deeper-cli 1.0.5 → 1.2.0

package/dist/cli/index.js

@@ -1831,10 +1831,10 @@ var init_token_count = __esm({
           const messagesJson = params.messages;
           let content = "";
           if (filePath) {
-            const { readFileSync: readFileSync38, existsSync: existsSync53 } = await import("fs");
+            const { readFileSync: readFileSync38, existsSync: existsSync54 } = await import("fs");
             const { resolve: resolve48 } = await import("path");
             const abs = resolve48(filePath);
-            if (!existsSync53(abs)) return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${abs}`, output: "" };
+            if (!existsSync54(abs)) return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${abs}`, output: "" };
             content = readFileSync38(abs, "utf-8");
           } else if (text) {
             content = text;
@@ -3271,6 +3271,651 @@ var init_MCPClient = __esm({
   }
 });
 
+// src/model/RetryManager.ts
+var RetryManager;
+var init_RetryManager = __esm({
+  "src/model/RetryManager.ts"() {
+    "use strict";
+    RetryManager = class {
+      maxRetries;
+      baseDelayMs;
+      maxDelayMs;
+      constructor(maxRetries = 3, baseDelayMs = 1e3, maxDelayMs = 3e4) {
+        this.maxRetries = maxRetries;
+        this.baseDelayMs = baseDelayMs;
+        this.maxDelayMs = maxDelayMs;
+      }
+      async execute(fn, shouldRetry, options) {
+        let lastError;
+        for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+          try {
+            return await fn();
+          } catch (error) {
+            lastError = error instanceof Error ? error : new Error(String(error));
+            if (attempt === this.maxRetries) {
+              break;
+            }
+            if (shouldRetry && !shouldRetry(lastError, attempt)) {
+              break;
+            }
+            if (!shouldRetry && this.isDefaultNonRetryable(lastError)) {
+              break;
+            }
+            const delay = this.calculateDelay(attempt);
+            if (options?.onRetry) {
+              options.onRetry(lastError, attempt, delay);
+            }
+            await this.sleep(delay);
+          }
+        }
+        throw lastError ?? new Error("Max retries exceeded");
+      }
+      withTimeout(fn, timeoutMs, signal) {
+        const controller = new AbortController();
+        return new Promise((resolve48, reject) => {
+          const timer = setTimeout(() => {
+            controller.abort();
+            reject(new Error(`Request timed out after ${timeoutMs}ms`));
+          }, timeoutMs);
+          const onAbort = () => {
+            clearTimeout(timer);
+            controller.abort();
+            reject(new Error("Request was aborted"));
+          };
+          if (signal) {
+            if (signal.aborted) {
+              clearTimeout(timer);
+              controller.abort();
+              reject(new Error("Request was aborted"));
+              return;
+            }
+            signal.addEventListener("abort", onAbort, { once: true });
+          }
+          fn().then((result) => {
+            clearTimeout(timer);
+            if (signal) {
+              signal.removeEventListener("abort", onAbort);
+            }
+            resolve48(result);
+          }).catch((error) => {
+            clearTimeout(timer);
+            if (signal) {
+              signal.removeEventListener("abort", onAbort);
+            }
+            reject(error);
+          });
+        });
+      }
+      calculateDelay(attempt) {
+        const exponentialDelay = this.baseDelayMs * Math.pow(2, attempt);
+        const jitter = Math.random() * exponentialDelay;
+        return Math.min(exponentialDelay + jitter, this.maxDelayMs);
+      }
+      isDefaultNonRetryable(error) {
+        const msg = error.message.toLowerCase();
+        if (msg.includes("400") && !msg.includes("429")) return true;
+        if (msg.includes("401") || msg.includes("unauthorized")) return true;
+        if (msg.includes("403") || msg.includes("forbidden")) return true;
+        if (msg.includes("404") || msg.includes("not found")) return true;
+        return false;
+      }
+      sleep(ms, signal) {
+        return new Promise((resolve48, reject) => {
+          const timer = setTimeout(resolve48, ms);
+          if (signal) {
+            const onAbort = () => {
+              clearTimeout(timer);
+              reject(new Error("Retry sleep was aborted"));
+            };
+            if (signal.aborted) {
+              clearTimeout(timer);
+              reject(new Error("Retry sleep was aborted"));
+              return;
+            }
+            signal.addEventListener("abort", onAbort, { once: true });
+          }
+        });
+      }
+    };
+  }
+});
+
+// src/model/StreamHandler.ts
+var StreamHandler;
+var init_StreamHandler = __esm({
+  "src/model/StreamHandler.ts"() {
+    "use strict";
+    StreamHandler = class {
+      textBuffer;
+      thinkingBuffer;
+      toolCallBuffer;
+      finished;
+      lastYieldedIndex;
+      constructor() {
+        this.textBuffer = "";
+        this.thinkingBuffer = "";
+        this.toolCallBuffer = /* @__PURE__ */ new Map();
+        this.finished = false;
+        this.lastYieldedIndex = -1;
+      }
+      reset() {
+        this.textBuffer = "";
+        this.thinkingBuffer = "";
+        this.toolCallBuffer.clear();
+        this.finished = false;
+        this.lastYieldedIndex = -1;
+      }
+      handleEvent(event, data) {
+        if (event === "error") {
+          return { type: "error", error: data || "SSE error event" };
+        }
+        if (event === "[DONE]" || data === "[DONE]") {
+          const results = this.finalizePendingToolCalls();
+          this.finished = true;
+          if (results.length > 0) {
+            return [...results, { type: "done" }];
+          }
+          return { type: "done" };
+        }
+        if (!data) {
+          return null;
+        }
+        try {
+          const parsed = JSON.parse(data);
+          const choices = parsed.choices;
+          if (!choices || choices.length === 0) {
+            return null;
+          }
+          const choice = choices[0];
+          const delta = choice.delta;
+          if (!delta) {
+            const finishReason2 = choice.finish_reason;
+            if (finishReason2 === "stop" || finishReason2 === "length" || finishReason2 === "tool_calls") {
+              const results = this.finalizePendingToolCalls();
+              this.finished = true;
+              if (results.length > 0) {
+                return [...results, { type: "done" }];
+              }
+              return { type: "done" };
+            }
+            return null;
+          }
+          if (delta.reasoning_content) {
+            const thinkingChunk = delta.reasoning_content;
+            this.thinkingBuffer += thinkingChunk;
+            if (this.thinkingBuffer.length > 1e5) {
+              this.thinkingBuffer = this.thinkingBuffer.slice(-8e4);
+            }
+            return {
+              type: "thinking",
+              content: thinkingChunk
+            };
+          }
+          if (delta.tool_calls) {
+            return this.handleToolCallsDelta(delta.tool_calls);
+          }
+          if (delta.content) {
+            const textChunk = delta.content;
+            this.textBuffer += textChunk;
+            if (this.textBuffer.length > 5e5) {
+              this.textBuffer = this.textBuffer.slice(-4e5);
+            }
+            return {
+              type: "text",
+              content: textChunk
+            };
+          }
+          const finishReason = choice.finish_reason;
+          if (finishReason === "stop" || finishReason === "length" || finishReason === "tool_calls") {
+            const results = this.finalizePendingToolCalls();
+            this.finished = true;
+            if (results.length > 0) {
+              return [...results, { type: "done" }];
+            }
+            return { type: "done" };
+          }
+        } catch {
+          return {
+            type: "error",
+            error: `Failed to parse SSE data: ${data.slice(0, 200)}`
+          };
+        }
+        return null;
+      }
+      getAccumulatedText() {
+        return this.textBuffer;
+      }
+      getAccumulatedThinking() {
+        return this.thinkingBuffer;
+      }
+      getToolCalls() {
+        const result = [];
+        const indices = [...this.toolCallBuffer.keys()].sort((a, b2) => a - b2);
+        for (const idx of indices) {
+          const pending = this.toolCallBuffer.get(idx);
+          if (pending) {
+            result.push({
+              id: pending.id,
+              name: pending.name,
+              arguments: this.parseArgsStr(pending.argsStr),
+              index: pending.index
+            });
+          }
+        }
+        return result;
+      }
+      isFinished() {
+        return this.finished;
+      }
+      handleToolCallsDelta(toolCalls) {
+        const results = [];
+        for (const tc of toolCalls) {
+          const index = tc.index;
+          const id = tc.id;
+          const fn = tc.function;
+          if (!this.toolCallBuffer.has(index)) {
+            this.toolCallBuffer.set(index, {
+              id: id ?? "",
+              name: fn?.name ?? "",
+              argsStr: "",
+              index,
+              started: false
+            });
+          }
+          const existing = this.toolCallBuffer.get(index);
+          if (id) {
+            existing.id = id;
+          }
+          if (fn?.name) {
+            existing.name = fn.name;
+          }
+          if (fn?.arguments) {
+            existing.argsStr += fn.arguments;
+          }
+          if (!existing.started) {
+            existing.started = true;
+            if (this.lastYieldedIndex >= 0) {
+              const prev = this.toolCallBuffer.get(this.lastYieldedIndex);
+              if (prev && prev !== existing) {
+                results.push({
+                  type: "tool_call_end",
+                  tool_call: {
+                    id: prev.id,
+                    name: prev.name,
+                    arguments: this.parseArgsStr(prev.argsStr),
+                    index: prev.index
+                  }
+                });
+              }
+            }
+            this.lastYieldedIndex = index;
+            results.push({
+              type: "tool_call_start",
+              tool_call: { id: existing.id, name: existing.name, index: existing.index }
+            });
+          }
+        }
+        return results;
+      }
+      finalizePendingToolCalls() {
+        const results = [];
+        if (this.lastYieldedIndex >= 0) {
+          const last = this.toolCallBuffer.get(this.lastYieldedIndex);
+          if (last) {
+            results.push({
+              type: "tool_call_end",
+              tool_call: {
+                id: last.id,
+                name: last.name,
+                arguments: this.parseArgsStr(last.argsStr),
+                index: last.index
+              }
+            });
+          }
+          this.lastYieldedIndex = -1;
+        }
+        return results;
+      }
+      parseArgsStr(argsStr) {
+        if (!argsStr) return {};
+        try {
+          return JSON.parse(argsStr);
+        } catch {
+          const trimmed = argsStr.trim();
+          if (trimmed.startsWith("{") && !trimmed.endsWith("}")) {
+            try {
+              return JSON.parse(trimmed + "}");
+            } catch {
+              try {
+                return JSON.parse(trimmed + "}}");
+              } catch {
+              }
+            }
+          }
+          return {};
+        }
+      }
+    };
+  }
+});
+
+// src/core/logger.ts
+import { appendFileSync, existsSync as existsSync8, mkdirSync as mkdirSync5 } from "fs";
+import { join as join7, dirname as dirname2 } from "path";
+var LOG_LEVEL_RANK, Logger, logger;
+var init_logger = __esm({
+  "src/core/logger.ts"() {
+    "use strict";
+    init_constants();
+    LOG_LEVEL_RANK = {
+      debug: 0,
+      info: 1,
+      warn: 2,
+      error: 3
+    };
+    Logger = class {
+      level;
+      logDir;
+      currentLogFile;
+      constructor(level = "info", logDir) {
+        this.level = level;
+        this.logDir = logDir ?? DEEPER_LOGS_DIR;
+        this.currentLogFile = this.generateLogFileName();
+        this.ensureLogDir();
+      }
+      setLevel(level) {
+        this.level = level;
+      }
+      debug(message, data) {
+        this.log("debug", message, data);
+      }
+      info(message, data) {
+        this.log("info", message, data);
+      }
+      warn(message, data) {
+        this.log("warn", message, data);
+      }
+      error(message, data) {
+        this.log("error", message, data);
+      }
+      log(level, message, data) {
+        if (LOG_LEVEL_RANK[level] < LOG_LEVEL_RANK[this.level]) {
+          return;
+        }
+        const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+        const formatted = this.formatMessage(level, timestamp, message, data);
+        switch (level) {
+          case "error":
+            console.error(formatted);
+            break;
+          case "warn":
+            console.warn(formatted);
+            break;
+          default:
+            console.log(formatted);
+            break;
+        }
+        try {
+          appendFileSync(this.currentLogFile, this.stripAnsi(formatted) + "\n", "utf-8");
+        } catch {
+        }
+      }
+      formatMessage(level, timestamp, message, data) {
+        const levelUpper = level.toUpperCase();
+        const base = `[${timestamp}] [${levelUpper}] ${message}`;
+        if (data !== void 0) {
+          if (typeof data === "string") {
+            return `${base} ${data}`;
+          }
+          if (data instanceof Error) {
+            return `${base} ${data.message}
+${data.stack ?? ""}`;
+          }
+          try {
+            return `${base} ${JSON.stringify(data)}`;
+          } catch {
+            return `${base} [Unserializable data]`;
+          }
+        }
+        return base;
+      }
+      stripAnsi(text) {
+        return text.replace(/\x1b\[[0-9;]*m/g, "");
+      }
+      generateLogFileName() {
+        const now = /* @__PURE__ */ new Date();
+        const dateStr = now.toISOString().slice(0, 10).replace(/-/g, "");
+        return join7(this.logDir, `deeper-${dateStr}.log`);
+      }
+      ensureLogDir() {
+        const dir = dirname2(this.currentLogFile);
+        if (!existsSync8(dir)) {
+          mkdirSync5(dir, { recursive: true });
+        }
+      }
+    };
+    logger = new Logger();
+  }
+});
+
+// src/model/DeepSeekClient.ts
+var DEFAULT_TIMEOUT_MS, MAX_RETRIES, isRetryable, DeepSeekClient;
+var init_DeepSeekClient = __esm({
+  "src/model/DeepSeekClient.ts"() {
+    "use strict";
+    init_RetryManager();
+    init_StreamHandler();
+    init_logger();
+    DEFAULT_TIMEOUT_MS = 12e4;
+    MAX_RETRIES = 3;
+    isRetryable = (error, _attempt) => {
+      const msg = error.message.toLowerCase();
+      if (msg.includes("429") || msg.includes("rate limit")) return true;
+      if (msg.includes("500") || msg.includes("502") || msg.includes("503") || msg.includes("504")) return true;
+      if (msg.includes("timeout") || msg.includes("abort")) return _attempt < 2;
+      if (msg.includes("econnreset") || msg.includes("econnrefused")) return true;
+      return false;
+    };
+    DeepSeekClient = class {
+      config;
+      retryManager;
+      constructor(config) {
+        this.config = config;
+        this.retryManager = new RetryManager(MAX_RETRIES);
+      }
+      async chat(messages, tools, overrides) {
+        const cfg = this.mergeConfig(overrides);
+        const body = this.buildRequestBody(messages, tools, cfg, false);
+        const response = await this.retryManager.execute(async () => {
+          return this.retryManager.withTimeout(
+            () => this.makeRequest(cfg, body),
+            DEFAULT_TIMEOUT_MS,
+            cfg.signal
+          );
+        }, isRetryable);
+        const data = await response.json();
+        if (!data.choices || data.choices.length === 0) {
+          throw new Error("No choices returned from API");
+        }
+        const choice = data.choices[0];
+        const message = choice.message;
+        const result = {
+          role: "assistant",
+          content: message.content
+        };
+        if (message.tool_calls) {
+          result.tool_calls = message.tool_calls.map((tc) => ({
+            id: tc.id,
+            name: tc.function.name,
+            arguments: this.parseArguments(tc.function.arguments)
+          }));
+        }
+        if (message.reasoning_content) {
+          result.reasoning_content = message.reasoning_content;
+        }
+        return result;
+      }
+      async chatStream(messages, tools, overrides) {
+        const cfg = this.mergeConfig(overrides);
+        const body = this.buildRequestBody(messages, tools, cfg, true);
+        const response = await this.retryManager.execute(async () => {
+          return this.retryManager.withTimeout(
+            () => this.makeRequest(cfg, body),
+            DEFAULT_TIMEOUT_MS,
+            cfg.signal
+          );
+        }, isRetryable);
+        if (!response.body) {
+          throw new Error("Response body is empty");
+        }
+        return this.createStreamIterable(response.body);
+      }
+      async *createStreamIterable(body) {
+        const handler = new StreamHandler();
+        let buffer = "";
+        const stream = body;
+        for await (const chunk of stream) {
+          const text = typeof chunk === "string" ? chunk : new TextDecoder().decode(chunk);
+          buffer += text;
+          const lines = buffer.split("\n");
+          buffer = lines.pop() ?? "";
+          for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith(":")) {
+              continue;
+            }
+            if (trimmed.startsWith("data: ")) {
+              const data = trimmed.slice(6);
+              const result = handler.handleEvent("message", data);
+              if (result) {
+                if (Array.isArray(result)) {
+                  for (const r2 of result) yield r2;
+                } else yield result;
+              }
+            } else if (trimmed === "data: [DONE]") {
+              yield { type: "done" };
+              return;
+            }
+          }
+        }
+        if (buffer.trim()) {
+          const trimmed = buffer.trim();
+          if (trimmed.startsWith("data: ")) {
+            const data = trimmed.slice(6);
+            const result = handler.handleEvent("message", data);
+            if (result) {
+              if (Array.isArray(result)) {
+                for (const r2 of result) yield r2;
+              } else yield result;
+            }
+          }
+        }
+        if (!handler.isFinished()) {
+          yield { type: "done" };
+        }
+      }
+      buildRequestBody(messages, tools, config, stream) {
+        const body = {
+          model: config.model,
+          messages: messages.map((m) => {
+            const msg = {
+              role: m.role,
+              content: m.content
+            };
+            if (m.tool_calls) {
+              msg.tool_calls = m.tool_calls.map((tc) => ({
+                id: tc.id,
+                type: "function",
+                function: {
+                  name: tc.name,
+                  arguments: JSON.stringify(tc.arguments)
+                }
+              }));
+            }
+            if (m.tool_call_id) {
+              msg.tool_call_id = m.tool_call_id;
+            }
+            if (m.name) {
+              msg.name = m.name;
+            }
+            const rc = m.reasoning_content || m.thinking;
+            if (rc) msg.reasoning_content = rc;
+            return msg;
+          }),
+          temperature: config.temperature,
+          max_tokens: config.maxTokens,
+          stream
+        };
+        if (config.think?.enabled) {
+          body.thinking = {
+            type: "enabled",
+            budget_tokens: config.think.budgetTokens
+          };
+        }
+        if (tools && tools.length > 0) {
+          body.tools = tools.map((tool) => ({
+            type: "function",
+            function: {
+              name: tool.name,
+              description: tool.description,
+              parameters: tool.parameters
+            }
+          }));
+          body.tool_choice = "auto";
+        }
+        return JSON.stringify(body);
+      }
+      async makeRequest(config, body) {
+        const url = `${config.baseUrl}/v1/chat/completions`;
+        logger.debug("DeepSeek API request", { url, model: config.model });
+        const fetchOpts = {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "Authorization": `Bearer ${config.apiKey}`,
+            "Accept": "application/json"
+          },
+          body
+        };
+        if (config.signal) {
+          fetchOpts.signal = config.signal;
+        }
+        const response = await fetch(url, fetchOpts);
+        if (!response.ok) {
+          const errorBody = await response.text().catch(() => "");
+          logger.error("DeepSeek API error", {
+            status: response.status,
+            statusText: response.statusText,
+            body: errorBody.slice(0, 500)
+          });
+          throw new Error(`API request failed: ${response.status} ${response.statusText} - ${errorBody.slice(0, 200)}`);
+        }
+        return response;
+      }
+      parseArguments(argsStr) {
+        try {
+          return JSON.parse(argsStr);
+        } catch {
+          return {};
+        }
+      }
+      mergeConfig(overrides) {
+        if (!overrides) {
+          return this.config;
+        }
+        return {
+          ...this.config,
+          ...overrides,
+          think: {
+            ...this.config.think,
+            ...overrides.think ?? {}
+          }
+        };
+      }
+    };
+  }
+});
+
 // src/ui/ansi.ts
 import process4 from "process";
 function Oflush() {
@@ -3363,7 +4008,7 @@ var init_ansi = __esm({
 });
 
 // src/tools/builtin/filesystem/read_file.ts
-import { readFileSync as readFileSync5, existsSync as existsSync8 } from "fs";
+import { readFileSync as readFileSync5, existsSync as existsSync9 } from "fs";
 import { resolve, normalize } from "path";
 var read_file;
 var init_read_file = __esm({
@@ -3387,11 +4032,11 @@ var init_read_file = __esm({
       async execute(params) {
         try {
           const filePath = resolve(params.file_path);
-          if (!existsSync8(filePath)) {
+          if (!existsSync9(filePath)) {
             return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${filePath}`, output: "" };
           }
-          const statSync12 = await import("fs").then((m) => m.statSync);
-          const stat = statSync12(filePath);
+          const statSync13 = await import("fs").then((m) => m.statSync);
+          const stat = statSync13(filePath);
           if (stat.isDirectory()) {
             return { success: false, error: `\u8DEF\u5F84\u662F\u76EE\u5F55\uFF0C\u4E0D\u662F\u6587\u4EF6: ${filePath}`, output: "" };
           }
@@ -3425,9 +4070,9 @@ var init_read_file = __esm({
 });
 
 // src/tools/builtin/filesystem/write_file.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync5 } from "fs";
+import { existsSync as existsSync10, mkdirSync as mkdirSync6 } from "fs";
 import { writeFile as writeFile2, appendFile } from "fs/promises";
-import { dirname as dirname2, resolve as resolve2 } from "path";
+import { dirname as dirname3, resolve as resolve2 } from "path";
 var write_file;
 var init_write_file = __esm({
   "src/tools/builtin/filesystem/write_file.ts"() {
@@ -3458,8 +4103,8 @@ var init_write_file = __esm({
           if (!content.trim() && !append) {
             return { success: false, error: `\u5185\u5BB9\u4E3A\u7A7A\uFF0C\u8DF3\u8FC7\u5199\u5165: ${filePath}`, output: "" };
           }
-          const dir = dirname2(filePath);
-          if (!existsSync9(dir)) mkdirSync5(dir, { recursive: true });
+          const dir = dirname3(filePath);
+          if (!existsSync10(dir)) mkdirSync6(dir, { recursive: true });
           if (append) {
             await appendFile(filePath, content, "utf-8");
           } else {
@@ -3476,7 +4121,7 @@ var init_write_file = __esm({
 });
 
 // src/tools/builtin/filesystem/edit_file.ts
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync4, existsSync as existsSync10 } from "fs";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync4, existsSync as existsSync11 } from "fs";
 import { resolve as resolve3 } from "path";
 var edit_file;
 var init_edit_file = __esm({
@@ -3504,7 +4149,7 @@ var init_edit_file = __esm({
           const oldStr = params.old_str;
           const newStr = params.new_str;
           const replaceAll = params.replace_all ?? false;
-          if (!existsSync10(filePath)) return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${filePath}`, output: "" };
+          if (!existsSync11(filePath)) return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${filePath}`, output: "" };
           const content = readFileSync6(filePath, "utf-8");
           const index = content.indexOf(oldStr);
           if (index === -1) return { success: false, error: "\u672A\u627E\u5230\u5339\u914D\u7684\u5B57\u7B26\u4E32", output: "" };
@@ -3530,7 +4175,7 @@ var init_edit_file = __esm({
 });
 
 // src/tools/builtin/filesystem/delete_file.ts
-import { unlinkSync, existsSync as existsSync11 } from "fs";
+import { unlinkSync, existsSync as existsSync12 } from "fs";
 import { resolve as resolve4 } from "path";
 var delete_file;
 var init_delete_file = __esm({
@@ -3552,7 +4197,7 @@ var init_delete_file = __esm({
       async execute(params) {
         try {
           const filePath = resolve4(params.file_path);
-          if (!existsSync11(filePath)) {
+          if (!existsSync12(filePath)) {
             return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${filePath}`, output: "" };
           }
           unlinkSync(filePath);
@@ -3566,8 +4211,8 @@ var init_delete_file = __esm({
 });
 
 // src/tools/builtin/filesystem/list_dir.ts
-import { readdirSync as readdirSync3, existsSync as existsSync12 } from "fs";
-import { resolve as resolve5, join as join7 } from "path";
+import { readdirSync as readdirSync3, existsSync as existsSync13 } from "fs";
+import { resolve as resolve5, join as join8 } from "path";
 var list_dir;
 var init_list_dir = __esm({
   "src/tools/builtin/filesystem/list_dir.ts"() {
@@ -3597,7 +4242,7 @@ var init_list_dir = __esm({
                 const isDir = entry.isDirectory();
                 lines.push(`${prefix}${isDir ? "\u{1F4C1}" : "\u{1F4C4}"} ${entry.name}`);
                 if (isDir && recursive) {
-                  walk2(join7(dir, entry.name), depth + 1, prefix + "  ");
+                  walk2(join8(dir, entry.name), depth + 1, prefix + "  ");
                 }
               }
             } catch {
@@ -3608,10 +4253,10 @@ var init_list_dir = __esm({
           const dirPath = resolve5(params.dir_path);
           const recursive = params.recursive ?? false;
           const maxDepth = params.max_depth ?? 3;
-          if (!existsSync12(dirPath)) {
+          if (!existsSync13(dirPath)) {
             return { success: false, error: `\u76EE\u5F55\u4E0D\u5B58\u5728: ${dirPath}`, output: "" };
           }
-          const { statSync: statSync12 } = await import("fs");
+          const { statSync: statSync13 } = await import("fs");
           const lines = [];
           walk2(dirPath, 1, "");
           return { success: true, output: lines.join("\n"), metadata: { path: dirPath, entries: lines.length } };
@@ -3674,8 +4319,8 @@ var init_glob_find = __esm({
 });
 
 // src/tools/builtin/filesystem/move_file.ts
-import { renameSync, existsSync as existsSync13 } from "fs";
-import { resolve as resolve7, dirname as dirname3 } from "path";
+import { renameSync, existsSync as existsSync14 } from "fs";
+import { resolve as resolve7, dirname as dirname4 } from "path";
 var move_file;
 var init_move_file = __esm({
   "src/tools/builtin/filesystem/move_file.ts"() {
@@ -3698,13 +4343,13 @@ var init_move_file = __esm({
         try {
           const source = resolve7(params.source);
           const dest = resolve7(params.destination);
-          if (!existsSync13(source)) {
+          if (!existsSync14(source)) {
             return { success: false, error: `\u6E90\u6587\u4EF6\u4E0D\u5B58\u5728: ${source}`, output: "" };
           }
-          const destDir = dirname3(dest);
-          const { mkdirSync: mkdirSync15 } = await import("fs");
-          if (!existsSync13(destDir)) {
-            mkdirSync15(destDir, { recursive: true });
+          const destDir = dirname4(dest);
+          const { mkdirSync: mkdirSync16 } = await import("fs");
+          if (!existsSync14(destDir)) {
+            mkdirSync16(destDir, { recursive: true });
           }
           renameSync(source, dest);
           return { success: true, output: `\u5DF2\u79FB\u52A8: ${source} -> ${dest}` };
@@ -3717,8 +4362,8 @@ var init_move_file = __esm({
 });
 
 // src/tools/builtin/filesystem/copy_file.ts
-import { copyFileSync, existsSync as existsSync14, mkdirSync as mkdirSync6 } from "fs";
-import { resolve as resolve8, dirname as dirname4 } from "path";
+import { copyFileSync, existsSync as existsSync15, mkdirSync as mkdirSync7 } from "fs";
+import { resolve as resolve8, dirname as dirname5 } from "path";
 var copy_file;
 var init_copy_file = __esm({
   "src/tools/builtin/filesystem/copy_file.ts"() {
@@ -3741,12 +4386,12 @@ var init_copy_file = __esm({
         try {
           const source = resolve8(params.source);
           const dest = resolve8(params.destination);
-          if (!existsSync14(source)) {
+          if (!existsSync15(source)) {
             return { success: false, error: `\u6E90\u6587\u4EF6\u4E0D\u5B58\u5728: ${source}`, output: "" };
           }
-          const destDir = dirname4(dest);
-          if (!existsSync14(destDir)) {
-            mkdirSync6(destDir, { recursive: true });
+          const destDir = dirname5(dest);
+          if (!existsSync15(destDir)) {
+            mkdirSync7(destDir, { recursive: true });
           }
           copyFileSync(source, dest);
           return { success: true, output: `\u5DF2\u590D\u5236: ${source} -> ${dest}` };
@@ -3759,7 +4404,7 @@ var init_copy_file = __esm({
 });
 
 // src/tools/builtin/filesystem/create_dir.ts
-import { mkdirSync as mkdirSync7, existsSync as existsSync15 } from "fs";
+import { mkdirSync as mkdirSync8, existsSync as existsSync16 } from "fs";
 import { resolve as resolve9 } from "path";
 var create_dir;
 var init_create_dir = __esm({
@@ -3781,10 +4426,10 @@ var init_create_dir = __esm({
       async execute(params) {
         try {
           const dirPath = resolve9(params.dir_path);
-          if (existsSync15(dirPath)) {
+          if (existsSync16(dirPath)) {
             return { success: true, output: `\u76EE\u5F55\u5DF2\u5B58\u5728: ${dirPath}` };
           }
-          mkdirSync7(dirPath, { recursive: true });
+          mkdirSync8(dirPath, { recursive: true });
           return { success: true, output: `\u76EE\u5F55\u5DF2\u521B\u5EFA: ${dirPath}` };
         } catch (err) {
           return { success: false, error: err.message, output: "" };
@@ -3795,7 +4440,7 @@ var init_create_dir = __esm({
 });
 
 // src/tools/builtin/filesystem/file_info.ts
-import { statSync, existsSync as existsSync16 } from "fs";
+import { statSync, existsSync as existsSync17 } from "fs";
 import { resolve as resolve10, basename } from "path";
 function formatSize(bytes) {
   if (bytes < 1024) return `${bytes} B`;
@@ -3823,7 +4468,7 @@ var init_file_info = __esm({
       async execute(params) {
         try {
           const filePath = resolve10(params.file_path);
-          if (!existsSync16(filePath)) {
+          if (!existsSync17(filePath)) {
             return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${filePath}`, output: "" };
           }
           const stat = statSync(filePath);
@@ -3852,7 +4497,7 @@ var init_file_info = __esm({
 });
 
 // src/tools/builtin/filesystem/watch_file.ts
-import { existsSync as existsSync17 } from "fs";
+import { existsSync as existsSync18 } from "fs";
 import { resolve as resolve11 } from "path";
 var watch_file;
 var init_watch_file = __esm({
@@ -3874,7 +4519,7 @@ var init_watch_file = __esm({
       async execute(params) {
         try {
           const filePath = resolve11(params.file_path);
-          if (!existsSync17(filePath)) {
+          if (!existsSync18(filePath)) {
             return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${filePath}`, output: "" };
           }
           return {
@@ -3891,7 +4536,7 @@ var init_watch_file = __esm({
 });
 
 // src/tools/builtin/filesystem/batch_read.ts
-import { readFileSync as readFileSync7, existsSync as existsSync18 } from "fs";
+import { readFileSync as readFileSync7, existsSync as existsSync19 } from "fs";
 import { resolve as resolve12 } from "path";
 var batch_read;
 var init_batch_read = __esm({
@@ -3919,7 +4564,7 @@ var init_batch_read = __esm({
           for (const p of paths) {
             const abs = resolve12(p);
             try {
-              if (!existsSync18(abs)) {
+              if (!existsSync19(abs)) {
                 results[p] = { content: "", error: "\u6587\u4EF6\u4E0D\u5B58\u5728" };
                 continue;
               }
@@ -3952,9 +4597,9 @@ ${r2.content}`;
 });
 
 // src/tools/builtin/filesystem/batch_write.ts
-import { existsSync as existsSync19, mkdirSync as mkdirSync8 } from "fs";
+import { existsSync as existsSync20, mkdirSync as mkdirSync9 } from "fs";
 import { writeFile as writeFile3 } from "fs/promises";
-import { resolve as resolve13, dirname as dirname5 } from "path";
+import { resolve as resolve13, dirname as dirname6 } from "path";
 var batch_write;
 var init_batch_write = __esm({
   "src/tools/builtin/filesystem/batch_write.ts"() {
@@ -4001,9 +4646,9 @@ var init_batch_write = __esm({
               skipped.push(`${abs} (\u5185\u5BB9\u8FC7\u5927)`);
               continue;
             }
-            const dir = dirname5(abs);
-            if (!existsSync19(dir)) {
-              mkdirSync8(dir, { recursive: true });
+            const dir = dirname6(abs);
+            if (!existsSync20(dir)) {
+              mkdirSync9(dir, { recursive: true });
             }
             await writeFile3(abs, content, "utf-8");
             results.push(abs);
@@ -4025,7 +4670,7 @@ var init_batch_write = __esm({
 });
 
 // src/tools/builtin/filesystem/diff_files.ts
-import { readFileSync as readFileSync8, existsSync as existsSync20 } from "fs";
+import { readFileSync as readFileSync8, existsSync as existsSync21 } from "fs";
 import { resolve as resolve14 } from "path";
 var diff_files;
 var init_diff_files = __esm({
@@ -4051,8 +4696,8 @@ var init_diff_files = __esm({
           const fileA = resolve14(params.file_a);
           const fileB = resolve14(params.file_b);
           const contextLines = params.context_lines ?? 3;
-          if (!existsSync20(fileA)) return { success: false, error: `\u6587\u4EF6A\u4E0D\u5B58\u5728: ${fileA}`, output: "" };
-          if (!existsSync20(fileB)) return { success: false, error: `\u6587\u4EF6B\u4E0D\u5B58\u5728: ${fileB}`, output: "" };
+          if (!existsSync21(fileA)) return { success: false, error: `\u6587\u4EF6A\u4E0D\u5B58\u5728: ${fileA}`, output: "" };
+          if (!existsSync21(fileB)) return { success: false, error: `\u6587\u4EF6B\u4E0D\u5B58\u5728: ${fileB}`, output: "" };
           const contentA = readFileSync8(fileA, "utf-8");
           const contentB = readFileSync8(fileB, "utf-8");
           const Diff = await import("diff");
@@ -4083,7 +4728,7 @@ var init_diff_files = __esm({
 });
 
 // src/tools/builtin/filesystem/merge_files.ts
-import { readFileSync as readFileSync9, writeFileSync as writeFileSync5, existsSync as existsSync21 } from "fs";
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync5, existsSync as existsSync22 } from "fs";
 import { resolve as resolve15 } from "path";
 var merge_files;
 var init_merge_files = __esm({
@@ -4112,7 +4757,7 @@ var init_merge_files = __esm({
           const parts = [];
           for (const p of paths) {
             const abs = resolve15(p);
-            if (!existsSync21(abs)) {
+            if (!existsSync22(abs)) {
               return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${abs}`, output: "" };
             }
             parts.push(readFileSync9(abs, "utf-8"));
@@ -4133,7 +4778,7 @@ var init_merge_files = __esm({
 });
 
 // src/tools/builtin/search/grep_search.ts
-import { readFileSync as readFileSync10, existsSync as existsSync22, statSync as statSync2 } from "fs";
+import { readFileSync as readFileSync10, existsSync as existsSync23, statSync as statSync2 } from "fs";
 import { resolve as resolve16 } from "path";
 var grep_search;
 var init_grep_search = __esm({
@@ -4198,7 +4843,7 @@ var init_grep_search = __esm({
           const maxFileSize = 5 * 1024 * 1024;
           if (filePath) {
             const abs = resolve16(filePath);
-            if (existsSync22(abs)) searchFile2(abs);
+            if (existsSync23(abs)) searchFile2(abs);
           } else if (dirPath) {
             const fg2 = await import("fast-glob");
             const pattern2 = glob ? `**/${glob}` : "**/*";
@@ -4671,7 +5316,7 @@ var init_fuzzy_find = __esm({
 });
 
 // src/tools/builtin/search/regex_find.ts
-import { readFileSync as readFileSync16, writeFileSync as writeFileSync6, existsSync as existsSync28 } from "fs";
+import { readFileSync as readFileSync16, writeFileSync as writeFileSync6, existsSync as existsSync29 } from "fs";
 import { resolve as resolve23 } from "path";
 var regex_find;
 var init_regex_find = __esm({
@@ -4737,7 +5382,7 @@ var init_regex_find = __esm({
           }
           if (filePath) {
             const abs = resolve23(filePath);
-            if (existsSync28(abs)) await processFile(abs);
+            if (existsSync29(abs)) await processFile(abs);
           } else if (dirPath) {
             const fg2 = await import("fast-glob");
             const files = await fg2.default(filePattern, {
@@ -5315,7 +5960,7 @@ ${stderr}` : ""),
 });
 
 // src/tools/builtin/shell/shell_script.ts
-import { existsSync as existsSync29 } from "fs";
+import { existsSync as existsSync30 } from "fs";
 import { exec as execCb2 } from "child_process";
 import { promisify as promisify2 } from "util";
 import { resolve as resolve24 } from "path";
@@ -5346,7 +5991,7 @@ var init_shell_script = __esm({
           const args = params.args ?? [];
           const cwd = params.cwd ?? process.cwd();
           const timeout = params.timeout_ms ?? 3e4;
-          if (!existsSync29(scriptPath)) {
+          if (!existsSync30(scriptPath)) {
             return { success: false, error: `\u811A\u672C\u6587\u4EF6\u4E0D\u5B58\u5728: ${scriptPath}`, output: "" };
           }
           const shell = process.platform === "win32" ? process.env.ComSpec || "cmd.exe" : process.env.SHELL || "/bin/sh";
@@ -6017,8 +6662,8 @@ var init_http_request = __esm({
 });
 
 // src/tools/builtin/network/download_file.ts
-import { createWriteStream, existsSync as existsSync30, mkdirSync as mkdirSync9 } from "fs";
-import { dirname as dirname6, resolve as resolve25 } from "path";
+import { createWriteStream, existsSync as existsSync31, mkdirSync as mkdirSync10 } from "fs";
+import { dirname as dirname7, resolve as resolve25 } from "path";
 import { pipeline } from "stream/promises";
 function formatSize2(bytes) {
   if (bytes < 1024) return `${bytes} B`;
@@ -6049,9 +6694,9 @@ var init_download_file = __esm({
           const url = params.url;
           const filePath = resolve25(params.file_path);
           const timeout = params.timeout_ms ?? 6e4;
-          const dir = dirname6(filePath);
-          if (!existsSync30(dir)) {
-            mkdirSync9(dir, { recursive: true });
+          const dir = dirname7(filePath);
+          if (!existsSync31(dir)) {
+            mkdirSync10(dir, { recursive: true });
           }
           const controller = new AbortController();
           const timer = setTimeout(() => controller.abort(), timeout);
@@ -6631,7 +7276,7 @@ var init_proxy_request = __esm({
 });
 
 // src/tools/builtin/code/parse_ast.ts
-import { readFileSync as readFileSync18, existsSync as existsSync31 } from "fs";
+import { readFileSync as readFileSync18, existsSync as existsSync32 } from "fs";
 import { resolve as resolve26 } from "path";
 var parse_ast;
 var init_parse_ast = __esm({
@@ -6655,7 +7300,7 @@ var init_parse_ast = __esm({
         try {
           const filePath = resolve26(params.file_path);
           const language = params.language ?? "typescript";
-          if (!existsSync31(filePath)) {
+          if (!existsSync32(filePath)) {
             return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${filePath}`, output: "" };
           }
           const content = readFileSync18(filePath, "utf-8");
@@ -6716,7 +7361,7 @@ var init_parse_ast = __esm({
 });
 
 // src/tools/builtin/code/format_code.ts
-import { readFileSync as readFileSync19, existsSync as existsSync32 } from "fs";
+import { readFileSync as readFileSync19, existsSync as existsSync33 } from "fs";
 import { resolve as resolve27 } from "path";
 var format_code;
 var init_format_code = __esm({
@@ -6740,13 +7385,13 @@ var init_format_code = __esm({
         try {
           const filePath = resolve27(params.file_path);
           const language = params.language ?? "typescript";
-          if (!existsSync32(filePath)) {
+          if (!existsSync33(filePath)) {
             return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${filePath}`, output: "" };
           }
           try {
-            const { execSync: execSync19 } = await import("child_process");
+            const { execSync: execSync20 } = await import("child_process");
             const ext = filePath.split(".").pop() ?? "ts";
-            execSync19(`npx prettier --write "${filePath}"`, {
+            execSync20(`npx prettier --write "${filePath}"`, {
               encoding: "utf-8",
               timeout: 3e4,
               stdio: "pipe"
@@ -6964,7 +7609,7 @@ var init_generate_code = __esm({
 });
 
 // src/tools/builtin/code/refactor_code.ts
-import { readFileSync as readFileSync20, existsSync as existsSync33 } from "fs";
+import { readFileSync as readFileSync20, existsSync as existsSync34 } from "fs";
 import { resolve as resolve30 } from "path";
 function escapeRegex3(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -6995,7 +7640,7 @@ var init_refactor_code = __esm({
           const action = params.action;
           const target = params.target;
           const newName = params.new_name;
-          if (!existsSync33(filePath)) {
+          if (!existsSync34(filePath)) {
             return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${filePath}`, output: "" };
           }
           const content = readFileSync20(filePath, "utf-8");
@@ -7032,7 +7677,7 @@ var init_refactor_code = __esm({
 });
 
 // src/tools/builtin/code/extract_function.ts
-import { readFileSync as readFileSync21, existsSync as existsSync34 } from "fs";
+import { readFileSync as readFileSync21, existsSync as existsSync35 } from "fs";
 import { resolve as resolve31 } from "path";
 function escapeRegex4(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -7059,7 +7704,7 @@ var init_extract_function = __esm({
         try {
           const filePath = resolve31(params.file_path);
           const funcName = params.function_name;
-          if (!existsSync34(filePath)) {
+          if (!existsSync35(filePath)) {
             return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${filePath}`, output: "" };
           }
           const content = readFileSync21(filePath, "utf-8");
@@ -7187,7 +7832,7 @@ var init_analyze_deps = __esm({
 });
 
 // src/tools/builtin/code/import_organizer.ts
-import { readFileSync as readFileSync23, existsSync as existsSync36 } from "fs";
+import { readFileSync as readFileSync23, existsSync as existsSync37 } from "fs";
 import { resolve as resolve33 } from "path";
 var import_organizer;
 var init_import_organizer = __esm({
@@ -7215,7 +7860,7 @@ var init_import_organizer = __esm({
           const groupBy = params.group_by ?? "source";
           const sort = params.sort ?? true;
           const removeUnused = params.remove_unused ?? false;
-          if (!existsSync36(filePath)) {
+          if (!existsSync37(filePath)) {
             return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${filePath}`, output: "" };
           }
           const content = readFileSync23(filePath, "utf-8");
@@ -7390,10 +8035,10 @@ var init_code_metrics = __esm({
 });
 
 // src/core/bugscan.ts
-import { existsSync as existsSync38, readFileSync as readFileSync25, statSync as statSync10 } from "fs";
+import { existsSync as existsSync39, readFileSync as readFileSync25, statSync as statSync10 } from "fs";
 import { extname, basename as basename3 } from "path";
 function analyzeFile(filePath) {
-  if (!existsSync38(filePath)) return [];
+  if (!existsSync39(filePath)) return [];
   try {
     if (statSync10(filePath).size > MAX_FILE_SIZE) return [];
   } catch {
@@ -7529,7 +8174,7 @@ var init_bugscan = __esm({
 
 // src/tools/builtin/code/bug_scan.ts
 import { statSync as statSync11 } from "fs";
-import { isAbsolute, join as join8 } from "path";
+import { isAbsolute, join as join9 } from "path";
 import fg from "fast-glob";
 var MAX_FILES, EXTENSIONS, SEVERITY_ORDER, bug_scan;
 var init_bug_scan = __esm({
@@ -7559,7 +8204,7 @@ var init_bug_scan = __esm({
           const target = params.path;
           const recursive = params.recursive ?? false;
           const minSeverity = params.severity ?? "warning";
-          const absPath = isAbsolute(target) ? target : join8(process.cwd(), target);
+          const absPath = isAbsolute(target) ? target : join9(process.cwd(), target);
           let isFile = false;
           try {
             isFile = statSync11(absPath).isFile();
@@ -7932,25 +8577,25 @@ var init_db_restore = __esm({
         try {
           const engine = params.engine;
           const connection = params.connection;
-          const backupFile = params.backup_file;
+          const backupFile2 = params.backup_file;
           let cmd = "";
           switch (engine) {
             case "sqlite":
-              cmd = `sqlite3 "${connection || "database.db"}" < "${backupFile}"`;
+              cmd = `sqlite3 "${connection || "database.db"}" < "${backupFile2}"`;
               break;
             case "mysql":
-              cmd = `mysql ${connection || ""} < "${backupFile}"`;
+              cmd = `mysql ${connection || ""} < "${backupFile2}"`;
               break;
             case "postgresql":
-              cmd = `psql ${connection || ""} < "${backupFile}"`;
+              cmd = `psql ${connection || ""} < "${backupFile2}"`;
               break;
             default:
               return { success: false, error: `\u4E0D\u652F\u6301\u7684\u6570\u636E\u5E93\u5F15\u64CE: ${engine}`, output: "" };
           }
           try {
             const output = execSync9(cmd, { encoding: "utf-8", timeout: 12e4, stdio: "pipe" });
-            return { success: true, output: `\u6062\u590D\u5B8C\u6210: ${backupFile}
-${output || ""}`, metadata: { engine, backupFile } };
+            return { success: true, output: `\u6062\u590D\u5B8C\u6210: ${backupFile2}
+${output || ""}`, metadata: { engine, backupFile: backupFile2 } };
           } catch (err) {
             const e = err;
             return { success: false, error: `\u6062\u590D\u5931\u8D25: ${e.message || String(err)}`, output: "" };
@@ -8124,10 +8769,10 @@ var init_json_parse = __esm({
           const query = params.query;
           let jsonContent = "";
           if (filePath) {
-            const { readFileSync: readFileSync38, existsSync: existsSync53 } = await import("fs");
+            const { readFileSync: readFileSync38, existsSync: existsSync54 } = await import("fs");
             const { resolve: resolve48 } = await import("path");
             const abs = resolve48(filePath);
-            if (!existsSync53(abs)) return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${abs}`, output: "" };
+            if (!existsSync54(abs)) return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${abs}`, output: "" };
             jsonContent = readFileSync38(abs, "utf-8");
           } else if (content) {
             jsonContent = content;
@@ -8181,10 +8826,10 @@ var init_csv_parse = __esm({
           const delimiter = params.delimiter ?? ",";
           const hasHeader = params.has_header ?? true;
           if (filePath) {
-            const { readFileSync: readFileSync38, existsSync: existsSync53 } = await import("fs");
+            const { readFileSync: readFileSync38, existsSync: existsSync54 } = await import("fs");
             const { resolve: resolve48 } = await import("path");
             const abs = resolve48(filePath);
-            if (!existsSync53(abs)) return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${abs}`, output: "" };
+            if (!existsSync54(abs)) return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${abs}`, output: "" };
             csvContent = readFileSync38(abs, "utf-8");
           } else if (content) {
             csvContent = content;
@@ -8268,10 +8913,10 @@ var init_xml_parse = __esm({
           const filePath = params.file_path;
           const content = params.content;
           if (filePath) {
-            const { readFileSync: readFileSync38, existsSync: existsSync53 } = await import("fs");
+            const { readFileSync: readFileSync38, existsSync: existsSync54 } = await import("fs");
             const { resolve: resolve48 } = await import("path");
             const abs = resolve48(filePath);
-            if (!existsSync53(abs)) return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${abs}`, output: "" };
+            if (!existsSync54(abs)) return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${abs}`, output: "" };
             xmlContent = readFileSync38(abs, "utf-8");
           } else if (content) {
             xmlContent = content;
@@ -8313,10 +8958,10 @@ var init_yaml_parse = __esm({
           const filePath = params.file_path;
           const content = params.content;
           if (filePath) {
-            const { readFileSync: readFileSync38, existsSync: existsSync53 } = await import("fs");
+            const { readFileSync: readFileSync38, existsSync: existsSync54 } = await import("fs");
             const { resolve: resolve48 } = await import("path");
             const abs = resolve48(filePath);
-            if (!existsSync53(abs)) return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${abs}`, output: "" };
+            if (!existsSync54(abs)) return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${abs}`, output: "" };
             yamlContent = readFileSync38(abs, "utf-8");
           } else if (content) {
             yamlContent = content;
@@ -8359,10 +9004,10 @@ var init_toml_parse = __esm({
           const filePath = params.file_path;
           let tomlContent = "";
           if (filePath) {
-            const { readFileSync: readFileSync38, existsSync: existsSync53 } = await import("fs");
+            const { readFileSync: readFileSync38, existsSync: existsSync54 } = await import("fs");
             const { resolve: resolve48 } = await import("path");
             const abs = resolve48(filePath);
-            if (!existsSync53(abs)) return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${abs}`, output: "" };
+            if (!existsSync54(abs)) return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${abs}`, output: "" };
             tomlContent = readFileSync38(abs, "utf-8");
           } else if (content) {
             tomlContent = content;
@@ -8411,10 +9056,10 @@ var init_data_transform = __esm({
           const output = params.output;
           let inputStr = "";
           if (filePath) {
-            const { readFileSync: readFileSync38, existsSync: existsSync53 } = await import("fs");
+            const { readFileSync: readFileSync38, existsSync: existsSync54 } = await import("fs");
             const { resolve: resolve48 } = await import("path");
             const abs = resolve48(filePath);
-            if (!existsSync53(abs)) return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${abs}`, output: "" };
+            if (!existsSync54(abs)) return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${abs}`, output: "" };
             inputStr = readFileSync38(abs, "utf-8");
           } else if (data) {
             inputStr = data;
@@ -8623,7 +9268,7 @@ var init_data_diff = __esm({
 });
 
 // src/tools/builtin/data/template_render.ts
-import { readFileSync as readFileSync26, existsSync as existsSync39, writeFileSync as writeFileSync8 } from "fs";
+import { readFileSync as readFileSync26, existsSync as existsSync40, writeFileSync as writeFileSync8 } from "fs";
 import { resolve as resolve35 } from "path";
 function escapeRegex5(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -8657,7 +9302,7 @@ var init_template_render = __esm({
           let template = "";
           if (filePath) {
             const abs = resolve35(filePath);
-            if (!existsSync39(abs)) return { success: false, error: `\u6A21\u677F\u6587\u4EF6\u4E0D\u5B58\u5728: ${abs}`, output: "" };
+            if (!existsSync40(abs)) return { success: false, error: `\u6A21\u677F\u6587\u4EF6\u4E0D\u5B58\u5728: ${abs}`, output: "" };
             template = readFileSync26(abs, "utf-8");
           } else if (templateStr) {
             template = templateStr;
@@ -8833,8 +9478,8 @@ ${results.join("\n")}
 });
 
 // src/tools/builtin/security/encrypt_file.ts
-import { readFileSync as readFileSync28, writeFileSync as writeFileSync9, existsSync as existsSync41, mkdirSync as mkdirSync10 } from "fs";
-import { resolve as resolve37, dirname as dirname7 } from "path";
+import { readFileSync as readFileSync28, writeFileSync as writeFileSync9, existsSync as existsSync42, mkdirSync as mkdirSync11 } from "fs";
+import { resolve as resolve37, dirname as dirname8 } from "path";
 var encrypt_file;
 var init_encrypt_file = __esm({
   "src/tools/builtin/security/encrypt_file.ts"() {
@@ -8861,15 +9506,15 @@ var init_encrypt_file = __esm({
           const output = resolve37(params.output);
           const password = params.password;
           const algorithm = params.algorithm ?? "aes-256-cbc";
-          if (!existsSync41(filePath)) return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${filePath}`, output: "" };
+          if (!existsSync42(filePath)) return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${filePath}`, output: "" };
           const crypto = await import("crypto");
           const content = readFileSync28(filePath);
           const key = crypto.scryptSync(password || "default-secret-key", "salt", algorithm === "aes-256-cbc" ? 32 : 16);
           const iv = crypto.randomBytes(16);
           const cipher = crypto.createCipheriv(algorithm, key, iv);
           const encrypted = Buffer.concat([iv, cipher.update(content), cipher.final()]);
-          const outDir = dirname7(output);
-          if (!existsSync41(outDir)) mkdirSync10(outDir, { recursive: true });
+          const outDir = dirname8(output);
+          if (!existsSync42(outDir)) mkdirSync11(outDir, { recursive: true });
           writeFileSync9(output, encrypted);
           return {
             success: true,
@@ -8885,8 +9530,8 @@ var init_encrypt_file = __esm({
 });
 
 // src/tools/builtin/security/decrypt_file.ts
-import { readFileSync as readFileSync29, writeFileSync as writeFileSync10, existsSync as existsSync42, mkdirSync as mkdirSync11 } from "fs";
-import { resolve as resolve38, dirname as dirname8 } from "path";
+import { readFileSync as readFileSync29, writeFileSync as writeFileSync10, existsSync as existsSync43, mkdirSync as mkdirSync12 } from "fs";
+import { resolve as resolve38, dirname as dirname9 } from "path";
 var decrypt_file;
 var init_decrypt_file = __esm({
   "src/tools/builtin/security/decrypt_file.ts"() {
@@ -8913,7 +9558,7 @@ var init_decrypt_file = __esm({
           const output = resolve38(params.output);
           const password = params.password;
           const algorithm = params.algorithm ?? "aes-256-cbc";
-          if (!existsSync42(filePath)) return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${filePath}`, output: "" };
+          if (!existsSync43(filePath)) return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${filePath}`, output: "" };
           const crypto = await import("crypto");
           const encrypted = readFileSync29(filePath);
           const iv = encrypted.subarray(0, 16);
@@ -8921,8 +9566,8 @@ var init_decrypt_file = __esm({
           const key = crypto.scryptSync(password || "default-secret-key", "salt", algorithm === "aes-256-cbc" ? 32 : 16);
           const decipher = crypto.createDecipheriv(algorithm, key, iv);
           const decrypted = Buffer.concat([decipher.update(data), decipher.final()]);
-          const outDir = dirname8(output);
-          if (!existsSync42(outDir)) mkdirSync11(outDir, { recursive: true });
+          const outDir = dirname9(output);
+          if (!existsSync43(outDir)) mkdirSync12(outDir, { recursive: true });
           writeFileSync10(output, decrypted);
           return {
             success: true,
@@ -8939,7 +9584,7 @@ var init_decrypt_file = __esm({
 
 // src/tools/builtin/security/hash_generate.ts
 import { createHash } from "crypto";
-import { readFileSync as readFileSync30, existsSync as existsSync43 } from "fs";
+import { readFileSync as readFileSync30, existsSync as existsSync44 } from "fs";
 import { resolve as resolve39 } from "path";
 var hash_generate;
 var init_hash_generate = __esm({
@@ -8968,7 +9613,7 @@ var init_hash_generate = __esm({
           let hash;
           if (filePath) {
             const abs = resolve39(filePath);
-            if (!existsSync43(abs)) return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${abs}`, output: "" };
+            if (!existsSync44(abs)) return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${abs}`, output: "" };
             const fileContent = readFileSync30(abs);
             hash = createHash(algorithm).update(fileContent).digest("hex");
           } else if (content) {
@@ -9254,7 +9899,7 @@ ${output.slice(0, 5e3)}`,
 
 // src/tools/builtin/project/build_project.ts
 import { execSync as execSync14 } from "child_process";
-import { readFileSync as readFileSync31, existsSync as existsSync44 } from "fs";
+import { readFileSync as readFileSync31, existsSync as existsSync45 } from "fs";
 import { resolve as resolve40 } from "path";
 var build_project;
 var init_build_project = __esm({
@@ -9282,7 +9927,7 @@ var init_build_project = __esm({
           const tool = params.tool ?? "auto";
           let cmd = "";
           const pkgPath = resolve40(cwd, "package.json");
-          if (tool === "auto" && existsSync44(pkgPath)) {
+          if (tool === "auto" && existsSync45(pkgPath)) {
             const pkg = JSON.parse(readFileSync31(pkgPath, "utf-8"));
             const scripts = pkg.scripts || {};
             if (scripts.build) cmd = `npm run build`;
@@ -9332,7 +9977,7 @@ ${output.slice(0, 1e4)}`,
 
 // src/tools/builtin/project/run_test.ts
 import { execSync as execSync15 } from "child_process";
-import { readFileSync as readFileSync32, existsSync as existsSync45 } from "fs";
+import { readFileSync as readFileSync32, existsSync as existsSync46 } from "fs";
 import { resolve as resolve41 } from "path";
 var run_test;
 var init_run_test = __esm({
@@ -9363,7 +10008,7 @@ var init_run_test = __esm({
           let cmd = "";
           if (runner === "auto") {
             const pkgPath = resolve41(cwd, "package.json");
-            if (existsSync45(pkgPath)) {
+            if (existsSync46(pkgPath)) {
               const pkg = JSON.parse(readFileSync32(pkgPath, "utf-8"));
               const scripts = pkg.scripts || {};
               if (scripts.test) cmd = `npm run test`;
@@ -9482,7 +10127,7 @@ ${output.slice(0, 1e4)}`,
 });
 
 // src/tools/builtin/project/env_manage.ts
-import { readFileSync as readFileSync33, writeFileSync as writeFileSync11, existsSync as existsSync46 } from "fs";
+import { readFileSync as readFileSync33, writeFileSync as writeFileSync11, existsSync as existsSync47 } from "fs";
 import { resolve as resolve42 } from "path";
 var env_manage;
 var init_env_manage = __esm({
@@ -9514,14 +10159,14 @@ var init_env_manage = __esm({
           if (action === "list_envs") {
             const cwd = process.cwd();
             const envs = [".env", ".env.local", ".env.development", ".env.production", ".env.test"];
-            const found = envs.filter((f) => existsSync46(resolve42(cwd, f)));
+            const found = envs.filter((f) => existsSync47(resolve42(cwd, f)));
             return {
               success: true,
               output: found.join("\n") || "\u672A\u627E\u5230 .env \u6587\u4EF6",
               metadata: { files: found }
             };
           }
-          if (!existsSync46(abs)) {
+          if (!existsSync47(abs)) {
             if (action === "set" && key && value !== void 0) {
               writeFileSync11(abs, `${key}=${value}`, "utf-8");
               return { success: true, output: `\u5DF2\u521B\u5EFA ${filePath} \u5E76\u8BBE\u7F6E ${key}=${value}` };
@@ -9568,7 +10213,7 @@ var init_env_manage = __esm({
 });
 
 // src/tools/builtin/project/config_manage.ts
-import { readFileSync as readFileSync34, writeFileSync as writeFileSync12, existsSync as existsSync47 } from "fs";
+import { readFileSync as readFileSync34, writeFileSync as writeFileSync12, existsSync as existsSync48 } from "fs";
 import { resolve as resolve43 } from "path";
 var config_manage;
 var init_config_manage = __esm({
@@ -9608,7 +10253,7 @@ var init_config_manage = __esm({
               ".prettierrc"
             ];
             const cwd = process.cwd();
-            const found = configs.filter((f) => existsSync47(resolve43(cwd, f)));
+            const found = configs.filter((f) => existsSync48(resolve43(cwd, f)));
             return {
               success: true,
               output: `\u9879\u76EE\u914D\u7F6E\u6587\u4EF6:
@@ -9627,7 +10272,7 @@ NODE_ENV=development
             return { success: false, error: "\u7F3A\u5C11 file_path \u53C2\u6570", output: "" };
           }
           const abs = resolve43(filePath);
-          if (!existsSync47(abs)) {
+          if (!existsSync48(abs)) {
             return { success: false, error: `\u914D\u7F6E\u6587\u4EF6\u4E0D\u5B58\u5728: ${abs}`, output: "" };
           }
           if (action === "read") {
@@ -9680,7 +10325,7 @@ NODE_ENV=development
 
 // src/tools/builtin/project/docker_manage.ts
 import { execSync as execSync17 } from "child_process";
-import { existsSync as existsSync48 } from "fs";
+import { existsSync as existsSync49 } from "fs";
 import { resolve as resolve44 } from "path";
 var docker_manage;
 var init_docker_manage = __esm({
@@ -9716,7 +10361,7 @@ var init_docker_manage = __esm({
           switch (action) {
             case "build": {
               const dockerfile = resolve44(cwd, "Dockerfile");
-              if (!existsSync48(dockerfile)) {
+              if (!existsSync49(dockerfile)) {
                 return { success: false, error: `Dockerfile \u4E0D\u5B58\u5728: ${dockerfile}`, output: "" };
               }
               cmd = `docker build ${options} -t ${image || "app"} .`;
@@ -9811,10 +10456,10 @@ var init_context_summarize = __esm({
           const maxLength = params.max_length ?? 500;
           let content = "";
           if (filePath) {
-            const { readFileSync: readFileSync38, existsSync: existsSync53 } = await import("fs");
+            const { readFileSync: readFileSync38, existsSync: existsSync54 } = await import("fs");
             const { resolve: resolve48 } = await import("path");
             const abs = resolve48(filePath);
-            if (!existsSync53(abs)) return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${abs}`, output: "" };
+            if (!existsSync54(abs)) return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${abs}`, output: "" };
             content = readFileSync38(abs, "utf-8");
           } else if (text) {
             content = text;
@@ -9917,9 +10562,9 @@ ${list.join("\n")}`,
 });
 
 // src/tools/builtin/ai/skill_create.ts
-import { mkdirSync as mkdirSync12, existsSync as existsSync49 } from "fs";
+import { mkdirSync as mkdirSync13, existsSync as existsSync50 } from "fs";
 import { writeFile as writeFile4 } from "fs/promises";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 var skill_create;
 var init_skill_create = __esm({
   "src/tools/builtin/ai/skill_create.ts"() {
@@ -9947,8 +10592,8 @@ var init_skill_create = __esm({
           const description = params.description || `${name} \u6280\u80FD`;
           const prompt = params.prompt;
           const triggers = params.triggers || [];
-          const skillDir = join9(DEEPER_SKILLS_DIR, name);
-          if (!existsSync49(skillDir)) mkdirSync12(skillDir, { recursive: true });
+          const skillDir = join10(DEEPER_SKILLS_DIR, name);
+          if (!existsSync50(skillDir)) mkdirSync13(skillDir, { recursive: true });
           const yaml = [
             `name: ${name}`,
             `description: ${description}`,
@@ -9962,7 +10607,7 @@ ${yaml}
 ---
 
 ${prompt}`;
-          await writeFile4(join9(skillDir, "skill.md"), md, "utf-8");
+          await writeFile4(join10(skillDir, "skill.md"), md, "utf-8");
           return {
             success: true,
             output: `Skill "${name}" \u5DF2\u521B\u5EFA
@@ -10036,13 +10681,13 @@ var init_tool_create = __esm({
 });
 
 // src/tools/builtin/ai/memory_store.ts
-import { readFileSync as readFileSync35, writeFileSync as writeFileSync13, existsSync as existsSync50, mkdirSync as mkdirSync13 } from "fs";
-import { join as join10 } from "path";
+import { readFileSync as readFileSync35, writeFileSync as writeFileSync13, existsSync as existsSync51, mkdirSync as mkdirSync14 } from "fs";
+import { join as join11 } from "path";
 var MEMORY_DIR, memory_store;
 var init_memory_store = __esm({
   "src/tools/builtin/ai/memory_store.ts"() {
     "use strict";
-    MEMORY_DIR = join10(process.env.HOME || process.env.USERPROFILE || process.cwd(), ".deepercode", "memories");
+    MEMORY_DIR = join11(process.env.HOME || process.env.USERPROFILE || process.cwd(), ".deepercode", "memories");
     memory_store = {
       name: "memory_store",
       description: "\u6301\u4E45\u5316\u8BB0\u5FC6\u5B58\u50A8",
@@ -10065,29 +10710,29 @@ var init_memory_store = __esm({
           const key = params.key;
           const value = params.value;
           const query = params.query;
-          if (!existsSync50(MEMORY_DIR)) {
-            mkdirSync13(MEMORY_DIR, { recursive: true });
+          if (!existsSync51(MEMORY_DIR)) {
+            mkdirSync14(MEMORY_DIR, { recursive: true });
           }
           switch (action) {
             case "set": {
               if (!key || value === void 0) return { success: false, error: "set \u9700\u8981 key \u548C value \u53C2\u6570", output: "" };
-              const memPath = join10(MEMORY_DIR, `${key}.json`);
+              const memPath = join11(MEMORY_DIR, `${key}.json`);
               writeFileSync13(memPath, JSON.stringify({ key, value, timestamp: Date.now() }), "utf-8");
               return { success: true, output: `\u8BB0\u5FC6\u5DF2\u4FDD\u5B58: ${key}` };
             }
             case "get": {
               if (!key) return { success: false, error: "get \u9700\u8981 key \u53C2\u6570", output: "" };
-              const memPath = join10(MEMORY_DIR, `${key}.json`);
-              if (!existsSync50(memPath)) return { success: false, error: `\u8BB0\u5FC6\u4E0D\u5B58\u5728: ${key}`, output: "" };
+              const memPath = join11(MEMORY_DIR, `${key}.json`);
+              if (!existsSync51(memPath)) return { success: false, error: `\u8BB0\u5FC6\u4E0D\u5B58\u5728: ${key}`, output: "" };
               const data = JSON.parse(readFileSync35(memPath, "utf-8"));
               return { success: true, output: data.value };
             }
             case "delete": {
               if (!key) return { success: false, error: "delete \u9700\u8981 key \u53C2\u6570", output: "" };
-              const memPath = join10(MEMORY_DIR, `${key}.json`);
-              if (!existsSync50(memPath)) return { success: false, error: `\u8BB0\u5FC6\u4E0D\u5B58\u5728: ${key}`, output: "" };
-              const { unlinkSync: unlinkSync2 } = await import("fs");
-              unlinkSync2(memPath);
+              const memPath = join11(MEMORY_DIR, `${key}.json`);
+              if (!existsSync51(memPath)) return { success: false, error: `\u8BB0\u5FC6\u4E0D\u5B58\u5728: ${key}`, output: "" };
+              const { unlinkSync: unlinkSync3 } = await import("fs");
+              unlinkSync3(memPath);
               return { success: true, output: `\u8BB0\u5FC6\u5DF2\u5220\u9664: ${key}` };
             }
             case "list": {
@@ -10106,7 +10751,7 @@ var init_memory_store = __esm({
               const files = readdirSync5(MEMORY_DIR).filter((f) => f.endsWith(".json"));
               const matches = [];
               for (const f of files) {
-                const data = JSON.parse(readFileSync35(join10(MEMORY_DIR, f), "utf-8"));
+                const data = JSON.parse(readFileSync35(join11(MEMORY_DIR, f), "utf-8"));
                 if (data.value.includes(query) || data.key.includes(query)) {
                   matches.push(`${data.key}: ${data.value.slice(0, 200)}`);
                 }
@@ -10378,17 +11023,17 @@ var init_notify_user = __esm({
           const output = `${icons[level] || ""} [${level.toUpperCase()}] ${title}: ${message}`;
           try {
             if (process.platform === "win32") {
-              const { execSync: execSync19 } = await import("child_process");
-              execSync19(`powershell -Command "Add-Type -AssemblyName System.Windows.Forms; $notify = New-Object System.Windows.Forms.NotifyIcon; $notify.Icon = [System.Drawing.SystemIcons]::Information; $notify.Visible = $true; $notify.ShowBalloonTip(5000, '${title}', '${message}', [System.Windows.Forms.ToolTipIcon]::${level === "error" ? "Error" : "Info"}); Start-Sleep -Seconds 6; $notify.Dispose()"`, {
+              const { execSync: execSync20 } = await import("child_process");
+              execSync20(`powershell -Command "Add-Type -AssemblyName System.Windows.Forms; $notify = New-Object System.Windows.Forms.NotifyIcon; $notify.Icon = [System.Drawing.SystemIcons]::Information; $notify.Visible = $true; $notify.ShowBalloonTip(5000, '${title}', '${message}', [System.Windows.Forms.ToolTipIcon]::${level === "error" ? "Error" : "Info"}); Start-Sleep -Seconds 6; $notify.Dispose()"`, {
                 timeout: 1e4,
                 stdio: "ignore"
               });
             } else if (process.platform === "darwin") {
-              const { execSync: execSync19 } = await import("child_process");
-              execSync19(`osascript -e 'display notification "${message}" with title "${title}"'`, { stdio: "ignore" });
+              const { execSync: execSync20 } = await import("child_process");
+              execSync20(`osascript -e 'display notification "${message}" with title "${title}"'`, { stdio: "ignore" });
             } else {
-              const { execSync: execSync19 } = await import("child_process");
-              execSync19(`notify-send "${title}" "${message}"`, { stdio: "ignore" });
+              const { execSync: execSync20 } = await import("child_process");
+              execSync20(`notify-send "${title}" "${message}"`, { stdio: "ignore" });
             }
             return { success: true, output, metadata: { title, level, notified: true } };
           } catch {
@@ -10403,7 +11048,7 @@ var init_notify_user = __esm({
 });
 
 // src/tools/builtin/system/log_viewer.ts
-import { readFileSync as readFileSync36, existsSync as existsSync51 } from "fs";
+import { readFileSync as readFileSync36, existsSync as existsSync52 } from "fs";
 import { resolve as resolve47 } from "path";
 var log_viewer;
 var init_log_viewer = __esm({
@@ -10434,7 +11079,7 @@ var init_log_viewer = __esm({
           if (action !== "clear" && !filePath) {
             const defaultLogs = ["npm-debug.log", "yarn-error.log", ".log", "logs/"];
             const cwd = process.cwd();
-            const found = defaultLogs.filter((f) => existsSync51(resolve47(cwd, f)));
+            const found = defaultLogs.filter((f) => existsSync52(resolve47(cwd, f)));
             return {
               success: true,
               output: `\u8BF7\u6307\u5B9A file_path\u3002\u9879\u76EE\u76EE\u5F55\u4E2D\u7684\u65E5\u5FD7\u6587\u4EF6:
@@ -10447,7 +11092,7 @@ ${found.length > 0 ? found.join("\n") : "  (\u672A\u627E\u5230)"}`
             writeFileSync15(abs, "", "utf-8");
             return { success: true, output: `\u65E5\u5FD7\u5DF2\u6E05\u7A7A: ${abs}` };
           }
-          if (!existsSync51(abs)) {
+          if (!existsSync52(abs)) {
             return { success: false, error: `\u65E5\u5FD7\u6587\u4EF6\u4E0D\u5B58\u5728: ${abs}`, output: "" };
           }
           const content = readFileSync36(abs, "utf-8");
@@ -10729,8 +11374,28 @@ __export(chat_repl_exports, {
 });
 import readline from "readline";
 import process5 from "process";
-import { existsSync as existsSync52, mkdirSync as mkdirSync14, readFileSync as readFileSync37, writeFileSync as writeFileSync14, readdirSync as readdirSync4 } from "fs";
-import { join as join11 } from "path";
+import { existsSync as existsSync53, mkdirSync as mkdirSync15, readFileSync as readFileSync37, writeFileSync as writeFileSync14, readdirSync as readdirSync4, statSync as statSync12, copyFileSync as copyFileSync2, unlinkSync as unlinkSync2 } from "fs";
+import { join as join12, relative as relative6 } from "path";
+import { execSync as execSync19 } from "child_process";
+function backupFile(filePath) {
+  if (!existsSync53(filePath)) return;
+  try {
+    if (!existsSync53(BACKUP_DIR)) mkdirSync15(BACKUP_DIR, { recursive: true });
+    const rel = relative6(process5.cwd(), filePath).replace(/[/\\]/g, "_");
+    const ts = Date.now();
+    const backupPath = join12(BACKUP_DIR, `${ts}_${rel}`);
+    copyFileSync2(filePath, backupPath);
+    fileBackupStack.push({ path: filePath, backupPath, timestamp: ts });
+    if (fileBackupStack.length > MAX_BACKUPS) {
+      const old = fileBackupStack.shift();
+      try {
+        unlinkSync2(old.backupPath);
+      } catch {
+      }
+    }
+  } catch {
+  }
+}
 function getSkillSystemPrompt() {
   if (!skillEngine) return "";
   return skillEngine.getSystemPrompt();
@@ -10755,7 +11420,7 @@ async function startRepl(opts) {
         let curTc = null;
         let se = null;
         try {
-          const stream = await callApi(opts, msgs, tds, 0, 131072);
+          const stream = await callApi(opts, msgs, tds, 131072);
           GS.api++;
           ce = 0;
           for await (const chunk of stream) {
@@ -10767,10 +11432,11 @@ async function startRepl(opts) {
               const tc = chunk.tool_call;
               if (tc) curTc = { id: tc.id, name: tc.name, argsStr: "" };
             }
-            if (chunk.type === "tool_call_args" && curTc) curTc.argsStr += chunk.content || "";
             if (chunk.type === "tool_call_end" && curTc) {
+              const tcData = chunk.tool_call;
               try {
-                tcs.push({ id: curTc.id, name: curTc.name, args: JSON.parse(curTc.argsStr || "{}") });
+                const args = tcData?.arguments || JSON.parse(curTc.argsStr || "{}");
+                tcs.push({ id: curTc.id, name: curTc.name, args });
               } catch {
                 tcs.push({ id: curTc.id, name: curTc.name, args: {} });
               }
@@ -10807,7 +11473,11 @@ async function startRepl(opts) {
               continue;
             }
             try {
-              const r2 = await tool.execute(tc.args, new AbortController().signal);
+              const ac = new AbortController();
+              const timeout = TOOL_TIMEOUT_MAP[tc.name] || DEFAULT_TOOL_TIMEOUT;
+              const timer = setTimeout(() => ac.abort(), timeout);
+              const r2 = await tool.execute(tc.args, ac.signal);
+              clearTimeout(timer);
               const txt = sanitize(r2.output || "").slice(0, TOOL_RESULT_MAX);
               lh.push({ role: "tool", content: r2.success ? txt : `Error: ${r2.error}`, tool_call_id: tc.id });
               GS.tc++;
@@ -10843,7 +11513,7 @@ async function startRepl(opts) {
     }
   });
   const history = [];
-  if (!existsSync52(SESSION_DIR)) mkdirSync14(SESSION_DIR, { recursive: true });
+  if (!existsSync53(SESSION_DIR)) mkdirSync15(SESSION_DIR, { recursive: true });
   const sid = `sess_${Date.now()}`;
   setSessionId(sid);
   await xmemory.load();
@@ -10903,13 +11573,14 @@ ${prevSummary.slice(0, 800)}` });
   };
   drawHeader();
   let resizeTimer = null;
-  process5.stdout.on("resize", () => {
+  const onResize = () => {
     if (resizeTimer) return;
     resizeTimer = setTimeout(() => {
       resizeTimer = null;
       Oflush();
     }, 200);
-  });
+  };
+  process5.stdout.on("resize", onResize);
   let resolveLine = null;
   let running = true;
   const rl = readline.createInterface({ input: process5.stdin, output: process5.stdout, terminal: true });
@@ -10944,7 +11615,13 @@ ${prevSummary.slice(0, 800)}` });
     else showPrompt();
     return ok;
   };
-  rl.on("SIGINT", () => {
+  const onSigint = () => {
+    if (currentAbortController) {
+      currentAbortController.abort();
+      currentAbortController = null;
+      O(y("\n  \u26A1 \u5DF2\u4E2D\u65AD\u5F53\u524D\u8BF7\u6C42\n"));
+      return;
+    }
     if (resolveLine) {
       const cb = resolveLine;
       resolveLine = null;
@@ -10952,22 +11629,28 @@ ${prevSummary.slice(0, 800)}` });
       return;
     }
     Oflush();
+    process5.stdout.removeListener("resize", onResize);
+    process5.removeListener("uncaughtException", onUCE);
+    process5.removeListener("unhandledRejection", onUHR);
     xmemory.save().then(() => {
       O("\n" + y("\u518D\u89C1\uFF01") + "\n");
       running = false;
       rl.close();
       process5.exit(0);
     });
-  });
-  process5.on("uncaughtException", (err) => {
-    if (!err.message?.includes("readline")) O(r(`
+  };
+  rl.on("SIGINT", onSigint);
+  const onUCE = (err) => {
+    if (!err.message?.includes("readline") && !err.message?.includes("abort")) O(r(`
   \u26A0 ${err.message}`) + "\n");
-  });
-  process5.on("unhandledRejection", (reason) => {
+  };
+  process5.on("uncaughtException", onUCE);
+  const onUHR = (reason) => {
     const m = reason instanceof Error ? reason.message : String(reason);
     if (!m.includes("readline") && !m.includes("Abort") && !m.includes("timeout")) O(r(`
   \u26A0 ${m}`) + "\n");
-  });
+  };
+  process5.on("unhandledRejection", onUHR);
   while (running) {
     currentPrompt = c("\u276F ");
     const tasks = getTodos();
@@ -10995,6 +11678,12 @@ ${prevSummary.slice(0, 800)}` });
         O(G("  /mcp") + G("       MCP\u670D\u52A1\u5668") + "\n");
         O(G("  /plan") + G(" <\u4EFB\u52A1> \u5148\u51FA\u65B9\u6848") + "\n");
         O(G("  /spec") + G(" <\u4EFB\u52A1> \u5148\u51FA\u89C4\u683C") + "\n");
+        O(G("  /review") + G(" <\u8DEF\u5F84> \u4EE3\u7801\u5BA1\u67E5") + "\n");
+        O(G("  /fix") + G(" [\u76EE\u6807] \u81EA\u52A8\u4FEE\u590D") + "\n");
+        O(G("  /commit") + G("    \u667A\u80FD\u63D0\u4EA4") + "\n");
+        O(G("  /analyze") + G(" [\u8DEF\u5F84] \u9879\u76EE\u5206\u6790") + "\n");
+        O(G("  /diff") + G(" <\u6587\u4EF6> \u53D8\u66F4\u9884\u89C8") + "\n");
+        O(G("  /undo") + G("      \u64A4\u9500\u64CD\u4F5C") + "\n");
         O(G("  /status") + G("    \u5F53\u524D\u72B6\u6001") + "\n");
         O(G("  /model") + G("     \u6A21\u578B\u8BBE\u7F6E") + "\n");
         O(G("  /config") + G("    \u914D\u7F6E\u7BA1\u7406") + "\n");
@@ -11089,11 +11778,11 @@ ${prevSummary.slice(0, 800)}` });
         continue;
       }
       if (cmd === "/rules") {
-        const projectRules = join11(process5.cwd(), ".deeper", "rules.md");
-        const globalRules = join11(DEEPER_HOME, "rules.md");
+        const projectRules = join12(process5.cwd(), ".deeper", "rules.md");
+        const globalRules = join12(DEEPER_HOME, "rules.md");
         O(b(c("  Rules")) + "\n");
         const showRules = (label, path) => {
-          if (existsSync52(path)) {
+          if (existsSync53(path)) {
             const content = readFileSync37(path, "utf-8");
             O(G(`  ${label}: `) + c(path) + G(` (${content.split("\n").length}\u884C)`) + "\n");
             const lines = content.split("\n").slice(0, 8);
@@ -11111,7 +11800,8 @@ ${prevSummary.slice(0, 800)}` });
       if (cmd === "/help") {
         O(c("  /help /clear /quit /save [name] /load|resume [name] /sessions\n"));
         O(c("  /tools [cat] /stats /memory /tasks /model /config /cwd /export /init /mcp /rules\n"));
-        O(c("  /plan <\u4EFB\u52A1> /spec <\u4EFB\u52A1> /status\n\n"));
+        O(c("  /plan <\u4EFB\u52A1> /spec <\u4EFB\u52A1> /review <\u8DEF\u5F84> /fix [\u76EE\u6807]\n"));
+        O(c("  /commit /analyze [\u8DEF\u5F84] /diff <\u6587\u4EF6> /undo /status\n\n"));
         continue;
       }
       if (cmd === "/plan") {
@@ -11155,6 +11845,178 @@ ${prevSummary.slice(0, 800)}` });
         await runLoop(opts, history, tools, sfdefs, confirm);
         continue;
       }
+      if (cmd === "/review") {
+        const target = arg || ".";
+        O(b(c("  Review Mode")) + G(` \u2022 ${target}`) + "\n\n");
+        history.push({ role: "system", content: `[Review Mode]
+\u4F60\u662F\u4E00\u4F4D\u8D44\u6DF1\u4EE3\u7801\u5BA1\u67E5\u4E13\u5BB6\u3002\u8BF7\u5BF9\u6307\u5B9A\u4EE3\u7801\u8FDB\u884C\u5168\u9762\u5BA1\u67E5\uFF1A
+
+1. \u5148\u7528 read_file / glob_find / grep_search \u8BFB\u53D6\u76F8\u5173\u4EE3\u7801
+2. \u4ECE\u4EE5\u4E0B\u7EF4\u5EA6\u9010\u9879\u5BA1\u67E5\u5E76\u8BC4\u5206\uFF081-10\uFF09\uFF1A
+   - \u4EE3\u7801\u8D28\u91CF\uFF1A\u53EF\u8BFB\u6027\u3001\u547D\u540D\u3001\u7ED3\u6784
+   - \u5B89\u5168\u6027\uFF1A\u6CE8\u5165\u3001XSS\u3001\u5BC6\u94A5\u6CC4\u9732\u3001\u6743\u9650\u95EE\u9898
+   - \u6027\u80FD\uFF1AN+1\u67E5\u8BE2\u3001\u5185\u5B58\u6CC4\u6F0F\u3001\u4E0D\u5FC5\u8981\u7684\u8BA1\u7B97
+   - \u53EF\u7EF4\u62A4\u6027\uFF1A\u8026\u5408\u5EA6\u3001\u91CD\u590D\u4EE3\u7801\u3001\u6D4B\u8BD5\u8986\u76D6
+   - \u6700\u4F73\u5B9E\u8DF5\uFF1A\u8BBE\u8BA1\u6A21\u5F0F\u3001SOLID\u539F\u5219\u3001\u9519\u8BEF\u5904\u7406
+3. \u5BF9\u6BCF\u4E2A\u95EE\u9898\u7ED9\u51FA\uFF1A\u6587\u4EF6\u8DEF\u5F84\u3001\u884C\u53F7\u8303\u56F4\u3001\u95EE\u9898\u63CF\u8FF0\u3001\u4FEE\u590D\u5EFA\u8BAE\u3001\u4E25\u91CD\u7A0B\u5EA6(\u{1F534}\u9AD8/\u{1F7E1}\u4E2D/\u{1F7E2}\u4F4E)
+4. \u6700\u540E\u7ED9\u51FA\u603B\u4F53\u8BC4\u5206\u548C\u6539\u8FDB\u4F18\u5148\u7EA7\u5217\u8868
+
+\u5BA1\u67E5\u76EE\u6807\uFF1A${target}` });
+        history.push({ role: "user", content: `\u5BA1\u67E5 ${target} \u7684\u4EE3\u7801\u8D28\u91CF` });
+        const rvdefs = toolsToDefs(tools);
+        await runLoop(opts, history, tools, rvdefs, confirm);
+        continue;
+      }
+      if (cmd === "/commit") {
+        O(b(c("  Commit Mode")) + G(" \u2022 \u667A\u80FD\u63D0\u4EA4") + "\n\n");
+        try {
+          const statusOut = execSync19("git status --porcelain", { encoding: "utf-8", timeout: 1e4, cwd: process5.cwd() });
+          if (!statusOut.trim()) {
+            O(y("  \u6CA1\u6709\u672A\u63D0\u4EA4\u7684\u53D8\u66F4\n\n"));
+            continue;
+          }
+          const diffOut = execSync19("git diff --stat", { encoding: "utf-8", timeout: 15e3, cwd: process5.cwd() });
+          const stagedOut = execSync19("git diff --cached --stat", { encoding: "utf-8", timeout: 15e3, cwd: process5.cwd() });
+          const files = statusOut.trim().split("\n").filter(Boolean);
+          O(G(`  ${files.length} \u4E2A\u6587\u4EF6\u53D8\u66F4:
+`));
+          for (const f of files.slice(0, 20)) {
+            const status = f.slice(0, 2).trim();
+            const path = f.slice(3);
+            const icon = status === "M" ? y("M") : status === "A" ? g("A") : status === "D" ? r("D") : status === "?" ? G("?") : c(status);
+            O(G(`    ${icon} ${path.slice(0, 60)}`) + "\n");
+          }
+          if (files.length > 20) O(G(`    \u2026\u8FD8\u6709 ${files.length - 20} \u4E2A`) + "\n");
+          O("\n");
+          history.push({ role: "system", content: `[Commit Mode]
+\u5206\u6790 git \u53D8\u66F4\u5E76\u751F\u6210\u63D0\u4EA4\u4FE1\u606F\uFF1A
+1. \u5148\u7528 run_command \u6267\u884C git diff \u67E5\u770B\u5177\u4F53\u53D8\u66F4\u5185\u5BB9
+2. \u5206\u6790\u53D8\u66F4\u7C7B\u578B\u548C\u8303\u56F4\uFF0C\u751F\u6210\u7B26\u5408 Conventional Commits \u89C4\u8303\u7684\u63D0\u4EA4\u4FE1\u606F
+3. \u683C\u5F0F: type(scope): description
+   - type: feat/fix/refactor/docs/style/test/chore/perf
+   - scope: \u53EF\u9009\uFF0C\u5F71\u54CD\u7684\u6A21\u5757
+4. \u7528 run_command \u6267\u884C git add \u548C git commit
+5. \u5982\u679C\u53D8\u66F4\u8F83\u591A\uFF0C\u5EFA\u8BAE\u5206\u591A\u6B21\u63D0\u4EA4
+
+\u5F53\u524D\u53D8\u66F4\u7EDF\u8BA1\uFF1A
+${diffOut || stagedOut || "\u65E0staged\u53D8\u66F4"}` });
+          history.push({ role: "user", content: "\u5206\u6790\u53D8\u66F4\u5E76\u63D0\u4EA4" });
+          const cmdefs = toolsToDefs(tools);
+          await runLoop(opts, history, tools, cmdefs, confirm);
+        } catch (e) {
+          O(r(`  Git \u64CD\u4F5C\u5931\u8D25: ${e instanceof Error ? e.message.slice(0, 80) : String(e).slice(0, 80)}
+
+`));
+        }
+        continue;
+      }
+      if (cmd === "/analyze") {
+        const target = arg || process5.cwd();
+        O(b(c("  Analyze Mode")) + G(` \u2022 ${target}`) + "\n\n");
+        history.push({ role: "system", content: `[Analyze Mode]
+\u4F60\u662F\u4E00\u4F4D\u9879\u76EE\u67B6\u6784\u5206\u6790\u5E08\u3002\u8BF7\u5BF9\u9879\u76EE\u8FDB\u884C\u5168\u9762\u5206\u6790\uFF1A
+
+1. \u7528 glob_find \u626B\u63CF\u9879\u76EE\u76EE\u5F55\u7ED3\u6784
+2. \u7528 read_file \u8BFB\u53D6 package.json / tsconfig.json / Cargo.toml \u7B49\u914D\u7F6E
+3. \u7528 grep_search / codebase_search \u5206\u6790\u4EE3\u7801\u6A21\u5F0F
+4. \u8F93\u51FA\u4EE5\u4E0B\u5206\u6790\u62A5\u544A\uFF1A
+   - \u{1F4C1} \u9879\u76EE\u7ED3\u6784\u6811\uFF08\u5173\u952E\u76EE\u5F55\u548C\u6587\u4EF6\uFF09
+   - \u{1F6E0} \u6280\u672F\u6808\u8BC6\u522B\uFF08\u8BED\u8A00\u3001\u6846\u67B6\u3001\u5E93\u3001\u5DE5\u5177\u94FE\uFF09
+   - \u{1F4CA} \u4EE3\u7801\u7EDF\u8BA1\uFF08\u6587\u4EF6\u6570\u3001\u4EE3\u7801\u884C\u6570\u4F30\u7B97\u3001\u5404\u8BED\u8A00\u5360\u6BD4\uFF09
+   - \u{1F3D7}\uFE0F \u67B6\u6784\u6A21\u5F0F\uFF08MVC/\u5FAE\u670D\u52A1/\u5355\u4F53/\u63D2\u4EF6\u5F0F\u7B49\uFF09
+   - \u{1F517} \u4F9D\u8D56\u5173\u7CFB\uFF08\u6838\u5FC3\u4F9D\u8D56\u3001\u5F00\u53D1\u4F9D\u8D56\u3001\u7248\u672C\u98CE\u9669\uFF09
+   - \u26A0\uFE0F \u6F5C\u5728\u95EE\u9898\uFF08\u8FC7\u65F6\u4F9D\u8D56\u3001\u5B89\u5168\u98CE\u9669\u3001\u4EE3\u7801\u5F02\u5473\uFF09
+   - \u{1F4A1} \u6539\u8FDB\u5EFA\u8BAE\uFF08\u4F18\u5148\u7EA7\u6392\u5E8F\uFF09
+
+\u5206\u6790\u76EE\u6807\uFF1A${target}` });
+        history.push({ role: "user", content: `\u5206\u6790\u9879\u76EE ${target}` });
+        const andefs = toolsToDefs(tools);
+        await runLoop(opts, history, tools, andefs, confirm);
+        continue;
+      }
+      if (cmd === "/fix") {
+        const target = arg || "";
+        O(b(c("  Fix Mode")) + G(" \u2022 \u81EA\u52A8\u4FEE\u590D") + "\n\n");
+        history.push({ role: "system", content: `[Fix Mode]
+\u4F60\u662F\u4E00\u4F4D\u81EA\u52A8\u4FEE\u590D\u5DE5\u7A0B\u5E08\u3002\u8BF7\u6267\u884C\u4EE5\u4E0B\u6D41\u7A0B\uFF1A
+
+1. \u5148\u7528 run_command \u8FD0\u884C\u6784\u5EFA\u547D\u4EE4\uFF08\u5982 npm run build, tsc --noEmit, cargo check \u7B49\uFF09
+2. \u5982\u679C\u6784\u5EFA\u6210\u529F\uFF0C\u8FD0\u884C\u6D4B\u8BD5\uFF08npm test, cargo test \u7B49\uFF09
+3. \u5982\u679C\u6709\u9519\u8BEF\uFF1A
+   a. \u4ED4\u7EC6\u5206\u6790\u9519\u8BEF\u4FE1\u606F\uFF0C\u5B9A\u4F4D\u5230\u5177\u4F53\u6587\u4EF6\u548C\u884C\u53F7
+   b. \u7528 read_file \u8BFB\u53D6\u51FA\u9519\u6587\u4EF6\u7684\u76F8\u5173\u4EE3\u7801
+   c. \u7406\u89E3\u9519\u8BEF\u6839\u56E0\uFF0C\u5236\u5B9A\u4FEE\u590D\u65B9\u6848
+   d. \u7528 edit_file \u7CBE\u786E\u4FEE\u590D\uFF08\u4F18\u5148\u7528 edit \u800C\u975E\u91CD\u5199\u6574\u4E2A\u6587\u4EF6\uFF09
+   e. \u91CD\u65B0\u8FD0\u884C\u6784\u5EFA\u9A8C\u8BC1\u4FEE\u590D
+   f. \u91CD\u590D\u76F4\u5230\u6240\u6709\u9519\u8BEF\u6E05\u9664
+4. \u5982\u679C\u6D4B\u8BD5\u5931\u8D25\uFF0C\u540C\u6837\u5206\u6790\u5E76\u4FEE\u590D
+5. \u6700\u591A\u5C1D\u8BD5\u4FEE\u590D 5 \u8F6E\uFF0C\u907F\u514D\u65E0\u9650\u5FAA\u73AF
+6. \u6BCF\u6B21\u4FEE\u590D\u540E\u90FD\u91CD\u65B0\u9A8C\u8BC1
+
+${target ? `\u4FEE\u590D\u76EE\u6807\uFF1A${target}
+` : "\u81EA\u52A8\u68C0\u6D4B\u5E76\u4FEE\u590D\u6240\u6709\u6784\u5EFA/\u6D4B\u8BD5\u9519\u8BEF"}` });
+        history.push({ role: "user", content: target || "\u68C0\u6D4B\u5E76\u4FEE\u590D\u9879\u76EE\u9519\u8BEF" });
+        const fxdefs = toolsToDefs(tools);
+        await runLoop(opts, history, tools, fxdefs, confirm);
+        continue;
+      }
+      if (cmd === "/diff") {
+        if (!arg) {
+          O(y("  \u7528\u6CD5: /diff <\u6587\u4EF6\u8DEF\u5F84>\n  \u663E\u793A\u6587\u4EF6\u6700\u8FD1\u7684\u53D8\u66F4\n\n"));
+          continue;
+        }
+        const filePath = arg.startsWith("/") || arg.startsWith("\\") || arg.length > 2 ? arg : join12(process5.cwd(), arg);
+        if (fileBackupStack.length === 0) {
+          O(y("  \u6CA1\u6709\u53EF\u7528\u7684\u5907\u4EFD\u8BB0\u5F55\n\n"));
+          continue;
+        }
+        const backups = fileBackupStack.filter((b2) => b2.path === filePath).reverse();
+        if (backups.length === 0) {
+          const allBackups = [...fileBackupStack].reverse();
+          O(G("  \u6700\u8FD1\u7684\u6587\u4EF6\u53D8\u66F4:\n"));
+          for (const b2 of allBackups.slice(0, 10)) {
+            const rel = relative6(process5.cwd(), b2.path);
+            const time = new Date(b2.timestamp).toLocaleTimeString();
+            O(G(`    ${time} ${rel.slice(0, 50)}`) + "\n");
+          }
+          O("\n");
+          continue;
+        }
+        const latest = backups[0];
+        try {
+          const currentContent = existsSync53(filePath) ? readFileSync37(filePath, "utf-8") : "(\u6587\u4EF6\u5DF2\u5220\u9664)";
+          const backupContent = readFileSync37(latest.backupPath, "utf-8");
+          const diffResult = computeSimpleDiff(backupContent, currentContent, filePath);
+          O(b(c("  Diff")) + G(` \u2022 ${relative6(process5.cwd(), filePath)}`) + "\n\n");
+          O(diffResult + "\n\n");
+        } catch {
+          O(y("  \u65E0\u6CD5\u8BFB\u53D6\u6587\u4EF6\u8FDB\u884C\u5BF9\u6BD4\n\n"));
+        }
+        continue;
+      }
+      if (cmd === "/undo") {
+        if (fileBackupStack.length === 0) {
+          O(y("  \u6CA1\u6709\u53EF\u64A4\u9500\u7684\u64CD\u4F5C\n\n"));
+          continue;
+        }
+        const last = fileBackupStack[fileBackupStack.length - 1];
+        try {
+          const rel = relative6(process5.cwd(), last.path);
+          copyFileSync2(last.backupPath, last.path);
+          fileBackupStack.pop();
+          try {
+            unlinkSync2(last.backupPath);
+          } catch {
+          }
+          O(g("  \u2713 \u5DF2\u64A4\u9500") + G(` ${rel}`) + "\n");
+          O(G("  \u63D0\u793A: \u53EF\u7EE7\u7EED /undo \u64A4\u9500\u66F4\u591A\u64CD\u4F5C\n\n"));
+        } catch (e) {
+          O(r(`  \u64A4\u9500\u5931\u8D25: ${e instanceof Error ? e.message.slice(0, 60) : String(e).slice(0, 60)}
+
+`));
+        }
+        continue;
+      }
       O(G(`  \u672A\u77E5\u547D\u4EE4: ${cmd} (\u8F93\u5165 /help \u67E5\u770B\u5E2E\u52A9)
 
 `));
@@ -11169,6 +12031,9 @@ ${prevSummary.slice(0, 800)}` });
   }
   rl.close();
   Oflush();
+  process5.stdout.removeListener("resize", onResize);
+  process5.removeListener("uncaughtException", onUCE);
+  process5.removeListener("unhandledRejection", onUHR);
   await xmemory.save();
   if (mcpClient) mcpClient.disconnectAll();
   Oflush();
@@ -11221,8 +12086,9 @@ async function runLoop(opts, history, tools, toolDefs, confirm) {
         thinkAnimIv = null;
       }
     };
+    currentAbortController = new AbortController();
     try {
-      const stream = await callApi(opts, msgs, toolDefs, 0, amax);
+      const stream = await callApi(opts, msgs, toolDefs, amax, currentAbortController.signal);
       GS.api++;
       ce = 0;
       const cols = process5.stdout.columns || 80;
@@ -11261,10 +12127,11 @@ async function runLoop(opts, history, tools, toolDefs, confirm) {
           const tc = chunk.tool_call;
           if (tc) curTc = { id: tc.id, name: tc.name, argsStr: "" };
         }
-        if (chunk.type === "tool_call_args" && curTc) curTc.argsStr += chunk.content || "";
         if (chunk.type === "tool_call_end" && curTc) {
+          const tcData = chunk.tool_call;
           try {
-            tcs.push({ id: curTc.id, name: curTc.name, args: JSON.parse(curTc.argsStr || "{}") });
+            const args = tcData?.arguments || JSON.parse(curTc.argsStr || "{}");
+            tcs.push({ id: curTc.id, name: curTc.name, args });
           } catch {
             tcs.push({ id: curTc.id, name: curTc.name, args: {} });
           }
@@ -11278,8 +12145,15 @@ async function runLoop(opts, history, tools, toolDefs, confirm) {
       }
     } catch (e) {
       stopStreamAnim();
-      se = e instanceof Error ? e.message : String(e);
+      const errMsg = e instanceof Error ? e.message : String(e);
+      if (errMsg.includes("abort") || errMsg.includes("cancel")) {
+        se = null;
+        O(y("\n  \u26A1 \u8BF7\u6C42\u5DF2\u53D6\u6D88\n"));
+      } else {
+        se = errMsg;
+      }
     }
+    currentAbortController = null;
     stopStreamAnim();
     Oflush();
     const remaining = md.flush();
@@ -11415,14 +12289,19 @@ async function execTool(tc, tools, opts, confirm) {
     execAnimIv = setInterval(() => {
       rawWrite("\r" + thinkingAnimAt(toolName, toolStart));
     }, 80);
-    const execed = Promise.race([
-      tool.execute(tc.args, new AbortController().signal),
-      new Promise((_, rej) => setTimeout(() => rej(new Error("\u5DE5\u5177\u8D85\u65F6 (30s)")), 3e4))
-    ]);
+    const timeout = TOOL_TIMEOUT_MAP[tc.name] || DEFAULT_TOOL_TIMEOUT;
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), timeout);
+    if (tc.name === "write_file" || tc.name === "edit_file") {
+      const fp = tc.args.file_path || tc.args.path || tc.args.file || "";
+      if (fp) backupFile(fp);
+    }
     let result;
     try {
-      result = await execed;
+      result = await tool.execute(tc.args, ac.signal);
+      clearTimeout(timer);
     } catch (e) {
+      clearTimeout(timer);
       result = { success: false, error: e.message, output: "" };
     }
     stopToolAnim();
@@ -11487,56 +12366,71 @@ async function execTool(tc, tools, opts, confirm) {
 }
 function buildMsgs(history) {
   const r2 = [];
-  let sysContent = `You are DeeperCode V4-Pro, a full-stack coding agent.
-Rules:
-1. Read before write. Use tools to inspect project state first.
-2. Write COMPLETE files. No placeholders like "// ..." or "rest of code".
-3. One write_file = one complete file. Batch independent writes.
-4. Use todo_manager for multi-step tasks. Update status as you progress.
-5. Keep reasoning brief. Prefer action over explanation.
-6. cwd=${process5.cwd()} plat=${process5.platform}
-7. Respond in Chinese when user uses Chinese.`;
+  let sysContent = `You are DeeperCode V4-Pro, an elite full-stack AI coding agent with autonomous execution capability.
+
+## Core Principles
+1. READ BEFORE WRITE \u2014 Always inspect project state before making changes.
+2. COMPLETE CODE \u2014 Write full files. Never use placeholders like "// ..." or "rest of code".
+3. ONE CALL = ONE FILE \u2014 Each write_file contains exactly one complete file. Batch independent writes.
+4. PLAN WITH TODOS \u2014 Use todo_manager for multi-step tasks. Update status as you progress.
+5. ACT OVER EXPLAIN \u2014 Keep reasoning brief. Prefer tool calls over lengthy explanations.
+6. VERIFY AFTER WRITE \u2014 After writing code, run type checks, linters, or tests to confirm correctness.
+7. FIX ERRORS PROACTIVELY \u2014 If a tool returns an error, diagnose and fix it immediately.
+8. PARALLEL WHEN POSSIBLE \u2014 Execute independent tool calls simultaneously for efficiency.
+
+## Smart Editing Strategy
+- For EXISTING files, prefer edit_file over write_file to minimize diff size.
+- For NEW files, use write_file with complete content.
+- Before editing, read the file first to understand its current state.
+- Make targeted, minimal edits rather than rewriting entire files.
+
+## Auto-Verification Loop
+After writing or editing code files, ALWAYS verify the changes:
+1. Run the project's build command (npm run build, tsc --noEmit, cargo check, etc.)
+2. If build fails, read the error output, fix the issues, and re-verify
+3. If tests exist, run them to confirm nothing is broken
+4. Repeat until all checks pass \u2014 do NOT leave the user with broken code
+
+## Error Recovery
+- When a tool call fails, analyze the error message carefully before retrying
+- If the same approach fails twice, try a different strategy
+- For type errors: read the file, understand the types, fix precisely
+- For runtime errors: add proper error handling and logging
+- Never give up after one failure \u2014 adapt and overcome
+
+## Execution Strategy
+- Start by reading relevant files and understanding the codebase structure.
+- Break complex tasks into small, verifiable steps.
+- After each code change, verify it compiles/passes before moving on.
+- When stuck, try a different approach rather than repeating the same failed action.
+- Use subagent for independent subtasks that can run in parallel.
+
+## Context
+- cwd=${process5.cwd()} plat=${process5.platform} arch=${process5.arch}
+- Respond in the same language as the user's input.`;
   const ts = todoSummary(4);
-  if (ts) sysContent += "\n[Remaining]\n" + ts;
+  if (ts) sysContent += "\n[Remaining Tasks]\n" + ts;
   const lastU = history.filter((m) => m.role === "user").pop();
   if (lastU?.content) {
     const hints = xmemory.getProceduralHints(lastU.content || "", 3);
     if (hints) sysContent += "\n" + hints;
   }
   const workCtx = xmemory.getWorkingContext(400);
-  if (workCtx) sysContent += "\n[\u6700\u8FD1\u5DE5\u4F5C]\n" + workCtx;
+  if (workCtx) sysContent += "\n[Recent Work]\n" + workCtx;
   const skillPrompt = getSkillSystemPrompt();
   if (skillPrompt) sysContent += "\n" + skillPrompt;
   r2.push({ role: "system", content: sysContent });
-  try {
-    const deeperMd = join11(process5.cwd(), "deeper.md");
-    if (existsSync52(deeperMd)) {
-      const ctx = readFileSync37(deeperMd, "utf-8").slice(0, 4e3);
-      if (ctx.trim() && !ctx.includes("<!-- \u586B\u5199")) {
-        r2.push({ role: "system", content: `[\u9879\u76EE\u4E0A\u4E0B\u6587 deeper.md]
-${ctx}` });
-      }
-    }
-  } catch {
-  }
-  try {
-    const rulesFile = join11(process5.cwd(), ".deeper", "rules.md");
-    if (existsSync52(rulesFile)) {
-      const rules = readFileSync37(rulesFile, "utf-8").slice(0, 4e3);
-      if (rules.trim()) r2.push({ role: "system", content: `[\u9879\u76EE\u89C4\u5219 rules.md]
-${rules}` });
-    }
-  } catch {
-  }
-  try {
-    const globalRules = join11(DEEPER_HOME, "rules.md");
-    if (existsSync52(globalRules)) {
-      const rules = readFileSync37(globalRules, "utf-8").slice(0, 2e3);
-      if (rules.trim()) r2.push({ role: "system", content: `[\u5168\u5C40\u89C4\u5219]
-${rules}` });
-    }
-  } catch {
-  }
+  const deeperCtx = cachedRead(join12(process5.cwd(), "deeper.md"));
+  if (deeperCtx && deeperCtx.trim() && !deeperCtx.includes("<!-- \u586B\u5199")) {
+    r2.push({ role: "system", content: `[\u9879\u76EE\u4E0A\u4E0B\u6587 deeper.md]
+${deeperCtx}` });
+  }
+  const projRules = cachedRead(join12(process5.cwd(), ".deeper", "rules.md"));
+  if (projRules && projRules.trim()) r2.push({ role: "system", content: `[\u9879\u76EE\u89C4\u5219 rules.md]
+${projRules}` });
+  const globalRules = cachedRead(join12(DEEPER_HOME, "rules.md"), 2e3);
+  if (globalRules && globalRules.trim()) r2.push({ role: "system", content: `[\u5168\u5C40\u89C4\u5219]
+${globalRules}` });
   for (const m of history.slice(-30)) {
     const e = { role: m.role };
     if (m.content != null) e.content = (m.content || "").slice(0, 8e3);
@@ -11554,27 +12448,62 @@ ${rules}` });
 function trimHistory(h, max) {
   while (h.length > max) h.shift();
 }
+function cachedRead(path, maxLen = 4e3) {
+  if (!existsSync53(path)) return null;
+  try {
+    const st = statSync12(path);
+    const cached = _fileCache.get(path);
+    if (cached && cached.mtime === st.mtimeMs) return cached.content;
+    const content = readFileSync37(path, "utf-8").slice(0, maxLen);
+    _fileCache.set(path, { mtime: st.mtimeMs, content });
+    return content;
+  } catch {
+    return null;
+  }
+}
 function compressHistory(h) {
   if (h.length <= 6) return;
   const keep = 6;
   const old = h.slice(0, h.length - keep);
   const recent = h.slice(h.length - keep);
-  let compressed = "";
+  const sections = [];
+  let userParts = [];
+  let assistantParts = [];
+  let toolParts = [];
+  const flushSection = () => {
+    if (userParts.length > 0) sections.push(`[\u7528\u6237] ${userParts.join(" \u2192 ")}`);
+    if (assistantParts.length > 0) sections.push(`[\u52A9\u624B] ${assistantParts.join(" \u2192 ")}`);
+    if (toolParts.length > 0) sections.push(`[\u5DE5\u5177] ${toolParts.join(", ")}`);
+    userParts = [];
+    assistantParts = [];
+    toolParts = [];
+  };
   for (const m of old) {
+    if (m.role === "system") {
+      flushSection();
+      continue;
+    }
     if (m.role === "user" && m.content) {
-      compressed += `[\u7528\u6237] ${m.content.slice(0, 100)}
-`;
-    } else if (m.role === "assistant" && m.content) {
-      compressed += `[\u52A9\u624B] ${m.content.slice(0, 150)}
-`;
+      if (assistantParts.length > 0 || toolParts.length > 0) flushSection();
+      userParts.push(m.content.slice(0, 120));
+    } else if (m.role === "assistant") {
+      if (m.tool_calls && m.tool_calls.length > 0) {
+        const names = m.tool_calls.map((t) => t.name).join(", ");
+        toolParts.push(names);
+      }
+      if (m.content) {
+        assistantParts.push(m.content.slice(0, 150));
+      }
     } else if (m.role === "tool" && m.content) {
-      compressed += `[\u5DE5\u5177] ${m.content.slice(0, 80)}
-`;
+      const isErr = m.content.startsWith("Error:");
+      toolParts.push(isErr ? "\u274C" : "\u2713");
     }
   }
+  flushSection();
+  const compressed = sections.join("\n").slice(0, 4e3);
   h.length = 0;
   h.push({ role: "system", content: `[\u4E0A\u4E0B\u6587\u538B\u7F29\xB7${old.length}\u6761\u6458\u8981]
-${compressed.slice(0, 3e3)}` });
+${compressed}` });
   h.push(...recent);
 }
 function sanitize(t) {
@@ -11584,17 +12513,56 @@ function lastUser(h) {
   for (let i = h.length - 1; i >= 0; i--) if (h[i].role === "user" && h[i].content) return h[i].content;
   return "";
 }
+function computeSimpleDiff(oldText, newText, filePath) {
+  const oldLines = oldText.split("\n");
+  const newLines = newText.split("\n");
+  const maxLines = Math.max(oldLines.length, newLines.length);
+  const result = [];
+  let changeCount = 0;
+  const contextLines = 3;
+  for (let i = 0; i < maxLines; i++) {
+    const oldLine = oldLines[i];
+    const newLine = newLines[i];
+    if (oldLine !== newLine) {
+      changeCount++;
+      const start = Math.max(0, i - contextLines);
+      const end = Math.min(maxLines, i + contextLines + 1);
+      if (result.length === 0 || result[result.length - 1] !== "...") {
+        result.push(G(`  @@ line ${i + 1} @@`));
+      }
+      for (let j = start; j < end; j++) {
+        if (j === i) {
+          if (oldLine !== void 0 && newLine !== void 0) {
+            result.push(r(`  - ${oldLines[j]}`));
+            result.push(g(`  + ${newLines[j]}`));
+          } else if (oldLine !== void 0) {
+            result.push(r(`  - ${oldLines[j]}`));
+          } else {
+            result.push(g(`  + ${newLines[j]}`));
+          }
+        } else if (j < oldLines.length && j < newLines.length) {
+          result.push(G(`    ${oldLines[j]}`));
+        }
+      }
+      result.push(G("  ..."));
+    }
+  }
+  if (changeCount === 0) return G("  (\u65E0\u53D8\u66F4)");
+  const rel = relative6(process5.cwd(), filePath);
+  return `${G(`\u6587\u4EF6: ${rel} (${changeCount} \u5904\u53D8\u66F4)`)}
+${result.join("\n")}`;
+}
 function toolsToDefs(tools) {
   return tools.map((t) => ({ type: "function", function: { name: t.name, description: t.description, parameters: t.parameters } }));
 }
 async function saveSession(history, name) {
   const label = name || (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-  const file = join11(SESSION_DIR, `sess_${label}.json`);
+  const file = join12(SESSION_DIR, `sess_${label}.json`);
   writeFileSync14(file, JSON.stringify({ savedAt: (/* @__PURE__ */ new Date()).toISOString(), cwd: process5.cwd(), messages: history }, null, 2), "utf-8");
   O(g(`\u5DF2\u4FDD\u5B58: sess_${label}`) + "\n\n");
 }
 async function listSessions() {
-  if (!existsSync52(SESSION_DIR)) {
+  if (!existsSync53(SESSION_DIR)) {
     O(r("\u65E0\u4FDD\u5B58\u7684\u4F1A\u8BDD\n\n"));
     return;
   }
@@ -11607,10 +12575,9 @@ async function listSessions() {
   for (let i = 0; i < Math.min(files.length, 15); i++) {
     const f = files[i];
     try {
-      const data = JSON.parse(readFileSync37(join11(SESSION_DIR, f), "utf-8"));
+      const data = JSON.parse(readFileSync37(join12(SESSION_DIR, f), "utf-8"));
       const label = f.replace(/^sess_|\.json$/g, "");
       const msgCount = data.messages?.length || 0;
-      const cwd = data.cwd || "?";
       const savedAt = data.savedAt?.slice(0, 16) || "?";
       O(G(`  ${i + 1}. `) + c(label) + G(` \xB7 ${msgCount}\u6761 \xB7 ${savedAt}`) + "\n");
     } catch {
@@ -11621,8 +12588,8 @@ async function listSessions() {
   O("\n  \u52A0\u8F7D: /load <name> | \u6062\u590D: /resume\n\n");
 }
 async function loadNamedSession(history, name) {
-  const file = join11(SESSION_DIR, `sess_${name}.json`);
-  if (!existsSync52(file)) {
+  const file = join12(SESSION_DIR, `sess_${name}.json`);
+  if (!existsSync53(file)) {
     O(r(`\u4F1A\u8BDD\u4E0D\u5B58\u5728: ${name}
 
 `));
@@ -11635,7 +12602,7 @@ async function loadNamedSession(history, name) {
   O(g(`\u5DF2\u52A0\u8F7D: ${name}`) + "\n\n");
 }
 async function loadLatestSession(history) {
-  if (!existsSync52(SESSION_DIR)) {
+  if (!existsSync53(SESSION_DIR)) {
     O(r("\u65E0\u4FDD\u5B58\u7684\u4F1A\u8BDD\n\n"));
     return;
   }
@@ -11644,7 +12611,7 @@ async function loadLatestSession(history) {
     O(r("\u65E0\u4FDD\u5B58\u7684\u4F1A\u8BDD\n\n"));
     return;
   }
-  const file = join11(SESSION_DIR, files[0]);
+  const file = join12(SESSION_DIR, files[0]);
   const data = JSON.parse(readFileSync37(file, "utf-8"));
   const label = files[0].replace(/^sess_|\.json$/g, "");
   history.push({ role: "system", content: `[\u5DF2\u52A0\u8F7D: ${label} (${data.messages?.length || 0} \u6761)]` });
@@ -11653,13 +12620,13 @@ async function loadLatestSession(history) {
   O(g(`\u5DF2\u52A0\u8F7D: ${label}`) + "\n\n");
 }
 async function exportHistory(history) {
-  const file = join11(process5.cwd(), `deeper-export-${Date.now()}.json`);
+  const file = join12(process5.cwd(), `deeper-export-${Date.now()}.json`);
   writeFileSync14(file, JSON.stringify(history, null, 2), "utf-8");
   O(g(`\u5DF2\u5BFC\u51FA: ${file}`) + "\n\n");
 }
 async function initProject() {
-  const file = join11(process5.cwd(), "deeper.md");
-  if (existsSync52(file)) {
+  const file = join12(process5.cwd(), "deeper.md");
+  if (existsSync53(file)) {
     O(y("  deeper.md \u5DF2\u5B58\u5728\uFF0C\u8DF3\u8FC7\n\n"));
     return;
   }
@@ -11785,99 +12752,34 @@ async function loadBuiltinTools() {
   const { builtinTools: builtinTools2 } = await Promise.resolve().then(() => (init_builtin(), builtin_exports));
   return builtinTools2;
 }
-async function callApi(opts, msgs, tools, retry = 0, cmt = 8192) {
-  const MR = 2, TO = 9e4;
-  const ac = new AbortController();
-  const t = setTimeout(() => ac.abort(), TO);
-  try {
-    const resp = await fetch(`${opts.baseUrl}/v1/chat/completions`, {
-      method: "POST",
-      signal: ac.signal,
-      headers: { "Content-Type": "application/json", "Authorization": `Bearer ${opts.apiKey}` },
-      body: JSON.stringify({
-        model: opts.model,
-        messages: msgs,
-        tools: tools.length > 0 ? tools : void 0,
-        tool_choice: tools.length > 0 ? "auto" : void 0,
-        stream: true,
-        max_tokens: cmt,
-        temperature: opts.temperature
-      })
-    });
-    if (!resp.ok) {
-      const et = await resp.text().catch(() => "");
-      if (resp.status === 401) throw new Error('API Key \u65E0\u6548: deeper config set api_key "sk-xxx"');
-      if ((resp.status === 429 || resp.status >= 500) && retry < MR) {
-        const d2 = Math.min(1e3 * (retry + 1), 5e3);
-        await new Promise((r2) => setTimeout(r2, d2));
-        return callApi(opts, msgs, tools, retry + 1, cmt);
-      }
-      throw new Error(`HTTP ${resp.status}: ${et.slice(0, 200)}`);
-    }
-    if (!resp.body) throw new Error("\u7A7A\u54CD\u5E94");
-    return sseIter(resp.body);
-  } catch (e) {
-    const m = (e instanceof Error ? e.message : String(e)).toLowerCase();
-    if ((m.includes("timeout") || m.includes("abort") || m.includes("econn")) && retry < MR) {
-      const d2 = Math.min(1e3 * (retry + 1), 5e3);
-      await new Promise((r2) => setTimeout(r2, d2));
-      return callApi(opts, msgs, tools, retry + 1, cmt);
-    }
-    throw e;
-  } finally {
-    clearTimeout(t);
-  }
-}
-async function* sseIter(body) {
-  const reader = body.getReader();
-  const dec = new TextDecoder();
-  let buf = "";
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      buf += dec.decode(value, { stream: true });
-      if (buf.length > 65536) buf = buf.slice(-32768);
-      const lines = buf.split("\n");
-      buf = lines.pop() || "";
-      for (const line of lines) {
-        const tr = line.trim();
-        if (!tr || tr.startsWith(":")) continue;
-        if (!tr.startsWith("data: ")) continue;
-        const d2 = tr.slice(6).trim();
-        if (d2 === "[DONE]") {
-          yield { type: "done" };
-          return;
-        }
-        try {
-          const p = JSON.parse(d2);
-          const ch = p.choices?.[0];
-          if (!ch) continue;
-          const dl = ch.delta;
-          if (dl?.content) yield { type: "text", content: dl.content };
-          if (dl?.reasoning_content) yield { type: "thinking", content: dl.reasoning_content };
-          if (dl?.tool_calls) for (const tc of dl.tool_calls) {
-            if (tc.id) yield { type: "tool_call_start", tool_call: { id: tc.id, name: tc.function?.name || "" } };
-            if (tc.function?.arguments) yield { type: "tool_call_args", content: tc.function.arguments };
-            if (tc.id && tc.function?.arguments) yield { type: "tool_call_end" };
-          }
-          if (ch.finish_reason === "tool_calls") yield { type: "tool_call_end" };
-        } catch {
-        }
-      }
-    }
-  } catch (e) {
-    if (e instanceof Error && e.name === "AbortError") {
-    } else yield { type: "error", error: e instanceof Error ? e.message : String(e) };
-  } finally {
-    try {
-      reader.releaseLock();
-    } catch {
-    }
-  }
-  yield { type: "done" };
+async function callApi(opts, msgs, tools, cmt = 8192, signal) {
+  const client = new DeepSeekClient({
+    apiKey: opts.apiKey || "",
+    model: opts.model || "deepseek-chat",
+    baseUrl: opts.baseUrl || "https://api.deepseek.com",
+    temperature: opts.temperature ?? 0,
+    maxTokens: cmt,
+    think: { enabled: true, budgetTokens: cmt },
+    signal
+  });
+  const chatMsgs = msgs.map((m) => ({
+    role: m.role || "user",
+    content: m.content != null ? String(m.content) : null,
+    tool_calls: m.tool_calls,
+    tool_call_id: m.tool_call_id,
+    name: m.name,
+    reasoning_content: m.reasoning_content,
+    thinking: m.thinking
+  }));
+  const stream = await client.chatStream(chatMsgs, tools.map((t) => ({
+    name: t.function.name,
+    description: t.function.description,
+    category: "",
+    parameters: t.function.parameters
+  })));
+  return stream;
 }
-var MAX_HISTORY, CONTEXT_LIMIT, CTX_WARN, TOOL_RESULT_MAX, SESSION_DIR, AUTOSAVE_FILE, GS, skillEngine, mcpClient, validator;
+var MAX_HISTORY, CONTEXT_LIMIT, CTX_WARN, TOOL_RESULT_MAX, SESSION_DIR, AUTOSAVE_FILE, TOOL_TIMEOUT_MAP, DEFAULT_TOOL_TIMEOUT, GS, skillEngine, mcpClient, validator, currentAbortController, BACKUP_DIR, MAX_BACKUPS, fileBackupStack, _fileCache;
 var init_chat_repl = __esm({
   "src/cli/chat-repl.ts"() {
     "use strict";
@@ -11890,17 +12792,47 @@ var init_chat_repl = __esm({
     init_token_count();
     init_SkillEngine();
     init_MCPClient();
+    init_DeepSeekClient();
     init_ansi();
     MAX_HISTORY = 60;
     CONTEXT_LIMIT = 1048576;
     CTX_WARN = 786432;
     TOOL_RESULT_MAX = 4e3;
-    SESSION_DIR = join11(DEEPER_HOME, "sessions");
-    AUTOSAVE_FILE = join11(SESSION_DIR, "_autosave.json");
+    SESSION_DIR = join12(DEEPER_HOME, "sessions");
+    AUTOSAVE_FILE = join12(SESSION_DIR, "_autosave.json");
+    TOOL_TIMEOUT_MAP = {
+      run_command: 12e4,
+      run_async: 12e4,
+      pipe_commands: 12e4,
+      shell_script: 12e4,
+      build_project: 18e4,
+      run_test: 18e4,
+      npm_manage: 12e4,
+      docker_manage: 12e4,
+      project_init: 12e4,
+      web_fetch: 6e4,
+      web_search: 6e4,
+      http_request: 6e4,
+      browser_action: 6e4,
+      screenshot_page: 6e4,
+      sql_query: 6e4,
+      sql_migrate: 12e4,
+      db_backup: 18e4,
+      db_restore: 18e4,
+      secret_scan: 6e4,
+      vulnerability_check: 6e4,
+      subagent: 18e4
+    };
+    DEFAULT_TOOL_TIMEOUT = 3e4;
     GS = { tc: 0, api: 0, ch: 0 };
     skillEngine = null;
     mcpClient = null;
     validator = new ToolValidator();
+    currentAbortController = null;
+    BACKUP_DIR = join12(DEEPER_HOME, "backups");
+    MAX_BACKUPS = 50;
+    fileBackupStack = [];
+    _fileCache = /* @__PURE__ */ new Map();
   }
 });