minimal-agent 0.1.9 → 0.2.0

package/dist/main.js

@@ -2,7 +2,7 @@
 
 // src/main.tsx
 import { render } from "ink";
-import { existsSync as existsSync10, mkdirSync } from "fs";
+import { existsSync as existsSync9, mkdirSync } from "fs";
 import { createRequire } from "module";
 import { resolve as resolve9 } from "path";
 
@@ -418,16 +418,12 @@ ${toolList}
 ${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\u66B4\u9732\u5F62\u5982 \`/ralph-loop\` \u7684\u547D\u4EE4\u3002
+- 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\u7528\u6237\u7684\u9700\u6C42\u662F **"\u81EA\u52A8\u91CD\u590D\u5C1D\u8BD5\u76F4\u5230\u6210\u529F / \u8FED\u4EE3\u4FEE\u590D\u6D4B\u8BD5\u76F4\u5230\u5168\u7EFF / \u53CD\u590D\u6253\u78E8\u540C\u4E00\u4EFD\u4EA7\u7269"** \u7B49
-  \u957F\u5FAA\u73AF\u573A\u666F\u65F6\uFF0C\u53EF\u4EE5\u5EFA\u8BAE\u7528\u6237\u6539\u7528\uFF1A\`/ralph-loop "<\u76EE\u6807>" [--max-iterations N] [--verify ...]\`
-  \uFF08\u5185\u7F6E\u7684\u590D\u5236\u4EFB\u52A1\u5FAA\u73AF\uFF0C\u4E94\u9636\u6BB5 FSM\uFF1APLAN \u2192 BUILD \u2192 VERIFY \u2192 HEAL \u2192 DONE\uFF09\u3002
-- \u5982\u679C\u5F53\u8F6E\u7528\u6237\u6D88\u606F\u91CC\u51FA\u73B0 \`<promise>DONE</promise>\` / \`<PROMISE>NEED_REPLAN</PROMISE>\` \u54E8\u5175
-  \u6216 PLAN/BUILD/VERIFY/HEAL \u9636\u6BB5\u6807\u8BB0\uFF0C\u8BF4\u660E\u4F60\u6B63\u8FD0\u884C\u5728 ralph-loop \u5185\u2014\u2014\u4E25\u683C\u6309\u7167\u5F53\u8F6E\u6CE8\u5165\u7684
-  freshContext \u6307\u5F15\u884C\u52A8\uFF0C**\u4EC5\u5728\u4EFB\u52A1\u771F\u6B63\u5B8C\u6210\u65F6**\u8F93\u51FA \`<promise>DONE</promise>\`\u3002
-- \u5728**\u5E38\u89C4\u5BF9\u8BDD**\uFF08\u65E0\u4E0A\u8FF0\u9636\u6BB5\u6807\u8BB0\uFF09\u4E2D**\u7981\u6B62**\u4F7F\u7528\u8FD9\u4E9B\u54E8\u5175\u548C\u9636\u6BB5\u8BCD\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
@@ -4120,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 " })
     ] }),
@@ -4452,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);
@@ -4481,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";
+// src/plugins/pluginLoader.ts
+import { existsSync as existsSync8 } from "fs";
 import { join as join8 } from "path";
-import { spawn as spawn4 } from "child_process";
-async function loadStopHookConfig(pluginRoot) {
-  const hooksJsonPath = join8(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((resolve10) => {
-    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", () => {
-      resolve10({ decision: "pass" });
-    });
-    child.on("close", (code) => {
-      if (code !== 0) {
-        resolve10({ decision: "pass" });
-        return;
-      }
-      const trimmed = stdout.trim();
-      if (!trimmed) {
-        resolve10({ decision: "pass" });
-        return;
-      }
-      try {
-        const parsed = JSON.parse(trimmed);
-        if (parsed.decision === "block") {
-          resolve10({
-            decision: "block",
-            reason: typeof parsed.reason === "string" ? parsed.reason : void 0,
-            systemMessage: typeof parsed.systemMessage === "string" ? parsed.systemMessage : void 0
-          });
-          return;
-        }
-        resolve10({ decision: "pass" });
-      } catch {
-        resolve10({ decision: "pass" });
-      }
-    });
-    child.stdin.write(transcriptText);
-    child.stdin.end();
-  });
-}
-
-// src/plugins/verificationGate.ts
-import { existsSync as existsSync8, 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((resolve10) => {
-    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", () => {
-      resolve10({ exitCode: null, stdout, stderr, errored: true });
-    });
-    child.on("close", (code) => {
-      resolve10({ 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`
-    };
+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;
   }
-  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 = existsSync8(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 existsSync9, readFileSync as readFileSync2 } from "fs";
-import { join as join9 } 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 = join9(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(join9(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 = join9(this.dir, `${name}.md`);
-      if (!existsSync9(path2)) {
-        await writeFile6(path2, content);
-      }
-    }
-  }
-  get goal() {
-    try {
-      return readFileSync2(join9(this.dir, "goal.md"), "utf8").trim();
-    } catch {
-      return "";
-    }
-  }
-  get completionCriteria() {
-    try {
-      const raw = readFileSync2(join9(this.dir, "completion.md"), "utf8").trim();
-      return JSON.parse(raw);
-    } catch {
-      return [];
-    }
-  }
-  get currentPhase() {
-    try {
-      const raw = readFileSync2(join9(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`
+    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(join9(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(join9(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(join9(this.dir, "progress.md"), `[${timestamp}] ${line}
-`);
-  }
-  tailProgress(n) {
-    try {
-      const content = readFileSync2(join9(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(join9(this.dir, "learnings.md"), `- ${lesson}
-`);
-  }
-  get learnings() {
-    try {
-      const raw = readFileSync2(join9(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(join9(this.dir, "decisions.md"), `${line}
-`);
-  }
-  findSimilarDecisions(ctx, k = 3) {
-    try {
-      const content = readFileSync2(join9(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(join9(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(join9(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";
@@ -5249,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,
@@ -5279,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
@@ -5432,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 () => {
@@ -5448,7 +4816,7 @@ function useChat(args) {
       setError(null);
       setInterrupted(false);
       setStreamingText("");
-      setPluginLoop(null);
+      setPluginProgress(null);
       const ac = new AbortController();
       abortRef.current = ac;
       try {
@@ -5463,7 +4831,7 @@ function useChat(args) {
             setCompacting,
             setError,
             setInterrupted,
-            setPluginLoop,
+            setPluginProgress,
             bump
           });
         }
@@ -5474,7 +4842,7 @@ function useChat(args) {
         setStreamingText("");
         setToolStatus(null);
         setCompacting(false);
-        setPluginLoop(null);
+        setPluginProgress(null);
         abortRef.current = null;
         args.onPersist?.(historyRef.current);
       }
@@ -5531,7 +4899,7 @@ function useChat(args) {
     error,
     interrupted,
     compacting,
-    pluginLoop,
+    pluginProgress,
     submit,
     abort,
     clearHistory,
@@ -5539,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(() => "");
@@ -5549,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();
@@ -5576,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;
@@ -5637,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
+      }
+    )
   ] });
 }
 
@@ -5772,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)}
 `
         );
       }
@@ -5800,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
 `
         );
       }
@@ -5810,7 +5189,7 @@ function handleEvent2(event, output, verbose) {
       return {};
     case "error":
       console.error(`
-\u9519\u8BEF: ${event.error}`);
+\u9519\u8BEF: ${e.error}`);
       return { exitCode: 1 };
     default:
       return {};
@@ -5851,7 +5230,7 @@ async function main() {
   const dirArg = extractCwdArg(args);
   if (dirArg) {
     const abs = resolve9(dirArg);
-    if (!existsSync10(abs)) {
+    if (!existsSync9(abs)) {
       mkdirSync(abs, { recursive: true });
     }
     process.chdir(abs);