diff --git a/astrbot/core/tools/computer_tools/edit_engine.py b/astrbot/core/tools/computer_tools/edit_engine.py
new file mode 100644
index 0000000000..24c222d8fa
--- /dev/null
+++ b/astrbot/core/tools/computer_tools/edit_engine.py
@@ -0,0 +1,815 @@
+"""
+Robust file editing engine for AstrBot, inspired by opencode's multi-strategy replacer chain.
+
+Implements 9 fallback replacers to handle LLM-generated edits that may have:
+- indentation drift
+- whitespace normalization issues
+- escape sequence mismatches (\\n vs actual newline)
+- trailing/leading whitespace differences
+- block-level fuzzy matching via Levenshtein similarity
+
+"""
+
+from __future__ import annotations
+
+import asyncio
+import difflib
+import os
+import weakref
+from collections.abc import Callable, Iterator
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Literal
+
+Replacer = Callable[[str, str], Iterator[str]]
+
+# File-level locks to prevent concurrent edits on the same file.
+# Use WeakValueDictionary so locks for deleted files can be garbage-collected.
+_locks: weakref.WeakValueDictionary[str, asyncio.Lock] = weakref.WeakValueDictionary()
+
+
+def get_file_lock(path: str) -> asyncio.Lock:
+    """Get or create an asyncio.Lock for the given file path."""
+    resolved = str(Path(path).resolve())
+    lock = _locks.get(resolved)
+    if lock is None:
+        lock = asyncio.Lock()
+        _locks[resolved] = lock
+    return lock
+
+
+# ---------------------------------------------------------------------------
+# Line-ending / BOM helpers (mirrors opencode src/tool/edit.ts)
+# ---------------------------------------------------------------------------
+
+
+def _normalize_line_endings(text: str) -> str:
+    """
+    Normalize actual CRLF line endings to LF.
+
+    ONLY handles real carriage-return + newline sequences (\\r\\n bytes).
+    Does NOT interpret escape sequences — literal \\n in file content
+    (e.g. Python string literals) must be preserved as-is.
+
+    Escape sequence handling for search strings is done by the
+    _escape_normalized_replacer in the replacer chain.
+    """
+    return text.replace("\r\n", "\n")
+
+
+def _detect_line_ending(text: str) -> Literal["\n", "\r\n"]:
+    return "\r\n" if "\r\n" in text else "\n"
+
+
+def _convert_to_line_ending(text: str, ending: Literal["\n", "\r\n"]) -> str:
+    if ending == "\n":
+        return text
+    # Convert standalone \n to \r\n, but avoid converting existing \r\n to \r\r\n
+    # by first normalizing any existing \r\n to \n, then converting all \n to \r\n
+    text = text.replace("\r\n", "\n")
+    return text.replace("\n", "\r\n")
+
+
+# ---------------------------------------------------------------------------
+# Levenshtein distance (for BlockAnchorReplacer)
+# ---------------------------------------------------------------------------
+
+
+def _levenshtein(a: str, b: str) -> int:
+    if a == "" or b == "":
+        return max(len(a), len(b))
+    # Use a single row DP to reduce memory
+    prev = list(range(len(b) + 1))
+    for i in range(1, len(a) + 1):
+        curr = [i]
+        ai = a[i - 1]
+        for j in range(1, len(b) + 1):
+            cost = 0 if ai == b[j - 1] else 1
+            curr.append(min(curr[-1] + 1, prev[j] + 1, prev[j - 1] + cost))
+        prev = curr
+    return prev[len(b)]
+
+
+# ---------------------------------------------------------------------------
+# Escape helpers
+# ---------------------------------------------------------------------------
+
+
+def _unescape(s: str) -> str:
+    """
+    Unescape common escape sequences in a string.
+
+    Handles: \\n, \\t, \\r, \\b, \\f, \\v, \\\\, \\", \\', \\`, \\$
+    Also handles \\xNN hex and \\uNNNN unicode escapes.
+    """
+    result = []
+    i = 0
+    while i < len(s):
+        if s[i] == "\\" and i + 1 < len(s):
+            nxt = s[i + 1]
+            if nxt == "n":
+                result.append("\n")
+            elif nxt == "t":
+                result.append("\t")
+            elif nxt == "r":
+                result.append("\r")
+            elif nxt == "b":
+                result.append("\b")
+            elif nxt == "f":
+                result.append("\f")
+            elif nxt == "v":
+                result.append("\v")
+            elif nxt == "x" and i + 3 < len(s):
+                # \xNN hex escape
+                try:
+                    val = int(s[i + 2 : i + 4], 16)
+                    result.append(chr(val))
+                    i += 4
+                    continue
+                except ValueError:
+                    result.append(s[i])
+                    result.append(nxt)
+            elif nxt == "u" and i + 5 < len(s):
+                # \uNNNN unicode escape
+                try:
+                    val = int(s[i + 2 : i + 6], 16)
+                    result.append(chr(val))
+                    i += 6
+                    continue
+                except ValueError:
+                    result.append(s[i])
+                    result.append(nxt)
+            elif nxt in ("'", '"', "`", "\\", "$"):
+                result.append(nxt)
+            else:
+                # Unknown escape: preserve both characters
+                result.append(s[i])
+                result.append(nxt)
+            i += 2
+        else:
+            result.append(s[i])
+            i += 1
+    return "".join(result)
+
+
+# ---------------------------------------------------------------------------
+# Replacer implementations
+# ---------------------------------------------------------------------------
+
+
+def _simple_replacer(content: str, find: str) -> Iterator[str]:
+    """Exact match."""
+    if not find:
+        return
+    yield find
+
+
+def _escape_normalized_replacer(content: str, find: str) -> Iterator[str]:
+    """
+    Handle escaped sequences like \\n, \\t in the find string.
+
+    This replacer tries two approaches:
+    1. Unescape the find string and look for it in content
+    2. If find contains literal backslash sequences, try matching content
+       blocks after unescaping them
+
+    Results are deduplicated to avoid yielding the same block twice.
+    """
+    if not find:
+        return
+
+    yielded = set()
+
+    # Approach 1: unescape find and search in content
+    unescaped_find = _unescape(find)
+    if unescaped_find != find and unescaped_find in content:
+        yielded.add(unescaped_find)
+        yield unescaped_find
+
+    # Approach 2: if find contains literal backslash sequences,
+    # try matching against content blocks after unescaping
+    if "\\" in find:
+        lines = content.split("\n")
+        find_lines = unescaped_find.split("\n")
+        for i in range(len(lines) - len(find_lines) + 1):
+            block = "\n".join(lines[i : i + len(find_lines)])
+            if block not in yielded and _unescape(block) == unescaped_find:
+                yielded.add(block)
+                yield block
+
+
+def _line_trimmed_replacer(content: str, find: str) -> Iterator[str]:
+    """Match blocks where each line matches after trim."""
+    if not find:
+        return
+    original_lines = content.split("\n")
+    search_lines = find.split("\n")
+    if search_lines and search_lines[-1] == "":
+        search_lines.pop()
+    if not search_lines:
+        return
+    for i in range(len(original_lines) - len(search_lines) + 1):
+        if all(
+            original_lines[i + j].strip() == search_lines[j].strip()
+            for j in range(len(search_lines))
+        ):
+            yield "\n".join(original_lines[i : i + len(search_lines)])
+
+
+def _block_anchor_replacer(content: str, find: str) -> Iterator[str]:
+    """
+    Use first and last line as anchors, then use Levenshtein similarity on middle lines.
+    Single candidate threshold: 0.0 (accept if anchors match)
+    Multiple candidates threshold: 0.3 (pick best)
+    """
+    if not find:
+        return
+    original_lines = content.split("\n")
+    search_lines = find.split("\n")
+    if len(search_lines) < 3:
+        return
+    if search_lines and search_lines[-1] == "":
+        search_lines.pop()
+    if len(search_lines) < 3:
+        return
+
+    first_anchor = search_lines[0].strip()
+    last_anchor = search_lines[-1].strip()
+    search_block_size = len(search_lines)
+
+    candidates: list[tuple[int, int]] = []
+    # Limit the search window for the last anchor to avoid matching unrelated lines far away
+    max_window = max(search_block_size * 2, search_block_size + 10)
+    for i, line in enumerate(original_lines):
+        if line.strip() != first_anchor:
+            continue
+        for j in range(i + 2, min(len(original_lines), i + max_window)):
+            if original_lines[j].strip() == last_anchor:
+                candidates.append((i, j))
+    if not candidates:
+        return
+
+    def _similarity(start: int, end: int) -> float:
+        actual_size = end - start + 1
+        lines_to_check = min(search_block_size - 2, actual_size - 2)
+        if lines_to_check <= 0:
+            return 1.0
+        sim = 0.0
+        for k in range(1, lines_to_check + 1):
+            if start + k >= len(original_lines) or k >= len(search_lines) - 1:
+                break
+            ol = original_lines[start + k].strip()
+            sl = search_lines[k].strip()
+            max_len = max(len(ol), len(sl))
+            if max_len == 0:
+                continue
+            dist = _levenshtein(ol, sl)
+            sim += (1 - dist / max_len) / lines_to_check
+        return sim
+
+    if len(candidates) == 1:
+        start, end = candidates[0]
+        if _similarity(start, end) >= 0.0:
+            yield "\n".join(original_lines[start : end + 1])
+        return
+
+    best_match: tuple[int, int] | None = None
+    max_sim = -1.0
+    for start, end in candidates:
+        sim = _similarity(start, end)
+        if sim > max_sim:
+            max_sim = sim
+            best_match = (start, end)
+
+    if max_sim >= 0.3 and best_match:
+        start, end = best_match
+        yield "\n".join(original_lines[start : end + 1])
+
+
+def _whitespace_normalized_replacer(content: str, find: str) -> Iterator[str]:
+    """Collapse all whitespace sequences to a single space before matching."""
+    if not find:
+        return
+
+    def _norm(t: str) -> str:
+        return " ".join(t.split())
+
+    normalized_find = _norm(find)
+    if not normalized_find:
+        return
+
+    # Single-line matches
+    for line in content.split("\n"):
+        if _norm(line) == normalized_find:
+            yield line
+
+    # Multi-line block matches
+    lines = content.split("\n")
+    find_lines = find.split("\n")
+    if len(find_lines) > 1:
+        for i in range(len(lines) - len(find_lines) + 1):
+            block = "\n".join(lines[i : i + len(find_lines)])
+            if _norm(block) == normalized_find:
+                yield block
+
+
+def _indentation_flexible_replacer(content: str, find: str) -> Iterator[str]:
+    """
+    Match blocks where removing common indentation makes them equal to find.
+
+    Important: yields the ORIGINAL block (with original indentation),
+    not the de-indented version. This preserves the file's indentation
+    during replacement.
+    """
+    if not find:
+        return
+
+    def _remove_indent(text: str) -> str:
+        lines = text.split("\n")
+        non_empty = [ln for ln in lines if ln.strip()]
+        if not non_empty:
+            return text
+        min_indent = min(len(ln) - len(ln.lstrip()) for ln in non_empty if ln.strip())
+        return "\n".join(ln[min_indent:] if ln.strip() else ln for ln in lines)
+
+    normalized_find = _remove_indent(find)
+    content_lines = content.split("\n")
+    find_lines = find.split("\n")
+    for i in range(len(content_lines) - len(find_lines) + 1):
+        block = "\n".join(content_lines[i : i + len(find_lines)])
+        if _remove_indent(block) == normalized_find:
+            yield block
+
+
+def _trimmed_boundary_replacer(content: str, find: str) -> Iterator[str]:
+    """Match if the trimmed version of find exists in content."""
+    if not find:
+        return
+    trimmed = find.strip()
+    if trimmed == find:
+        return
+    if trimmed in content:
+        yield trimmed
+
+    lines = content.split("\n")
+    find_lines = find.split("\n")
+    for i in range(len(lines) - len(find_lines) + 1):
+        block = "\n".join(lines[i : i + len(find_lines)])
+        if block.strip() == trimmed:
+            yield block
+
+
+def _context_aware_replacer(content: str, find: str) -> Iterator[str]:
+    """
+    Use first and last line as context anchors, accept if >= 50% of middle lines match.
+    """
+    if not find:
+        return
+    find_lines = find.split("\n")
+    if len(find_lines) < 3:
+        return
+    if find_lines and find_lines[-1] == "":
+        find_lines.pop()
+    if len(find_lines) < 3:
+        return
+
+    first_line = find_lines[0].strip()
+    last_line = find_lines[-1].strip()
+    content_lines = content.split("\n")
+
+    for i, line in enumerate(content_lines):
+        if line.strip() != first_line:
+            continue
+        for j in range(i + 2, len(content_lines)):
+            if content_lines[j].strip() != last_line:
+                continue
+            block_lines = content_lines[i : j + 1]
+            if len(block_lines) != len(find_lines):
+                continue
+            matching = 0
+            total_nonempty = 0
+            for k in range(1, len(block_lines) - 1):
+                bl = block_lines[k].strip()
+                fl = find_lines[k].strip()
+                if bl or fl:
+                    total_nonempty += 1
+                    if bl == fl:
+                        matching += 1
+            if total_nonempty == 0 or matching / total_nonempty >= 0.5:
+                yield "\n".join(block_lines)
+                return  # Only first match
+            break
+
+
+def _multi_occurrence_replacer(content: str, find: str) -> Iterator[str]:
+    """Yield all exact matches (used with replace_all)."""
+    if not find:
+        return
+    start = 0
+    while True:
+        idx = content.find(find, start)
+        if idx == -1:
+            break
+        yield find
+        start = idx + len(find)
+
+
+# Ordered chain: most specific first, most lenient last.
+# Escape-normalized is placed early because it handles a common LLM issue
+# (using \\n instead of actual newlines) before more aggressive fuzzy matchers.
+_REPLACERS: list[Replacer] = [
+    _simple_replacer,
+    _escape_normalized_replacer,
+    _line_trimmed_replacer,
+    _block_anchor_replacer,
+    _whitespace_normalized_replacer,
+    _indentation_flexible_replacer,
+    _trimmed_boundary_replacer,
+    _context_aware_replacer,
+    _multi_occurrence_replacer,
+]
+
+
+# ---------------------------------------------------------------------------
+# Indent adjustment helper
+# ---------------------------------------------------------------------------
+
+
+def _get_leading_whitespace(line: str) -> str:
+    """Return the leading whitespace of a line."""
+    return line[: len(line) - len(line.lstrip())]
+
+
+def _first_nonempty_line_indent(text: str) -> str:
+    """Get the leading whitespace of the first non-empty line in text."""
+    for line in text.split("\n"):
+        if line.strip():
+            return _get_leading_whitespace(line)
+    return ""
+
+
+def _adjust_replacement_indent(
+    new_string: str,
+    old_string: str,
+    matched_block: str,
+    content: str = "",
+    match_idx: int = -1,
+) -> str:
+    """
+    Adjust new_string's indentation to preserve the file's indent level.
+
+    When a fuzzy replacer (e.g. LineTrimmedReplacer, IndentationFlexibleReplacer)
+    matches a block whose indentation differs from old_string, this function
+    computes the indent delta and applies it to every non-empty line of
+    new_string so the replacement preserves the file's original indentation.
+
+    When *content* and *match_idx* are provided, the effective indent is
+    computed from the actual line in the file rather than from matched_block
+    alone. This correctly handles substring matches (e.g. SimpleReplacer
+    matching ``"print(x)"`` inside ``"                print(x)"``).
+
+    Indent adjustment rules:
+    - If the match starts at the beginning of a line (match_idx == line_start),
+      all lines of new_string get the indent delta applied.
+    - If the match starts after a whitespace-only prefix (at the content
+      boundary of an indented line), the first line is NOT adjusted —
+      the content prefix already provides the indent. Lines 2+ get adjusted.
+    - If the match starts mid-line (after non-whitespace content), NO lines
+      are adjusted — the user wrote absolute indentation and the first line
+      inherits the prefix context.
+
+    For exact matches (old_string == matched_block and both span the full
+    line), delta is zero and this is a no-op.
+    """
+    old_indent = _first_nonempty_line_indent(old_string)
+
+    # Compute effective file indent from the actual line context when available.
+    # This handles substring matches where matched_block doesn't include
+    # the line's leading whitespace.
+    match_starts_at_line_beginning = True
+    adjust_subsequent_lines = True
+    if content and match_idx >= 0:
+        line_start = content.rfind("\n", 0, match_idx) + 1
+        effective_line = content[line_start:]
+        file_indent = _get_leading_whitespace(effective_line)
+        if match_idx == line_start:
+            # Match starts at the very beginning of the line
+            match_starts_at_line_beginning = True
+            adjust_subsequent_lines = True
+        else:
+            prefix = content[line_start:match_idx]
+            match_starts_at_line_beginning = False
+            if prefix.strip() == "":
+                # Match starts after whitespace-only prefix (content boundary)
+                # First line inherits prefix; subsequent lines get adjusted
+                adjust_subsequent_lines = True
+            else:
+                # Match starts after non-whitespace (truly mid-line)
+                # User wrote absolute indentation; no adjustment needed
+                adjust_subsequent_lines = False
+    else:
+        file_indent = _first_nonempty_line_indent(matched_block)
+
+    if file_indent == old_indent:
+        return new_string
+
+    # Determine indent character from the file's indentation
+    indent_char = " "
+    if file_indent:
+        indent_char = file_indent[0]
+    elif old_indent:
+        indent_char = old_indent[0]
+
+    delta = len(file_indent) - len(old_indent)
+
+    new_lines = new_string.split("\n")
+    adjusted: list[str] = []
+    for i, line in enumerate(new_lines):
+        if not line.strip():
+            # Empty or whitespace-only line: keep as-is
+            adjusted.append(line)
+        elif i == 0 and not match_starts_at_line_beginning:
+            # First line and match is not at line start: don't adjust.
+            # The content prefix already provides the indent context.
+            adjusted.append(line)
+        elif i > 0 and not adjust_subsequent_lines:
+            # Subsequent lines in a truly mid-line match: don't adjust.
+            # User wrote absolute indentation.
+            adjusted.append(line)
+        elif delta > 0:
+            # Need to add indentation to match file's deeper indent level
+            adjusted.append(indent_char * delta + line)
+        elif delta < 0:
+            # Need to remove indentation (file is less indented than old_string)
+            current_indent = _get_leading_whitespace(line)
+            remove = min(-delta, len(current_indent))
+            adjusted.append(line[remove:])
+        else:
+            adjusted.append(line)
+
+    return "\n".join(adjusted)
+
+
+# ---------------------------------------------------------------------------
+# Core replace function
+# ---------------------------------------------------------------------------
+
+
+def robust_replace(
+    content: str,
+    old_string: str,
+    new_string: str,
+    *,
+    replace_all: bool = False,
+) -> tuple[str, int]:
+    """
+    Replace old_string with new_string using the multi-strategy replacer chain.
+
+    Returns:
+        A tuple of (new_content, replacements_count).
+
+    Raises:
+        ValueError: If old_string cannot be found, or if multiple non-unique
+                    matches are found (when replace_all=False).
+    """
+    if old_string == new_string:
+        raise ValueError(
+            "No changes to apply: old_string and new_string are identical."
+        )
+
+    not_found = True
+
+    for replacer in _REPLACERS:
+        matches = list(replacer(content, old_string))
+        if not matches:
+            continue
+
+        # Collect all unique match positions
+        match_positions: list[tuple[int, str]] = []
+        for match in matches:
+            start = 0
+            while True:
+                idx = content.find(match, start)
+                if idx == -1:
+                    break
+                # Avoid duplicate positions from overlapping matches
+                if not any(pos <= idx < pos + len(m) for pos, m in match_positions):
+                    match_positions.append((idx, match))
+                start = idx + 1
+
+        if not match_positions:
+            continue
+
+        not_found = False
+
+        if replace_all:
+            # Replace all occurrences, from end to start to preserve indices
+            new_content = content
+            replacements = 0
+            for idx, match in sorted(match_positions, key=lambda x: x[0], reverse=True):
+                adjusted_new = _adjust_replacement_indent(
+                    new_string,
+                    old_string,
+                    match,
+                    content,
+                    idx,
+                )
+                new_content = (
+                    new_content[:idx] + adjusted_new + new_content[idx + len(match) :]
+                )
+                replacements += 1
+            return new_content, replacements
+
+        # Single replacement mode: require exactly one match
+        if len(match_positions) == 1:
+            idx, match = match_positions[0]
+            adjusted_new = _adjust_replacement_indent(
+                new_string,
+                old_string,
+                match,
+                content,
+                idx,
+            )
+            return content[:idx] + adjusted_new + content[idx + len(match) :], 1
+
+        # Multiple matches found in single-replacement mode: continue to next replacer
+        # to try a more specific strategy
+        continue
+
+    if not_found:
+        raise ValueError(
+            "Could not find oldString in the file. It must match exactly, "
+            "including whitespace, indentation, and line endings. "
+            "Try providing more surrounding context to make the match unique."
+        )
+    raise ValueError(
+        "Found multiple matches for oldString. Provide more surrounding context "
+        "to make the match unique, or use replace_all=True to change every instance."
+    )
+
+
+# ---------------------------------------------------------------------------
+# Edit result model
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class EditResult:
+    success: bool
+    replacements: int = 0
+    diff: str = ""
+    error: str = ""
+    old_content: str = ""
+    new_content: str = ""
+
+
+# ---------------------------------------------------------------------------
+# Async file edit with locking and line-ending preservation (local runtime)
+# ---------------------------------------------------------------------------
+
+
+def bytes_edit_file(
+    raw_bytes: bytes,
+    old_string: str,
+    new_string: str,
+    *,
+    replace_all: bool = False,
+    encoding: str = "utf-8",
+) -> tuple[bytes, EditResult]:
+    """
+    Core line-ending-aware edit logic operating on raw bytes.
+
+    Performs:
+    1. BOM detection and preservation
+    2. Line-ending detection (CRLF vs LF)
+    3. Normalize to LF for matching (replacer chain works on LF)
+    4. Execute robust_replace()
+    5. Convert back to original line endings
+    6. Re-attach BOM if present
+
+    Returns:
+        (output_bytes, EditResult) — the caller is responsible for writing
+        *output_bytes* back to the file.
+
+    Raises:
+        ValueError: If old_string cannot be found or is not unique.
+    """
+    has_bom = raw_bytes.startswith(b"\xef\xbb\xbf")
+    if has_bom:
+        raw_bytes = raw_bytes[3:]
+
+    old_content = raw_bytes.decode(encoding)
+    original_ending = _detect_line_ending(old_content)
+
+    # Normalize for matching: ONLY normalize actual CRLF line endings.
+    # Escape sequence handling (\n vs actual newline, \t vs tab, etc.)
+    # is deferred to the _escape_normalized_replacer in the replacer chain.
+    normalized_old = _normalize_line_endings(old_string)
+    normalized_new = _normalize_line_endings(new_string)
+
+    # Normalize file content to LF for matching (replacers work on LF)
+    normalized_content = _normalize_line_endings(old_content)
+
+    # Perform replacement
+    new_content, replacements = robust_replace(
+        normalized_content,
+        normalized_old,
+        normalized_new,
+        replace_all=replace_all,
+    )
+
+    # Convert back to original line endings
+    if original_ending == "\r\n":
+        new_content = _convert_to_line_ending(new_content, "\r\n")
+
+    # Re-add BOM if present
+    write_bytes = b""
+    if has_bom:
+        write_bytes += b"\xef\xbb\xbf"
+    write_bytes += new_content.encode(encoding)
+
+    # Generate unified diff
+    diff = build_unified_diff("", old_content, new_content)
+
+    result = EditResult(
+        success=True,
+        replacements=replacements,
+        diff=diff,
+        old_content=old_content,
+        new_content=new_content,
+    )
+    return write_bytes, result
+
+
+async def edit_file(
+    path: str,
+    old_string: str,
+    new_string: str,
+    *,
+    replace_all: bool = False,
+    encoding: str = "utf-8",
+) -> EditResult:
+    """
+    Edit a file using the robust multi-strategy replacer.
+
+    Features:
+    - File-level asyncio lock prevents concurrent edits
+    - Preserves original line endings (\\n vs \\r\\n)
+    - Preserves BOM if present
+    - Returns unified diff of changes
+    """
+    lock = get_file_lock(path)
+    async with lock:
+        try:
+            # Read file in binary mode to preserve original line endings
+            raw_bytes = await asyncio.to_thread(_read_file_bytes, path)
+            write_bytes, result = bytes_edit_file(
+                raw_bytes,
+                old_string,
+                new_string,
+                replace_all=replace_all,
+                encoding=encoding,
+            )
+            # Write file in binary mode to preserve restored line endings
+            await asyncio.to_thread(_write_file_bytes, path, write_bytes)
+            return result
+        except Exception as exc:
+            return EditResult(
+                success=False,
+                error=str(exc),
+            )
+
+
+def _read_file_bytes(path: str) -> bytes:
+    with open(path, "rb") as f:
+        return f.read()
+
+
+def _write_file_bytes(path: str, data: bytes) -> None:
+    # Ensure parent directory exists
+    os.makedirs(os.path.dirname(path) or ".", exist_ok=True)
+    with open(path, "wb") as f:
+        f.write(data)
+
+
+# ---------------------------------------------------------------------------
+# Public diff helper
+# ---------------------------------------------------------------------------
+
+
+def build_unified_diff(
+    old_path: str,
+    old_content: str,
+    new_content: str,
+) -> str:
+    """Generate a unified diff between two content strings."""
+    diff = list(
+        difflib.unified_diff(
+            old_content.splitlines(),
+            new_content.splitlines(),
+            fromfile=old_path,
+            tofile=old_path,
+            lineterm="",
+        )
+    )
+    return "\n".join(diff)
diff --git a/astrbot/core/tools/computer_tools/fs.py b/astrbot/core/tools/computer_tools/fs.py
index 5660022fd0..6b4a9b8709 100644
--- a/astrbot/core/tools/computer_tools/fs.py
+++ b/astrbot/core/tools/computer_tools/fs.py
@@ -33,6 +33,7 @@
 - In sandbox runtime, relative paths are passed through unchanged.
 """
 
+import base64
 import os
 import uuid
 from dataclasses import dataclass, field
@@ -55,6 +56,12 @@
 
 from ..registry import builtin_tool
 from . import util as computer_util
+from .edit_engine import (
+    EditResult,
+    bytes_edit_file,
+    edit_file,
+    get_file_lock,
+)
 from .util import (
     check_admin_permission,
     is_local_runtime,
@@ -368,22 +375,150 @@ async def call(
             return f"Error writing file: {exc}"
 
 
+async def _sandbox_read_bytes(sb, path: str) -> bytes:
+    """Read a file in binary mode inside the sandbox via sb.python.exec.
+
+    Returns the raw bytes so that original line endings (CRLF/LF) are preserved.
+    Raises IOError on read failure.
+    """
+    code = (
+        "import base64 as _b64, sys\n"
+        f"path = {path!r}\n"
+        "try:\n"
+        "    with open(path, 'rb') as _f:\n"
+        "        _data = _f.read()\n"
+        "    print(_b64.b64encode(_data).decode(), end='')\n"
+        "except Exception as _e:\n"
+        "    print('ERROR:' + str(_e), end='', file=sys.stderr)\n"
+        "    sys.exit(1)\n"
+    )
+    result = await sb.python.exec(code, timeout=30)
+    if not result.get("success", False):
+        error = str(result.get("error", "") or "").strip()
+        if not error:
+            output = result.get("output", "")
+            if isinstance(output, dict):
+                error = str(output.get("error", "") or "").strip()
+        raise OSError(
+            f"Failed to read file in sandbox: {error or 'unknown read error'}"
+        )
+    output = result.get("output", "")
+    if isinstance(output, dict):
+        output = output.get("text", "")
+    b64_text = str(output).strip()
+    return base64.b64decode(b64_text)
+
+
+async def _sandbox_write_bytes(sb, path: str, data: bytes) -> None:
+    """Write raw bytes to a file inside the sandbox via sb.python.exec.
+
+    Raises IOError on write failure.
+    """
+    b64_data = base64.b64encode(data).decode()
+    code = (
+        "import base64 as _b64, sys\n"
+        f"path = {path!r}\n"
+        f"b64 = {b64_data!r}\n"
+        "try:\n"
+        "    _raw = _b64.b64decode(b64)\n"
+        "    with open(path, 'wb') as _f:\n"
+        "        _f.write(_raw)\n"
+        "    print('ok', end='')\n"
+        "except Exception as _e:\n"
+        "    print('ERROR:' + str(_e), end='', file=sys.stderr)\n"
+        "    sys.exit(1)\n"
+    )
+    result = await sb.python.exec(code, timeout=30)
+    if not result.get("success", False):
+        error = str(result.get("error", "") or "").strip()
+        if not error:
+            output = result.get("output", "")
+            if isinstance(output, dict):
+                error = str(output.get("error", "") or "").strip()
+        raise OSError(
+            f"Failed to write file in sandbox: {error or 'unknown write error'}"
+        )
+
+
+def _format_result(
+    path: str,
+    result: EditResult,
+    *,
+    replace_all: bool,
+) -> str:
+    """Build the human-readable / LLM-readable result string with optional diff."""
+    if not result.success:
+        return f"Error editing file: {result.error}"
+
+    mode_text = "all matches" if replace_all else "first match"
+
+    lines = [
+        f"Edited {path}.",
+        f"Replaced {result.replacements} occurrence(s) using {mode_text} mode.",
+    ]
+
+    if result.diff:
+        diff_preview = result.diff
+        if len(diff_preview) > 2000:
+            diff_preview = diff_preview[:2000] + "\n... (diff truncated)"
+        lines.append("")
+        lines.append("Diff:")
+        lines.append("```diff")
+        lines.append(diff_preview)
+        lines.append("```")
+
+    return "\n".join(lines)
+
+
 @builtin_tool(config=_COMPUTER_RUNTIME_TOOL_CONFIG)
 @dataclass
 class FileEditTool(FunctionTool):
+    """
+    Enhanced file editing tool with robust fuzzy matching.
+
+    In local runtime it uses the full robust edit engine (BOM +
+    line-ending preservation, file locks); in sandbox runtimes it
+    mediates reads and writes through the booter's filesystem
+    abstraction while applying the same 9-strategy replacer chain.
+
+    This tool is designed to handle LLM-generated edits that may
+    have minor whitespace, indentation, or escape sequence
+    differences from the actual file content.
+    """
+
     name: str = "astrbot_file_edit_tool"
-    description: str = "Editing files."
+    description: str = (
+        "Editing files with robust fuzzy matching. "
+        "Supports exact match, escape-normalized match, line-trimmed match, block-anchor match, "
+        "whitespace-normalized match, indentation-flexible match, "
+        "trimmed-boundary match, context-aware match, "
+        "and multi-occurrence replacement. "
+        "When editing text from Read tool output, preserve the exact indentation "
+        "(tabs/spaces) as it appears AFTER the line number prefix. "
+        "The line number prefix format is: line number + colon + space (e.g., '1: '). "
+        "Everything after that space is the actual file content to match. "
+        "Never include any part of the line number prefix in oldString or newString. "
+        "The edit will FAIL if oldString is not found. "
+        "The edit will FAIL if oldString is found multiple times and replace_all is false. "
+        "Use replace_all for renaming variables or strings across the file."
+    )
     parameters: dict = field(
         default_factory=lambda: {
             "type": "object",
             "properties": {
                 "path": {
                     "type": "string",
-                    "description": "Path of the file to edit. If relative, will be in workspace root.",
+                    "description": (
+                        "Path of the file to edit. If relative, will be in workspace root."
+                    ),
                 },
                 "old": {
                     "type": "string",
-                    "description": "The exact old text to replace.",
+                    "description": (
+                        "The text to replace. Must be an exact substring of the file content, "
+                        "but the tool will try multiple matching strategies if exact match fails. "
+                        "Include sufficient surrounding context (3-5 lines) to make the match unique."
+                    ),
                 },
                 "new": {
                     "type": "string",
@@ -391,7 +526,10 @@ class FileEditTool(FunctionTool):
                 },
                 "replace_all": {
                     "type": "boolean",
-                    "description": "Whether to replace all matches. Defaults to false.",
+                    "description": (
+                        "Whether to replace all matches. Defaults to false. "
+                        "Useful for renaming variables or strings across the file."
+                    ),
                 },
             },
             "required": ["path", "old", "new"],
@@ -409,45 +547,67 @@ async def call(
         umo = str(context.context.event.unified_msg_origin)
         local_env = is_local_runtime(context)
         restricted = _is_restricted_env(context)
+
         try:
-            normalized_path = (
-                _normalize_rw_path(
+            if local_env:
+                normalized_path = _normalize_rw_path(
                     path,
                     restricted=restricted,
                     local_env=local_env,
                     umo=umo,
                     write=True,
                 )
-                if local_env
-                else path.strip()
-            )
+            else:
+                normalized_path = path.strip()
+
             if not normalized_path:
                 raise ValueError("`path` must be a non-empty string.")
-            normalized_old = _decode_escaped_text(old)
-            normalized_new = _decode_escaped_text(new)
-            sb = await get_booter(
-                context.context.context,
-                context.context.event.unified_msg_origin,
-            )
-            result = await sb.fs.edit_file(
-                path=normalized_path,
-                old_string=normalized_old,
-                new_string=normalized_new,
-                replace_all=replace_all,
-                encoding="utf-8",
-            )
-            if not result.get("success", False):
-                error_detail = str(result.get("error", "") or "").strip()
-                return (
-                    "Error editing file: "
-                    f"{error_detail or 'unknown filesystem edit error'}"
+
+            if local_env:
+                result = await edit_file(
+                    path=normalized_path,
+                    old_string=old,
+                    new_string=new,
+                    replace_all=replace_all,
+                    encoding="utf-8",
+                )
+            else:
+                sb = await get_booter(
+                    context.context.context,
+                    umo,
                 )
-            replacements = int(result.get("replacements", 0) or 0)
-            mode_text = "all matches" if replace_all else "first match"
-            return (
-                f"Edited {normalized_path}. "
-                f"Replaced {replacements} occurrence(s) using {mode_text} mode."
+                lock = get_file_lock(normalized_path)
+                async with lock:
+                    # 1. Binary read — preserves original line endings (CRLF/LF)
+                    try:
+                        raw_bytes = await _sandbox_read_bytes(sb, normalized_path)
+                    except OSError as exc:
+                        return f"Error editing file: {exc}"
+
+                    # 2. Line-ending-aware edit (reuses edit_engine core logic)
+                    try:
+                        write_bytes, result = bytes_edit_file(
+                            raw_bytes,
+                            old,
+                            new,
+                            replace_all=replace_all,
+                            encoding="utf-8",
+                        )
+                    except ValueError as exc:
+                        return f"Error editing file: {exc}"
+
+                    # 3. Binary write — preserves restored line endings
+                    try:
+                        await _sandbox_write_bytes(sb, normalized_path, write_bytes)
+                    except OSError as exc:
+                        return f"Error editing file: {exc}"
+
+            return _format_result(
+                normalized_path,
+                result,
+                replace_all=replace_all,
             )
+
         except PermissionError as exc:
             return f"Error: {exc}"
         except Exception as exc:
diff --git a/dashboard/src/components/chat/ReasoningSidebar.vue b/dashboard/src/components/chat/ReasoningSidebar.vue
index a20a4bb896..e2d0d1f240 100644
--- a/dashboard/src/components/chat/ReasoningSidebar.vue
+++ b/dashboard/src/components/chat/ReasoningSidebar.vue
@@ -1,6 +1,17 @@
 <template>
   <transition name="slide-left">
-    <aside v-if="modelValue" class="reasoning-sidebar">
+    <aside
+      v-if="modelValue"
+      ref="sidebarRef"
+      class="reasoning-sidebar"
+      :style="{ width: sidebarWidth + 'px' }"
+    >
+      <!-- Drag handle -->
+      <div
+        class="reasoning-sidebar-resizer"
+        @mousedown="startResize"
+      />
+
       <div class="reasoning-sidebar-header">
         <div class="reasoning-sidebar-title">{{ reasoningTitle }}</div>
         <v-btn icon="mdi-close" size="small" variant="text" @click="close" />
@@ -22,7 +33,7 @@
 </template>
 
 <script setup lang="ts">
-import { computed } from "vue";
+import { onBeforeUnmount, ref, computed } from "vue";
 import {
   reasoningActivityCounts,
   reasoningActivityTitle,
@@ -55,6 +66,49 @@ const reasoningTitle = computed(() =>
 function close() {
   emit("update:modelValue", false);
 }
+
+// ── Drag resize ────────────────────────────────────────────────────
+
+const MIN_WIDTH = 280;
+const MAX_WIDTH = 1200;
+const DEFAULT_WIDTH = 380;
+
+const sidebarWidth = ref(DEFAULT_WIDTH);
+const sidebarRef = ref<HTMLElement | null>(null);
+let isResizing = false;
+
+function startResize(e: MouseEvent) {
+  e.preventDefault();
+  isResizing = true;
+  document.body.style.cursor = "ew-resize";
+  document.body.style.userSelect = "none";
+  document.addEventListener("mousemove", onMouseMove);
+  document.addEventListener("mouseup", onMouseUp);
+}
+
+function onMouseMove(e: MouseEvent) {
+  if (!isResizing || !sidebarRef.value) return;
+  // The sidebar is on the right side of the viewport.
+  // `sidebarRef` is positioned inside the parent's flex layout.
+  // Calculate width from the right edge of the viewport:
+  const rect = sidebarRef.value.parentElement?.getBoundingClientRect();
+  if (!rect) return;
+  const newWidth = rect.right - e.clientX;
+  sidebarWidth.value = Math.min(MAX_WIDTH, Math.max(MIN_WIDTH, newWidth));
+}
+
+function onMouseUp() {
+  if (!isResizing) return;
+  isResizing = false;
+  document.body.style.cursor = "";
+  document.body.style.userSelect = "";
+  document.removeEventListener("mousemove", onMouseMove);
+  document.removeEventListener("mouseup", onMouseUp);
+}
+
+onBeforeUnmount(() => {
+  onMouseUp();
+});
 </script>
 
 <style scoped>
@@ -67,8 +121,29 @@ function close() {
   display: flex;
   flex-direction: column;
   flex-shrink: 0;
+  position: relative;
 }
 
+/* ── Drag handle ──────────────────────────────────────────────── */
+
+.reasoning-sidebar-resizer {
+  position: absolute;
+  left: 0;
+  top: 0;
+  bottom: 0;
+  width: 6px;
+  cursor: ew-resize;
+  z-index: 10;
+  transition: background 0.15s ease;
+}
+
+.reasoning-sidebar-resizer:hover,
+.reasoning-sidebar-resizer:active {
+  background: rgba(var(--v-theme-primary), 0.2);
+}
+
+/* ── Transition ───────────────────────────────────────────────── */
+
 .slide-left-enter-active,
 .slide-left-leave-active {
   transition: all 0.2s ease;
@@ -80,6 +155,8 @@ function close() {
   opacity: 0;
 }
 
+/* ── Header ───────────────────────────────────────────────────── */
+
 .reasoning-sidebar-header {
   display: flex;
   align-items: center;
@@ -94,6 +171,8 @@ function close() {
   color: rgb(var(--v-theme-on-surface));
 }
 
+/* ── Body ─────────────────────────────────────────────────────── */
+
 .reasoning-sidebar-body {
   flex: 1;
   min-height: 0;
@@ -109,16 +188,22 @@ function close() {
   font-size: 13px;
 }
 
+/* ── Mobile ───────────────────────────────────────────────────── */
+
 @media (max-width: 760px) {
   .reasoning-sidebar {
     position: fixed;
     inset: 0;
     z-index: 1300;
-    width: 100vw;
+    width: 100vw !important;
     height: 100dvh;
     border-left: 0;
   }
 
+  .reasoning-sidebar-resizer {
+    display: none;
+  }
+
   .reasoning-sidebar-header {
     min-height: 52px;
     padding: calc(10px + env(safe-area-inset-top)) 12px 8px;
diff --git a/dashboard/src/components/chat/message_list_comps/DiffPreview.vue b/dashboard/src/components/chat/message_list_comps/DiffPreview.vue
new file mode 100644
index 0000000000..e3465c3e0e
--- /dev/null
+++ b/dashboard/src/components/chat/message_list_comps/DiffPreview.vue
@@ -0,0 +1,538 @@
+<template>
+  <div
+    class="diff-preview"
+    :class="{ 'is-dark': isDark, collapsed: isCollapsed }"
+  >
+    <!-- Summary header — always visible, clickable to toggle -->
+    <button
+      v-if="summary || filePath || statsAdds || statsDels"
+      type="button"
+      class="diff-header"
+      @click="toggleCollapsed"
+    >
+      <div class="diff-header-left">
+        <v-icon size="16" class="diff-header-icon">mdi-file-document-edit-outline</v-icon>
+        <span v-if="filePath" class="diff-file-path">{{ filePath }}</span>
+      </div>
+      <div class="diff-header-right">
+        <template v-if="statsAdds || statsDels">
+          <span v-if="statsAdds" class="diff-stats diff-stats-add">+{{ statsAdds }}</span>
+          <span v-if="statsDels" class="diff-stats diff-stats-del">−{{ statsDels }}</span>
+        </template>
+        <v-icon
+          v-if="collapsible"
+          size="18"
+          class="diff-chevron"
+          :class="{ expanded: !isCollapsed }"
+        >
+          mdi-chevron-right
+        </v-icon>
+      </div>
+    </button>
+
+    <!-- Summary text (e.g. "Replaced 1 occurrence(s)...") -->
+    <div v-if="summary && !isCollapsed" class="diff-summary-text">
+      {{ summary }}
+    </div>
+
+    <!-- Diff hunks — hidden when collapsed -->
+    <div v-if="!isCollapsed" class="diff-body">
+      <div v-if="truncated" class="diff-truncation-warning">
+        ⚠ Diff truncated (showing first {{ maxChars.toLocaleString() }} characters)
+      </div>
+
+      <div
+        v-for="(hunk, hi) in parsedHunks"
+        :key="hi"
+        class="diff-hunk"
+      >
+        <div class="hunk-header">
+          {{ hunk.header }}
+        </div>
+        <div
+          v-for="(line, li) in hunk.lines"
+          :key="li"
+          class="diff-line"
+          :class="line.type"
+        >
+          <span class="line-number old">{{ line.oldNo }}</span>
+          <span class="line-number new">{{ line.newNo }}</span>
+          <span class="line-prefix">{{ line.prefix }}</span>
+          <span class="line-content">{{ line.content }}</span>
+        </div>
+      </div>
+
+      <div v-if="collapsedOverflow > 0" class="diff-overflow-bar">
+        <button type="button" class="diff-show-more" @click="showAllLines = true">
+          Show all {{ totalLines.toLocaleString() }} lines
+          ({{ collapsedOverflow }} more)
+        </button>
+      </div>
+    </div>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { computed, ref } from "vue";
+
+// ── Types ──────────────────────────────────────────────────────────
+
+interface DiffLine {
+  type: "add" | "del" | "ctx" | "header-file";
+  prefix: string;
+  content: string;
+  oldNo: string;
+  newNo: string;
+}
+
+interface DiffHunk {
+  header: string;
+  lines: DiffLine[];
+}
+
+// ── Props ──────────────────────────────────────────────────────────
+
+const props = withDefaults(
+  defineProps<{
+    content: string;
+    filePath?: string;
+    summary?: string;
+    maxLines?: number;
+    maxChars?: number;
+    collapsible?: boolean;
+    isDark?: boolean;
+  }>(),
+  {
+    filePath: "",
+    summary: "",
+    maxLines: 30,
+    maxChars: 2000,
+    collapsible: true,
+    isDark: false,
+  },
+);
+
+// ── State ──────────────────────────────────────────────────────────
+
+const isCollapsed = ref(false);
+const showAllLines = ref(false);
+const effectiveMaxLines = computed(() =>
+  showAllLines.value ? Infinity : props.maxLines,
+);
+
+const toggleCollapsed = () => {
+  if (props.collapsible) {
+    isCollapsed.value = !isCollapsed.value;
+  }
+};
+
+// ── Parse unified diff ─────────────────────────────────────────────
+
+const parsedHunks = computed<DiffHunk[]>(() => {
+  const text = extractDiffContent(props.content);
+  return parseUnifiedDiff(text, effectiveMaxLines.value);
+});
+
+const totalLines = computed(() =>
+  parsedHunks.value.reduce((sum, h) => sum + h.lines.length, 0),
+);
+
+const truncated = computed(() => {
+  const raw = extractDiffContent(props.content);
+  return raw.length > props.maxChars;
+});
+
+const collapsedOverflow = computed(() => {
+  if (showAllLines.value) return 0;
+  const fullHunks = parseUnifiedDiff(
+    extractDiffContent(props.content),
+    Infinity,
+  );
+  const fullTotal = fullHunks.reduce((sum, h) => sum + h.lines.length, 0);
+  return Math.max(0, fullTotal - totalLines.value);
+});
+
+// ── Stats ──────────────────────────────────────────────────────────
+
+const statsAdds = computed(() => {
+  let adds = 0;
+  for (const hunk of parsedHunks.value) {
+    for (const line of hunk.lines) {
+      if (line.type === "add") adds++;
+    }
+  }
+  return adds || null;
+});
+
+const statsDels = computed(() => {
+  let dels = 0;
+  for (const hunk of parsedHunks.value) {
+    for (const line of hunk.lines) {
+      if (line.type === "del") dels++;
+    }
+  }
+  return dels || null;
+});
+
+// ── Helpers ────────────────────────────────────────────────────────
+
+function extractDiffContent(raw: string): string {
+  // If the text contains a ```diff ... ``` block, extract its content
+  const blockMatch = raw.match(/```diff\s*\n?([\s\S]*?)```/);
+  if (blockMatch) return blockMatch[1];
+
+  // Otherwise, try to strip leading "Diff:" / "Edited ..." lines
+  const diffIdx = raw.indexOf("@@");
+  if (diffIdx >= 0) return raw.slice(diffIdx);
+
+  return raw;
+}
+
+function parseUnifiedDiff(text: string, maxLines: number): DiffHunk[] {
+  const lines = text.split("\n");
+  const hunks: DiffHunk[] = [];
+  let currentHunk: DiffHunk | null = null;
+  let totalLines = 0;
+  let oldNo = 0;
+  let newNo = 0;
+
+  // Try to parse --- / +++ file headers to get old/new line numbers
+  for (const rawLine of lines) {
+    if (totalLines >= maxLines) break;
+
+    const hunkMatch = rawLine.match(
+      /^@@\s+-(\d+)(?:,(\d+))?\s+\+(\d+)(?:,(\d+))?\s+@@(.*)$/,
+    );
+    if (hunkMatch) {
+      // Flush previous hunk
+      if (currentHunk) hunks.push(currentHunk);
+
+      oldNo = parseInt(hunkMatch[1], 10);
+      newNo = parseInt(hunkMatch[3], 10);
+
+      currentHunk = {
+        header: rawLine,
+        lines: [],
+      };
+      continue;
+    }
+
+    if (!currentHunk) continue;
+
+    const ch = rawLine[0];
+    let type: DiffLine["type"];
+    let prefix: string;
+    let content: string;
+
+    if (ch === "+") {
+      type = "add";
+      prefix = "+";
+      content = rawLine.slice(1);
+    } else if (ch === "-") {
+      type = "del";
+      prefix = "−";
+      content = rawLine.slice(1);
+    } else if (ch === " ") {
+      type = "ctx";
+      prefix = " ";
+      content = rawLine.slice(1);
+    } else if (rawLine === "\\ No newline at end of file") {
+      type = "ctx";
+      prefix = " ";
+      content = rawLine;
+    } else {
+      // Could be --- or +++ header lines; skip or treat as ctx
+      if (rawLine.startsWith("---") || rawLine.startsWith("+++")) continue;
+      type = "ctx";
+      prefix = " ";
+      content = rawLine;
+    }
+
+    const line: DiffLine = {
+      type,
+      prefix,
+      content,
+      oldNo: type === "add" ? "" : String(oldNo),
+      newNo: type === "del" ? "" : String(newNo),
+    };
+
+    if (type !== "add") oldNo++;
+    if (type !== "del") newNo++;
+
+    currentHunk.lines.push(line);
+    totalLines++;
+  }
+
+  if (currentHunk) hunks.push(currentHunk);
+  return hunks;
+}
+</script>
+
+<style scoped>
+.diff-preview {
+  --diff-add-bg: rgba(70, 200, 70, 0.12);
+  --diff-add-border: rgba(70, 200, 70, 0.35);
+  --diff-del-bg: rgba(255, 100, 100, 0.12);
+  --diff-del-border: rgba(255, 100, 100, 0.35);
+  --diff-hunk-bg: #e8f0fe;
+  --diff-hunk-border: rgba(100, 150, 220, 0.3);
+  --diff-line-no: rgba(0, 0, 0, 0.35);
+  --diff-border: rgba(0, 0, 0, 0.08);
+
+  margin: 4px 0;
+  border: 1px solid var(--diff-border);
+  border-radius: 8px;
+  overflow: hidden;
+  font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+  font-size: 12px;
+  line-height: 1.55;
+}
+
+.diff-preview.is-dark {
+  --diff-add-bg: rgba(70, 200, 70, 0.16);
+  --diff-add-border: rgba(70, 200, 70, 0.3);
+  --diff-del-bg: rgba(255, 100, 100, 0.16);
+  --diff-del-border: rgba(255, 100, 100, 0.3);
+  --diff-hunk-bg: rgba(100, 150, 255, 0.12);
+  --diff-hunk-border: rgba(100, 150, 255, 0.2);
+  --diff-line-no: rgba(255, 255, 255, 0.35);
+  --diff-border: rgba(255, 255, 255, 0.1);
+}
+
+/* ── Header ─────────────────────────────────────────────────────── */
+
+.diff-header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  width: 100%;
+  padding: 8px 12px;
+  background: rgba(0, 0, 0, 0.02);
+  border: 0;
+  cursor: pointer;
+  font: inherit;
+  color: inherit;
+  user-select: none;
+}
+
+.diff-preview.is-dark .diff-header {
+  background: rgba(255, 255, 255, 0.03);
+}
+
+.diff-header:hover {
+  background: rgba(0, 0, 0, 0.05);
+}
+
+.diff-preview.is-dark .diff-header:hover {
+  background: rgba(255, 255, 255, 0.06);
+}
+
+.diff-header-left {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  min-width: 0;
+}
+
+.diff-header-right {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  flex-shrink: 0;
+}
+
+.diff-header-icon {
+  color: rgba(var(--v-theme-on-surface), 0.55);
+  flex-shrink: 0;
+}
+
+.diff-file-path {
+  font-size: 12px;
+  font-weight: 600;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  color: rgba(var(--v-theme-on-surface), 0.8);
+}
+
+.diff-stats {
+  font-size: 11px;
+  font-weight: 600;
+  font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+  white-space: nowrap;
+}
+
+.diff-stats-add {
+  color: #2da44e;
+  margin-right: 4px;
+}
+
+.diff-preview.is-dark .diff-stats-add {
+  color: #57ab5a;
+}
+
+.diff-stats-del {
+  color: #cf222e;
+}
+
+.diff-preview.is-dark .diff-stats-del {
+  color: #f47067;
+}
+
+.diff-chevron {
+  color: rgba(var(--v-theme-on-surface), 0.45);
+  transition: transform 0.2s ease;
+}
+
+.diff-chevron.expanded {
+  transform: rotate(90deg);
+}
+
+/* ── Summary text ────────────────────────────────────────────────── */
+
+.diff-summary-text {
+  padding: 4px 12px 8px;
+  font-size: 11px;
+  color: rgba(var(--v-theme-on-surface), 0.55);
+  font-family: inherit;
+}
+
+/* ── Body ────────────────────────────────────────────────────────── */
+
+.diff-body {
+  border-top: 1px solid var(--diff-border);
+}
+
+.diff-truncation-warning {
+  padding: 6px 12px;
+  font-size: 11px;
+  color: rgba(var(--v-theme-on-surface), 0.55);
+  background: rgba(var(--v-theme-warning), 0.08);
+  border-bottom: 1px solid var(--diff-border);
+}
+
+/* ── Hunk ────────────────────────────────────────────────────────── */
+
+.diff-hunk + .diff-hunk {
+  border-top: 1px solid rgba(var(--v-theme-on-surface), 0.04);
+}
+
+.hunk-header {
+  padding: 4px 12px;
+  font-size: 11px;
+  font-weight: 600;
+  color: rgba(var(--v-theme-on-surface), 0.55);
+  background: var(--diff-hunk-bg);
+  border-bottom: 1px solid var(--diff-hunk-border);
+}
+
+/* ── Diff line ───────────────────────────────────────────────────── */
+
+.diff-line {
+  display: flex;
+  align-items: baseline;
+  padding: 1px 12px;
+  min-height: 20px;
+  transition: background 0.1s ease;
+}
+
+.diff-line:hover {
+  filter: brightness(0.94);
+}
+
+.diff-preview.is-dark .diff-line:hover {
+  filter: brightness(1.15);
+}
+
+.diff-line.add {
+  background: var(--diff-add-bg);
+  border-left: 3px solid var(--diff-add-border);
+}
+
+.diff-line.del {
+  background: var(--diff-del-bg);
+  border-left: 3px solid var(--diff-del-border);
+}
+
+.diff-line.ctx {
+  border-left: 3px solid transparent;
+}
+
+/* ── Line numbers ────────────────────────────────────────────────── */
+
+.line-number {
+  width: 36px;
+  flex-shrink: 0;
+  text-align: right;
+  padding-right: 8px;
+  color: var(--diff-line-no);
+  user-select: none;
+}
+
+.line-number.new {
+  padding-right: 0;
+  padding-left: 8px;
+}
+
+/* ── Prefix and content ──────────────────────────────────────────── */
+
+.line-prefix {
+  width: 14px;
+  flex-shrink: 0;
+  text-align: center;
+  font-weight: 700;
+  user-select: none;
+}
+
+.diff-line.add .line-prefix {
+  color: #2da44e;
+}
+
+.diff-preview.is-dark .diff-line.add .line-prefix {
+  color: #57ab5a;
+}
+
+.diff-line.del .line-prefix {
+  color: #cf222e;
+}
+
+.diff-preview.is-dark .diff-line.del .line-prefix {
+  color: #f47067;
+}
+
+.line-content {
+  white-space: pre-wrap;
+  word-break: break-all;
+  min-width: 0;
+  padding-left: 4px;
+}
+
+/* ── Show more ───────────────────────────────────────────────────── */
+
+.diff-overflow-bar {
+  border-top: 1px solid var(--diff-border);
+  padding: 6px 12px;
+}
+
+.diff-show-more {
+  background: none;
+  border: 0;
+  padding: 0;
+  font: inherit;
+  font-size: 11px;
+  color: rgba(var(--v-theme-on-surface), 0.5);
+  cursor: pointer;
+}
+
+.diff-show-more:hover {
+  color: rgba(var(--v-theme-on-surface), 0.75);
+  text-decoration: underline;
+}
+
+/* ── Collapsed state ─────────────────────────────────────────────── */
+
+.diff-preview.collapsed .diff-body,
+.diff-preview.collapsed .diff-summary-text {
+  display: none;
+}
+</style>
diff --git a/dashboard/src/components/chat/message_list_comps/IPythonToolBlock.vue b/dashboard/src/components/chat/message_list_comps/IPythonToolBlock.vue
index 716d8d1b0b..edb72a4f9d 100644
--- a/dashboard/src/components/chat/message_list_comps/IPythonToolBlock.vue
+++ b/dashboard/src/components/chat/message_list_comps/IPythonToolBlock.vue
@@ -1,21 +1,23 @@
 <template>
     <div class="ipython-tool-block" :class="{ compact: !showHeader }">
         <div v-if="displayExpanded" class="py-3 animate-fade-in">
-            <!-- Code Section -->
+            <!-- Code Section (matches ToolResultView result-code style) -->
             <div class="code-section">
-                <div v-if="shikiReady && code" class="code-highlighted"
-                    v-html="highlightedCode"></div>
-                <pre v-else class="code-fallback"
-                    :class="{ 'dark-theme': isDark }">{{ code || 'No code available' }}</pre>
+                <div
+                    v-if="shikiReady && code"
+                    class="code-highlighted code-result-shiki"
+                    v-html="highlightedCode"
+                ></div>
+                <pre v-else class="code-fallback">{{ code || 'No code available' }}</pre>
             </div>
 
-            <!-- Result Section -->
+            <!-- Result Section (matches ToolResultView result-code style) -->
             <div v-if="result" class="result-section">
                 <div class="result-label">
                     {{ tm('ipython.output') }}:
                 </div>
-                <pre class="result-content"
-                    :class="{ 'dark-theme': isDark }">{{ formattedResult }}</pre>
+                <pre class="result-content">{{ formattedResult }}</pre>
+                <div v-if="resultNotice" class="result-suffix">{{ resultNotice }}</div>
             </div>
         </div>
     </div>
@@ -25,6 +27,7 @@
 import { ref, computed, onMounted } from 'vue';
 import { useModuleI18n } from '@/i18n/composables';
 import { ensureShikiLanguages, escapeHtml, renderShikiCode } from '@/utils/shiki';
+import { findSystemNoticeIndex } from '@/utils/systemNotice';
 
 const props = defineProps({
     toolCall: {
@@ -69,14 +72,26 @@ const result = computed(() => props.toolCall.result);
 
 const formattedResult = computed(() => {
     if (!result.value) return '';
+    let text = result.value;
+    const idx = findSystemNoticeIndex(text);
+    if (idx >= 0) {
+        text = text.slice(0, idx).trim();
+    }
     try {
-        const parsed = JSON.parse(result.value);
+        const parsed = JSON.parse(text);
         return JSON.stringify(parsed, null, 2);
     } catch {
-        return result.value;
+        return text;
     }
 });
 
+const resultNotice = computed(() => {
+    if (!result.value) return null;
+    const idx = findSystemNoticeIndex(result.value);
+    if (idx < 0) return null;
+    return result.value.slice(idx).trim();
+});
+
 const highlightedCode = computed(() => {
     if (!shikiReady.value || !shikiHighlighter.value || !code.value) {
         return '';
@@ -128,89 +143,104 @@ onMounted(async () => {
     padding-bottom: 12px;
 }
 
+/* ── Code section (matches ToolResultView .result-code) ──────── */
+
 .code-section {
-    margin-bottom: 12px;
+    margin-bottom: 8px;
 }
 
-.code-highlighted {
-    border-radius: 6px;
-    overflow: hidden;
-    font-size: 12px;
-    line-height: 1.5;
+/* Fallback (non-Shiki) code block */
+.code-fallback {
+    margin: 0;
+    padding: 8px 10px;
+    border-radius: 4px;
     overflow-x: auto;
+    font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+    font-size: 11.5px;
+    line-height: 1.55;
+    background: rgba(var(--v-theme-on-surface), 0.04);
+    white-space: pre-wrap;
+    word-break: break-all;
+    max-height: 300px;
+    overflow-y: auto;
 }
 
-:deep(.code-highlighted pre.shiki) {
+/* Shiki highlighted code — mirrors ToolResultView .result-code-shiki */
+.code-result-shiki {
+    padding: 0;
+    border-radius: 4px;
+    overflow: hidden;
+}
+
+:deep(.code-result-shiki pre.shiki) {
     margin: 0;
-    padding: 16px;
-    border-radius: 6px;
+    padding: 8px 10px;
+    border-radius: 4px;
     overflow: auto;
+    max-height: 300px;
+    font-size: 11.5px;
+    line-height: 1.55;
+    tab-size: 4;
 }
 
-:deep(.code-highlighted pre.shiki code) {
+:deep(.code-result-shiki pre.shiki code) {
     display: block;
     padding: 0;
     background: transparent;
-    border-radius: 0;
-}
-
-.code-fallback {
-    margin: 0;
-    padding: 12px;
-    border-radius: 6px;
-    overflow-x: auto;
-    font-size: 12px;
-    line-height: 1.5;
-    background-color: #f5f5f5;
+    font-family: inherit;
+    font-size: inherit;
+    line-height: inherit;
 }
 
-.code-fallback.dark-theme {
-    background-color: rgb(var(--v-theme-codeBg));
-}
+/* ── Result section ─────────────────────────────────────────── */
 
 .result-section {
-    margin-top: 12px;
+    margin-top: 8px;
 }
 
 .result-label {
-    font-size: 12px;
+    font-size: 11px;
     font-weight: 600;
-    color: var(--v-theme-secondaryText);
-    margin-bottom: 6px;
+    color: rgba(var(--v-theme-on-surface), 0.55);
+    margin-bottom: 4px;
     opacity: 0.8;
 }
 
 .result-content {
     margin: 0;
-    padding: 12px;
-    border-radius: 6px;
+    padding: 8px 10px;
+    border-radius: 4px;
     overflow-x: auto;
-    font-size: 12px;
-    line-height: 1.5;
-    background-color: #f5f5f5;
+    font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+    font-size: 11.5px;
+    line-height: 1.55;
+    background: rgba(var(--v-theme-on-surface), 0.04);
+    white-space: pre-wrap;
+    word-break: break-all;
     max-height: 300px;
     overflow-y: auto;
 }
 
-.result-content.dark-theme {
-    background-color: rgb(var(--v-theme-codeBg));
+/* ── System notice suffix ───────────────────────────────────── */
+.result-suffix {
+    margin-top: 6px;
+    padding: 4px 8px;
+    border-radius: 4px;
+    background: rgba(var(--v-theme-on-surface), 0.03);
+    font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+    font-size: 11px;
+    line-height: 1.55;
+    color: rgba(var(--v-theme-on-surface), 0.55);
+    white-space: pre-wrap;
+    word-break: break-word;
 }
 
 .animate-fade-in {
     animation: fadeIn 0.2s ease-in-out;
 }
 
-:deep(.code-highlighted pre) {
-    background-color: transparent !important;
-}
-
 @keyframes fadeIn {
-    from {
-        opacity: 0;
-    }
-
-    to {
-        opacity: 1;
-    }
+    from { opacity: 0; }
+    to { opacity: 1; }
 }
 </style>
diff --git a/dashboard/src/components/chat/message_list_comps/ToolCallCard.vue b/dashboard/src/components/chat/message_list_comps/ToolCallCard.vue
index 7ba80905a6..5e76d38456 100644
--- a/dashboard/src/components/chat/message_list_comps/ToolCallCard.vue
+++ b/dashboard/src/components/chat/message_list_comps/ToolCallCard.vue
@@ -23,26 +23,74 @@
         </code>
       </div>
 
-      <div class="tool-call-detail-row">
+      <!-- ── Args: key-value table ──────────────────────────── -->
+      <div v-if="argEntries.length" class="tool-call-detail-row">
         <span class="detail-label">Args:</span>
-        <pre class="detail-value detail-json">{{
-          JSON.stringify(toolCall.args, null, 2)
-        }}</pre>
+        <div class="args-table">
+          <div
+            v-for="(entry, i) in displayedArgEntries"
+            :key="i"
+            class="args-row"
+            :class="{ clickable: entry.long }"
+            @click="entry.long && toggleArgExpand(i)"
+          >
+            <span class="args-key">{{ entry.icon }}{{ entry.key }}</span>
+            <span class="args-value">{{ entry.display }}</span>
+            <span v-if="entry.long && !expandedArgs[i]" class="args-expand-hint">…</span>
+          </div>
+          <div
+            v-if="argEntries.length > maxVisibleArgs"
+            class="args-row args-more"
+            @click="showAllArgs = !showAllArgs"
+          >
+            <span class="args-key"></span>
+            <span class="args-value args-more-text">
+              {{ showAllArgs
+                ? 'Show fewer'
+                : `+${argEntries.length - maxVisibleArgs} more` }}
+            </span>
+          </div>
+        </div>
       </div>
 
-      <div v-if="toolCall.result" class="tool-call-detail-row">
+      <!-- ── Result ────────────────────────────────────────── -->
+      <div
+        v-if="isEditTool && editToolDiff"
+        class="tool-call-detail-row"
+      >
+        <span class="detail-label">Result:</span>
+        <DiffPreview
+          :content="editToolDiff"
+          :file-path="editToolFilePath"
+          :summary="editToolSummary"
+          :is-dark="isDark"
+          :max-lines="25"
+          :collapsible="false"
+        />
+        <div v-if="editToolNotice" class="edit-tool-notice">{{ editToolNotice }}</div>
+      </div>
+
+      <div
+        v-else-if="toolCall.result"
+        class="tool-call-detail-row"
+      >
         <span class="detail-label">Result:</span>
-        <pre class="detail-value detail-json detail-result">{{
-          formattedResult
-        }}</pre>
+        <ToolResultView
+          :tool-name="toolCall.name ?? ''"
+          :result="toolCall.result ?? ''"
+          :tool-args="toolCall.args"
+        />
       </div>
     </div>
   </div>
 </template>
 
 <script setup>
-import { computed, onMounted, onUnmounted, ref } from "vue";
+import { computed, onMounted, onUnmounted, reactive, ref } from "vue";
 import { useModuleI18n } from "@/i18n/composables";
+import { findSystemNoticeIndex } from "@/utils/systemNotice";
+import DiffPreview from "./DiffPreview.vue";
+import ToolResultView from "./ToolResultView.vue";
 
 const props = defineProps({
   toolCall: {
@@ -73,20 +121,116 @@ const elapsedTime = computed(() => {
 
 const displayToolName = computed(() => props.toolCall.name || "tool");
 
+// ── Icons ─────────────────────────────────────────────────────
+
 const toolCallIcon = computed(() => {
   const name = String(props.toolCall.name || "");
-  if (name === "astrbot_execute_ipython" || name === "astrbot_execute_python") {
-    return "mdi-code-json";
-  }
-  if (name.includes("web_search") || name.includes("tavily")) {
-    return "mdi-web";
-  }
-  if (name === "astrbot_execute_shell") {
-    return "mdi-console-line";
-  }
+  if (name === "astrbot_file_read_tool") return "mdi-file-document-outline";
+  if (name === "astrbot_file_write_tool") return "mdi-content-save-outline";
+  if (name === "astrbot_file_edit_tool") return "mdi-file-document-edit-outline";
+  if (name === "astrbot_grep_tool") return "mdi-magnify";
+  if (name === "astrbot_execute_shell") return "mdi-console-line";
+  if (name === "astrbot_execute_python" || name === "astrbot_execute_ipython") return "mdi-language-python";
+  if (name === "astrbot_upload_file") return "mdi-upload-outline";
+  if (name === "astrbot_download_file") return "mdi-download-outline";
+  if (name.includes("web_search") || name.includes("tavily")) return "mdi-web";
   return "mdi-wrench";
 });
 
+// ── Args display ──────────────────────────────────────────────
+
+const maxVisibleArgs = 5;
+const showAllArgs = ref(false);
+const expandedArgs = reactive({});
+
+const argEntries = computed(() => {
+  const args = props.toolCall.args;
+  if (!args || typeof args !== "object") return [];
+  return Object.entries(args).map(([key, value], index) => {
+    const raw = value === null || value === undefined ? "—" : String(value);
+    const long = raw.length > 60;
+    const isExpanded = !!expandedArgs[index];
+    return {
+      key,
+      raw,
+      long,
+      icon: argIcon(key),
+      display: long && !isExpanded ? raw.slice(0, 60) : raw,
+    };
+  });
+});
+
+const displayedArgEntries = computed(() => {
+  const entries = argEntries.value;
+  if (showAllArgs.value) return entries;
+  return entries.slice(0, maxVisibleArgs);
+});
+
+function argIcon(key) {
+  const k = key.toLowerCase();
+  if (k.includes("path") || k === "file" || k.includes("dir")) return "📁 ";
+  if (k.includes("content") || k === "old" || k === "new" || k === "text") return "📝 ";
+  if (k.includes("pattern") || k.includes("query") || k.includes("search")) return "🔍 ";
+  if (k.includes("command") || k.includes("cmd")) return "⚡ ";
+  if (k.includes("code") || k.includes("python")) return "🐍 ";
+  if (k.includes("replace_all")) return "🔄 ";
+  if (k.includes("offset") || k.includes("limit") || k.includes("result_limit")) return "#⃣ ";
+  return "";
+}
+
+function toggleArgExpand(index) {
+  expandedArgs[index] = !expandedArgs[index];
+}
+
+// ── file_edit_tool diff rendering ─────────────────────────────
+
+const isEditTool = computed(
+  () => props.toolCall.name === "astrbot_file_edit_tool",
+);
+
+// Strip [SYSTEM NOTICE] suffix from the raw result for all edit tool computed properties.
+// Uses the shared findSystemNoticeIndex() to correctly distinguish genuine system
+// notices from "[SYSTEM NOTICE]" text that may appear inside the edited file's diff content.
+const editToolCleanResult = computed(() => {
+  const raw = props.toolCall.result ?? "";
+  const idx = findSystemNoticeIndex(raw);
+  return idx < 0 ? raw : raw.slice(0, idx).trim();
+});
+
+const editToolNotice = computed(() => {
+  const raw = props.toolCall.result ?? "";
+  const idx = findSystemNoticeIndex(raw);
+  return idx < 0 ? null : raw.slice(idx).trim();
+});
+
+const editToolDiff = computed(() => {
+  if (!isEditTool.value) return "";
+  const raw = editToolCleanResult.value;
+  const match = raw.match(/```diff\s*\n?([\s\S]*?)```/);
+  return match ? match[1] : raw;
+});
+
+const editToolFilePath = computed(() => {
+  if (!isEditTool.value) return "";
+  const raw = editToolCleanResult.value;
+  const match = raw.match(/^Edited\s+(.+?)\./m);
+  return match ? match[1] : "";
+});
+
+const editToolSummary = computed(() => {
+  if (!isEditTool.value) return "";
+  const raw = editToolCleanResult.value;
+  const lines = raw.split("\n");
+  const statusParts = [];
+  for (const line of lines) {
+    if (line.startsWith("Diff:") || line.startsWith("```")) break;
+    if (line.trim()) statusParts.push(line.trim());
+  }
+  return statusParts.join("\n");
+});
+
+// ── Duration ──────────────────────────────────────────────────
+
 const toolCallDuration = computed(() => {
   const startTime = Number(props.toolCall.ts);
   if (!Number.isFinite(startTime) || startTime <= 0) return "";
@@ -96,16 +240,6 @@ const toolCallDuration = computed(() => {
   return elapsedTime.value;
 });
 
-const formattedResult = computed(() => {
-  if (!props.toolCall.result) return "";
-  try {
-    const parsed = JSON.parse(props.toolCall.result);
-    return JSON.stringify(parsed, null, 2);
-  } catch {
-    return props.toolCall.result;
-  }
-});
-
 const formatDuration = (seconds) => {
   if (!Number.isFinite(seconds) || seconds < 0) return "";
   if (seconds < 1) {
@@ -205,6 +339,19 @@ onUnmounted(() => {
   animation: fadeIn 0.2s ease-in-out;
 }
 
+.edit-tool-notice {
+  margin-top: 6px;
+  padding: 4px 8px;
+  border-radius: 4px;
+  background: rgba(var(--v-theme-on-surface), 0.03);
+  font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+  font-size: 11px;
+  line-height: 1.55;
+  color: rgba(var(--v-theme-on-surface), 0.55);
+  white-space: pre-wrap;
+  word-break: break-word;
+}
+
 .tool-call-detail-row {
   display: flex;
   flex-direction: column;
@@ -226,12 +373,81 @@ onUnmounted(() => {
 .detail-value {
   font-size: 12px;
   color: rgba(var(--v-theme-on-surface), 0.8);
-  background-color: transparent;
-  padding: 0;
+  word-break: break-all;
+}
+
+/* ── Args table ─────────────────────────────────────────────── */
+
+.args-table {
+  border: 1px solid rgba(var(--v-theme-on-surface), 0.08);
   border-radius: 4px;
+  overflow: hidden;
+}
+
+.args-row {
+  display: flex;
+  align-items: baseline;
+  padding: 3px 8px;
+  font-size: 11.5px;
+  line-height: 1.55;
+}
+
+.args-row + .args-row {
+  border-top: 1px solid rgba(var(--v-theme-on-surface), 0.05);
+}
+
+.args-row.clickable {
+  cursor: pointer;
+}
+
+.args-row.clickable:hover {
+  background: rgba(var(--v-theme-on-surface), 0.03);
+}
+
+.args-key {
+  flex-shrink: 0;
+  width: 110px;
+  font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+  font-size: 11px;
+  color: rgba(var(--v-theme-on-surface), 0.5);
+  font-weight: 600;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  padding-right: 8px;
+}
+
+.args-value {
+  font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+  font-size: 11px;
+  color: rgba(var(--v-theme-on-surface), 0.8);
+  white-space: pre-wrap;
   word-break: break-all;
+  min-width: 0;
+}
+
+.args-expand-hint {
+  color: rgba(var(--v-theme-on-surface), 0.35);
+  font-style: italic;
+  margin-left: 4px;
+}
+
+.args-more {
+  cursor: pointer;
+  background: rgba(var(--v-theme-on-surface), 0.02);
+}
+
+.args-more:hover {
+  background: rgba(var(--v-theme-on-surface), 0.05);
+}
+
+.args-more-text {
+  color: rgba(var(--v-theme-on-surface), 0.45) !important;
+  font-style: italic;
 }
 
+/* ── Legacy detail rows ─────────────────────────────────────── */
+
 .detail-json {
   font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
   white-space: pre-wrap;
@@ -240,32 +456,12 @@ onUnmounted(() => {
   margin: 0;
 }
 
-.detail-result {
-  max-height: 300px;
-  background-color: transparent;
-}
-
 .animate-fade-in {
   animation: fadeIn 0.2s ease-in-out;
 }
 
 @keyframes fadeIn {
-  from {
-    opacity: 0;
-  }
-
-  to {
-    opacity: 1;
-  }
-}
-
-@keyframes spin {
-  from {
-    transform: rotate(0deg);
-  }
-
-  to {
-    transform: rotate(360deg);
-  }
+  from { opacity: 0; }
+  to { opacity: 1; }
 }
 </style>
diff --git a/dashboard/src/components/chat/message_list_comps/ToolResultView.vue b/dashboard/src/components/chat/message_list_comps/ToolResultView.vue
new file mode 100644
index 0000000000..ce6407f9bc
--- /dev/null
+++ b/dashboard/src/components/chat/message_list_comps/ToolResultView.vue
@@ -0,0 +1,648 @@
+<template>
+  <div class="tool-result-view">
+    <!-- ── file_read_tool ──────────────────────────────────────── -->
+    <template v-if="toolName === 'astrbot_file_read_tool'">
+      <div class="result-header">
+        <v-icon size="14" class="result-header-icon">mdi-file-document-outline</v-icon>
+        <span class="result-header-text">{{ readFilePath }}</span>
+        <span v-if="readFileRange" class="result-header-meta">{{ readFileRange }}</span>
+      </div>
+      <div
+        v-if="shikiReady && detectedLanguage !== 'text'"
+        class="result-code result-code-shiki"
+        v-html="highlightedCode"
+      ></div>
+      <pre v-else class="result-code">{{ readFileContent }}</pre>
+    </template>
+
+    <!-- ── file_write_tool ─────────────────────────────────────── -->
+    <template v-else-if="toolName === 'astrbot_file_write_tool'">
+      <div class="result-status" :class="resultOk ? 'success' : 'error'">
+        <v-icon size="16">{{ resultOk ? 'mdi-check-circle' : 'mdi-alert-circle' }}</v-icon>
+        <span>{{ resultOk ? writeFilePath : resultText }}</span>
+      </div>
+    </template>
+
+    <!-- ── grep_tool ───────────────────────────────────────────── -->
+    <template v-else-if="toolName === 'astrbot_grep_tool'">
+      <div v-if="grepLines.length" class="result-header">
+        <v-icon size="14" class="result-header-icon">mdi-magnify</v-icon>
+        <span class="result-header-text">Found {{ grepLines.length }} match(es)</span>
+      </div>
+      <div v-if="grepLines.length" class="grep-results">
+        <div
+          v-for="(line, i) in grepLines"
+          :key="i"
+          class="grep-line"
+        >
+          <span v-if="line.file" class="grep-file">{{ line.file }}</span>
+          <span v-if="line.lineno" class="grep-lineno">{{ line.lineno }}</span>
+          <span class="grep-text">{{ line.text }}</span>
+        </div>
+      </div>
+      <div v-if="grepTruncated" class="result-truncated">{{ grepTruncated }}</div>
+    </template>
+
+    <!-- ── execute_shell ───────────────────────────────────────── -->
+    <template v-else-if="toolName === 'astrbot_execute_shell'">
+      <div class="shell-result">
+        <div class="shell-row">
+          <span class="shell-label">Stdout</span>
+          <pre class="shell-value" v-text="shellStdout"></pre>
+        </div>
+        <div v-if="shellStderr" class="shell-row shell-stderr">
+          <span class="shell-label">Stderr</span>
+          <pre class="shell-value shell-stderr-text" v-text="shellStderr"></pre>
+        </div>
+        <div class="shell-row">
+          <span class="shell-label">Exit code</span>
+          <span class="shell-exit-code" :class="shellExitCodeVal === 0 ? 'success' : 'error'">{{ shellExitCodeVal }}</span>
+        </div>
+      </div>
+      <div v-if="shellExtra" class="shell-extra-text">{{ shellExtra }}</div>
+    </template>
+
+    <!-- ── execute_python ──────────────────────────────────────── -->
+    <template v-else-if="toolName === 'astrbot_execute_python' || toolName === 'astrbot_execute_ipython'">
+      <pre class="result-terminal" v-text="resultText"></pre>
+    </template>
+
+    <!-- ── fallback ────────────────────────────────────────────── -->
+    <template v-else>
+      <pre class="result-raw">{{ formattedResult }}</pre>
+    </template>
+
+    <!-- ── shared system suffix ([SYSTEM NOTICE] + overflow notice; exclude shell which handles it separately) ── -->
+    <div v-if="resultSuffix && toolName !== 'astrbot_execute_shell'" class="result-suffix">{{ resultSuffix }}</div>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { computed, onMounted, ref } from "vue";
+import {
+  ensureShikiLanguages,
+  escapeHtml,
+  renderShikiCode,
+} from "@/utils/shiki";
+import { findSystemNoticeIndex } from "@/utils/systemNotice";
+
+const props = defineProps<{
+  toolName: string;
+  result: string;
+  toolArgs?: Record<string, any>;
+}>();
+
+// ── Shiki syntax highlighting ─────────────────────────────────────
+
+const EXT_TO_LANG: Record<string, string> = {
+  ".py": "python",
+  ".js": "javascript",
+  ".mjs": "javascript",
+  ".cjs": "javascript",
+  ".ts": "typescript",
+  ".tsx": "tsx",
+  ".jsx": "jsx",
+  ".vue": "vue",
+  ".json": "json",
+  ".yaml": "yaml",
+  ".yml": "yaml",
+  ".sh": "bash",
+  ".bash": "bash",
+  ".zsh": "bash",
+  ".css": "css",
+  ".html": "html",
+  ".htm": "html",
+  ".xml": "xml",
+  ".svg": "xml",
+  ".md": "markdown",
+  ".sql": "sql",
+  ".java": "java",
+  ".ini": "ini",
+  ".diff": "diff",
+  ".patch": "diff",
+  ".ps1": "powershell",
+  ".dockerfile": "dockerfile",
+  ".txt": "text",
+  // C / C++ / Go / Rust
+  ".c": "c",
+  ".h": "c",
+  ".cpp": "cpp",
+  ".cc": "cpp",
+  ".cxx": "cpp",
+  ".hpp": "cpp",
+  ".c++": "cpp",
+  ".go": "go",
+  ".rs": "rust",
+};
+
+function detectLanguage(filePath: string): string {
+  const m = filePath.match(/\.([\w]+)$/i);
+  if (!m) return "text";
+  const key = "." + m[1].toLowerCase();
+  return EXT_TO_LANG[key] || "text";
+}
+
+const shikiHighlighter = ref<any>(null);
+const shikiReady = ref(false);
+
+// ── helpers ──────────────────────────────────────────────────────
+
+const rawResult = computed(() => (props.result ?? "").trim());
+
+// Strip system-injected suffixes ([SYSTEM NOTICE] + overflow notice) for all
+// non-shell templates.  Shell uses rawResult directly via brace-tracking in
+// shellParsed.  All other tools now use the smart findSystemNoticeIndex()
+// which handles both [SYSTEM NOTICE] markers and the overflow notice pattern.
+const resultText = computed(() => {
+  const text = rawResult.value;
+  const idx = findSystemNoticeIndex(text);
+  if (idx < 0) return text;
+  return text.slice(0, idx).trim();
+});
+
+const resultSuffix = computed(() => {
+  const text = rawResult.value;
+  const idx = findSystemNoticeIndex(text);
+  if (idx < 0) return null;
+  return text.slice(idx).trim();
+});
+
+const resultOk = computed(() => {
+  const t = resultText.value.toLowerCase();
+  return t.includes("success") || t.includes("successfully") || t.startsWith("file written") || t.startsWith("file uploaded") || t.startsWith("file downloaded");
+});
+
+const formattedResult = computed(() => {
+  if (!resultText.value) return "";
+  try {
+    return JSON.stringify(JSON.parse(resultText.value), null, 2);
+  } catch {
+    return resultText.value;
+  }
+});
+
+// ── file_read_tool ──────────────────────────────────────────────
+
+const readFilePath = computed(() => {
+  // Prefer tool args when available
+  if (props.toolArgs?.path) return String(props.toolArgs.path);
+  // Try to parse from a formatted header like "path (lines 0-50, 82 lines total)"
+  const m = resultText.value.match(/^(.+?)\s*\(/m);
+  if (m) return m[1];
+  // fallback: first line of raw content
+  return resultText.value.split("\n")[0]?.slice(0, 120) || "";
+});
+
+const readFileRange = computed(() => {
+  // Build from args when offset/limit are provided
+  if (props.toolArgs) {
+    const offset = props.toolArgs.offset;
+    const limit = props.toolArgs.limit;
+    if (offset !== undefined || limit !== undefined) {
+      const parts: string[] = [];
+      if (offset !== undefined && offset !== null) parts.push(`offset ${offset}`);
+      if (limit !== undefined && limit !== null) parts.push(`limit ${limit}`);
+      if (parts.length) return parts.join(", ");
+    }
+  }
+  // Fallback: parse from a formatted header
+  const m = resultText.value.match(/\((Lines?\s+[\d–\-]+)/i);
+  return m ? m[1] : "";
+});
+
+const readFileContent = computed(() => {
+  const lines = resultText.value.split("\n");
+  // Detect if the first non-empty line looks like a path+range header
+  // e.g. "F:/path/to/file (Lines 0-50, 82 lines total)"
+  const firstLine = lines[0]?.trim() || "";
+  const hasHeader =
+    /^.+?\s*\((Lines?\s+[\d–\-]+)/i.test(firstLine);
+  if (hasHeader) {
+    // Strip the header line and any following blank separator
+    let i = 1;
+    while (i < lines.length && !lines[i].trim()) i++;
+    return lines.slice(i).join("\n");
+  }
+  // No recognizable header — show full content as-is
+  return resultText.value;
+});
+
+// ── Shiki highlighting (file_read_tool) ──────────────────────────
+
+const detectedLanguage = computed(() =>
+  detectLanguage(readFilePath.value),
+);
+
+const highlightedCode = computed(() => {
+  if (!shikiReady.value || !shikiHighlighter.value) return "";
+  const lang = detectedLanguage.value;
+  const code = readFileContent.value;
+  if (!code) return "";
+  try {
+    return renderShikiCode(
+      shikiHighlighter.value,
+      code,
+      lang,
+      // ToolResultView doesn't receive isDark directly; Shiki's
+      // default dual-theme (light/dark) output works through CSS
+      // media queries, so we pass "auto" here.
+      "auto",
+    );
+  } catch (err) {
+    console.error("Failed to highlight code with Shiki:", err);
+    return `<pre><code>${escapeHtml(code)}</code></pre>`;
+  }
+});
+
+onMounted(async () => {
+  try {
+    shikiHighlighter.value = await ensureShikiLanguages();
+    shikiReady.value = true;
+  } catch (err) {
+    console.error("Failed to initialize Shiki:", err);
+  }
+});
+
+// ── file_write_tool ─────────────────────────────────────────────
+
+const writeFilePath = computed(() => {
+  const m = resultText.value.match(/^File written successfully:\s*(.+)/i);
+  if (m) return m[1];
+  return resultText.value;
+});
+
+// ── grep_tool ──────────────────────────────────────────────────
+
+const grepLines = computed(() => {
+  const lines = resultText.value.split("\n");
+  const parsed: Array<{ file?: string; lineno?: string; text: string }> = [];
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    if (line.startsWith("[Truncated")) continue;
+    // Try "file:lineno:text" pattern
+    const m = line.match(/^(.+?):(\d+):(.*)$/);
+    if (m) {
+      parsed.push({ file: m[1], lineno: m[2], text: m[3] });
+    } else {
+      // Try "file-path:text" or "file:text" (ripgrep with -n)
+      const m2 = line.match(/^(.+?):(\d+)[:\-](.*)$/);
+      if (m2) {
+        parsed.push({ file: m2[1], lineno: m2[2], text: m2[3] });
+      } else {
+        parsed.push({ text: line });
+      }
+    }
+  }
+  return parsed;
+});
+
+const grepTruncated = computed(() => {
+  const m = resultText.value.match(/\[Truncated.+\]/);
+  return m ? m[0] : "";
+});
+
+// ── execute_shell ──────────────────────────────────────────────
+
+const shellParsed = computed(() => {
+  // Extract JSON from text that may have trailing non-JSON content (e.g. [SYSTEM NOTICE]).
+  const text = rawResult.value;
+  const start = text.indexOf("{");
+  if (start < 0) {
+    return { json: null, extra: text };
+  }
+  // Track brace depth to find the matching closing brace
+  let depth = 0;
+  let end = -1;
+  for (let i = start; i < text.length; i++) {
+    if (text[i] === "{") depth++;
+    else if (text[i] === "}") {
+      depth--;
+      if (depth === 0) {
+        end = i + 1;
+        break;
+      }
+    }
+  }
+  if (end < 0) {
+    return { json: null, extra: text };
+  }
+  const jsonStr = text.slice(start, end);
+  const extraStr = text.slice(end).trim();
+  try {
+    const parsed = JSON.parse(jsonStr);
+    if (parsed && typeof parsed === "object") {
+      return { json: parsed, extra: extraStr || null };
+    }
+  } catch {
+    // not valid JSON
+  }
+  return { json: null, extra: text };
+});
+
+const shellStdout = computed(() => {
+  if (shellParsed.value?.json && "stdout" in shellParsed.value.json) {
+    return shellParsed.value.json.stdout;
+  }
+  return resultText.value;
+});
+
+const shellStderr = computed(() => {
+  return shellParsed.value?.json?.stderr || "";
+});
+
+const shellExitCodeVal = computed(() => {
+  if (shellParsed.value?.json && "exit_code" in shellParsed.value.json) {
+    return shellParsed.value.json.exit_code;
+  }
+  return null;
+});
+
+const shellExtra = computed(() => {
+  return shellParsed.value?.extra || null;
+});
+
+</script>
+
+<style scoped>
+.tool-result-view {
+  font-size: 12px;
+  line-height: 1.5;
+}
+
+/* ── Header ─────────────────────────────────────────────────── */
+
+.result-header {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  margin-bottom: 6px;
+  padding: 4px 8px;
+  border-radius: 4px;
+  background: rgba(var(--v-theme-on-surface), 0.04);
+  font-size: 11.5px;
+}
+
+.result-header-icon {
+  color: rgba(var(--v-theme-on-surface), 0.5);
+  flex-shrink: 0;
+}
+
+.result-header-text {
+  font-weight: 600;
+  color: rgba(var(--v-theme-on-surface), 0.75);
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  min-width: 0;
+}
+
+.result-header-meta {
+  color: rgba(var(--v-theme-on-surface), 0.45);
+  flex-shrink: 0;
+  margin-left: auto;
+}
+
+/* ── Code block ──────────────────────────────────────────────── */
+
+.result-code {
+  margin: 0;
+  padding: 8px 10px;
+  border-radius: 4px;
+  background: rgba(var(--v-theme-on-surface), 0.04);
+  font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+  font-size: 11.5px;
+  line-height: 1.55;
+  white-space: pre-wrap;
+  word-break: break-all;
+  max-height: 300px;
+  overflow-y: auto;
+}
+
+/* Shiki 高亮容器 — 继承 code block 布局，清除 Shiki 默认样式 */
+.result-code-shiki {
+  padding: 0;
+  border-radius: 6px;
+  overflow: hidden;
+}
+
+.result-code-shiki :deep(pre.shiki) {
+  margin: 0;
+  padding: 10px 12px;
+  border-radius: 6px;
+  overflow: auto;
+  max-height: 300px;
+  font-size: 11.5px;
+  line-height: 1.55;
+  tab-size: 4;
+}
+
+.result-code-shiki :deep(pre.shiki code) {
+  display: block;
+  padding: 0;
+  background: transparent;
+  font-family: inherit;
+  font-size: inherit;
+  line-height: inherit;
+}
+
+/* ── Shell result ─────────────────────────────────────────── */
+
+.shell-result {
+  border: 1px solid rgba(var(--v-theme-on-surface), 0.1);
+  border-radius: 4px;
+  overflow: hidden;
+}
+
+.shell-row {
+  display: flex;
+  align-items: flex-start;
+  padding: 3px 8px;
+  font-size: 11px;
+  line-height: 1.55;
+}
+
+.shell-row + .shell-row {
+  border-top: 1px solid rgba(var(--v-theme-on-surface), 0.06);
+}
+
+.shell-label {
+  flex-shrink: 0;
+  width: 64px;
+  font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+  font-size: 11px;
+  font-weight: 600;
+  color: rgba(var(--v-theme-on-surface), 0.5);
+  padding-right: 8px;
+}
+
+.shell-value {
+  flex: 1;
+  font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+  font-size: 11px;
+  color: rgba(var(--v-theme-on-surface), 0.8);
+  white-space: pre-wrap;
+  word-break: break-all;
+  margin: 0;
+  padding: 0;
+  max-height: 200px;
+  overflow-y: auto;
+}
+
+.shell-stderr {
+  background: rgba(207, 34, 46, 0.04);
+}
+
+.shell-stderr-text {
+  color: #cf222e;
+}
+
+.shell-exit-code {
+  font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+  font-size: 11px;
+  font-weight: 600;
+}
+
+.shell-exit-code.success {
+  color: #2da44e;
+}
+
+.shell-exit-code.error {
+  color: #cf222e;
+}
+
+/* ── Terminal block (deprecated, shell now uses .shell-result) ── */
+.result-terminal-deprecated {}
+
+/* ── Shell extra text (e.g. [SYSTEM NOTICE]) ────────────── */
+
+.shell-extra-text {
+  margin-top: 6px;
+  padding: 4px 8px;
+  border-radius: 4px;
+  background: rgba(var(--v-theme-on-surface), 0.03);
+  font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+  font-size: 11px;
+  line-height: 1.55;
+  color: rgba(var(--v-theme-on-surface), 0.55);
+  white-space: pre-wrap;
+  word-break: break-word;
+}
+
+/* Shared [SYSTEM NOTICE] suffix for non-shell tools */
+.result-suffix {
+  margin-top: 6px;
+  padding: 4px 8px;
+  border-radius: 4px;
+  background: rgba(var(--v-theme-on-surface), 0.03);
+  font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+  font-size: 11px;
+  line-height: 1.55;
+  color: rgba(var(--v-theme-on-surface), 0.55);
+  white-space: pre-wrap;
+  word-break: break-word;
+}
+
+/* ── Status badge ────────────────────────────────────────────── */
+
+.result-status {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  padding: 6px 10px;
+  border-radius: 4px;
+  font-size: 12px;
+}
+
+.result-status.success {
+  background: rgba(70, 200, 70, 0.08);
+  color: #2da44e;
+}
+
+.result-status.error {
+  background: rgba(255, 100, 100, 0.08);
+  color: #cf222e;
+}
+
+/* ── Exit code ───────────────────────────────────────────────── */
+
+.result-exit-code {
+  margin-top: 4px;
+  padding: 2px 8px;
+  border-radius: 3px;
+  font-size: 11px;
+  font-weight: 600;
+  display: inline-block;
+}
+
+.result-exit-code.success {
+  background: rgba(70, 200, 70, 0.1);
+  color: #2da44e;
+}
+
+.result-exit-code.error {
+  background: rgba(255, 100, 100, 0.1);
+  color: #cf222e;
+}
+
+/* ── Grep results ────────────────────────────────────────────── */
+
+.grep-results {
+  max-height: 300px;
+  overflow-y: auto;
+}
+
+.grep-line {
+  display: flex;
+  gap: 0;
+  padding: 1px 0;
+  font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+  font-size: 11.5px;
+  line-height: 1.55;
+}
+
+.grep-file {
+  color: rgba(var(--v-theme-on-surface), 0.45);
+  flex-shrink: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  max-width: 140px;
+  white-space: nowrap;
+  padding-right: 4px;
+}
+
+.grep-lineno {
+  color: rgba(var(--v-theme-on-surface), 0.35);
+  flex-shrink: 0;
+  min-width: 32px;
+  text-align: right;
+  padding-right: 6px;
+}
+
+.grep-text {
+  color: rgba(var(--v-theme-on-surface), 0.8);
+  white-space: pre-wrap;
+  word-break: break-all;
+  min-width: 0;
+}
+
+.result-truncated {
+  padding: 4px 0;
+  font-size: 11px;
+  color: rgba(var(--v-theme-on-surface), 0.45);
+  font-style: italic;
+}
+
+/* ── Raw fallback ────────────────────────────────────────────── */
+
+.result-raw {
+  margin: 0;
+  font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+  font-size: 11.5px;
+  line-height: 1.55;
+  white-space: pre-wrap;
+  word-break: break-all;
+  max-height: 300px;
+  overflow-y: auto;
+  color: rgba(var(--v-theme-on-surface), 0.8);
+}
+</style>
diff --git a/dashboard/src/components/shared/ThemeAwareMarkdownCodeBlock.vue b/dashboard/src/components/shared/ThemeAwareMarkdownCodeBlock.vue
index 902cc51113..608edae579 100644
--- a/dashboard/src/components/shared/ThemeAwareMarkdownCodeBlock.vue
+++ b/dashboard/src/components/shared/ThemeAwareMarkdownCodeBlock.vue
@@ -1,5 +1,12 @@
 <template>
+  <DiffPreview
+    v-if="node.lang === 'diff'"
+    :content="String((node as Record<string, unknown>).content ?? (node as Record<string, unknown>).code ?? '')"
+    :is-dark="effectiveIsDark"
+    :max-lines="30"
+  />
   <MarkdownCodeBlockNode
+    v-else
     :key="themeRenderKey"
     v-bind="forwardedBindings"
   >
@@ -16,6 +23,7 @@
 import { computed, inject, type Ref } from "vue";
 import { MarkdownCodeBlockNode } from "markstream-vue";
 import { useAttrs } from "vue";
+import DiffPreview from "@/components/chat/message_list_comps/DiffPreview.vue";
 
 defineOptions({
   inheritAttrs: false,
diff --git a/dashboard/src/utils/shikiLimitedBundle.js b/dashboard/src/utils/shikiLimitedBundle.js
index b0ece53879..89862f7cb4 100644
--- a/dashboard/src/utils/shikiLimitedBundle.js
+++ b/dashboard/src/utils/shikiLimitedBundle.js
@@ -1,9 +1,12 @@
 import { createHighlighterCore } from "shiki/core";
 import { createJavaScriptRegexEngine } from "shiki/engine/javascript";
 import bash from "shiki/langs/bash.mjs";
+import c from "shiki/langs/c.mjs";
+import cpp from "shiki/langs/cpp.mjs";
 import css from "shiki/langs/css.mjs";
 import diff from "shiki/langs/diff.mjs";
 import dockerfile from "shiki/langs/dockerfile.mjs";
+import go from "shiki/langs/go.mjs";
 import html from "shiki/langs/html.mjs";
 import ini from "shiki/langs/ini.mjs";
 import java from "shiki/langs/java.mjs";
@@ -13,6 +16,7 @@ import jsx from "shiki/langs/jsx.mjs";
 import markdown from "shiki/langs/markdown.mjs";
 import powershell from "shiki/langs/powershell.mjs";
 import python from "shiki/langs/python.mjs";
+import rust from "shiki/langs/rust.mjs";
 import sql from "shiki/langs/sql.mjs";
 import tsx from "shiki/langs/tsx.mjs";
 import typescript from "shiki/langs/typescript.mjs";
@@ -26,9 +30,12 @@ import vitesseLight from "shiki/themes/vitesse-light.mjs";
 
 export const LIMITED_SHIKI_LANGUAGES = [
   ...bash,
+  ...c,
+  ...cpp,
   ...css,
   ...diff,
   ...dockerfile,
+  ...go,
   ...html,
   ...ini,
   ...java,
@@ -38,6 +45,7 @@ export const LIMITED_SHIKI_LANGUAGES = [
   ...markdown,
   ...powershell,
   ...python,
+  ...rust,
   ...sql,
   ...tsx,
   ...typescript,
@@ -57,10 +65,16 @@ const BUILT_IN_LANGUAGES = ["text", "plaintext", "plain"];
 
 export const LIMITED_SHIKI_LANGUAGE_ALIASES = {
   bat: "powershell",
+  "c++": "cpp",
+  cc: "cpp",
   cjs: "javascript",
   console: "bash",
   cts: "typescript",
+  cxx: "cpp",
   docker: "dockerfile",
+  golang: "go",
+  h: "c",
+  hpp: "cpp",
   htm: "html",
   js: "javascript",
   md: "markdown",
@@ -71,6 +85,7 @@ export const LIMITED_SHIKI_LANGUAGE_ALIASES = {
   ps1: "powershell",
   pwsh: "powershell",
   py: "python",
+  rs: "rust",
   shell: "bash",
   shellscript: "bash",
   sh: "bash",
diff --git a/dashboard/src/utils/systemNotice.ts b/dashboard/src/utils/systemNotice.ts
new file mode 100644
index 0000000000..b0497e76ef
--- /dev/null
+++ b/dashboard/src/utils/systemNotice.ts
@@ -0,0 +1,199 @@
+/**
+ * Utilities for detecting and extracting system-injected suffixes from
+ * tool call results.  Two kinds of suffixes are recognised:
+ *
+ * 1. **[SYSTEM NOTICE]** — repeated-tool warnings, follow-up notices, etc.
+ *    Always prefixed with the literal marker `[SYSTEM NOTICE]` followed by
+ *    one of the known SYSTEM_NOTICE_PREFIXES.
+ *
+ * 2. **Tool-result overflow notice** — emitted when a tool output is too
+ *    large and gets spilled to a file.  The notice text starts with
+ *    `"Truncated tool output preview shown above."` and does NOT carry the
+ *    `[SYSTEM NOTICE]` marker (it is a plain-text suffix).
+ *
+ * Both suffixes are always appended at the very end of the tool result by
+ * the backend, possibly as a chain of multiple notices (e.g. repeated-tool
+ * warning + follow-up notice).  When the tool output itself contains text
+ * that looks like a system notice (e.g. reading a log file), the algorithm
+ * must correctly ignore those false positives.
+ *
+ * **Key invariant**: the real system notice chain starts at the EARLIEST
+ * valid candidate where everything from that position to end-of-text is
+ * exclusively notice-chain content (no file content mixed in).
+ *
+ * Known message prefixes produced by the AstrBot system (not file content).
+ * Used to distinguish genuine system notices from text that happens to
+ * contain the literal string "[SYSTEM NOTICE]".
+ */
+export const SYSTEM_NOTICE_PREFIXES = [
+  "By the way,",
+  "Important:",
+  "User sent",
+];
+
+const MARKER = "[SYSTEM NOTICE]";
+
+/** Distinctive opening of the tool-result overflow notice. */
+const OVERFLOW_NOTICE_PREFIX = "Truncated tool output preview shown above.";
+
+// ── Helpers ─────────────────────────────────────────────────────────────
+
+/**
+ * Check whether the text starting at `idx` begins with a genuine
+ * `[SYSTEM NOTICE]` marker followed by one of the known prefixes.
+ */
+function isGenuineSystemNotice(text: string, idx: number): boolean {
+  const suffix = text.slice(idx).trim();
+  return SYSTEM_NOTICE_PREFIXES.some((p) =>
+    suffix.startsWith(`${MARKER} ${p}`),
+  );
+}
+
+/**
+ * Check whether the entire region from `fromPos` to end-of-text contains
+ * ONLY notice-chain content (no real file content).
+ *
+ * Allowed line types within the notice chain:
+ *   - Blank lines (separators between notices)
+ *   - Lines containing `[SYSTEM NOTICE]` (notice markers and their bodies)
+ *   - Lines starting with the overflow notice prefix
+ *   - Numbered list items (`N. …`) — but ONLY when preceded by a
+ *     `[SYSTEM NOTICE] User sent` (follow-up notice) in the chain.
+ *     This prevents file content like `1. item` from being mistaken for
+ *     notice content.
+ *   - Continuation lines of a notice paragraph (non-blank, directly after
+ *     a notice marker line, before any blank line gap).
+ */
+function isNoticeChainRegion(text: string, fromPos: number): boolean {
+  const region = text.slice(fromPos);
+  const lines = region.split("\n");
+  let inFollowUp = false;
+  let sawBlankAfterNotice = false;
+
+  for (const rawLine of lines) {
+    const trimmed = rawLine.trim();
+
+    // Blank lines are separators between notices — always allowed.
+    if (trimmed === "") {
+      if (!inFollowUp) sawBlankAfterNotice = true;
+      continue;
+    }
+
+    // [SYSTEM NOTICE] marker — starts a new notice in the chain.
+    if (trimmed.includes(MARKER)) {
+      // Track whether this is a follow-up notice (allows numbered items).
+      const markerIdx = trimmed.indexOf(MARKER);
+      const afterMarker = trimmed.slice(markerIdx).trim();
+      if (afterMarker.startsWith(`${MARKER} User sent`)) {
+        inFollowUp = true;
+      }
+      sawBlankAfterNotice = false;
+      continue;
+    }
+
+    // Overflow notice prefix — part of the chain.
+    if (trimmed.startsWith(OVERFLOW_NOTICE_PREFIX)) {
+      inFollowUp = false;
+      sawBlankAfterNotice = false;
+      continue;
+    }
+
+    // Numbered list items — only valid after a "User sent" follow-up notice.
+    if (inFollowUp && /^\d+\.\s/.test(trimmed)) continue;
+
+    // Continuation lines:
+    // - In follow-up mode: free-form instruction text is part of the notice body.
+    // - Outside follow-up: continuation of an overflow notice paragraph
+    //   (before any blank line gap).
+    if (inFollowUp || !sawBlankAfterNotice) {
+      continue;
+    }
+
+    // Anything else is real file content — not a valid notice chain.
+    return false;
+  }
+
+  return true;
+}
+
+// ── Public API ──────────────────────────────────────────────────────────
+
+/**
+ * Find the character index where the system notice suffix begins.
+ *
+ * Returns the EARLIEST position where a genuine notice candidate starts
+ * and everything from that position to end-of-text is exclusively
+ * notice-chain content.  This ensures that when multiple notices are
+ * chained (e.g. repeated-tool warning + follow-up notice), ALL of them
+ * are captured in the suffix.
+ *
+ * For tools whose result may contain file content (e.g. astrbot_file_read_tool,
+ * astrbot_file_edit_tool), the raw result can include literal
+ * `[SYSTEM NOTICE]` strings or overflow-notice-like text that are part of
+ * the file being read/edited, not a system message.  These are rejected
+ * because the region from the fake notice to end-of-text contains real
+ * file content.
+ *
+ * **Strategy** (first valid candidate wins):
+ *   1. Find all `[SYSTEM NOTICE]` markers in the text (in order).
+ *   2. For each genuine marker (earliest first), check if the region from
+ *      that position to end-of-text is a valid notice chain.
+ *   3. Return the first position that passes.
+ *   4. If no `[SYSTEM NOTICE]` passes, check for overflow notice.
+ *   5. If nothing passes, return -1.
+ *
+ * @returns The character index where the notice suffix begins, or -1.
+ */
+export function findSystemNoticeIndex(text: string): number {
+  // ── Collect all candidates and sort by position ascending ─────────
+  const positions: { pos: number; type: "system" | "overflow" }[] = [];
+
+  let searchFrom = 0;
+  while (searchFrom < text.length) {
+    const idx = text.indexOf(MARKER, searchFrom);
+    if (idx < 0) break;
+    positions.push({ pos: idx, type: "system" });
+    searchFrom = idx + MARKER.length;
+  }
+
+  searchFrom = 0;
+  while (searchFrom < text.length) {
+    const idx = text.indexOf(OVERFLOW_NOTICE_PREFIX, searchFrom);
+    if (idx < 0) break;
+    positions.push({ pos: idx, type: "overflow" });
+    searchFrom = idx + OVERFLOW_NOTICE_PREFIX.length;
+  }
+
+  positions.sort((a, b) => a.pos - b.pos);
+
+  // ── Check each candidate (earliest first) ────────────────────────
+  for (const { pos, type } of positions) {
+    // Quick prefix check — skip non-genuine candidates.
+    if (type === "system" && !isGenuineSystemNotice(text, pos)) continue;
+
+    if (isNoticeChainRegion(text, pos)) {
+      return pos;
+    }
+  }
+
+  return -1;
+}
+
+/**
+ * Split tool result text into the main content and the optional
+ * system notice suffix.
+ *
+ * @param text  The raw tool result text.
+ * @returns An object with `content` (the main result) and `notice`
+ *          (the system notice string, or null if none).
+ */
+export function splitSystemNotice(
+  text: string,
+): { content: string; notice: string | null } {
+  const idx = findSystemNoticeIndex(text);
+  if (idx < 0) return { content: text, notice: null };
+  return {
+    content: text.slice(0, idx).trim(),
+    notice: text.slice(idx).trim(),
+  };
+}