minimal-agent 0.1.8 → 0.2.0

package/dist/main.js

@@ -4,7 +4,7 @@
 import { render } from "ink";
 import { existsSync as existsSync9, mkdirSync } from "fs";
 import { createRequire } from "module";
-import { resolve as resolve8 } from "path";
+import { resolve as resolve9 } from "path";
 
 // src/bootstrap/cwdArg.ts
 function extractCwdArg(argv) {
@@ -50,6 +50,7 @@ async function readSavedConfig() {
       model: data.model,
       provider: typeof data.provider === "string" ? data.provider : void 0,
       contextWindow: typeof data.contextWindow === "number" && data.contextWindow > 0 ? data.contextWindow : void 0,
+      tavilyApiKey: typeof data.tavilyApiKey === "string" && data.tavilyApiKey.length > 0 ? data.tavilyApiKey : void 0,
       savedAt: typeof data.savedAt === "number" ? data.savedAt : 0
     };
   } catch {
@@ -98,6 +99,13 @@ async function loadProviderLayered() {
     contextWindow
   };
 }
+async function applyToolKeysToEnv() {
+  const saved = await readSavedConfig();
+  if (!saved) return;
+  if (!process.env.TAVILY_API_KEY && saved.tavilyApiKey) {
+    process.env.TAVILY_API_KEY = saved.tavilyApiKey;
+  }
+}
 
 // src/context/persistContext.ts
 import { mkdir as mkdir3, readFile as readFile2, readdir, rmdir, unlink, writeFile as writeFile2 } from "fs/promises";
@@ -221,7 +229,11 @@ async function loadProjectInstructions(cwd) {
 
 // src/prompts/skillList.ts
 import { readFile as readFile4, readdir as readdir2 } from "fs/promises";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
+
+// src/utils/resourcePaths.ts
+import { existsSync as existsSync2 } from "fs";
+import { join as join5, resolve as resolve4 } from "path";
 
 // src/utils/packageRoot.ts
 import { existsSync } from "fs";
@@ -245,8 +257,26 @@ function findPackageRoot(metaUrl) {
   throw new Error(`packageRoot: \u627E\u4E0D\u5230 package.json\uFF08\u8D77\u70B9 ${metaUrl}\uFF09`);
 }
 
+// src/utils/resourcePaths.ts
+function getResourceSearchPaths(name, metaUrl) {
+  const paths = [];
+  const cwdPath = resolve4(join5(getWorkingDir(), name));
+  if (existsSync2(cwdPath)) {
+    paths.push(cwdPath);
+  }
+  let pkgPath;
+  try {
+    pkgPath = resolve4(join5(findPackageRoot(metaUrl), name));
+  } catch {
+    return paths;
+  }
+  if (pkgPath !== cwdPath && existsSync2(pkgPath)) {
+    paths.push(pkgPath);
+  }
+  return paths;
+}
+
 // src/prompts/skillList.ts
-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("'")) {
@@ -254,7 +284,7 @@ function stripQuotes(s) {
   }
   return trimmed;
 }
-function parseFrontmatter(content) {
+function parseFrontmatter(content, sourceDir) {
   const match = content.match(/^---\n([\s\S]*?)\n---/);
   if (!match) return null;
   const frontmatter = match[1];
@@ -267,26 +297,33 @@ function parseFrontmatter(content) {
     name: stripQuotes(nameMatch[1]),
     description: stripQuotes(descMatch[1]),
     type: typeMatch ? stripQuotes(typeMatch[1]) : void 0,
-    triggers: triggersMatch ? stripQuotes(triggersMatch[1]) : void 0
+    triggers: triggersMatch ? stripQuotes(triggersMatch[1]) : void 0,
+    sourceDir
   };
 }
 async function getSkillList() {
   const skills = [];
-  try {
-    const entries = await readdir2(SKILLS_DIR, { withFileTypes: true });
-    for (const entry of entries) {
-      if (!entry.isDirectory()) continue;
-      const skillPath = join5(SKILLS_DIR, entry.name, "SKILL.md");
-      try {
-        const content = await readFile4(skillPath, "utf8");
-        const meta = parseFrontmatter(content);
-        if (meta) {
-          skills.push(meta);
+  const seenNames = /* @__PURE__ */ new Set();
+  const searchPaths = getResourceSearchPaths("skills", import.meta.url);
+  for (const root of searchPaths) {
+    try {
+      const entries = await readdir2(root, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        const sourceDir = join6(root, entry.name);
+        const skillPath = join6(sourceDir, "SKILL.md");
+        try {
+          const content = await readFile4(skillPath, "utf8");
+          const meta = parseFrontmatter(content, sourceDir);
+          if (meta && !seenNames.has(meta.name)) {
+            seenNames.add(meta.name);
+            skills.push(meta);
+          }
+        } catch {
         }
-      } catch {
       }
+    } catch {
     }
-  } catch {
   }
   return skills;
 }
@@ -297,13 +334,11 @@ function formatSkillHint(skills) {
   const lines = [];
   lines.push("# \u53EF\u7528\u6280\u80FD\uFF08/\u547D\u4EE4\uFF09");
   lines.push("");
-  lines.push(`> Skills \u6839\u76EE\u5F55\u7EDD\u5BF9\u8DEF\u5F84\uFF1A\`${SKILLS_DIR}\``);
-  lines.push("");
   lines.push(
-    "\u4EE5\u4E0B\u662F\u5F53\u524D\u53EF\u7528\u7684\u6280\u80FD\u3002**\u5F53\u7528\u6237\u610F\u56FE\u5339\u914D\u67D0\u4E2A\u6280\u80FD\u7684\u89E6\u53D1\u65F6\u673A\u65F6\uFF0C\u4F60\u5E94\u8BE5\u4E3B\u52A8\u4F7F\u7528\u5B83**\u3002"
+    "\u4EE5\u4E0B\u662F\u5F53\u524D\u53EF\u7528\u7684\u6280\u80FD\uFF08**\u53CC\u6E90**\uFF1A\u7528\u6237\u9879\u76EE\u76EE\u5F55 + minimal-agent \u5305\u76EE\u5F55\uFF0C\u540C\u540D\u65F6\u9879\u76EE\u4F18\u5148\uFF09\u3002**\u5F53\u7528\u6237\u610F\u56FE\u5339\u914D\u67D0\u4E2A\u6280\u80FD\u7684\u89E6\u53D1\u65F6\u673A\u65F6\uFF0C\u4F60\u5E94\u8BE5\u4E3B\u52A8\u4F7F\u7528\u5B83**\u3002"
   );
   lines.push(
-    `\u5728\u4F7F\u7528\u524D\uFF0C\u5148\u7528 Read \u5DE5\u5177\u8BFB\u53D6 \`${SKILLS_DIR}/{name}/SKILL.md\` \u4E86\u89E3\u5B8C\u6574\u6D41\u7A0B\u3002`
+    "\u5728\u4F7F\u7528\u524D\uFF0C\u5148\u7528 Read \u5DE5\u5177\u8BFB\u53D6\u4E0B\u65B9\u6BCF\u4E2A\u6280\u80FD\u5361\u7247\u91CC\u7684 `**\u6280\u80FD\u76EE\u5F55**` \u8DEF\u5F84 + `/SKILL.md` \u4E86\u89E3\u5B8C\u6574\u6D41\u7A0B\u3002"
   );
   lines.push("");
   for (const skill of skills) {
@@ -313,14 +348,14 @@ function formatSkillHint(skills) {
     lines.push(`- **\u89E6\u53D1\u65F6\u673A**: ${triggers}`);
     lines.push(`- **\u529F\u80FD**: ${skill.description}`);
     lines.push(`- **\u7C7B\u578B**: ${type}`);
-    lines.push(`- **\u6280\u80FD\u76EE\u5F55**: \`${SKILLS_DIR}/${skill.name}/\``);
+    lines.push(`- **\u6280\u80FD\u76EE\u5F55**: \`${skill.sourceDir}\``);
     lines.push("");
   }
   lines.push("## \u6280\u80FD\u8C03\u7528\u6D41\u7A0B");
   lines.push("");
   lines.push("```");
   lines.push("1. \u5728 T \u9636\u6BB5\u5224\u65AD\u7528\u6237\u610F\u56FE\u662F\u5426\u5339\u914D\u67D0\u4E2A\u6280\u80FD\u7684\u89E6\u53D1\u65F6\u673A");
-  lines.push(`2. \u5339\u914D \u2192 \u5728 A \u9636\u6BB5\u7528 Read \u5DE5\u5177\u8BFB\u53D6 ${SKILLS_DIR}/{name}/SKILL.md`);
+  lines.push('2. \u5339\u914D \u2192 \u5728 A \u9636\u6BB5\u7528 Read \u5DE5\u5177\u8BFB\u53D6\u8BE5\u6280\u80FD\u5361\u7247\u7684"\u6280\u80FD\u76EE\u5F55"/SKILL.md');
   lines.push("3. \u6309\u7167 SKILL.md \u7684 Quick Reference \u548C\u6D41\u7A0B\u6267\u884C");
   lines.push("4. \u6280\u80FD\u811A\u672C\uFF08scripts/\uFF09\u4E0E SKILL.md \u4F4D\u4E8E\u540C\u4E00\u76EE\u5F55\u4E0B\uFF0C\u7528\u7EDD\u5BF9\u8DEF\u5F84\u6267\u884C");
   lines.push("5. \u5982\u679C\u6280\u80FD\u7C7B\u578B\u662F prompt\uFF0C\u5C06\u5176\u5185\u5BB9\u4F5C\u4E3A\u989D\u5916\u4E0A\u4E0B\u6587\u6307\u5BFC\u540E\u7EED\u64CD\u4F5C");
@@ -382,6 +417,14 @@ ${toolList}
 # \u6280\u80FD\u7CFB\u7EDF\uFF08\u79EF\u6781\u4F7F\u7528\uFF09
 ${skillHint}
 
+# \u63D2\u4EF6\u7CFB\u7EDF\uFF08\u88AB\u52A8\u89E6\u53D1\uFF09
+- minimal-agent \u5728 \`plugins/\` \u76EE\u5F55\u4E0B\u52A0\u8F7D\u7528\u6237\u5B89\u88C5\u7684\u63D2\u4EF6\uFF0C\u6BCF\u4E2A\u63D2\u4EF6\u53EF\u66B4\u9732\u5F62\u5982 \`/<cmd>\` \u7684\u547D\u4EE4\u3002
+  \u4E0E skill \u4E0D\u540C\uFF0C**\u63D2\u4EF6\u547D\u4EE4\u5FC5\u987B\u7531\u7528\u6237\u4E3B\u52A8\u8F93\u5165\u624D\u89E6\u53D1**\u2014\u2014\u4F60**\u4E0D\u8981**\u4E3B\u52A8\u8C03\u7528\u6216\u6A21\u62DF\u8FD9\u4E9B\u547D\u4EE4\uFF0C
+  \u4E5F\u4E0D\u8981\u5728\u5DE5\u5177\u8C03\u7528\u91CC\u5047\u88C5\u5728\u8DD1\u63D2\u4EF6\u3002
+- \u5F53\u67D0\u4E2A\u63D2\u4EF6\u547D\u4EE4\u5728\u6267\u884C\u4E2D\uFF08\u4F60\u4F1A\u5728\u5F53\u8F6E\u7528\u6237\u6D88\u606F\u91CC\u770B\u5230\u8BE5\u63D2\u4EF6\u6CE8\u5165\u7684\u4E0A\u4E0B\u6587 / \u9636\u6BB5\u6807\u8BB0 / \u54E8\u5175\u7EA6\u5B9A\uFF09\uFF0C
+  \u8BF7\u4E25\u683C\u6309\u7167\u8BE5\u63D2\u4EF6\u7ED9\u51FA\u7684\u6307\u5F15\u884C\u52A8\uFF0C\u4E0D\u8981\u7ED5\u5F00\u5B83\u7684\u5951\u7EA6\u3002
+- \u5728**\u5E38\u89C4\u5BF9\u8BDD**\uFF08\u65E0\u63D2\u4EF6\u6CE8\u5165\u7684\u9636\u6BB5\u6807\u8BB0 / \u54E8\u5175\u7EA6\u5B9A\uFF09\u4E2D\uFF0C\u4E0D\u8981\u51ED\u7A7A\u4F7F\u7528\u8FD9\u4E9B\u6807\u8BB0\u6216\u54E8\u5175\u8BCD\u3002
+
 # \u6587\u4EF6\u8BFB\u53D6\u89C4\u8303\uFF08\u91CD\u8981\uFF01\u9632\u6B62\u4E0A\u4E0B\u6587\u6C61\u67D3\uFF09
 ## \u8BFB\u53D6\u7B56\u7565\uFF08\u6309\u573A\u666F\u9009\u62E9\uFF09
 ### \u573A\u666F 1\uFF1A\u4E0D\u786E\u5B9A\u6587\u4EF6\u5185\u5BB9
@@ -861,14 +904,14 @@ var bashTool = {
 
 // src/tools/edit/edit.ts
 import { readFile as readFile6, writeFile as writeFile3, mkdir as mkdir4 } from "fs/promises";
-import { existsSync as existsSync3 } from "fs";
+import { existsSync as existsSync4 } from "fs";
 import { dirname as dirname5 } from "path";
-import { z as z2 } from "zod";
+import { z as z3 } 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";
+import { extname, resolve as resolve5 } from "path";
 var BLOCKED_DEVICE_PATHS = /* @__PURE__ */ new Set([
   "/dev/zero",
   "/dev/random",
@@ -904,7 +947,7 @@ function validateAndResolvePath(rawPath, workingDir) {
     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);
+  const resolved = resolve5(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` };
   }
@@ -915,10 +958,13 @@ function validateAndResolvePath(rawPath, workingDir) {
 }
 function expandPath(p) {
   if (p.startsWith("~/") || p === "~") {
-    return resolve4(homedir4(), p.slice(2));
+    return resolve5(homedir4(), p.slice(2));
   }
   return p;
 }
+function resolveToolPath(rawPath) {
+  return validateAndResolvePath(rawPath, getWorkingDir());
+}
 function detectLineEndingsForString(content) {
   let crlfCount = 0;
   let lfCount = 0;
@@ -1108,9 +1154,28 @@ function applyCurlySingleQuotes(str) {
   }
   return result.join("");
 }
+function countOccurrences(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 splitReplaceAll(haystack, needle, replacement) {
+  return haystack.split(needle).join(replacement);
+}
+
+// src/tools/shared/schemas.ts
+import { z as z2 } from "zod";
+function filePathField(action) {
+  return z2.string().min(1, "\u5FC5\u987B\u63D0\u4F9B file_path").describe(`\u8981${action}\u7684\u6587\u4EF6\u8DEF\u5F84\uFF08\u7EDD\u5BF9\u8DEF\u5F84\u4F18\u5148\uFF0C\u76F8\u5BF9\u8DEF\u5F84\u57FA\u4E8E working dir \u89E3\u6790\uFF09`);
+}
 
 // src/tools/shared/fileState.ts
-import { existsSync as existsSync2, statSync } from "fs";
+import { existsSync as existsSync3, statSync } from "fs";
 var fileState = /* @__PURE__ */ new Map();
 function recordRead(absPath) {
   try {
@@ -1122,7 +1187,7 @@ function recordRead(absPath) {
 function assertFresh(absPath) {
   const entry = fileState.get(absPath);
   if (!entry) {
-    if (existsSync2(absPath)) {
+    if (existsSync3(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`
@@ -1149,13 +1214,13 @@ function clearFileState() {
 
 // 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"),
-  old_string: z2.string().describe(
+var inputSchema2 = z3.object({
+  file_path: filePathField("\u7F16\u8F91"),
+  old_string: z3.string().describe(
     "\u8981\u66FF\u6362\u7684\u539F\u6587\u672C\uFF08\u5FC5\u987B\u5728\u6587\u4EF6\u4E2D\u552F\u4E00\uFF0C\u9664\u975E replace_all=true\uFF09\uFF1B\u4E3A\u7A7A\u5B57\u7B26\u4E32\u4E14\u6587\u4EF6\u4E0D\u5B58\u5728\u65F6\u521B\u5EFA\u65B0\u6587\u4EF6"
   ),
-  new_string: z2.string().describe("\u66FF\u6362\u4E3A\u7684\u65B0\u6587\u672C\uFF08\u4E0E old_string \u5FC5\u987B\u4E0D\u540C\uFF09"),
-  replace_all: z2.boolean().optional().describe("\u662F\u5426\u66FF\u6362\u6240\u6709\u51FA\u73B0\u4F4D\u7F6E\uFF08\u9ED8\u8BA4 false\uFF09")
+  new_string: z3.string().describe("\u66FF\u6362\u4E3A\u7684\u65B0\u6587\u672C\uFF08\u4E0E old_string \u5FC5\u987B\u4E0D\u540C\uFF09"),
+  replace_all: z3.boolean().optional().describe("\u662F\u5426\u66FF\u6362\u6240\u6709\u51FA\u73B0\u4F4D\u7F6E\uFF08\u9ED8\u8BA4 false\uFF09")
 });
 var parameters2 = toToolParameters(inputSchema2);
 var description2 = `Performs exact string replacements in files.
@@ -1164,7 +1229,8 @@ Usage:
 - You MUST use your \`Read\` tool to read the current content of the file BEFORE calling Edit.
   Memory is unreliable \u2014 if you think you "remember" how the code looks, you are probably wrong.
   Re-read the relevant sections (function, module, or area you plan to change) every time.
-- To create a new file, pass an empty \`old_string\` and the desired contents as \`new_string\`.
+- To create a new file, pass an empty \`old_string\` and the desired contents as \`new_string\`. When creating a new file (path does not yet exist), you may call Edit directly \u2014 no prior Read is needed.
+- If the file already exists and you pass an empty \`old_string\`, the edit is rejected with a clear error. To replace the entire content of an existing file, use the Write tool instead.
 - ALWAYS prefer editing existing files in the codebase. NEVER write new files unless explicitly required.
 - 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.
@@ -1172,7 +1238,7 @@ Usage:
 async function call2(input) {
   const { old_string, new_string } = input;
   const replaceAll = input.replace_all ?? false;
-  const pathResult = validateAndResolvePath(input.file_path, getWorkingDir());
+  const pathResult = resolveToolPath(input.file_path);
   if (!pathResult.ok) return pathResult;
   const filePath = pathResult.resolvedPath;
   const freshness = assertFresh(filePath);
@@ -1182,10 +1248,11 @@ async function call2(input) {
   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 === "" && !existsSync3(filePath)) {
+  if (old_string === "" && !existsSync4(filePath)) {
     try {
       await mkdir4(dirname5(filePath), { recursive: true });
       await writeFile3(filePath, new_string, "utf8");
+      recordRead(filePath);
       return {
         ok: true,
         content: `\u5DF2\u521B\u5EFA\u65B0\u6587\u4EF6\uFF1A${filePath}\uFF08${new_string.length} \u5B57\u7B26\uFF09`
@@ -1194,7 +1261,7 @@ async function call2(input) {
       return { ok: false, error: `\u521B\u5EFA\u6587\u4EF6\u5931\u8D25\uFF1A${e.message}` };
     }
   }
-  if (!existsSync3(filePath)) {
+  if (!existsSync4(filePath)) {
     return {
       ok: false,
       error: `\u6587\u4EF6\u4E0D\u5B58\u5728\uFF1A${filePath}
@@ -1250,6 +1317,7 @@ async function call2(input) {
   const normalizedReplaced = applyLineEnding(replaced, originalLineEnding);
   try {
     await writeFile3(filePath, normalizedReplaced, "utf8");
+    recordRead(filePath);
   } catch (e) {
     return { ok: false, error: `\u5199\u5165\u5931\u8D25\uFF1A${e.message}` };
   }
@@ -1262,19 +1330,6 @@ async function call2(input) {
 \u884C\u6570\uFF1A${linesBefore} \u2192 ${linesAfter}`
   };
 }
-function countOccurrences(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 splitReplaceAll(haystack, needle, replacement) {
-  return haystack.split(needle).join(replacement);
-}
 function findFuzzyMatchHint(fileContent, target) {
   const MIN_OVERLAP_RATIO = 0.5;
   const MAX_HINTS = 3;
@@ -1349,16 +1404,16 @@ var editTool = {
 
 // 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")
+import { existsSync as existsSync5 } from "fs";
+import { z as z4 } from "zod";
+var editItemSchema = z4.object({
+  old_string: z4.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: z4.string().describe("\u66FF\u6362\u4E3A\u7684\u65B0\u6587\u672C"),
+  replace_all: z4.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 inputSchema3 = z4.object({
+  file_path: filePathField("\u7F16\u8F91"),
+  edits: z4.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).
@@ -1371,28 +1426,15 @@ Usage:
 - 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());
+  const pathResult = resolveToolPath(input.file_path);
   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)) {
+  if (!existsSync5(filePath)) {
     return {
       ok: false,
       error: `\u6587\u4EF6\u4E0D\u5B58\u5728\uFF1A${filePath}
@@ -1433,7 +1475,7 @@ async function call3(input) {
       searchTarget = actualOld;
       processedNewString = preserveQuoteStyle(edit.old_string, actualOld, edit.new_string);
     }
-    const occurrences = countOccurrences2(currentContent, searchTarget);
+    const occurrences = countOccurrences(currentContent, searchTarget);
     if (occurrences === 0) {
       return {
         ok: false,
@@ -1446,12 +1488,13 @@ async function call3(input) {
         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);
+    currentContent = replaceAll ? splitReplaceAll(currentContent, searchTarget, processedNewString) : currentContent.replace(searchTarget, processedNewString);
   }
   const lineEnding = await detectFileLineEndings(filePath);
   const finalContent = applyLineEnding(currentContent, lineEnding);
   try {
     await writeFile4(filePath, finalContent, "utf8");
+    recordRead(filePath);
   } catch (e) {
     return { ok: false, error: `\u5199\u5165\u5931\u8D25\uFF1A${e.message}` };
   }
@@ -1473,12 +1516,12 @@ var multiEditTool = {
 
 // src/tools/glob/glob.ts
 import { stat as stat2 } from "fs/promises";
-import { isAbsolute, resolve as resolve5 } from "path";
+import { isAbsolute, resolve as resolve6 } from "path";
 import fg from "fast-glob";
-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')
+import { z as z5 } from "zod";
+var inputSchema4 = z5.object({
+  pattern: z5.string().min(1).describe('glob \u6A21\u5F0F\uFF0C\u4F8B\u5982 "**/*.ts" \u6216 "src/components/**/*.tsx"'),
+  path: z5.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 parameters4 = toToolParameters(inputSchema4);
 var description4 = `- Fast file pattern matching tool that works with any codebase size
@@ -1487,7 +1530,7 @@ var description4 = `- Fast file pattern matching tool that works with any codeba
 - 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 call4(input) {
-  const cwd = input.path ? resolve5(input.path) : getWorkingDir();
+  const cwd = input.path ? resolve6(input.path) : getWorkingDir();
   const pattern = input.pattern.replace(/\\/g, "/");
   let matches;
   try {
@@ -1508,7 +1551,7 @@ async function call4(input) {
   }
   const withMtime = await Promise.all(
     matches.map(async (rel) => {
-      const abs = isAbsolute(rel) ? rel : resolve5(cwd, rel);
+      const abs = isAbsolute(rel) ? rel : resolve6(cwd, rel);
       try {
         const st = await stat2(abs);
         return { path: rel, mtime: st.mtimeMs };
@@ -1544,13 +1587,13 @@ var globTool = {
 
 // src/tools/grep/grep.ts
 import { spawn as spawn3 } from "child_process";
-import { resolve as resolve7 } from "path";
-import { z as z5 } from "zod";
+import { resolve as resolve8 } from "path";
+import { z as z6 } from "zod";
 
 // src/tools/grep/rgPath.ts
 import { spawn as spawn2 } from "child_process";
-import { chmodSync, existsSync as existsSync5 } from "fs";
-import { resolve as resolve6 } from "path";
+import { chmodSync, existsSync as existsSync6 } from "fs";
+import { resolve as resolve7 } from "path";
 var cached;
 async function resolveRgPath() {
   if (cached !== void 0) return cached;
@@ -1559,15 +1602,15 @@ async function resolveRgPath() {
 }
 async function detect() {
   const fromEnv = process.env.MINIMAL_AGENT_RIPGREP_PATH;
-  if (fromEnv && existsSync5(fromEnv)) return fromEnv;
+  if (fromEnv && existsSync6(fromEnv)) return fromEnv;
   const vendored = vendoredRgPath();
-  if (vendored && existsSync5(vendored)) {
+  if (vendored && existsSync6(vendored)) {
     ensureExecutable(vendored);
     return vendored;
   }
   if (await trySpawn("rg")) return "rg";
   for (const candidate of claudeCodeCandidates()) {
-    if (existsSync5(candidate)) {
+    if (existsSync6(candidate)) {
       ensureExecutable(candidate);
       return candidate;
     }
@@ -1577,7 +1620,7 @@ async function detect() {
 function vendoredRgPath() {
   try {
     const projectRoot = findPackageRoot(import.meta.url);
-    return resolve6(projectRoot, "vendor", "ripgrep", subdir(), exeName());
+    return resolve7(projectRoot, "vendor", "ripgrep", subdir(), exeName());
   } catch {
     return null;
   }
@@ -1636,42 +1679,42 @@ function claudeCodeCandidates() {
   const npmRoots = [];
   if (platform === "win32") {
     if (process.env.APPDATA) {
-      npmRoots.push(resolve6(process.env.APPDATA, "npm", "node_modules"));
+      npmRoots.push(resolve7(process.env.APPDATA, "npm", "node_modules"));
     }
     if (process.env.USERPROFILE) {
       npmRoots.push(
-        resolve6(process.env.USERPROFILE, "AppData", "Roaming", "npm", "node_modules")
+        resolve7(process.env.USERPROFILE, "AppData", "Roaming", "npm", "node_modules")
       );
     }
   } else {
     const home = process.env.HOME ?? "";
     if (home) {
-      npmRoots.push(resolve6(home, ".npm-global", "lib", "node_modules"));
-      npmRoots.push(resolve6(home, ".npm", "lib", "node_modules"));
-      npmRoots.push(resolve6(home, "node_modules"));
+      npmRoots.push(resolve7(home, ".npm-global", "lib", "node_modules"));
+      npmRoots.push(resolve7(home, ".npm", "lib", "node_modules"));
+      npmRoots.push(resolve7(home, "node_modules"));
     }
     npmRoots.push("/usr/local/lib/node_modules");
     npmRoots.push("/usr/lib/node_modules");
     npmRoots.push("/opt/homebrew/lib/node_modules");
   }
   return npmRoots.map(
-    (root) => resolve6(root, "@anthropic-ai", "claude-code", "vendor", "ripgrep", subdir2, exe)
+    (root) => resolve7(root, "@anthropic-ai", "claude-code", "vendor", "ripgrep", subdir2, exe)
   );
 }
 
 // src/tools/grep/grep.ts
-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 inputSchema5 = z6.object({
+  pattern: z6.string().min(1).describe("\u6B63\u5219\u8868\u8FBE\u5F0F\uFF08ripgrep \u517C\u5BB9\u8BED\u6CD5\uFF09"),
+  path: z6.string().optional().describe("\u641C\u7D22\u7684\u6839\u76EE\u5F55\u6216\u6587\u4EF6\uFF08\u9ED8\u8BA4\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\uFF09"),
+  glob: z6.string().optional().describe('\u6587\u4EF6\u540D glob \u8FC7\u6EE4\uFF0C\u5982 "*.ts"'),
+  type: z6.string().optional().describe('rg \u7684\u6587\u4EF6\u7C7B\u578B\u5FEB\u6377\u540D\uFF0C\u5982 "py"\u3001"rust"\u3001"js"'),
+  output_mode: z6.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": z6.boolean().optional().describe("\u5FFD\u7565\u5927\u5C0F\u5199"),
+  "-n": z6.boolean().optional().describe("\u663E\u793A\u884C\u53F7\uFF08\u4EC5 content \u6A21\u5F0F\uFF09"),
+  "-A": z6.number().int().min(0).optional().describe("\u5339\u914D\u540E\u5C55\u793A\u51E0\u884C\u4E0A\u4E0B\u6587"),
+  "-B": z6.number().int().min(0).optional().describe("\u5339\u914D\u524D\u5C55\u793A\u51E0\u884C\u4E0A\u4E0B\u6587"),
+  "-C": z6.number().int().min(0).optional().describe("\u5339\u914D\u524D\u540E\u5404\u5C55\u793A\u51E0\u884C\uFF08\u8986\u76D6 -A/-B\uFF09"),
+  head_limit: z6.number().int().positive().optional().describe("\u8F93\u51FA\u6700\u591A\u4FDD\u7559\u524D N \u884C\uFF08\u9632\u6B62\u7ED3\u679C\u8FC7\u5927\uFF09")
 });
 var parameters5 = toToolParameters(inputSchema5);
 var description5 = `A powerful search tool built on ripgrep.
@@ -1701,7 +1744,7 @@ async function call5(input, signal) {
   args.push("--max-columns-preview");
   args.push("--sort", "modified");
   args.push("-e", input.pattern);
-  args.push(input.path ? resolve7(input.path) : ".");
+  args.push(input.path ? resolve8(input.path) : ".");
   const rgPath = await resolveRgPath();
   if (!rgPath) {
     return {
@@ -1772,18 +1815,18 @@ var grepTool = {
 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}`)
+import { z as z7 } from "zod";
+var inputSchema6 = z7.object({
+  file_path: filePathField("\u8BFB\u53D6"),
+  offset: z7.number().int().positive().optional().describe("\u8D77\u59CB\u884C\u53F7\uFF081-indexed\uFF09\uFF1B\u4E0D\u586B\u5219\u4ECE\u6587\u4EF6\u5F00\u5934\u8BFB"),
+  limit: z7.number().int().positive().optional().describe(`\u6700\u591A\u8BFB\u591A\u5C11\u884C\uFF1B\u4E0D\u586B\u5219\u7528\u9ED8\u8BA4\u503C ${MAX_LINES_TO_READ}`)
 });
 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:
-- The file_path parameter must be an absolute path, not a relative path
+- The file_path parameter is preferably an absolute path. Relative paths are accepted and will be resolved against the agent's working directory (locked at startup via \`-d <dir>\` or process cwd).
 - By default, it reads up to ${MAX_LINES_TO_READ} lines starting from the beginning of the file
 - You can optionally specify a line offset and limit (especially handy for long files)
 - Results are returned using cat -n format, with line numbers starting at 1
@@ -1794,10 +1837,8 @@ 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 pathResult = resolveToolPath(input.file_path);
+  if (!pathResult.ok) return pathResult;
   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` };
@@ -1929,7 +1970,7 @@ var readTool = {
 };
 
 // src/tools/webfetch/webfetch.ts
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 
 // src/tools/webfetch/preapproved.ts
 var PREAPPROVED_HOSTS = /* @__PURE__ */ new Set([
@@ -2214,9 +2255,9 @@ function cleanCache() {
     }
   }
 }
-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 inputSchema7 = z8.object({
+  url: z8.string().describe("\u8981\u83B7\u53D6\u5185\u5BB9\u7684 URL"),
+  prompt: z8.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 parameters7 = toToolParameters(inputSchema7);
 var description7 = `- Fetches content from a specified URL and processes it using an AI model.
@@ -2436,7 +2477,7 @@ var webfetchTool = {
 };
 
 // src/tools/webbrowser/webbrowser.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 
 // src/tools/webbrowser/browser.ts
 import os from "os";
@@ -2472,12 +2513,12 @@ function screenshotPath(prefix = "browser") {
 }
 
 // src/tools/webbrowser/webbrowser.ts
-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 inputSchema8 = z9.object({
+  action: z9.enum(["navigate", "screenshot", "getContent", "click", "fill", "submit"]).describe("Browser action to perform"),
+  url: z9.string().url().optional().describe("URL to navigate to (required for navigate action)"),
+  selector: z9.string().optional().describe("CSS selector for click/fill/submit actions"),
+  value: z9.string().optional().describe("Value to fill in input fields"),
+  timeout: z9.number().int().positive().optional().describe("Timeout in milliseconds (default: 30000)")
 });
 var parameters8 = toToolParameters(inputSchema8);
 var description8 = `Control a headless web browser. Navigate to URLs, take screenshots, and interact with web pages.
@@ -2625,12 +2666,12 @@ var webbrowserTool = {
 };
 
 // src/tools/websearch/websearch.ts
-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")
+import { z as z10 } from "zod";
+var inputSchema9 = z10.object({
+  query: z10.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: z10.number().int().min(1).max(20).optional().describe("\u8FD4\u56DE\u7ED3\u679C\u6570\u91CF\uFF0C1-20\uFF0C\u9ED8\u8BA4 5"),
+  search_depth: z10.enum(["basic", "advanced"]).optional().describe("basic \u5FEB\u4F46\u6D45\uFF1Badvanced \u6162\u4F46\u6DF1\uFF08\u542B answer \u6458\u8981\uFF09\uFF0C\u9ED8\u8BA4 basic"),
+  topic: z10.enum(["general", "news"]).optional().describe("general=\u901A\u7528\u7F51\u9875\uFF1Bnews=\u504F\u65B0\u95FB\u6E90\uFF1B\u9ED8\u8BA4 general")
 });
 var parameters9 = toToolParameters(inputSchema9);
 var description9 = `- Searches the public web via the Tavily Search API and returns structured results.
@@ -2730,14 +2771,14 @@ var webSearchTool = {
 };
 
 // src/tools/write/write.ts
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync7 } 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";
+import { z as z11 } from "zod";
 var MAX_WRITE_SIZE_BYTES = 1024 * 1024 * 1024;
-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 inputSchema10 = z11.object({
+  file_path: filePathField("\u5199\u5165"),
+  content: z11.string().describe("\u6587\u4EF6\u5B8C\u6574\u5185\u5BB9\uFF08\u4F1A\u8986\u76D6\u65E2\u6709\u5185\u5BB9\uFF09")
 });
 var parameters10 = toToolParameters(inputSchema10);
 var description10 = `Writes a file to the local filesystem.
@@ -2749,7 +2790,7 @@ Usage:
 - 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.`;
 async function call10(input) {
-  const pathResult = validateAndResolvePath(input.file_path, getWorkingDir());
+  const pathResult = resolveToolPath(input.file_path);
   if (!pathResult.ok) return pathResult;
   const filePath = pathResult.resolvedPath;
   const freshness = assertFresh(filePath);
@@ -2766,7 +2807,7 @@ async function call10(input) {
   try {
     await mkdir5(dirname6(filePath), { recursive: true });
     let originalSize = 0;
-    const fileExisted = existsSync6(filePath);
+    const fileExisted = existsSync7(filePath);
     if (fileExisted) {
       try {
         const st = await stat4(filePath);
@@ -2795,8 +2836,10 @@ async function call10(input) {
     } else {
       await writeFile5(filePath, contentToWrite, "utf8");
     }
+    recordRead(filePath);
     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 ${contentToWrite.length} \u5B57\u7B26\uFF09` : `\uFF08${contentToWrite.length} \u5B57\u7B26\uFF09`;
+    const newSize = Buffer.byteLength(contentToWrite, "utf8");
+    const sizeInfo = fileExisted ? `\uFF08\u539F\u6587\u4EF6 ${originalSize} \u5B57\u8282 \u2192 \u65B0\u5185\u5BB9 ${newSize} \u5B57\u8282\uFF09` : `\uFF08${newSize} \u5B57\u8282\uFF09`;
     const bomInfo = bomEncoding === "utf8-bom" ? "\uFF0C\u5DF2\u4FDD\u7559 UTF-8 BOM" : "";
     return {
       ok: true,
@@ -2876,39 +2919,52 @@ import { Box as Box7, Text as Text7 } from "ink";
 import { useCallback, useMemo, useState } from "react";
 import { Box, Text, useApp, useInput } from "ink";
 import { jsx, jsxs } from "react/jsx-runtime";
-var DEFAULT_CONTEXT_WINDOW2 = 128e3;
+var FALLBACK_CONTEXT_WINDOW = 128e3;
 var PRESETS = [
   {
     name: "minimax",
     label: "MiniMax (\u6D77\u87BA)",
     baseURL: "https://api.minimax.chat/v1",
-    models: ["MiniMax-M2.7", "MiniMax-M1", "abab6.5s-chat"]
+    models: ["MiniMax-M2.7", "MiniMax-M1", "abab6.5s-chat"],
+    contextWindow: 204800
   },
   {
     name: "deepseek",
     label: "DeepSeek",
     baseURL: "https://api.deepseek.com/v1",
-    models: ["deepseek-chat", "deepseek-reasoner"]
+    models: ["deepseek-chat", "deepseek-reasoner"],
+    contextWindow: 128e3
   },
   {
     name: "openai",
     label: "OpenAI",
     baseURL: "https://api.openai.com/v1",
-    models: ["gpt-4o", "gpt-4o-mini"]
+    models: ["gpt-4o", "gpt-4o-mini"],
+    contextWindow: 128e3
   },
   {
     name: "moonshot",
     label: "Moonshot (Kimi)",
     baseURL: "https://api.moonshot.cn/v1",
-    models: ["moonshot-v1-8k", "moonshot-v1-32k", "moonshot-v1-128k"]
+    models: ["moonshot-v1-8k", "moonshot-v1-32k", "moonshot-v1-128k"],
+    contextWindow: 128e3,
+    modelContextWindows: {
+      "moonshot-v1-8k": 8e3,
+      "moonshot-v1-32k": 32e3,
+      "moonshot-v1-128k": 128e3
+    }
   },
   {
     name: "custom",
     label: "\u81EA\u5B9A\u4E49\uFF08\u624B\u52A8\u586B baseURL\uFF09",
     baseURL: "",
-    models: []
+    models: [],
+    contextWindow: FALLBACK_CONTEXT_WINDOW
   }
 ];
+function resolveContextWindow(preset, model) {
+  return preset.modelContextWindows?.[model] ?? preset.contextWindow ?? FALLBACK_CONTEXT_WINDOW;
+}
 function ConfigWizard({ onSuccess }) {
   const { exit } = useApp();
   const [step, setStep] = useState("preset");
@@ -2937,51 +2993,68 @@ function ConfigWizard({ onSuccess }) {
     },
     [baseURL, model, preset]
   );
-  const handleTest = useCallback(async () => {
-    setStep("testing");
-    setErrorMsg(null);
-    try {
-      const url = `${baseURL.replace(/\/$/, "")}/chat/completions`;
-      const resp = await fetch(url, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${apiKey}`
-        },
-        body: JSON.stringify({
-          model,
-          messages: [{ role: "user", content: "ping" }],
-          max_tokens: 5,
-          stream: false
-        })
-      });
-      if (!resp.ok) {
-        const body = await resp.text().catch(() => "");
-        throw new Error(`HTTP ${resp.status}: ${body.slice(0, 200) || resp.statusText}`);
-      }
-      const data = await resp.json();
-      if (!Array.isArray(data.choices)) {
-        throw new Error("\u54CD\u5E94\u4E2D\u6CA1\u6709 choices \u5B57\u6BB5\uFF0C\u53EF\u80FD\u4E0D\u662F OpenAI \u517C\u5BB9\u534F\u8BAE");
+  const handleTest = useCallback(
+    async (finalModel) => {
+      setStep("testing");
+      setErrorMsg(null);
+      try {
+        const url = `${baseURL.replace(/\/$/, "")}/chat/completions`;
+        const resp = await fetch(url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${apiKey}`
+          },
+          body: JSON.stringify({
+            model: finalModel,
+            messages: [{ role: "user", content: "ping" }],
+            max_tokens: 5,
+            stream: false
+          })
+        });
+        if (!resp.ok) {
+          const body = await resp.text().catch(() => "");
+          throw new Error(
+            `HTTP ${resp.status}: ${body.slice(0, 200) || resp.statusText}`
+          );
+        }
+        const data = await resp.json();
+        if (!Array.isArray(data.choices)) {
+          throw new Error("\u54CD\u5E94\u4E2D\u6CA1\u6709 choices \u5B57\u6BB5\uFF0C\u53EF\u80FD\u4E0D\u662F OpenAI \u517C\u5BB9\u534F\u8BAE");
+        }
+        setDraft("");
+        setStep("tavily");
+      } catch (e) {
+        setErrorMsg(e.message || "\u8FDE\u63A5\u5931\u8D25");
+        setStep("error");
       }
+    },
+    [apiKey, baseURL]
+  );
+  const finalize = useCallback(
+    async (finalModel, tavilyApiKey) => {
+      const contextWindow = resolveContextWindow(preset, finalModel);
       await saveConfig({
         baseURL,
         apiKey,
-        model,
+        model: finalModel,
         provider: preset.name,
-        contextWindow: DEFAULT_CONTEXT_WINDOW2
+        contextWindow,
+        tavilyApiKey
       });
+      if (tavilyApiKey) {
+        process.env.TAVILY_API_KEY = tavilyApiKey;
+      }
       onSuccess({
         name: preset.name,
         baseURL,
         apiKey,
-        model,
-        contextWindow: DEFAULT_CONTEXT_WINDOW2
+        model: finalModel,
+        contextWindow
       });
-    } catch (e) {
-      setErrorMsg(e.message || "\u8FDE\u63A5\u5931\u8D25");
-      setStep("error");
-    }
-  }, [apiKey, baseURL, model, onSuccess, preset.name]);
+    },
+    [apiKey, baseURL, onSuccess, preset]
+  );
   useInput((input, key) => {
     if (key.escape || key.ctrl && input === "c") {
       exit();
@@ -3036,9 +3109,10 @@ function ConfigWizard({ onSuccess }) {
         }
       }
       if (key.return) {
-        if (draft.trim().length === 0) return;
-        setModel(draft.trim());
-        void handleTest();
+        const finalModel = draft.trim();
+        if (finalModel.length === 0) return;
+        setModel(finalModel);
+        void handleTest(finalModel);
       } else if (key.backspace || key.delete) {
         setDraft((s) => s.slice(0, -1));
       } else if (input && !key.meta && !key.ctrl && !key.upArrow && !key.downArrow) {
@@ -3046,6 +3120,17 @@ function ConfigWizard({ onSuccess }) {
       }
       return;
     }
+    if (step === "tavily") {
+      if (key.return) {
+        const tavilyApiKey = draft.trim().length > 0 ? draft.trim() : void 0;
+        void finalize(model, tavilyApiKey);
+      } else if (key.backspace || key.delete) {
+        setDraft((s) => s.slice(0, -1));
+      } else if (input && !key.meta && !key.ctrl) {
+        setDraft((s) => s + input);
+      }
+      return;
+    }
     if (step === "error") {
       if (key.return) {
         enterStep("preset");
@@ -3058,7 +3143,7 @@ function ConfigWizard({ onSuccess }) {
     /* @__PURE__ */ jsx(Box, { marginBottom: 1, children: /* @__PURE__ */ jsx(Text, { color: "cyan", bold: true, children: "minimal-agent \xB7 \u9996\u6B21\u914D\u7F6E\u5411\u5BFC" }) }),
     /* @__PURE__ */ jsx(Box, { marginBottom: 1, children: /* @__PURE__ */ jsx(Text, { color: "gray", children: "\u6309 ESC \u6216 Ctrl+C \u9000\u51FA\uFF08\u4E0D\u5199\u914D\u7F6E\uFF0C\u4E0B\u6B21\u542F\u52A8\u7EE7\u7EED\u5411\u5BFC\uFF09" }) }),
     step === "preset" && /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsx(Text, { children: "Step 1/4 \xB7 \u9009\u62E9 provider \u9884\u8BBE\uFF08\u2191\u2193 \u79FB\u52A8\uFF0CEnter \u786E\u8BA4\uFF09" }),
+      /* @__PURE__ */ jsx(Text, { children: "Step 1/5 \xB7 \u9009\u62E9 provider \u9884\u8BBE\uFF08\u2191\u2193 \u79FB\u52A8\uFF0CEnter \u786E\u8BA4\uFF09" }),
       /* @__PURE__ */ jsx(Box, { flexDirection: "column", marginTop: 1, children: PRESETS.map((p, i) => /* @__PURE__ */ jsxs(Text, { color: i === presetIndex ? "cyan" : void 0, children: [
         i === presetIndex ? "> " : "  ",
         p.label,
@@ -3066,12 +3151,12 @@ function ConfigWizard({ onSuccess }) {
       ] }, p.name)) })
     ] }),
     step === "baseURL" && /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsx(Text, { children: "Step 2/4 \xB7 \u8F93\u5165 API base URL\uFF08\u9ED8\u8BA4\u4E3A\u9884\u8BBE\u503C\uFF0C\u53EF\u6539\uFF09" }),
+      /* @__PURE__ */ jsx(Text, { children: "Step 2/5 \xB7 \u8F93\u5165 API base URL\uFF08\u9ED8\u8BA4\u4E3A\u9884\u8BBE\u503C\uFF0C\u53EF\u6539\uFF09" }),
       /* @__PURE__ */ jsx(Box, { marginTop: 1, borderStyle: "round", borderColor: "cyan", paddingX: 1, children: /* @__PURE__ */ jsx(Text, { children: draft || " " }) }),
       /* @__PURE__ */ jsx(Text, { color: "gray", children: "Enter \u786E\u8BA4 \xB7 Backspace \u5220\u9664" })
     ] }),
     step === "apiKey" && /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsx(Text, { children: "Step 3/4 \xB7 \u8F93\u5165 API key\uFF08\u8F93\u5165\u5185\u5BB9\u4E0D\u4F1A\u663E\u793A\uFF09" }),
+      /* @__PURE__ */ jsx(Text, { children: "Step 3/5 \xB7 \u8F93\u5165 API key\uFF08\u8F93\u5165\u5185\u5BB9\u4E0D\u4F1A\u663E\u793A\uFF09" }),
       /* @__PURE__ */ jsx(Box, { marginTop: 1, borderStyle: "round", borderColor: "cyan", paddingX: 1, children: /* @__PURE__ */ jsx(Text, { children: maskedApiKey || " " }) }),
       /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
         "Enter \u786E\u8BA4 \xB7 Backspace \u5220\u9664\uFF08\u5DF2\u8F93\u5165 ",
@@ -3081,7 +3166,7 @@ function ConfigWizard({ onSuccess }) {
     ] }),
     step === "model" && /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
       /* @__PURE__ */ jsxs(Text, { children: [
-        "Step 4/4 \xB7 \u8F93\u5165\u6216\u9009\u62E9 model",
+        "Step 4/5 \xB7 \u8F93\u5165\u6216\u9009\u62E9 model",
         preset.models.length > 0 ? "\uFF08\u2191\u2193 \u5207\u6362\u9884\u8BBE\uFF0C\u6216\u76F4\u63A5\u7F16\u8F91\uFF09" : ""
       ] }),
       preset.models.length > 0 && /* @__PURE__ */ jsx(Box, { flexDirection: "column", marginTop: 1, children: preset.models.map((m, i) => /* @__PURE__ */ jsxs(Text, { color: i === modelIndex ? "cyan" : "gray", children: [
@@ -3102,6 +3187,17 @@ function ConfigWizard({ onSuccess }) {
         model
       ] })
     ] }),
+    step === "tavily" && /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx(Text, { color: "green", children: "\u2713 LLM \u8FDE\u63A5\u6D4B\u8BD5\u901A\u8FC7" }),
+      /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { children: "Step 5/5 \xB7 \u53EF\u9009 - Tavily API key\uFF08\u7528\u4E8E WebSearch \u5DE5\u5177\uFF09" }) }),
+      /* @__PURE__ */ jsx(Box, { marginTop: 1, borderStyle: "round", borderColor: "cyan", paddingX: 1, children: /* @__PURE__ */ jsx(Text, { children: maskedApiKey || " " }) }),
+      /* @__PURE__ */ jsx(Text, { color: "gray", children: "\u76F4\u63A5 Enter \u8DF3\u8FC7\uFF08\u4E4B\u540E\u53EF\u5728\u5BF9\u8BDD\u91CC\u8F93\u5165 /config \u6DFB\u52A0\uFF0C\u6216\u8BBE env TAVILY_API_KEY\uFF09" }),
+      /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+        "\u514D\u8D39 key \u7533\u8BF7\uFF1Ahttps://tavily.com/  \xB7  \u5DF2\u8F93\u5165 ",
+        draft.length,
+        " \u5B57\u7B26"
+      ] })
+    ] }),
     step === "error" && /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
       /* @__PURE__ */ jsx(Text, { color: "red", children: "\u2717 \u8FDE\u63A5\u6D4B\u8BD5\u5931\u8D25" }),
       /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { color: "red", children: errorMsg ?? "\u672A\u77E5\u9519\u8BEF" }) }),
@@ -4020,22 +4116,26 @@ function useTokenUsage(messages, provider) {
 
 // src/ui/StatusLine.tsx
 import { Fragment, jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
-function StatusLine({ provider, history, pluginLoop }) {
+function StatusLine({
+  provider,
+  history,
+  pluginProgress
+}) {
   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: [
+    pluginProgress && /* @__PURE__ */ jsxs4(Fragment, { children: [
       /* @__PURE__ */ jsxs4(Text4, { color: "magenta", children: [
         "\u{1F504} ",
-        pluginLoop.pluginName,
+        pluginProgress.pluginId,
         " "
       ] }),
       /* @__PURE__ */ jsxs4(Text4, { color: "magenta", children: [
-        pluginLoop.current,
+        pluginProgress.current,
         "/",
-        pluginLoop.max
+        pluginProgress.max
       ] }),
       /* @__PURE__ */ jsx4(Text4, { color: "gray", children: " \xB7 " })
     ] }),
@@ -4231,8 +4331,7 @@ 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");
+import { join as join7 } from "path";
 var pluginCache = /* @__PURE__ */ new Map();
 var discoveryDone = false;
 function stripQuotes2(s) {
@@ -4257,7 +4356,7 @@ function parseMarkdownFrontmatter(content) {
 }
 async function loadPlugin(pluginDirPath) {
   const dirName = pluginDirPath.split("/").pop() ?? pluginDirPath;
-  const manifestPath = join6(pluginDirPath, ".claude-plugin", "plugin.json");
+  const manifestPath = join7(pluginDirPath, ".claude-plugin", "plugin.json");
   let manifestName = dirName;
   let manifestVersion;
   let manifestDesc;
@@ -4269,13 +4368,13 @@ async function loadPlugin(pluginDirPath) {
     manifestDesc = parsed.description;
   } catch {
   }
-  const commandsDir = join6(pluginDirPath, "commands");
+  const commandsDir = join7(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);
+      const cmdPath = join7(commandsDir, entry.name);
       try {
         const content = await readFile9(cmdPath, "utf8");
         const fm = parseMarkdownFrontmatter(content);
@@ -4294,7 +4393,7 @@ async function loadPlugin(pluginDirPath) {
     }
   } catch {
   }
-  const hooksJsonPath = join6(pluginDirPath, "hooks", "hooks.json");
+  const hooksJsonPath = join7(pluginDirPath, "hooks", "hooks.json");
   let hasStopHook = false;
   try {
     const hooksRaw = await readFile9(hooksJsonPath, "utf8");
@@ -4321,17 +4420,20 @@ async function discoverPlugins() {
   }
   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) {
+  const searchPaths = getResourceSearchPaths("plugins", import.meta.url);
+  for (const root of searchPaths) {
+    try {
+      const entries = await readdir3(root, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        if (entry.name.startsWith(".")) continue;
+        const plugin = await loadPlugin(join7(root, entry.name));
+        if (!plugin) continue;
+        if (pluginCache.has(plugin.name)) continue;
         pluginCache.set(plugin.name, plugin);
       }
+    } catch {
     }
-  } catch {
   }
   return Array.from(pluginCache.values());
 }
@@ -4350,24 +4452,8 @@ function resolveCommand(input) {
   }
   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);
+  const { cmd, arguments: args } = resolved;
   let input = cmd.promptBody;
   input = input.replaceAll("${CLAUDE_PLUGIN_ROOT}", cmd.pluginRoot);
   input = input.replaceAll("$ARGUMENTS", args);
@@ -4379,537 +4465,47 @@ function buildCommandInput(resolved) {
   }
   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";
+// src/plugins/pluginLoader.ts
+import { existsSync as existsSync8 } 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 [];
-    }
+import { pathToFileURL } from "url";
+var loaderCache = /* @__PURE__ */ new Map();
+function isPluginApi(value) {
+  if (!value || typeof value !== "object") return false;
+  const { runCommand } = value;
+  if (runCommand !== void 0 && typeof runCommand !== "function") return false;
+  return true;
+}
+async function loadPluginApi(pluginRoot) {
+  if (loaderCache.has(pluginRoot)) {
+    return loaderCache.get(pluginRoot) ?? null;
+  }
+  const pluginTsPath = join8(pluginRoot, "plugin.ts");
+  if (!existsSync8(pluginTsPath)) {
+    loaderCache.set(pluginRoot, null);
+    return null;
   }
-  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`
+  try {
+    const mod = await import(pathToFileURL(pluginTsPath).href);
+    const candidate = mod.default;
+    if (!isPluginApi(candidate)) {
+      console.warn(
+        `[minimal-agent] plugin.ts default export is not a valid PluginApi: ${pluginRoot}`
       );
+      loaderCache.set(pluginRoot, null);
+      return null;
     }
-    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;
+    loaderCache.set(pluginRoot, candidate);
+    return candidate;
+  } catch (err) {
+    console.warn(
+      `[minimal-agent] failed to load plugin.ts at ${pluginRoot}: ${err instanceof Error ? err.message : String(err)}`
+    );
+    loaderCache.set(pluginRoot, null);
+    return null;
   }
-};
+}
 
 // src/context/microCompactLite.ts
 import { createHash as createHash2 } from "crypto";
@@ -5147,28 +4743,23 @@ function previewArgs(rawJson) {
 }
 
 // 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);
-    }
+  if (!isSlashCommand) {
+    yield* runQuery(userInput, {
+      provider,
+      history,
+      signal,
+      maxTurns: options.maxTurns,
+      sessionState: options.sessionState
+    });
+    return;
   }
-  const activeHookPlugins = matchedCmd ? getActiveStopHookPlugins() : [];
-  const enterLoop = matchedCmd !== null && activeHookPlugins.length > 0;
-  if (!enterLoop) {
-    yield* runQuery(currentInput, {
+  await discoverPlugins();
+  const matched = resolveCommand(userInput);
+  if (!matched) {
+    yield* runQuery(userInput, {
       provider,
       history,
       signal,
@@ -5177,146 +4768,25 @@ async function* runWithPlugins(userInput, options) {
     });
     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();
+  const api = await loadPluginApi(matched.cmd.pluginRoot);
+  if (api?.runCommand) {
+    yield* api.runCommand(matched.cmd.name, matched.arguments, {
+      provider,
+      history,
+      signal,
+      sessionState: options.sessionState,
+      maxTurns: options.maxTurns
+    });
+    return;
   }
+  const promptInput = buildCommandInput(matched);
+  yield* runQuery(promptInput, {
+    provider,
+    history,
+    signal,
+    maxTurns: options.maxTurns,
+    sessionState: options.sessionState
+  });
 }
 
 // src/ui/hooks/useChat.ts
@@ -5330,7 +4800,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 [pluginProgress, setPluginProgress] = useState5(null);
   const abortRef = useRef3(null);
   useEffect(() => {
     return () => {
@@ -5346,7 +4816,7 @@ function useChat(args) {
       setError(null);
       setInterrupted(false);
       setStreamingText("");
-      setPluginLoop(null);
+      setPluginProgress(null);
       const ac = new AbortController();
       abortRef.current = ac;
       try {
@@ -5361,7 +4831,7 @@ function useChat(args) {
             setCompacting,
             setError,
             setInterrupted,
-            setPluginLoop,
+            setPluginProgress,
             bump
           });
         }
@@ -5372,7 +4842,7 @@ function useChat(args) {
         setStreamingText("");
         setToolStatus(null);
         setCompacting(false);
-        setPluginLoop(null);
+        setPluginProgress(null);
         abortRef.current = null;
         args.onPersist?.(historyRef.current);
       }
@@ -5429,7 +4899,7 @@ function useChat(args) {
     error,
     interrupted,
     compacting,
-    pluginLoop,
+    pluginProgress,
     submit,
     abort,
     clearHistory,
@@ -5437,9 +4907,10 @@ function useChat(args) {
   };
 }
 function handleEvent(ev, setters) {
-  switch (ev.type) {
+  const e = ev;
+  switch (e.type) {
     case "text":
-      setters.setStreamingText((prev) => prev + ev.delta);
+      setters.setStreamingText((prev) => prev + e.delta);
       break;
     case "assistant_message":
       setters.setStreamingText(() => "");
@@ -5447,8 +4918,8 @@ function handleEvent(ev, setters) {
       break;
     case "tool_start":
       setters.setToolStatus({
-        toolName: ev.toolName,
-        argsPreview: ev.argsPreview,
+        toolName: e.toolName,
+        argsPreview: e.argsPreview,
         status: "running"
       });
       setters.bump();
@@ -5474,16 +4945,15 @@ function handleEvent(ev, setters) {
       setters.bump();
       break;
     case "error":
-      setters.setError(ev.error);
+      setters.setError(e.error);
       setters.bump();
       break;
-    case "plugin_start":
-      break;
-    case "plugin_iteration":
-      setters.setPluginLoop({
-        pluginName: ev.pluginName,
-        current: ev.current,
-        max: ev.max ?? 0
+    case "plugin_progress":
+      setters.setPluginProgress({
+        pluginId: e.pluginId,
+        current: e.current,
+        max: e.max ?? 0,
+        message: e.message
       });
       setters.bump();
       break;
@@ -5535,7 +5005,14 @@ function App({ provider, initialHistory }) {
         onCompact: chat2.compactNow
       }
     ),
-    /* @__PURE__ */ jsx6(StatusLine, { provider, history: chat2.history, pluginLoop: chat2.pluginLoop })
+    /* @__PURE__ */ jsx6(
+      StatusLine,
+      {
+        provider,
+        history: chat2.history,
+        pluginProgress: chat2.pluginProgress
+      }
+    )
   ] });
 }
 
@@ -5670,24 +5147,28 @@ async function runPrintMode(provider, args, initialHistory, options) {
   await saveContext(history);
 }
 function handleEvent2(event, output, verbose) {
-  switch (event.type) {
+  if (event.type === "workflow_start" || event.type === "workflow_step_start" || event.type === "workflow_step_end" || event.type === "workflow_step_skipped" || event.type === "workflow_done" || event.type === "plugin_progress") {
+    return {};
+  }
+  const e = event;
+  switch (e.type) {
     case "text":
-      if (verbose) process.stdout.write(event.delta);
-      output.buffer += event.delta;
+      if (verbose) process.stdout.write(e.delta);
+      output.buffer += e.delta;
       return {};
     case "assistant_message":
       return {};
     case "tool_start":
       if (verbose) {
         process.stderr.write(`
-\u{1F527} \u5DE5\u5177: ${event.toolName}(${event.argsPreview})
+\u{1F527} \u5DE5\u5177: ${e.toolName}(${e.argsPreview})
 `);
       }
       return {};
     case "tool_end":
       if (verbose) {
         process.stderr.write(
-          `${event.ok ? "\u2705" : "\u274C"} ${event.toolName}: ${truncateForDisplay(event.content)}
+          `${e.ok ? "\u2705" : "\u274C"} ${e.toolName}: ${truncateForDisplay(e.content)}
 `
         );
       }
@@ -5698,7 +5179,7 @@ function handleEvent2(event, output, verbose) {
     case "compact_done":
       if (verbose) {
         process.stderr.write(
-          `\u{1F4DD} \u538B\u7F29\u5B8C\u6210: ${event.before} \u2192 ${event.after} tokens
+          `\u{1F4DD} \u538B\u7F29\u5B8C\u6210: ${e.before} \u2192 ${e.after} tokens
 `
         );
       }
@@ -5708,20 +5189,20 @@ function handleEvent2(event, output, verbose) {
       return {};
     case "error":
       console.error(`
-\u9519\u8BEF: ${event.error}`);
+\u9519\u8BEF: ${e.error}`);
       return { exitCode: 1 };
     default:
       return {};
   }
 }
 function readFromStdin() {
-  return new Promise((resolve9) => {
+  return new Promise((resolve10) => {
     let data = "";
     let settled = false;
     const timer = setTimeout(() => {
       if (!settled) {
         settled = true;
-        resolve9("");
+        resolve10("");
       }
     }, STDIN_TIMEOUT_MS);
     process.stdin.setEncoding("utf8");
@@ -5732,7 +5213,7 @@ function readFromStdin() {
       if (!settled) {
         clearTimeout(timer);
         settled = true;
-        resolve9(data.trim());
+        resolve10(data.trim());
       }
     }
     process.stdin.on("data", onData);
@@ -5748,7 +5229,7 @@ async function main() {
   const args = process.argv.slice(2);
   const dirArg = extractCwdArg(args);
   if (dirArg) {
-    const abs = resolve8(dirArg);
+    const abs = resolve9(dirArg);
     if (!existsSync9(abs)) {
       mkdirSync(abs, { recursive: true });
     }
@@ -5756,6 +5237,7 @@ async function main() {
   }
   initWorkingDir();
   await migrateLegacyContext(getWorkingDir());
+  await applyToolKeysToEnv();
   if (args.includes("-h") || args.includes("--help")) {
     printHelp();
     return;