monk-pi 0.2.0 → 0.10.0

package/dist/chunk-37UZNIY3.js

@@ -0,0 +1,1772 @@
+// src/constants.ts
+import os from "os";
+import path from "path";
+var MONK_BASE_URL = "https://monk.party/v1";
+var MONK_WEBSITE = "https://monk.party";
+var MONK_ACCOUNT_URL = "https://monk.party/account/";
+var MONK_MODELS = [
+  {
+    id: "monk-coding",
+    name: "Monk Coding (\u4EE3\u7801\u4E3B\u529B - \u63A8\u8350)",
+    description: "\u4E13\u4E3A Agent \u6DF1\u5EA6\u4F18\u5316\uFF0C\u517C\u5907\u9AD8\u541E\u5410\u903B\u8F91\u63A8\u6F14\u4E0E\u5DE5\u5177\u8C03\u7528\u80FD\u529B",
+    reasoning: true,
+    contextWindow: 1e6,
+    maxTokens: 64e3
+  },
+  {
+    id: "monk-fast",
+    name: "Monk Fast (\u6781\u901F\u63A8\u7406)",
+    description: "\u6781\u901F\u54CD\u5E94\uFF0C\u9002\u5408\u65E5\u5E38\u95EE\u7B54\u3001\u5FEB\u901F\u4EE3\u7801\u63A2\u7D22\u4E0E\u5355\u6587\u4EF6\u9605\u8BFB",
+    reasoning: true,
+    contextWindow: 1e6,
+    maxTokens: 64e3
+  },
+  {
+    id: "monk",
+    name: "Monk (\u878D\u5408\u6A21\u578B)",
+    description: "\u96C6\u4E09\u5927 Flash \u4E4B\u6240\u957F\uFF0C\u7EFC\u5408\u8D28\u91CF\u4E0E\u601D\u8003\u80FD\u529B\u4F18\u5148",
+    reasoning: true,
+    contextWindow: 1e6,
+    maxTokens: 64e3
+  }
+];
+var DEFAULT_MONK_MODEL = "monk-coding";
+function getMonkHomeDir() {
+  return path.join(os.homedir(), ".monk-pi");
+}
+function getMonkConfigFile() {
+  return path.join(getMonkHomeDir(), "config.json");
+}
+function getPiHomeDir() {
+  return process.env.PI_CODING_AGENT_DIR || path.join(os.homedir(), ".pi", "agent");
+}
+function getPiModelsFile() {
+  return path.join(getPiHomeDir(), "models.json");
+}
+function getPiSettingsFile() {
+  return path.join(getPiHomeDir(), "settings.json");
+}
+function getPiExtensionsDir() {
+  return path.join(getPiHomeDir(), "extensions");
+}
+function getPiMonkExtensionFile() {
+  return path.join(getPiExtensionsDir(), "monk.ts");
+}
+
+// src/config.ts
+import fs from "fs";
+
+// src/extension/code.ts
+var MONK_EXTENSION_CODE = `// @monk-managed-pi-extension
+// Monk \xD7 Pi Native Extension
+// Features: Footer status, Starter Navigator widget, Tips, Context macros (@diff, @recent, @git, @staged), Chinese engineering prompt, /undo, /commit, /review, /monk, and auto-compaction
+
+const fs = require("node:fs");
+const path = require("node:path");
+
+const MONK_MODELS = [
+  { id: "monk-coding", label: "monk-coding (\u4EE3\u7801\u4E3B\u529B - \u63A8\u8350 \xB7 \u6DF1\u5EA6\u5DE5\u5177\u8C03\u7528)" },
+  { id: "monk-fast", label: "monk-fast (\u6781\u901F\u63A8\u7406 \xB7 \u5FEB\u901F\u95EE\u7B54\u4E0E\u8F7B\u91CF\u4EFB\u52A1)" },
+  { id: "monk", label: "monk (\u878D\u5408\u65D7\u8230 \xB7 \u8D28\u91CF\u4F18\u5148\u4E0E\u7EFC\u5408\u63A8\u7406)" },
+];
+
+const PRO_TIPS = [
+  "\u5728\u8F93\u5165\u6846\u8F93\u5165 @diff \u5373\u53EF\u79D2\u7EA7\u628A\u5F53\u524D\u672A\u63D0\u4EA4\u6539\u52A8\u5E26\u5165\u5206\u6790",
+  "\u8F93\u5165 /commit \u53EF\u6309 Conventional Commits \u89C4\u8303\u81EA\u52A8\u751F\u6210\u4E2D\u6587\u63D0\u4EA4",
+  "AI \u6539\u4E71\u4E86\u4EE3\u7801\u4E0D\u7528\u614C\uFF0C\u968F\u65F6\u8F93\u5165 /undo \u6216 /\u56DE\u9000 \u77AC\u95F4\u4E00\u952E\u590D\u539F",
+  "\u8F93\u5165 /review \u53EF\u4ECE\u7F3A\u9677\u3001\u6027\u80FD\u3001\u67B6\u6784\u56DB\u4E2A\u7EF4\u5EA6\u5BF9\u4EE3\u7801\u8FDB\u884C\u6DF1\u5EA6\u5BA1\u67E5",
+  "\u8F93\u5165 /monk \u53EF\u547C\u51FA\u56FE\u5F62\u5316\u63A7\u5236\u53F0\uFF0C\u79D2\u7EA7\u514D\u91CD\u542F\u5207\u6362\u4E3B\u529B\u6A21\u578B",
+  "\u8F93\u5165 @recent \u5FEB\u901F\u63D0\u53D6\u6700\u8FD1\u53D8\u52A8\u7684\u9879\u76EE\u6838\u5FC3\u6E90\u6587\u4EF6\u5217\u8868",
+  "\u8F93\u5165 /monk cn \u968F\u65F6\u5207\u6362\u4E2D\u6587\u5DE5\u7A0B\u7CBE\u70BC\u6A21\u5F0F\uFF08\u96F6\u5BA2\u5957\xB7\u884C\u52A8\u4F18\u5148\uFF09",
+  "\u7EC8\u7AEF\u8F93\u5165 monk-pi -r \u53EF\u89C6\u5316\u6062\u590D\u4EE5\u5F80\u4EFB\u610F\u5386\u53F2\u4EFB\u52A1\u65AD\u70B9\u7EED\u5199",
+];
+
+const OVERFLOW_PATTERNS = [
+  /context.*length/i,
+  /maximum.*tokens/i,
+  /token.*limit/i,
+  /too many tokens/i,
+  /prompt.*too long/i,
+  /request.*too large/i,
+  /context_window_exceeded/i,
+  /exceed.*context/i,
+];
+
+const CHINESE_ENGINEERING_PROMPT = \`
+# \u4E2D\u6587\u5DE5\u7A0B\u4EA4\u4E92\u89C4\u8303 (Monk Chinese Engineering Persona)
+1. \u8BED\u8A00\u8868\u8FBE\u51C6\u5219\uFF1A
+   - \u5168\u7A0B\u4F7F\u7528\u5E72\u7EC3\u3001\u4E13\u4E1A\u3001\u81EA\u7136\u7684\u4E2D\u6587\u8FDB\u884C\u6C9F\u901A\u4E0E\u6280\u672F\u5206\u6790\u3002
+   - \u4E25\u7981\u4EFB\u4F55\u5F62\u5F0F\u7684\u5BA2\u5957\u4E0E\u94FA\u57AB\u5E9F\u8BDD\uFF08\u4E25\u7981\u8F93\u51FA\u8BF8\u5982\u201C\u597D\u7684\u201D\u3001\u201C\u6CA1\u95EE\u9898\u201D\u3001\u201C\u6536\u5230\u201D\u3001\u201C\u63A5\u4E0B\u6765\u6211\u5C06\u2026\u2026\u201D\u3001\u201C\u8FD9\u662F\u4E00\u4E2A\u5F88\u597D\u7684\u95EE\u9898\u201D\u7B49\u65E0\u610F\u4E49\u586B\u5145\u8BCD\uFF09\u3002
+   - \u4EE3\u7801\u4E2D\u7684\u6807\u8BC6\u7B26\u3001\u7C7B\u540D\u3001\u51FD\u6570\u540D\u3001\u5E93\u540D\u3001Git \u547D\u4EE4\u3001\u53C2\u6570\u9009\u9879\u53CA\u4E1A\u754C\u901A\u7528\u6280\u672F\u540D\u8BCD\uFF08\u5982 JWT\u3001Promise\u3001Hook\u3001WebSocket\u3001Props \u7B49\uFF09\u4FDD\u6301\u82F1\u6587\u539F\u8C8C\uFF0C\u5207\u52FF\u751F\u786C\u7FFB\u8BD1\u3002
+2. \u4EFB\u52A1\u6267\u884C\u51C6\u5219 (Action First)\uFF1A
+   - \u884C\u52A8\u5148\u4E8E\u89E3\u91CA\u3002\u51E1\u662F\u9700\u8981\u9605\u8BFB\u6587\u4EF6\u3001\u4FEE\u6539\u4EE3\u7801\u6216\u6267\u884C\u7CFB\u7EDF\u547D\u4EE4\u7684\u573A\u666F\uFF0C\u76F4\u63A5\u8C03\u7528\u76F8\u5E94\u5DE5\u5177 (read / edit / write / bash)\uFF0C\u7981\u6B62\u5728\u8C03\u7528\u5DE5\u5177\u524D\u9648\u8FF0\u5197\u4F59\u7684\u64CD\u4F5C\u8BA1\u5212\u3002
+   - \u5DE5\u5177\u8C03\u7528\u540E\uFF0C\u7528\u6700\u7B80\u7EC3\u7684\u4E00\u81F3\u4E24\u53E5\u8BDD\u603B\u7ED3\u6539\u52A8\u8981\u70B9\uFF08\u660E\u786E\u6307\u51FA\u4FEE\u6539\u4E86\u54EA\u4E2A\u6A21\u5757\u3001\u89E3\u51B3\u4E86\u4EC0\u4E48\u95EE\u9898\uFF09\uFF0C\u5FC5\u8981\u65F6\u63D0\u4F9B\u9A8C\u8BC1\u547D\u4EE4\uFF08\u5982\u6D4B\u8BD5\u6216\u542F\u52A8\u547D\u4EE4\uFF09\u3002
+3. \u4EE3\u7801\u8D28\u91CF\u51C6\u5219\uFF1A
+   - \u4E25\u5B88\u65E2\u6709\u4EE3\u7801\u5E93\u7684\u4EE3\u7801\u98CE\u683C\u4E0E\u67B6\u6784\u89C4\u8303\u3002
+   - \u4FEE\u6539\u4EE3\u7801\u5FC5\u987B\u7CBE\u51C6\u5FAE\u8C03\uFF0C\u907F\u514D\u4E0D\u5FC5\u8981\u7684\u683C\u5F0F\u6D17\u724C\u6216\u6574\u6587\u4EF6\u76F2\u76EE\u91CD\u5199\u3002
+   - \u590D\u6742\u7B97\u6CD5\u6216\u5173\u952E\u4E1A\u52A1\u903B\u8F91\u5904\u589E\u52A0\u7B80\u6D01\u660E\u4E86\u7684\u4E2D\u6587\u884C\u5185\u6CE8\u91CA\u3002
+\`;
+
+export default function monkExtension(pi) {
+  let turnCount = 0;
+  let chinesePromptEnabled = true;
+
+  // Undo Checkpoint Storage
+  const undoStack = [];
+  let currentTurnBackups = new Map();
+
+  function updateStatus(ctx) {
+    if (!ctx.ui) return;
+    const model = ctx.model;
+    const isMonk = model && model.provider === "monk";
+
+    if (!isMonk) {
+      ctx.ui.setStatus("monk", undefined);
+      return;
+    }
+
+    const theme = ctx.ui.theme;
+    const indicator = theme.fg("success", "\u25CF");
+    const label = theme.fg("accent", \`Monk: \${model.id}\`);
+    const cnBadge = chinesePromptEnabled ? theme.fg("dim", " [\u4E2D]") : "";
+    const undoBadge =
+      undoStack.length > 0 ? theme.fg("warning", \` [\u53EF\u64A4\u9500:\${undoStack.length}]\`) : "";
+    const meta = theme.fg("dim", " (1M ctx)");
+    ctx.ui.setStatus("monk", \`\${indicator} \${label}\${cnBadge}\${undoBadge}\${meta}\`);
+  }
+
+  // 1. Lifecycle Events
+  pi.on("session_start", async (_event, ctx) => {
+    updateStatus(ctx);
+
+    try {
+      if (ctx.ui && typeof ctx.ui.addAutocompleteProvider === "function") {
+        ctx.ui.addAutocompleteProvider((current) => ({
+          triggerCharacters: ["@"],
+          async getSuggestions(lines, cursorLine, cursorCol, options) {
+            const line = lines[cursorLine] ?? "";
+            const beforeCursor = line.slice(0, cursorCol);
+            const match = beforeCursor.match(/(?:^|[ \\t])@([a-zA-Z]*)$/);
+
+            const macros = [
+              { value: "@diff", label: "@diff", description: "\u5F53\u524D\u672A\u63D0\u4EA4\u7684 Git \u6539\u52A8\u4EE3\u7801 (Working Tree Diff)" },
+              { value: "@staged", label: "@staged", description: "\u5F53\u524D Git \u6682\u5B58\u533A\u6539\u52A8 (git diff --staged)" },
+              { value: "@recent", label: "@recent", description: "\u6700\u8FD1\u4FEE\u6539\u8FC7\u7684\u76F8\u5173\u9879\u76EE\u6587\u4EF6\u5217\u8868" },
+              { value: "@git", label: "@git", description: "\u5F53\u524D Git \u5206\u652F\u72B6\u6001\u4E0E\u6700\u65B0\u63D0\u4EA4\u8BB0\u5F55" },
+            ];
+
+            if (!match) {
+              return current.getSuggestions(lines, cursorLine, cursorCol, options);
+            }
+
+            const query = (match[1] || "").toLowerCase();
+            const filtered = macros.filter((m) => m.value.slice(1).startsWith(query));
+
+            const baseResult = await current.getSuggestions(lines, cursorLine, cursorCol, options);
+            const baseItems = (baseResult && baseResult.items) || [];
+
+            if (filtered.length > 0) {
+              return {
+                items: [...filtered, ...baseItems],
+                prefix: \`@\${query}\`,
+              };
+            }
+
+            return baseResult;
+          },
+          applyCompletion(lines, cursorLine, cursorCol, item, prefix) {
+            return current.applyCompletion(lines, cursorLine, cursorCol, item, prefix);
+          },
+          shouldTriggerFileCompletion(lines, cursorLine, cursorCol) {
+            return current.shouldTriggerFileCompletion ? current.shouldTriggerFileCompletion(lines, cursorLine, cursorCol) : true;
+          },
+        }));
+      }
+    } catch {}
+
+    // Startup Smart Navigator Widget (Auto-dismisses on first prompt)
+    if (ctx.ui && typeof ctx.ui.setWidget === "function") {
+      try {
+        const { stack, gitInfo } = await getProjectContext(pi);
+        const randomTip = PRO_TIPS[Math.floor(Math.random() * PRO_TIPS.length)];
+        const theme = ctx.ui.theme;
+
+        const widgetLines = [
+          theme.fg("accent", \`\u26A1 Monk \u6781\u5BA2\u5BFC\u822A \xB7 \${stack} (\${gitInfo})\`),
+          theme.fg("dim", "  \u63A8\u8350\u6307\u4EE4: @diff (\u6539\u52A8) \xB7 /commit (\u81EA\u52A8\u63D0\u4EA4) \xB7 /undo (\u4E00\u952E\u64A4\u9500) \xB7 /tips"),
+          theme.fg("warning", \`  \u{1F4A1} \u6280\u5DE7: \${randomTip}\`),
+        ];
+
+        ctx.ui.setWidget("monk-starter", widgetLines, { placement: "aboveEditor" });
+      } catch {}
+    }
+  });
+
+  pi.on("model_select", async (_event, ctx) => {
+    updateStatus(ctx);
+  });
+
+  pi.on("turn_start", async (event, ctx) => {
+    turnCount = event.turnIndex || turnCount + 1;
+    currentTurnBackups = new Map();
+
+    // Clear starter widget once conversation starts
+    if (ctx.ui && typeof ctx.ui.setWidget === "function") {
+      try {
+        ctx.ui.setWidget("monk-starter", undefined);
+      } catch {}
+    }
+
+    if (!ctx.ui) return;
+    const model = ctx.model;
+    if (model && model.provider === "monk") {
+      const theme = ctx.ui.theme;
+      const spinner = theme.fg("warning", "\u25B2");
+      const label = theme.fg("accent", \`Monk: \${model.id}\`);
+      const text = theme.fg("dim", \` [Turn \${turnCount}]\`);
+      ctx.ui.setStatus("monk", \`\${spinner} \${label}\${text}\`);
+    }
+  });
+
+  pi.on("turn_end", async (_event, ctx) => {
+    if (currentTurnBackups.size > 0) {
+      undoStack.push({
+        turnIndex: turnCount,
+        timestamp: Date.now(),
+        files: new Map(currentTurnBackups),
+      });
+
+      if (undoStack.length > 10) {
+        undoStack.shift();
+      }
+
+      if (ctx.ui) {
+        const count = currentTurnBackups.size;
+        if (count === 1) {
+          const firstFile = Array.from(currentTurnBackups.values())[0];
+          ctx.ui.notify(
+            \`\u5DF2\u4FEE\u6539 \${firstFile.relativePath} \xB7 \u5982\u9700\u64A4\u9500\u53EF\u968F\u65F6\u8F93\u5165 /undo \u4E00\u952E\u8FD8\u539F\`,
+            "info"
+          );
+        } else {
+          ctx.ui.notify(
+            \`\u5DF2\u4FEE\u6539 \${count} \u4E2A\u6587\u4EF6 \xB7 \u5982\u9700\u64A4\u9500\u53EF\u968F\u65F6\u8F93\u5165 /undo \u4E00\u952E\u8FD8\u539F\`,
+            "info"
+          );
+        }
+      }
+    }
+    currentTurnBackups = new Map();
+    updateStatus(ctx);
+  });
+
+  // 2. Magic Context Macro Expansion (@diff, @recent, @git, @staged)
+  pi.on("input", async (event, ctx) => {
+    if (event.source === "extension") return { action: "continue" };
+
+    let text = event.text || "";
+    let modified = false;
+
+    if (
+      text.includes("@diff") ||
+      text.includes("@staged") ||
+      text.includes("@git") ||
+      text.includes("@recent")
+    ) {
+      if (text.includes("@diff")) {
+        const diffBlock = await getGitDiff(pi);
+        text = text.replaceAll("@diff", diffBlock);
+        modified = true;
+      }
+
+      if (text.includes("@staged")) {
+        const stagedBlock = await getGitStagedDiff(pi);
+        text = text.replaceAll("@staged", stagedBlock);
+        modified = true;
+      }
+
+      if (text.includes("@git")) {
+        const gitBlock = await getGitSummary(pi);
+        text = text.replaceAll("@git", gitBlock);
+        modified = true;
+      }
+
+      if (text.includes("@recent")) {
+        const recentBlock = await getRecentFiles(pi);
+        text = text.replaceAll("@recent", recentBlock);
+        modified = true;
+      }
+
+      if (modified) {
+        ctx.ui && ctx.ui.notify("\u5DF2\u6210\u529F\u89E3\u6790\u5E76\u5C55\u5F00\u4E0A\u4E0B\u6587\u5B8F (@diff / @recent / @git)", "info");
+        return { action: "transform", text };
+      }
+    }
+  });
+
+  // 3. Intercept Tool Calls: File Pre-Snapshot for Undo
+  pi.on("tool_call", async (event) => {
+    if (event.toolName === "edit" || event.toolName === "write") {
+      const rawPath = event.input && event.input.path;
+      if (typeof rawPath === "string" && rawPath.trim()) {
+        const absPath = path.resolve(process.cwd(), rawPath.trim());
+
+        if (!currentTurnBackups.has(absPath)) {
+          const relPath = path.relative(process.cwd(), absPath);
+          try {
+            if (fs.existsSync(absPath)) {
+              const content = fs.readFileSync(absPath, "utf-8");
+              currentTurnBackups.set(absPath, {
+                path: absPath,
+                relativePath: relPath,
+                existed: true,
+                content,
+              });
+            } else {
+              currentTurnBackups.set(absPath, {
+                path: absPath,
+                relativePath: relPath,
+                existed: false,
+              });
+            }
+          } catch {}
+        }
+      }
+    }
+  });
+
+  // 4. Chinese Engineering System Prompt Injection
+  pi.on("before_agent_start", async (event, ctx) => {
+    if (!chinesePromptEnabled) return;
+    const model = ctx.model;
+    const isMonk = model && model.provider === "monk";
+    if (!isMonk) return;
+
+    const currentPrompt = event.systemPrompt || "";
+    if (!currentPrompt.includes("\u4E2D\u6587\u5DE5\u7A0B\u4EA4\u4E92\u89C4\u8303")) {
+      return {
+        systemPrompt: \`\${currentPrompt}\\n\\n\${CHINESE_ENGINEERING_PROMPT.trim()}\`,
+      };
+    }
+  });
+
+  // 5. Intelligent Context Overflow & Compaction Recovery
+  pi.on("message_end", async (event, ctx) => {
+    const message = event.message;
+    if (!message || message.role !== "assistant") return;
+    if (message.stopReason !== "error") return;
+
+    const isMonk = message.provider === "monk" || (ctx.model && ctx.model.provider === "monk");
+    if (!isMonk) return;
+
+    const errorMsg = message.errorMessage || "";
+    if (errorMsg.includes("context_length_exceeded")) return;
+
+    const isOverflow = OVERFLOW_PATTERNS.some((p) => p.test(errorMsg));
+    if (isOverflow) {
+      ctx.ui && ctx.ui.notify(
+        "Monk: \u68C0\u6D4B\u5230\u4E0A\u4E0B\u6587\u8D85\u957F\uFF0C\u5DF2\u81EA\u52A8\u91CD\u5199\u9519\u8BEF\u5E76\u89E6\u53D1\u667A\u80FD\u538B\u7F29 (Compaction) \u91CD\u8BD5...",
+        "warning"
+      );
+      return {
+        message: {
+          ...message,
+          errorMessage: \`context_length_exceeded: \${errorMsg}\`,
+        },
+      };
+    }
+  });
+
+  // 6. Custom Slash Command: /tips (\u6280\u5DE7\u6E05\u5355)
+  pi.registerCommand("tips", {
+    description: "\u67E5\u770B Monk-Pi \u6781\u5BA2\u6280\u5DE7\u6E05\u5355 (/tips)",
+    handler: async (_args, ctx) => {
+      if (!ctx.ui) return;
+      await ctx.ui.select(
+        "Monk-Pi \u5B9E\u7528\u6781\u5BA2\u6280\u5DE7\u6E05\u5355:",
+        PRO_TIPS.map((t, i) => \`\${i + 1}. \${t}\`)
+      );
+    },
+  });
+
+  // 7. Custom Slash Command: /undo (\u4E00\u952E\u64A4\u9500)
+  pi.registerCommand("undo", {
+    description: "\u4E00\u952E\u64A4\u9500\u4E0A\u4E00\u6B21 AI \u5BF9\u6587\u4EF6\u7684\u6240\u6709\u4FEE\u6539 (/undo)",
+    handler: async (_args, ctx) => {
+      await handleUndoCommand(ctx, undoStack, () => updateStatus(ctx));
+    },
+  });
+
+  pi.registerCommand("\u56DE\u9000", {
+    description: "\u4E00\u952E\u64A4\u9500\u4E0A\u4E00\u6B21 AI \u5BF9\u6587\u4EF6\u7684\u6240\u6709\u4FEE\u6539 (/\u56DE\u9000)",
+    handler: async (_args, ctx) => {
+      await handleUndoCommand(ctx, undoStack, () => updateStatus(ctx));
+    },
+  });
+
+  // 8. Custom Slash Command: /commit (\u81EA\u52A8\u4E2D\u6587\u8BED\u4E49\u5316\u63D0\u4EA4)
+  pi.registerCommand("commit", {
+    description: "\u68C0\u67E5 Git \u6539\u52A8\u5E76\u751F\u6210\u8BED\u4E49\u5316\u4E2D\u6587 Commit \u63D0\u4EA4 (/commit [\u9644\u52A0\u8BF4\u660E])",
+    handler: async (args, ctx) => {
+      await handleCommitCommand(pi, ctx, args);
+    },
+  });
+
+  // 9. Custom Slash Command: /review (\u6DF1\u5EA6\u4E2D\u6587\u4EE3\u7801\u5BA1\u67E5)
+  pi.registerCommand("review", {
+    description: "\u5BF9\u5F53\u524D Git \u6539\u52A8\u6216\u6307\u5B9A\u6587\u4EF6\u8FDB\u884C\u4E13\u4E1A\u4E2D\u6587\u4EE3\u7801\u5BA1\u67E5 (/review [\u8DEF\u5F84/\u5206\u652F])",
+    handler: async (args, ctx) => {
+      await handleReviewCommand(pi, ctx, args);
+    },
+  });
+
+  // 10. Custom Slash Command: /monk
+  pi.registerCommand("monk", {
+    description: "Monk \u4E13\u5C5E\u63A7\u5236\u53F0 (/monk [model|undo|commit|review|prompt|tips|ping|status|account])",
+    handler: async (args, ctx) => {
+      const sub = (args || "").trim().toLowerCase();
+
+      if (sub === "undo" || sub === "rollback") {
+        await handleUndoCommand(ctx, undoStack, () => updateStatus(ctx));
+        return;
+      }
+
+      if (sub === "tips" || sub === "help") {
+        if (ctx.ui) {
+          await ctx.ui.select(
+            "Monk-Pi \u6781\u5BA2\u6280\u5DE7\u6E05\u5355:",
+            PRO_TIPS.map((t, i) => \`\${i + 1}. \${t}\`)
+          );
+        }
+        return;
+      }
+
+      if (sub === "model" || sub === "switch") {
+        await handleModelSwitch(pi, ctx);
+        return;
+      }
+
+      if (sub === "commit" || sub === "ci") {
+        await handleCommitCommand(pi, ctx, "");
+        return;
+      }
+
+      if (sub === "review" || sub === "cr") {
+        await handleReviewCommand(pi, ctx, "");
+        return;
+      }
+
+      if (sub === "prompt" || sub === "cn") {
+        chinesePromptEnabled = !chinesePromptEnabled;
+        const state = chinesePromptEnabled ? "\u5DF2\u542F\u7528 (\u7CBE\u70BC\u5E72\u7EC3)" : "\u5DF2\u5173\u95ED (\u6062\u590D\u539F\u751F\u9ED8\u8BA4)";
+        ctx.ui && ctx.ui.notify(\`Monk \u4E2D\u6587\u5DE5\u7A0B\u7CFB\u7EDF\u63D0\u793A\u8BCD: \${state}\`, "info");
+        updateStatus(ctx);
+        return;
+      }
+
+      if (sub === "ping" || sub === "status") {
+        await handlePing(ctx);
+        return;
+      }
+
+      if (sub === "account" || sub === "quota") {
+        ctx.ui && ctx.ui.notify("Monk \u7528\u91CF\u4E0E\u5230\u671F\u67E5\u8BE2: https://monk.party/account/", "info");
+        return;
+      }
+
+      // Default: interactive menu
+      await handleMenu(
+        pi,
+        ctx,
+        undoStack,
+        () => {
+          chinesePromptEnabled = !chinesePromptEnabled;
+          updateStatus(ctx);
+          return chinesePromptEnabled;
+        },
+        () => updateStatus(ctx)
+      );
+    },
+  });
+}
+
+// ============================================================================
+// Context Macro Resolvers (@diff, @staged, @git, @recent)
+// ============================================================================
+
+async function getGitDiff(pi) {
+  const check = await pi.exec("git", ["rev-parse", "--is-inside-work-tree"]);
+  if (check.code !== 0) return "[\u5F53\u524D\u76EE\u5F55\u975E Git \u4ED3\u5E93\uFF0C\u65E0\u6CD5\u83B7\u53D6 @diff]";
+
+  const res = await pi.exec("git", ["diff"]);
+  const stagedRes = await pi.exec("git", ["diff", "--staged"]);
+  const combined = [res.stdout && res.stdout.trim(), stagedRes.stdout && stagedRes.stdout.trim()]
+    .filter(Boolean)
+    .join("\\n\\n");
+
+  if (!combined) return "[\u5F53\u524D Git \u5DE5\u4F5C\u533A\u5E72\u51C0\uFF0C\u6682\u65E0\u672A\u63D0\u4EA4\u7684\u4EE3\u7801\u6539\u52A8]";
+
+  const lines = combined.split("\\n");
+  if (lines.length > 500) {
+    const truncated = lines.slice(0, 500).join("\\n");
+    return \`\\n\`\`\`diff\\n# [Git Diff \u53D8\u66F4\u4EE3\u7801 - \u5171 \${lines.length} \u884C\uFF0C\u5C55\u793A\u524D 500 \u884C]\\n\${truncated}\\n\`\`\`\\n\`;
+  }
+
+  return \`\\n\`\`\`diff\\n# [Git Diff \u53D8\u66F4\u4EE3\u7801 - \u5171 \${lines.length} \u884C]\\n\${combined}\\n\`\`\`\\n\`;
+}
+
+async function getGitStagedDiff(pi) {
+  const check = await pi.exec("git", ["rev-parse", "--is-inside-work-tree"]);
+  if (check.code !== 0) return "[\u5F53\u524D\u76EE\u5F55\u975E Git \u4ED3\u5E93\uFF0C\u65E0\u6CD5\u83B7\u53D6 @staged]";
+
+  const res = await pi.exec("git", ["diff", "--staged"]);
+  const diff = res.stdout && res.stdout.trim();
+  if (!diff) return "[\u5F53\u524D Git \u6682\u5B58\u533A\u6682\u65E0\u6539\u52A8 (Staged is empty)]";
+
+  return \`\\n\`\`\`diff\\n# [Git \u6682\u5B58\u533A\u4EE3\u7801\u53D8\u52A8 (Staged Diff)]\\n\${diff}\\n\`\`\`\\n\`;
+}
+
+async function getGitSummary(pi) {
+  const check = await pi.exec("git", ["rev-parse", "--is-inside-work-tree"]);
+  if (check.code !== 0) return "[\u5F53\u524D\u76EE\u5F55\u975E Git \u4ED3\u5E93\uFF0C\u65E0\u6CD5\u83B7\u53D6 @git]";
+
+  const branchRes = await pi.exec("git", ["branch", "--show-current"]);
+  const statusRes = await pi.exec("git", ["status", "-s"]);
+  const logRes = await pi.exec("git", ["log", "-n", "3", "--oneline"]);
+
+  const branch = (branchRes.stdout && branchRes.stdout.trim()) || "HEAD";
+  const status = (statusRes.stdout && statusRes.stdout.trim()) || "(\u5DE5\u4F5C\u533A\u5E72\u51C0)";
+  const log = (logRes.stdout && logRes.stdout.trim()) || "(\u6682\u65E0\u63D0\u4EA4\u8BB0\u5F55)";
+
+  return \`\\n\`\`\`\\n# [Git \u5F53\u524D\u5206\u652F\u4E0E\u72B6\u6001\u4FE1\u606F]\\n\u5206\u652F: \${branch}\\n\u72B6\u6001\u53D8\u52A8:\\n\${status}\\n\\n\u6700\u8FD1 3 \u6761\u63D0\u4EA4:\\n\${log}\\n\`\`\`\\n\`;
+}
+
+async function getRecentFiles(pi) {
+  const check = await pi.exec("git", ["rev-parse", "--is-inside-work-tree"]);
+  if (check.code === 0) {
+    const statusRes = await pi.exec("git", ["status", "--porcelain"]);
+    const logRes = await pi.exec("git", ["log", "-n", "5", "--name-only", "--format="]);
+    const fileSet = new Set();
+
+    if (statusRes.stdout) {
+      statusRes.stdout.split("\\n").forEach((line) => {
+        const p = line.slice(3).trim();
+        if (p) fileSet.add(p);
+      });
+    }
+
+    if (logRes.stdout) {
+      logRes.stdout.split("\\n").forEach((line) => {
+        const p = line.trim();
+        if (p) fileSet.add(p);
+      });
+    }
+
+    const files = Array.from(fileSet).slice(0, 15);
+    if (files.length > 0) {
+      return \`\\n# [\u6700\u8FD1\u53D8\u52A8\u5173\u8054\u7684\u9879\u76EE\u6E90\u6587\u4EF6\u5217\u8868]\\n\${files.map((f) => \`- \${f}\`).join("\\n")}\\n\`;
+    }
+  }
+
+  return "[\u6682\u672A\u627E\u5230\u6700\u8FD1\u53D8\u52A8\u7684\u5173\u8054\u6587\u4EF6]";
+}
+
+// ============================================================================
+// Project Context Profiler
+// ============================================================================
+
+async function getProjectContext(pi) {
+  let stack = "\u901A\u7528\u9879\u76EE";
+  const cwd = process.cwd();
+
+  const pkgPath = path.join(cwd, "package.json");
+  if (fs.existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+      const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+      if (deps["vue"] || deps["nuxt"]) stack = "Vue 3 \u6280\u672F\u6808";
+      else if (deps["next"]) stack = "Next.js \u5168\u6808";
+      else if (deps["react"]) stack = "React \u524D\u7AEF";
+      else if (deps["@earendil-works/pi-coding-agent"]) stack = "Monk-Pi / Agent \u5DE5\u7A0B";
+      else stack = "Node.js \u5DE5\u7A0B";
+    } catch {
+      stack = "Node.js \u5DE5\u7A0B";
+    }
+  } else if (fs.existsSync(path.join(cwd, "go.mod"))) {
+    stack = "Go \u540E\u7AEF\u5DE5\u7A0B";
+  } else if (fs.existsSync(path.join(cwd, "Cargo.toml"))) {
+    stack = "Rust \u7CFB\u7EDF\u5DE5\u7A0B";
+  } else if (
+    fs.existsSync(path.join(cwd, "requirements.txt")) ||
+    fs.existsSync(path.join(cwd, "pyproject.toml"))
+  ) {
+    stack = "Python \u5DE5\u7A0B";
+  } else if (
+    fs.existsSync(path.join(cwd, "pom.xml")) ||
+    fs.existsSync(path.join(cwd, "build.gradle"))
+  ) {
+    stack = "Java / Spring \u5DE5\u7A0B";
+  }
+
+  let gitInfo = "\u65E0 Git";
+  const gitCheck = await pi.exec("git", ["rev-parse", "--is-inside-work-tree"]);
+  if (gitCheck.code === 0) {
+    const branchRes = await pi.exec("git", ["branch", "--show-current"]);
+    const statusRes = await pi.exec("git", ["status", "--porcelain"]);
+    const branch = (branchRes.stdout && branchRes.stdout.trim()) || "HEAD";
+    const changedCount = statusRes.stdout
+      ? statusRes.stdout.split("\\n").filter((l) => l.trim()).length
+      : 0;
+    gitInfo = changedCount > 0 ? \`\${branch}: \${changedCount} \u6539\u52A8\` : \`\${branch}: \u5E72\u51C0\`;
+  }
+
+  return { stack, gitInfo };
+}
+
+// ============================================================================
+// Undo, Commit, Review & Control Handlers
+// ============================================================================
+
+async function handleUndoCommand(ctx, undoStack, refreshStatus) {
+  if (undoStack.length === 0) {
+    ctx.ui && ctx.ui.notify("\u5F53\u524D\u6CA1\u6709\u53EF\u64A4\u9500\u7684 AI \u6539\u52A8\u8BB0\u5F55 (\u6682\u65E0\u68C0\u67E5\u70B9)", "info");
+    return;
+  }
+
+  const checkpoint = undoStack[undoStack.length - 1];
+  const fileBackups = Array.from(checkpoint.files.values());
+
+  if (fileBackups.length === 0) {
+    undoStack.pop();
+    ctx.ui && ctx.ui.notify(\`\u4E0A\u4E00\u4E2A\u8F6E\u6B21 (Turn \${checkpoint.turnIndex}) \u672A\u4EA7\u751F\u6587\u4EF6\u6539\u52A8\`, "info");
+    refreshStatus();
+    return;
+  }
+
+  const fileSummaries = fileBackups.map((f) => {
+    return f.existed ? \`  \u21BA \u6062\u590D\u539F\u72B6: \${f.relativePath}\` : \`  \u{1F5D1} \u5220\u9664\u65B0\u5EFA: \${f.relativePath}\`;
+  });
+
+  const promptText = \`\u786E\u8BA4\u64A4\u9500\u7B2C \${checkpoint.turnIndex} \u8F6E\u7684 AI \u6587\u4EF6\u6539\u52A8\uFF1F\\n\${fileSummaries.join("\\n")}\`;
+  const choice = await (ctx.ui && ctx.ui.select(promptText, [
+    \`\u786E\u8BA4\u64A4\u9500 (\${fileBackups.length} \u4E2A\u6587\u4EF6)\`,
+    "\u53D6\u6D88",
+  ]));
+
+  if (!choice || choice.includes("\u53D6\u6D88")) {
+    ctx.ui && ctx.ui.notify("\u5DF2\u53D6\u6D88\u64A4\u9500\u64CD\u4F5C", "info");
+    return;
+  }
+
+  undoStack.pop();
+  let restoredCount = 0;
+  let deletedCount = 0;
+  const errors = [];
+
+  for (const file of fileBackups) {
+    try {
+      if (!file.existed) {
+        if (fs.existsSync(file.path)) {
+          fs.unlinkSync(file.path);
+          deletedCount++;
+        }
+      } else if (file.content !== undefined) {
+        fs.writeFileSync(file.path, file.content, "utf-8");
+        restoredCount++;
+      }
+    } catch (err) {
+      errors.push(\`\${file.relativePath}: \${err instanceof Error ? err.message : String(err)}\`);
+    }
+  }
+
+  refreshStatus();
+
+  if (errors.length > 0) {
+    ctx.ui && ctx.ui.notify(\`\u64A4\u9500\u90E8\u5206\u5B8C\u6210\uFF0C\u4F46\u5B58\u5728\u9519\u8BEF: \${errors.join("; ")}\`, "warning");
+  } else {
+    ctx.ui && ctx.ui.notify(
+      \`\u5DF2\u6210\u529F\u64A4\u9500\u6539\u52A8\uFF01\u5171\u6062\u590D \${restoredCount} \u4E2A\u6587\u4EF6\uFF0C\u6E05\u7406 \${deletedCount} \u4E2A\u65B0\u5EFA\u6587\u4EF6\`,
+      "success"
+    );
+  }
+}
+
+async function handleCommitCommand(pi, ctx, extraArgs) {
+  const gitCheck = await pi.exec("git", ["rev-parse", "--is-inside-work-tree"]);
+  if (gitCheck.code !== 0) {
+    ctx.ui && ctx.ui.notify("\u5F53\u524D\u76EE\u5F55\u4E0D\u662F Git \u4ED3\u5E93\uFF0C\u65E0\u6CD5\u6267\u884C /commit", "warning");
+    return;
+  }
+
+  const statusCheck = await pi.exec("git", ["status", "--porcelain"]);
+  if (!statusCheck.stdout || !statusCheck.stdout.trim()) {
+    ctx.ui && ctx.ui.notify("Git \u5DE5\u4F5C\u533A\u5E72\u51C0\uFF0C\u6CA1\u6709\u5F85\u63D0\u4EA4\u7684\u6539\u52A8 (Working tree clean)", "info");
+    return;
+  }
+
+  ctx.ui && ctx.ui.notify("\u6B63\u5728\u5206\u6790 Git \u6539\u52A8\u5E76\u51C6\u5907\u4E2D\u6587\u8BED\u4E49\u5316\u63D0\u4EA4...", "info");
+
+  const prompt = [
+    "\u8BF7\u68C0\u67E5\u5F53\u524D\u7684 Git \u6539\u52A8\uFF0C\u5E76\u6309\u7167 Conventional Commits \u89C4\u8303\u751F\u6210\u5730\u9053\u7684\u4E2D\u6587\u8BED\u4E49\u5316\u63D0\u4EA4\u4FE1\u606F\u5E76\u5B8C\u6210\u63D0\u4EA4\uFF1A",
+    "1. \u5148\u8C03\u7528 bash \u67E5\u770B\u5F53\u524D\u53D8\u66F4\u72B6\u6001 (\`git status -s\`) \u4E0E\u4EE3\u7801\u6539\u52A8 (\`git diff --stat\` \u548C \`git diff\`)\u3002",
+    "2. \u6839\u636E\u53D8\u66F4\u5185\u5BB9\u786E\u5B9A\u89C4\u8303\u7684\u63D0\u4EA4\u4FE1\u606F\uFF1A",
+    "   \u683C\u5F0F\uFF1A<type>(<scope>): <\u7B80\u660E\u6E05\u6670\u7684\u4E2D\u6587\u63D0\u4EA4\u4E3B\u9898>",
+    "   \u5E38\u89C1\u7C7B\u578B\uFF1Afeat(\u65B0\u7279\u6027)\u3001fix(\u4FEE\u590D)\u3001docs(\u6587\u6863)\u3001refactor(\u91CD\u6784)\u3001perf(\u6027\u80FD)\u3001test(\u6D4B\u8BD5)\u3001chore(\u6742\u9879)\u3002",
+    "3. \u76F4\u63A5\u8C03\u7528 bash \u6267\u884C \`git add -A\` \u5E76\u4F7F\u7528 \`git commit -m \\"...\\"\` \u6267\u884C\u63D0\u4EA4\u3002",
+    "4. \u63D0\u4EA4\u5B8C\u6210\u540E\uFF0C\u7528\u4E24\u53E5\u8BDD\u7B80\u8981\u6C47\u62A5 commit hash \u4E0E\u63D0\u4EA4\u4FE1\u606F\u3002",
+    extraArgs ? \`\\n\u9644\u52A0\u8981\u6C42\uFF1A\${extraArgs}\` : "",
+  ].join("\\n");
+
+  pi.sendUserMessage(prompt);
+}
+
+async function handleReviewCommand(pi, ctx, targetPath) {
+  const target = (targetPath || "").trim();
+
+  if (target) {
+    ctx.ui && ctx.ui.notify(\`\u6B63\u5728\u9488\u5BF9\u6307\u5B9A\u76EE\u6807\u53D1\u8D77\u6DF1\u5EA6\u4EE3\u7801\u5BA1\u67E5: \${target} ...\`, "info");
+    const prompt = [
+      \`\u8BF7\u5BF9\u6307\u5B9A\u76EE\u6807\u8FDB\u884C\u4E13\u4E1A\u3001\u6DF1\u5165\u7684\u4EE3\u7801\u5BA1\u67E5 (Code Review)\uFF1A\${target}\`,
+      "1. \u8C03\u7528 read \u5DE5\u5177\u9605\u8BFB\u76F8\u5173\u6E90\u4EE3\u7801\u53CA\u9879\u76EE\u4E0A\u4E0B\u6587\u3002",
+      "2. \u4ECE\u4EE5\u4E0B\u56DB\u4E2A\u5173\u952E\u7EF4\u5EA6\u8F93\u51FA\u7ED3\u6784\u5316\u4E2D\u6587\u5BA1\u67E5\u62A5\u544A\uFF1A",
+      "   - \u{1F6A8}\u3010\u6F5C\u5728\u7F3A\u9677\u4E0E\u8FB9\u754C\u5F02\u5E38\u3011\uFF1A\u7A7A\u6307\u9488/\u672A\u5B9A\u4E49\u3001\u5E76\u53D1\u7ADE\u4E89\u3001\u672A\u6355\u83B7\u5F02\u5E38\u3001\u8FB9\u754C\u8D8A\u754C\u7B49\u9690\u60A3\u3002",
+      "   - \u26A1\u3010\u6027\u80FD\u4E0E\u8D44\u6E90\u6D88\u8017\u3011\uFF1A\u65E0\u610F\u4E49\u5FAA\u73AF\u3001\u5185\u5B58\u6CC4\u6F0F\u3001\u8FC7\u591A\u91CD\u7ED8\u3001\u6602\u8D35\u8BA1\u7B97\u6216\u8FDE\u63A5\u672A\u91CA\u653E\u3002",
+      "   - \u{1F3D7}\u3010\u8BBE\u8BA1\u4E0E\u53EF\u7EF4\u62A4\u6027\u3011\uFF1A\u5355\u4E00\u804C\u8D23\u539F\u5219\u3001\u6A21\u5757\u89E3\u8026\u3001\u4EE3\u7801\u590D\u7528\u3001\u547D\u540D\u89C4\u8303\u4E0E\u53EF\u8BFB\u6027\u3002",
+      "   - \u{1F4A1}\u3010\u5177\u4F53\u6539\u8FDB\u5EFA\u8BAE\u3011\uFF1A\u6307\u51FA\u5177\u4F53\u6709\u95EE\u9898\u7684\u4EE3\u7801\u4F4D\u7F6E\uFF0C\u5E76\u7ED9\u51FA\u4F18\u5316\u540E\u7684\u53C2\u8003\u5B9E\u73B0\u7247\u6BB5\u3002",
+      "3. \u8BED\u8A00\u4FDD\u6301\u5BA2\u89C2\u4E13\u4E1A\uFF0C\u7A81\u51FA\u9AD8\u4EF7\u503C\u4FEE\u6539\u610F\u89C1\u3002",
+    ].join("\\n");
+
+    pi.sendUserMessage(prompt);
+    return;
+  }
+
+  const gitCheck = await pi.exec("git", ["rev-parse", "--is-inside-work-tree"]);
+  if (gitCheck.code !== 0) {
+    ctx.ui && ctx.ui.notify("\u5F53\u524D\u76EE\u5F55\u4E0D\u662F Git \u4ED3\u5E93\uFF0C\u8BF7\u6307\u5B9A\u5177\u4F53\u6587\u4EF6\u8DEF\u5F84\u5BA1\u67E5\uFF0C\u4F8B\u5982: /review src/index.ts", "warning");
+    return;
+  }
+
+  const statusCheck = await pi.exec("git", ["status", "--porcelain"]);
+  if (!statusCheck.stdout || !statusCheck.stdout.trim()) {
+    ctx.ui && ctx.ui.notify("\u5F53\u524D Git \u5DE5\u4F5C\u533A\u65E0\u672A\u63D0\u4EA4\u6539\u52A8\u3002\u53EF\u6307\u5B9A\u7279\u5B9A\u6587\u4EF6\u5BA1\u67E5\uFF0C\u4F8B\u5982: /review src/index.ts", "info");
+    return;
+  }
+
+  ctx.ui && ctx.ui.notify("\u6B63\u5728\u9488\u5BF9\u5F53\u524D\u672A\u63D0\u4EA4\u7684 Git \u6539\u52A8\u53D1\u8D77\u6DF1\u5EA6\u4EE3\u7801\u5BA1\u67E5...", "info");
+
+  const prompt = [
+    "\u8BF7\u5BF9\u5F53\u524D\u5DE5\u4F5C\u533A\u7684\u6240\u6709\u672A\u63D0\u4EA4\u6539\u52A8 (Uncommitted Changes) \u8FDB\u884C\u4E13\u4E1A\u3001\u6DF1\u5165\u7684\u4E2D\u6587\u4EE3\u7801\u5BA1\u67E5 (Code Review)\uFF1A",
+    "1. \u8C03\u7528 bash \u6267\u884C \`git diff\` \u53CA \`git diff --staged\` \u83B7\u53D6\u5B8C\u6574\u6539\u52A8\u4EE3\u7801\u3002",
+    "2. \u4ECE\u4EE5\u4E0B\u56DB\u4E2A\u5173\u952E\u7EF4\u5EA6\u8FDB\u884C\u5206\u6790\u5E76\u8F93\u51FA\u7ED3\u6784\u6E05\u6670\u7684 Markdown \u5BA1\u67E5\u62A5\u544A\uFF1A",
+    "   - \u{1F6A8}\u3010\u6F5C\u5728\u7F3A\u9677\u4E0E\u8FB9\u754C\u5F02\u5E38\u3011\uFF1A\u7A7A\u6307\u9488/\u672A\u5B9A\u4E49\u3001\u903B\u8F91\u6B7B\u89D2\u3001\u672A\u5904\u7406\u7684\u9519\u8BEF\u3001\u8FB9\u754C\u5F02\u5E38\u3002",
+    "   - \u26A1\u3010\u6027\u80FD\u4E0E\u8D44\u6E90\u6D88\u8017\u3011\uFF1A\u4E0D\u5FC5\u8981\u7684\u5FAA\u73AF\u3001\u91CD\u590D\u6E32\u67D3\u3001\u672A\u6E05\u7406\u7684\u526F\u4F5C\u7528\u3001\u9AD8\u8017\u65F6\u64CD\u4F5C\u3002",
+    "   - \u{1F3D7}\u3010\u8BBE\u8BA1\u4E0E\u67B6\u6784\u8D28\u91CF\u3011\uFF1A\u4EE3\u7801\u89E3\u8026\u3001\u5355\u4E00\u804C\u8D23\u3001\u547D\u540D\u5951\u5408\u5EA6\u4E0E\u53EF\u8BFB\u6027\u3002",
+    "   - \u{1F4A1}\u3010\u5173\u952E\u91CD\u6784\u5EFA\u8BAE\u4E0E\u7247\u6BB5\u3011\uFF1A\u7ED9\u51FA\u5177\u4F53\u7684\u4FEE\u6539\u65B9\u6848\u4E0E\u63A8\u8350\u7684\u4EE3\u7801\u91CD\u6784\u5199\u6CD5\u3002",
+    "3. \u5982\u679C\u6539\u52A8\u6574\u4F53\u8D28\u91CF\u4F18\u79C0\uFF0C\u8BF7\u660E\u786E\u6307\u51FA\u4EAE\u70B9\u5E76\u4E88\u4EE5\u80AF\u5B9A\u3002",
+  ].join("\\n");
+
+  pi.sendUserMessage(prompt);
+}
+
+async function handleModelSwitch(pi, ctx) {
+  if (!ctx.ui) return;
+
+  const choices = MONK_MODELS.map((m) => m.label);
+  const selectedLabel = await ctx.ui.select("\u9009\u62E9\u5F53\u524D\u4F1A\u8BDD\u7684 Monk \u6A21\u578B:", choices);
+
+  if (!selectedLabel) return;
+
+  const matched = MONK_MODELS.find((m) => m.label === selectedLabel);
+  if (!matched) return;
+
+  const model = ctx.modelRegistry.find("monk", matched.id);
+  if (!model) {
+    ctx.ui.notify(\`\u672A\u5728\u914D\u7F6E\u4E2D\u627E\u5230\u6A21\u578B: monk/\${matched.id}\`, "error");
+    return;
+  }
+
+  const success = await pi.setModel(model);
+  if (success) {
+    ctx.ui.notify(\`\u4E3B\u529B\u6A21\u578B\u5DF2\u5207\u6362\u81F3: \${matched.id}\`, "info");
+  } else {
+    ctx.ui.notify(\`\u5207\u6362\u5931\u8D25\uFF0C\u672A\u80FD\u8BBE\u7F6E\u6A21\u578B: \${matched.id}\`, "error");
+  }
+}
+
+async function handlePing(ctx) {
+  if (!ctx.ui) return;
+
+  const startTime = Date.now();
+  const apiKey = process.env.MONK_API_KEY || "";
+
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 6000);
+
+    const res = await fetch("https://monk.party/v1/models", {
+      headers: { Authorization: \`Bearer \${apiKey}\` },
+      signal: controller.signal,
+    });
+
+    clearTimeout(timeout);
+    const latency = Date.now() - startTime;
+
+    if (res.ok) {
+      ctx.ui.notify(\`Monk API \u8FDE\u901A\u6B63\u5E38 \xB7 \u5EF6\u8FDF \${latency}ms\`, "info");
+    } else {
+      ctx.ui.notify(\`Monk API \u54CD\u5E94\u5F02\u5E38 (HTTP \${res.status})\`, "warning");
+    }
+  } catch (err) {
+    ctx.ui.notify(
+      \`Monk API \u8FDE\u63A5\u5931\u8D25: \${err instanceof Error ? err.message : String(err)}\`,
+      "error"
+    );
+  }
+}
+
+async function handleMenu(pi, ctx, undoStack, toggleCnPrompt, refreshStatus) {
+  if (!ctx.ui) return;
+
+  const undoText =
+    undoStack.length > 0
+      ? \`2. \u4E00\u952E\u64A4\u9500\u4E0A\u6B21\u6539\u52A8 (/undo \xB7 \${undoStack.length} \u4E2A\u53EF\u56DE\u9000)\`
+      : "2. \u4E00\u952E\u64A4\u9500\u4E0A\u6B21\u6539\u52A8 (/undo \xB7 \u6682\u65E0)";
+
+  const choice = await ctx.ui.select("Monk API \u63A7\u5236\u53F0", [
+    "1. \u5207\u6362\u4F1A\u8BDD\u6A21\u578B (Switch Model)",
+    undoText,
+    "3. \u8BED\u4E49\u5316 Git \u63D0\u4EA4 (/commit)",
+    "4. \u6DF1\u5EA6\u4EE3\u7801\u5BA1\u67E5 (/review)",
+    "5. \u67E5\u770B\u6781\u5BA2\u6280\u5DE7\u901F\u67E5 (/tips)",
+    "6. \u5207\u6362\u4E2D\u6587\u5DE5\u7A0B\u63D0\u793A\u8BCD\u5F00\u5173 (Toggle Chinese Prompt)",
+    "7. \u63A2\u6D4B\u7F51\u7EDC\u5EF6\u8FDF (Ping API)",
+    "8. \u67E5\u8BE2\u7528\u91CF\u4E0E\u5230\u671F\u65F6\u95F4 (Account Info)",
+  ]);
+
+  if (!choice) return;
+
+  if (choice.startsWith("1")) {
+    await handleModelSwitch(pi, ctx);
+  } else if (choice.startsWith("2")) {
+    await handleUndoCommand(ctx, undoStack, refreshStatus);
+  } else if (choice.startsWith("3")) {
+    await handleCommitCommand(pi, ctx, "");
+  } else if (choice.startsWith("4")) {
+    await handleReviewCommand(pi, ctx, "");
+  } else if (choice.startsWith("5")) {
+    await ctx.ui.select(
+      "Monk-Pi \u5B9E\u7528\u6781\u5BA2\u6280\u5DE7\u6E05\u5355:",
+      PRO_TIPS.map((t, i) => \`\${i + 1}. \${t}\`)
+    );
+  } else if (choice.startsWith("6")) {
+    const nowEnabled = toggleCnPrompt();
+    const state = nowEnabled ? "\u5DF2\u542F\u7528 (\u96F6\u5E9F\u8BDD\xB7\u884C\u52A8\u4F18\u5148)" : "\u5DF2\u5173\u95ED (\u6062\u590D\u539F\u751F)";
+    ctx.ui.notify(\`\u4E2D\u6587\u5DE5\u7A0B\u7CFB\u7EDF\u63D0\u793A\u8BCD: \${state}\`, "info");
+  } else if (choice.startsWith("7")) {
+    await handlePing(ctx);
+  } else if (choice.startsWith("8")) {
+    ctx.ui.notify("\u8BF7\u5728\u6D4F\u89C8\u5668\u6253\u5F00 https://monk.party/account/ \u67E5\u770B\u7528\u91CF\u4E0E\u5269\u4F59\u5929\u6570", "info");
+  }
+}
+`;
+
+// src/config.ts
+function loadMonkConfig() {
+  const configFile = getMonkConfigFile();
+  try {
+    if (fs.existsSync(configFile)) {
+      const content = fs.readFileSync(configFile, "utf-8");
+      return JSON.parse(content);
+    }
+  } catch {
+  }
+  return {};
+}
+function saveMonkConfig(config) {
+  const homeDir = getMonkHomeDir();
+  if (!fs.existsSync(homeDir)) {
+    fs.mkdirSync(homeDir, { recursive: true });
+  }
+  const configFile = getMonkConfigFile();
+  const existing = loadMonkConfig();
+  const merged = { ...existing, ...config };
+  fs.writeFileSync(configFile, JSON.stringify(merged, null, 2), "utf-8");
+}
+function resolveApiKey() {
+  const envKey = process.env.MONK_API_KEY?.trim();
+  if (envKey) {
+    return { key: envKey, source: "env" };
+  }
+  const localConfig = loadMonkConfig();
+  if (localConfig.apiKey?.trim()) {
+    return { key: localConfig.apiKey.trim(), source: "local" };
+  }
+  const piModelsFile = getPiModelsFile();
+  try {
+    if (fs.existsSync(piModelsFile)) {
+      const data = JSON.parse(fs.readFileSync(piModelsFile, "utf-8"));
+      const key = data?.providers?.monk?.apiKey;
+      if (typeof key === "string" && key.trim() && !key.startsWith("$")) {
+        return { key: key.trim(), source: "pi" };
+      }
+    }
+  } catch {
+  }
+  return { key: "", source: "none" };
+}
+function syncPiModelsJson(apiKey) {
+  const piDir = getPiHomeDir();
+  const piModelsFile = getPiModelsFile();
+  try {
+    if (!fs.existsSync(piDir)) {
+      fs.mkdirSync(piDir, { recursive: true });
+    }
+    let modelsData = { providers: {} };
+    if (fs.existsSync(piModelsFile)) {
+      const raw = fs.readFileSync(piModelsFile, "utf-8");
+      try {
+        modelsData = JSON.parse(raw);
+        if (!modelsData.providers) {
+          modelsData.providers = {};
+        }
+      } catch {
+        modelsData = { providers: {} };
+      }
+    }
+    const monkProviderConfig = {
+      name: "Monk",
+      baseUrl: MONK_BASE_URL,
+      api: "openai-completions",
+      apiKey: apiKey && !apiKey.startsWith("$") ? apiKey : "$MONK_API_KEY",
+      compat: {
+        supportsDeveloperRole: false,
+        maxTokensField: "max_tokens",
+        requiresToolResultName: true
+      },
+      models: MONK_MODELS.map((m) => ({
+        id: m.id,
+        name: m.name,
+        reasoning: m.reasoning,
+        input: ["text"],
+        contextWindow: m.contextWindow,
+        maxTokens: m.maxTokens,
+        cost: {
+          input: 0,
+          output: 0,
+          cacheRead: 0,
+          cacheWrite: 0
+        }
+      }))
+    };
+    modelsData.providers.monk = monkProviderConfig;
+    fs.writeFileSync(piModelsFile, JSON.stringify(modelsData, null, 2), "utf-8");
+    return { success: true, path: piModelsFile };
+  } catch (err) {
+    return {
+      success: false,
+      path: piModelsFile,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+function syncPiExtension(force = false) {
+  const extDir = getPiExtensionsDir();
+  const extFile = getPiMonkExtensionFile();
+  try {
+    if (!fs.existsSync(extDir)) {
+      fs.mkdirSync(extDir, { recursive: true });
+    }
+    const targetContent = MONK_EXTENSION_CODE.trim() + "\n";
+    if (fs.existsSync(extFile)) {
+      const existing = fs.readFileSync(extFile, "utf-8");
+      if (existing === targetContent && !force) {
+        return { success: true, path: extFile, updated: false };
+      }
+    }
+    fs.writeFileSync(extFile, targetContent, "utf-8");
+    return { success: true, path: extFile, updated: true };
+  } catch (err) {
+    return {
+      success: false,
+      path: extFile,
+      updated: false,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+function getDefaultModel() {
+  const config = loadMonkConfig();
+  if (config.defaultModel && MONK_MODELS.some((m) => m.id === config.defaultModel)) {
+    return config.defaultModel;
+  }
+  return DEFAULT_MONK_MODEL;
+}
+
+// src/monk-api.ts
+async function validateApiKey(apiKey, baseUrl = MONK_BASE_URL) {
+  const trimmedKey = apiKey.trim();
+  if (!trimmedKey) {
+    return {
+      valid: false,
+      latencyMs: 0,
+      models: [],
+      error: "API Key \u4E0D\u80FD\u4E3A\u7A7A"
+    };
+  }
+  const endpoint = `${baseUrl.replace(/\/+$/, "")}/models`;
+  const startTime = Date.now();
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 8e3);
+    const response = await fetch(endpoint, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${trimmedKey}`,
+        Accept: "application/json"
+      },
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    const latencyMs = Date.now() - startTime;
+    if (response.status === 401 || response.status === 403) {
+      const body = await response.json().catch(() => ({}));
+      return {
+        valid: false,
+        latencyMs,
+        models: [],
+        statusCode: response.status,
+        error: body.error?.message || "API Key \u65E0\u6548\u6216\u5DF2\u8FC7\u671F\uFF0C\u8BF7\u68C0\u67E5 monk.party \u7684\u8BA2\u9605\u51ED\u8BC1"
+      };
+    }
+    if (!response.ok) {
+      return {
+        valid: false,
+        latencyMs,
+        models: [],
+        statusCode: response.status,
+        error: `Monk API \u54CD\u5E94\u5F02\u5E38 (HTTP ${response.status})`
+      };
+    }
+    const data = await response.json().catch(() => ({}));
+    const models = Array.isArray(data.data) ? data.data.map((m) => m.id) : [];
+    return {
+      valid: true,
+      latencyMs,
+      models,
+      statusCode: response.status
+    };
+  } catch (err) {
+    const latencyMs = Date.now() - startTime;
+    const isAbort = err instanceof Error && err.name === "AbortError";
+    return {
+      valid: false,
+      latencyMs,
+      models: [],
+      error: isAbort ? "\u8FDE\u63A5 Monk \u670D\u52A1\u8D85\u65F6\uFF08\u8D85\u8FC7 8 \u79D2\uFF09\uFF0C\u8BF7\u68C0\u67E5\u7F51\u7EDC\u8FDE\u63A5" : `\u7F51\u7EDC\u8FDE\u63A5\u5931\u8D25: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+}
+async function testChatCompletion(apiKey, model = "monk-fast", baseUrl = MONK_BASE_URL) {
+  const endpoint = `${baseUrl.replace(/\/+$/, "")}/chat/completions`;
+  const startTime = Date.now();
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 12e3);
+    const response = await fetch(endpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey.trim()}`
+      },
+      body: JSON.stringify({
+        model,
+        messages: [{ role: "user", content: "pong" }],
+        max_tokens: 10,
+        temperature: 0.1
+      }),
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    const latencyMs = Date.now() - startTime;
+    if (!response.ok) {
+      const errJson = await response.json().catch(() => ({}));
+      return {
+        success: false,
+        latencyMs,
+        error: errJson.error?.message || `HTTP ${response.status}`
+      };
+    }
+    const json = await response.json().catch(() => ({}));
+    const reply = json.choices?.[0]?.message?.content?.trim() || "";
+    return {
+      success: true,
+      latencyMs,
+      reply
+    };
+  } catch (err) {
+    const latencyMs = Date.now() - startTime;
+    return {
+      success: false,
+      latencyMs,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+
+// src/ui.ts
+import spawn from "cross-spawn";
+import pc from "picocolors";
+import { password, select, confirm } from "@inquirer/prompts";
+function openBrowser(url) {
+  try {
+    if (process.platform === "darwin") {
+      spawn("open", [url], { stdio: "ignore", detached: true });
+      return true;
+    }
+    if (process.platform === "win32") {
+      spawn("cmd", ["/c", "start", "", url], { stdio: "ignore", detached: true });
+      return true;
+    }
+    spawn("xdg-open", [url], { stdio: "ignore", detached: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function printBanner() {
+  const line = pc.dim("\u2500".repeat(54));
+  console.log();
+  console.log(pc.bold(pc.yellow("  \u2588\u2580\u2584\u2580\u2588 \u2588\u2580\u2588 \u2588\u2584\u2591\u2588 \u2588\u2584\u2580") + "   \u2715   " + pc.cyan("\u2588\u2580\u2588 \u2588")));
+  console.log(pc.bold(pc.yellow("  \u2588\u2591\u2580\u2591\u2588 \u2588\u2584\u2588 \u2588\u2591\u2580\u2588 \u2588\u2591\u2588") + "       " + pc.cyan("\u2588\u2580\u2580 \u2588")));
+  console.log(line);
+  console.log(
+    `  ${pc.bold("Monk \xD7 Pi Harness")} ${pc.dim("\xB7")} ${pc.green("OpenAI-Compatible Fusion Agent")}`
+  );
+  console.log(
+    `  ${pc.dim("\u6A21\u578B:")} ${pc.yellow("monk-coding")} ${pc.dim("|")} ${pc.cyan("monk-fast")} ${pc.dim("|")} ${pc.magenta("monk")}`
+  );
+  console.log(line);
+  console.log();
+}
+function logSuccess(msg) {
+  console.log(`  ${pc.green("\u2714")} ${msg}`);
+}
+function logInfo(msg) {
+  console.log(`  ${pc.cyan("\u2139")} ${msg}`);
+}
+function logWarn(msg) {
+  console.log(`  ${pc.yellow("\u25B2")} ${msg}`);
+}
+function logError(msg) {
+  console.log(`  ${pc.red("\u2716")} ${msg}`);
+}
+function logStep(step, total, msg) {
+  console.log(`  ${pc.dim(`[${step}/${total}]`)} ${pc.bold(msg)}`);
+}
+async function promptForApiKey(currentKey) {
+  console.log();
+  console.log(`  ${pc.bold("\u6B22\u8FCE\u4F7F\u7528 Monk \xD7 Pi \u7F16\u7801\u4F34\u4FA3\uFF01")}`);
+  console.log(
+    `  ${pc.dim("Monk \u4E13\u4E3A Agent \u63D0\u4F9B\u6781\u901F\u9AD8\u541E\u5410\u878D\u5408\u6A21\u578B (\u6708\u5361 \xA530 / 100\u4E07 Token \u4E0A\u4E0B\u6587)")}`
+  );
+  console.log();
+  if (!currentKey) {
+    const action = await select({
+      message: "\u8BF7\u9009\u62E9\u914D\u7F6E\u6216\u83B7\u53D6 Monk API Key \u7684\u65B9\u5F0F:",
+      choices: [
+        {
+          name: `1. \u6211\u5DF2\u6709 API Key\uFF0C\u76F4\u63A5\u7C98\u8D34\u8F93\u5165 ${pc.dim("(sk-monk-...)")}`,
+          value: "input"
+        },
+        {
+          name: `2. \u6211\u8FD8\u6CA1\u6709 Key\uFF0C\u7ACB\u5373\u6253\u5F00 monk.party \u8BA2\u9605 ${pc.green("(\u63A8\u8350 \xB7 \u56DE\u8F66\u6D4F\u89C8\u5668\u626B\u7801)")}`,
+          value: "open_browser"
+        }
+      ]
+    });
+    if (action === "open_browser") {
+      logInfo(`\u6B63\u5728\u4E3A\u60A8\u5728\u9ED8\u8BA4\u6D4F\u89C8\u5668\u6253\u5F00\u5B98\u7F51: ${pc.cyan(MONK_WEBSITE)} ...`);
+      openBrowser(MONK_WEBSITE);
+      console.log();
+      logSuccess("\u5DF2\u5524\u8D77\u6D4F\u89C8\u5668\uFF01\u8BF7\u5728\u7F51\u9875\u5B8C\u6210\u8BA2\u9605\u540E\uFF0C\u5C06\u751F\u6210\u7684 sk-monk-... Key \u590D\u5236\u5E76\u7C98\u8D34\u5230\u4E0B\u65B9\uFF1A");
+      console.log();
+    }
+  } else {
+    const action = await select({
+      message: `\u68C0\u6D4B\u5230\u5DF2\u914D\u7F6E Key (${maskKey(currentKey)})\uFF0C\u8BF7\u9009\u62E9\u64CD\u4F5C:`,
+      choices: [
+        {
+          name: "1. \u4FDD\u6301\u5E76\u6D4B\u8BD5\u5F53\u524D Key",
+          value: "keep"
+        },
+        {
+          name: "2. \u66F4\u6362\u4E3A\u65B0\u7684 API Key",
+          value: "replace"
+        },
+        {
+          name: `3. \u5728\u6D4F\u89C8\u5668\u6253\u5F00 monk.party \u5B98\u7F51 (\u67E5\u8BE2/\u7EED\u8D39)`,
+          value: "open_browser"
+        }
+      ]
+    });
+    if (action === "keep") {
+      return currentKey;
+    }
+    if (action === "open_browser") {
+      logInfo(`\u6B63\u5728\u4E3A\u60A8\u5728\u6D4F\u89C8\u5668\u6253\u5F00\u5B98\u7F51: ${pc.cyan(MONK_ACCOUNT_URL)} ...`);
+      openBrowser(MONK_ACCOUNT_URL);
+      console.log();
+      logInfo("\u5DF2\u6253\u5F00\u67E5\u8BE2\u9875\u9762\u3002\u5982\u9700\u66F4\u6362 Key \u8BF7\u5728\u4E0B\u65B9\u7C98\u8D34\uFF0C\u76F4\u63A5\u56DE\u8F66\u4FDD\u6301\u5F53\u524D Key\uFF1A");
+      console.log();
+    }
+  }
+  const key = await password({
+    message: currentKey ? `\u8BF7\u8F93\u5165 Monk API Key (\u76F4\u63A5\u56DE\u8F66\u4FDD\u6301\u5F53\u524D: ${maskKey(currentKey)}):` : "\u8BF7\u7C98\u8D34\u60A8\u7684 Monk API Key (sk-monk-...):",
+    mask: "*",
+    validate: (val) => {
+      const trimmed = val.trim();
+      if (!trimmed && currentKey) return true;
+      if (!trimmed) return "API Key \u4E0D\u80FD\u4E3A\u7A7A";
+      if (!trimmed.startsWith("sk-")) {
+        return "Key \u683C\u5F0F\u901A\u5E38\u4EE5 sk- \u5F00\u5934\uFF0C\u8BF7\u786E\u8BA4\u590D\u5236\u5B8C\u6574";
+      }
+      return true;
+    }
+  });
+  const finalKey = key.trim() || currentKey || "";
+  return finalKey;
+}
+async function promptSelectModel(currentModel) {
+  const choices = MONK_MODELS.map((m) => ({
+    name: `${m.name.padEnd(28)} ${pc.dim(m.description)}`,
+    value: m.id,
+    description: m.description
+  }));
+  const selected = await select({
+    message: "\u8BF7\u9009\u62E9\u9ED8\u8BA4\u4E3B\u529B\u6A21\u578B:",
+    choices,
+    default: currentModel || "monk-coding"
+  });
+  return selected;
+}
+async function promptInstallPi() {
+  logWarn("\u672A\u68C0\u6D4B\u5230\u5168\u5C40\u5B89\u88C5\u7684 pi \u7F16\u7801\u52A9\u624B (@earendil-works/pi-coding-agent)\u3002");
+  console.log(`  ${pc.dim("Monk Harness \u4F9D\u8D56 Pi \u4F5C\u4E3A\u5E95\u5C42 TUI/Agent \u8FD0\u884C\u65F6\u3002")}`);
+  console.log();
+  return await confirm({
+    message: "\u662F\u5426\u7ACB\u5373\u4F7F\u7528 npm \u5168\u5C40\u5B89\u88C5 @earendil-works/pi-coding-agent\uFF1F",
+    default: true
+  });
+}
+function maskKey(key) {
+  if (!key || key.length < 10) return "******";
+  return `${key.slice(0, 7)}...${key.slice(-4)}`;
+}
+
+// src/pi-runner.ts
+import fs2 from "fs";
+import path2 from "path";
+import { fileURLToPath } from "url";
+import spawn2 from "cross-spawn";
+import pc2 from "picocolors";
+function resolvePiBinary() {
+  try {
+    const globalCheck = spawn2.sync("pi", ["--version"], {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    if (globalCheck.status === 0 && globalCheck.stdout) {
+      return {
+        type: "global",
+        command: "pi",
+        argsPrefix: [],
+        version: globalCheck.stdout.trim(),
+        sourceDescription: "\u7CFB\u7EDF\u5168\u5C40\u547D\u4EE4 (PATH)"
+      };
+    }
+  } catch {
+  }
+  const candidateBinDirs = [
+    path2.resolve(path2.dirname(fileURLToPath(import.meta.url)), "../node_modules/.bin/pi"),
+    path2.resolve(process.cwd(), "node_modules/.bin/pi")
+  ];
+  for (const binPath of candidateBinDirs) {
+    if (fs2.existsSync(binPath)) {
+      try {
+        const localCheck = spawn2.sync(binPath, ["--version"], {
+          encoding: "utf-8",
+          stdio: ["ignore", "pipe", "ignore"]
+        });
+        if (localCheck.status === 0 && localCheck.stdout) {
+          return {
+            type: "local",
+            command: binPath,
+            argsPrefix: [],
+            version: localCheck.stdout.trim(),
+            sourceDescription: `\u672C\u5730\u4F9D\u8D56 (${path2.basename(path2.dirname(binPath))})`
+          };
+        }
+      } catch {
+      }
+    }
+  }
+  try {
+    const mainEntry = fileURLToPath(import.meta.resolve("@earendil-works/pi-coding-agent"));
+    const cliEntry = path2.join(path2.dirname(mainEntry), "bundle", "cli.js");
+    if (fs2.existsSync(cliEntry)) {
+      const moduleCheck = spawn2.sync(process.execPath, [cliEntry, "--version"], {
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "ignore"]
+      });
+      if (moduleCheck.status === 0 && moduleCheck.stdout) {
+        return {
+          type: "bundled",
+          command: process.execPath,
+          argsPrefix: [cliEntry],
+          version: moduleCheck.stdout.trim(),
+          sourceDescription: "Monk-Pi \u5185\u5D4C\u6838\u5FC3 (\u514D\u5B89\u88C5\u8FD0\u884C)"
+        };
+      }
+    }
+  } catch {
+  }
+  return {
+    type: "missing",
+    command: "",
+    argsPrefix: [],
+    sourceDescription: "\u672A\u68C0\u6D4B\u5230\u53EF\u7528\u7684 Pi \u6838\u5FC3"
+  };
+}
+function detectPi() {
+  const resolved = resolvePiBinary();
+  return {
+    installed: resolved.type !== "missing",
+    version: resolved.version,
+    type: resolved.type,
+    description: resolved.sourceDescription
+  };
+}
+function detectPackageManager() {
+  try {
+    const bunCheck = spawn2.sync("bun", ["--version"], { stdio: "ignore" });
+    if (bunCheck.status === 0) return "bun";
+  } catch {
+  }
+  try {
+    const pnpmCheck = spawn2.sync("pnpm", ["--version"], { stdio: "ignore" });
+    if (pnpmCheck.status === 0) return "pnpm";
+  } catch {
+  }
+  return "npm";
+}
+async function installPi() {
+  const pm = detectPackageManager();
+  let cmd = "npm";
+  let args = ["install", "-g", "@earendil-works/pi-coding-agent"];
+  if (pm === "bun") {
+    cmd = "bun";
+    args = ["add", "-g", "@earendil-works/pi-coding-agent"];
+  } else if (pm === "pnpm") {
+    cmd = "pnpm";
+    args = ["add", "-g", "@earendil-works/pi-coding-agent"];
+  }
+  logInfo(`\u68C0\u6D4B\u5230\u5305\u7BA1\u7406\u5668: ${pc2.bold(pm)}\uFF0C\u6B63\u5728\u6267\u884C: ${pc2.yellow(`${cmd} ${args.join(" ")}`)} ...`);
+  try {
+    const child = spawn2.sync(cmd, args, {
+      stdio: "inherit"
+    });
+    if (child.status === 0) {
+      logSuccess("Pi \u6838\u5FC3\u5957\u4EF6\u5B89\u88C5\u6210\u529F\uFF01");
+      return true;
+    }
+    logError(`\u5B89\u88C5\u5931\u8D25\uFF0C\u9000\u51FA\u7801: ${child.status}`);
+    logWarn(`\u82E5\u56E0\u6743\u9650\u95EE\u9898 (EACCES) \u5931\u8D25\uFF0C\u8BF7\u5C1D\u8BD5:`);
+    console.log(`    ${pc2.cyan(`sudo ${cmd} ${args.join(" ")}`)}`);
+    console.log(`    \u6216\u76F4\u63A5\u4F7F\u7528\u514D\u5B89\u88C5\u65B9\u6848: ${pc2.cyan("npx monk-pi")}`);
+    return false;
+  } catch (err) {
+    logError(`\u6267\u884C\u5B89\u88C5\u5F02\u5E38: ${err instanceof Error ? err.message : String(err)}`);
+    return false;
+  }
+}
+function launchPi(options) {
+  const resolved = resolvePiBinary();
+  if (resolved.type === "missing") {
+    logError("\u672A\u627E\u5230\u53EF\u7528\u7684 Pi \u6838\u5FC3\u8FD0\u884C\u73AF\u5883\u3002");
+    return 1;
+  }
+  const { apiKey, defaultModel, passthroughArgs } = options;
+  const extraArgs = [];
+  const hasProvider = passthroughArgs.includes("--provider");
+  const hasModel = passthroughArgs.some((arg, idx) => {
+    return arg === "--model" || arg === "-m" || passthroughArgs[idx - 1] === "--model";
+  });
+  if (!hasProvider && !hasModel) {
+    extraArgs.push("--provider", "monk", "--model", defaultModel);
+  } else if (!hasProvider && hasModel) {
+    extraArgs.push("--provider", "monk");
+  }
+  const fullArgs = [...resolved.argsPrefix, ...extraArgs, ...passthroughArgs];
+  const env = {
+    ...process.env,
+    MONK_API_KEY: apiKey
+  };
+  const child = spawn2(resolved.command, fullArgs, {
+    stdio: "inherit",
+    env
+  });
+  const forwardSignal = (signal) => {
+    try {
+      child.kill(signal);
+    } catch {
+    }
+  };
+  process.on("SIGINT", () => forwardSignal("SIGINT"));
+  process.on("SIGTERM", () => forwardSignal("SIGTERM"));
+  return new Promise((resolve) => {
+    child.on("close", (code) => {
+      resolve(code ?? 0);
+    });
+    child.on("error", (err) => {
+      logError(`\u542F\u52A8 Pi \u53D1\u751F\u9519\u8BEF: ${err.message}`);
+      resolve(1);
+    });
+  });
+}
+
+// src/commands/doctor.ts
+import fs3 from "fs";
+import os2 from "os";
+import pc3 from "picocolors";
+async function doctorCommand() {
+  printBanner();
+  console.log(`  ${pc3.bold("\u3010Monk \xD7 Pi \u73AF\u5883\u8BCA\u65AD (Doctor)\u3011")}`);
+  console.log();
+  let hasIssue = false;
+  const nodeVersion = process.version;
+  const major = parseInt(nodeVersion.slice(1).split(".")[0], 10);
+  if (major >= 18) {
+    logSuccess(`Node.js \u7248\u672C: ${pc3.bold(nodeVersion)} (\u6EE1\u8DB3 >= 18 \u8981\u6C42)`);
+  } else {
+    hasIssue = true;
+    logError(`Node.js \u7248\u672C: ${pc3.bold(nodeVersion)} (\u8FC7\u4F4E\uFF0C\u8BF7\u5347\u7EA7\u5230 Node 18+)`);
+  }
+  logInfo(`\u64CD\u4F5C\u7CFB\u7EDF: ${os2.type()} ${os2.release()} (${os2.arch()})`);
+  const pi = detectPi();
+  if (pi.installed) {
+    logSuccess(
+      `Pi \u6838\u5FC3\u5957\u4EF6: ${pc3.bold(`\u5DF2\u5C31\u7EEA (v${pi.version})`)} \xB7 ${pc3.dim(`[\u6765\u6E90: ${pi.description}]`)}`
+    );
+  } else {
+    hasIssue = true;
+    logError(`Pi \u6838\u5FC3\u5957\u4EF6: ${pc3.bold("\u672A\u627E\u5230\u53EF\u7528\u8FD0\u884C\u65F6")}`);
+    console.log(`    ${pc3.dim("\u89E3\u51B3\u529E\u6CD5: \u8FD0\u884C npm install -g @earendil-works/pi-coding-agent")}`);
+  }
+  const { key, source } = resolveApiKey();
+  if (key) {
+    logSuccess(`Monk API Key: ${pc3.bold(maskKey(key))} (\u6765\u6E90: ${source})`);
+  } else {
+    hasIssue = true;
+    logError(`Monk API Key: \u672A\u914D\u7F6E`);
+    console.log(`    ${pc3.dim("\u89E3\u51B3\u529E\u6CD5: \u8FD0\u884C monk-pi login")}`);
+  }
+  const modelsFile = getPiModelsFile();
+  if (fs3.existsSync(modelsFile)) {
+    try {
+      const data = JSON.parse(fs3.readFileSync(modelsFile, "utf-8"));
+      const monk = data?.providers?.monk;
+      if (monk) {
+        const hasCompat = monk.compat?.supportsDeveloperRole === false && monk.compat?.maxTokensField === "max_tokens";
+        if (hasCompat) {
+          logSuccess(`Pi \u914D\u7F6E\u6587\u4EF6: ${pc3.bold("\u5DF2\u914D\u7F6E Monk \u4E13\u5C5E\u4F18\u5316\u517C\u5BB9\u53C2\u6570")}`);
+        } else {
+          logWarn(`Pi \u914D\u7F6E\u6587\u4EF6: \u5B58\u5728 Monk \u914D\u7F6E\uFF0C\u4F46\u7F3A\u5C11\u6700\u4F73 compat \u53C2\u6570`);
+          console.log(`    ${pc3.dim("\u6B63\u5728\u4E3A\u60A8\u81EA\u52A8\u7EA0\u6B63...")}`);
+          syncPiModelsJson(key);
+          logSuccess(`Pi \u914D\u7F6E\u6587\u4EF6: \u5DF2\u81EA\u52A8\u4FEE\u590D\u4F18\u5316`);
+        }
+      } else {
+        logWarn(`Pi \u914D\u7F6E\u6587\u4EF6: \u5C1A\u672A\u6CE8\u5165 Monk \u4F9B\u5E94\u5546`);
+        syncPiModelsJson(key);
+        logSuccess(`Pi \u914D\u7F6E\u6587\u4EF6: \u5DF2\u6210\u529F\u81EA\u52A8\u6CE8\u5165`);
+      }
+    } catch {
+      logError(`Pi \u914D\u7F6E\u6587\u4EF6: ${modelsFile} \u5B58\u5728\u8BED\u6CD5\u9519\u8BEF`);
+    }
+  } else {
+    logWarn(`Pi \u914D\u7F6E\u6587\u4EF6: \u5C1A\u672A\u521B\u5EFA\uFF0C\u6B63\u5728\u4E3A\u60A8\u81EA\u52A8\u521B\u5EFA...`);
+    syncPiModelsJson(key);
+    logSuccess(`Pi \u914D\u7F6E\u6587\u4EF6: \u521B\u5EFA\u5B8C\u6210`);
+  }
+  const extRes = syncPiExtension();
+  if (extRes.success) {
+    if (extRes.updated) {
+      logSuccess(
+        `Pi \u539F\u751F\u6269\u5C55: ${pc3.bold("\u5DF2\u81EA\u52A8\u66F4\u65B0\u81F3\u6700\u65B0\u7248")} (\u4E2D\u6587\u5DE5\u7A0B\u63D0\u793A\u8BCD\u3001/monk \u6307\u4EE4\u4E0E\u81EA\u52A8\u91CD\u8BD5\u5C31\u7EEA)`
+      );
+    } else {
+      logSuccess(
+        `Pi \u539F\u751F\u6269\u5C55: ${pc3.bold("\u5DF2\u5C31\u7EEA")} (\u4E2D\u6587\u5DE5\u7A0B\u63D0\u793A\u8BCD\u3001/monk \u6307\u4EE4\u4E0E\u81EA\u52A8\u91CD\u8BD5\u5C31\u7EEA)`
+      );
+    }
+  } else {
+    logError(`Pi \u539F\u751F\u6269\u5C55\u90E8\u7F72\u5931\u8D25: ${extRes.error}`);
+  }
+  if (key) {
+    process.stdout.write(`  ${pc3.dim("\u23F3 \u6B63\u5728\u63A2\u6D4B\u4E0E monk.party \u63A5\u53E3\u7684\u8FDE\u901A\u6027...")} `);
+    const val = await validateApiKey(key);
+    process.stdout.write("\r" + " ".repeat(50) + "\r");
+    if (val.valid) {
+      logSuccess(`Monk \u8FDE\u901A\u6027: ${pc3.green("\u4F18\u79C0")} \xB7 \u5EF6\u8FDF ${val.latencyMs}ms`);
+    } else {
+      hasIssue = true;
+      logError(`Monk \u8FDE\u901A\u6027\u5F02\u5E38: ${val.error}`);
+    }
+  }
+  console.log();
+  console.log(pc3.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  if (hasIssue) {
+    logWarn("\u68C0\u6D4B\u5230\u73AF\u5883\u5B58\u5728\u90E8\u5206\u95EE\u9898\uFF0C\u8BF7\u53C2\u8003\u4E0A\u65B9\u63D0\u793A\u5904\u7406\u3002");
+  } else {
+    logSuccess(pc3.bold("\u592A\u68D2\u4E86\uFF01\u6240\u6709\u68C0\u67E5\u9879\u5168\u90E8\u901A\u8FC7\uFF0C\u73AF\u5883\u5904\u4E8E\u6700\u4F73\u72B6\u6001\u3002"));
+  }
+  console.log();
+}
+
+// src/commands/login.ts
+import pc4 from "picocolors";
+async function loginCommand() {
+  printBanner();
+  const current = resolveApiKey();
+  const apiKey = await promptForApiKey(current.key || void 0);
+  if (!apiKey) {
+    logWarn("\u672A\u8F93\u5165 API Key\uFF0C\u64CD\u4F5C\u5DF2\u53D6\u6D88\u3002");
+    return false;
+  }
+  logInfo("\u6B63\u5728\u8FDE\u63A5 Monk API \u9A8C\u8BC1\u5BC6\u94A5...");
+  const result = await validateApiKey(apiKey);
+  if (!result.valid) {
+    logError(`\u9A8C\u8BC1\u5931\u8D25: ${result.error || "\u672A\u77E5\u9519\u8BEF"}`);
+    logWarn("\u8BF7\u6838\u5BF9\u540E\u91CD\u65B0\u8FD0\u884C `monk-pi login`\u3002");
+    return false;
+  }
+  logSuccess(`\u9A8C\u8BC1\u901A\u8FC7\uFF01\u7F51\u7EDC\u5EF6\u8FDF: ${pc4.green(`${result.latencyMs}ms`)}`);
+  if (result.models.length > 0) {
+    logInfo(`\u53EF\u7528\u6A21\u578B: ${pc4.yellow(result.models.join(", "))}`);
+  }
+  saveMonkConfig({
+    apiKey,
+    lastVerified: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  logSuccess(`\u51ED\u8BC1\u5DF2\u4FDD\u5B58\u81F3\u672C\u5730\u914D\u7F6E`);
+  const syncResult = syncPiModelsJson(apiKey);
+  const extResult = syncPiExtension();
+  if (syncResult.success) {
+    logSuccess(`\u5DF2\u6210\u529F\u540C\u6B65\u5E76\u4F18\u5316 Pi \u914D\u7F6E\u6587\u4EF6: ${pc4.dim(syncResult.path)}`);
+  } else {
+    logWarn(`\u540C\u6B65 Pi \u914D\u7F6E\u6587\u4EF6\u5931\u8D25: ${syncResult.error}`);
+  }
+  if (extResult.success) {
+    logSuccess(`\u5DF2\u5B89\u88C5 Monk \u539F\u751F TUI \u6269\u5C55: ${pc4.dim(extResult.path)}`);
+  }
+  console.log();
+  logSuccess(`Monk \xD7 Pi \u5C31\u7EEA\uFF01\u73B0\u5728\u60A8\u53EF\u4EE5\u76F4\u63A5\u8F93\u5165 ${pc4.bold(pc4.yellow("monk-pi"))} \u5F00\u59CB\u7F16\u7801\u3002`);
+  console.log();
+  return true;
+}
+
+// src/commands/model.ts
+import pc5 from "picocolors";
+async function modelCommand(targetModel) {
+  printBanner();
+  const currentModel = getDefaultModel();
+  if (targetModel) {
+    const matched2 = MONK_MODELS.find(
+      (m) => m.id === targetModel || m.id.endsWith(targetModel)
+    );
+    if (!matched2) {
+      logWarn(`\u672A\u77E5\u6A21\u578B: "${targetModel}"`);
+      logInfo(`\u652F\u6301\u7684\u6A21\u578B\u5217\u8868: ${MONK_MODELS.map((m) => m.id).join(", ")}`);
+      return;
+    }
+    saveMonkConfig({ defaultModel: matched2.id });
+    logSuccess(`\u9ED8\u8BA4\u4E3B\u529B\u6A21\u578B\u5DF2\u5207\u6362\u4E3A: ${pc5.bold(pc5.yellow(matched2.name))}`);
+    return;
+  }
+  const selected = await promptSelectModel(currentModel);
+  saveMonkConfig({ defaultModel: selected });
+  const matched = MONK_MODELS.find((m) => m.id === selected);
+  console.log();
+  logSuccess(`\u9ED8\u8BA4\u4E3B\u529B\u6A21\u578B\u5DF2\u6210\u529F\u8BBE\u5B9A\u4E3A: ${pc5.bold(pc5.yellow(matched?.name || selected))}`);
+  console.log();
+}
+
+// src/commands/run.ts
+import pc6 from "picocolors";
+
+// src/extension/monk-extension.ts
+import fs4 from "fs";
+import path3 from "path";
+var PRO_TIPS = [
+  "\u5728\u8F93\u5165\u6846\u8F93\u5165 @diff \u5373\u53EF\u79D2\u7EA7\u628A\u5F53\u524D\u672A\u63D0\u4EA4\u6539\u52A8\u5E26\u5165\u5206\u6790",
+  "\u8F93\u5165 /commit \u53EF\u6309 Conventional Commits \u89C4\u8303\u81EA\u52A8\u751F\u6210\u4E2D\u6587\u63D0\u4EA4",
+  "AI \u6539\u4E71\u4E86\u4EE3\u7801\u4E0D\u7528\u614C\uFF0C\u968F\u65F6\u8F93\u5165 /undo \u6216 /\u56DE\u9000 \u77AC\u95F4\u4E00\u952E\u590D\u539F",
+  "\u8F93\u5165 /review \u53EF\u4ECE\u7F3A\u9677\u3001\u6027\u80FD\u3001\u67B6\u6784\u56DB\u4E2A\u7EF4\u5EA6\u5BF9\u4EE3\u7801\u8FDB\u884C\u6DF1\u5EA6\u5BA1\u67E5",
+  "\u8F93\u5165 /monk \u53EF\u547C\u51FA\u56FE\u5F62\u5316\u63A7\u5236\u53F0\uFF0C\u79D2\u7EA7\u514D\u91CD\u542F\u5207\u6362\u4E3B\u529B\u6A21\u578B",
+  "\u8F93\u5165 @recent \u5FEB\u901F\u63D0\u53D6\u6700\u8FD1\u53D8\u52A8\u7684\u9879\u76EE\u6838\u5FC3\u6E90\u6587\u4EF6\u5217\u8868",
+  "\u8F93\u5165 /monk cn \u968F\u65F6\u5207\u6362\u4E2D\u6587\u5DE5\u7A0B\u7CBE\u70BC\u6A21\u5F0F\uFF08\u96F6\u5BA2\u5957\xB7\u884C\u52A8\u4F18\u5148\uFF09",
+  "\u7EC8\u7AEF\u8F93\u5165 monk-pi -r \u53EF\u89C6\u5316\u6062\u590D\u4EE5\u5F80\u4EFB\u610F\u5386\u53F2\u4EFB\u52A1\u65AD\u70B9\u7EED\u5199"
+];
+
+// src/commands/run.ts
+async function runCommand(passthroughArgs) {
+  const piCheck = detectPi();
+  if (!piCheck.installed) {
+    const shouldInstall = await promptInstallPi();
+    if (shouldInstall) {
+      const installed = await installPi();
+      if (!installed) {
+        logError("\u65E0\u6CD5\u81EA\u52A8\u5B89\u88C5 Pi\uFF0C\u8BF7\u624B\u52A8\u8FD0\u884C `npm install -g @earendil-works/pi-coding-agent` \u540E\u91CD\u8BD5\u3002");
+        return 1;
+      }
+    } else {
+      logWarn("\u5DF2\u53D6\u6D88\u8FD0\u884C\u3002Monk Harness \u9700\u8981 Pi \u4F5C\u4E3A\u8FD0\u884C\u5E95\u5EA7\u3002");
+      return 1;
+    }
+  }
+  let { key } = resolveApiKey();
+  if (!key) {
+    logWarn("\u672A\u68C0\u6D4B\u5230 Monk API Key\uFF0C\u6B63\u5728\u4E3A\u60A8\u542F\u52A8\u9996\u6B21\u914D\u7F6E\u5F15\u5BFC...");
+    const ok = await loginCommand();
+    if (!ok) {
+      return 1;
+    }
+    const resolved = resolveApiKey();
+    key = resolved.key;
+  }
+  if (!key) {
+    logError("\u672A\u627E\u5230\u6709\u6548\u7684 Monk API Key\uFF0C\u9000\u51FA\u8FD0\u884C\u3002");
+    return 1;
+  }
+  syncPiModelsJson(key);
+  syncPiExtension();
+  const defaultModel = getDefaultModel();
+  if (!passthroughArgs.includes("-p") && !passthroughArgs.includes("--print")) {
+    const tip = PRO_TIPS[Math.floor(Math.random() * PRO_TIPS.length)];
+    console.log(`  ${pc6.yellow("\u{1F4A1} \u6781\u5BA2\u5C0F\u8D34\u58EB:")} ${pc6.dim(tip)}`);
+    console.log();
+  }
+  return launchPi({
+    apiKey: key,
+    defaultModel,
+    passthroughArgs
+  });
+}
+
+// src/commands/status.ts
+import pc7 from "picocolors";
+async function statusCommand() {
+  printBanner();
+  console.log(`  ${pc7.bold("\u3010\u670D\u52A1\u4E0E\u73AF\u5883\u72B6\u6001\u68C0\u6D4B\u3011")}`);
+  console.log();
+  const piDetect = detectPi();
+  if (piDetect.installed) {
+    logSuccess(
+      `Pi \u8FD0\u884C\u73AF\u5883: ${pc7.bold("\u5DF2\u5C31\u7EEA")} (v${piDetect.version}) \xB7 ${pc7.dim(`[\u6765\u6E90: ${piDetect.description}]`)}`
+    );
+  } else {
+    logWarn(`Pi \u8FD0\u884C\u73AF\u5883: ${pc7.red("\u672A\u68C0\u6D4B\u5230\u53EF\u7528\u8FD0\u884C\u65F6")}`);
+    console.log(`    ${pc7.dim("\u8BF7\u8FD0\u884C npm install -g @earendil-works/pi-coding-agent")}`);
+  }
+  const { key, source } = resolveApiKey();
+  const defaultModel = getDefaultModel();
+  if (!key) {
+    logError(`Monk API Key: ${pc7.red("\u672A\u914D\u7F6E")}`);
+    console.log(`    ${pc7.dim("\u8BF7\u8FD0\u884C `monk-pi login` \u8F93\u5165\u60A8\u7684 Key")}`);
+    return;
+  }
+  const sourceLabels = {
+    env: "\u73AF\u5883\u53D8\u91CF ($MONK_API_KEY)",
+    local: `\u672C\u5730\u914D\u7F6E (${getMonkConfigFile()})`,
+    pi: `Pi \u914D\u7F6E\u6587\u4EF6 (${getPiModelsFile()})`,
+    none: "\u65E0"
+  };
+  logSuccess(`Monk API Key: ${pc7.bold(maskKey(key))} ${pc7.dim(`[\u6765\u6E90: ${sourceLabels[source]}]`)}`);
+  logInfo(`\u5F53\u524D\u9ED8\u8BA4\u4E3B\u529B\u6A21\u578B: ${pc7.yellow(defaultModel)}`);
+  logInfo(`Monk \u57FA\u7840\u5730\u5740: ${pc7.dim(MONK_BASE_URL)}`);
+  process.stdout.write(`  ${pc7.dim("\u23F3 \u6B63\u5728\u6D4B\u8BD5 Monk API \u8FDE\u63A5\u4E0E\u8BA4\u8BC1...")} `);
+  const valResult = await validateApiKey(key);
+  if (valResult.valid) {
+    process.stdout.write("\r" + " ".repeat(50) + "\r");
+    logSuccess(
+      `Monk API \u8FDE\u63A5\u6B63\u5E38 ${pc7.dim("\xB7")} \u8BA4\u8BC1\u6709\u6548 ${pc7.dim("\xB7")} \u5EF6\u8FDF: ${pc7.green(`${valResult.latencyMs}ms`)}`
+    );
+    if (valResult.models.length > 0) {
+      logInfo(`\u652F\u6301\u7684\u6A21\u578B\u7AEF\u70B9: ${pc7.dim(valResult.models.join(" \xB7 "))}`);
+    }
+  } else {
+    process.stdout.write("\r" + " ".repeat(50) + "\r");
+    logError(`Monk API \u9A8C\u8BC1\u5F02\u5E38: ${valResult.error}`);
+    return;
+  }
+  process.stdout.write(`  ${pc7.dim(`\u23F3 \u6B63\u5728\u5BF9 ${defaultModel} \u53D1\u8D77\u6781\u7B80\u63E1\u624B\u63A8\u6F14...`)} `);
+  const testRes = await testChatCompletion(key, defaultModel);
+  if (testRes.success) {
+    process.stdout.write("\r" + " ".repeat(50) + "\r");
+    logSuccess(
+      `\u63A8\u7406\u901A\u9053\u63E1\u624B\u6210\u529F ${pc7.dim("\xB7")} \u54CD\u5E94\u5EF6\u8FDF: ${pc7.green(`${testRes.latencyMs}ms`)}`
+    );
+  } else {
+    process.stdout.write("\r" + " ".repeat(50) + "\r");
+    logWarn(`\u63A8\u7406\u901A\u9053\u63E1\u624B\u8F7B\u5FAE\u544A\u8B66: ${testRes.error || "\u672A\u8FD4\u56DE\u5E38\u89C4\u5185\u5BB9"}`);
+  }
+  console.log();
+  console.log(pc7.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  console.log(`  ${pc7.dim("\u5B98\u65B9\u7F51\u7AD9:")} ${pc7.cyan(MONK_WEBSITE)}`);
+  console.log(`  ${pc7.dim("\u7528\u91CF\u4E0E\u5230\u671F\u67E5\u8BE2:")} ${pc7.cyan(MONK_ACCOUNT_URL)}`);
+  console.log();
+}
+
+export {
+  MONK_BASE_URL,
+  MONK_WEBSITE,
+  MONK_ACCOUNT_URL,
+  MONK_MODELS,
+  DEFAULT_MONK_MODEL,
+  getMonkHomeDir,
+  getMonkConfigFile,
+  getPiHomeDir,
+  getPiModelsFile,
+  getPiSettingsFile,
+  getPiExtensionsDir,
+  getPiMonkExtensionFile,
+  loadMonkConfig,
+  saveMonkConfig,
+  resolveApiKey,
+  syncPiModelsJson,
+  syncPiExtension,
+  getDefaultModel,
+  validateApiKey,
+  testChatCompletion,
+  openBrowser,
+  printBanner,
+  logSuccess,
+  logInfo,
+  logWarn,
+  logError,
+  logStep,
+  promptForApiKey,
+  promptSelectModel,
+  promptInstallPi,
+  maskKey,
+  resolvePiBinary,
+  detectPi,
+  detectPackageManager,
+  installPi,
+  launchPi,
+  doctorCommand,
+  loginCommand,
+  modelCommand,
+  runCommand,
+  statusCommand
+};