minimal-agent 0.1.5 → 0.1.7

package/dist/main.js

@@ -2,7 +2,19 @@
 
 // src/main.tsx
 import { render } from "ink";
+import { existsSync as existsSync9, mkdirSync } from "fs";
 import { createRequire } from "module";
+import { resolve as resolve8 } from "path";
+
+// src/bootstrap/cwdArg.ts
+function extractCwdArg(argv) {
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === "-d" || argv[i] === "--cwd") {
+      return argv[i + 1] ?? null;
+    }
+  }
+  return null;
+}
 
 // src/bootstrap/workingDir.ts
 import { resolve } from "path";
@@ -57,42 +69,6 @@ async function saveConfig(cfg) {
 
 // src/config.ts
 var DEFAULT_CONTEXT_WINDOW = 128e3;
-async function loadProvider() {
-  const baseURL = process.env.MINIMAL_AGENT_BASE_URL;
-  const apiKey = process.env.MINIMAL_AGENT_API_KEY;
-  const model = process.env.MINIMAL_AGENT_MODEL;
-  if (!baseURL || !apiKey || !model) {
-    const missing = [];
-    if (!baseURL) missing.push("MINIMAL_AGENT_BASE_URL");
-    if (!apiKey) missing.push("MINIMAL_AGENT_API_KEY");
-    if (!model) missing.push("MINIMAL_AGENT_MODEL");
-    throw new Error(
-      `\u7F3A\u5C11\u5FC5\u9700\u7684\u73AF\u5883\u53D8\u91CF\uFF1A${missing.join(", ")}
-
-\u8BF7\u5728 .env \u4E2D\u914D\u7F6E\uFF1A
-  MINIMAL_AGENT_BASE_URL=https://api.example.com/v1
-  MINIMAL_AGENT_API_KEY=your-api-key
-  MINIMAL_AGENT_MODEL=your-model
-
-\u53C2\u8003 .env.example`
-    );
-  }
-  const contextWindowRaw = process.env.MINIMAL_AGENT_CONTEXT_WINDOW;
-  let contextWindow = DEFAULT_CONTEXT_WINDOW;
-  if (contextWindowRaw) {
-    const n = parseInt(contextWindowRaw, 10);
-    if (!Number.isNaN(n) && n > 0) {
-      contextWindow = n;
-    }
-  }
-  return {
-    name: process.env.MINIMAL_AGENT_PROVIDER ?? "env",
-    baseURL,
-    apiKey,
-    model,
-    contextWindow
-  };
-}
 async function loadProviderLayered() {
   const envBaseURL = process.env.MINIMAL_AGENT_BASE_URL;
   const envApiKey = process.env.MINIMAL_AGENT_API_KEY;
@@ -124,8 +100,8 @@ async function loadProviderLayered() {
 }
 
 // src/context/persistContext.ts
-import { mkdir as mkdir3, readFile as readFile2, unlink, writeFile as writeFile2 } from "fs/promises";
-import { dirname as dirname3 } from "path";
+import { mkdir as mkdir3, readFile as readFile2, readdir, rmdir, unlink, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname3, join as join3 } from "path";
 
 // src/context/sessionPath.ts
 import { createHash } from "crypto";
@@ -191,6 +167,30 @@ async function clearContext(file) {
     await unlink(target);
   } catch {
   }
+  const cwd = getWorkingDir();
+  let topEntries;
+  try {
+    topEntries = await readdir(cwd);
+  } catch {
+    return;
+  }
+  const stateDirs = topEntries.filter(
+    (name) => name === ".minimal-agent" || name.startsWith(".minimal-agent-")
+  );
+  for (const name of stateDirs) {
+    const dir = join3(cwd, name);
+    try {
+      const entries = await readdir(dir);
+      for (const entry of entries) {
+        try {
+          await unlink(join3(dir, entry));
+        } catch {
+        }
+      }
+      await rmdir(dir);
+    } catch {
+    }
+  }
 }
 
 // src/prompts/system.ts
@@ -198,10 +198,10 @@ import { homedir as homedir3 } from "os";
 
 // src/prompts/projectInstructions.ts
 import { readFile as readFile3 } from "fs/promises";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 var FILENAME = "minimal-agent.md";
 async function loadProjectInstructions(cwd) {
-  const filePath = join3(cwd, FILENAME);
+  const filePath = join4(cwd, FILENAME);
   try {
     const content = await readFile3(filePath, "utf-8");
     const trimmed = content.trim();
@@ -220,8 +220,8 @@ async function loadProjectInstructions(cwd) {
 }
 
 // src/prompts/skillList.ts
-import { readFile as readFile4, readdir } from "fs/promises";
-import { join as join4 } from "path";
+import { readFile as readFile4, readdir as readdir2 } from "fs/promises";
+import { join as join5 } from "path";
 
 // src/utils/packageRoot.ts
 import { existsSync } from "fs";
@@ -246,7 +246,7 @@ function findPackageRoot(metaUrl) {
 }
 
 // src/prompts/skillList.ts
-var SKILLS_DIR = join4(findPackageRoot(import.meta.url), "skills");
+var SKILLS_DIR = join5(findPackageRoot(import.meta.url), "skills");
 function stripQuotes(s) {
   const trimmed = s.trim();
   if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
@@ -273,10 +273,10 @@ function parseFrontmatter(content) {
 async function getSkillList() {
   const skills = [];
   try {
-    const entries = await readdir(SKILLS_DIR, { withFileTypes: true });
+    const entries = await readdir2(SKILLS_DIR, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-      const skillPath = join4(SKILLS_DIR, entry.name, "SKILL.md");
+      const skillPath = join5(SKILLS_DIR, entry.name, "SKILL.md");
       try {
         const content = await readFile4(skillPath, "utf8");
         const meta = parseFrontmatter(content);
@@ -462,6 +462,141 @@ function toToolParameters(schema) {
   return rest;
 }
 
+// src/tools/bash/semantics.ts
+var DEFAULT_SEMANTIC = (exitCode) => ({
+  isError: exitCode !== 0,
+  message: exitCode !== 0 ? `Command failed with exit code ${exitCode}` : void 0
+});
+var COMMAND_SEMANTICS = /* @__PURE__ */ new Map([
+  // grep: 0=找到匹配, 1=无匹配（非错误）, 2+=真错误
+  ["grep", (exitCode) => ({
+    isError: exitCode >= 2,
+    message: exitCode === 1 ? "No matches found" : void 0
+  })],
+  // ripgrep 与 grep 同义
+  ["rg", (exitCode) => ({
+    isError: exitCode >= 2,
+    message: exitCode === 1 ? "No matches found" : void 0
+  })],
+  // find: 1=部分目录不可达（仍有结果，非致命）, 2+=错误
+  ["find", (exitCode) => ({
+    isError: exitCode >= 2,
+    message: exitCode === 1 ? "Some directories were inaccessible" : void 0
+  })],
+  // diff: 0=相同, 1=有差异（非错误）, 2+=错误
+  ["diff", (exitCode) => ({
+    isError: exitCode >= 2,
+    message: exitCode === 1 ? "Files differ" : void 0
+  })],
+  // test: 0=真, 1=假（非错误）, 2+=错误
+  ["test", (exitCode) => ({
+    isError: exitCode >= 2,
+    message: exitCode === 1 ? "Condition is false" : void 0
+  })],
+  // [ 是 test 的别名
+  ["[", (exitCode) => ({
+    isError: exitCode >= 2,
+    message: exitCode === 1 ? "Condition is false" : void 0
+  })]
+]);
+function extractPrimaryCommand(command) {
+  let cmd = command.trim();
+  const wrapMatch = cmd.match(/^(?:bash|sh|zsh|dash)\s+-c\s+(['"])(.+)\1\s*$/s);
+  if (wrapMatch) cmd = wrapMatch[2].trim();
+  const segments = cmd.split(/\s*(?:\|\||&&|;|\|)\s*/).filter((s) => s.length > 0);
+  let last = segments[segments.length - 1] ?? cmd;
+  last = last.trim();
+  const tokens = last.split(/\s+/);
+  let i = 0;
+  if (tokens[i] === "env") i++;
+  while (i < tokens.length && /^[A-Za-z_][A-Za-z0-9_]*=/.test(tokens[i])) i++;
+  return tokens[i] ?? "";
+}
+function interpretCommandResult(command, exitCode, stdout, stderr) {
+  const base = extractPrimaryCommand(command);
+  const fn = COMMAND_SEMANTICS.get(base) ?? DEFAULT_SEMANTIC;
+  return fn(exitCode, stdout, stderr);
+}
+
+// src/tools/bash/warnings.ts
+var DESTRUCTIVE_PATTERNS = [
+  // Git —— 数据丢失 / 难回退
+  {
+    pattern: /\bgit\s+reset\s+--hard\b/,
+    warning: "Note: may discard uncommitted changes"
+  },
+  {
+    pattern: /\bgit\s+push\b[^;&|\n]*[ \t](--force|--force-with-lease|-f)\b/,
+    warning: "Note: may overwrite remote history"
+  },
+  {
+    pattern: /\bgit\s+clean\b(?![^;&|\n]*(?:-[a-zA-Z]*n|--dry-run))[^;&|\n]*-[a-zA-Z]*f/,
+    warning: "Note: may permanently delete untracked files"
+  },
+  {
+    pattern: /\bgit\s+checkout\s+(--\s+)?\.[ \t]*($|[;&|\n])/,
+    warning: "Note: may discard all working tree changes"
+  },
+  {
+    pattern: /\bgit\s+restore\s+(--\s+)?\.[ \t]*($|[;&|\n])/,
+    warning: "Note: may discard all working tree changes"
+  },
+  {
+    pattern: /\bgit\s+stash[ \t]+(drop|clear)\b/,
+    warning: "Note: may permanently remove stashed changes"
+  },
+  {
+    pattern: /\bgit\s+branch\s+(-D[ \t]|--delete\s+--force|--force\s+--delete)\b/,
+    warning: "Note: may force-delete a branch"
+  },
+  // Git —— 安全绕过
+  {
+    pattern: /\bgit\s+(commit|push|merge)\b[^;&|\n]*--no-verify\b/,
+    warning: "Note: may skip safety hooks"
+  },
+  {
+    pattern: /\bgit\s+commit\b[^;&|\n]*--amend\b/,
+    warning: "Note: may rewrite the last commit"
+  },
+  // 文件删除（rm -rf / 之类的致命形式由 bash.ts 黑名单处理；这里只做"未到致命"的提醒）
+  {
+    pattern: /(^|[;&|\n]\s*)rm\s+-[a-zA-Z]*[rR][a-zA-Z]*f|(^|[;&|\n]\s*)rm\s+-[a-zA-Z]*f[a-zA-Z]*[rR]/,
+    warning: "Note: may recursively force-remove files"
+  },
+  {
+    pattern: /(^|[;&|\n]\s*)rm\s+-[a-zA-Z]*[rR]/,
+    warning: "Note: may recursively remove files"
+  },
+  {
+    pattern: /(^|[;&|\n]\s*)rm\s+-[a-zA-Z]*f/,
+    warning: "Note: may force-remove files"
+  },
+  // 数据库
+  {
+    pattern: /\b(DROP|TRUNCATE)\s+(TABLE|DATABASE|SCHEMA)\b/i,
+    warning: "Note: may drop or truncate database objects"
+  },
+  {
+    pattern: /\bDELETE\s+FROM\s+\w+[ \t]*(;|"|'|\n|$)/i,
+    warning: "Note: may delete all rows from a database table"
+  },
+  // 基础设施
+  {
+    pattern: /\bkubectl\s+delete\b/,
+    warning: "Note: may delete Kubernetes resources"
+  },
+  {
+    pattern: /\bterraform\s+destroy\b/,
+    warning: "Note: may destroy Terraform infrastructure"
+  }
+];
+function scanDestructiveCommand(command) {
+  for (const { pattern, warning } of DESTRUCTIVE_PATTERNS) {
+    if (pattern.test(command)) return warning;
+  }
+  return null;
+}
+
 // src/tools/bash/bash.ts
 var DEFAULT_TIMEOUT_MS = 12e4;
 var MAX_TIMEOUT_MS = 6e5;
@@ -599,6 +734,7 @@ async function call(input, signal) {
 \u547D\u4EE4\uFF1A${command}`
     };
   }
+  const destructiveWarning = scanDestructiveCommand(command);
   let stdout = "";
   let stderr = "";
   let exitCode = null;
@@ -669,16 +805,33 @@ ${stderr.replace(/\s+$/, "")}
   }
   parts.push(`
 [exit code: ${exitCode === null ? "killed" : exitCode}]`);
-  let content = parts.join("\n");
-  if (content.length > DEFAULT_MAX_RESULT_SIZE_CHARS) {
-    content = content.slice(0, DEFAULT_MAX_RESULT_SIZE_CHARS) + `
+  let combinedOutput = parts.join("\n");
+  if (combinedOutput.length > DEFAULT_MAX_RESULT_SIZE_CHARS) {
+    combinedOutput = combinedOutput.slice(0, DEFAULT_MAX_RESULT_SIZE_CHARS) + `
 
 ... (\u8F93\u51FA\u8D85\u8FC7 ${DEFAULT_MAX_RESULT_SIZE_CHARS} \u5B57\u7B26\uFF0C\u5DF2\u622A\u65AD)`;
   }
-  if (timedOut || exitCode !== null && exitCode !== 0 || killedBySignal) {
-    return { ok: false, error: content };
+  if (timedOut || killedBySignal) {
+    return { ok: false, error: combinedOutput };
   }
-  return { ok: true, content };
+  const semantic = interpretCommandResult(
+    command,
+    exitCode ?? 0,
+    stdout,
+    stderr
+  );
+  const finalContent = destructiveWarning ? `\u26A0\uFE0F \u8B66\u544A: ${destructiveWarning}
+
+${combinedOutput}` : combinedOutput;
+  if (semantic.isError) {
+    return {
+      ok: false,
+      error: `\u547D\u4EE4\u5931\u8D25 (exit ${exitCode}): ${stderr || stdout || semantic.message || ""}`.trim() + `
+
+${finalContent}`
+    };
+  }
+  return { ok: true, content: finalContent };
 }
 var bashTool = {
   name: "Bash",
@@ -693,10 +846,294 @@ var bashTool = {
 };
 
 // src/tools/edit/edit.ts
-import { readFile as readFile5, writeFile as writeFile3, mkdir as mkdir4 } from "fs/promises";
-import { existsSync as existsSync2 } from "fs";
-import { dirname as dirname5, resolve as resolve4 } from "path";
+import { readFile as readFile6, writeFile as writeFile3, mkdir as mkdir4 } from "fs/promises";
+import { existsSync as existsSync3 } from "fs";
+import { dirname as dirname5 } from "path";
 import { z as z2 } from "zod";
+
+// src/tools/shared/fileUtils.ts
+import { open, readFile as readFile5 } from "fs/promises";
+import { homedir as homedir4 } from "os";
+import { extname, resolve as resolve4 } from "path";
+var BLOCKED_DEVICE_PATHS = /* @__PURE__ */ new Set([
+  "/dev/zero",
+  "/dev/random",
+  "/dev/urandom",
+  "/dev/full",
+  "/dev/stdin",
+  "/dev/tty",
+  "/dev/console",
+  "/dev/stdout",
+  "/dev/stderr",
+  "/dev/fd/0",
+  "/dev/fd/1",
+  "/dev/fd/2"
+]);
+var WINDOWS_BLOCKED_NAMES = /* @__PURE__ */ new Set(["NUL", "CON", "PRN", "AUX", "COM1", "COM2", "LPT1"]);
+function isBlockedDevicePath(filePath) {
+  const slashed = filePath.replaceAll("\\", "/");
+  if (BLOCKED_DEVICE_PATHS.has(slashed)) return true;
+  if (slashed.startsWith("/proc/") && (slashed.endsWith("/fd/0") || slashed.endsWith("/fd/1") || slashed.endsWith("/fd/2"))) {
+    return true;
+  }
+  const baseName = slashed.split("/").pop() ?? "";
+  if (WINDOWS_BLOCKED_NAMES.has(baseName.toUpperCase())) {
+    return true;
+  }
+  return false;
+}
+function validateAndResolvePath(rawPath, workingDir) {
+  if (rawPath.includes("\0")) {
+    return { ok: false, error: "\u8DEF\u5F84\u5305\u542B\u975E\u6CD5\u5B57\u7B26\uFF08null byte\uFF09" };
+  }
+  if (isBlockedDevicePath(rawPath)) {
+    return { ok: false, error: `\u4E0D\u5141\u8BB8\u8BFB\u53D6\u8BBE\u5907\u6587\u4EF6\uFF1A${rawPath}\u3002\u8BE5\u8DEF\u5F84\u53EF\u80FD\u4EA7\u751F\u65E0\u9650\u8F93\u51FA\u6216\u963B\u585E\u8FDB\u7A0B\u3002` };
+  }
+  const expanded = expandPath(rawPath);
+  const resolved = resolve4(workingDir, expanded);
+  if (isBlockedDevicePath(resolved)) {
+    return { ok: false, error: `\u4E0D\u5141\u8BB8\u8BFB\u53D6\u8BBE\u5907\u6587\u4EF6\uFF1A${resolved}\u3002\u8BE5\u8DEF\u5F84\u53EF\u80FD\u4EA7\u751F\u65E0\u9650\u8F93\u51FA\u6216\u963B\u585E\u8FDB\u7A0B\u3002` };
+  }
+  if (process.platform === "win32" && /^\\\\/.test(resolved)) {
+    return { ok: false, error: "\u4E0D\u652F\u6301 UNC \u8DEF\u5F84\uFF08\\\\server\\share \u683C\u5F0F\uFF09\uFF0C\u8BF7\u4F7F\u7528\u672C\u5730\u8DEF\u5F84" };
+  }
+  return { ok: true, resolvedPath: resolved };
+}
+function expandPath(p) {
+  if (p.startsWith("~/") || p === "~") {
+    return resolve4(homedir4(), p.slice(2));
+  }
+  return p;
+}
+function detectLineEndingsForString(content) {
+  let crlfCount = 0;
+  let lfCount = 0;
+  for (let i = 0; i < content.length; i++) {
+    if (content[i] === "\n") {
+      if (i > 0 && content[i - 1] === "\r") {
+        crlfCount++;
+      } else {
+        lfCount++;
+      }
+    }
+  }
+  return crlfCount > lfCount ? "CRLF" : "LF";
+}
+async function detectFileLineEndings(filePath) {
+  try {
+    const handle = await readFile5(filePath, { encoding: "utf8" });
+    const head = handle.slice(0, 4096);
+    return detectLineEndingsForString(head);
+  } catch {
+    return "LF";
+  }
+}
+function applyLineEnding(content, ending) {
+  if (ending === "CRLF") {
+    return content.replaceAll("\r\n", "\n").split("\n").join("\r\n");
+  }
+  return content;
+}
+var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".webp",
+  ".bmp",
+  ".ico",
+  ".tiff",
+  ".tif",
+  ".pdf",
+  ".doc",
+  ".docx",
+  ".xls",
+  ".xlsx",
+  ".ppt",
+  ".pptx",
+  ".exe",
+  ".dll",
+  ".so",
+  ".dylib",
+  ".o",
+  ".a",
+  ".pyc",
+  ".pyo",
+  ".class",
+  ".jar",
+  ".zip",
+  ".tar",
+  ".gz",
+  ".bz2",
+  ".7z",
+  ".rar",
+  ".iso",
+  ".mp3",
+  ".mp4",
+  ".mov",
+  ".avi",
+  ".mkv",
+  ".wav",
+  ".flac",
+  ".ogg",
+  ".ttf",
+  ".otf",
+  ".woff",
+  ".woff2",
+  ".sqlite",
+  ".sqlite3",
+  ".db",
+  ".psd",
+  ".ai",
+  ".bin",
+  ".wasm"
+]);
+function hasBinaryExtension(filePath) {
+  const ext = extname(filePath).toLowerCase();
+  return BINARY_EXTENSIONS.has(ext);
+}
+async function detectFileBomEncoding(filePath) {
+  let fh = null;
+  try {
+    fh = await open(filePath, "r");
+    const buf = Buffer.alloc(3);
+    const { bytesRead } = await fh.read(buf, 0, 3, 0);
+    if (bytesRead >= 3 && buf[0] === 239 && buf[1] === 187 && buf[2] === 191) {
+      return "utf8-bom";
+    }
+    if (bytesRead >= 2 && buf[0] === 255 && buf[1] === 254) {
+      return "utf16le";
+    }
+    return "utf8";
+  } catch {
+    return "utf8";
+  } finally {
+    if (fh) {
+      try {
+        await fh.close();
+      } catch {
+      }
+    }
+  }
+}
+var LEFT_SINGLE_CURLY_QUOTE = "\u2018";
+var RIGHT_SINGLE_CURLY_QUOTE = "\u2019";
+var LEFT_DOUBLE_CURLY_QUOTE = "\u201C";
+var RIGHT_DOUBLE_CURLY_QUOTE = "\u201D";
+function normalizeQuotes(str) {
+  return str.replaceAll(LEFT_SINGLE_CURLY_QUOTE, "'").replaceAll(RIGHT_SINGLE_CURLY_QUOTE, "'").replaceAll(LEFT_DOUBLE_CURLY_QUOTE, '"').replaceAll(RIGHT_DOUBLE_CURLY_QUOTE, '"');
+}
+function findActualString(fileContent, searchString) {
+  if (fileContent.includes(searchString)) {
+    return searchString;
+  }
+  const normalizedSearch = normalizeQuotes(searchString);
+  const normalizedFile = normalizeQuotes(fileContent);
+  const searchIndex = normalizedFile.indexOf(normalizedSearch);
+  if (searchIndex !== -1) {
+    return fileContent.substring(searchIndex, searchIndex + searchString.length);
+  }
+  return null;
+}
+function preserveQuoteStyle(oldString, actualOldString, newString) {
+  if (oldString === actualOldString) {
+    return newString;
+  }
+  const hasDoubleQuotes = actualOldString.includes(LEFT_DOUBLE_CURLY_QUOTE) || actualOldString.includes(RIGHT_DOUBLE_CURLY_QUOTE);
+  const hasSingleQuotes = actualOldString.includes(LEFT_SINGLE_CURLY_QUOTE) || actualOldString.includes(RIGHT_SINGLE_CURLY_QUOTE);
+  if (!hasDoubleQuotes && !hasSingleQuotes) {
+    return newString;
+  }
+  let result = newString;
+  if (hasDoubleQuotes) {
+    result = applyCurlyDoubleQuotes(result);
+  }
+  if (hasSingleQuotes) {
+    result = applyCurlySingleQuotes(result);
+  }
+  return result;
+}
+function isOpeningContext(chars, index) {
+  if (index === 0) return true;
+  const prev = chars[index - 1];
+  return prev === " " || prev === "	" || prev === "\n" || prev === "\r" || prev === "(" || prev === "[" || prev === "{" || prev === "\u2014" || prev === "\u2013";
+}
+function applyCurlyDoubleQuotes(str) {
+  const chars = [...str];
+  const result = [];
+  for (let i = 0; i < chars.length; i++) {
+    if (chars[i] === '"') {
+      result.push(
+        isOpeningContext(chars, i) ? LEFT_DOUBLE_CURLY_QUOTE : RIGHT_DOUBLE_CURLY_QUOTE
+      );
+    } else {
+      result.push(chars[i]);
+    }
+  }
+  return result.join("");
+}
+function applyCurlySingleQuotes(str) {
+  const chars = [...str];
+  const result = [];
+  for (let i = 0; i < chars.length; i++) {
+    if (chars[i] === "'") {
+      const prev = i > 0 ? chars[i - 1] : void 0;
+      const next = i < chars.length - 1 ? chars[i + 1] : void 0;
+      const prevIsLetter = prev !== void 0 && new RegExp("\\p{L}", "u").test(prev);
+      const nextIsLetter = next !== void 0 && new RegExp("\\p{L}", "u").test(next);
+      if (prevIsLetter && nextIsLetter) {
+        result.push(RIGHT_SINGLE_CURLY_QUOTE);
+      } else {
+        result.push(
+          isOpeningContext(chars, i) ? LEFT_SINGLE_CURLY_QUOTE : RIGHT_SINGLE_CURLY_QUOTE
+        );
+      }
+    } else {
+      result.push(chars[i]);
+    }
+  }
+  return result.join("");
+}
+
+// src/tools/shared/fileState.ts
+import { existsSync as existsSync2, statSync } from "fs";
+var fileState = /* @__PURE__ */ new Map();
+function recordRead(absPath) {
+  try {
+    const st = statSync(absPath);
+    fileState.set(absPath, { timestamp: st.mtimeMs, size: st.size });
+  } catch {
+  }
+}
+function assertFresh(absPath) {
+  const entry = fileState.get(absPath);
+  if (!entry) {
+    if (existsSync2(absPath)) {
+      return {
+        ok: false,
+        error: `\u6587\u4EF6 ${absPath} \u5DF2\u5B58\u5728\u4F46\u672A\u5728\u672C\u4F1A\u8BDD Read \u8FC7\u3002\u8BF7\u5148\u7528 Read \u5DE5\u5177\u8BFB\u53D6\uFF0C\u786E\u8BA4\u5185\u5BB9\u540E\u518D\u4FEE\u6539\u3002`
+      };
+    }
+    return { ok: true };
+  }
+  try {
+    const st = statSync(absPath);
+    if (st.mtimeMs > entry.timestamp) {
+      return {
+        ok: false,
+        error: `${absPath} \u5728 Read \u540E\u88AB\u5916\u90E8\u4FEE\u6539\uFF08mtime \u6F02\u79FB\uFF09\u3002\u8BF7\u91CD\u65B0\u7528 Read \u5DE5\u5177\u8BFB\u53D6\u6700\u65B0\u5185\u5BB9\u3002`
+      };
+    }
+  } catch {
+    return { ok: true };
+  }
+  return { ok: true };
+}
+function clearFileState() {
+  fileState.clear();
+}
+
+// src/tools/edit/edit.ts
 var MAX_EDIT_FILE_SIZE_BYTES = 1024 * 1024 * 1024;
 var inputSchema2 = z2.object({
   file_path: z2.string().min(1).describe("\u8981\u7F16\u8F91\u7684\u6587\u4EF6\u8DEF\u5F84"),
@@ -718,25 +1155,20 @@ Usage:
 - The edit will FAIL if \`old_string\` is not unique in the file. Either provide a larger string with more surrounding context to make it unique or use \`replace_all\` to change every instance of \`old_string\`.
 - Use \`replace_all\` for replacing and renaming strings across the file. This parameter is useful if you want to rename a variable for instance.
 - Preserve exact indentation (tabs/spaces).`;
-function validatePath(filePath) {
-  if (filePath.includes("\0")) {
-    return { ok: false, error: "\u8DEF\u5F84\u5305\u542B\u975E\u6CD5\u5B57\u7B26\uFF08null byte\uFF09" };
-  }
-  if (process.platform === "win32" && filePath.includes("\\\\")) {
-    return { ok: false, error: "\u4E0D\u652F\u6301 UNC \u8DEF\u5F84\uFF08\\\\server\\share \u683C\u5F0F\uFF09\uFF0C\u8BF7\u4F7F\u7528\u672C\u5730\u8DEF\u5F84" };
-  }
-  return { ok: true };
-}
 async function call2(input) {
-  const filePath = resolve4(input.file_path);
   const { old_string, new_string } = input;
   const replaceAll = input.replace_all ?? false;
-  const pathCheck = validatePath(filePath);
-  if (!pathCheck.ok) return pathCheck;
+  const pathResult = validateAndResolvePath(input.file_path, getWorkingDir());
+  if (!pathResult.ok) return pathResult;
+  const filePath = pathResult.resolvedPath;
+  const freshness = assertFresh(filePath);
+  if (!freshness.ok) {
+    return { ok: false, error: freshness.error };
+  }
   if (old_string === new_string) {
     return { ok: false, error: "old_string \u4E0E new_string \u5B8C\u5168\u76F8\u540C\uFF0C\u6CA1\u6709\u53EF\u6539\u7684\u5185\u5BB9\u3002" };
   }
-  if (old_string === "" && !existsSync2(filePath)) {
+  if (old_string === "" && !existsSync3(filePath)) {
     try {
       await mkdir4(dirname5(filePath), { recursive: true });
       await writeFile3(filePath, new_string, "utf8");
@@ -748,7 +1180,7 @@ async function call2(input) {
       return { ok: false, error: `\u521B\u5EFA\u6587\u4EF6\u5931\u8D25\uFF1A${e.message}` };
     }
   }
-  if (!existsSync2(filePath)) {
+  if (!existsSync3(filePath)) {
     return {
       ok: false,
       error: `\u6587\u4EF6\u4E0D\u5B58\u5728\uFF1A${filePath}
@@ -757,10 +1189,11 @@ async function call2(input) {
   }
   let original;
   try {
-    original = await readFile5(filePath, "utf8");
+    original = await readFile6(filePath, "utf8");
   } catch (e) {
     return { ok: false, error: `\u8BFB\u53D6\u5931\u8D25\uFF1A${e.message}` };
   }
+  const originalLineEnding = detectLineEndingsForString(original);
   const fileSize = Buffer.byteLength(original, "utf8");
   if (fileSize > MAX_EDIT_FILE_SIZE_BYTES) {
     return {
@@ -774,9 +1207,16 @@ async function call2(input) {
       error: "old_string \u4E3A\u7A7A\u4F46\u6587\u4EF6\u5DF2\u5B58\u5728 \u2014\u2014 \u8FD9\u901A\u5E38\u662F\u9519\u8BEF\u7684\u3002\u8981\u66FF\u6362\u5168\u6587\u8BF7\u7528 Write \u5DE5\u5177\u3002"
     };
   }
-  const occurrences = countOccurrences(original, old_string);
+  let searchTarget = old_string;
+  let processedNewString = new_string;
+  const actualOld = findActualString(original, old_string);
+  if (actualOld !== null && actualOld !== old_string) {
+    searchTarget = actualOld;
+    processedNewString = preserveQuoteStyle(old_string, actualOld, new_string);
+  }
+  const occurrences = countOccurrences(original, searchTarget);
   if (occurrences === 0) {
-    const hint = findFuzzyMatchHint(original, old_string);
+    const hint = findFuzzyMatchHint(original, searchTarget);
     const extraMsg = hint ? `
 
 \u{1F4A1} \u63D0\u793A\uFF1A${hint}` : "";
@@ -792,9 +1232,10 @@ async function call2(input) {
 \u8BF7\u6269\u5927 old_string \u5305\u542B\u66F4\u591A\u4E0A\u4E0B\u6587\uFF0C\u6216\u663E\u5F0F\u4F20 replace_all=true\u3002`
     };
   }
-  const replaced = replaceAll ? splitReplaceAll(original, old_string, new_string) : original.replace(old_string, new_string);
+  const replaced = replaceAll ? splitReplaceAll(original, searchTarget, processedNewString) : original.replace(searchTarget, processedNewString);
+  const normalizedReplaced = applyLineEnding(replaced, originalLineEnding);
   try {
-    await writeFile3(filePath, replaced, "utf8");
+    await writeFile3(filePath, normalizedReplaced, "utf8");
   } catch (e) {
     return { ok: false, error: `\u5199\u5165\u5931\u8D25\uFF1A${e.message}` };
   }
@@ -892,22 +1333,146 @@ var editTool = {
   call: call2
 };
 
+// src/tools/edit/multi-edit.ts
+import { readFile as readFile7, writeFile as writeFile4 } from "fs/promises";
+import { existsSync as existsSync4 } from "fs";
+import { z as z3 } from "zod";
+var editItemSchema = z3.object({
+  old_string: z3.string().min(1).describe("\u8981\u66FF\u6362\u7684\u539F\u6587\u672C\uFF08\u4E0D\u5141\u8BB8\u4E3A\u7A7A \u2014\u2014 \u521B\u5EFA\u65B0\u6587\u4EF6\u8BF7\u7528 Edit \u5DE5\u5177\uFF09"),
+  new_string: z3.string().describe("\u66FF\u6362\u4E3A\u7684\u65B0\u6587\u672C"),
+  replace_all: z3.boolean().optional().describe("\u662F\u5426\u66FF\u6362\u6240\u6709\u51FA\u73B0\u4F4D\u7F6E\uFF08\u9ED8\u8BA4 false\uFF0C\u8981\u6C42 old_string \u5728\u5F53\u524D\u5185\u5BB9\u4E2D\u552F\u4E00\uFF09")
+});
+var inputSchema3 = z3.object({
+  file_path: z3.string().min(1).describe("\u8981\u7F16\u8F91\u7684\u6587\u4EF6\u8DEF\u5F84"),
+  edits: z3.array(editItemSchema).min(1).max(50).describe("\u6309\u987A\u5E8F\u5E94\u7528\u7684 edit \u5217\u8868\uFF081-50 \u6761\uFF09\uFF0C\u539F\u5B50\u5316\u6267\u884C\uFF1A\u5168\u90E8\u6210\u529F\u624D\u843D\u76D8")
+});
+var parameters3 = toToolParameters(inputSchema3);
+var description3 = `Performs multiple exact string replacements in a single file, applied atomically (all-or-nothing).
+
+Usage:
+- You MUST use your \`Read\` tool to read the current content of the file BEFORE calling MultiEdit.
+- Provide a list of \`edits\`, each with \`old_string\`, \`new_string\`, and optional \`replace_all\`.
+- All edits are applied sequentially in memory; if ANY edit fails (string not found, ambiguous match, or dependency conflict), the file on disk is UNTOUCHED.
+- Order matters: later edits operate on the result of earlier edits. If a later edit's \`old_string\` is a substring of an earlier edit's \`new_string\`, MultiEdit refuses (reorder or merge instead).
+- Each \`old_string\` must be unique in the current content (after prior edits) unless \`replace_all=true\`.
+- Empty \`old_string\` is NOT allowed in MultiEdit. To create a new file, use the \`Edit\` tool with a single empty-old_string call.
+- Preserve exact indentation (tabs/spaces).`;
+function countOccurrences2(haystack, needle) {
+  if (needle.length === 0) return 0;
+  let count = 0;
+  let pos = 0;
+  while ((pos = haystack.indexOf(needle, pos)) !== -1) {
+    count++;
+    pos += needle.length;
+  }
+  return count;
+}
+function splitReplaceAll2(haystack, needle, replacement) {
+  return haystack.split(needle).join(replacement);
+}
+async function call3(input) {
+  const pathResult = validateAndResolvePath(input.file_path, getWorkingDir());
+  if (!pathResult.ok) return pathResult;
+  const filePath = pathResult.resolvedPath;
+  const freshness = assertFresh(filePath);
+  if (!freshness.ok) {
+    return { ok: false, error: freshness.error };
+  }
+  if (!existsSync4(filePath)) {
+    return {
+      ok: false,
+      error: `\u6587\u4EF6\u4E0D\u5B58\u5728\uFF1A${filePath}
+\uFF08MultiEdit \u4E0D\u652F\u6301\u521B\u5EFA\u65B0\u6587\u4EF6\uFF0C\u8BF7\u6539\u7528 Edit \u5DE5\u5177\uFF09`
+    };
+  }
+  const edits = input.edits;
+  for (let i = 0; i < edits.length; i++) {
+    for (let j = 0; j < i; j++) {
+      if (edits[j].new_string.includes(edits[i].old_string)) {
+        return {
+          ok: false,
+          error: `edits[${i}].old_string \u662F edits[${j}].new_string \u7684\u5B50\u4E32\uFF0C\u4F1A\u5BFC\u81F4\u540E\u7EED edit \u547D\u4E2D\u524D\u5E8F\u4EA7\u7269\uFF0C\u8BF7\u91CD\u65B0\u6392\u5E8F\u6216\u5408\u5E76`
+        };
+      }
+    }
+  }
+  let originalContent;
+  try {
+    originalContent = await readFile7(filePath, "utf8");
+  } catch (e) {
+    return { ok: false, error: `\u8BFB\u53D6\u5931\u8D25\uFF1A${e.message}` };
+  }
+  let currentContent = originalContent;
+  for (let i = 0; i < edits.length; i++) {
+    const edit = edits[i];
+    const replaceAll = edit.replace_all ?? false;
+    let searchTarget = edit.old_string;
+    let processedNewString = edit.new_string;
+    const actualOld = findActualString(currentContent, edit.old_string);
+    if (actualOld === null) {
+      return {
+        ok: false,
+        error: `edits[${i}] \u672A\u5339\u914D\u5230 old_string\uFF08\u5728\u5DF2\u5E94\u7528\u524D\u5E8F ${i} \u5904\u4FEE\u6539\u540E\u7684\u5185\u5BB9\u4E2D\u627E\u4E0D\u5230\uFF09\u3002\u8BF7\u5148\u7528 Read \u5DE5\u5177\u6838\u5BF9\u5F53\u524D\u5185\u5BB9\uFF08\u6CE8\u610F\u7A7A\u683C/\u7F29\u8FDB/\u6362\u884C\uFF09\uFF0C\u5E76\u68C0\u67E5 edit \u987A\u5E8F\u3002`
+      };
+    }
+    if (actualOld !== edit.old_string) {
+      searchTarget = actualOld;
+      processedNewString = preserveQuoteStyle(edit.old_string, actualOld, edit.new_string);
+    }
+    const occurrences = countOccurrences2(currentContent, searchTarget);
+    if (occurrences === 0) {
+      return {
+        ok: false,
+        error: `edits[${i}] \u672A\u5339\u914D\u5230 old_string\uFF08\u5DF2\u5E94\u7528\u524D\u5E8F ${i} \u5904\u4FEE\u6539\u540E\u5185\u5BB9\u4E2D\u51FA\u73B0 0 \u6B21\uFF09\u3002`
+      };
+    }
+    if (occurrences > 1 && !replaceAll) {
+      return {
+        ok: false,
+        error: `edits[${i}].old_string \u5728\u5F53\u524D\u5185\u5BB9\u4E2D\u51FA\u73B0 ${occurrences} \u6B21\uFF0C\u4E0D\u552F\u4E00\u3002\u8BF7\u6269\u5927 old_string \u5305\u542B\u66F4\u591A\u4E0A\u4E0B\u6587\uFF0C\u6216\u663E\u5F0F\u4F20 replace_all=true\u3002`
+      };
+    }
+    currentContent = replaceAll ? splitReplaceAll2(currentContent, searchTarget, processedNewString) : currentContent.replace(searchTarget, processedNewString);
+  }
+  const lineEnding = await detectFileLineEndings(filePath);
+  const finalContent = applyLineEnding(currentContent, lineEnding);
+  try {
+    await writeFile4(filePath, finalContent, "utf8");
+  } catch (e) {
+    return { ok: false, error: `\u5199\u5165\u5931\u8D25\uFF1A${e.message}` };
+  }
+  return {
+    ok: true,
+    content: `\u5DF2\u5BF9 ${filePath} \u5E94\u7528 ${edits.length} \u5904\u4FEE\u6539`
+  };
+}
+var multiEditTool = {
+  name: "MultiEdit",
+  description: description3,
+  inputSchema: inputSchema3,
+  parameters: parameters3,
+  isReadOnly: false,
+  isConcurrencySafe: false,
+  maxResultSizeChars: DEFAULT_MAX_RESULT_SIZE_CHARS,
+  call: call3
+};
+
 // src/tools/glob/glob.ts
 import { stat as stat2 } from "fs/promises";
 import { isAbsolute, resolve as resolve5 } from "path";
 import fg from "fast-glob";
-import { z as z3 } from "zod";
-var inputSchema3 = z3.object({
-  pattern: z3.string().min(1).describe('glob \u6A21\u5F0F\uFF0C\u4F8B\u5982 "**/*.ts" \u6216 "src/components/**/*.tsx"'),
-  path: z3.string().optional().describe('\u641C\u7D22\u7684\u6839\u76EE\u5F55\uFF08\u9ED8\u8BA4\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\uFF09\uFF1B\u7701\u7565\u65F6\u4E0D\u8981\u4F20 "undefined" \u5B57\u7B26\u4E32')
+import { z as z4 } from "zod";
+var inputSchema4 = z4.object({
+  pattern: z4.string().min(1).describe('glob \u6A21\u5F0F\uFF0C\u4F8B\u5982 "**/*.ts" \u6216 "src/components/**/*.tsx"'),
+  path: z4.string().optional().describe('\u641C\u7D22\u7684\u6839\u76EE\u5F55\uFF08\u9ED8\u8BA4\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\uFF09\uFF1B\u7701\u7565\u65F6\u4E0D\u8981\u4F20 "undefined" \u5B57\u7B26\u4E32')
 });
-var parameters3 = toToolParameters(inputSchema3);
-var description3 = `- Fast file pattern matching tool that works with any codebase size
+var parameters4 = toToolParameters(inputSchema4);
+var description4 = `- Fast file pattern matching tool that works with any codebase size
 - Supports glob patterns like "**/*.js" or "src/**/*.ts"
 - Returns matching file paths sorted by modification time (oldest first)
 - Use this tool when you need to find files by name patterns
 - When you need to do an open ended search that may require multiple rounds, prefer the Grep tool for content search`;
-async function call3(input) {
+async function call4(input) {
   const cwd = input.path ? resolve5(input.path) : getWorkingDir();
   const pattern = input.pattern.replace(/\\/g, "/");
   let matches;
@@ -954,23 +1519,23 @@ async function call3(input) {
 }
 var globTool = {
   name: "Glob",
-  description: description3,
-  inputSchema: inputSchema3,
-  parameters: parameters3,
+  description: description4,
+  inputSchema: inputSchema4,
+  parameters: parameters4,
   isReadOnly: true,
   isConcurrencySafe: true,
   maxResultSizeChars: DEFAULT_MAX_RESULT_SIZE_CHARS,
-  call: call3
+  call: call4
 };
 
 // src/tools/grep/grep.ts
 import { spawn as spawn3 } from "child_process";
 import { resolve as resolve7 } from "path";
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 
 // src/tools/grep/rgPath.ts
 import { spawn as spawn2 } from "child_process";
-import { chmodSync, existsSync as existsSync3 } from "fs";
+import { chmodSync, existsSync as existsSync5 } from "fs";
 import { resolve as resolve6 } from "path";
 var cached;
 async function resolveRgPath() {
@@ -980,15 +1545,15 @@ async function resolveRgPath() {
 }
 async function detect() {
   const fromEnv = process.env.MINIMAL_AGENT_RIPGREP_PATH;
-  if (fromEnv && existsSync3(fromEnv)) return fromEnv;
+  if (fromEnv && existsSync5(fromEnv)) return fromEnv;
   const vendored = vendoredRgPath();
-  if (vendored && existsSync3(vendored)) {
+  if (vendored && existsSync5(vendored)) {
     ensureExecutable(vendored);
     return vendored;
   }
   if (await trySpawn("rg")) return "rg";
   for (const candidate of claudeCodeCandidates()) {
-    if (existsSync3(candidate)) {
+    if (existsSync5(candidate)) {
       ensureExecutable(candidate);
       return candidate;
     }
@@ -1081,21 +1646,21 @@ function claudeCodeCandidates() {
 }
 
 // src/tools/grep/grep.ts
-var inputSchema4 = z4.object({
-  pattern: z4.string().min(1).describe("\u6B63\u5219\u8868\u8FBE\u5F0F\uFF08ripgrep \u517C\u5BB9\u8BED\u6CD5\uFF09"),
-  path: z4.string().optional().describe("\u641C\u7D22\u7684\u6839\u76EE\u5F55\u6216\u6587\u4EF6\uFF08\u9ED8\u8BA4\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\uFF09"),
-  glob: z4.string().optional().describe('\u6587\u4EF6\u540D glob \u8FC7\u6EE4\uFF0C\u5982 "*.ts"'),
-  type: z4.string().optional().describe('rg \u7684\u6587\u4EF6\u7C7B\u578B\u5FEB\u6377\u540D\uFF0C\u5982 "py"\u3001"rust"\u3001"js"'),
-  output_mode: z4.enum(["content", "files_with_matches", "count"]).optional().describe("\u8F93\u51FA\u6A21\u5F0F\uFF1Acontent=\u5339\u914D\u884C\uFF1Bfiles_with_matches=\u53EA\u5217\u6587\u4EF6\uFF1Bcount=\u6BCF\u6587\u4EF6\u8BA1\u6570"),
-  "-i": z4.boolean().optional().describe("\u5FFD\u7565\u5927\u5C0F\u5199"),
-  "-n": z4.boolean().optional().describe("\u663E\u793A\u884C\u53F7\uFF08\u4EC5 content \u6A21\u5F0F\uFF09"),
-  "-A": z4.number().int().min(0).optional().describe("\u5339\u914D\u540E\u5C55\u793A\u51E0\u884C\u4E0A\u4E0B\u6587"),
-  "-B": z4.number().int().min(0).optional().describe("\u5339\u914D\u524D\u5C55\u793A\u51E0\u884C\u4E0A\u4E0B\u6587"),
-  "-C": z4.number().int().min(0).optional().describe("\u5339\u914D\u524D\u540E\u5404\u5C55\u793A\u51E0\u884C\uFF08\u8986\u76D6 -A/-B\uFF09"),
-  head_limit: z4.number().int().positive().optional().describe("\u8F93\u51FA\u6700\u591A\u4FDD\u7559\u524D N \u884C\uFF08\u9632\u6B62\u7ED3\u679C\u8FC7\u5927\uFF09")
+var inputSchema5 = z5.object({
+  pattern: z5.string().min(1).describe("\u6B63\u5219\u8868\u8FBE\u5F0F\uFF08ripgrep \u517C\u5BB9\u8BED\u6CD5\uFF09"),
+  path: z5.string().optional().describe("\u641C\u7D22\u7684\u6839\u76EE\u5F55\u6216\u6587\u4EF6\uFF08\u9ED8\u8BA4\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\uFF09"),
+  glob: z5.string().optional().describe('\u6587\u4EF6\u540D glob \u8FC7\u6EE4\uFF0C\u5982 "*.ts"'),
+  type: z5.string().optional().describe('rg \u7684\u6587\u4EF6\u7C7B\u578B\u5FEB\u6377\u540D\uFF0C\u5982 "py"\u3001"rust"\u3001"js"'),
+  output_mode: z5.enum(["content", "files_with_matches", "count"]).optional().describe("\u8F93\u51FA\u6A21\u5F0F\uFF1Acontent=\u5339\u914D\u884C\uFF1Bfiles_with_matches=\u53EA\u5217\u6587\u4EF6\uFF1Bcount=\u6BCF\u6587\u4EF6\u8BA1\u6570"),
+  "-i": z5.boolean().optional().describe("\u5FFD\u7565\u5927\u5C0F\u5199"),
+  "-n": z5.boolean().optional().describe("\u663E\u793A\u884C\u53F7\uFF08\u4EC5 content \u6A21\u5F0F\uFF09"),
+  "-A": z5.number().int().min(0).optional().describe("\u5339\u914D\u540E\u5C55\u793A\u51E0\u884C\u4E0A\u4E0B\u6587"),
+  "-B": z5.number().int().min(0).optional().describe("\u5339\u914D\u524D\u5C55\u793A\u51E0\u884C\u4E0A\u4E0B\u6587"),
+  "-C": z5.number().int().min(0).optional().describe("\u5339\u914D\u524D\u540E\u5404\u5C55\u793A\u51E0\u884C\uFF08\u8986\u76D6 -A/-B\uFF09"),
+  head_limit: z5.number().int().positive().optional().describe("\u8F93\u51FA\u6700\u591A\u4FDD\u7559\u524D N \u884C\uFF08\u9632\u6B62\u7ED3\u679C\u8FC7\u5927\uFF09")
 });
-var parameters4 = toToolParameters(inputSchema4);
-var description4 = `A powerful search tool built on ripgrep.
+var parameters5 = toToolParameters(inputSchema5);
+var description5 = `A powerful search tool built on ripgrep.
 
 Usage:
 - ALWAYS use Grep for content search tasks. Do NOT invoke \`grep\` or \`rg\` directly via Bash.
@@ -1103,7 +1668,7 @@ Usage:
 - Filter files with glob parameter (e.g., "*.js", "**/*.tsx") or type parameter (e.g., "js", "py", "rust")
 - Output modes: "content" shows matching lines, "files_with_matches" shows only file paths (default), "count" shows match counts
 - Pattern syntax: Uses ripgrep (not classic grep)`;
-async function call4(input, signal) {
+async function call5(input, signal) {
   const args = [];
   const mode = input.output_mode ?? "files_with_matches";
   if (mode === "files_with_matches") args.push("-l");
@@ -1180,26 +1745,27 @@ async function call4(input, signal) {
 }
 var grepTool = {
   name: "Grep",
-  description: description4,
-  inputSchema: inputSchema4,
-  parameters: parameters4,
+  description: description5,
+  inputSchema: inputSchema5,
+  parameters: parameters5,
   isReadOnly: true,
   isConcurrencySafe: true,
   maxResultSizeChars: DEFAULT_MAX_RESULT_SIZE_CHARS,
-  call: call4
+  call: call5
 };
 
 // src/tools/read/read.ts
-import { readFile as readFile6, stat as stat3 } from "fs/promises";
-import { resolve as resolve8 } from "path";
-import { z as z5 } from "zod";
-var inputSchema5 = z5.object({
-  file_path: z5.string().min(1, "\u5FC5\u987B\u63D0\u4F9B file_path").describe("\u8981\u8BFB\u53D6\u7684\u6587\u4EF6\u8DEF\u5F84\uFF0C\u7EDD\u5BF9\u8DEF\u5F84\u4F18\u5148"),
-  offset: z5.number().int().positive().optional().describe("\u8D77\u59CB\u884C\u53F7\uFF081-indexed\uFF09\uFF1B\u4E0D\u586B\u5219\u4ECE\u6587\u4EF6\u5F00\u5934\u8BFB"),
-  limit: z5.number().int().positive().optional().describe(`\u6700\u591A\u8BFB\u591A\u5C11\u884C\uFF1B\u4E0D\u586B\u5219\u7528\u9ED8\u8BA4\u503C ${MAX_LINES_TO_READ}`)
+import { createReadStream } from "fs";
+import { readFile as readFile8, stat as stat3 } from "fs/promises";
+import { createInterface } from "readline";
+import { z as z6 } from "zod";
+var inputSchema6 = z6.object({
+  file_path: z6.string().min(1, "\u5FC5\u987B\u63D0\u4F9B file_path").describe("\u8981\u8BFB\u53D6\u7684\u6587\u4EF6\u8DEF\u5F84\uFF0C\u7EDD\u5BF9\u8DEF\u5F84\u4F18\u5148"),
+  offset: z6.number().int().positive().optional().describe("\u8D77\u59CB\u884C\u53F7\uFF081-indexed\uFF09\uFF1B\u4E0D\u586B\u5219\u4ECE\u6587\u4EF6\u5F00\u5934\u8BFB"),
+  limit: z6.number().int().positive().optional().describe(`\u6700\u591A\u8BFB\u591A\u5C11\u884C\uFF1B\u4E0D\u586B\u5219\u7528\u9ED8\u8BA4\u503C ${MAX_LINES_TO_READ}`)
 });
-var parameters5 = toToolParameters(inputSchema5);
-var description5 = `Reads a file from the local filesystem. You can access any file directly by using this tool.
+var parameters6 = toToolParameters(inputSchema6);
+var description6 = `Reads a file from the local filesystem. You can access any file directly by using this tool.
 Assume this tool is able to read all files on the machine. If the User provides a path to a file assume that path is valid. It is okay to read a file that does not exist; an error will be returned.
 
 Usage:
@@ -1209,10 +1775,24 @@ Usage:
 - Results are returned using cat -n format, with line numbers starting at 1
 - This tool can only read text files, not directories. To read a directory, use the Glob tool.
 - If you read a file that exists but has empty contents you will receive a warning in place of file contents.`;
-async function call5(input) {
-  const filePath = resolve8(input.file_path);
+var STREAM_THRESHOLD = 1024 * 1024;
+async function call6(input) {
   const offset = input.offset ?? 1;
   const limit = input.limit ?? MAX_LINES_TO_READ;
+  const pathResult = validateAndResolvePath(input.file_path, getWorkingDir());
+  if (!pathResult.ok) {
+    return { ok: false, error: pathResult.error };
+  }
+  const filePath = pathResult.resolvedPath;
+  if (isBlockedDevicePath(filePath)) {
+    return { ok: false, error: `\u4E0D\u5141\u8BB8\u8BFB\u53D6\u8BBE\u5907\u6587\u4EF6\uFF1A${filePath}\u3002\u8BE5\u8DEF\u5F84\u53EF\u80FD\u4EA7\u751F\u65E0\u9650\u8F93\u51FA\u6216\u963B\u585E\u8FDB\u7A0B\u3002` };
+  }
+  if (hasBinaryExtension(filePath)) {
+    return {
+      ok: false,
+      error: `\u4E0D\u652F\u6301\u8BFB\u53D6\u4E8C\u8FDB\u5236\u6587\u4EF6\uFF1A${filePath}\uFF08\u6269\u5C55\u540D\u547D\u4E2D\u4E8C\u8FDB\u5236\u9ED1\u540D\u5355\uFF09\u3002\u82E5\u8BE5\u6587\u4EF6\u5B9E\u9645\u4E3A\u6587\u672C\uFF0C\u53EF\u6539\u540E\u7F00\u6216\u7528 Bash cat \u65C1\u8DEF\u3002`
+    };
+  }
   let st;
   try {
     st = await stat3(filePath);
@@ -1231,54 +1811,110 @@ async function call5(input) {
       error: `\u6587\u4EF6\u8FC7\u5927\uFF08${st.size} \u5B57\u8282 > ${MAX_FILE_SIZE_BYTES}\uFF09\u3002\u8BF7\u7528 offset/limit \u5206\u6BB5\u8BFB\u3002`
     };
   }
-  let raw;
-  try {
-    raw = await readFile6(filePath, "utf8");
-  } catch (e) {
-    return { ok: false, error: `\u8BFB\u53D6\u5931\u8D25\uFF1A${e.message}` };
+  let numbered;
+  let totalLines;
+  if (st.size <= STREAM_THRESHOLD) {
+    const result = await readSmallFile(filePath, offset, limit);
+    numbered = result.numbered;
+    totalLines = result.totalLines;
+    if (result.isEmpty) {
+      recordRead(filePath);
+      return { ok: true, content: "<file is empty>" };
+    }
+  } else {
+    const result = await readLargeFileStream(filePath, offset, limit);
+    numbered = result.numbered;
+    totalLines = result.totalLines;
   }
-  if (raw.length === 0) {
+  if (totalLines === 0 || !numbered) {
+    recordRead(filePath);
     return { ok: true, content: "<file is empty>" };
   }
-  const allLines = raw.split("\n");
-  const totalLines = allLines.length;
-  const startIdx = Math.max(0, offset - 1);
-  const endIdx = Math.min(totalLines, startIdx + limit);
-  const slice = allLines.slice(startIdx, endIdx);
-  const numbered = slice.map((line, i) => `${(startIdx + i + 1).toString()}	${line}`).join("\n");
   let content = numbered;
-  const contentLength = content.length;
-  if (contentLength > DEFAULT_MAX_RESULT_SIZE_CHARS) {
+  if (content.length > DEFAULT_MAX_RESULT_SIZE_CHARS) {
     content = content.slice(0, DEFAULT_MAX_RESULT_SIZE_CHARS) + `
 
 ... (\u8F93\u51FA\u8D85\u8FC7 ${DEFAULT_MAX_RESULT_SIZE_CHARS} \u5B57\u7B26\uFF0C\u5DF2\u622A\u65AD)`;
   }
+  const startIdx = Math.max(0, offset - 1);
+  const endIdx = Math.min(totalLines, startIdx + limit);
   if (endIdx < totalLines) {
     const nextOffset = endIdx + 1;
+    const returnedLines = content.split("\n").filter((l) => l.trim()).length;
     content += `
 
-... (\u672C\u6B21\u8FD4\u56DE ${slice.length} \u884C / \u6587\u4EF6\u5171 ${totalLines} \u884C\uFF1B\u7528 offset=${nextOffset} \u7EE7\u7EED\u8BFB)`;
+... (\u672C\u6B21\u8FD4\u56DE ${returnedLines} \u884C / \u6587\u4EF6\u5171 ${totalLines} \u884C\uFF1B\u7528 offset=${nextOffset} \u7EE7\u7EED\u8BFB)`;
   }
   if (st.size > 100 * 1024 && offset === 1) {
     content += `
 
 \u26A0\uFE0F \u6CE8\u610F\uFF1A\u8FD9\u662F\u4E00\u4E2A\u5927\u6587\u4EF6\uFF08${(st.size / 1024).toFixed(1)} KB\uFF09\u3002\u5EFA\u8BAE\u7528 offset/limit \u5206\u6BB5\u8BFB\u53D6\uFF0C\u4F8B\u5982\u5148\u8BFB\u5173\u952E\u90E8\u5206\uFF08imports\u3001exports\u3001\u51FD\u6570\u7B7E\u540D\uFF09\u3002`;
   }
+  recordRead(filePath);
   return { ok: true, content };
 }
+async function readSmallFile(filePath, offset, limit) {
+  const raw = await readFile8(filePath, "utf8");
+  if (raw.length === 0) {
+    return { numbered: "", totalLines: 0, isEmpty: true };
+  }
+  const allLines = raw.split("\n");
+  const totalLines = allLines.length;
+  const startIdx = Math.max(0, offset - 1);
+  const endIdx = Math.min(totalLines, startIdx + limit);
+  const slice = allLines.slice(startIdx, endIdx);
+  const numbered = slice.map((line, i) => `${(startIdx + i + 1).toString()}	${line}`).join("\n");
+  return { numbered, totalLines, isEmpty: false };
+}
+async function readLargeFileStream(filePath, offset, limit) {
+  return new Promise((resolvePromise, reject) => {
+    const lines = [];
+    let currentLine = 0;
+    const startIdx = Math.max(0, offset - 1);
+    const endLine = startIdx + limit;
+    const input = createReadStream(filePath, { encoding: "utf8" });
+    const rl = createInterface({
+      input,
+      crlfDelay: Infinity
+    });
+    input.on("error", (err) => {
+      reject(err);
+    });
+    rl.on("line", (line) => {
+      currentLine++;
+      if (currentLine > endLine) {
+        rl.close();
+        rl.removeAllListeners();
+        return;
+      }
+      if (currentLine >= offset) {
+        lines.push(`${currentLine}	${line}`);
+      }
+    });
+    rl.on("close", () => {
+      resolvePromise({
+        numbered: lines.join("\n"),
+        totalLines: currentLine
+      });
+    });
+    rl.on("error", (err) => {
+      reject(err);
+    });
+  });
+}
 var readTool = {
   name: "Read",
-  description: description5,
-  inputSchema: inputSchema5,
-  parameters: parameters5,
+  description: description6,
+  inputSchema: inputSchema6,
+  parameters: parameters6,
   isReadOnly: true,
   isConcurrencySafe: true,
   maxResultSizeChars: DEFAULT_MAX_RESULT_SIZE_CHARS,
-  call: call5
+  call: call6
 };
 
 // src/tools/webfetch/webfetch.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 
 // src/tools/webfetch/preapproved.ts
 var PREAPPROVED_HOSTS = /* @__PURE__ */ new Set([
@@ -1563,12 +2199,12 @@ function cleanCache() {
     }
   }
 }
-var inputSchema6 = z6.object({
-  url: z6.string().describe("\u8981\u83B7\u53D6\u5185\u5BB9\u7684 URL"),
-  prompt: z6.string().describe("\u5BF9\u5185\u5BB9\u8FDB\u884C\u5904\u7406\u7684\u6307\u4EE4\uFF0C\u63CF\u8FF0\u4F60\u60F3\u4ECE\u9875\u9762\u63D0\u53D6\u4EC0\u4E48\u4FE1\u606F")
+var inputSchema7 = z7.object({
+  url: z7.string().describe("\u8981\u83B7\u53D6\u5185\u5BB9\u7684 URL"),
+  prompt: z7.string().describe("\u5BF9\u5185\u5BB9\u8FDB\u884C\u5904\u7406\u7684\u6307\u4EE4\uFF0C\u63CF\u8FF0\u4F60\u60F3\u4ECE\u9875\u9762\u63D0\u53D6\u4EC0\u4E48\u4FE1\u606F")
 });
-var parameters6 = toToolParameters(inputSchema6);
-var description6 = `- Fetches content from a specified URL and processes it using an AI model.
+var parameters7 = toToolParameters(inputSchema7);
+var description7 = `- Fetches content from a specified URL and processes it using an AI model.
 - Takes a URL and a prompt as input.
 - Fetches the URL content, converts HTML to markdown.
 - Processes the content with the prompt (e.g., extract summary, find specific info).
@@ -1677,7 +2313,7 @@ async function htmlToMarkdown(html) {
   const td = new TurndownService();
   return td.turndown(html);
 }
-async function call6(input, signal) {
+async function call7(input, signal) {
   const { url } = input;
   const start = Date.now();
   const cacheKey = url;
@@ -1775,17 +2411,17 @@ ${content}`;
 }
 var webfetchTool = {
   name: "WebFetch",
-  description: description6,
-  inputSchema: inputSchema6,
-  parameters: parameters6,
+  description: description7,
+  inputSchema: inputSchema7,
+  parameters: parameters7,
   isReadOnly: true,
   isConcurrencySafe: true,
   maxResultSizeChars: DEFAULT_MAX_RESULT_SIZE_CHARS,
-  call: call6
+  call: call7
 };
 
 // src/tools/webbrowser/webbrowser.ts
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 
 // src/tools/webbrowser/browser.ts
 import os from "os";
@@ -1821,15 +2457,15 @@ function screenshotPath(prefix = "browser") {
 }
 
 // src/tools/webbrowser/webbrowser.ts
-var inputSchema7 = z7.object({
-  action: z7.enum(["navigate", "screenshot", "getContent", "click", "fill", "submit"]).describe("Browser action to perform"),
-  url: z7.string().url().optional().describe("URL to navigate to (required for navigate action)"),
-  selector: z7.string().optional().describe("CSS selector for click/fill/submit actions"),
-  value: z7.string().optional().describe("Value to fill in input fields"),
-  timeout: z7.number().int().positive().optional().describe("Timeout in milliseconds (default: 30000)")
+var inputSchema8 = z8.object({
+  action: z8.enum(["navigate", "screenshot", "getContent", "click", "fill", "submit"]).describe("Browser action to perform"),
+  url: z8.string().url().optional().describe("URL to navigate to (required for navigate action)"),
+  selector: z8.string().optional().describe("CSS selector for click/fill/submit actions"),
+  value: z8.string().optional().describe("Value to fill in input fields"),
+  timeout: z8.number().int().positive().optional().describe("Timeout in milliseconds (default: 30000)")
 });
-var parameters7 = toToolParameters(inputSchema7);
-var description7 = `Control a headless web browser. Navigate to URLs, take screenshots, and interact with web pages.
+var parameters8 = toToolParameters(inputSchema8);
+var description8 = `Control a headless web browser. Navigate to URLs, take screenshots, and interact with web pages.
 
 When to use WebBrowser vs WebSearch:
 - WebSearch: When you need to find information or discover URLs through search
@@ -1860,7 +2496,7 @@ Example actions:
   - Take screenshot: { action: "screenshot" }
   - Click element: { action: "click", selector: "#submit-btn" }
   - Fill form field: { action: "fill", selector: "input[name='email']", value: "user@example.com" }`;
-async function call7(input, signal) {
+async function call8(input, signal) {
   const { action, url, selector, value, timeout = 3e4 } = input;
   let page;
   try {
@@ -1964,30 +2600,30 @@ Current URL: ${page.url()}`
 }
 var webbrowserTool = {
   name: "WebBrowser",
-  description: description7,
-  inputSchema: inputSchema7,
-  parameters: parameters7,
+  description: description8,
+  inputSchema: inputSchema8,
+  parameters: parameters8,
   isReadOnly: false,
   isConcurrencySafe: false,
   maxResultSizeChars: DEFAULT_MAX_RESULT_SIZE_CHARS,
-  call: call7
+  call: call8
 };
 
 // src/tools/websearch/websearch.ts
-import { z as z8 } from "zod";
-var inputSchema8 = z8.object({
-  query: z8.string().min(1, "\u5FC5\u987B\u63D0\u4F9B\u641C\u7D22\u5173\u952E\u8BCD").max(400, "\u641C\u7D22\u5173\u952E\u8BCD\u592A\u957F\uFF08>400 \u5B57\uFF09").describe("\u641C\u7D22\u5173\u952E\u8BCD\uFF0C\u5EFA\u8BAE\u81EA\u7136\u8BED\u8A00\u63CF\u8FF0\u9700\u8981\u67E5\u7684\u4FE1\u606F"),
-  max_results: z8.number().int().min(1).max(20).optional().describe("\u8FD4\u56DE\u7ED3\u679C\u6570\u91CF\uFF0C1-20\uFF0C\u9ED8\u8BA4 5"),
-  search_depth: z8.enum(["basic", "advanced"]).optional().describe("basic \u5FEB\u4F46\u6D45\uFF1Badvanced \u6162\u4F46\u6DF1\uFF08\u542B answer \u6458\u8981\uFF09\uFF0C\u9ED8\u8BA4 basic"),
-  topic: z8.enum(["general", "news"]).optional().describe("general=\u901A\u7528\u7F51\u9875\uFF1Bnews=\u504F\u65B0\u95FB\u6E90\uFF1B\u9ED8\u8BA4 general")
+import { z as z9 } from "zod";
+var inputSchema9 = z9.object({
+  query: z9.string().min(1, "\u5FC5\u987B\u63D0\u4F9B\u641C\u7D22\u5173\u952E\u8BCD").max(400, "\u641C\u7D22\u5173\u952E\u8BCD\u592A\u957F\uFF08>400 \u5B57\uFF09").describe("\u641C\u7D22\u5173\u952E\u8BCD\uFF0C\u5EFA\u8BAE\u81EA\u7136\u8BED\u8A00\u63CF\u8FF0\u9700\u8981\u67E5\u7684\u4FE1\u606F"),
+  max_results: z9.number().int().min(1).max(20).optional().describe("\u8FD4\u56DE\u7ED3\u679C\u6570\u91CF\uFF0C1-20\uFF0C\u9ED8\u8BA4 5"),
+  search_depth: z9.enum(["basic", "advanced"]).optional().describe("basic \u5FEB\u4F46\u6D45\uFF1Badvanced \u6162\u4F46\u6DF1\uFF08\u542B answer \u6458\u8981\uFF09\uFF0C\u9ED8\u8BA4 basic"),
+  topic: z9.enum(["general", "news"]).optional().describe("general=\u901A\u7528\u7F51\u9875\uFF1Bnews=\u504F\u65B0\u95FB\u6E90\uFF1B\u9ED8\u8BA4 general")
 });
-var parameters8 = toToolParameters(inputSchema8);
-var description8 = `- Searches the public web via the Tavily Search API and returns structured results.
+var parameters9 = toToolParameters(inputSchema9);
+var description9 = `- Searches the public web via the Tavily Search API and returns structured results.
 - Use this when you need up-to-date information that is not in your training data, or when the user asks for recent news / docs / API references.
 - Returns the top N results, each with a title, URL, and content snippet. With \`search_depth: "advanced"\` Tavily also returns a synthesized answer at the top.
 - Prefer specific natural-language queries over keyword soup (e.g. "how does Bun handle .env files in version 1.1").
 - Requires the TAVILY_API_KEY environment variable to be set; if missing the tool returns a friendly error.`;
-async function call8(input, signal) {
+async function call9(input, signal) {
   const apiKey = process.env.TAVILY_API_KEY;
   if (!apiKey) {
     return {
@@ -2069,46 +2705,41 @@ ${(r.content ?? "").trim()}`
 }
 var webSearchTool = {
   name: "WebSearch",
-  description: description8,
-  inputSchema: inputSchema8,
-  parameters: parameters8,
+  description: description9,
+  inputSchema: inputSchema9,
+  parameters: parameters9,
   isReadOnly: true,
   isConcurrencySafe: true,
   maxResultSizeChars: DEFAULT_MAX_RESULT_SIZE_CHARS,
-  call: call8
+  call: call9
 };
 
 // src/tools/write/write.ts
-import { existsSync as existsSync4 } from "fs";
-import { mkdir as mkdir5, stat as stat4, writeFile as writeFile4 } from "fs/promises";
-import { dirname as dirname6, resolve as resolve9 } from "path";
-import { z as z9 } from "zod";
+import { existsSync as existsSync6 } from "fs";
+import { mkdir as mkdir5, stat as stat4, writeFile as writeFile5 } from "fs/promises";
+import { dirname as dirname6 } from "path";
+import { z as z10 } from "zod";
 var MAX_WRITE_SIZE_BYTES = 1024 * 1024 * 1024;
-var inputSchema9 = z9.object({
-  file_path: z9.string().min(1).describe("\u8981\u5199\u5165\u7684\u6587\u4EF6\u8DEF\u5F84"),
-  content: z9.string().describe("\u6587\u4EF6\u5B8C\u6574\u5185\u5BB9\uFF08\u4F1A\u8986\u76D6\u65E2\u6709\u5185\u5BB9\uFF09")
+var inputSchema10 = z10.object({
+  file_path: z10.string().min(1).describe("\u8981\u5199\u5165\u7684\u6587\u4EF6\u8DEF\u5F84"),
+  content: z10.string().describe("\u6587\u4EF6\u5B8C\u6574\u5185\u5BB9\uFF08\u4F1A\u8986\u76D6\u65E2\u6709\u5185\u5BB9\uFF09")
 });
-var parameters9 = toToolParameters(inputSchema9);
-var description9 = `Writes a file to the local filesystem.
+var parameters10 = toToolParameters(inputSchema10);
+var description10 = `Writes a file to the local filesystem.
 
 Usage:
 - This tool will overwrite the existing file if there is one at the provided path.
 - If the parent directory does not exist, it will be created recursively.
 - ALWAYS prefer editing existing files in the codebase via the Edit tool. NEVER write new files unless explicitly required.
 - NEVER create documentation files (*.md) or README files unless explicitly requested by the User.`;
-function validatePath2(filePath) {
-  if (filePath.includes("\0")) {
-    return { ok: false, error: "\u8DEF\u5F84\u5305\u542B\u975E\u6CD5\u5B57\u7B26\uFF08null byte\uFF09" };
+async function call10(input) {
+  const pathResult = validateAndResolvePath(input.file_path, getWorkingDir());
+  if (!pathResult.ok) return pathResult;
+  const filePath = pathResult.resolvedPath;
+  const freshness = assertFresh(filePath);
+  if (!freshness.ok) {
+    return { ok: false, error: freshness.error };
   }
-  if (process.platform === "win32" && filePath.includes("\\\\")) {
-    return { ok: false, error: "\u4E0D\u652F\u6301 UNC \u8DEF\u5F84\uFF08\\\\server\\share \u683C\u5F0F\uFF09\uFF0C\u8BF7\u4F7F\u7528\u672C\u5730\u8DEF\u5F84" };
-  }
-  return { ok: true };
-}
-async function call9(input) {
-  const filePath = resolve9(input.file_path);
-  const pathCheck = validatePath2(filePath);
-  if (!pathCheck.ok) return pathCheck;
   const contentSize = Buffer.byteLength(input.content, "utf8");
   if (contentSize > MAX_WRITE_SIZE_BYTES) {
     return {
@@ -2119,7 +2750,7 @@ async function call9(input) {
   try {
     await mkdir5(dirname6(filePath), { recursive: true });
     let originalSize = 0;
-    const fileExisted = existsSync4(filePath);
+    const fileExisted = existsSync6(filePath);
     if (fileExisted) {
       try {
         const st = await stat4(filePath);
@@ -2127,12 +2758,33 @@ async function call9(input) {
       } catch {
       }
     }
-    await writeFile4(filePath, input.content, "utf8");
+    let contentToWrite = input.content;
+    let bomEncoding = "utf8";
+    if (fileExisted) {
+      const detected = await detectFileBomEncoding(filePath);
+      if (detected === "utf16le") {
+        return {
+          ok: false,
+          error: "\u6682\u4E0D\u652F\u6301\u6539\u5199 UTF-16 LE \u6587\u4EF6\uFF08BOM=FF FE\uFF09\u3002\u8BF7\u6539\u7528 UTF-8 \u7F16\u7801\u3002"
+        };
+      }
+      bomEncoding = detected;
+      const lineEnding = await detectFileLineEndings(filePath);
+      contentToWrite = applyLineEnding(input.content, lineEnding);
+    }
+    if (bomEncoding === "utf8-bom") {
+      const bomBytes = Buffer.from([239, 187, 191]);
+      const bodyBytes = Buffer.from(contentToWrite, "utf8");
+      await writeFile5(filePath, Buffer.concat([bomBytes, bodyBytes]));
+    } else {
+      await writeFile5(filePath, contentToWrite, "utf8");
+    }
     const action = fileExisted ? "\u5DF2\u8986\u76D6" : "\u5DF2\u521B\u5EFA\u65B0\u6587\u4EF6";
-    const sizeInfo = fileExisted ? `\uFF08\u539F\u6587\u4EF6 ${originalSize} \u5B57\u7B26 \u2192 \u65B0\u5185\u5BB9 ${input.content.length} \u5B57\u7B26\uFF09` : `\uFF08${input.content.length} \u5B57\u7B26\uFF09`;
+    const sizeInfo = fileExisted ? `\uFF08\u539F\u6587\u4EF6 ${originalSize} \u5B57\u7B26 \u2192 \u65B0\u5185\u5BB9 ${contentToWrite.length} \u5B57\u7B26\uFF09` : `\uFF08${contentToWrite.length} \u5B57\u7B26\uFF09`;
+    const bomInfo = bomEncoding === "utf8-bom" ? "\uFF0C\u5DF2\u4FDD\u7559 UTF-8 BOM" : "";
     return {
       ok: true,
-      content: `${action} ${filePath}${sizeInfo}`
+      content: `${action} ${filePath}${sizeInfo}${bomInfo}`
     };
   } catch (e) {
     return { ok: false, error: `\u5199\u5165\u5931\u8D25\uFF1A${e.message}` };
@@ -2140,19 +2792,20 @@ async function call9(input) {
 }
 var writeTool = {
   name: "Write",
-  description: description9,
-  inputSchema: inputSchema9,
-  parameters: parameters9,
+  description: description10,
+  inputSchema: inputSchema10,
+  parameters: parameters10,
   isReadOnly: false,
   isConcurrencySafe: false,
   maxResultSizeChars: DEFAULT_MAX_RESULT_SIZE_CHARS,
-  call: call9
+  call: call10
 };
 
 // src/tools/index.ts
 var ALL_TOOLS = [
   readTool,
   editTool,
+  multiEditTool,
   writeTool,
   globTool,
   grepTool,
@@ -2962,7 +3615,7 @@ function MessageRow({ message }) {
 
 // src/ui/StatusLine.tsx
 import { Box as Box4, Text as Text4 } from "ink";
-import { homedir as homedir4 } from "os";
+import { homedir as homedir5 } from "os";
 import { sep } from "path";
 
 // src/llm/client.ts
@@ -3350,13 +4003,26 @@ function useTokenUsage(messages, provider) {
 }
 
 // src/ui/StatusLine.tsx
-import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
-function StatusLine({ provider, history }) {
+import { Fragment, jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+function StatusLine({ provider, history, pluginLoop }) {
   const usage = useTokenUsage(history, provider);
   const ratio = usage.tokens / usage.threshold;
   const color = ratio >= 1 ? "red" : ratio >= 0.7 ? "yellow" : "green";
   const cwdDisplay = shortenPath(getWorkingDir());
   return /* @__PURE__ */ jsxs4(Box4, { children: [
+    pluginLoop && /* @__PURE__ */ jsxs4(Fragment, { children: [
+      /* @__PURE__ */ jsxs4(Text4, { color: "magenta", children: [
+        "\u{1F504} ",
+        pluginLoop.pluginName,
+        " "
+      ] }),
+      /* @__PURE__ */ jsxs4(Text4, { color: "magenta", children: [
+        pluginLoop.current,
+        "/",
+        pluginLoop.max
+      ] }),
+      /* @__PURE__ */ jsx4(Text4, { color: "gray", children: " \xB7 " })
+    ] }),
     /* @__PURE__ */ jsx4(Text4, { color: "cyan", children: "cwd " }),
     /* @__PURE__ */ jsx4(Text4, { color: "gray", children: cwdDisplay }),
     /* @__PURE__ */ jsx4(Text4, { color: "gray", children: " \xB7 " }),
@@ -3382,7 +4048,7 @@ function fmt(n) {
   return `${(n / 1e6).toFixed(2)}M`;
 }
 function shortenPath(abs) {
-  const home = homedir4();
+  const home = homedir5();
   let p = abs;
   if (home && (p === home || p.startsWith(home + sep))) {
     p = "~" + p.slice(home.length);
@@ -3547,6 +4213,688 @@ async function reactiveCompactIfApplicable(messages, provider, error, state = de
   };
 }
 
+// src/plugins/commandRouter.ts
+import { readFile as readFile9, readdir as readdir3 } from "fs/promises";
+import { join as join6 } from "path";
+var PLUGINS_DIR = join6(findPackageRoot(import.meta.url), "plugins");
+var pluginCache = /* @__PURE__ */ new Map();
+var discoveryDone = false;
+function stripQuotes2(s) {
+  const trimmed = s.trim();
+  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+function parseMarkdownFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return {};
+  const frontmatter = {};
+  for (const line of match[1].split("\n")) {
+    const colon = line.indexOf(":");
+    if (colon < 0) continue;
+    const key = line.slice(0, colon).trim();
+    const value = line.slice(colon + 1).trim();
+    if (key) frontmatter[key] = stripQuotes2(value);
+  }
+  return frontmatter;
+}
+async function loadPlugin(pluginDirPath) {
+  const dirName = pluginDirPath.split("/").pop() ?? pluginDirPath;
+  const manifestPath = join6(pluginDirPath, ".claude-plugin", "plugin.json");
+  let manifestName = dirName;
+  let manifestVersion;
+  let manifestDesc;
+  try {
+    const raw = await readFile9(manifestPath, "utf8");
+    const parsed = JSON.parse(raw);
+    manifestName = parsed.name ?? dirName;
+    manifestVersion = parsed.version;
+    manifestDesc = parsed.description;
+  } catch {
+  }
+  const commandsDir = join6(pluginDirPath, "commands");
+  const commands = [];
+  try {
+    const entries = await readdir3(commandsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.name.endsWith(".md")) continue;
+      const cmdPath = join6(commandsDir, entry.name);
+      try {
+        const content = await readFile9(cmdPath, "utf8");
+        const fm = parseMarkdownFrontmatter(content);
+        const sep2 = content.indexOf("\n---", 4);
+        const body = sep2 >= 0 ? content.slice(sep2 + 4).trim() : content.trim();
+        commands.push({
+          name: entry.name.replace(/\.md$/, ""),
+          description: fm.description ?? "(no description)",
+          argumentHint: fm["argument-hint"],
+          pluginName: manifestName,
+          pluginRoot: pluginDirPath,
+          promptBody: body
+        });
+      } catch {
+      }
+    }
+  } catch {
+  }
+  const hooksJsonPath = join6(pluginDirPath, "hooks", "hooks.json");
+  let hasStopHook = false;
+  try {
+    const hooksRaw = await readFile9(hooksJsonPath, "utf8");
+    const hooksParsed = JSON.parse(hooksRaw);
+    const stopHooks = hooksParsed?.hooks?.Stop;
+    if (Array.isArray(stopHooks) && stopHooks.length > 0) {
+      hasStopHook = true;
+    }
+  } catch {
+  }
+  if (commands.length === 0 && !hasStopHook) return null;
+  return {
+    name: manifestName,
+    version: manifestVersion,
+    description: manifestDesc,
+    root: pluginDirPath,
+    commands,
+    hasStopHook
+  };
+}
+async function discoverPlugins() {
+  if (discoveryDone && pluginCache.size > 0) {
+    return Array.from(pluginCache.values());
+  }
+  pluginCache.clear();
+  discoveryDone = true;
+  try {
+    const entries = await readdir3(PLUGINS_DIR, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (entry.name.startsWith(".")) continue;
+      const plugin = await loadPlugin(join6(PLUGINS_DIR, entry.name));
+      if (plugin) {
+        pluginCache.set(plugin.name, plugin);
+      }
+    }
+  } catch {
+  }
+  return Array.from(pluginCache.values());
+}
+function resolveCommand(input) {
+  const trimmed = input.trimStart();
+  if (!trimmed.startsWith("/")) return null;
+  const spaceIdx = trimmed.indexOf(" ", 1);
+  const cmdName = spaceIdx >= 0 ? trimmed.slice(1, spaceIdx) : trimmed.slice(1);
+  const args = spaceIdx >= 0 ? trimmed.slice(spaceIdx + 1) : "";
+  for (const plugin of pluginCache.values()) {
+    for (const cmd of plugin.commands) {
+      if (cmd.name === cmdName) {
+        return { cmd, arguments: args };
+      }
+    }
+  }
+  return null;
+}
+var COMMAND_DEFAULTS = {
+  "ralph-loop": ["--max-iterations", "50"]
+};
+function applyDefaultArgs(cmdName, args) {
+  const defaults = COMMAND_DEFAULTS[cmdName];
+  if (!defaults) return args;
+  const existing = new Set(args.trim().split(/\s+/).filter(Boolean));
+  let result = args;
+  for (let i = 0; i < defaults.length; i += 2) {
+    const flag = defaults[i];
+    if (existing.has(flag)) continue;
+    result = result.trim() ? `${result} ${flag} ${defaults[i + 1]}` : `${flag} ${defaults[i + 1]}`;
+  }
+  return result;
+}
+function buildCommandInput(resolved) {
+  const { cmd, arguments: rawArgs } = resolved;
+  const args = applyDefaultArgs(cmd.name, rawArgs);
+  let input = cmd.promptBody;
+  input = input.replaceAll("${CLAUDE_PLUGIN_ROOT}", cmd.pluginRoot);
+  input = input.replaceAll("$ARGUMENTS", args);
+  input = input.replaceAll("${ARGUMENTS}", args);
+  if (args.trim()) {
+    input += `
+
+\u7528\u6237\u53C2\u6570: ${args.trim()}`;
+  }
+  return input;
+}
+function getActiveStopHookPlugins() {
+  const result = [];
+  for (const plugin of pluginCache.values()) {
+    if (plugin.hasStopHook) {
+      result.push(plugin.root);
+    }
+  }
+  return result;
+}
+
+// src/plugins/stopHook.ts
+import { readFile as readFile10 } from "fs/promises";
+import { join as join7 } from "path";
+import { spawn as spawn4 } from "child_process";
+async function loadStopHookConfig(pluginRoot) {
+  const hooksJsonPath = join7(pluginRoot, "hooks", "hooks.json");
+  try {
+    const raw = await readFile10(hooksJsonPath, "utf8");
+    const parsed = JSON.parse(raw);
+    const stopEntries = parsed?.hooks?.Stop;
+    if (!Array.isArray(stopEntries)) return [];
+    const commands = [];
+    for (const entry of stopEntries) {
+      const hooks = entry.hooks;
+      if (Array.isArray(hooks)) {
+        for (const h of hooks) {
+          if (h.type === "command" && h.command) {
+            commands.push(h);
+          }
+        }
+      }
+    }
+    return commands;
+  } catch {
+    return [];
+  }
+}
+async function executeStopHooks(pluginRoots, transcriptText) {
+  if (process.platform === "win32") {
+    return { decision: "pass" };
+  }
+  for (const pluginRoot of pluginRoots) {
+    const hookConfigs = await loadStopHookConfig(pluginRoot);
+    for (const hookConfig of hookConfigs) {
+      const result = await runSingleStopHook(hookConfig, pluginRoot, transcriptText);
+      if (result.decision === "block") {
+        return result;
+      }
+    }
+  }
+  return { decision: "pass" };
+}
+function runSingleStopHook(hookConfig, pluginRoot, transcriptText) {
+  const resolvedCommand = hookConfig.command.replaceAll("${CLAUDE_PLUGIN_ROOT}", pluginRoot);
+  return new Promise((resolve9) => {
+    const child = spawn4("bash", [resolvedCommand], {
+      env: {
+        ...process.env,
+        CLAUDE_PLUGIN_ROOT: pluginRoot
+      }
+    });
+    let stdout = "";
+    child.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    child.on("error", () => {
+      resolve9({ decision: "pass" });
+    });
+    child.on("close", (code) => {
+      if (code !== 0) {
+        resolve9({ decision: "pass" });
+        return;
+      }
+      const trimmed = stdout.trim();
+      if (!trimmed) {
+        resolve9({ decision: "pass" });
+        return;
+      }
+      try {
+        const parsed = JSON.parse(trimmed);
+        if (parsed.decision === "block") {
+          resolve9({
+            decision: "block",
+            reason: typeof parsed.reason === "string" ? parsed.reason : void 0,
+            systemMessage: typeof parsed.systemMessage === "string" ? parsed.systemMessage : void 0
+          });
+          return;
+        }
+        resolve9({ decision: "pass" });
+      } catch {
+        resolve9({ decision: "pass" });
+      }
+    });
+    child.stdin.write(transcriptText);
+    child.stdin.end();
+  });
+}
+
+// src/plugins/verificationGate.ts
+import { existsSync as existsSync7, readFileSync } from "fs";
+import { spawn as spawn5 } from "child_process";
+function parseVerifyArg(arg) {
+  const colonIdx = arg.indexOf(":");
+  if (colonIdx < 0) return null;
+  const type = arg.slice(0, colonIdx).trim().toLowerCase();
+  const value = arg.slice(colonIdx + 1).trim();
+  switch (type) {
+    case "shell":
+      return { type: "shell", command: value, timeout: 3e4 };
+    case "file_exists":
+      return { type: "file_exists", file: value };
+    case "file_contains": {
+      const sep2 = value.indexOf(":");
+      if (sep2 < 0) return null;
+      return {
+        type: "file_contains",
+        file: value.slice(0, sep2),
+        pattern: value.slice(sep2 + 1)
+      };
+    }
+    case "test_count": {
+      const count = parseInt(value, 10);
+      if (isNaN(count) || count < 0) return null;
+      return { type: "test_count", minCount: count };
+    }
+    default:
+      return null;
+  }
+}
+function parseVerifyArgs(args) {
+  const checks = [];
+  const regex = /--verify\s+("[^"]*"|\S+)/gi;
+  let match;
+  while ((match = regex.exec(args)) !== null) {
+    const raw = match[1].replace(/^"|"$/g, "");
+    const check = parseVerifyArg(raw);
+    if (check) checks.push(check);
+  }
+  return checks;
+}
+function runShell(command, timeout) {
+  return new Promise((resolve9) => {
+    const isWin = process.platform === "win32";
+    const child = isWin ? spawn5("cmd", ["/c", command], { timeout, env: process.env }) : spawn5("bash", ["-c", command], { timeout, env: process.env });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (d) => {
+      stdout += d.toString();
+    });
+    child.stderr.on("data", (d) => {
+      stderr += d.toString();
+    });
+    child.on("error", () => {
+      resolve9({ exitCode: null, stdout, stderr, errored: true });
+    });
+    child.on("close", (code) => {
+      resolve9({ exitCode: code, stdout, stderr, errored: false });
+    });
+  });
+}
+async function verifyShell(command, timeout) {
+  const r = await runShell(command, timeout);
+  if (r.errored) {
+    return {
+      check: { type: "shell", command },
+      passed: false,
+      output: `\u6267\u884C\u5931\u8D25`
+    };
+  }
+  return {
+    check: { type: "shell", command },
+    passed: r.exitCode === 0,
+    output: r.stdout.trim() || r.stderr.trim() || `exit code ${r.exitCode}`
+  };
+}
+function verifyFileExists(file) {
+  const exists = existsSync7(file);
+  return {
+    check: { type: "file_exists", file },
+    passed: exists,
+    output: exists ? "\u6587\u4EF6\u5B58\u5728" : `\u6587\u4EF6\u4E0D\u5B58\u5728: ${file}`
+  };
+}
+function verifyFileContains(file, pattern) {
+  try {
+    const content = readFileSync(file, "utf8");
+    const regex = new RegExp(pattern);
+    const matched = regex.test(content);
+    return {
+      check: { type: "file_contains", file, pattern },
+      passed: matched,
+      output: matched ? `\u6587\u4EF6\u5305\u542B "${pattern}"` : `\u6587\u4EF6\u4E0D\u5305\u542B "${pattern}"`
+    };
+  } catch {
+    return {
+      check: { type: "file_contains", file, pattern },
+      passed: false,
+      output: `\u65E0\u6CD5\u8BFB\u53D6\u6587\u4EF6: ${file}`
+    };
+  }
+}
+async function verifyTestCount(minCount) {
+  const r = await runShell(`bun test`, 6e4);
+  const combined = `${r.stdout}
+${r.stderr}`;
+  if (r.errored) {
+    return {
+      check: { type: "test_count", minCount },
+      passed: false,
+      output: "\u65E0\u6CD5\u6267\u884C bun test"
+    };
+  }
+  const matches = [...combined.matchAll(/(\d+)\s+pass/gi)];
+  const count = matches.length > 0 ? parseInt(matches[matches.length - 1][1], 10) : 0;
+  const passed = count >= minCount;
+  return {
+    check: { type: "test_count", minCount },
+    passed,
+    output: `${count} pass (\u9700\u8981 >=${minCount})`
+  };
+}
+async function runVerification(checks) {
+  if (checks.length === 0) {
+    return { passed: true, details: [], summary: "\u65E0\u9A8C\u8BC1\u9879" };
+  }
+  const results = [];
+  for (const check of checks) {
+    let result;
+    switch (check.type) {
+      case "shell":
+        result = await verifyShell(check.command ?? "", check.timeout ?? 3e4);
+        break;
+      case "file_exists":
+        result = verifyFileExists(check.file ?? "");
+        break;
+      case "file_contains":
+        result = verifyFileContains(check.file ?? "", check.pattern ?? "");
+        break;
+      case "test_count":
+        result = await verifyTestCount(check.minCount ?? 0);
+        break;
+      default:
+        result = {
+          check,
+          passed: false,
+          output: `\u672A\u77E5\u9A8C\u8BC1\u7C7B\u578B: ${check.type}`
+        };
+    }
+    results.push(result);
+  }
+  const allPassed = results.every((r) => r.passed);
+  const failedNames = results.filter((r) => !r.passed).map((r) => formatCheckName(r.check));
+  let summary;
+  if (allPassed) {
+    summary = `\u2705 \u5168\u90E8\u901A\u8FC7 (${results.length}/${results.length})`;
+  } else {
+    summary = `\u274C \u9A8C\u8BC1\u672A\u901A\u8FC7: ${failedNames.join(", ")}`;
+  }
+  return { passed: allPassed, details: results, summary };
+}
+function formatCheckName(check) {
+  switch (check.type) {
+    case "shell":
+      return `shell(${(check.command ?? "").slice(0, 40)})`;
+    case "file_exists":
+      return `exists(${check.file})`;
+    case "file_contains":
+      return `contains(${check.file}:${check.pattern})`;
+    case "test_count":
+      return `tests(>=${check.minCount})`;
+    default:
+      return check.type;
+  }
+}
+
+// src/plugins/goalState.ts
+import { mkdir as mkdir6, appendFile, writeFile as writeFile6, unlink as unlink2, rmdir as rmdir2 } from "fs/promises";
+import { existsSync as existsSync8, readFileSync as readFileSync2 } from "fs";
+import { join as join8 } from "path";
+var Phase = /* @__PURE__ */ ((Phase2) => {
+  Phase2["PLAN"] = "plan";
+  Phase2["BUILD"] = "build";
+  Phase2["VERIFY"] = "verify";
+  Phase2["HEAL"] = "heal";
+  Phase2["DONE"] = "done";
+  return Phase2;
+})(Phase || {});
+var VALID_PHASES = new Set(Object.values(Phase));
+var PHASE_TRANSITIONS = {
+  ["plan" /* PLAN */]: {
+    plan_complete: "build" /* BUILD */,
+    stuck: "plan" /* PLAN */
+  },
+  ["build" /* BUILD */]: {
+    task_complete: "verify" /* VERIFY */,
+    need_replan: "plan" /* PLAN */,
+    tests_failing: "heal" /* HEAL */
+  },
+  ["verify" /* VERIFY */]: {
+    all_pass: "build" /* BUILD */,
+    failures: "heal" /* HEAL */,
+    goal_complete: "done" /* DONE */
+  },
+  ["heal" /* HEAL */]: {
+    fixed: "verify" /* VERIFY */,
+    cannot_fix_locally: "plan" /* PLAN */
+  },
+  ["done" /* DONE */]: {}
+};
+function isLegalTransition(from, to) {
+  if (from === to) return true;
+  const allowed = PHASE_TRANSITIONS[from];
+  if (!allowed) return false;
+  return Object.values(allowed).includes(to);
+}
+var LEARNINGS_TAIL_LINES = 20;
+var GoalState = class {
+  dir;
+  constructor(workspaceDir, sessionTag) {
+    const suffix = sessionTag ? `-${sessionTag}` : "";
+    this.dir = join8(workspaceDir, `.minimal-agent${suffix}`);
+  }
+  async reset() {
+    const files = ["goal.md", "completion.md", "phase.md", "progress.md", "learnings.md", "decisions.md"];
+    for (const f of files) {
+      try {
+        await unlink2(join8(this.dir, f));
+      } catch {
+      }
+    }
+  }
+  async init(goal, criteria) {
+    await mkdir6(this.dir, { recursive: true });
+    const files = {
+      goal: `# \u4E0D\u53EF\u53D8\u76EE\u6807 (IMMUTABLE GOAL)
+
+${goal}
+`,
+      completion: JSON.stringify(criteria, null, 2),
+      phase: "plan" /* PLAN */,
+      progress: "",
+      learnings: "",
+      decisions: ""
+    };
+    for (const [name, content] of Object.entries(files)) {
+      const path2 = join8(this.dir, `${name}.md`);
+      if (!existsSync8(path2)) {
+        await writeFile6(path2, content);
+      }
+    }
+  }
+  get goal() {
+    try {
+      return readFileSync2(join8(this.dir, "goal.md"), "utf8").trim();
+    } catch {
+      return "";
+    }
+  }
+  get completionCriteria() {
+    try {
+      const raw = readFileSync2(join8(this.dir, "completion.md"), "utf8").trim();
+      return JSON.parse(raw);
+    } catch {
+      return [];
+    }
+  }
+  get currentPhase() {
+    try {
+      const raw = readFileSync2(join8(this.dir, "phase.md"), "utf8").trim();
+      if (VALID_PHASES.has(raw)) {
+        return raw;
+      }
+    } catch {
+    }
+    return "plan" /* PLAN */;
+  }
+  /**
+   * 切换阶段。`reason` 是给人看的日志文本，不参与校验。
+   * 校验只看 from→to 是否在 PHASE_TRANSITIONS 表里有路径（任意 event 通向 to 即合法）。
+   * 想绕开 FSM 用 forceSetPhase。
+   */
+  async setPhase(phase, reason) {
+    if (!VALID_PHASES.has(phase)) {
+      throw new Error(`Invalid phase: ${phase}`);
+    }
+    const current = this.currentPhase;
+    if (!isLegalTransition(current, phase)) {
+      throw new Error(
+        `\u975E\u6CD5\u9636\u6BB5\u5207\u6362: ${current} \u2192 ${phase}\u3002\u8BE5\u76EE\u6807\u9636\u6BB5\u4E0D\u5728 PHASE_TRANSITIONS[${current}] \u7684\u53EF\u8FBE\u96C6\u5408\u5185\uFF0C\u9700\u8981\u8D70 forceSetPhase\u3002`
+      );
+    }
+    await writeFile6(join8(this.dir, "phase.md"), phase);
+    await this.appendProgress(`PHASE \u2192 ${phase}: ${reason}`);
+  }
+  async forceSetPhase(phase, reason) {
+    if (!VALID_PHASES.has(phase)) {
+      throw new Error(`Invalid phase: ${phase}`);
+    }
+    await writeFile6(join8(this.dir, "phase.md"), phase);
+    await this.appendProgress(`PHASE \u2192 ${phase}: ${reason}`);
+  }
+  async appendProgress(line) {
+    const timestamp = (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", { hour12: false });
+    await appendFile(join8(this.dir, "progress.md"), `[${timestamp}] ${line}
+`);
+  }
+  tailProgress(n) {
+    try {
+      const content = readFileSync2(join8(this.dir, "progress.md"), "utf8");
+      const lines = content.trim().split("\n").filter(Boolean);
+      return lines.slice(-n).join("\n");
+    } catch {
+      return "";
+    }
+  }
+  async appendLearning(lesson) {
+    await appendFile(join8(this.dir, "learnings.md"), `- ${lesson}
+`);
+  }
+  get learnings() {
+    try {
+      const raw = readFileSync2(join8(this.dir, "learnings.md"), "utf8").trim();
+      if (!raw) return "";
+      const lines = raw.split("\n").filter(Boolean);
+      return lines.slice(-LEARNINGS_TAIL_LINES).join("\n");
+    } catch {
+      return "";
+    }
+  }
+  async recordDecision(ctx, options, chosen, reasoning) {
+    const entry = {
+      iteration: ctx.iteration,
+      phase: ctx.phase,
+      contextSummary: ctx.summary,
+      options,
+      chosen,
+      reasoning
+    };
+    const line = JSON.stringify(entry);
+    await appendFile(join8(this.dir, "decisions.md"), `${line}
+`);
+  }
+  findSimilarDecisions(ctx, k = 3) {
+    try {
+      const content = readFileSync2(join8(this.dir, "decisions.md"), "utf8");
+      const lines = content.trim().split("\n").filter(Boolean);
+      const entries = [];
+      for (const line of lines) {
+        try {
+          entries.push(JSON.parse(line));
+        } catch {
+        }
+      }
+      const scored = entries.map((entry) => ({
+        entry,
+        score: this._similarity(entry.contextSummary, ctx.summary)
+      })).sort((a, b) => b.score - a.score);
+      return scored.slice(0, k).filter((s) => s.score > 0.3).map((s) => s.entry);
+    } catch {
+      return [];
+    }
+  }
+  summarizeDecisions(maxEntries = 5) {
+    try {
+      const content = readFileSync2(join8(this.dir, "decisions.md"), "utf8");
+      const lines = content.trim().split("\n").filter(Boolean);
+      const entries = [];
+      for (const line of lines.slice(-maxEntries * 2)) {
+        try {
+          entries.push(JSON.parse(line));
+        } catch {
+        }
+      }
+      return entries.slice(-maxEntries).map(
+        (e) => `\u8FED\u4EE3 ${e.iteration}\uFF08${e.phase}\uFF09: \u5728 [${e.options.join(", ")}] \u4E2D\u9009\u62E9\u4E86 **${e.chosen}**\uFF0C\u539F\u56E0\uFF1A${e.reasoning.slice(0, 80)}`
+      ).join("\n");
+    } catch {
+      return "(\u65E0\u51B3\u7B56\u8BB0\u5F55)";
+    }
+  }
+  composeContext(iteration) {
+    const sections = [];
+    sections.push(`# \u4E0D\u53EF\u53D8\u76EE\u6807 (IMMUTABLE GOAL)
+${this.goal}
+\u26A0\uFE0F \u6CE8\u610F\uFF1A\u4F60\u4E0D\u80FD\u4FEE\u6539\u6216\u6269\u5927\u4E0A\u8FF0\u76EE\u6807\u3002\u5982\u679C\u4F60\u8BA4\u4E3A\u76EE\u6807\u672C\u8EAB\u6709\u95EE\u9898\uFF0C\u8BF7\u8F93\u51FA <PROMISE>NEED_GOAL_REVISION</PROMISE> \u5E76\u505C\u6B62\u3002`);
+    sections.push(`# \u5F53\u524D\u9636\u6BB5: ${this.currentPhase.toUpperCase()}`);
+    const lrn = this.learnings;
+    if (lrn) {
+      sections.push(`# \u5173\u952E\u6559\u8BAD\uFF08\u5FC5\u987B\u9075\u5B88\uFF0C\u907F\u514D\u91CD\u590D\u8E29\u5751\uFF09
+${lrn}`);
+    }
+    const decisions = this.summarizeDecisions(3);
+    if (decisions !== "(\u65E0\u51B3\u7B56\u8BB0\u5F55)") {
+      sections.push(`# \u5386\u53F2\u5173\u952E\u51B3\u7B56\uFF08\u8BF7\u53C2\u8003\uFF0C\u907F\u514D\u91CD\u590D\u8BD5\u9519\uFF09
+${decisions}`);
+    }
+    const recentProgress = this.tailProgress(10);
+    if (recentProgress) {
+      sections.push(`# \u6700\u8FD1\u8FDB\u5EA6
+${recentProgress}`);
+    }
+    sections.push(`---
+
+# \u672C\u8F6E\u4EFB\u52A1 (\u8FED\u4EE3 ${iteration})`);
+    return sections.join("\n\n---\n\n");
+  }
+  async cleanup() {
+    const files = ["goal.md", "completion.md", "phase.md", "progress.md", "learnings.md", "decisions.md"];
+    for (const f of files) {
+      try {
+        await unlink2(join8(this.dir, f));
+      } catch {
+      }
+    }
+    try {
+      await rmdir2(this.dir);
+    } catch {
+    }
+  }
+  _similarity(a, b) {
+    if (!a || !b) return 0;
+    const wordsA = new Set(a.toLowerCase().split(/\s+/));
+    const wordsB = new Set(b.toLowerCase().split(/\s+/));
+    let intersection = 0;
+    for (const word of wordsA) {
+      if (wordsB.has(word)) intersection++;
+    }
+    const union = (/* @__PURE__ */ new Set([...wordsA, ...wordsB])).size;
+    return union > 0 ? intersection / union : 0;
+  }
+};
+
 // src/context/microCompactLite.ts
 import { createHash as createHash2 } from "crypto";
 var MAX_REPEAT_COUNT = 3;
@@ -3782,6 +5130,179 @@ function previewArgs(rawJson) {
   return oneLine.slice(0, 60) + "...";
 }
 
+// src/plugins/pluginRunner.ts
+var DEFAULT_MAX_ITERATIONS = 50;
+var SAFETY_CEILING = 200;
+function extractMaxIterations(args) {
+  const match = args.match(/--max-iterations\s+(\d+)/i);
+  return match ? parseInt(match[1], 10) : void 0;
+}
+async function* runWithPlugins(userInput, options) {
+  const { provider, history, signal } = options;
+  const isSlashCommand = userInput.trimStart().startsWith("/");
+  let currentInput = userInput;
+  let matchedCmd = null;
+  if (isSlashCommand) {
+    await discoverPlugins();
+    matchedCmd = resolveCommand(userInput);
+    if (matchedCmd) {
+      currentInput = buildCommandInput(matchedCmd);
+    }
+  }
+  const activeHookPlugins = matchedCmd ? getActiveStopHookPlugins() : [];
+  const enterLoop = matchedCmd !== null && activeHookPlugins.length > 0;
+  if (!enterLoop) {
+    yield* runQuery(currentInput, {
+      provider,
+      history,
+      signal,
+      maxTurns: options.maxTurns,
+      sessionState: options.sessionState
+    });
+    return;
+  }
+  const cmd = matchedCmd.cmd;
+  const maxIter = Math.min(
+    extractMaxIterations(currentInput) ?? DEFAULT_MAX_ITERATIONS,
+    SAFETY_CEILING
+  );
+  yield {
+    type: "plugin_start",
+    pluginName: cmd.pluginName,
+    description: cmd.description
+  };
+  const checks = parseVerifyArgs(matchedCmd.arguments);
+  const goalState = new GoalState(getWorkingDir(), cmd.pluginName);
+  await goalState.reset();
+  await goalState.init(currentInput, checks);
+  await goalState.appendProgress(`=== Loop \u542F\u52A8 === \u76EE\u6807: ${currentInput.slice(0, 120)}...`);
+  const baseHistory = history.slice();
+  let iterationCount = 0;
+  let consecutiveFailures = 0;
+  let finalAssistantMsg = null;
+  try {
+    do {
+      iterationCount++;
+      if (iterationCount > maxIter) {
+        await goalState.forceSetPhase("done" /* DONE */, `\u8FBE\u5230\u8FED\u4EE3\u4E0A\u9650 ${maxIter}`);
+        await goalState.appendLearning(`[\u8FED\u4EE3\u4E0A\u9650] \u5FAA\u73AF\u5728 ${iterationCount - 1} \u8F6E\u540E\u5F3A\u5236\u7EC8\u6B62\uFF0C\u53EF\u80FD\u76EE\u6807\u8FC7\u5927\u6216\u9677\u5165\u6B7B\u5FAA\u73AF`);
+        yield { type: "error", error: `Loop \u5DF2\u8FBE\u8FED\u4EE3\u4E0A\u9650 ${maxIter}\uFF0C\u81EA\u52A8\u505C\u6B62` };
+        return;
+      }
+      if (signal?.aborted) {
+        yield { type: "interrupted" };
+        return;
+      }
+      yield {
+        type: "plugin_iteration",
+        pluginName: cmd.pluginName,
+        current: iterationCount,
+        max: maxIter
+      };
+      history.length = 0;
+      history.push(...baseHistory);
+      const freshContext = goalState.composeContext(iterationCount);
+      const enhancedInput = `${freshContext}
+
+${currentInput}`;
+      yield* runQuery(enhancedInput, {
+        provider,
+        history,
+        signal,
+        maxTurns: options.maxTurns,
+        sessionState: options.sessionState
+      });
+      if (signal?.aborted) {
+        yield { type: "interrupted" };
+        return;
+      }
+      const lastAssistantIdx = (() => {
+        for (let i = history.length - 1; i >= 0; i--) {
+          if (history[i].role === "assistant") return i;
+        }
+        return -1;
+      })();
+      finalAssistantMsg = lastAssistantIdx >= 0 ? history[lastAssistantIdx] : null;
+      const lastAssistantText = finalAssistantMsg ? typeof finalAssistantMsg.content === "string" ? finalAssistantMsg.content : JSON.stringify(finalAssistantMsg.content) : "";
+      const hasCompleteSentinel = /<promise>(?:COMPLETE|DONE|GOAL_COMPLETE)<\/promise>/i.test(lastAssistantText);
+      const hasNeedReplan = /<PROMISE>NEED_REPLAN<\/PROMISE>/i.test(lastAssistantText);
+      if (hasCompleteSentinel) {
+        await goalState.forceSetPhase("verify" /* VERIFY */, "\u68C0\u6D4B\u5230\u5B8C\u6210\u54E8\u5175\uFF0C\u8FDB\u5165\u9A8C\u8BC1");
+        await goalState.appendProgress(`\u8FED\u4EE3 ${iterationCount}: \u68C0\u6D4B\u5230\u5B8C\u6210\u54E8\u5175\uFF0C\u8FD0\u884C\u9A8C\u8BC1\u95E8...`);
+        if (checks.length > 0) {
+          const vResult = await runVerification(checks);
+          if (!vResult.passed) {
+            consecutiveFailures++;
+            await goalState.appendLearning(
+              `[\u8FED\u4EE3 ${iterationCount}] \u58F0\u79F0\u5B8C\u6210\u4F46\u9A8C\u8BC1\u672A\u901A\u8FC7: ${vResult.summary}`
+            );
+            yield {
+              type: "error",
+              error: `\u26A0\uFE0F \u9A8C\u8BC1\u672A\u901A\u8FC7: ${vResult.summary}\u3002\u7EE7\u7EED\u5C1D\u8BD5...`
+            };
+            if (consecutiveFailures >= 3) {
+              await goalState.forceSetPhase(
+                "heal" /* HEAL */,
+                `\u8FDE\u7EED ${consecutiveFailures} \u6B21\u9A8C\u8BC1\u5931\u8D25`
+              );
+            } else {
+              await goalState.setPhase("build" /* BUILD */, "\u9A8C\u8BC1\u672A\u901A\u8FC7\uFF0C\u8FD4\u56DE\u6784\u5EFA");
+            }
+            continue;
+          }
+          await goalState.appendProgress(`\u2705 \u9A8C\u8BC1\u901A\u8FC7: ${vResult.summary}`);
+        }
+        await goalState.setPhase("done" /* DONE */, "goal complete & verified");
+        yield {
+          type: "plugin_iteration",
+          pluginName: cmd.pluginName,
+          current: iterationCount,
+          max: maxIter
+        };
+        return;
+      }
+      if (hasNeedReplan) {
+        await goalState.forceSetPhase("plan" /* PLAN */, "agent \u8BF7\u6C42\u91CD\u65B0\u89C4\u5212");
+        await goalState.appendLearning("[NEED_REPLAN] Agent \u8BA4\u4E3A\u5F53\u524D\u65B9\u6848\u4E0D\u53EF\u884C\uFF0C\u9700\u8981\u91CD\u65B0\u89C4\u5212");
+        await goalState.appendProgress("Agent \u8BF7\u6C42 NEED_REPLAN\uFF0C\u56DE PLAN \u9636\u6BB5");
+        consecutiveFailures = 0;
+        continue;
+      }
+      if (goalState.currentPhase === "plan" /* PLAN */ && iterationCount >= 2) {
+        await goalState.setPhase("build" /* BUILD */, "\u89C4\u5212\u9636\u6BB5\u5DF2\u5B8C\u6210\uFF0C\u8FDB\u5165\u6784\u5EFA");
+      }
+      const hookTranscript = lastAssistantText;
+      const hookResult = await executeStopHooks(activeHookPlugins, hookTranscript);
+      if (hookResult.decision === "block" && hookResult.reason) {
+        currentInput = hookResult.reason;
+        consecutiveFailures = 0;
+        await goalState.recordDecision(
+          { iteration: iterationCount, phase: goalState.currentPhase, summary: "stop-hook \u53CD\u9988" },
+          ["\u7EE7\u7EED\u5FAA\u73AF", "\u7EC8\u6B62"],
+          "\u7EE7\u7EED\u5FAA\u73AF",
+          hookResult.reason.slice(0, 200)
+        );
+        if (hookResult.systemMessage) {
+          baseHistory.push({
+            role: "user",
+            content: `[Plugin Stop Hook] ${hookResult.systemMessage}`
+          });
+        }
+        await goalState.appendProgress(`\u8FED\u4EE3 ${iterationCount}: Stop hook block\uFF0C\u6CE8\u5165\u53CD\u9988\u7EE7\u7EED`);
+      } else {
+        await goalState.appendProgress(`\u8FED\u4EE3 ${iterationCount}: \u65E0\u54E8\u5175 / hook pass\uFF0C\u7EE7\u7EED\u4E0B\u4E00\u8F6E`);
+      }
+    } while (true);
+  } finally {
+    history.length = 0;
+    history.push(...baseHistory);
+    if (finalAssistantMsg) {
+      history.push(finalAssistantMsg);
+    }
+    await goalState.cleanup();
+  }
+}
+
 // src/ui/hooks/useChat.ts
 function useChat(args) {
   const historyRef = useRef3(args.initialHistory.slice());
@@ -3793,6 +5314,7 @@ function useChat(args) {
   const [error, setError] = useState5(null);
   const [interrupted, setInterrupted] = useState5(false);
   const [compacting, setCompacting] = useState5(false);
+  const [pluginLoop, setPluginLoop] = useState5(null);
   const abortRef = useRef3(null);
   useEffect(() => {
     return () => {
@@ -3808,10 +5330,11 @@ function useChat(args) {
       setError(null);
       setInterrupted(false);
       setStreamingText("");
+      setPluginLoop(null);
       const ac = new AbortController();
       abortRef.current = ac;
       try {
-        for await (const ev of runQuery(trimmed, {
+        for await (const ev of runWithPlugins(trimmed, {
           provider: args.provider,
           history: historyRef.current,
           signal: ac.signal
@@ -3822,6 +5345,7 @@ function useChat(args) {
             setCompacting,
             setError,
             setInterrupted,
+            setPluginLoop,
             bump
           });
         }
@@ -3832,6 +5356,7 @@ function useChat(args) {
         setStreamingText("");
         setToolStatus(null);
         setCompacting(false);
+        setPluginLoop(null);
         abortRef.current = null;
         args.onPersist?.(historyRef.current);
       }
@@ -3854,6 +5379,7 @@ function useChat(args) {
     setCompacting(false);
     bump();
     await clearContext();
+    clearFileState();
   }, [bump, isLoading]);
   const compactNow = useCallback5(async () => {
     if (isLoading) return;
@@ -3887,6 +5413,7 @@ function useChat(args) {
     error,
     interrupted,
     compacting,
+    pluginLoop,
     submit,
     abort,
     clearHistory,
@@ -3934,6 +5461,16 @@ function handleEvent(ev, setters) {
       setters.setError(ev.error);
       setters.bump();
       break;
+    case "plugin_start":
+      break;
+    case "plugin_iteration":
+      setters.setPluginLoop({
+        pluginName: ev.pluginName,
+        current: ev.current,
+        max: ev.max ?? 0
+      });
+      setters.bump();
+      break;
   }
 }
 
@@ -3982,7 +5519,7 @@ function App({ provider, initialHistory }) {
         onCompact: chat2.compactNow
       }
     ),
-    /* @__PURE__ */ jsx6(StatusLine, { provider, history: chat2.history })
+    /* @__PURE__ */ jsx6(StatusLine, { provider, history: chat2.history, pluginLoop: chat2.pluginLoop })
   ] });
 }
 
@@ -4041,8 +5578,28 @@ function truncateForDisplay(content, max = TOOL_OUTPUT_PREVIEW_MAX) {
   return content.slice(0, max) + "...";
 }
 function extractPromptArgs(args) {
-  const FLAGS = /* @__PURE__ */ new Set(["-p", "--print", "--verbose", "-v", "-h", "--help"]);
-  return args.filter((a) => !FLAGS.has(a));
+  const FLAG_BOOLEAN = /* @__PURE__ */ new Set([
+    "-p",
+    "--print",
+    "--verbose",
+    "-v",
+    "-h",
+    "--help",
+    "-V",
+    "--version"
+  ]);
+  const FLAG_WITH_VALUE = /* @__PURE__ */ new Set(["-d", "--cwd"]);
+  const result = [];
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (FLAG_BOOLEAN.has(a)) continue;
+    if (FLAG_WITH_VALUE.has(a)) {
+      i++;
+      continue;
+    }
+    result.push(a);
+  }
+  return result;
 }
 async function runPrintMode(provider, args, initialHistory, options) {
   process.stdout.on("error", handleEPIPE(process.stdout));
@@ -4073,7 +5630,7 @@ async function runPrintMode(provider, args, initialHistory, options) {
   const history = initialHistory;
   const output = { buffer: "" };
   try {
-    for await (const event of runQuery(prompt, {
+    for await (const event of runWithPlugins(prompt, {
       provider,
       history,
       signal: abortController.signal
@@ -4142,13 +5699,13 @@ function handleEvent2(event, output, verbose) {
   }
 }
 function readFromStdin() {
-  return new Promise((resolve10) => {
+  return new Promise((resolve9) => {
     let data = "";
     let settled = false;
     const timer = setTimeout(() => {
       if (!settled) {
         settled = true;
-        resolve10("");
+        resolve9("");
       }
     }, STDIN_TIMEOUT_MS);
     process.stdin.setEncoding("utf8");
@@ -4159,7 +5716,7 @@ function readFromStdin() {
       if (!settled) {
         clearTimeout(timer);
         settled = true;
-        resolve10(data.trim());
+        resolve9(data.trim());
       }
     }
     process.stdin.on("data", onData);
@@ -4172,9 +5729,17 @@ import { jsx as jsx8 } from "react/jsx-runtime";
 var require2 = createRequire(import.meta.url);
 var pkg = require2("../package.json");
 async function main() {
+  const args = process.argv.slice(2);
+  const dirArg = extractCwdArg(args);
+  if (dirArg) {
+    const abs = resolve8(dirArg);
+    if (!existsSync9(abs)) {
+      mkdirSync(abs, { recursive: true });
+    }
+    process.chdir(abs);
+  }
   initWorkingDir();
   await migrateLegacyContext(getWorkingDir());
-  const args = process.argv.slice(2);
   if (args.includes("-h") || args.includes("--help")) {
     printHelp();
     return;
@@ -4185,15 +5750,15 @@ async function main() {
   }
   const isPrintMode = args.includes("-p") || args.includes("--print");
   if (isPrintMode) {
-    let provider;
-    try {
-      provider = await loadProvider();
-    } catch (e) {
+    const provider = await loadProviderLayered();
+    if (!provider) {
       process.stderr.write(
         `
-${e.message}
+\u672A\u627E\u5230 provider \u914D\u7F6E\u3002
 
-\u63D0\u793A\uFF1A-p \u6A21\u5F0F\u4E0D\u652F\u6301\u4EA4\u4E92\u914D\u7F6E\u3002\u8BF7\u5148\u76F4\u63A5\u8FD0\u884C \`minimal-agent\` \u5B8C\u6210\u9996\u6B21\u914D\u7F6E\u5411\u5BFC\uFF0C\u6216\u5728 .env \u4E2D\u624B\u52A8\u586B\u597D BASE_URL / API_KEY / MODEL\u3002
+\u8BF7\u4E8C\u9009\u4E00\uFF1A
+  1. \u8BBE\u7F6E\u73AF\u5883\u53D8\u91CF MINIMAL_AGENT_BASE_URL / MINIMAL_AGENT_API_KEY / MINIMAL_AGENT_MODEL
+  2. \u5148\u76F4\u63A5\u8FD0\u884C \`minimal-agent\`\uFF08TUI\uFF09\u5B8C\u6210\u9996\u6B21\u914D\u7F6E\u5411\u5BFC\uFF1B\u5411\u5BFC\u4F1A\u5199\u51FA ~/.minimal-agent/config.json\uFF0C\u4E4B\u540E -p \u6A21\u5F0F\u81EA\u52A8\u590D\u7528
 
 `
       );
@@ -4227,6 +5792,8 @@ minimal-agent - \u8F7B\u91CF\u7EA7 AI \u7F16\u7A0B\u52A9\u624B
 \u9009\u9879:
   -p, --print        \u975E\u4EA4\u4E92\u6A21\u5F0F\uFF0C\u76F4\u63A5\u6267\u884C\u5355\u6B21\u95EE\u7B54
   -v, --verbose      \u663E\u793A\u8BE6\u7EC6\u8F93\u51FA\uFF08\u5DE5\u5177\u8C03\u7528\u3001\u538B\u7F29\u4FE1\u606F\uFF09
+  -d, --cwd <dir>    \u6307\u5B9A\u5DE5\u4F5C\u76EE\u5F55\uFF08\u4E0D\u5B58\u5728\u81EA\u52A8\u521B\u5EFA\uFF09\uFF1B\u542F\u52A8\u65F6 chdir \u5230\u8FD9\u91CC\uFF0C
+                     \u4E0A\u4E0B\u6587\u6587\u4EF6\u3001\u5DE5\u5177\u76F8\u5BF9\u8DEF\u5F84\u3001.env \u52A0\u8F7D\u90FD\u4EE5\u6B64\u4E3A\u57FA\u51C6
   -h, --help         \u663E\u793A\u5E2E\u52A9\u4FE1\u606F
 
 \u4F1A\u8BDD\u8BB0\u5FC6:
@@ -4238,6 +5805,7 @@ minimal-agent - \u8F7B\u91CF\u7EA7 AI \u7F16\u7A0B\u52A9\u624B
   minimal-agent -p "\u5E2E\u6211\u5199\u4E00\u4E2A hello world"
   echo "\u89E3\u91CA\u4EE3\u7801" | minimal-agent -p
   minimal-agent -p --verbose "\u8FD0\u884C\u6D4B\u8BD5\u5E76\u62A5\u544A\u7ED3\u679C"
+  minimal-agent -p "\u5904\u7406\u8D44\u6599" -d /tmp/job-123        # \u5DE5\u4F5C\u76EE\u5F55\u9694\u79BB
   `);
 }
 main().catch((e) => {