minimal-agent 0.1.4 → 0.1.6

package/dist/main.js

@@ -2,7 +2,19 @@
 
 // src/main.tsx
 import { render } from "ink";
+import { existsSync as existsSync7, 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);
@@ -693,10 +693,171 @@ var bashTool = {
 };
 
 // src/tools/edit/edit.ts
-import { readFile as readFile5, writeFile as writeFile3, mkdir as mkdir4 } from "fs/promises";
+import { readFile as readFile6, 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 { dirname as dirname5 } from "path";
 import { z as z2 } from "zod";
+
+// src/tools/shared/fileUtils.ts
+import { readFile as readFile5 } from "fs/promises";
+import { homedir as homedir4 } from "os";
+import { resolve as resolve4, normalize } 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 normalized = normalize(filePath);
+  if (BLOCKED_DEVICE_PATHS.has(normalized)) return true;
+  if (normalized.startsWith("/proc/") && (normalized.endsWith("/fd/0") || normalized.endsWith("/fd/1") || normalized.endsWith("/fd/2"))) {
+    return true;
+  }
+  const baseName = normalized.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" };
+  }
+  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 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/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,21 +879,12 @@ 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;
   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" };
   }
@@ -757,10 +909,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 +927,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 +952,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}` };
   }
@@ -1190,8 +1351,9 @@ var grepTool = {
 };
 
 // src/tools/read/read.ts
-import { readFile as readFile6, stat as stat3 } from "fs/promises";
-import { resolve as resolve8 } from "path";
+import { createReadStream } from "fs";
+import { readFile as readFile7, stat as stat3 } from "fs/promises";
+import { createInterface } from "readline";
 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"),
@@ -1209,10 +1371,18 @@ 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.`;
+var STREAM_THRESHOLD = 1024 * 1024;
 async function call5(input) {
-  const filePath = resolve8(input.file_path);
   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` };
+  }
   let st;
   try {
     st = await stat3(filePath);
@@ -1231,33 +1401,37 @@ 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) {
+      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) {
     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 += `
@@ -1266,6 +1440,55 @@ async function call5(input) {
   }
   return { ok: true, content };
 }
+async function readSmallFile(filePath, offset, limit) {
+  const raw = await readFile7(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,
@@ -2081,7 +2304,7 @@ var webSearchTool = {
 // 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 { dirname as dirname6 } from "path";
 import { z as z9 } from "zod";
 var MAX_WRITE_SIZE_BYTES = 1024 * 1024 * 1024;
 var inputSchema9 = z9.object({
@@ -2096,19 +2319,10 @@ Usage:
 - 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" };
-  }
-  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 pathResult = validateAndResolvePath(input.file_path, getWorkingDir());
+  if (!pathResult.ok) return pathResult;
+  const filePath = pathResult.resolvedPath;
   const contentSize = Buffer.byteLength(input.content, "utf8");
   if (contentSize > MAX_WRITE_SIZE_BYTES) {
     return {
@@ -2127,9 +2341,14 @@ async function call9(input) {
       } catch {
       }
     }
-    await writeFile4(filePath, input.content, "utf8");
+    let contentToWrite = input.content;
+    if (fileExisted) {
+      const lineEnding = await detectFileLineEndings(filePath);
+      contentToWrite = applyLineEnding(input.content, lineEnding);
+    }
+    await writeFile4(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`;
     return {
       ok: true,
       content: `${action} ${filePath}${sizeInfo}`
@@ -2962,7 +3181,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 +3569,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 +3614,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);
@@ -3480,9 +3712,12 @@ function findHeadCutpoint(messages, proposedCut) {
 }
 
 // src/context/reactiveCompact.ts
-var attemptedThisSession = false;
-function resetReactiveCompactState() {
-  attemptedThisSession = false;
+function createReactiveCompactState() {
+  return { attempted: false };
+}
+var defaultState = createReactiveCompactState();
+function resetReactiveCompactState(state = defaultState) {
+  state.attempted = false;
 }
 function isPromptTooLongError(error) {
   const msg = errorMessage(error).toLowerCase();
@@ -3499,18 +3734,18 @@ function errorMessage(error) {
   }
   return String(error ?? "");
 }
-async function reactiveCompactIfApplicable(messages, provider, error) {
+async function reactiveCompactIfApplicable(messages, provider, error, state = defaultState) {
   if (!isPromptTooLongError(error)) {
     return { recovered: false, messages, reason: "not a prompt-too-long error" };
   }
-  if (attemptedThisSession) {
+  if (state.attempted) {
     return {
       recovered: false,
       messages,
       reason: "already attempted this session \u2014 use /new or /compact manually"
     };
   }
-  attemptedThisSession = true;
+  state.attempted = true;
   try {
     const r = await forceCompact(messages, provider);
     return {
@@ -3544,6 +3779,688 @@ async function reactiveCompactIfApplicable(messages, provider, error) {
   };
 }
 
+// src/plugins/commandRouter.ts
+import { readFile as readFile8, 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 readFile8(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 readFile8(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 readFile8(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 readFile9 } 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 readFile9(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 existsSync5, 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 = existsSync5(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 writeFile5, unlink as unlink2, rmdir as rmdir2 } from "fs/promises";
+import { existsSync as existsSync6, 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 (!existsSync6(path2)) {
+        await writeFile5(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 writeFile5(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 writeFile5(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;
@@ -3552,10 +4469,12 @@ var HEAD_KEEP_CHARS = 2e3;
 var TAIL_KEEP_CHARS = 1e3;
 var MAX_KEEP_ROUNDS = 10;
 var SHORT_CONTENT_THRESHOLD = 200;
-var currentTurn = 0;
-var contentCache = /* @__PURE__ */ new Map();
-function incrementTurn() {
-  currentTurn++;
+function createMicroCompactState() {
+  return { turn: 0, cache: /* @__PURE__ */ new Map() };
+}
+var defaultState2 = createMicroCompactState();
+function incrementTurn(state = defaultState2) {
+  state.turn++;
 }
 var COMPRESSIBLE_TOOLS = /* @__PURE__ */ new Set([
   "Grep",
@@ -3563,7 +4482,7 @@ var COMPRESSIBLE_TOOLS = /* @__PURE__ */ new Set([
   "WebFetch",
   "Glob"
 ]);
-function microCompact(toolName, content) {
+function microCompact(toolName, content, state = defaultState2) {
   if (!content) return content;
   if (content.startsWith("Error:") || content.startsWith("\u9519\u8BEF")) {
     return content;
@@ -3572,7 +4491,7 @@ function microCompact(toolName, content) {
     return content;
   }
   const hash = sha1(content);
-  const existing = contentCache.get(hash);
+  const existing = state.cache.get(hash);
   if (existing) {
     existing.count++;
     if (existing.count > MAX_REPEAT_COUNT) {
@@ -3580,17 +4499,17 @@ function microCompact(toolName, content) {
     }
     return content;
   }
-  contentCache.set(hash, { count: 1, firstToolName: toolName, firstSeenTurn: currentTurn });
+  state.cache.set(hash, { count: 1, firstToolName: toolName, firstSeenTurn: state.turn });
   if (content.length > MAX_RESULT_SIZE && COMPRESSIBLE_TOOLS.has(toolName)) {
     return truncateContent(content);
   }
   return content;
 }
-function expireOldEntries() {
+function expireOldEntries(state = defaultState2) {
   let expired = 0;
-  for (const [hash, entry] of contentCache) {
-    if (currentTurn - entry.firstSeenTurn > MAX_KEEP_ROUNDS) {
-      contentCache.delete(hash);
+  for (const [hash, entry] of state.cache) {
+    if (state.turn - entry.firstSeenTurn > MAX_KEEP_ROUNDS) {
+      state.cache.delete(hash);
       expired++;
     }
   }
@@ -3610,15 +4529,15 @@ function truncateContent(content) {
 
 // src/loop.ts
 async function* runQuery(userInput, options) {
-  const { provider, history, signal } = options;
+  const { provider, history, signal, sessionState } = options;
   const maxTurns = options.maxTurns ?? 50;
   history.push({ role: "user", content: userInput });
   let reactiveAttempted = false;
   let turn = 0;
   while (turn < maxTurns) {
     turn++;
-    incrementTurn();
-    expireOldEntries();
+    incrementTurn(sessionState?.microCompact);
+    expireOldEntries(sessionState?.microCompact);
     if (signal?.aborted) {
       history.push({
         role: "user",
@@ -3680,7 +4599,12 @@ async function* runQuery(userInput, options) {
       if (isPromptTooLongError(e) && !reactiveAttempted) {
         reactiveAttempted = true;
         yield { type: "compact_start" };
-        const result = await reactiveCompactIfApplicable(history, provider, e);
+        const result = await reactiveCompactIfApplicable(
+          history,
+          provider,
+          e,
+          sessionState?.reactive
+        );
         if (result.recovered) {
           history.length = 0;
           history.push(...result.messages);
@@ -3728,7 +4652,11 @@ async function* runQuery(userInput, options) {
       };
       const result = await executeTool(tc.function.name, tc.function.arguments, signal);
       const rawContent = result.ok ? result.content : `Error: ${result.error}`;
-      const content = microCompact(tc.function.name, rawContent);
+      const content = microCompact(
+        tc.function.name,
+        rawContent,
+        sessionState?.microCompact
+      );
       history.push({
         role: "tool",
         content,
@@ -3768,6 +4696,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());
@@ -3779,6 +4880,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 () => {
@@ -3794,10 +4896,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
@@ -3808,6 +4911,7 @@ function useChat(args) {
             setCompacting,
             setError,
             setInterrupted,
+            setPluginLoop,
             bump
           });
         }
@@ -3818,6 +4922,7 @@ function useChat(args) {
         setStreamingText("");
         setToolStatus(null);
         setCompacting(false);
+        setPluginLoop(null);
         abortRef.current = null;
         args.onPersist?.(historyRef.current);
       }
@@ -3873,6 +4978,7 @@ function useChat(args) {
     error,
     interrupted,
     compacting,
+    pluginLoop,
     submit,
     abort,
     clearHistory,
@@ -3920,6 +5026,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;
   }
 }
 
@@ -3968,7 +5084,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 })
   ] });
 }
 
@@ -4027,8 +5143,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));
@@ -4059,7 +5195,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
@@ -4128,13 +5264,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");
@@ -4145,7 +5281,7 @@ function readFromStdin() {
       if (!settled) {
         clearTimeout(timer);
         settled = true;
-        resolve10(data.trim());
+        resolve9(data.trim());
       }
     }
     process.stdin.on("data", onData);
@@ -4158,9 +5294,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 (!existsSync7(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;
@@ -4171,15 +5315,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
 
 `
       );
@@ -4213,6 +5357,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:
@@ -4224,6 +5370,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) => {