dskcode 0.1.18 → 0.1.19

package/dist/index.js

@@ -773,7 +773,7 @@ async function getAllSkills(cwd) {
 }
 
 // src/cli/index.tsx
-import { readFile as readFile8 } from "fs/promises";
+import { readFile as readFile10 } from "fs/promises";
 import { join as join9 } from "path";
 
 // src/ui/RenderScope.tsx
@@ -1168,7 +1168,7 @@ function ToolCallBlock({ call, showPendingHint = true }) {
       ] })
     ] }),
     /* @__PURE__ */ jsx3(Box3, { flexDirection: "column", children: /* @__PURE__ */ jsx3(Text4, { color: "#888888", children: argsDisplay }) }),
-    showPendingHint && /* @__PURE__ */ jsx3(Box3, { children: /* @__PURE__ */ jsx3(Text4, { color: "yellow", children: "\u23F3 \u7B49\u5F85\u6267\u884C\uFF08\u5DE5\u5177\u7CFB\u7EDF\u5C06\u5728\u7B2C08\u7AE0\u5B9E\u73B0\uFF09" }) })
+    showPendingHint && /* @__PURE__ */ jsx3(Box3, { children: /* @__PURE__ */ jsx3(Text4, { color: "yellow", children: "\u23F3 \u7B49\u5F85\u6267\u884C" }) })
   ] });
 }
 
@@ -1306,12 +1306,12 @@ function DiffPreview({ diff }) {
         ")"
       ] })
     ] }),
-    /* @__PURE__ */ jsx5(Box5, { flexDirection: "column", marginLeft: 2, children: lines.map((line, i) => /* @__PURE__ */ jsx5(DiffLine, { line }, i)) })
+    /* @__PURE__ */ jsx5(Box5, { flexDirection: "column", marginLeft: 2, children: lines.filter((line) => !line.startsWith("---") && !line.startsWith("+++")).map((line, i) => /* @__PURE__ */ jsx5(DiffLine, { line }, i)) })
   ] });
 }
 function DiffLine({ line }) {
   if (line.startsWith("---") || line.startsWith("+++")) {
-    return /* @__PURE__ */ jsx5(Text6, { color: "#00cccc", bold: true, children: line });
+    return null;
   }
   if (line.startsWith("@@")) {
     return /* @__PURE__ */ jsx5(Text6, { color: "#00cccc", children: line });
@@ -1628,6 +1628,13 @@ var ToolRegistry = class {
   }
 };
 
+// src/tool/types.ts
+var AlwaysAllowGate = class {
+  check(_toolName, _args) {
+    return true;
+  }
+};
+
 // src/agent/index.ts
 var Session = class {
   #messages = [];
@@ -1636,6 +1643,8 @@ var Session = class {
   #costTracker;
   #options;
   #abortController = new AbortController();
+  // 风暴检测：记录每轮的工具调用错误
+  #stormRecords = [];
   constructor(provider, tools = [], costTracker, options) {
     this.#provider = provider;
     if (tools instanceof ToolRegistry) {
@@ -1650,7 +1659,9 @@ var Session = class {
       maxToolRounds: options?.maxToolRounds ?? 20,
       reservedForOutput: options?.reservedForOutput ?? 4096,
       preserveRecentRounds: options?.preserveRecentRounds ?? 10,
-      projectContext: options?.projectContext
+      projectContext: options?.projectContext,
+      gate: options?.gate ?? new AlwaysAllowGate(),
+      writeRoots: options?.writeRoots ?? [options?.cwd ?? process.cwd()]
     };
   }
   // -------------------------------------------------------------------------
@@ -1686,20 +1697,6 @@ var Session = class {
    *    c. 如果有工具调用 → 执行工具 → 追加结果 → 继续循环
    *    d. 如果没有工具调用 → 退出循环
    * 3. yield done 事件
-   *
-   * 调用方式：
-   * ```ts
-   * for await (const event of session.chat("你好")) {
-   *   switch (event.type) {
-   *     case "text_delta":  // 追加文本
-   *     case "tool_calls":  // 展示工具调用
-   *     case "tool_result": // 工具执行结果
-   *     case "usage":       // 记录使用量
-   *     case "done":        // 本轮完成
-   *     case "error":       // 处理错误
-   *   }
-   * }
-   * ```
    */
   async *chat(userInput) {
     this.#messages.push({ role: "user", content: userInput });
@@ -1757,30 +1754,31 @@ var Session = class {
         this.#messages.push(assistantMsg);
         if (lastToolCalls && lastToolCalls.length > 0) {
           yield { type: "tool_calls", calls: lastToolCalls };
-          const toolCtx = {
-            cwd: this.#options.cwd,
-            signal: this.#abortController.signal
-          };
-          for (const tc of lastToolCalls) {
-            let toolArgs;
-            try {
-              toolArgs = tc.arguments ? JSON.parse(tc.arguments) : {};
-            } catch {
-              toolArgs = {};
-            }
-            const result = await this.#toolRegistry.execute(tc.name, toolArgs, toolCtx);
-            yield { type: "tool_result", name: tc.name, result };
-            let toolContent = result.data;
-            if (result.diff && result.diff.patch) {
+          const stormBroken = this.#checkStormBreak(lastToolCalls);
+          if (stormBroken) {
+            const stormMsg = "\n\u26A0\uFE0F \u540C\u4E00\u5DE5\u5177\u91CD\u590D\u51FA\u9519\uFF0C\u5DF2\u5F3A\u5236\u5207\u6362\u7B56\u7565\n";
+            yield { type: "text_delta", content: stormMsg };
+            assistantMsg.toolCalls = void 0;
+            assistantMsg.content += stormMsg;
+            this.#stormRecords = [];
+            toolRounds++;
+            continue;
+          }
+          const results = await this.#executeBatch(lastToolCalls);
+          this.#stormRecords = results.records;
+          for (const item of results.items) {
+            yield { type: "tool_result", name: item.name, result: item.result };
+            let toolContent = item.result.data;
+            if (item.result.diff && item.result.diff.patch) {
               toolContent += `
 
-${result.diff.patch}`;
+${item.result.diff.patch}`;
             }
             this.#messages.push({
               role: "tool",
               content: toolContent,
-              toolCallId: tc.id,
-              name: tc.name
+              toolCallId: item.callId,
+              name: item.name
             });
           }
           toolRounds++;
@@ -1805,6 +1803,123 @@ ${result.diff.patch}`;
     yield { type: "done", elapsed };
   }
   // -------------------------------------------------------------------------
+  // 工具执行 — 批量、并行/串行、Gate、风暴检测
+  // -------------------------------------------------------------------------
+  /**
+   * 执行一批工具调用。
+   *
+   * 并行策略：
+   * - 如果这批工具全部是 ReadOnly 的，并行执行（最多 8 并发）
+   * - 否则按顺序串行执行，保证写/读顺序
+   */
+  async #executeBatch(calls) {
+    const toolCtx = {
+      cwd: this.#options.cwd,
+      signal: this.#abortController.signal
+    };
+    const allReadOnly = calls.every((tc) => {
+      const tool = this.#toolRegistry.get(tc.name);
+      return tool?.readOnly === true;
+    });
+    if (allReadOnly && calls.length > 1) {
+      const MAX_PARALLEL = 8;
+      const items2 = [];
+      const records2 = [];
+      for (let i = 0; i < calls.length; i += MAX_PARALLEL) {
+        const batch = calls.slice(i, i + MAX_PARALLEL);
+        const promises = batch.map((tc) => this.#executeOne(tc, toolCtx));
+        const batchResults = await Promise.all(promises);
+        for (const r of batchResults) {
+          items2.push(r.item);
+          records2.push(r.record);
+        }
+      }
+      return { items: items2, records: records2 };
+    }
+    const items = [];
+    const records = [];
+    for (const tc of calls) {
+      const r = await this.#executeOne(tc, toolCtx);
+      items.push(r.item);
+      records.push(r.record);
+    }
+    return { items, records };
+  }
+  /**
+   * 执行单个工具调用，包含 Gate 检查和预览。
+   */
+  async #executeOne(tc, ctx) {
+    const toolName = tc.name;
+    const timestamp = Date.now();
+    const tool = this.#toolRegistry.get(toolName);
+    if (!tool) {
+      const errMsg = `\u5DE5\u5177 "${toolName}" \u4E0D\u5B58\u5728\u6216\u5DF2\u88AB\u7981\u7528`;
+      return {
+        item: { name: toolName, callId: tc.id, result: { success: false, data: errMsg, error: "TOOL_NOT_FOUND" } },
+        record: { name: toolName, success: false, error: "TOOL_NOT_FOUND", timestamp }
+      };
+    }
+    let toolArgs;
+    try {
+      toolArgs = tc.arguments ? JSON.parse(tc.arguments) : {};
+    } catch {
+      toolArgs = {};
+    }
+    const gateResult = await this.#options.gate.check(toolName, toolArgs);
+    if (!gateResult) {
+      const errMsg = `\u5DE5\u5177 "${toolName}" \u88AB\u6743\u9650\u95E8\u62D2\u7EDD`;
+      return {
+        item: { name: toolName, callId: tc.id, result: { success: false, data: errMsg, error: "GATE_DENIED" } },
+        record: { name: toolName, success: false, error: "GATE_DENIED", timestamp }
+      };
+    }
+    if (!tool.readOnly) {
+      const maybePreviewer = tool;
+      if (typeof maybePreviewer.preview === "function") {
+        try {
+          await maybePreviewer.preview(toolArgs, ctx);
+        } catch {
+        }
+      }
+    }
+    try {
+      const result = await tool.execute(toolArgs, ctx);
+      return {
+        item: { name: toolName, callId: tc.id, result },
+        record: {
+          name: toolName,
+          success: result.success,
+          error: result.error,
+          timestamp
+        }
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      const errorResult = { success: false, data: `\u5DE5\u5177 "${toolName}" \u6267\u884C\u5F02\u5E38\uFF1A${message}`, error: "EXECUTION_ERROR" };
+      return {
+        item: { name: toolName, callId: tc.id, result: errorResult },
+        record: { name: toolName, success: false, error: "EXECUTION_ERROR", timestamp }
+      };
+    }
+  }
+  // -------------------------------------------------------------------------
+  // 风暴检测 — 同一工具同一错误连续 3 次 → 强制换策略
+  // -------------------------------------------------------------------------
+  /**
+   * 连续 3 次同一工具同一错误 → 触发风暴中断。
+   */
+  #checkStormBreak(currentCalls) {
+    if (this.#stormRecords.length < 3) return false;
+    const recentErrors = this.#stormRecords.slice(-3);
+    if (recentErrors.length < 3) return false;
+    const first = recentErrors[0];
+    const allSame = recentErrors.every(
+      (r) => r.name === first.name && r.error === first.error && !r.success
+    );
+    if (!allSame) return false;
+    return currentCalls.some((tc) => tc.name === first.name);
+  }
+  // -------------------------------------------------------------------------
   // 会话管理
   // -------------------------------------------------------------------------
   /** 取消正在进行的流式请求 */
@@ -1815,6 +1930,7 @@ ${result.diff.patch}`;
   reset() {
     this.#messages.length = 0;
     this.#costTracker.resetSession();
+    this.#stormRecords = [];
   }
   // -------------------------------------------------------------------------
   // 内部方法
@@ -1850,6 +1966,7 @@ ${result.diff.patch}`;
 
 // src/tool/sandbox.ts
 import { resolve, relative, isAbsolute } from "path";
+import { realpath as realpath2 } from "fs/promises";
 import { spawn } from "child_process";
 import process2 from "process";
 var DEFAULT_TIMEOUT_MS = 3e4;
@@ -1858,18 +1975,14 @@ var DEFAULT_MAX_FILE_SIZE = 10 * 1024 * 1024;
 var isWindows = process2.platform === "win32";
 function resolvePath(inputPath, cwd) {
   const resolved = isAbsolute(inputPath) ? inputPath : resolve(cwd, inputPath);
-  const normalized = resolve(resolved);
-  const rel = relative(cwd, normalized);
-  if (rel.startsWith("..") || normalized !== resolve(cwd) && !rel) {
-  }
-  return normalized;
+  return resolve(resolved);
 }
 function truncateOutput(content, maxLength = DEFAULT_MAX_OUTPUT_LENGTH) {
   if (content.length <= maxLength) return content;
   const truncated = content.slice(0, maxLength);
   return `${truncated}
 
-... [\u8F93\u51FA\u8FC7\u957F\uFF0C\u5DF2\u622A\u65AD\uFF0C\u5171 ${content.length} \u5B57\u7B26]`;
+... [\u8F93\u51FA\u8FC7\u957F\uFF0C\u5DF2\u622A\u65AD\uFF0C\u5171 ${String(content.length)} \u5B57\u7B26]`;
 }
 function getDefaultTimeout() {
   return DEFAULT_TIMEOUT_MS;
@@ -1930,97 +2043,119 @@ async function execCommand(command, args, cwd, timeoutMs = DEFAULT_TIMEOUT_MS, s
 }
 
 // src/tool/diff.ts
-function computeFileDiff(oldContent, newContent, filePath) {
-  if (oldContent === newContent) {
-    return {
-      filePath,
-      patch: "",
-      existedBefore: oldContent.length > 0,
-      additions: 0,
-      deletions: 0
-    };
-  }
-  if (oldContent.length === 0) {
-    const newLines2 = splitLines(newContent);
-    const patch2 = formatNewFileDiff(newLines2, filePath);
-    return {
-      filePath,
-      patch: patch2,
-      existedBefore: false,
-      additions: newLines2.length,
-      deletions: 0
-    };
-  }
-  if (newContent.length === 0) {
-    const oldLines2 = splitLines(oldContent);
-    const patch2 = formatDeletedFileDiff(oldLines2, filePath);
-    return {
-      filePath,
-      patch: patch2,
-      existedBefore: true,
-      additions: 0,
-      deletions: oldLines2.length
-    };
-  }
-  const oldLines = splitLines(oldContent);
-  const newLines = splitLines(newContent);
-  const diffLines = computeLineDiff(oldLines, newLines);
-  let additions = 0;
-  let deletions = 0;
-  for (const line of diffLines) {
-    if (line.op === "add") additions++;
-    if (line.op === "remove") deletions++;
-  }
-  const hunks = groupIntoHunks(diffLines);
-  const patch = formatUnifiedDiff(hunks, filePath);
-  return {
-    filePath,
-    patch,
-    existedBefore: true,
-    additions,
-    deletions
-  };
-}
 function splitLines(text) {
-  const raw = text.split("\n");
-  if (text.endsWith("\n") && raw.length > 0 && raw[raw.length - 1] === "") {
-    return raw.slice(0, -1);
+  if (text.length === 0) {
+    return { lines: [], eol: "\n", eofStyle: "no-eol" };
+  }
+  const crlfIdx = text.indexOf("\r\n");
+  const lfIdx = text.indexOf("\n");
+  let eol;
+  if (crlfIdx !== -1 && (lfIdx === -1 || crlfIdx <= lfIdx)) {
+    eol = "\r\n";
+  } else if (lfIdx !== -1) {
+    eol = "\n";
+  } else {
+    eol = "\n";
+  }
+  const lines = text.split(eol);
+  let eofStyle;
+  if (text.endsWith(eol)) {
+    if (lines.length > 0 && lines[lines.length - 1] === "") {
+      lines.pop();
+    }
+    eofStyle = "lf";
+  } else {
+    eofStyle = "no-eol";
   }
-  return raw;
+  return { lines, eol, eofStyle };
 }
 function computeLineDiff(oldLines, newLines) {
   const N = oldLines.length;
   const M = newLines.length;
-  const dp = [];
-  for (let i2 = 0; i2 <= N; i2++) {
-    dp[i2] = new Array(M + 1).fill(0);
-  }
-  for (let i2 = 1; i2 <= N; i2++) {
-    for (let j2 = 1; j2 <= M; j2++) {
-      if (oldLines[i2 - 1] === newLines[j2 - 1]) {
-        dp[i2][j2] = dp[i2 - 1][j2 - 1] + 1;
-      } else {
-        dp[i2][j2] = Math.max(dp[i2 - 1][j2], dp[i2][j2 - 1]);
+  if (N === 0 && M === 0) return [];
+  if (N === 0) return newLines.map((line) => ({ op: "add", line }));
+  if (M === 0) return oldLines.map((line) => ({ op: "remove", line }));
+  const trace = [];
+  const maxD = N + M;
+  const V = new Array(2 * maxD + 2).fill(-1);
+  const offset = maxD;
+  V[offset + 1] = 0;
+  outer:
+    for (let d = 0; d <= maxD; d++) {
+      const snapshot = /* @__PURE__ */ new Map();
+      const kStart = -d;
+      const kEnd = d;
+      for (let k = kStart; k <= kEnd; k += 2) {
+        const ki = k + offset;
+        let x;
+        if (k === -d || k !== d && V[ki - 1] < V[ki + 1]) {
+          x = V[ki + 1];
+        } else {
+          x = V[ki - 1] + 1;
+        }
+        let y = x - k;
+        while (x < N && y < M && oldLines[x] === newLines[y]) {
+          x++;
+          y++;
+        }
+        V[ki] = x;
+        snapshot.set(k, x);
+        if (x >= N && y >= M) {
+          trace.push(snapshot);
+          return backtrack(trace, N, M, oldLines, newLines, offset);
+        }
       }
+      trace.push(snapshot);
     }
-  }
+  return oldLines.map((line) => ({ op: "remove", line })).concat(newLines.map((line) => ({ op: "add", line })));
+}
+function backtrack(trace, N, M, oldLines, newLines, offset) {
   const result = [];
-  let i = N;
-  let j = M;
-  while (i > 0 || j > 0) {
-    const oldLine = i > 0 ? oldLines[i - 1] : void 0;
-    const newLine = j > 0 ? newLines[j - 1] : void 0;
-    if (i > 0 && j > 0 && oldLine !== void 0 && newLine !== void 0 && oldLine === newLine) {
-      result.unshift({ op: "equal", line: oldLine });
-      i--;
-      j--;
-    } else if (j > 0 && (i === 0 || dp[i][j - 1] >= dp[i - 1][j])) {
-      result.unshift({ op: "add", line: newLines[j - 1] });
-      j--;
+  let x = N;
+  let y = M;
+  for (let d = trace.length - 1; d >= 1; d--) {
+    const k = x - y;
+    const prevSnapshot = d > 0 ? trace[d - 1] : /* @__PURE__ */ new Map();
+    const prevKDown = prevSnapshot.get(k - 1);
+    const prevKUp = prevSnapshot.get(k + 1);
+    let prevK;
+    if (k === -d) {
+      prevK = k + 1;
+    } else if (k === d) {
+      prevK = k - 1;
+    } else if ((prevKDown ?? -1) < (prevKUp ?? -1)) {
+      prevK = k + 1;
     } else {
-      result.unshift({ op: "remove", line: oldLines[i - 1] });
-      i--;
+      prevK = k - 1;
     }
+    const prevX = prevSnapshot.get(prevK) ?? 0;
+    const prevY = prevX - prevK;
+    if (prevK === k - 1) {
+      while (x > prevX + 1 && y > prevY) {
+        x--;
+        y--;
+        result.unshift({ op: "equal", line: oldLines[x] });
+      }
+      if (x > prevX) {
+        x--;
+        result.unshift({ op: "remove", line: oldLines[x] });
+      }
+    } else {
+      while (x > prevX && y > prevY + 1) {
+        x--;
+        y--;
+        result.unshift({ op: "equal", line: oldLines[x] });
+      }
+      if (y > prevY) {
+        y--;
+        result.unshift({ op: "add", line: newLines[y] });
+      }
+    }
+  }
+  while (x > 0 && y > 0) {
+    x--;
+    y--;
+    result.unshift({ op: "equal", line: oldLines[x] });
   }
   return result;
 }
@@ -2029,21 +2164,24 @@ function groupIntoHunks(diffLines) {
   if (diffLines.length === 0) return [];
   const changeIndices = [];
   for (let i = 0; i < diffLines.length; i++) {
-    if (diffLines[i].op !== "equal") {
+    const line = diffLines[i];
+    if (line.op !== "equal") {
       changeIndices.push(i);
     }
   }
   if (changeIndices.length === 0) return [];
   const groups = [[changeIndices[0]]];
   for (let idx = 1; idx < changeIndices.length; idx++) {
-    const prevIdx = groups[groups.length - 1][groups[groups.length - 1].length - 1];
+    const lastGroup = groups[groups.length - 1];
+    const prevIdx = lastGroup[lastGroup.length - 1];
     const currIdx = changeIndices[idx];
     let gap = 0;
     for (let k = prevIdx + 1; k < currIdx; k++) {
-      if (diffLines[k].op === "equal") gap++;
+      const line = diffLines[k];
+      if (line.op === "equal") gap++;
     }
     if (gap <= 2 * CONTEXT_LINES) {
-      groups[groups.length - 1].push(currIdx);
+      lastGroup.push(currIdx);
     } else {
       groups.push([currIdx]);
     }
@@ -2058,15 +2196,15 @@ function groupIntoHunks(diffLines) {
     let oldLine = 0;
     let newLine = 0;
     for (let i = 0; i < startIdx; i++) {
-      const op = diffLines[i].op;
-      if (op === "equal" || op === "remove") oldLine++;
-      if (op === "equal" || op === "add") newLine++;
+      const line = diffLines[i];
+      if (line.op === "equal" || line.op === "remove") oldLine++;
+      if (line.op === "equal" || line.op === "add") newLine++;
     }
     let oldCount = 0;
     let newCount = 0;
-    for (const line of lines) {
-      if (line.op === "equal" || line.op === "remove") oldCount++;
-      if (line.op === "equal" || line.op === "add") newCount++;
+    for (const diffLine of lines) {
+      if (diffLine.op === "equal" || diffLine.op === "remove") oldCount++;
+      if (diffLine.op === "equal" || diffLine.op === "add") newCount++;
     }
     hunks.push({
       oldStart: oldLine + 1,
@@ -2085,17 +2223,19 @@ function formatUnifiedDiff(hunks, filePath) {
   parts.push(`--- a/${fileName}`);
   parts.push(`+++ b/${fileName}`);
   for (const hunk of hunks) {
-    parts.push(`@@ -${hunk.oldStart},${hunk.oldCount} +${hunk.newStart},${hunk.newCount} @@`);
-    for (const line of hunk.lines) {
-      switch (line.op) {
+    parts.push(
+      `@@ -${String(hunk.oldStart)},${String(hunk.oldCount)} +${String(hunk.newStart)},${String(hunk.newCount)} @@`
+    );
+    for (const diffLine of hunk.lines) {
+      switch (diffLine.op) {
         case "equal":
-          parts.push(` ${line.line}`);
+          parts.push(` ${diffLine.line}`);
           break;
         case "remove":
-          parts.push(`-${line.line}`);
+          parts.push(`-${diffLine.line}`);
           break;
         case "add":
-          parts.push(`+${line.line}`);
+          parts.push(`+${diffLine.line}`);
           break;
       }
     }
@@ -2107,7 +2247,7 @@ function formatNewFileDiff(lines, filePath) {
   const parts = [];
   parts.push(`--- /dev/null`);
   parts.push(`+++ b/${fileName}`);
-  parts.push(`@@ -0,0 +1,${lines.length} @@`);
+  parts.push(`@@ -0,0 +1,${String(lines.length)} @@`);
   for (const line of lines) {
     parts.push(`+${line}`);
   }
@@ -2118,7 +2258,7 @@ function formatDeletedFileDiff(lines, filePath) {
   const parts = [];
   parts.push(`--- a/${fileName}`);
   parts.push(`+++ /dev/null`);
-  parts.push(`@@ -1,${lines.length} +0,0 @@`);
+  parts.push(`@@ -1,${String(lines.length)} +0,0 @@`);
   for (const line of lines) {
     parts.push(`-${line}`);
   }
@@ -2128,10 +2268,62 @@ function extractFileName(filePath) {
   const normalized = filePath.replace(/\\/g, "/");
   return normalized.split("/").pop() ?? filePath;
 }
+function computeFileDiff(oldContent, newContent, filePath) {
+  if (oldContent === newContent) {
+    return {
+      filePath,
+      patch: "",
+      existedBefore: oldContent.length > 0,
+      additions: 0,
+      deletions: 0
+    };
+  }
+  if (oldContent.length === 0) {
+    const split = splitLines(newContent);
+    const patch2 = formatNewFileDiff(split.lines, filePath);
+    return {
+      filePath,
+      patch: patch2,
+      existedBefore: false,
+      additions: split.lines.length,
+      deletions: 0
+    };
+  }
+  if (newContent.length === 0) {
+    const split = splitLines(oldContent);
+    const patch2 = formatDeletedFileDiff(split.lines, filePath);
+    return {
+      filePath,
+      patch: patch2,
+      existedBefore: true,
+      additions: 0,
+      deletions: split.lines.length
+    };
+  }
+  const oldSplit = splitLines(oldContent);
+  const newSplit = splitLines(newContent);
+  const diffLines = computeLineDiff(oldSplit.lines, newSplit.lines);
+  let additions = 0;
+  let deletions = 0;
+  for (const line of diffLines) {
+    if (line.op === "add") additions++;
+    if (line.op === "remove") deletions++;
+  }
+  const hunks = groupIntoHunks(diffLines);
+  const patch = formatUnifiedDiff(hunks, filePath);
+  return {
+    filePath,
+    patch,
+    existedBefore: true,
+    additions,
+    deletions
+  };
+}
 
 // src/tool/builtins/read-file.ts
-import { readFile as readFile4 } from "fs/promises";
-import { stat } from "fs/promises";
+import { readFile as readFile4, stat } from "fs/promises";
+import { open } from "fs/promises";
+import { relative as relative2 } from "path";
 var readFileSchema = {
   type: "object",
   properties: {
@@ -2139,11 +2331,11 @@ var readFileSchema = {
       type: "string",
       description: "\u6587\u4EF6\u8DEF\u5F84\uFF08\u76F8\u5BF9\u4E8E\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\u6216\u7EDD\u5BF9\u8DEF\u5F84\uFF09"
     },
-    start_line: {
+    startLine: {
       type: "number",
       description: "\u8D77\u59CB\u884C\u53F7\uFF08\u4ECE 1 \u5F00\u59CB\uFF09\uFF0C\u9ED8\u8BA4\u4E3A 1"
     },
-    end_line: {
+    endLine: {
       type: "number",
       description: "\u7ED3\u675F\u884C\u53F7\uFF08\u5305\u542B\uFF09\uFF0C\u9ED8\u8BA4\u5230\u6587\u4EF6\u672B\u5C3E"
     }
@@ -2151,10 +2343,21 @@ var readFileSchema = {
   required: ["path"],
   additionalProperties: false
 };
+async function checkBinary(filePath) {
+  const fileHandle = await open(filePath, "r");
+  try {
+    const buffer = Buffer.alloc(8192);
+    const { bytesRead } = await fileHandle.read(buffer, 0, 8192, 0);
+    return buffer.subarray(0, bytesRead).includes(0);
+  } finally {
+    await fileHandle.close();
+  }
+}
 var readFileTool = {
   name: "read_file",
-  description: "\u8BFB\u53D6\u6307\u5B9A\u8DEF\u5F84\u7684\u6587\u4EF6\u5185\u5BB9\u3002\u652F\u6301\u884C\u53F7\u8303\u56F4\u9009\u62E9\uFF0C\u8F93\u51FA\u5E26\u884C\u53F7\u3002\u9002\u7528\u4E8E\u67E5\u770B\u6E90\u4EE3\u7801\u3001\u914D\u7F6E\u6587\u4EF6\u7B49\u6587\u672C\u6587\u4EF6\u3002",
+  description: "\u8BFB\u53D6\u6307\u5B9A\u8DEF\u5F84\u7684\u6587\u4EF6\u5185\u5BB9\u3002\u652F\u6301\u884C\u53F7\u8303\u56F4\u9009\u62E9\uFF0C\u8F93\u51FA\u5E26\u884C\u53F7\u3002\u9002\u7528\u4E8E\u67E5\u770B\u6E90\u4EE3\u7801\u3001\u914D\u7F6E\u6587\u4EF6\u7B49\u6587\u672C\u6587\u4EF6\u3002\u81EA\u52A8\u62D2\u7EDD\u4E8C\u8FDB\u5236\u6587\u4EF6\u3002",
   parameters: readFileSchema,
+  readOnly: true,
   async execute(args, ctx) {
     const params = args;
     if (!params?.path || typeof params.path !== "string") {
@@ -2171,19 +2374,46 @@ var readFileTool = {
           error: "FILE_TOO_LARGE"
         };
       }
+      if (fileStat.isDirectory()) {
+        return {
+          success: false,
+          data: `"${filePath}" \u662F\u4E00\u4E2A\u76EE\u5F55\uFF0C\u8BF7\u4F7F\u7528 ls \u5DE5\u5177\u67E5\u770B\u76EE\u5F55\u5185\u5BB9`,
+          error: "IS_DIRECTORY"
+        };
+      }
+      if (fileStat.size > 0) {
+        const isBin = await checkBinary(filePath);
+        if (isBin) {
+          return {
+            success: false,
+            data: `"${filePath}" \u770B\u8D77\u6765\u662F\u4E8C\u8FDB\u5236\u6587\u4EF6\uFF0C\u4E0D\u652F\u6301\u8BFB\u53D6`,
+            error: "BINARY_FILE"
+          };
+        }
+      }
       const content = await readFile4(filePath, "utf-8");
       const lines = content.split("\n");
-      const startLine = Math.max(1, params.start_line ?? 1) - 1;
-      const endLine = params.end_line ? Math.min(params.end_line, lines.length) : lines.length;
+      if (lines.length > 0 && lines[lines.length - 1] === "" && content.endsWith("\n")) {
+        lines.pop();
+      }
+      const startLine = Math.max(1, params.startLine ?? 1) - 1;
+      const endLine = params.endLine ? Math.min(params.endLine, lines.length) : lines.length;
       const selectedLines = lines.slice(startLine, endLine);
       const lineNumWidth = String(endLine).length;
       const result = selectedLines.map((line, i) => {
         const lineNum = String(startLine + i + 1).padStart(lineNumWidth, " ");
-        return `${lineNum} | ${line}`;
+        return `${lineNum}\u2192${line}`;
       }).join("\n");
+      const remaining = lines.length - endLine;
+      const tailHint = remaining > 0 ? `
+
+[\u8FD8\u6709 ${remaining} \u884C\uFF1B\u4F7F\u7528 startLine=${endLine + 1} \u7EE7\u7EED\u67E5\u770B]` : "";
+      const relPath = relative2(ctx.cwd, filePath).replace(/\\/g, "/");
+      const rangeLabel = startLine > 0 || endLine < lines.length ? `\u7B2C ${startLine + 1}-${endLine} \u884C` : `${lines.length} \u884C`;
       return {
         success: true,
-        data: truncateOutput(result)
+        data: truncateOutput(result) + tailHint,
+        summary: `\u{1F4D6} ${relPath}\uFF08${rangeLabel}\uFF09`
       };
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
@@ -2198,7 +2428,7 @@ var readFileTool = {
 
 // src/tool/builtins/write-file.ts
 import { writeFile as writeFile3, mkdir as mkdir4, readFile as readFile5 } from "fs/promises";
-import { dirname } from "path";
+import { dirname, relative as relative3, basename } from "path";
 var writeFileSchema = {
   type: "object",
   properties: {
@@ -2216,8 +2446,9 @@ var writeFileSchema = {
 };
 var writeFileTool = {
   name: "write_file",
-  description: "\u521B\u5EFA\u6216\u8986\u76D6\u6587\u4EF6\u3002\u5982\u679C\u7236\u76EE\u5F55\u4E0D\u5B58\u5728\u4F1A\u81EA\u52A8\u521B\u5EFA\u3002\u9002\u7528\u4E8E\u521B\u5EFA\u65B0\u6587\u4EF6\u6216\u5B8C\u5168\u66FF\u6362\u6587\u4EF6\u5185\u5BB9\u3002",
+  description: "\u521B\u5EFA\u6216\u8986\u76D6\u6587\u4EF6\u3002\u5982\u679C\u7236\u76EE\u5F55\u4E0D\u5B58\u5728\u4F1A\u81EA\u52A8\u521B\u5EFA\u3002\u9002\u7528\u4E8E\u521B\u5EFA\u65B0\u6587\u4EF6\u6216\u5B8C\u5168\u66FF\u6362\u6587\u4EF6\u5185\u5BB9\u3002\u8BF7\u52FF\u7528\u6B64\u5DE5\u5177\u521B\u5EFA _temp_\u3001_debug_ \u7B49\u7528\u4E8E\u8BCA\u65AD/\u8C03\u8BD5\u7684\u4E34\u65F6\u6587\u4EF6\u2014\u2014\u5982\u9700\u8BCA\u65AD\u8BF7\u6539\u7528 bash \u5DE5\u5177\u5185\u8054\u811A\u672C\uFF08node -e\uFF09\u3002",
   parameters: writeFileSchema,
+  readOnly: false,
   async execute(args, ctx) {
     const params = args;
     if (!params?.path || typeof params.path !== "string") {
@@ -2244,9 +2475,12 @@ var writeFileTool = {
       const byteSize = Buffer.byteLength(content, "utf-8");
       const action = existedBefore ? "\u5DF2\u4FEE\u6539" : "\u5DF2\u521B\u5EFA";
       const diffSummary = existedBefore ? `\uFF0C+${diff.additions} -${diff.deletions}` : `\uFF0C+${diff.additions} \u884C\uFF08\u65B0\u5EFA\uFF09`;
+      const fileName = basename(filePath);
+      const summary = existedBefore ? `\u{1F4DD} \u4FEE\u6539: ${fileName} (+${diff.additions} -${diff.deletions})` : `\u{1F4DD} \u65B0\u5EFA: ${fileName} (+${diff.additions} \u884C)`;
       return {
         success: true,
-        data: `\u6587\u4EF6${action}\uFF1A${filePath}\uFF08${lineCount} \u884C\uFF0C${byteSize} \u5B57\u8282${diffSummary}\uFF09`,
+        data: `\u6587\u4EF6${action}\uFF1A${relative3(ctx.cwd, filePath).replace(/\\/g, "/")}\uFF08${lineCount} \u884C\uFF0C${byteSize} \u5B57\u8282${diffSummary}\uFF09`,
+        summary,
         diff
       };
     } catch (err) {
@@ -2262,6 +2496,7 @@ var writeFileTool = {
 
 // src/tool/builtins/edit-file.ts
 import { readFile as readFile6, writeFile as writeFile4 } from "fs/promises";
+import { basename as basename2 } from "path";
 var editFileSchema = {
   type: "object",
   properties: {
@@ -2285,6 +2520,7 @@ var editFileTool = {
   name: "edit_file",
   description: "\u5BF9\u6587\u4EF6\u8FDB\u884C\u7CBE\u786E\u5B57\u7B26\u4E32\u66FF\u6362\u3002\u67E5\u627E\u6587\u4EF6\u4E2D\u7684 old_text \u5E76\u66FF\u6362\u4E3A new_text\u3002\u5982\u679C old_text \u51FA\u73B0\u591A\u6B21\u6216\u672A\u627E\u5230\u5219\u62A5\u9519\u3002\u9002\u7528\u4E8E\u5C0F\u8303\u56F4\u7CBE\u786E\u4FEE\u6539\u3002",
   parameters: editFileSchema,
+  readOnly: false,
   async execute(args, ctx) {
     const params = args;
     if (!params?.path || typeof params.path !== "string") {
@@ -2324,12 +2560,14 @@ var editFileTool = {
       const oldLines = params.old_text.split("\n").length;
       const newLines = params.new_text.split("\n").length;
       const diffSummary = `+${diff.additions} -${diff.deletions}`;
+      const summary = `\u{1F4DD} \u4FEE\u6539: ${basename2(filePath)} (+${diff.additions} -${diff.deletions})`;
       return {
         success: true,
         data: `\u6587\u4EF6\u5DF2\u7F16\u8F91\uFF1A${filePath}
 \u66FF\u6362\u4F4D\u7F6E\uFF1A\u7B2C ${startLine} \u884C
 ${oldLines} \u884C \u2192 ${newLines} \u884C
 \u53D8\u66F4\uFF1A${diffSummary}`,
+        summary,
         diff
       };
     } catch (err) {
@@ -2343,6 +2581,236 @@ ${oldLines} \u884C \u2192 ${newLines} \u884C
   }
 };
 
+// src/tool/builtins/multi-edit.ts
+import { readFile as readFile7, writeFile as writeFile5 } from "fs/promises";
+import { basename as basename3 } from "path";
+var multiEditSchema = {
+  type: "object",
+  properties: {
+    path: {
+      type: "string",
+      description: "\u6587\u4EF6\u8DEF\u5F84\uFF08\u76F8\u5BF9\u4E8E\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\u6216\u7EDD\u5BF9\u8DEF\u5F84\uFF09"
+    },
+    edits: {
+      type: "array",
+      description: "\u6709\u5E8F\u7684\u7F16\u8F91\u6B65\u9AA4\u5217\u8868\u3002\u6BCF\u4E2A\u6B65\u9AA4\u5305\u542B oldText\uFF08\u7CBE\u786E\u5339\u914D\uFF09\u3001newText\uFF08\u66FF\u6362\u5185\u5BB9\uFF09\u548C\u53EF\u9009\u7684 replaceAll\uFF08\u662F\u5426\u66FF\u6362\u6240\u6709\u5339\u914D\u9879\uFF09",
+      items: {
+        type: "object",
+        properties: {
+          oldText: { type: "string", description: "\u8981\u67E5\u627E\u7684\u539F\u59CB\u6587\u672C\uFF08\u7CBE\u786E\u5339\u914D\uFF09" },
+          newText: { type: "string", description: "\u66FF\u6362\u540E\u7684\u65B0\u6587\u672C" },
+          replaceAll: { type: "boolean", description: "\u662F\u5426\u66FF\u6362\u6240\u6709\u5339\u914D\u9879\uFF0C\u9ED8\u8BA4 false" }
+        },
+        required: ["oldText", "newText"],
+        additionalProperties: false
+      }
+    }
+  },
+  required: ["path", "edits"],
+  additionalProperties: false
+};
+var multiEditTool = {
+  name: "multi_edit",
+  description: "\u5BF9\u6587\u4EF6\u8FDB\u884C\u539F\u5B50\u6279\u91CF\u66FF\u6362\u7F16\u8F91\u3002\u5728\u4E00\u4E2A\u8BF7\u6C42\u4E2D\u6267\u884C\u591A\u4E2A\u7CBE\u786E\u66FF\u6362\uFF0C\u4EFB\u4E00\u5931\u8D25\u5219\u5168\u90E8\u56DE\u6EDA\u3002\u652F\u6301 replaceAll \u53C2\u6570\u505A\u5168\u5C40\u66FF\u6362\u3002\u9002\u7528\u4E8E\u9700\u8981\u540C\u65F6\u4FEE\u6539\u6587\u4EF6\u591A\u5904\u7684\u573A\u666F\u3002",
+  parameters: multiEditSchema,
+  readOnly: false,
+  async execute(args, ctx) {
+    const params = args;
+    if (!params?.path || typeof params.path !== "string") {
+      return { success: false, data: "\u7F3A\u5C11\u5FC5\u8981\u53C2\u6570 path", error: "INVALID_ARGS" };
+    }
+    if (!Array.isArray(params.edits) || params.edits.length === 0) {
+      return { success: false, data: "\u7F3A\u5C11\u5FC5\u8981\u53C2\u6570 edits\uFF08\u975E\u7A7A\u6570\u7EC4\uFF09", error: "INVALID_ARGS" };
+    }
+    const filePath = resolvePath(params.path, ctx.cwd);
+    try {
+      const originalContent = await readFile7(filePath, "utf-8");
+      let currentContent = originalContent;
+      for (let idx = 0; idx < params.edits.length; idx++) {
+        const step = params.edits[idx];
+        if (typeof step.oldText !== "string") {
+          return {
+            success: false,
+            data: `\u7B2C ${idx + 1} \u6B65\uFF1A\u7F3A\u5C11\u6709\u6548\u7684 oldText`,
+            error: "INVALID_STEP_ARGS"
+          };
+        }
+        if (step.replaceAll) {
+          let count = 0;
+          let pos = -1;
+          while ((pos = currentContent.indexOf(step.oldText, pos + 1)) !== -1) {
+            count++;
+          }
+          if (count === 0) {
+            return {
+              success: false,
+              data: `\u7B2C ${idx + 1} \u6B65\uFF1A\u672A\u627E\u5230\u8981\u66FF\u6362\u7684\u6587\u672C\uFF0C\u8BF7\u786E\u8BA4 oldText \u4E0E\u6587\u4EF6\u5185\u5BB9\u5B8C\u5168\u4E00\u81F4`,
+              error: "TEXT_NOT_FOUND"
+            };
+          }
+          currentContent = currentContent.split(step.oldText).join(step.newText);
+        } else {
+          const firstIdx = currentContent.indexOf(step.oldText);
+          if (firstIdx === -1) {
+            return {
+              success: false,
+              data: `\u7B2C ${idx + 1} \u6B65\uFF1A\u672A\u627E\u5230\u8981\u66FF\u6362\u7684\u6587\u672C\u3002\u8BF7\u786E\u8BA4 oldText \u4E0E\u6587\u4EF6\u5185\u5BB9\u5B8C\u5168\u4E00\u81F4\uFF08\u5305\u62EC\u7F29\u8FDB\u548C\u7A7A\u683C\uFF09\u3002`,
+              error: "TEXT_NOT_FOUND"
+            };
+          }
+          const secondIdx = currentContent.indexOf(step.oldText, firstIdx + 1);
+          if (secondIdx !== -1) {
+            return {
+              success: false,
+              data: `\u7B2C ${idx + 1} \u6B65\uFF1A\u8981\u66FF\u6362\u7684\u6587\u672C\u5728\u6587\u4EF6\u4E2D\u51FA\u73B0\u591A\u6B21\uFF0C\u8BF7\u63D0\u4F9B\u66F4\u591A\u4E0A\u4E0B\u6587\u4EE5\u7CBE\u786E\u5B9A\u4F4D\uFF0C\u6216\u8BBE\u7F6E replaceAll=true`,
+              error: "TEXT_MULTIPLE_MATCHES"
+            };
+          }
+          currentContent = currentContent.replace(step.oldText, step.newText);
+        }
+      }
+      await writeFile5(filePath, currentContent, "utf-8");
+      const diff = computeFileDiff(originalContent, currentContent, filePath);
+      diff.existedBefore = true;
+      return {
+        success: true,
+        data: `\u6587\u4EF6\u5DF2\u7F16\u8F91\uFF1A${filePath}
+\u5171\u6267\u884C ${params.edits.length} \u6B65\u66FF\u6362
+\u53D8\u66F4\uFF1A+${diff.additions} -${diff.deletions}`,
+        summary: `\u{1F4DD} \u4FEE\u6539: ${basename3(filePath)} (${params.edits.length} \u6B65, +${diff.additions} -${diff.deletions})`,
+        diff
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return {
+        success: false,
+        data: `\u6279\u91CF\u7F16\u8F91\u5931\u8D25\uFF1A${message}`,
+        error: "MULTI_EDIT_ERROR"
+      };
+    }
+  }
+};
+
+// src/tool/builtins/delete-range.ts
+import { readFile as readFile8, writeFile as writeFile6 } from "fs/promises";
+import { basename as basename4 } from "path";
+var deleteRangeSchema = {
+  type: "object",
+  properties: {
+    path: {
+      type: "string",
+      description: "\u6587\u4EF6\u8DEF\u5F84\uFF08\u76F8\u5BF9\u4E8E\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\u6216\u7EDD\u5BF9\u8DEF\u5F84\uFF09"
+    },
+    startAnchor: {
+      type: "string",
+      description: "\u5220\u9664\u8303\u56F4\u7684\u8D77\u59CB\u6807\u8BB0\u884C\u5185\u5BB9\uFF08\u5FC5\u987B\u5728\u6587\u4EF6\u4E2D\u552F\u4E00\uFF0C\u7CBE\u786E\u5339\u914D\u6574\u884C\uFF09"
+    },
+    endAnchor: {
+      type: "string",
+      description: "\u5220\u9664\u8303\u56F4\u7684\u7ED3\u675F\u6807\u8BB0\u884C\u5185\u5BB9\uFF08\u5FC5\u987B\u5728\u6587\u4EF6\u4E2D\u552F\u4E00\uFF0C\u7CBE\u786E\u5339\u914D\u6574\u884C\uFF0C\u987B\u5728 start_anchor \u4E4B\u540E\uFF09"
+    },
+    inclusive: {
+      type: "boolean",
+      description: "\u662F\u5426\u5305\u542B\u951A\u70B9\u884C\u672C\u8EAB\uFF0C\u9ED8\u8BA4 false\uFF08\u53EA\u5220\u9664\u4E24\u884C\u4E4B\u95F4\u7684\u5185\u5BB9\uFF09"
+    }
+  },
+  required: ["path", "startAnchor", "endAnchor"],
+  additionalProperties: false
+};
+function findUniqueLine(lines, anchor, label) {
+  const matches = [];
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i] === anchor) {
+      matches.push(i);
+    }
+  }
+  if (matches.length === 0) {
+    return { error: `\u672A\u627E\u5230 "${label}" \u951A\u70B9\u884C\uFF0C\u8BF7\u786E\u8BA4\u5185\u5BB9\u5B8C\u5168\u4E00\u81F4` };
+  }
+  if (matches.length > 1) {
+    return { error: `"${label}" \u951A\u70B9\u884C\u5728\u6587\u4EF6\u4E2D\u51FA\u73B0 ${matches.length} \u6B21\uFF0C\u8BF7\u4F7F\u7528\u66F4\u552F\u4E00\u7684\u884C\u5185\u5BB9` };
+  }
+  return { line: matches[0] };
+}
+var deleteRangeTool = {
+  name: "delete_range",
+  description: "\u5220\u9664\u6587\u4EF6\u4E2D\u4E24\u4E2A\u951A\u70B9\u884C\u4E4B\u95F4\u7684\u5185\u5BB9\u3002\u901A\u8FC7\u4E24\u4E2A\u552F\u4E00\u7684\u884C\u5185\u5BB9\u7CBE\u786E\u5B9A\u4F4D\u8303\u56F4\u3002\u9002\u7528\u4E8E\u5220\u9664\u65B9\u6CD5\u3001\u4EE3\u7801\u5757\u3001\u914D\u7F6E\u6BB5\u7B49\u3002",
+  parameters: deleteRangeSchema,
+  readOnly: false,
+  async execute(args, ctx) {
+    const params = args;
+    if (!params?.path || typeof params.path !== "string") {
+      return { success: false, data: "\u7F3A\u5C11\u5FC5\u8981\u53C2\u6570 path", error: "INVALID_ARGS" };
+    }
+    if (typeof params.startAnchor !== "string") {
+      return { success: false, data: "\u7F3A\u5C11\u6709\u6548\u53C2\u6570 startAnchor", error: "INVALID_ARGS" };
+    }
+    if (typeof params.endAnchor !== "string") {
+      return { success: false, data: "\u7F3A\u5C11\u6709\u6548\u53C2\u6570 endAnchor", error: "INVALID_ARGS" };
+    }
+    const filePath = resolvePath(params.path, ctx.cwd);
+    const inclusive = params.inclusive ?? false;
+    try {
+      const content = await readFile8(filePath, "utf-8");
+      const lines = content.split("\n");
+      const startResult = findUniqueLine(lines, params.startAnchor, "start_anchor");
+      if ("error" in startResult) {
+        return { success: false, data: startResult.error, error: "ANCHOR_NOT_FOUND" };
+      }
+      const endResult = findUniqueLine(lines, params.endAnchor, "end_anchor");
+      if ("error" in endResult) {
+        return { success: false, data: endResult.error, error: "ANCHOR_NOT_FOUND" };
+      }
+      const startLine = startResult.line;
+      const endLine = endResult.line;
+      if (startLine >= endLine) {
+        return {
+          success: false,
+          data: "end_anchor \u5FC5\u987B\u5728 start_anchor \u4E4B\u540E",
+          error: "ANCHOR_ORDER_ERROR"
+        };
+      }
+      const rangeStart = inclusive ? startLine : startLine + 1;
+      const rangeEnd = inclusive ? endLine : endLine - 1;
+      if (rangeStart > rangeEnd) {
+        return {
+          success: false,
+          data: "\u5220\u9664\u8303\u56F4\u4E3A\u7A7A\uFF08\u4E24\u884C\u951A\u70B9\u76F8\u90BB\u4E14 inclusive=false\uFF09",
+          error: "EMPTY_RANGE"
+        };
+      }
+      const newLines = [...lines.slice(0, rangeStart), ...lines.slice(rangeEnd + 1)];
+      const newContent = newLines.join("\n");
+      let writeContent = newContent;
+      if (content.endsWith("\n") && !newContent.endsWith("\n")) {
+        writeContent = newContent + "\n";
+      } else if (content.endsWith("\r\n") && !newContent.endsWith("\r\n") && !newContent.endsWith("\n")) {
+        writeContent = newContent + "\r\n";
+      }
+      await writeFile6(filePath, writeContent, "utf-8");
+      const diff = computeFileDiff(content, writeContent, filePath);
+      diff.existedBefore = true;
+      const deletedLines = rangeEnd - rangeStart + 1;
+      const summary = `\u{1F4DD} \u4FEE\u6539: ${basename4(filePath)} (\u5220 ${deletedLines} \u884C, +${diff.additions} -${diff.deletions})`;
+      return {
+        success: true,
+        data: `\u6587\u4EF6\u5DF2\u7F16\u8F91\uFF1A${filePath}
+\u5220\u9664\u884C\u8303\u56F4\uFF1A\u7B2C ${rangeStart + 1} \u884C ~ \u7B2C ${rangeEnd + 1} \u884C\uFF08\u5171 ${deletedLines} \u884C\uFF09
+\u53D8\u66F4\uFF1A+${diff.additions} -${diff.deletions}`,
+        summary,
+        diff
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return {
+        success: false,
+        data: `\u5220\u9664\u8303\u56F4\u5931\u8D25\uFF1A${message}`,
+        error: "DELETE_RANGE_ERROR"
+      };
+    }
+  }
+};
+
 // src/tool/builtins/bash.ts
 import process3 from "process";
 var isWindows2 = process3.platform === "win32";
@@ -2365,6 +2833,8 @@ var bashTool = {
   name: "bash",
   description: "\u5728 shell \u4E2D\u6267\u884C\u547D\u4EE4\u3002\u8FD4\u56DE\u6807\u51C6\u8F93\u51FA\u3001\u6807\u51C6\u9519\u8BEF\u548C\u9000\u51FA\u7801\u3002\u652F\u6301\u8D85\u65F6\u63A7\u5236\u548C\u4FE1\u53F7\u4E2D\u6B62\u3002\u9002\u7528\u4E8E\u8FD0\u884C\u6784\u5EFA\u3001\u6D4B\u8BD5\u3001Git \u64CD\u4F5C\u7B49\u547D\u4EE4\u3002",
   parameters: bashSchema,
+  readOnly: false,
+  // bash 有副作用，不能并行执行
   async execute(args, ctx) {
     const params = args;
     if (!params?.command || typeof params.command !== "string") {
@@ -2393,10 +2863,13 @@ ${truncateOutput(result.stderr)}`);
       }
       const success = result.exitCode === 0;
       const output = parts.length > 0 ? parts.join("\n") : "(\u65E0\u8F93\u51FA)";
+      const cmdPreview = params.command.length > 60 ? params.command.slice(0, 57) + "..." : params.command;
+      const summary = `\u{1F527} $ ${cmdPreview}\uFF08exit ${result.exitCode ?? "\u672A\u77E5"}\uFF09`;
       return {
         success,
         data: `${output}
 [\u9000\u51FA\u7801: ${result.exitCode ?? "\u672A\u77E5"}]`,
+        summary,
         error: success ? void 0 : `EXIT_CODE_${result.exitCode ?? "UNKNOWN"}`
       };
     } catch (err) {
@@ -2412,7 +2885,7 @@ ${truncateOutput(result.stderr)}`);
 
 // src/tool/builtins/glob.ts
 import { readdir as readdir2, stat as stat2 } from "fs/promises";
-import { join as join4, relative as relative2, isAbsolute as isAbsolute2 } from "path";
+import { join as join4, relative as relative4, isAbsolute as isAbsolute2 } from "path";
 var globSchema = {
   type: "object",
   properties: {
@@ -2453,7 +2926,7 @@ async function walkDir(dir, baseDir) {
       continue;
     }
     const fullPath = join4(dir, entry.name);
-    const relPath = relative2(baseDir, fullPath);
+    const relPath = relative4(baseDir, fullPath);
     if (entry.isDirectory()) {
       results.push(...await walkDir(fullPath, baseDir));
     } else {
@@ -2466,6 +2939,7 @@ var globTool = {
   name: "glob",
   description: "\u6309\u6A21\u5F0F\u641C\u7D22\u6587\u4EF6\u8DEF\u5F84\u3002\u652F\u6301 *\uFF08\u5339\u914D\u6587\u4EF6\u540D\u90E8\u5206\uFF09\u548C **\uFF08\u5339\u914D\u591A\u5C42\u76EE\u5F55\uFF09\u901A\u914D\u7B26\u3002\u81EA\u52A8\u8DF3\u8FC7 node_modules \u548C .git \u76EE\u5F55\u3002",
   parameters: globSchema,
+  readOnly: true,
   async execute(args, ctx) {
     const params = args;
     if (!params?.pattern || typeof params.pattern !== "string") {
@@ -2483,7 +2957,8 @@ var globTool = {
       if (matched.length === 0) {
         return {
           success: true,
-          data: `\u672A\u627E\u5230\u5339\u914D "${params.pattern}" \u7684\u6587\u4EF6`
+          data: `\u672A\u627E\u5230\u5339\u914D "${params.pattern}" \u7684\u6587\u4EF6`,
+          summary: `${params.pattern} \u2192 0 \u4E2A\u6587\u4EF6`
         };
       }
       const limit = 200;
@@ -2494,7 +2969,8 @@ var globTool = {
 ... \u5171 ${matched.length} \u4E2A\u6587\u4EF6\uFF0C\u53EA\u663E\u793A\u524D ${limit} \u4E2A` : "";
       return {
         success: true,
-        data: truncateOutput(output + suffix)
+        data: truncateOutput(output + suffix),
+        summary: `${params.pattern} \u2192 ${matched.length} \u4E2A\u6587\u4EF6`
       };
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
@@ -2508,8 +2984,8 @@ var globTool = {
 };
 
 // src/tool/builtins/grep.ts
-import { readdir as readdir3, readFile as readFile7, stat as stat3 } from "fs/promises";
-import { join as join5, relative as relative3, isAbsolute as isAbsolute3 } from "path";
+import { readdir as readdir3, readFile as readFile9, stat as stat3 } from "fs/promises";
+import { join as join5, relative as relative5, isAbsolute as isAbsolute3 } from "path";
 var grepSchema = {
   type: "object",
   properties: {
@@ -2566,6 +3042,7 @@ var grepTool = {
   name: "grep",
   description: "\u5728\u6587\u4EF6\u5185\u5BB9\u4E2D\u641C\u7D22\u6B63\u5219\u8868\u8FBE\u5F0F\u3002\u8FD4\u56DE\u5339\u914D\u884C\u7684\u6587\u4EF6\u8DEF\u5F84\u3001\u884C\u53F7\u548C\u5185\u5BB9\u3002\u652F\u6301\u5927\u5C0F\u5199\u654F\u611F\u3001\u6587\u4EF6\u6269\u5C55\u540D\u8FC7\u6EE4\u3002",
   parameters: grepSchema,
+  readOnly: true,
   async execute(args, ctx) {
     const params = args;
     if (!params?.pattern || typeof params.pattern !== "string") {
@@ -2584,9 +3061,9 @@ var grepTool = {
       const matches = [];
       for (const filePath of files) {
         try {
-          const content = await readFile7(filePath, "utf-8");
+          const content = await readFile9(filePath, "utf-8");
           const lines = content.split("\n");
-          const relPath = relative3(searchDir, filePath);
+          const relPath = relative5(searchDir, filePath);
           for (let i = 0; i < lines.length; i++) {
             if (regex.test(lines[i])) {
               regex.lastIndex = 0;
@@ -2606,13 +3083,17 @@ var grepTool = {
       if (matches.length === 0) {
         return {
           success: true,
-          data: `\u672A\u627E\u5230\u5339\u914D "${params.pattern}" \u7684\u5185\u5BB9`
+          data: `\u672A\u627E\u5230\u5339\u914D "${params.pattern}" \u7684\u5185\u5BB9`,
+          summary: `\u{1F50D} "${params.pattern}" \u2192 0 \u6761\u547D\u4E2D`
         };
       }
       const output = matches.map((m) => `${m.file}:${m.line}: ${m.content}`).join("\n");
+      const fileSet = new Set(matches.map((m) => m.file));
+      const summary = `\u{1F50D} "${params.pattern}" \u2192 ${matches.length} \u6761\u547D\u4E2D / ${fileSet.size} \u4E2A\u6587\u4EF6`;
       return {
         success: true,
-        data: truncateOutput(output)
+        data: truncateOutput(output),
+        summary
       };
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
@@ -2627,7 +3108,7 @@ var grepTool = {
 
 // src/tool/builtins/ls.ts
 import { readdir as readdir4, stat as stat4 } from "fs/promises";
-import { join as join6 } from "path";
+import { join as join6, relative as relative6 } from "path";
 var lsSchema = {
   type: "object",
   properties: {
@@ -2647,6 +3128,7 @@ var lsTool = {
   name: "ls",
   description: "\u5217\u51FA\u76EE\u5F55\u5185\u5BB9\u3002\u663E\u793A\u6761\u76EE\u7C7B\u578B\uFF08\u6587\u4EF6/\u76EE\u5F55/\u94FE\u63A5\uFF09\u548C\u5927\u5C0F\u3002\u53EF\u9009\u62E9\u662F\u5426\u663E\u793A\u9690\u85CF\u6587\u4EF6\u3002",
   parameters: lsSchema,
+  readOnly: true,
   async execute(args, ctx) {
     const params = args ?? {};
     const dirPath = params.path ? resolvePath(params.path, ctx.cwd) : ctx.cwd;
@@ -2682,12 +3164,14 @@ var lsTool = {
         lines.push(`${typeLabel} ${entry.name}${sizeStr ? ` (${sizeStr})` : ""}`);
       }
       if (lines.length === 0) {
-        return { success: true, data: "\u76EE\u5F55\u4E3A\u7A7A" };
+        return { success: true, data: "\u76EE\u5F55\u4E3A\u7A7A", summary: `\u{1F4C2} ${relative6(ctx.cwd, dirPath).replace(/\\/g, "/")}\uFF08\u7A7A\uFF09` };
       }
+      const relPath = relative6(ctx.cwd, dirPath).replace(/\\/g, "/");
       return {
         success: true,
         data: truncateOutput(`\u76EE\u5F55\uFF1A${dirPath}
-${lines.join("\n")}`)
+${lines.join("\n")}`),
+        summary: `\u{1F4C2} ${relPath}\uFF08${lines.length} \u9879\uFF09`
       };
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
@@ -2733,6 +3217,7 @@ var fetchTool = {
   name: "fetch",
   description: "\u53D1\u8D77 HTTP \u8BF7\u6C42\u5E76\u8FD4\u56DE\u54CD\u5E94\u5185\u5BB9\u3002\u652F\u6301\u81EA\u5B9A\u4E49\u65B9\u6CD5\u548C\u8BF7\u6C42\u5934\u3002\u9002\u7528\u4E8E\u83B7\u53D6\u7F51\u9875\u5185\u5BB9\u3001API \u8C03\u7528\u7B49\u573A\u666F\u3002",
   parameters: fetchSchema,
+  readOnly: true,
   async execute(args, ctx) {
     const params = args;
     if (!params?.url || typeof params.url !== "string") {
@@ -2764,9 +3249,12 @@ var fetchTool = {
       const header = `\u72B6\u6001: ${statusText}
 \u5185\u5BB9\u7C7B\u578B: ${contentType}`;
       const separator = body.length > 0 ? "\n---\n" : "";
+      const urlPreview = params.url.length > 60 ? params.url.slice(0, 57) + "..." : params.url;
+      const summary = `\u{1F310} ${method} ${urlPreview} \u2192 ${response.status}`;
       return {
         success: response.ok,
         data: `${header}${separator}${truncatedBody}`,
+        summary,
         error: response.ok ? void 0 : `HTTP_${response.status}`
       };
     } catch (err) {
@@ -2791,6 +3279,8 @@ var builtinTools = [
   readFileTool,
   writeFileTool,
   editFileTool,
+  multiEditTool,
+  deleteRangeTool,
   bashTool,
   globTool,
   grepTool,
@@ -3314,12 +3804,14 @@ function ChatSession({
             currentContentRef.current = "";
             setCurrentToolCalls([]);
             currentToolCallsRef.current = [];
+            const r = event.result;
+            const line = r.success ? r.summary ?? `\u2705 ${event.name}: ${r.data.slice(0, 500)}${r.data.length > 500 ? "..." : ""}` : `\u274C ${event.name}: ${r.error ?? "\u6267\u884C\u5931\u8D25"}`;
             setDisplayMessages((prev) => [
               ...prev,
               {
                 role: "tool",
-                content: event.result.success ? `\u2705 ${event.name}: ${event.result.data.slice(0, 500)}${event.result.data.length > 500 ? "..." : ""}` : `\u274C ${event.name}: ${event.result.error ?? "\u6267\u884C\u5931\u8D25"}`,
-                diff: event.result.diff
+                content: line,
+                diff: r.diff
               }
             ]);
             break;
@@ -4735,7 +5227,7 @@ function renderDetail(stock, _onBack, prices, countdown = 10, currentTime) {
 
 // src/utils/scan-files.ts
 import { readdir as readdir5 } from "fs/promises";
-import { join as join8, relative as relative4 } from "path";
+import { join as join8, relative as relative7 } from "path";
 var IGNORE_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
   ".git",
@@ -4800,7 +5292,7 @@ async function scanProjectFiles(baseDir, dir) {
     } else if (entry.isFile()) {
       const ext = name.slice(name.lastIndexOf(".")).toLowerCase();
       if (SOURCE_EXTS.has(ext)) {
-        files.push(relative4(baseDir, join8(currentDir, name)));
+        files.push(relative7(baseDir, join8(currentDir, name)));
       }
     }
   }
@@ -4969,7 +5461,7 @@ compdef _dskcode_completion dskcode`);
     const globalConfigPath = join9(home, ".dskcode", "settings.json");
     let globalConfigHasStock = false;
     try {
-      const raw = await readFile8(globalConfigPath, "utf-8");
+      const raw = await readFile10(globalConfigPath, "utf-8");
       const parsed = JSON.parse(raw);
       const stock = parsed.stock;
       globalConfigHasStock = Array.isArray(stock?.symbols) && stock.symbols.length > 0;