zencode-cli 0.1.0

package/dist/bin/zencode.js

@@ -0,0 +1,4176 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/config/defaults.ts
+var DEFAULT_CONFIG;
+var init_defaults = __esm({
+  "src/config/defaults.ts"() {
+    "use strict";
+    DEFAULT_CONFIG = {
+      model: "deepseek-chat",
+      api_key: "",
+      base_url: "https://api.deepseek.com/v1",
+      temperature: 0.7,
+      max_tokens: 8192,
+      agent_mode: "dual",
+      collaboration: "delegated",
+      dual_agent: {},
+      features: {
+        git: "auto",
+        mcp: "off",
+        planning_layer: "on",
+        parallel_agents: "on",
+        todo: "on"
+      },
+      permissions: {
+        auto_approve: ["read-file", "glob", "grep", "spawn-agents", "todo", "memo"],
+        require_approval: ["write-file", "edit-file", "bash", "git"]
+      },
+      mcp_servers: [],
+      prompts: [],
+      max_tool_output: 3e4
+    };
+  }
+});
+
+// src/config/loader.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { parse as parseYaml } from "yaml";
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    const sourceVal = source[key];
+    const targetVal = target[key];
+    if (sourceVal !== void 0 && sourceVal !== null && typeof sourceVal === "object" && !Array.isArray(sourceVal) && typeof targetVal === "object" && !Array.isArray(targetVal) && targetVal !== null) {
+      result[key] = deepMerge(targetVal, sourceVal);
+    } else if (sourceVal !== void 0) {
+      result[key] = sourceVal;
+    }
+  }
+  return result;
+}
+function loadYamlFile(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, "utf-8");
+    return parseYaml(content) || {};
+  } catch {
+    return {};
+  }
+}
+function loadEnvConfig() {
+  const config = {};
+  if (process.env["ZENCODE_API_KEY"]) {
+    config.api_key = process.env["ZENCODE_API_KEY"];
+  }
+  if (process.env["ZENCODE_MODEL"]) {
+    config.model = process.env["ZENCODE_MODEL"];
+  }
+  if (process.env["ZENCODE_BASE_URL"]) {
+    config.base_url = process.env["ZENCODE_BASE_URL"];
+  }
+  if (process.env["ZENCODE_MODE"]) {
+    const mode = process.env["ZENCODE_MODE"];
+    if (mode === "dual" || mode === "single") {
+      config.agent_mode = mode;
+    }
+  }
+  return config;
+}
+function loadCliConfig(opts) {
+  const config = {};
+  if (opts.model) config.model = opts.model;
+  if (opts.apiKey) config.api_key = opts.apiKey;
+  if (opts.baseUrl) config.base_url = opts.baseUrl;
+  if (opts.single) config.agent_mode = "single";
+  if (opts.dual) config.agent_mode = "dual";
+  if (opts.mode) {
+    const m = opts.mode;
+    if (m === "delegated" || m === "autonomous" || m === "controlled") {
+      config.collaboration = m;
+    }
+  }
+  return config;
+}
+function loadConfig(cliOpts = {}) {
+  const globalConfigPath = path.join(os.homedir(), ".zencode", "config.yaml");
+  const projectDirConfigPath = path.resolve(".zencode", "config.yaml");
+  const projectFileConfigPath = path.resolve(".zencode.yaml");
+  let config = { ...DEFAULT_CONFIG };
+  config = deepMerge(config, loadYamlFile(globalConfigPath));
+  config = deepMerge(config, loadYamlFile(projectDirConfigPath));
+  config = deepMerge(config, loadYamlFile(projectFileConfigPath));
+  config = deepMerge(config, loadEnvConfig());
+  config = deepMerge(config, loadCliConfig(cliOpts));
+  return config;
+}
+function resolveModelConfig(config, role) {
+  const roleConfig = config.dual_agent[role] || {};
+  return {
+    model: roleConfig.model || config.model,
+    api_key: roleConfig.api_key || config.api_key,
+    base_url: roleConfig.base_url || config.base_url,
+    temperature: roleConfig.temperature ?? config.temperature,
+    max_tokens: roleConfig.max_tokens ?? config.max_tokens
+  };
+}
+var init_loader = __esm({
+  "src/config/loader.ts"() {
+    "use strict";
+    init_defaults();
+  }
+});
+
+// src/llm/client.ts
+import OpenAI from "openai";
+function createLLMClient(options) {
+  return new LLMClient(options);
+}
+var LLMClient;
+var init_client = __esm({
+  "src/llm/client.ts"() {
+    "use strict";
+    LLMClient = class {
+      client;
+      model;
+      temperature;
+      maxTokens;
+      constructor(options) {
+        this.client = new OpenAI({
+          apiKey: options.apiKey,
+          baseURL: options.baseURL
+        });
+        this.model = options.model;
+        this.temperature = options.temperature ?? 0.7;
+        this.maxTokens = options.maxTokens ?? 8192;
+      }
+      /**
+       * 流式调用 LLM，实时回调文本内容和工具调用
+       */
+      async chatStream(messages, tools, callbacks) {
+        const params = {
+          model: this.model,
+          messages,
+          temperature: this.temperature,
+          max_tokens: this.maxTokens,
+          stream: true
+        };
+        if (tools && tools.length > 0) {
+          params.tools = tools;
+          params.tool_choice = "auto";
+        }
+        try {
+          const stream = await this.client.chat.completions.create(params);
+          let contentParts = [];
+          const toolCallMap = /* @__PURE__ */ new Map();
+          for await (const chunk of stream) {
+            const choice = chunk.choices[0];
+            if (!choice) continue;
+            const delta = choice.delta;
+            if (delta.content) {
+              contentParts.push(delta.content);
+              callbacks.onContent?.(delta.content);
+            }
+            if (delta.tool_calls) {
+              for (const tc of delta.tool_calls) {
+                const existing = toolCallMap.get(tc.index);
+                if (existing) {
+                  if (tc.function?.arguments) {
+                    existing.args += tc.function.arguments;
+                  }
+                } else {
+                  toolCallMap.set(tc.index, {
+                    id: tc.id || "",
+                    name: tc.function?.name || "",
+                    args: tc.function?.arguments || ""
+                  });
+                }
+                const entry = toolCallMap.get(tc.index);
+                if (entry && callbacks.onToolCallStreaming) {
+                  const n = entry.name;
+                  if (n === "write-file" || n === "edit-file") {
+                    callbacks.onToolCallStreaming(tc.index, n, entry.args);
+                  }
+                }
+              }
+            }
+          }
+          const toolCalls = [];
+          for (const [, tc] of [...toolCallMap.entries()].sort(([a], [b]) => a - b)) {
+            const toolCall = {
+              id: tc.id,
+              type: "function",
+              function: {
+                name: tc.name,
+                arguments: tc.args
+              }
+            };
+            toolCalls.push(toolCall);
+            callbacks.onToolCall?.(toolCall);
+          }
+          const fullContent = contentParts.join("");
+          const assistantMessage = {
+            role: "assistant",
+            content: fullContent || null
+          };
+          if (toolCalls.length > 0) {
+            assistantMessage.tool_calls = toolCalls;
+          }
+          callbacks.onFinish?.(assistantMessage);
+          return assistantMessage;
+        } catch (error) {
+          const err = error instanceof Error ? error : new Error(String(error));
+          callbacks.onError?.(err);
+          throw err;
+        }
+      }
+      /**
+       * 非流式调用 LLM
+       */
+      async chat(messages, tools) {
+        const params = {
+          model: this.model,
+          messages,
+          temperature: this.temperature,
+          max_tokens: this.maxTokens,
+          stream: false
+        };
+        if (tools && tools.length > 0) {
+          params.tools = tools;
+          params.tool_choice = "auto";
+        }
+        const response = await this.client.chat.completions.create(params);
+        const choice = response.choices[0];
+        if (!choice) {
+          throw new Error("No response from LLM");
+        }
+        const msg = choice.message;
+        const result = {
+          role: "assistant",
+          content: msg.content
+        };
+        if (msg.tool_calls && msg.tool_calls.length > 0) {
+          result.tool_calls = msg.tool_calls.map((tc) => ({
+            id: tc.id,
+            type: "function",
+            function: {
+              name: tc.function.name,
+              arguments: tc.function.arguments
+            }
+          }));
+        }
+        return result;
+      }
+      get modelName() {
+        return this.model;
+      }
+    };
+  }
+});
+
+// src/tools/registry.ts
+var ToolRegistry;
+var init_registry = __esm({
+  "src/tools/registry.ts"() {
+    "use strict";
+    ToolRegistry = class {
+      tools = /* @__PURE__ */ new Map();
+      permissionOverrides = null;
+      register(tool) {
+        this.tools.set(tool.name, tool);
+      }
+      get(name) {
+        return this.tools.get(name);
+      }
+      has(name) {
+        return this.tools.has(name);
+      }
+      unregister(name) {
+        return this.tools.delete(name);
+      }
+      /**
+       * 设置权限覆盖配置
+       */
+      setPermissions(permissions) {
+        this.permissionOverrides = permissions;
+      }
+      /**
+       * 运行时将某工具升级为自动批准（始终允许）
+       */
+      addAutoApprove(toolName) {
+        if (!this.permissionOverrides) {
+          this.permissionOverrides = { auto_approve: [], require_approval: [] };
+        }
+        if (!this.permissionOverrides.auto_approve.includes(toolName)) {
+          this.permissionOverrides.auto_approve.push(toolName);
+        }
+        this.permissionOverrides.require_approval = this.permissionOverrides.require_approval.filter((n) => n !== toolName);
+      }
+      /**
+       * 获取工具的有效权限级别
+       */
+      getPermissionLevel(toolName) {
+        if (this.permissionOverrides) {
+          if (this.permissionOverrides.auto_approve.includes(toolName)) return "auto";
+          if (this.permissionOverrides.require_approval.includes(toolName)) return "confirm";
+        }
+        const tool = this.tools.get(toolName);
+        return tool?.permissionLevel ?? "confirm";
+      }
+      /**
+       * 执行工具调用
+       */
+      async execute(name, params, maxOutput) {
+        const tool = this.tools.get(name);
+        if (!tool) {
+          return { content: `\u9519\u8BEF\uFF1A\u672A\u627E\u5230\u5DE5\u5177 "${name}"` };
+        }
+        try {
+          const result = await tool.execute(params);
+          if (result.content.length > maxOutput) {
+            return {
+              content: result.content.slice(0, maxOutput) + "\n\n[\u8F93\u51FA\u5DF2\u622A\u65AD]",
+              truncated: true
+            };
+          }
+          return result;
+        } catch (error) {
+          const msg = error instanceof Error ? error.message : String(error);
+          return { content: `\u5DE5\u5177\u6267\u884C\u9519\u8BEF\uFF1A${msg}` };
+        }
+      }
+      /**
+       * 导出为 OpenAI function calling 格式
+       */
+      toToolDefinitions(filter) {
+        const tools = [];
+        for (const [name, tool] of this.tools) {
+          if (filter && !filter.includes(name)) continue;
+          tools.push({
+            type: "function",
+            function: {
+              name: tool.name,
+              description: tool.description,
+              parameters: tool.parameters
+            }
+          });
+        }
+        return tools;
+      }
+      /**
+       * 获取所有已注册的工具名
+       */
+      listTools() {
+        return [...this.tools.keys()];
+      }
+    };
+  }
+});
+
+// src/tools/read-file.ts
+import * as fs2 from "fs/promises";
+import * as path2 from "path";
+var readFileTool;
+var init_read_file = __esm({
+  "src/tools/read-file.ts"() {
+    "use strict";
+    readFileTool = {
+      name: "read-file",
+      description: "\u8BFB\u53D6\u6587\u4EF6\u5185\u5BB9\u3002\u4FEE\u6539\u6587\u4EF6\u524D\u5FC5\u987B\u5148\u8BFB\u53D6\u3002\u652F\u6301 offset/limit \u8BFB\u53D6\u5927\u6587\u4EF6\u7684\u6307\u5B9A\u90E8\u5206\u3002\u8FD4\u56DE\u5E26\u884C\u53F7\u7684\u5185\u5BB9\u3002",
+      parameters: {
+        type: "object",
+        properties: {
+          path: {
+            type: "string",
+            description: "\u6587\u4EF6\u8DEF\u5F84\uFF08\u76F8\u5BF9\u4E8E\u5DE5\u4F5C\u76EE\u5F55\u6216\u7EDD\u5BF9\u8DEF\u5F84\uFF09"
+          },
+          offset: {
+            type: "number",
+            description: "\u8D77\u59CB\u884C\u53F7\uFF08\u4ECE1\u5F00\u59CB\uFF09\uFF0C\u9ED8\u8BA4\u4ECE\u5934\u8BFB\u53D6"
+          },
+          limit: {
+            type: "number",
+            description: "\u8BFB\u53D6\u7684\u884C\u6570\uFF0C\u9ED8\u8BA4\u8BFB\u53D6\u5168\u90E8"
+          }
+        },
+        required: ["path"]
+      },
+      permissionLevel: "auto",
+      async execute(params) {
+        const filePath = path2.resolve(params["path"]);
+        const offset = params["offset"] || 1;
+        const limit = params["limit"];
+        try {
+          const content = await fs2.readFile(filePath, "utf-8");
+          const lines = content.split("\n");
+          const startIdx = Math.max(0, offset - 1);
+          const endIdx = limit ? startIdx + limit : lines.length;
+          const selectedLines = lines.slice(startIdx, endIdx);
+          const numbered = selectedLines.map((line, i) => `${String(startIdx + i + 1).padStart(5)}	${line}`).join("\n");
+          return { content: numbered || "\uFF08\u7A7A\u6587\u4EF6\uFF09" };
+        } catch (error) {
+          const msg = error instanceof Error ? error.message : String(error);
+          return { content: `\u8BFB\u53D6\u6587\u4EF6\u5931\u8D25\uFF1A${msg}` };
+        }
+      }
+    };
+  }
+});
+
+// src/tools/write-file.ts
+import * as fs3 from "fs/promises";
+import * as path3 from "path";
+var writeFileTool;
+var init_write_file = __esm({
+  "src/tools/write-file.ts"() {
+    "use strict";
+    writeFileTool = {
+      name: "write-file",
+      description: "\u521B\u5EFA\u65B0\u6587\u4EF6\u6216\u5B8C\u6574\u91CD\u5199\u6587\u4EF6\u3002\u5982\u679C\u662F\u4FEE\u6539\u5DF2\u6709\u6587\u4EF6\uFF0C\u4F18\u5148\u4F7F\u7528 edit-file\u3002\u4F1A\u81EA\u52A8\u521B\u5EFA\u7236\u76EE\u5F55\u3002",
+      parameters: {
+        type: "object",
+        properties: {
+          path: {
+            type: "string",
+            description: "\u6587\u4EF6\u8DEF\u5F84"
+          },
+          content: {
+            type: "string",
+            description: "\u8981\u5199\u5165\u7684\u6587\u4EF6\u5185\u5BB9"
+          }
+        },
+        required: ["path", "content"]
+      },
+      permissionLevel: "confirm",
+      async execute(params) {
+        const filePath = path3.resolve(params["path"]);
+        const content = params["content"];
+        try {
+          await fs3.mkdir(path3.dirname(filePath), { recursive: true });
+          await fs3.writeFile(filePath, content, "utf-8");
+          return { content: `\u6587\u4EF6\u5DF2\u5199\u5165\uFF1A${filePath}` };
+        } catch (error) {
+          const msg = error instanceof Error ? error.message : String(error);
+          return { content: `\u5199\u5165\u6587\u4EF6\u5931\u8D25\uFF1A${msg}` };
+        }
+      }
+    };
+  }
+});
+
+// src/tools/edit-file.ts
+import * as fs4 from "fs/promises";
+import * as path4 from "path";
+var editFileTool;
+var init_edit_file = __esm({
+  "src/tools/edit-file.ts"() {
+    "use strict";
+    editFileTool = {
+      name: "edit-file",
+      description: "\u901A\u8FC7\u5B57\u7B26\u4E32\u66FF\u6362\u7F16\u8F91\u6587\u4EF6\uFF08\u63A8\u8350\u7684\u6587\u4EF6\u4FEE\u6539\u65B9\u5F0F\uFF09\u3002old_string \u5FC5\u987B\u5728\u6587\u4EF6\u4E2D\u552F\u4E00\u5339\u914D\uFF0C\u5C06\u88AB\u66FF\u6362\u4E3A new_string\u3002\u5339\u914D\u5931\u8D25\u65F6\u8BF7\u63D0\u4F9B\u66F4\u591A\u4E0A\u4E0B\u6587\u4F7F\u5176\u552F\u4E00\uFF0C\u6216\u4F7F\u7528 replace_all\u3002",
+      parameters: {
+        type: "object",
+        properties: {
+          path: {
+            type: "string",
+            description: "\u6587\u4EF6\u8DEF\u5F84"
+          },
+          old_string: {
+            type: "string",
+            description: "\u8981\u88AB\u66FF\u6362\u7684\u539F\u59CB\u5B57\u7B26\u4E32\uFF08\u5FC5\u987B\u552F\u4E00\u5339\u914D\uFF09"
+          },
+          new_string: {
+            type: "string",
+            description: "\u66FF\u6362\u540E\u7684\u5B57\u7B26\u4E32"
+          },
+          replace_all: {
+            type: "boolean",
+            description: "\u662F\u5426\u66FF\u6362\u6240\u6709\u5339\u914D\u9879\uFF0C\u9ED8\u8BA4 false"
+          }
+        },
+        required: ["path", "old_string", "new_string"]
+      },
+      permissionLevel: "confirm",
+      async execute(params) {
+        const filePath = path4.resolve(params["path"]);
+        const oldString = params["old_string"];
+        const newString = params["new_string"];
+        const replaceAll = params["replace_all"] ?? false;
+        try {
+          const content = await fs4.readFile(filePath, "utf-8");
+          if (replaceAll) {
+            const newContent2 = content.split(oldString).join(newString);
+            if (newContent2 === content) {
+              return { content: `\u672A\u627E\u5230\u5339\u914D\u5185\u5BB9\uFF1A${oldString.slice(0, 50)}...` };
+            }
+            await fs4.writeFile(filePath, newContent2, "utf-8");
+            const count = content.split(oldString).length - 1;
+            return { content: `\u5DF2\u66FF\u6362 ${count} \u5904\u5339\u914D` };
+          }
+          const firstIdx = content.indexOf(oldString);
+          if (firstIdx === -1) {
+            return { content: `\u672A\u627E\u5230\u5339\u914D\u5185\u5BB9\uFF1A${oldString.slice(0, 100)}` };
+          }
+          const secondIdx = content.indexOf(oldString, firstIdx + 1);
+          if (secondIdx !== -1) {
+            return { content: `old_string \u4E0D\u552F\u4E00\uFF0C\u627E\u5230\u591A\u5904\u5339\u914D\u3002\u8BF7\u63D0\u4F9B\u66F4\u591A\u4E0A\u4E0B\u6587\u4F7F\u5176\u552F\u4E00\u3002` };
+          }
+          const newContent = content.slice(0, firstIdx) + newString + content.slice(firstIdx + oldString.length);
+          await fs4.writeFile(filePath, newContent, "utf-8");
+          return { content: `\u6587\u4EF6\u5DF2\u7F16\u8F91\uFF1A${filePath}` };
+        } catch (error) {
+          const msg = error instanceof Error ? error.message : String(error);
+          return { content: `\u7F16\u8F91\u6587\u4EF6\u5931\u8D25\uFF1A${msg}` };
+        }
+      }
+    };
+  }
+});
+
+// src/tools/bash.ts
+import { exec } from "child_process";
+var DEFAULT_TIMEOUT, bashTool;
+var init_bash = __esm({
+  "src/tools/bash.ts"() {
+    "use strict";
+    DEFAULT_TIMEOUT = 12e4;
+    bashTool = {
+      name: "bash",
+      description: "\u6267\u884C shell \u547D\u4EE4\u3002\u7528\u4E8E\u8FD0\u884C\u6784\u5EFA\u3001\u6D4B\u8BD5\u3001git \u64CD\u4F5C\u7B49\u7CFB\u7EDF\u547D\u4EE4\u3002\u4E0D\u8981\u7528 bash \u505A\u6587\u4EF6\u8BFB\u5199\uFF08\u7528 read-file/edit-file/write-file\uFF09\u6216\u641C\u7D22\uFF08\u7528 glob/grep\uFF09\u3002",
+      parameters: {
+        type: "object",
+        properties: {
+          command: {
+            type: "string",
+            description: "\u8981\u6267\u884C\u7684 shell \u547D\u4EE4"
+          },
+          timeout: {
+            type: "number",
+            description: "\u8D85\u65F6\u65F6\u95F4\uFF08\u6BEB\u79D2\uFF09\uFF0C\u9ED8\u8BA4 120000"
+          }
+        },
+        required: ["command"]
+      },
+      permissionLevel: "confirm",
+      async execute(params) {
+        const command = params["command"];
+        const timeout = params["timeout"] || DEFAULT_TIMEOUT;
+        return new Promise((resolve7) => {
+          exec(
+            command,
+            {
+              cwd: process.cwd(),
+              timeout,
+              maxBuffer: 1024 * 1024 * 10,
+              // 10MB
+              shell: process.platform === "win32" ? "cmd.exe" : "/bin/bash"
+            },
+            (error, stdout, stderr) => {
+              let output = "";
+              if (stdout) output += stdout;
+              if (stderr) output += (output ? "\n" : "") + `[stderr]
+${stderr}`;
+              if (error && error.killed) {
+                output += `
+[\u547D\u4EE4\u8D85\u65F6\uFF0C\u5DF2\u7EC8\u6B62]`;
+              } else if (error && !stdout && !stderr) {
+                output = `\u547D\u4EE4\u6267\u884C\u5931\u8D25\uFF1A${error.message}`;
+              }
+              resolve7({ content: output || "\uFF08\u65E0\u8F93\u51FA\uFF09" });
+            }
+          );
+        });
+      }
+    };
+  }
+});
+
+// src/tools/glob.ts
+import { glob as globFn } from "glob";
+var globTool;
+var init_glob = __esm({
+  "src/tools/glob.ts"() {
+    "use strict";
+    globTool = {
+      name: "glob",
+      description: '\u6309 glob \u6A21\u5F0F\u641C\u7D22\u6587\u4EF6\u8DEF\u5F84\u3002\u7528\u4E8E\u67E5\u627E\u6587\u4EF6\u4F4D\u7F6E\uFF0C\u5982 "**/*.ts"\u3001"src/**/config.*"\u3002\u81EA\u52A8\u5FFD\u7565 node_modules \u548C .git\u3002',
+      parameters: {
+        type: "object",
+        properties: {
+          pattern: {
+            type: "string",
+            description: 'Glob \u6A21\u5F0F\uFF0C\u5982 "**/*.ts"\u3001"src/**/*.js"'
+          },
+          cwd: {
+            type: "string",
+            description: "\u641C\u7D22\u7684\u6839\u76EE\u5F55\uFF0C\u9ED8\u8BA4\u4E3A\u5DE5\u4F5C\u76EE\u5F55"
+          }
+        },
+        required: ["pattern"]
+      },
+      permissionLevel: "auto",
+      async execute(params) {
+        const pattern = params["pattern"];
+        const cwd = params["cwd"] || process.cwd();
+        try {
+          const files = await globFn(pattern, {
+            cwd,
+            nodir: true,
+            dot: false,
+            ignore: ["**/node_modules/**", "**/.git/**"]
+          });
+          if (files.length === 0) {
+            return { content: "\u672A\u627E\u5230\u5339\u914D\u7684\u6587\u4EF6" };
+          }
+          return { content: files.join("\n") };
+        } catch (error) {
+          const msg = error instanceof Error ? error.message : String(error);
+          return { content: `\u641C\u7D22\u5931\u8D25\uFF1A${msg}` };
+        }
+      }
+    };
+  }
+});
+
+// src/tools/grep.ts
+import * as fs5 from "fs/promises";
+import * as path5 from "path";
+async function jsGrep(pattern, searchPath, options) {
+  const regex = new RegExp(pattern, options.ignoreCase ? "i" : "");
+  const results = [];
+  const maxResults = options.maxResults ?? 200;
+  async function searchFile(filePath) {
+    if (results.length >= maxResults) return;
+    try {
+      const content = await fs5.readFile(filePath, "utf-8");
+      const lines = content.split("\n");
+      for (let i = 0; i < lines.length; i++) {
+        if (results.length >= maxResults) break;
+        if (regex.test(lines[i])) {
+          results.push(`${filePath}:${i + 1}: ${lines[i]}`);
+        }
+      }
+    } catch {
+    }
+  }
+  async function searchDir(dirPath) {
+    if (results.length >= maxResults) return;
+    try {
+      const entries = await fs5.readdir(dirPath, { withFileTypes: true });
+      for (const entry of entries) {
+        if (results.length >= maxResults) break;
+        const fullPath = path5.join(dirPath, entry.name);
+        if (entry.isDirectory()) {
+          if (["node_modules", ".git", "dist", ".next", "__pycache__"].includes(entry.name)) {
+            continue;
+          }
+          await searchDir(fullPath);
+        } else if (entry.isFile()) {
+          const ext = path5.extname(entry.name).toLowerCase();
+          const textExts = [
+            ".ts",
+            ".tsx",
+            ".js",
+            ".jsx",
+            ".json",
+            ".md",
+            ".txt",
+            ".yaml",
+            ".yml",
+            ".toml",
+            ".css",
+            ".scss",
+            ".html",
+            ".vue",
+            ".svelte",
+            ".py",
+            ".go",
+            ".rs",
+            ".java",
+            ".c",
+            ".cpp",
+            ".h",
+            ".hpp",
+            ".rb",
+            ".php",
+            ".sh",
+            ".bash",
+            ".zsh",
+            ".fish",
+            ".sql",
+            ".xml",
+            ".svg",
+            ".env",
+            ".gitignore",
+            ".editorconfig",
+            ".prettierrc",
+            ".eslintrc"
+          ];
+          if (ext && !textExts.includes(ext)) continue;
+          await searchFile(fullPath);
+        }
+      }
+    } catch {
+    }
+  }
+  const stat2 = await fs5.stat(searchPath);
+  if (stat2.isFile()) {
+    await searchFile(searchPath);
+  } else {
+    await searchDir(searchPath);
+  }
+  return results;
+}
+var grepTool;
+var init_grep = __esm({
+  "src/tools/grep.ts"() {
+    "use strict";
+    grepTool = {
+      name: "grep",
+      description: "\u5728\u6587\u4EF6\u5185\u5BB9\u4E2D\u641C\u7D22\u6B63\u5219\u8868\u8FBE\u5F0F\u3002\u7528\u4E8E\u67E5\u627E\u51FD\u6570\u5B9A\u4E49\u3001\u7C7B\u5F15\u7528\u3001\u7279\u5B9A\u4EE3\u7801\u6A21\u5F0F\u3002\u8FD4\u56DE\u5339\u914D\u7684\u6587\u4EF6\u8DEF\u5F84\u3001\u884C\u53F7\u548C\u5185\u5BB9\u3002",
+      parameters: {
+        type: "object",
+        properties: {
+          pattern: {
+            type: "string",
+            description: "\u6B63\u5219\u8868\u8FBE\u5F0F\u641C\u7D22\u6A21\u5F0F"
+          },
+          path: {
+            type: "string",
+            description: "\u641C\u7D22\u7684\u6587\u4EF6\u6216\u76EE\u5F55\u8DEF\u5F84\uFF0C\u9ED8\u8BA4\u4E3A\u5DE5\u4F5C\u76EE\u5F55"
+          },
+          ignore_case: {
+            type: "boolean",
+            description: "\u662F\u5426\u5FFD\u7565\u5927\u5C0F\u5199"
+          }
+        },
+        required: ["pattern"]
+      },
+      permissionLevel: "auto",
+      async execute(params) {
+        const pattern = params["pattern"];
+        const searchPath = params["path"] || process.cwd();
+        const ignoreCase = params["ignore_case"] ?? false;
+        try {
+          const resolvedPath = path5.resolve(searchPath);
+          const results = await jsGrep(pattern, resolvedPath, {
+            ignoreCase,
+            maxResults: 200
+          });
+          if (results.length === 0) {
+            return { content: "\u672A\u627E\u5230\u5339\u914D\u5185\u5BB9" };
+          }
+          return { content: results.join("\n") };
+        } catch (error) {
+          const msg = error instanceof Error ? error.message : String(error);
+          return { content: `\u641C\u7D22\u5931\u8D25\uFF1A${msg}` };
+        }
+      }
+    };
+  }
+});
+
+// src/tools/register.ts
+function registerCoreTools(registry) {
+  registry.register(readFileTool);
+  registry.register(writeFileTool);
+  registry.register(editFileTool);
+  registry.register(bashTool);
+  registry.register(globTool);
+  registry.register(grepTool);
+}
+var init_register = __esm({
+  "src/tools/register.ts"() {
+    "use strict";
+    init_read_file();
+    init_write_file();
+    init_edit_file();
+    init_bash();
+    init_glob();
+    init_grep();
+  }
+});
+
+// src/tools/permission.ts
+import chalk from "chalk";
+function setConfirmHandler(handler) {
+  globalConfirmHandler = handler;
+}
+function setStructuredConfirmHandler(handler) {
+  structuredConfirmHandler = handler;
+}
+function formatToolDetail(toolName, params) {
+  const lines = [];
+  switch (toolName) {
+    case "bash":
+      lines.push(`  ${chalk.dim("\u547D\u4EE4:")} ${chalk.white(String(params["command"] || ""))}`);
+      break;
+    case "write-file":
+      lines.push(`  ${chalk.dim("\u6587\u4EF6:")} ${chalk.white(String(params["path"] || ""))}`);
+      if (params["content"]) {
+        const content = String(params["content"]);
+        const preview = content.length > 200 ? content.slice(0, 200) + "..." : content;
+        lines.push(`  ${chalk.dim("\u5185\u5BB9:")} ${chalk.gray(preview.split("\n").join("\n        "))}`);
+      }
+      break;
+    case "edit-file":
+      lines.push(`  ${chalk.dim("\u6587\u4EF6:")} ${chalk.white(String(params["path"] || ""))}`);
+      if (params["old_string"]) {
+        const old = String(params["old_string"]);
+        const preview = old.length > 100 ? old.slice(0, 100) + "..." : old;
+        lines.push(`  ${chalk.dim("\u66FF\u6362:")} ${chalk.red(preview)}`);
+      }
+      if (params["new_string"]) {
+        const neu = String(params["new_string"]);
+        const preview = neu.length > 100 ? neu.slice(0, 100) + "..." : neu;
+        lines.push(`  ${chalk.dim("\u4E3A  :")} ${chalk.green(preview)}`);
+      }
+      break;
+    case "git":
+      lines.push(`  ${chalk.dim("\u547D\u4EE4:")} git ${chalk.white(String(params["command"] || ""))}`);
+      break;
+    default:
+      for (const [key, value] of Object.entries(params)) {
+        const str = typeof value === "string" ? value : JSON.stringify(value);
+        lines.push(`  ${chalk.dim(key + ":")} ${str.slice(0, 120)}`);
+      }
+      break;
+  }
+  return lines.join("\n");
+}
+async function confirmExecution(toolName, params) {
+  if (structuredConfirmHandler) {
+    return structuredConfirmHandler(toolName, params);
+  }
+  const detail = formatToolDetail(toolName, params);
+  const prompt = `
+${chalk.yellow("\u26A0")} ${chalk.bold("\u9700\u8981\u786E\u8BA4")} ${chalk.cyan(`[${toolName}]`)}
+${detail}
+`;
+  process.stderr.write(prompt);
+  const approved = await globalConfirmHandler(`${chalk.yellow("?")} \u662F\u5426\u6267\u884C\uFF1F(${chalk.green("y")}/${chalk.red("N")}) `);
+  return { approved };
+}
+var globalConfirmHandler, structuredConfirmHandler;
+var init_permission = __esm({
+  "src/tools/permission.ts"() {
+    "use strict";
+    globalConfirmHandler = async () => false;
+    structuredConfirmHandler = null;
+  }
+});
+
+// src/core/conversation.ts
+var Conversation;
+var init_conversation = __esm({
+  "src/core/conversation.ts"() {
+    "use strict";
+    Conversation = class {
+      messages = [];
+      systemPrompt = "";
+      setSystemPrompt(prompt) {
+        this.systemPrompt = prompt;
+      }
+      addMessage(message) {
+        this.messages.push(message);
+      }
+      addUserMessage(content) {
+        this.messages.push({ role: "user", content });
+      }
+      addAssistantMessage(message) {
+        this.messages.push(message);
+      }
+      addToolResult(toolCallId, content) {
+        this.messages.push({
+          role: "tool",
+          tool_call_id: toolCallId,
+          content
+        });
+      }
+      /**
+       * 获取完整的消息列表（包含系统提示词）
+       */
+      getMessages() {
+        const result = [];
+        if (this.systemPrompt) {
+          result.push({ role: "system", content: this.systemPrompt });
+        }
+        result.push(...this.messages);
+        return result;
+      }
+      /**
+       * 获取不含系统提示词的历史消息
+       */
+      getHistory() {
+        return [...this.messages];
+      }
+      /**
+       * 清空对话历史（保留系统提示词）
+       */
+      clear() {
+        this.messages = [];
+      }
+      /**
+       * 获取消息数量
+       */
+      get length() {
+        return this.messages.length;
+      }
+    };
+  }
+});
+
+// src/core/agent.ts
+var Agent;
+var init_agent = __esm({
+  "src/core/agent.ts"() {
+    "use strict";
+    init_permission();
+    init_conversation();
+    Agent = class {
+      conversation;
+      client;
+      registry;
+      config;
+      fixedTools;
+      constructor(client, registry, config, systemPrompt, tools) {
+        this.client = client;
+        this.registry = registry;
+        this.config = config;
+        this.conversation = new Conversation();
+        this.conversation.setSystemPrompt(systemPrompt);
+        this.fixedTools = tools;
+      }
+      /**
+       * 执行一轮完整的 agent 循环
+       */
+      async run(userMessage, callbacks = {}) {
+        this.conversation.addUserMessage(userMessage);
+        let lastContent = "";
+        while (true) {
+          const tools = this.fixedTools || this.registry.toToolDefinitions();
+          const assistantMsg = await this.client.chatStream(
+            this.conversation.getMessages(),
+            tools.length > 0 ? tools : void 0,
+            callbacks
+          );
+          this.conversation.addAssistantMessage(assistantMsg);
+          if (!assistantMsg.tool_calls || assistantMsg.tool_calls.length === 0) {
+            lastContent = assistantMsg.content || "";
+            break;
+          }
+          for (const toolCall of assistantMsg.tool_calls) {
+            const toolName = toolCall.function.name;
+            let params;
+            try {
+              params = JSON.parse(toolCall.function.arguments);
+            } catch {
+              this.conversation.addToolResult(toolCall.id, "\u53C2\u6570\u89E3\u6790\u5931\u8D25\uFF1A\u65E0\u6548\u7684 JSON");
+              continue;
+            }
+            try {
+              const permLevel = this.registry.getPermissionLevel(toolName);
+              if (permLevel === "deny") {
+                callbacks.onDenied?.(toolName);
+                this.conversation.addToolResult(toolCall.id, `\u5DE5\u5177 "${toolName}" \u5DF2\u88AB\u7981\u6B62\u6267\u884C`);
+                continue;
+              }
+              if (permLevel === "auto") {
+                callbacks.onToolExecuting?.(toolName, params);
+              }
+              if (permLevel === "confirm") {
+                const confirmResult = await confirmExecution(toolName, params);
+                if (!confirmResult.approved) {
+                  callbacks.onDenied?.(toolName, confirmResult.feedback);
+                  const denyMsg = confirmResult.feedback ? `\u7528\u6237\u62D2\u7EDD\u4E86\u6B64\u64CD\u4F5C\uFF0C\u7528\u6237\u53CD\u9988: ${confirmResult.feedback}` : "\u7528\u6237\u62D2\u7EDD\u4E86\u6B64\u64CD\u4F5C";
+                  this.conversation.addToolResult(toolCall.id, denyMsg);
+                  continue;
+                }
+              }
+              const result = await this.registry.execute(toolName, params, this.config.max_tool_output);
+              callbacks.onToolResult?.(toolName, result.content, result.truncated ?? false);
+              this.conversation.addToolResult(toolCall.id, result.content);
+            } catch (err) {
+              const msg = err instanceof Error ? err.message : String(err);
+              this.conversation.addToolResult(toolCall.id, `\u5DE5\u5177\u6267\u884C\u5F02\u5E38\uFF1A${msg}`);
+            }
+          }
+          if (assistantMsg.content) {
+            lastContent = assistantMsg.content;
+          }
+        }
+        return lastContent;
+      }
+      /**
+       * 获取对话历史
+       */
+      getConversation() {
+        return this.conversation;
+      }
+    };
+  }
+});
+
+// src/core/dual-agent/coder.ts
+var Coder;
+var init_coder = __esm({
+  "src/core/dual-agent/coder.ts"() {
+    "use strict";
+    init_conversation();
+    init_permission();
+    Coder = class {
+      client;
+      registry;
+      config;
+      systemPrompt;
+      tools;
+      constructor(client, registry, config, systemPrompt, tools) {
+        this.client = client;
+        this.registry = registry;
+        this.config = config;
+        this.systemPrompt = systemPrompt;
+        this.tools = tools;
+      }
+      /**
+       * 执行编码任务（短生命周期，每次新建会话）
+       *
+       * @param taskMessage 调度者发来的任务描述（作为 user message）
+       * @param callbacks 回调
+       * @returns 编码者的最终响应
+       */
+      async execute(taskMessage, callbacks = {}) {
+        const conversation = new Conversation();
+        conversation.setSystemPrompt(this.systemPrompt);
+        conversation.addUserMessage(taskMessage);
+        let lastContent = "";
+        while (true) {
+          const assistantMsg = await this.client.chatStream(
+            conversation.getMessages(),
+            this.tools.length > 0 ? this.tools : void 0,
+            callbacks
+          );
+          conversation.addAssistantMessage(assistantMsg);
+          if (!assistantMsg.tool_calls || assistantMsg.tool_calls.length === 0) {
+            lastContent = assistantMsg.content || "";
+            break;
+          }
+          for (const toolCall of assistantMsg.tool_calls) {
+            const toolName = toolCall.function.name;
+            let params;
+            try {
+              params = JSON.parse(toolCall.function.arguments);
+            } catch {
+              conversation.addToolResult(toolCall.id, "\u53C2\u6570\u89E3\u6790\u5931\u8D25\uFF1A\u65E0\u6548\u7684 JSON");
+              continue;
+            }
+            try {
+              const permLevel = this.registry.getPermissionLevel(toolName);
+              if (permLevel === "deny") {
+                callbacks.onDenied?.(toolName);
+                conversation.addToolResult(toolCall.id, `\u5DE5\u5177 "${toolName}" \u5DF2\u88AB\u7981\u6B62\u6267\u884C`);
+                continue;
+              }
+              if (permLevel === "auto") {
+                callbacks.onToolExecuting?.(toolName, params);
+              }
+              if (permLevel === "confirm") {
+                const confirmResult = await confirmExecution(toolName, params);
+                if (!confirmResult.approved) {
+                  callbacks.onDenied?.(toolName, confirmResult.feedback);
+                  const denyMsg = confirmResult.feedback ? `\u7528\u6237\u62D2\u7EDD\u4E86\u6B64\u64CD\u4F5C\uFF0C\u7528\u6237\u53CD\u9988: ${confirmResult.feedback}` : "\u7528\u6237\u62D2\u7EDD\u4E86\u6B64\u64CD\u4F5C";
+                  conversation.addToolResult(toolCall.id, denyMsg);
+                  continue;
+                }
+              }
+              const result = await this.registry.execute(toolName, params, this.config.max_tool_output);
+              callbacks.onToolResult?.(toolName, result.content, result.truncated ?? false);
+              conversation.addToolResult(toolCall.id, result.content);
+            } catch (err) {
+              const msg = err instanceof Error ? err.message : String(err);
+              conversation.addToolResult(toolCall.id, `\u5DE5\u5177\u6267\u884C\u5F02\u5E38\uFF1A${msg}`);
+            }
+          }
+          if (assistantMsg.content) {
+            lastContent = assistantMsg.content;
+          }
+        }
+        return lastContent;
+      }
+    };
+  }
+});
+
+// src/core/dual-agent/modes.ts
+function getMode(name) {
+  switch (name) {
+    case "delegated":
+      return DELEGATED_MODE;
+    case "autonomous":
+      return AUTONOMOUS_MODE;
+    case "controlled":
+      return CONTROLLED_MODE;
+    default:
+      return DELEGATED_MODE;
+  }
+}
+var CODER_IDENTITY, DELEGATED_MODE, AUTONOMOUS_MODE, CONTROLLED_MODE;
+var init_modes = __esm({
+  "src/core/dual-agent/modes.ts"() {
+    "use strict";
+    CODER_IDENTITY = `\u4F60\u662F\u7F16\u7801\u5B50 Agent\u3002\u6309\u4EE5\u4E0B\u987A\u5E8F\u5DE5\u4F5C\uFF1A
+
+1. **\u8BFB memo**\uFF1A\u5982\u679C\u4EFB\u52A1\u63D0\u5230\u4E86 memo key\uFF0C\u5148 memo read \u83B7\u53D6\u8C03\u5EA6\u8005\u8BB0\u5F55\u7684\u4E0A\u4E0B\u6587
+2. **\u7F16\u7801**\uFF1A
+   - \u65B0\u5EFA\u6587\u4EF6 \u2192 \u76F4\u63A5 write-file
+   - \u4FEE\u6539\u6587\u4EF6 \u2192 read-file \u9605\u8BFB\u8981\u6539\u7684\u6587\u4EF6 \u2192 edit-file \u4FEE\u6539
+3. **\u5199 memo**\uFF1A\u5B8C\u6210\u540E memo write \u8BB0\u5F55\u6539\u52A8\u6458\u8981\uFF08key \u5982 "done-xxx"\uFF09\uFF0C\u4FBF\u4E8E\u8C03\u5EA6\u8005\u4E86\u89E3\u8FDB\u5C55
+4. **\u56DE\u590D**\uFF1A\u4E00\u53E5\u8BDD\u8BF4\u660E\u7ED3\u679C
+
+## \u7981\u6B62
+- \u274C \u7F16\u7801\u524D\u505A\u63A2\u7D22\uFF08bash ls/dir/pwd\u3001glob\u3001grep\uFF09\u2014 \u8C03\u5EA6\u8005\u5DF2\u7ECF\u505A\u8FC7\u4E86\uFF0C\u7ED3\u679C\u5728 memo \u4E2D
+- \u274C \u8F93\u51FA\u8BA1\u5212\u3001\u5206\u6790\u3001\u601D\u8DEF\u8BF4\u660E \u2014 \u76F4\u63A5\u52A8\u624B
+- \u274C \u505A\u4EFB\u52A1\u8303\u56F4\u5916\u7684\u6539\u52A8
+- \u274C \u6DFB\u52A0\u672A\u8981\u6C42\u7684\u6CE8\u91CA\u3001\u6587\u6863\u3001\u9519\u8BEF\u5904\u7406
+- \u274C \u8FC7\u5EA6\u5DE5\u7A0B\u5316`;
+    DELEGATED_MODE = {
+      name: "delegated",
+      description: "A\u6536\u96C6\u4E0A\u4E0B\u6587\u5E76\u59D4\u6D3E\uFF0CB\u62E5\u6709\u5B8C\u6574\u5DE5\u5177\u72EC\u7ACB\u6267\u884C",
+      coderHasTools: true,
+      coderToolNames: ["read-file", "write-file", "edit-file", "bash", "glob", "grep", "memo"],
+      coderSystemPrompt: `${CODER_IDENTITY}`
+    };
+    AUTONOMOUS_MODE = {
+      name: "autonomous",
+      description: "A\u89C4\u5212\uFF0CB\u81EA\u4E3B\u6267\u884C\uFF08\u9002\u5408\u80FD\u529B\u5F3A\u7684\u6A21\u578B\uFF09",
+      coderHasTools: true,
+      coderToolNames: ["read-file", "write-file", "edit-file", "bash", "glob", "grep", "memo"],
+      coderSystemPrompt: `${CODER_IDENTITY}`
+    };
+    CONTROLLED_MODE = {
+      name: "controlled",
+      description: "A\u5168\u6743\u7BA1\u7406\uFF0CB\u53EA\u8FD4\u56DE\u4EE3\u7801",
+      coderHasTools: false,
+      coderSystemPrompt: "\u4F60\u662F\u88AB\u8C03\u5EA6\u8005\u6D3E\u51FA\u7684\u5B50 Agent\u3002\u6839\u636E\u63D0\u4F9B\u7684\u4EE3\u7801\u548C\u9700\u6C42\uFF0C\u53EA\u8FD4\u56DE\u4FEE\u6539\u540E\u7684\u4EE3\u7801\u3002\u4E0D\u8981\u81EA\u884C\u64CD\u4F5C\u6587\u4EF6\uFF0C\u4E0D\u8981\u505A\u989D\u5916\u6539\u52A8\u3002"
+    };
+  }
+});
+
+// src/core/dual-agent/orchestrator.ts
+var SEND_TO_CODER_TOOL, Orchestrator;
+var init_orchestrator = __esm({
+  "src/core/dual-agent/orchestrator.ts"() {
+    "use strict";
+    init_client();
+    init_loader();
+    init_conversation();
+    init_permission();
+    init_coder();
+    init_modes();
+    SEND_TO_CODER_TOOL = {
+      type: "function",
+      function: {
+        name: "send-to-coder",
+        description: "\u5C06\u7F16\u7801\u4EFB\u52A1\u53D1\u9001\u7ED9\u7F16\u7801 Agent\u3002\u4F20\u5165\u4EFB\u52A1\u63CF\u8FF0\u548C\u76F8\u5173\u4EE3\u7801\u4E0A\u4E0B\u6587\uFF0C\u7F16\u7801 Agent \u5C06\u8FD4\u56DE\u4EE3\u7801\u6216\u89E3\u51B3\u65B9\u6848\u3002",
+        parameters: {
+          type: "object",
+          properties: {
+            task: {
+              type: "string",
+              description: "\u8981\u53D1\u9001\u7ED9\u7F16\u7801 Agent \u7684\u4EFB\u52A1\u63CF\u8FF0\uFF0C\u5305\u542B\u76F8\u5173\u4EE3\u7801\u4E0A\u4E0B\u6587"
+            }
+          },
+          required: ["task"]
+        }
+      }
+    };
+    Orchestrator = class {
+      conversation;
+      orchestratorClient;
+      coderClient;
+      registry;
+      config;
+      mode;
+      baseSystemPrompt;
+      memoStore;
+      constructor(registry, config, systemPrompt, memoStore) {
+        this.registry = registry;
+        this.config = config;
+        this.mode = config.collaboration;
+        this.baseSystemPrompt = systemPrompt;
+        this.memoStore = memoStore;
+        const orchConfig = resolveModelConfig(config, "orchestrator");
+        this.orchestratorClient = createLLMClient({
+          apiKey: orchConfig.api_key,
+          baseURL: orchConfig.base_url,
+          model: orchConfig.model,
+          temperature: orchConfig.temperature,
+          maxTokens: orchConfig.max_tokens
+        });
+        const coderConfig = resolveModelConfig(config, "coder");
+        this.coderClient = createLLMClient({
+          apiKey: coderConfig.api_key,
+          baseURL: coderConfig.base_url,
+          model: coderConfig.model,
+          temperature: coderConfig.temperature,
+          maxTokens: coderConfig.max_tokens
+        });
+        this.conversation = new Conversation();
+        this.conversation.setSystemPrompt(this.buildSystemPrompt());
+      }
+      /**
+       * 动态获取调度者的工具列表：注册表工具 + send-to-coder
+       */
+      getTools() {
+        return [
+          ...this.registry.toToolDefinitions(),
+          SEND_TO_CODER_TOOL
+        ];
+      }
+      /**
+       * 构建调度者的系统提示词（包含当前协作模式）
+       */
+      buildSystemPrompt() {
+        const modeInfo = getMode(this.mode);
+        return `${this.baseSystemPrompt}
+
+# \u4F60\u662F\u8C03\u5EA6\u8005 Agent
+
+\u534F\u4F5C\u6A21\u5F0F\uFF1A${modeInfo.name} - ${modeInfo.description}
+
+\u4F60\u662F\u4FA6\u5BDF\u5175 + \u6307\u6325\u5B98\u3002\u4F60\u81EA\u5DF1\u4E0D\u5199\u4EE3\u7801\uFF0C\u4F60\u7684\u804C\u8D23\u662F\uFF1A\u6536\u96C6\u60C5\u62A5 \u2192 \u8BB0\u5165 memo \u2192 \u59D4\u6D3E\u7F16\u7801 Agent\u3002
+
+## \u6838\u5FC3\u6D41\u7A0B
+
+1. **\u8BC4\u4F30**\uFF1A\u4EFB\u52A1\u662F\u5426\u9700\u8981\u4E86\u89E3\u73B0\u6709\u4EE3\u7801\uFF1F
+   - \u9700\u8981\u4FEE\u6539\u73B0\u6709\u6587\u4EF6\u3001\u9700\u8981\u4E0E\u73B0\u6709\u4EE3\u7801\u98CE\u683C\u4E00\u81F4\u3001\u9700\u8981\u7406\u89E3\u4F9D\u8D56\u5173\u7CFB \u2192 \u5148\u6536\u96C6
+   - \u9700\u6C42\u5B8C\u5168\u81EA\u5305\u542B\u3001\u76EE\u6807\u8DEF\u5F84\u5DF2\u660E\u786E \u2192 \u8DF3\u5230\u7B2C 3 \u6B65
+
+2. **\u6536\u96C6\u4E0A\u4E0B\u6587**\uFF08\u9AD8\u6548\uFF0C\u4E0D\u91CD\u590D\uFF09
+   - \u7528 glob/grep \u5B9A\u4F4D\uFF08\u4E00\u6B21\u5C31\u591F\uFF0C\u4E0D\u8981\u540C\u4E00\u76EE\u6807\u67E5\u591A\u6B21\uFF09
+   - \u7528 read-file \u6216 spawn-agents \u5E76\u884C\u8BFB\u53D6\u5173\u952E\u6587\u4EF6
+   - **\u5FC5\u987B memo write \u8BB0\u5F55\u53D1\u73B0**\uFF0Ckey \u7528\u6709\u610F\u4E49\u7684\u540D\u79F0
+     \u4F8B\uFF1Amemo write key="demo-structure" value="demo/ \u4E0B\u6709 weather.html\uFF08\u5929\u6C14\u7EC4\u4EF6\u793A\u4F8B\uFF09\uFF0C\u4F7F\u7528\u7EAF HTML+CSS+JS \u5355\u6587\u4EF6\u7ED3\u6784"
+   - \u7CBE\u70BC\u6458\u8981\uFF0C\u4E0D\u8981\u590D\u5236\u6574\u4E2A\u6587\u4EF6\u5185\u5BB9
+
+3. **\u59D4\u6D3E\u7F16\u7801**\uFF1Asend-to-coder
+   - task \u4E2D\u5199\u6E05\uFF1A\u505A\u4EC0\u4E48 + \u76EE\u6807\u8DEF\u5F84 + \u5F15\u7528 memo key
+     \u4F8B\uFF1Atask="\u5728 demo/newyear.html \u521B\u5EFA\u9A6C\u5E74\u6625\u8282\u795D\u798F\u7F51\u9875\u3002\u9879\u76EE\u73B0\u6709\u7ED3\u6784\u89C1 memo key 'demo-structure'\u3002\u8981\u6C42\uFF1A\u5355\u6587\u4EF6 HTML\uFF0C\u5305\u542B\u5185\u8054 CSS \u548C JS\uFF0C\u4E2D\u6587\u5185\u5BB9\u3002"
+   - \u6BCF\u6B21\u53EA\u53D1\u4E00\u4E2A\u5177\u4F53\u6B65\u9AA4
+
+4. **\u8FED\u4EE3/\u9A8C\u8BC1**\uFF1A\u9700\u8981\u65F6\u7EE7\u7EED\u59D4\u6D3E\u6216\u7528 bash \u8FD0\u884C\u9A8C\u8BC1
+
+## \u91CD\u8981
+
+- memo \u662F\u4F60\u4E0E\u7F16\u7801 Agent \u7684\u5171\u4EAB\u8BB0\u5FC6\uFF0C\u662F\u534F\u4F5C\u7684\u6838\u5FC3\u6865\u6881
+- \u4E0D\u8981\u91CD\u590D\u63A2\u7D22\uFF08glob \u67E5\u8FC7\u5C31\u4E0D\u8981\u518D bash ls \u540C\u4E00\u76EE\u5F55\uFF09
+- bash \u7528\u4E8E\u6267\u884C\u547D\u4EE4\uFF08\u6784\u5EFA\u3001\u6D4B\u8BD5\uFF09\uFF0C\u4E0D\u9700\u8981\u59D4\u6D3E
+- \u5B8C\u6210\u6240\u6709\u6B65\u9AA4\u540E\u7B80\u8981\u544A\u77E5\u7528\u6237\u7ED3\u679C`;
+      }
+      /**
+       * 切换协作模式
+       */
+      setMode(mode) {
+        this.mode = mode;
+        this.conversation.setSystemPrompt(this.buildSystemPrompt());
+      }
+      /**
+       * 执行用户请求
+       */
+      async run(userMessage, callbacks = {}) {
+        callbacks.onModeInfo?.(this.mode);
+        this.conversation.addUserMessage(userMessage);
+        let lastContent = "";
+        while (true) {
+          const tools = this.getTools();
+          const assistantMsg = await this.orchestratorClient.chatStream(
+            this.conversation.getMessages(),
+            tools,
+            callbacks
+          );
+          this.conversation.addAssistantMessage(assistantMsg);
+          if (!assistantMsg.tool_calls || assistantMsg.tool_calls.length === 0) {
+            lastContent = assistantMsg.content || "";
+            break;
+          }
+          for (const toolCall of assistantMsg.tool_calls) {
+            const toolName = toolCall.function.name;
+            let params;
+            try {
+              params = JSON.parse(toolCall.function.arguments);
+            } catch {
+              this.conversation.addToolResult(toolCall.id, "\u53C2\u6570\u89E3\u6790\u5931\u8D25\uFF1A\u65E0\u6548\u7684 JSON");
+              continue;
+            }
+            try {
+              if (toolName === "send-to-coder") {
+                const task = params["task"];
+                const coderResponse = await this.invokeCoder(task, callbacks);
+                this.conversation.addToolResult(toolCall.id, coderResponse);
+                continue;
+              }
+              const permLevel = this.registry.getPermissionLevel(toolName);
+              if (permLevel === "deny") {
+                callbacks.onDenied?.(toolName);
+                this.conversation.addToolResult(toolCall.id, `\u5DE5\u5177 "${toolName}" \u5DF2\u88AB\u7981\u6B62\u6267\u884C`);
+                continue;
+              }
+              if (permLevel === "auto") {
+                callbacks.onToolExecuting?.(toolName, params);
+              }
+              if (permLevel === "confirm") {
+                const confirmResult = await confirmExecution(toolName, params);
+                if (!confirmResult.approved) {
+                  callbacks.onDenied?.(toolName, confirmResult.feedback);
+                  const denyMsg = confirmResult.feedback ? `\u7528\u6237\u62D2\u7EDD\u4E86\u6B64\u64CD\u4F5C\uFF0C\u7528\u6237\u53CD\u9988: ${confirmResult.feedback}` : "\u7528\u6237\u62D2\u7EDD\u4E86\u6B64\u64CD\u4F5C";
+                  this.conversation.addToolResult(toolCall.id, denyMsg);
+                  continue;
+                }
+              }
+              const result = await this.registry.execute(toolName, params, this.config.max_tool_output);
+              callbacks.onToolResult?.(toolName, result.content, result.truncated ?? false);
+              this.conversation.addToolResult(toolCall.id, result.content);
+            } catch (err) {
+              const msg = err instanceof Error ? err.message : String(err);
+              this.conversation.addToolResult(toolCall.id, `\u5DE5\u5177\u6267\u884C\u5F02\u5E38\uFF1A${msg}`);
+            }
+          }
+          if (assistantMsg.content) {
+            lastContent = assistantMsg.content;
+          }
+        }
+        return lastContent;
+      }
+      /**
+       * 调用编码者 Agent
+       */
+      async invokeCoder(task, callbacks) {
+        callbacks.onCoderStart?.();
+        const modeInfo = getMode(this.mode);
+        let coderTools = [];
+        if (modeInfo.coderHasTools && modeInfo.coderToolNames) {
+          coderTools = this.registry.toToolDefinitions(modeInfo.coderToolNames);
+        }
+        let taskWithMemo = task;
+        if (this.memoStore) {
+          const index = this.memoStore.buildIndex();
+          if (index) {
+            taskWithMemo += `
+
+[\u5171\u4EAB\u5907\u5FD8\u5F55]
+${index}`;
+          }
+        }
+        taskWithMemo += "\n\n[\u91CD\u8981\uFF1A\u7ACB\u5373\u5F00\u59CB\u7F16\u7801\uFF0C\u4E0D\u8981\u63A2\u7D22\uFF0C\u4E0D\u8981\u8F93\u51FA\u5206\u6790]";
+        const coder = new Coder(
+          this.coderClient,
+          this.registry,
+          this.config,
+          modeInfo.coderSystemPrompt,
+          coderTools
+        );
+        const response = await coder.execute(taskWithMemo, {
+          onContent: callbacks.onContent,
+          onToolCallStreaming: callbacks.onToolCallStreaming,
+          onToolExecuting: callbacks.onToolExecuting,
+          onToolResult: callbacks.onToolResult,
+          onDenied: callbacks.onDenied
+        });
+        callbacks.onCoderEnd?.(response);
+        return response;
+      }
+      /**
+       * 获取对话历史
+       */
+      getConversation() {
+        return this.conversation;
+      }
+    };
+  }
+});
+
+// src/core/prompt/layers/core.ts
+import * as os2 from "os";
+function buildCorePrompt() {
+  return `\u4F60\u662F ZenCode\uFF0C\u4E00\u4E2A CLI \u73AF\u5883\u4E0B\u7684 AI \u7F16\u7A0B\u52A9\u624B\u3002\u4F60\u5E2E\u52A9\u7528\u6237\u5B8C\u6210\u8F6F\u4EF6\u5DE5\u7A0B\u4EFB\u52A1\uFF1A\u4FEEbug\u3001\u52A0\u529F\u80FD\u3001\u91CD\u6784\u4EE3\u7801\u3001\u89E3\u91CA\u4EE3\u7801\u7B49\u3002
+
+\u5DE5\u4F5C\u76EE\u5F55\uFF1A${process.cwd()}
+\u7CFB\u7EDF\uFF1A${os2.platform()} ${os2.arch()}
+
+# \u5DE5\u5177\u4F7F\u7528\u539F\u5219
+
+\u4F60\u6709\u4EE5\u4E0B\u5DE5\u5177\u53EF\u7528\uFF0C\u8BF7\u6839\u636E\u4EFB\u52A1\u9009\u62E9\u6700\u5408\u9002\u7684\u5DE5\u5177\uFF1A
+
+- **read-file**\uFF1A\u8BFB\u53D6\u6587\u4EF6\u5185\u5BB9\u3002\u4FEE\u6539\u4EE3\u7801\u524D\u5FC5\u987B\u5148\u8BFB\u53D6\u76EE\u6807\u6587\u4EF6\u3002\u652F\u6301 offset/limit \u8BFB\u53D6\u5927\u6587\u4EF6\u7684\u7279\u5B9A\u90E8\u5206\u3002
+- **edit-file**\uFF1A\u901A\u8FC7\u5B57\u7B26\u4E32\u66FF\u6362\u7F16\u8F91\u6587\u4EF6\u3002\u4F18\u5148\u4F7F\u7528 edit-file \u800C\u975E write-file \u4FEE\u6539\u5DF2\u6709\u6587\u4EF6\u2014\u2014\u5B83\u66F4\u7CBE\u786E\u3001\u66F4\u5B89\u5168\u3002old_string \u5FC5\u987B\u552F\u4E00\u5339\u914D\uFF0C\u5339\u914D\u5931\u8D25\u65F6\u63D0\u4F9B\u66F4\u591A\u4E0A\u4E0B\u6587\u4F7F\u5176\u552F\u4E00\u3002
+- **write-file**\uFF1A\u521B\u5EFA\u65B0\u6587\u4EF6\u6216\u5B8C\u6574\u91CD\u5199\u6587\u4EF6\u3002\u4EC5\u5728\u521B\u5EFA\u65B0\u6587\u4EF6\u6216\u9700\u8981\u5927\u5E45\u91CD\u5199\u65F6\u4F7F\u7528\u3002
+- **glob**\uFF1A\u6309\u6A21\u5F0F\u641C\u7D22\u6587\u4EF6\u8DEF\u5F84\u3002\u7528\u4E8E\u67E5\u627E\u6587\u4EF6\u4F4D\u7F6E\uFF08\u5982 \`**/*.ts\`\u3001\`src/**/config.*\`\uFF09\u3002
+- **grep**\uFF1A\u5728\u6587\u4EF6\u5185\u5BB9\u4E2D\u641C\u7D22\u6B63\u5219\u8868\u8FBE\u5F0F\u3002\u7528\u4E8E\u67E5\u627E\u51FD\u6570\u5B9A\u4E49\u3001\u5F15\u7528\u3001\u7279\u5B9A\u4EE3\u7801\u6A21\u5F0F\u3002
+- **bash**\uFF1A\u6267\u884C shell \u547D\u4EE4\u3002\u7528\u4E8E\u8FD0\u884C\u6784\u5EFA\u3001\u6D4B\u8BD5\u3001git \u64CD\u4F5C\u7B49\u3002\u4E0D\u8981\u7528 bash \u505A\u80FD\u7528\u4E0A\u8FF0\u5DE5\u5177\u5B8C\u6210\u7684\u4E8B\uFF08\u5982\u4E0D\u8981\u7528 cat \u8BFB\u6587\u4EF6\u3001\u4E0D\u8981\u7528 sed \u7F16\u8F91\u6587\u4EF6\u3001\u4E0D\u8981\u7528 find \u641C\u7D22\u6587\u4EF6\uFF09\u3002
+
+\u5173\u952E\u89C4\u5219\uFF1A
+- \u4FEE\u6539\u4EE3\u7801\u524D\u5148\u7528 read-file \u9605\u8BFB\u76F8\u5173\u6587\u4EF6\uFF0C\u7406\u89E3\u73B0\u6709\u903B\u8F91
+- \u4F18\u5148 edit-file \u7F16\u8F91\u5DF2\u6709\u6587\u4EF6\uFF0C\u800C\u975E write-file \u91CD\u5199
+- \u4E0D\u8981\u521B\u5EFA\u4E0D\u5FC5\u8981\u7684\u65B0\u6587\u4EF6\uFF0C\u4F18\u5148\u5728\u73B0\u6709\u6587\u4EF6\u4E2D\u4FEE\u6539
+- \u53EA\u505A\u5FC5\u8981\u7684\u6700\u5C0F\u6539\u52A8\uFF0C\u4E0D\u505A\u989D\u5916"\u6539\u8FDB"
+- \u4E0D\u8981\u6DFB\u52A0\u7528\u6237\u672A\u8981\u6C42\u7684\u6CE8\u91CA\u3001\u6587\u6863\u3001\u7C7B\u578B\u6CE8\u89E3
+- \u4E0D\u8981\u5F15\u5165\u5B89\u5168\u6F0F\u6D1E\uFF08\u6CE8\u5165\u3001XSS\u3001SQL \u6CE8\u5165\u7B49 OWASP Top 10\uFF09
+- \u5F15\u7528\u4EE3\u7801\u65F6\u4F7F\u7528 \`\u6587\u4EF6\u8DEF\u5F84:\u884C\u53F7\` \u683C\u5F0F\uFF08\u5982 \`src/app.ts:42\`\uFF09\uFF0C\u65B9\u4FBF\u7528\u6237\u8DF3\u8F6C
+
+# \u4EA4\u4E92\u98CE\u683C
+
+- \u4FDD\u6301\u6280\u672F\u5BA2\u89C2\u6027\uFF0C\u57FA\u4E8E\u4E8B\u5B9E\u56DE\u7B54\uFF0C\u4E0D\u8FC7\u5EA6\u8D5E\u540C\u6216\u606D\u7EF4\u7528\u6237\uFF0C\u5FC5\u8981\u65F6\u76F4\u63A5\u6307\u51FA\u95EE\u9898
+- \u4E0D\u786E\u5B9A\u65F6\u5148\u8C03\u67E5\u9A8C\u8BC1\uFF0C\u800C\u975E\u76F4\u89C9\u6027\u5730\u786E\u8BA4\u7528\u6237\u7684\u5047\u8BBE
+- \u4E0D\u8981\u7ED9\u51FA\u65F6\u95F4\u9884\u4F30\uFF08"\u5927\u6982\u9700\u8981\u51E0\u5206\u949F"\u4E4B\u7C7B\uFF09
+- \u56DE\u590D\u7B80\u6D01\uFF0C\u76F4\u63A5\u7ED9\u7ED3\u679C`;
+}
+var init_core = __esm({
+  "src/core/prompt/layers/core.ts"() {
+    "use strict";
+  }
+});
+
+// src/core/prompt/layers/planning.ts
+function buildPlanningPrompt() {
+  return `# \u5DE5\u4F5C\u65B9\u6CD5
+
+\u5904\u7406\u7F16\u7A0B\u4EFB\u52A1\u65F6\uFF1A
+1. \u5148\u7528 read-file / grep / glob \u9605\u8BFB\u76F8\u5173\u4EE3\u7801\uFF0C\u7406\u89E3\u73B0\u6709\u903B\u8F91\u548C\u4E0A\u4E0B\u6587
+2. \u786E\u5B9A\u65B9\u6848\u540E\u76F4\u63A5\u5B9E\u65BD\uFF0C\u4E0D\u8981\u957F\u7BC7\u89E3\u91CA\u8BA1\u5212
+3. \u6539\u5B8C\u5373\u6B62\uFF0C\u4E0D\u8981\u81EA\u884C"\u9A8C\u8BC1"\u6216"\u6D4B\u8BD5"
+
+\u591A\u6B65\u4EFB\u52A1\u7BA1\u7406\uFF1A
+- \u5BF9\u4E8E 3 \u4E2A\u4EE5\u4E0A\u6B65\u9AA4\u7684\u4EFB\u52A1\uFF0C\u4F7F\u7528 todo \u5DE5\u5177\u521B\u5EFA\u8BA1\u5212\u518D\u9010\u6B65\u6267\u884C
+- \u5F00\u59CB\u6B65\u9AA4\u524D\u6807\u8BB0 in-progress\uFF0C\u5B8C\u6210\u540E\u6807\u8BB0 completed
+- \u6BCF\u6B65\u5B8C\u6210\u540E\u68C0\u67E5\u8BA1\u5212\uFF0C\u51B3\u5B9A\u4E0B\u4E00\u6B65
+
+\u4EE3\u7801\u8D28\u91CF\uFF1A
+- \u4E0D\u8981\u5199\u4E0D\u5FC5\u8981\u7684\u6D4B\u8BD5\uFF1B\u5982\u679C\u8981\u5199\u6D4B\u8BD5\uFF0C\u5148\u786E\u8BA4\u9879\u76EE\u7684\u6D4B\u8BD5\u6846\u67B6\u548C\u4F9D\u8D56\uFF0C\u786E\u4FDD\u80FD\u5B9E\u9645\u8FD0\u884C
+- \u4E0D\u8981\u8FC7\u5EA6\u5DE5\u7A0B\u5316\uFF1A\u4E0D\u8981\u4E3A\u4E00\u6B21\u6027\u64CD\u4F5C\u521B\u5EFA\u62BD\u8C61\u3001\u4E0D\u8981\u4E3A\u5047\u8BBE\u7684\u672A\u6765\u9700\u6C42\u8BBE\u8BA1
+- \u4E0D\u8981\u4E3A\u4E0D\u53EF\u80FD\u53D1\u751F\u7684\u573A\u666F\u6DFB\u52A0\u9519\u8BEF\u5904\u7406\uFF1B\u53EA\u5728\u7CFB\u7EDF\u8FB9\u754C\uFF08\u7528\u6237\u8F93\u5165\u3001\u5916\u90E8 API\uFF09\u505A\u6821\u9A8C
+- \u5982\u679C\u5220\u9664\u4E86\u4EE3\u7801\uFF0C\u5C31\u5F7B\u5E95\u5220\u9664\uFF0C\u4E0D\u8981\u7559\u6CE8\u91CA\u8BF4"\u5DF2\u79FB\u9664"\uFF0C\u4E0D\u8981\u4FDD\u7559\u672A\u4F7F\u7528\u7684\u517C\u5BB9\u6027\u53D8\u91CF
+- \u4E09\u884C\u76F8\u4F3C\u4EE3\u7801\u4F18\u4E8E\u4E00\u4E2A\u8FC7\u65E9\u7684\u62BD\u8C61`;
+}
+var init_planning = __esm({
+  "src/core/prompt/layers/planning.ts"() {
+    "use strict";
+  }
+});
+
+// src/core/prompt/layers/parallel.ts
+function buildParallelPrompt() {
+  return `# \u5E76\u884C\u6267\u884C\uFF08\u91CD\u8981\uFF09
+
+\u5F53\u9700\u8981\u8BFB\u53D6\u3001\u641C\u7D22\u6216\u5206\u6790 2 \u4E2A\u4EE5\u4E0A\u72EC\u7ACB\u76EE\u6807\u65F6\uFF0C\u5FC5\u987B\u4F7F\u7528 spawn-agents \u5E76\u884C\u6267\u884C\uFF0C\u4E0D\u8981\u9010\u4E2A\u4E32\u884C\u8C03\u7528\u3002
+
+\u89C4\u5219\uFF1A
+- \u9700\u8981\u8BFB 2+ \u4E2A\u6587\u4EF6 \u2192 spawn-agents \u5E76\u884C\u8BFB\u53D6
+- \u9700\u8981\u641C\u7D22 2+ \u4E2A\u6A21\u5F0F \u2192 spawn-agents \u5E76\u884C\u641C\u7D22
+- \u9700\u8981\u4E86\u89E3 2+ \u4E2A\u6A21\u5757 \u2192 spawn-agents \u5E76\u884C\u5206\u6790
+- \u53EA\u6709 1 \u4E2A\u76EE\u6807 \u2192 \u76F4\u63A5\u7528\u5DE5\u5177\uFF0C\u65E0\u9700 spawn-agents
+
+\u793A\u4F8B - \u7528\u6237\u8BF4"\u5E2E\u6211\u7406\u89E3\u8BA4\u8BC1\u6A21\u5757"\uFF1A
+  \u6B63\u786E\uFF1Aspawn-agents \u540C\u65F6\u8BFB auth controller\u3001auth service\u3001auth middleware\u3001auth types
+  \u9519\u8BEF\uFF1A\u5148 read-file controller\uFF0C\u518D read-file service\uFF0C\u518D read-file middleware...
+
+\u6BCF\u4E2A\u5B50 Agent \u6709\u72EC\u7ACB\u5BF9\u8BDD\uFF0C\u9ED8\u8BA4\u53EF\u7528 read-file\u3001glob\u3001grep\u3001memo\u3002`;
+}
+var init_parallel = __esm({
+  "src/core/prompt/layers/parallel.ts"() {
+    "use strict";
+  }
+});
+
+// src/core/prompt/layers/git.ts
+function buildGitPrompt() {
+  return `# Git \u64CD\u4F5C
+
+\u5F53\u524D\u9879\u76EE\u4F7F\u7528 git \u7BA1\u7406\u3002
+
+\u63D0\u4EA4\u89C4\u8303\uFF1A
+- \u53EA\u5728\u7528\u6237\u660E\u786E\u8981\u6C42\u65F6\u624D\u521B\u5EFA commit
+- \u7528 git diff \u67E5\u770B\u53D8\u66F4\uFF0C\u518D\u5199 commit message
+- commit message \u63CF\u8FF0"\u4E3A\u4EC0\u4E48"\u800C\u975E"\u6539\u4E86\u4EC0\u4E48"
+
+\u5B89\u5168\u89C4\u5219\uFF1A
+- \u4E0D\u8981 force push\u3001reset --hard\u3001checkout .\u3001clean -f \u7B49\u7834\u574F\u6027\u64CD\u4F5C\uFF0C\u9664\u975E\u7528\u6237\u660E\u786E\u8981\u6C42
+- \u4E0D\u8981 --no-verify \u8DF3\u8FC7 hook\uFF0C\u9664\u975E\u7528\u6237\u660E\u786E\u8981\u6C42
+- \u4F18\u5148\u521B\u5EFA\u65B0 commit\uFF0C\u4E0D\u8981 --amend \u4FEE\u6539\u5DF2\u6709 commit\uFF0C\u9664\u975E\u7528\u6237\u660E\u786E\u8981\u6C42\uFF08hook \u5931\u8D25\u540E amend \u4F1A\u7834\u574F\u4E0A\u4E00\u4E2A commit\uFF09
+- git add \u65F6\u6307\u5B9A\u5177\u4F53\u6587\u4EF6\uFF0C\u907F\u514D git add -A \u610F\u5916\u6682\u5B58\u654F\u611F\u6587\u4EF6\uFF08.env\u3001credentials \u7B49\uFF09
+- \u4E0D\u8981\u4F7F\u7528\u4EA4\u4E92\u5F0F\u6807\u5FD7\uFF08git rebase -i\u3001git add -i\uFF09\uFF0CCLI \u73AF\u5883\u4E0D\u652F\u6301
+- \u4E0D\u8981\u4FEE\u6539 git config`;
+}
+var init_git = __esm({
+  "src/core/prompt/layers/git.ts"() {
+    "use strict";
+  }
+});
+
+// src/core/prompt/layers/project.ts
+import * as fs6 from "fs/promises";
+import * as path6 from "path";
+async function buildProjectPrompt() {
+  try {
+    const content = await fs6.readFile(path6.resolve("ZENCODE.md"), "utf-8");
+    return content.trim() || null;
+  } catch {
+    return null;
+  }
+}
+async function loadUserPrompts(paths) {
+  const prompts = [];
+  for (const p of paths) {
+    try {
+      const resolved = p.startsWith("~") ? path6.join(process.env["HOME"] || process.env["USERPROFILE"] || "", p.slice(1)) : path6.resolve(p);
+      const content = await fs6.readFile(resolved, "utf-8");
+      if (content.trim()) {
+        prompts.push(content.trim());
+      }
+    } catch {
+    }
+  }
+  return prompts;
+}
+var init_project = __esm({
+  "src/core/prompt/layers/project.ts"() {
+    "use strict";
+  }
+});
+
+// src/core/prompt/builder.ts
+import * as fs7 from "fs";
+function isGitRepo() {
+  try {
+    fs7.statSync(".git");
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function buildPrompt(config) {
+  const layers = [];
+  layers.push(buildCorePrompt());
+  if (config.features.planning_layer === "on") {
+    layers.push(buildPlanningPrompt());
+  }
+  const gitEnabled = config.features.git === "on" || config.features.git === "auto" && isGitRepo();
+  if (gitEnabled) {
+    layers.push(buildGitPrompt());
+  }
+  if (config.features.parallel_agents === "on") {
+    layers.push(buildParallelPrompt());
+  }
+  const projectPrompt = await buildProjectPrompt();
+  if (projectPrompt) {
+    layers.push(projectPrompt);
+  }
+  if (config.prompts.length > 0) {
+    const userPrompts = await loadUserPrompts(config.prompts);
+    layers.push(...userPrompts);
+  }
+  const systemPrompt = layers.join("\n\n");
+  return { systemPrompt, layers };
+}
+var init_builder = __esm({
+  "src/core/prompt/builder.ts"() {
+    "use strict";
+    init_core();
+    init_planning();
+    init_parallel();
+    init_git();
+    init_project();
+  }
+});
+
+// src/core/todo-store.ts
+var TodoStore;
+var init_todo_store = __esm({
+  "src/core/todo-store.ts"() {
+    "use strict";
+    TodoStore = class {
+      plan = null;
+      listeners = /* @__PURE__ */ new Set();
+      create(items) {
+        this.plan = {
+          items: items.map((item) => ({
+            id: item.id,
+            title: item.title,
+            status: "pending"
+          }))
+        };
+        this.notify();
+        return this.plan;
+      }
+      update(id, status) {
+        if (!this.plan) return null;
+        const item = this.plan.items.find((i) => i.id === id);
+        if (!item) return null;
+        item.status = status;
+        this.notify();
+        return { ...item };
+      }
+      list() {
+        return this.plan;
+      }
+      clear() {
+        this.plan = null;
+        this.notify();
+      }
+      subscribe(listener) {
+        this.listeners.add(listener);
+        return () => {
+          this.listeners.delete(listener);
+        };
+      }
+      notify() {
+        const snapshot = this.plan ? { items: this.plan.items.map((i) => ({ ...i })) } : null;
+        for (const listener of this.listeners) {
+          listener(snapshot);
+        }
+      }
+    };
+  }
+});
+
+// src/core/memo-store.ts
+var MAX_ENTRIES, MAX_CONTENT_LENGTH, MemoStore;
+var init_memo_store = __esm({
+  "src/core/memo-store.ts"() {
+    "use strict";
+    MAX_ENTRIES = 30;
+    MAX_CONTENT_LENGTH = 3e3;
+    MemoStore = class {
+      entries = /* @__PURE__ */ new Map();
+      write(key, content, author = "agent") {
+        const trimmed = content.slice(0, MAX_CONTENT_LENGTH);
+        const entry = { key, content: trimmed, author, updatedAt: Date.now() };
+        if (!this.entries.has(key) && this.entries.size >= MAX_ENTRIES) {
+          let oldest = null;
+          let oldestTime = Infinity;
+          for (const [k, v] of this.entries) {
+            if (v.updatedAt < oldestTime) {
+              oldestTime = v.updatedAt;
+              oldest = k;
+            }
+          }
+          if (oldest) this.entries.delete(oldest);
+        }
+        this.entries.set(key, entry);
+        return entry;
+      }
+      read(key) {
+        return this.entries.get(key) ?? null;
+      }
+      list() {
+        return [...this.entries.values()].map((e) => ({
+          key: e.key,
+          author: e.author,
+          preview: e.content.slice(0, 80)
+        }));
+      }
+      delete(key) {
+        return this.entries.delete(key);
+      }
+      clear() {
+        this.entries.clear();
+      }
+      /**
+       * 生成简短的备忘录索引（用于注入 Agent 系统提示词）
+       * 仅包含 key 列表和简短预览，占用极少 token
+       */
+      buildIndex() {
+        if (this.entries.size === 0) return null;
+        const lines = [...this.entries.values()].map(
+          (e) => `- ${e.key}: ${e.content.slice(0, 50)}`
+        );
+        return lines.join("\n");
+      }
+    };
+  }
+});
+
+// src/core/sub-agent.ts
+var DEFAULT_TIMEOUT_MS, SubAgent;
+var init_sub_agent = __esm({
+  "src/core/sub-agent.ts"() {
+    "use strict";
+    init_conversation();
+    DEFAULT_TIMEOUT_MS = 12e4;
+    SubAgent = class {
+      client;
+      registry;
+      config;
+      task;
+      allowedTools;
+      maxTurns;
+      timeoutMs;
+      memoStore;
+      constructor(client, registry, config, task, allowedTools = ["read-file", "glob", "grep", "memo"], maxTurns = 10, timeoutMs = DEFAULT_TIMEOUT_MS, memoStore) {
+        this.client = client;
+        this.registry = registry;
+        this.config = config;
+        this.task = task;
+        this.allowedTools = allowedTools.filter((t) => t !== "spawn-agents" && t !== "todo");
+        this.maxTurns = Math.min(maxTurns, 15);
+        this.timeoutMs = timeoutMs;
+        this.memoStore = memoStore;
+      }
+      async run() {
+        return Promise.race([
+          this.execute(),
+          this.timeout()
+        ]);
+      }
+      timeout() {
+        return new Promise((_, reject) => {
+          setTimeout(
+            () => reject(new Error(`\u5B50 Agent \u8D85\u65F6\uFF08${this.timeoutMs / 1e3}s\uFF09`)),
+            this.timeoutMs
+          );
+        });
+      }
+      async execute() {
+        const conversation = new Conversation();
+        let systemPrompt = `\u4F60\u662F ZenCode \u5B50 Agent\u3002\u4F60\u7684\u4EFB\u52A1\uFF1A${this.task}
+\u5B8C\u6210\u540E\u76F4\u63A5\u8FD4\u56DE\u7ED3\u679C\uFF0C\u4E0D\u8981\u591A\u4F59\u89E3\u91CA\u3002`;
+        if (this.memoStore) {
+          const index = this.memoStore.buildIndex();
+          if (index) {
+            systemPrompt += `
+
+[\u5171\u4EAB\u5907\u5FD8\u5F55 - \u53EF\u7528 memo read \u8BFB\u53D6\u8BE6\u60C5]
+${index}`;
+          }
+        }
+        conversation.setSystemPrompt(systemPrompt);
+        conversation.addUserMessage(this.task);
+        const tools = this.registry.toToolDefinitions(this.allowedTools);
+        let lastContent = "";
+        for (let turn = 0; turn < this.maxTurns; turn++) {
+          const assistantMsg = await this.client.chat(
+            conversation.getMessages(),
+            tools.length > 0 ? tools : void 0
+          );
+          conversation.addAssistantMessage(assistantMsg);
+          if (!assistantMsg.tool_calls || assistantMsg.tool_calls.length === 0) {
+            lastContent = assistantMsg.content || "";
+            break;
+          }
+          for (const toolCall of assistantMsg.tool_calls) {
+            const toolName = toolCall.function.name;
+            if (!this.allowedTools.includes(toolName)) {
+              conversation.addToolResult(
+                toolCall.id,
+                `\u5B50 Agent \u4E0D\u5141\u8BB8\u4F7F\u7528\u5DE5\u5177 "${toolName}"`
+              );
+              continue;
+            }
+            let params;
+            try {
+              params = JSON.parse(toolCall.function.arguments);
+            } catch {
+              conversation.addToolResult(toolCall.id, "\u53C2\u6570\u89E3\u6790\u5931\u8D25\uFF1A\u65E0\u6548\u7684 JSON");
+              continue;
+            }
+            try {
+              const result = await this.registry.execute(
+                toolName,
+                params,
+                this.config.max_tool_output
+              );
+              conversation.addToolResult(toolCall.id, result.content);
+            } catch (err) {
+              const msg = err instanceof Error ? err.message : String(err);
+              conversation.addToolResult(toolCall.id, `\u5DE5\u5177\u6267\u884C\u5F02\u5E38\uFF1A${msg}`);
+            }
+          }
+          if (assistantMsg.content) {
+            lastContent = assistantMsg.content;
+          }
+        }
+        return lastContent;
+      }
+    };
+  }
+});
+
+// src/tools/spawn-agents.ts
+function createSpawnAgentsTool(client, registry, config, tracker, memoStore) {
+  return {
+    name: "spawn-agents",
+    description: "\u5E76\u884C\u542F\u52A8\u591A\u4E2A\u5B50 Agent \u6267\u884C\u4EFB\u52A1\u3002\u6BCF\u4E2A\u5B50 Agent \u6709\u72EC\u7ACB\u5BF9\u8BDD\uFF0C\u9ED8\u8BA4\u53EA\u80FD\u7528\u53EA\u8BFB\u5DE5\u5177 (read-file, glob, grep)\u3002\u9002\u7528\u4E8E\u540C\u65F6\u8BFB\u53D6\u548C\u5206\u6790\u591A\u4E2A\u6587\u4EF6\u3001\u641C\u7D22\u591A\u4E2A\u6A21\u5F0F\u7B49\u573A\u666F\u3002",
+    parameters: {
+      type: "object",
+      properties: {
+        tasks: {
+          type: "array",
+          description: "\u8981\u5E76\u884C\u6267\u884C\u7684\u4EFB\u52A1\u5217\u8868",
+          items: {
+            type: "object",
+            properties: {
+              description: {
+                type: "string",
+                description: "\u4EFB\u52A1\u63CF\u8FF0"
+              },
+              tools: {
+                type: "array",
+                description: "\u5141\u8BB8\u4F7F\u7528\u7684\u5DE5\u5177\u5217\u8868\uFF08\u9ED8\u8BA4 read-file, glob, grep\uFF09\uFF0C\u4E0D\u53EF\u5305\u542B spawn-agents",
+                items: { type: "string" }
+              }
+            },
+            required: ["description"]
+          }
+        },
+        max_turns: {
+          type: "number",
+          description: "\u6BCF\u4E2A\u5B50 Agent \u7684\u6700\u5927\u8F6E\u6570\uFF08\u9ED8\u8BA4 10\uFF0C\u4E0A\u9650 15\uFF09"
+        }
+      },
+      required: ["tasks"]
+    },
+    permissionLevel: "auto",
+    async execute(params) {
+      const tasks = params["tasks"];
+      const maxTurns = Math.min(
+        params["max_turns"] || 10,
+        MAX_TURNS_LIMIT
+      );
+      if (!tasks || tasks.length === 0) {
+        return { content: "\u9519\u8BEF\uFF1A\u672A\u63D0\u4F9B\u4EFB\u52A1" };
+      }
+      if (tasks.length > MAX_CONCURRENT) {
+        return { content: `\u9519\u8BEF\uFF1A\u6700\u591A\u652F\u6301 ${MAX_CONCURRENT} \u4E2A\u5E76\u53D1\u4EFB\u52A1` };
+      }
+      const autoTools = registry.listTools().filter((t) => registry.getPermissionLevel(t) === "auto" && t !== "spawn-agents");
+      const descriptions = tasks.map((t) => t.description);
+      tracker?.start(descriptions);
+      const agents = tasks.map((task) => {
+        let tools = task.tools ? task.tools.filter((t) => t !== "spawn-agents").filter((t) => autoTools.includes(t)) : DEFAULT_TOOLS.filter((t) => autoTools.includes(t));
+        if (tools.length === 0) {
+          tools = DEFAULT_TOOLS.filter((t) => autoTools.includes(t));
+        }
+        return new SubAgent(client, registry, config, task.description, tools, maxTurns, void 0, memoStore);
+      });
+      const wrappedRuns = agents.map(
+        (agent) => agent.run().then(
+          (result) => {
+            tracker?.markCompleted();
+            return result;
+          },
+          (err) => {
+            tracker?.markFailed();
+            throw err;
+          }
+        )
+      );
+      const results = await Promise.allSettled(wrappedRuns);
+      tracker?.finish();
+      const succeeded = results.filter((r) => r.status === "fulfilled").length;
+      const failed = results.filter((r) => r.status === "rejected").length;
+      const output = results.map((result, i) => {
+        const task = tasks[i];
+        const status = result.status === "fulfilled" ? "\u2713" : "\u2717";
+        const header = `=== ${status} \u4EFB\u52A1 ${i + 1}: ${task.description} ===`;
+        if (result.status === "fulfilled") {
+          return `${header}
+${result.value}`;
+        }
+        return `${header}
+\u9519\u8BEF: ${result.reason}`;
+      }).join("\n\n");
+      const summary = `[${succeeded} \u6210\u529F${failed > 0 ? `, ${failed} \u5931\u8D25` : ""}]`;
+      return { content: `${summary}
+
+${output}` };
+    }
+  };
+}
+var DEFAULT_TOOLS, MAX_CONCURRENT, MAX_TURNS_LIMIT;
+var init_spawn_agents = __esm({
+  "src/tools/spawn-agents.ts"() {
+    "use strict";
+    init_sub_agent();
+    DEFAULT_TOOLS = ["read-file", "glob", "grep", "memo"];
+    MAX_CONCURRENT = 10;
+    MAX_TURNS_LIMIT = 15;
+  }
+});
+
+// src/tools/todo.ts
+function createTodoTool(store) {
+  return {
+    name: "todo",
+    description: "\u7BA1\u7406\u4EFB\u52A1\u8BA1\u5212\u3002\u652F\u6301\u521B\u5EFA\u8BA1\u5212\u3001\u66F4\u65B0\u6761\u76EE\u72B6\u6001\u3001\u67E5\u770B\u8BA1\u5212\u548C\u6E05\u7A7A\u8BA1\u5212\u3002\u5BF9\u4E8E\u5305\u542B\u591A\u4E2A\u6B65\u9AA4\u7684\u4EFB\u52A1\uFF0C\u5148\u521B\u5EFA\u8BA1\u5212\u518D\u9010\u6B65\u6267\u884C\u3002",
+    parameters: {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          description: "\u64CD\u4F5C\u7C7B\u578B",
+          enum: ["create", "update", "list", "clear"]
+        },
+        items: {
+          type: "array",
+          description: "create \u65F6\u5FC5\u586B\uFF1A\u8BA1\u5212\u6761\u76EE\u5217\u8868",
+          items: {
+            type: "object",
+            properties: {
+              id: { type: "string", description: "\u6761\u76EE ID" },
+              title: { type: "string", description: "\u6761\u76EE\u6807\u9898" }
+            },
+            required: ["id", "title"]
+          }
+        },
+        id: {
+          type: "string",
+          description: "update \u65F6\u5FC5\u586B\uFF1A\u8981\u66F4\u65B0\u7684\u6761\u76EE ID"
+        },
+        status: {
+          type: "string",
+          description: "update \u65F6\u5FC5\u586B\uFF1A\u65B0\u72B6\u6001",
+          enum: ["pending", "in-progress", "completed"]
+        }
+      },
+      required: ["action"]
+    },
+    permissionLevel: "auto",
+    async execute(params) {
+      const action = params["action"];
+      switch (action) {
+        case "create": {
+          const items = params["items"];
+          if (!items || items.length === 0) {
+            return { content: "\u9519\u8BEF\uFF1Acreate \u9700\u8981\u63D0\u4F9B items" };
+          }
+          const plan = store.create(items);
+          const lines = plan.items.map(
+            (item) => `\u25CB [${item.id}] ${item.title}`
+          );
+          return {
+            content: `\u8BA1\u5212\u5DF2\u521B\u5EFA\uFF08${plan.items.length} \u4E2A\u6761\u76EE\uFF09\uFF1A
+${lines.join("\n")}`
+          };
+        }
+        case "update": {
+          const id = params["id"];
+          const status = params["status"];
+          if (!id || !status) {
+            return { content: "\u9519\u8BEF\uFF1Aupdate \u9700\u8981\u63D0\u4F9B id \u548C status" };
+          }
+          const item = store.update(
+            id,
+            status
+          );
+          if (!item) {
+            return { content: `\u9519\u8BEF\uFF1A\u672A\u627E\u5230\u6761\u76EE "${id}"` };
+          }
+          const icon = item.status === "completed" ? "\u25CF" : item.status === "in-progress" ? "\u25D0" : "\u25CB";
+          return {
+            content: `\u5DF2\u66F4\u65B0\uFF1A${icon} [${item.id}] ${item.title} \u2192 ${item.status}`
+          };
+        }
+        case "list": {
+          const plan = store.list();
+          if (!plan) {
+            return { content: "\u5F53\u524D\u6CA1\u6709\u8BA1\u5212" };
+          }
+          const completed = plan.items.filter(
+            (i) => i.status === "completed"
+          ).length;
+          const lines = plan.items.map((item) => {
+            const icon = item.status === "completed" ? "\u25CF" : item.status === "in-progress" ? "\u25D0" : "\u25CB";
+            return `${icon} [${item.id}] ${item.title}`;
+          });
+          return {
+            content: `\u8BA1\u5212\u8FDB\u5EA6 ${completed}/${plan.items.length}\uFF1A
+${lines.join("\n")}`
+          };
+        }
+        case "clear": {
+          store.clear();
+          return { content: "\u8BA1\u5212\u5DF2\u6E05\u7A7A" };
+        }
+        default:
+          return {
+            content: `\u9519\u8BEF\uFF1A\u672A\u77E5\u64CD\u4F5C "${action}"\u3002\u652F\u6301: create, update, list, clear`
+          };
+      }
+    }
+  };
+}
+var init_todo = __esm({
+  "src/tools/todo.ts"() {
+    "use strict";
+  }
+});
+
+// src/tools/memo.ts
+function createMemoTool(store) {
+  return {
+    name: "memo",
+    description: "\u5171\u4EAB\u5907\u5FD8\u5F55\uFF1A\u5728\u591A\u4E2A Agent \u4E4B\u95F4\u5171\u4EAB\u4FE1\u606F\u3002write \u5199\u5165\u53D1\u73B0/\u51B3\u7B56/\u6458\u8981\u4F9B\u5176\u4ED6 Agent \u8BFB\u53D6\uFF0Cread \u6309 key \u8BFB\u53D6\uFF0Clist \u67E5\u770B\u6240\u6709\u53EF\u7528\u6761\u76EE\u3002",
+    parameters: {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          description: "\u64CD\u4F5C\u7C7B\u578B",
+          enum: ["write", "read", "list", "delete", "clear"]
+        },
+        key: {
+          type: "string",
+          description: "write/read/delete \u65F6\u5FC5\u586B\uFF1A\u5907\u5FD8\u5F55 key"
+        },
+        content: {
+          type: "string",
+          description: "write \u65F6\u5FC5\u586B\uFF1A\u8981\u5199\u5165\u7684\u5185\u5BB9\uFF08\u5EFA\u8BAE\u7B80\u6D01\u6458\u8981\uFF0C\u6700\u591A 3000 \u5B57\u7B26\uFF09"
+        }
+      },
+      required: ["action"]
+    },
+    permissionLevel: "auto",
+    async execute(params) {
+      const action = params["action"];
+      switch (action) {
+        case "write": {
+          const key = params["key"];
+          const content = params["content"];
+          if (!key || !content) {
+            return { content: "\u9519\u8BEF\uFF1Awrite \u9700\u8981\u63D0\u4F9B key \u548C content" };
+          }
+          const entry = store.write(key, content);
+          return { content: `\u5DF2\u5199\u5165 memo [${entry.key}]\uFF08${entry.content.length} \u5B57\u7B26\uFF09` };
+        }
+        case "read": {
+          const key = params["key"];
+          if (!key) {
+            return { content: "\u9519\u8BEF\uFF1Aread \u9700\u8981\u63D0\u4F9B key" };
+          }
+          const entry = store.read(key);
+          if (!entry) {
+            return { content: `memo [${key}] \u4E0D\u5B58\u5728` };
+          }
+          return { content: `[${entry.key}] by ${entry.author}:
+${entry.content}` };
+        }
+        case "list": {
+          const items = store.list();
+          if (items.length === 0) {
+            return { content: "\u5907\u5FD8\u5F55\u4E3A\u7A7A" };
+          }
+          const lines = items.map(
+            (item) => `[${item.key}] (${item.author}) ${item.preview}`
+          );
+          return { content: `\u5171 ${items.length} \u6761\u5907\u5FD8\u5F55\uFF1A
+${lines.join("\n")}` };
+        }
+        case "delete": {
+          const key = params["key"];
+          if (!key) {
+            return { content: "\u9519\u8BEF\uFF1Adelete \u9700\u8981\u63D0\u4F9B key" };
+          }
+          const ok = store.delete(key);
+          return { content: ok ? `\u5DF2\u5220\u9664 memo [${key}]` : `memo [${key}] \u4E0D\u5B58\u5728` };
+        }
+        case "clear": {
+          store.clear();
+          return { content: "\u5907\u5FD8\u5F55\u5DF2\u6E05\u7A7A" };
+        }
+        default:
+          return { content: `\u9519\u8BEF\uFF1A\u672A\u77E5\u64CD\u4F5C "${action}"\u3002\u652F\u6301: write, read, list, delete, clear` };
+      }
+    }
+  };
+}
+var init_memo = __esm({
+  "src/tools/memo.ts"() {
+    "use strict";
+  }
+});
+
+// src/cli/tui/bridge.ts
+function createThinkFilter() {
+  let inThink = false;
+  let tagBuffer = "";
+  let lineStart = true;
+  let postThink = false;
+  return function filter(text) {
+    let result = "";
+    for (let i = 0; i < text.length; i++) {
+      const ch = text[i];
+      if (tagBuffer.length > 0) {
+        tagBuffer += ch;
+        if (tagBuffer === "<think>") {
+          inThink = true;
+          lineStart = true;
+          tagBuffer = "";
+          result += `\u256D\u2500 \u{1F4AD} ${THINK_BORDER}
+`;
+        } else if (tagBuffer === "</think>") {
+          inThink = false;
+          postThink = true;
+          tagBuffer = "";
+          result += `
+\u2570${THINK_BORDER}\u2500\u2500\u2500
+
+`;
+        } else if (!"<think>".startsWith(tagBuffer) && !"</think>".startsWith(tagBuffer)) {
+          if (inThink && lineStart) {
+            result += "\u2502 ";
+            lineStart = false;
+          }
+          result += tagBuffer;
+          tagBuffer = "";
+        }
+        continue;
+      }
+      if (ch === "<") {
+        tagBuffer = "<";
+        continue;
+      }
+      if (inThink) {
+        if (lineStart) {
+          result += "\u2502 ";
+          lineStart = false;
+        }
+        result += ch;
+        if (ch === "\n") {
+          lineStart = true;
+        }
+      } else {
+        if (postThink) {
+          if (ch === "\n" || ch === "\r" || ch === " " || ch === "	") continue;
+          postThink = false;
+        }
+        result += ch;
+      }
+    }
+    return result;
+  };
+}
+function createTokenBatcher(dispatch) {
+  let buffer = "";
+  let timer = null;
+  function flush() {
+    if (buffer.length > 0) {
+      const text = buffer;
+      buffer = "";
+      dispatch({ type: "APPEND_CONTENT", text });
+    }
+  }
+  function start() {
+    if (!timer) {
+      timer = setInterval(flush, BATCH_INTERVAL_MS);
+    }
+  }
+  function stop() {
+    flush();
+    if (timer) {
+      clearInterval(timer);
+      timer = null;
+    }
+  }
+  function append(text) {
+    buffer += text;
+    start();
+  }
+  function pause() {
+    if (timer) {
+      clearInterval(timer);
+      timer = null;
+    }
+  }
+  return { append, stop, flush, pause };
+}
+function extractCodeFromArgs(name, args) {
+  const field = name === "write-file" ? "content" : "new_string";
+  const patterns = [`"${field}": "`, `"${field}":"`];
+  for (const pattern of patterns) {
+    const idx = args.indexOf(pattern);
+    if (idx >= 0) {
+      let raw = args.slice(idx + pattern.length);
+      if (raw.endsWith('"}')) raw = raw.slice(0, -2);
+      else if (raw.endsWith('"')) raw = raw.slice(0, -1);
+      return raw.replace(/\\n/g, "\n").replace(/\\t/g, "	").replace(/\\"/g, '"').replace(/\\\\/g, "\\");
+    }
+  }
+  return null;
+}
+function registerConfirmToolId(toolName, id) {
+  activeToolIds.set(toolName, id);
+}
+function createBridgeCallbacks(dispatch) {
+  const batcher = createTokenBatcher(dispatch);
+  const thinkFilter = createThinkFilter();
+  activeToolIds = /* @__PURE__ */ new Map();
+  streamingToolIds = /* @__PURE__ */ new Map();
+  lastStreamingArgs = /* @__PURE__ */ new Map();
+  toolCallCounter = 0;
+  let streamingThrottleTimer = null;
+  let pendingStreamingUpdate = null;
+  function flushStreamingUpdate() {
+    if (pendingStreamingUpdate) {
+      pendingStreamingUpdate();
+      pendingStreamingUpdate = null;
+    }
+    if (streamingThrottleTimer) {
+      clearTimeout(streamingThrottleTimer);
+      streamingThrottleTimer = null;
+    }
+  }
+  return {
+    onContent: (text) => {
+      const filtered = thinkFilter(text);
+      if (filtered) batcher.append(filtered);
+    },
+    onToolCallStreaming: (index, name, accumulatedArgs) => {
+      if (!streamingToolIds.has(index)) {
+        batcher.flush();
+        const id2 = `tool-${++toolCallCounter}`;
+        streamingToolIds.set(index, id2);
+        activeToolIds.set(name, id2);
+        dispatch({ type: "TOOL_STREAMING", id: id2, name, streamingContent: "0" });
+      }
+      const id = streamingToolIds.get(index);
+      lastStreamingArgs.set(id, accumulatedArgs);
+      const lineCount = (accumulatedArgs.match(/\\n/g) || []).length;
+      pendingStreamingUpdate = () => {
+        dispatch({ type: "TOOL_STREAMING", id, name, streamingContent: String(lineCount) });
+      };
+      if (!streamingThrottleTimer) {
+        streamingThrottleTimer = setTimeout(() => {
+          flushStreamingUpdate();
+        }, 80);
+      }
+    },
+    onToolExecuting: (name, params) => {
+      flushStreamingUpdate();
+      batcher.flush();
+      batcher.pause();
+      const existingId = activeToolIds.get(name);
+      const id = existingId || `tool-${++toolCallCounter}`;
+      activeToolIds.set(name, id);
+      dispatch({ type: "TOOL_EXECUTING", id, name, params });
+    },
+    onToolResult: (name, result, truncated) => {
+      const id = activeToolIds.get(name) || `tool-${++toolCallCounter}`;
+      const lines = result.split("\n");
+      const isWriteTool = name === "write-file" || name === "edit-file";
+      let summary;
+      if (isWriteTool) {
+        const code = extractCodeFromArgs(name, lastStreamingArgs.get(id) || "");
+        const codeLines = code ? code.split("\n").length : 0;
+        summary = codeLines > 0 ? `${codeLines} \u884C` : truncated ? "\u8F93\u51FA\u5DF2\u622A\u65AD" : `${lines.length} \u884C`;
+      } else {
+        summary = truncated ? `\u8F93\u51FA\u5DF2\u622A\u65AD` : `${lines.length} \u884C`;
+      }
+      const preview = lines.slice(0, 5).join("\n").slice(0, 200);
+      const resultContent = lines.length > 5 || preview.length >= 200 ? preview + "..." : preview;
+      dispatch({ type: "TOOL_RESULT", id, resultSummary: summary, resultContent });
+    },
+    onCoderStart: () => {
+      batcher.flush();
+      dispatch({ type: "CODER_START" });
+    },
+    onCoderEnd: () => {
+      dispatch({ type: "CODER_END" });
+    },
+    onDenied: (toolName, feedback) => {
+      const id = activeToolIds.get(toolName) || `tool-${++toolCallCounter}`;
+      dispatch({ type: "TOOL_DENIED", id, feedback });
+    },
+    onError: (err) => {
+      batcher.stop();
+      dispatch({ type: "SET_ERROR", error: err.message });
+    },
+    // Called internally when streaming is complete
+    _stopBatcher: () => {
+      batcher.stop();
+    }
+  };
+}
+var BATCH_INTERVAL_MS, THINK_BORDER, toolCallCounter, activeToolIds, streamingToolIds, lastStreamingArgs;
+var init_bridge = __esm({
+  "src/cli/tui/bridge.ts"() {
+    "use strict";
+    BATCH_INTERVAL_MS = 64;
+    THINK_BORDER = "\u2500".repeat(40);
+    toolCallCounter = 0;
+    activeToolIds = /* @__PURE__ */ new Map();
+    streamingToolIds = /* @__PURE__ */ new Map();
+    lastStreamingArgs = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/core/sub-agent-tracker.ts
+var SubAgentTracker;
+var init_sub_agent_tracker = __esm({
+  "src/core/sub-agent-tracker.ts"() {
+    "use strict";
+    SubAgentTracker = class {
+      progress = null;
+      listeners = /* @__PURE__ */ new Set();
+      start(descriptions) {
+        this.progress = {
+          total: descriptions.length,
+          completed: 0,
+          failed: 0,
+          descriptions
+        };
+        this.notify();
+      }
+      markCompleted() {
+        if (!this.progress) return;
+        this.progress = { ...this.progress, completed: this.progress.completed + 1 };
+        this.notify();
+      }
+      markFailed() {
+        if (!this.progress) return;
+        this.progress = { ...this.progress, failed: this.progress.failed + 1 };
+        this.notify();
+      }
+      finish() {
+        this.progress = null;
+        this.notify();
+      }
+      get current() {
+        return this.progress;
+      }
+      subscribe(listener) {
+        this.listeners.add(listener);
+        return () => {
+          this.listeners.delete(listener);
+        };
+      }
+      notify() {
+        const snapshot = this.progress ? { ...this.progress } : null;
+        for (const listener of this.listeners) {
+          listener(snapshot);
+        }
+      }
+    };
+  }
+});
+
+// src/cli/tui/state.ts
+function createInitialState(modelName, agentMode, collaboration) {
+  return {
+    messages: [],
+    isRunning: false,
+    error: void 0,
+    coderWorking: false,
+    modelName,
+    agentMode,
+    collaboration,
+    todoPlan: null,
+    subAgentProgress: null
+  };
+}
+function nextId() {
+  return `msg-${++messageCounter}`;
+}
+function updateLastAssistant(messages, updater) {
+  const result = [...messages];
+  for (let i = result.length - 1; i >= 0; i--) {
+    if (result[i].role === "assistant") {
+      result[i] = updater(result[i]);
+      return result;
+    }
+  }
+  return result;
+}
+function updateToolInBlocks(blocks, toolId, updater) {
+  return blocks.map((b) => {
+    if (b.type === "tool" && b.toolCall.id === toolId) {
+      return { type: "tool", toolCall: updater(b.toolCall) };
+    }
+    return b;
+  });
+}
+function tuiReducer(state, action) {
+  switch (action.type) {
+    case "ADD_USER_MESSAGE":
+      return {
+        ...state,
+        messages: [
+          ...state.messages,
+          {
+            id: nextId(),
+            role: "user",
+            blocks: [{ type: "text", text: action.text }],
+            isStreaming: false
+          }
+        ]
+      };
+    case "START_ASSISTANT":
+      return {
+        ...state,
+        error: void 0,
+        messages: [
+          ...state.messages,
+          {
+            id: nextId(),
+            role: "assistant",
+            blocks: [],
+            isStreaming: true
+          }
+        ]
+      };
+    case "APPEND_CONTENT": {
+      return {
+        ...state,
+        messages: updateLastAssistant(state.messages, (msg) => {
+          const blocks = [...msg.blocks];
+          const last = blocks[blocks.length - 1];
+          if (last && last.type === "text") {
+            blocks[blocks.length - 1] = { type: "text", text: last.text + action.text };
+          } else {
+            blocks.push({ type: "text", text: action.text });
+          }
+          return { ...msg, blocks };
+        })
+      };
+    }
+    case "TOOL_EXECUTING": {
+      return {
+        ...state,
+        messages: updateLastAssistant(state.messages, (msg) => {
+          const existingIdx = msg.blocks.findIndex(
+            (b) => b.type === "tool" && b.toolCall.id === action.id
+          );
+          if (existingIdx >= 0) {
+            return {
+              ...msg,
+              blocks: updateToolInBlocks(msg.blocks, action.id, (tc) => ({
+                ...tc,
+                status: "running",
+                params: action.params
+              }))
+            };
+          }
+          return {
+            ...msg,
+            blocks: [
+              ...msg.blocks,
+              {
+                type: "tool",
+                toolCall: {
+                  id: action.id,
+                  name: action.name,
+                  params: action.params,
+                  status: "running"
+                }
+              }
+            ]
+          };
+        })
+      };
+    }
+    case "TOOL_STREAMING": {
+      return {
+        ...state,
+        messages: updateLastAssistant(state.messages, (msg) => {
+          const existingIdx = msg.blocks.findIndex(
+            (b) => b.type === "tool" && b.toolCall.id === action.id
+          );
+          if (existingIdx >= 0) {
+            return {
+              ...msg,
+              blocks: updateToolInBlocks(msg.blocks, action.id, (tc) => ({
+                ...tc,
+                streamingContent: action.streamingContent
+              }))
+            };
+          }
+          return {
+            ...msg,
+            blocks: [
+              ...msg.blocks,
+              {
+                type: "tool",
+                toolCall: {
+                  id: action.id,
+                  name: action.name,
+                  params: {},
+                  status: "running",
+                  streamingContent: action.streamingContent
+                }
+              }
+            ]
+          };
+        })
+      };
+    }
+    case "TOOL_RESULT": {
+      return {
+        ...state,
+        messages: updateLastAssistant(state.messages, (msg) => ({
+          ...msg,
+          blocks: updateToolInBlocks(msg.blocks, action.id, (tc) => ({
+            ...tc,
+            status: "done",
+            resultSummary: action.resultSummary,
+            resultContent: action.resultContent
+          }))
+        }))
+      };
+    }
+    case "TOOL_DENIED": {
+      return {
+        ...state,
+        messages: updateLastAssistant(state.messages, (msg) => ({
+          ...msg,
+          blocks: updateToolInBlocks(msg.blocks, action.id, (tc) => ({
+            ...tc,
+            status: "denied",
+            denyFeedback: action.feedback
+          }))
+        }))
+      };
+    }
+    case "TOOL_CONFIRMING": {
+      return {
+        ...state,
+        messages: updateLastAssistant(state.messages, (msg) => ({
+          ...msg,
+          blocks: [
+            ...msg.blocks,
+            {
+              type: "tool",
+              toolCall: {
+                id: action.id,
+                name: action.name,
+                params: action.params,
+                status: "confirming"
+              }
+            }
+          ],
+          confirmPending: {
+            toolName: action.name,
+            params: action.params,
+            resolve: action.resolve
+          }
+        }))
+      };
+    }
+    case "CONFIRM_RESPONDED": {
+      return {
+        ...state,
+        messages: updateLastAssistant(state.messages, (msg) => ({
+          ...msg,
+          confirmPending: void 0
+        }))
+      };
+    }
+    case "FINISH_STREAMING":
+      return {
+        ...state,
+        messages: updateLastAssistant(state.messages, (msg) => ({
+          ...msg,
+          isStreaming: false
+        }))
+      };
+    case "SET_RUNNING":
+      return { ...state, isRunning: action.running };
+    case "SET_ERROR":
+      return { ...state, error: action.error, isRunning: false };
+    case "CLEAR_ERROR":
+      return { ...state, error: void 0 };
+    case "CODER_START":
+      return { ...state, coderWorking: true };
+    case "CODER_END":
+      return { ...state, coderWorking: false };
+    case "CLEAR_MESSAGES":
+      return { ...state, messages: [] };
+    case "SET_MODE":
+      return { ...state, agentMode: action.agentMode, collaboration: action.collaboration };
+    case "SET_TODO_PLAN":
+      return { ...state, todoPlan: action.plan };
+    case "SET_SUB_AGENT_PROGRESS":
+      return { ...state, subAgentProgress: action.progress };
+    default:
+      return state;
+  }
+}
+var messageCounter;
+var init_state = __esm({
+  "src/cli/tui/state.ts"() {
+    "use strict";
+    messageCounter = 0;
+  }
+});
+
+// src/cli/tui/components/ToolCallLine.tsx
+import { Box, Text } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+function getToolParamSummary(name, params) {
+  switch (name) {
+    case "bash":
+      return String(params["command"] || "").slice(0, 60);
+    case "read-file":
+    case "write-file":
+    case "edit-file":
+      return String(params["path"] || "");
+    case "glob":
+      return String(params["pattern"] || "");
+    case "grep":
+      return String(params["pattern"] || "");
+    case "send-to-coder":
+      return String(params["task"] || "").slice(0, 40);
+    case "spawn-agents": {
+      const tasks = params["tasks"];
+      if (!tasks) return "";
+      if (tasks.length <= 2) {
+        return tasks.map((t) => t.description.slice(0, 30)).join(", ");
+      }
+      return `${tasks.length} \u4E2A\u5E76\u884C\u4EFB\u52A1`;
+    }
+    case "todo": {
+      const action = String(params["action"] || "");
+      const id = params["id"] ? ` [${params["id"]}]` : "";
+      return `${action}${id}`;
+    }
+    case "memo": {
+      const action = String(params["action"] || "");
+      const key = params["key"] ? ` [${params["key"]}]` : "";
+      return `${action}${key}`;
+    }
+    default: {
+      const keys = Object.keys(params);
+      if (keys.length > 0 && keys[0]) {
+        return String(params[keys[0]] || "").slice(0, 40);
+      }
+      return "";
+    }
+  }
+}
+function getToolIcon(name) {
+  switch (name) {
+    case "bash":
+      return "$";
+    case "write-file":
+      return "+";
+    case "edit-file":
+      return "\xB1";
+    case "read-file":
+      return "\u{1F4C4}";
+    case "glob":
+      return "\u{1F50D}";
+    case "grep":
+      return "\u{1F50D}";
+    case "spawn-agents":
+      return "\u26A1";
+    case "todo":
+      return "\u{1F4CB}";
+    case "memo":
+      return "\u{1F4DD}";
+    default:
+      return "\u2699";
+  }
+}
+function getCodeContent(name, params) {
+  if (name === "write-file") {
+    return params["content"] || null;
+  }
+  if (name === "edit-file") {
+    return params["new_string"] || null;
+  }
+  return null;
+}
+function truncateCode(code, maxLines) {
+  const lines = code.split("\n");
+  if (lines.length <= maxLines) return code;
+  return lines.slice(0, maxLines).join("\n") + `
+... (\u5171 ${lines.length} \u884C)`;
+}
+function ToolCallLine({ toolCall }) {
+  const { name, params, status, resultSummary, resultContent, denyFeedback } = toolCall;
+  const summary = getToolParamSummary(name, params);
+  const icon = getToolIcon(name);
+  const isWriteTool = name === "write-file" || name === "edit-file";
+  const rawCode = isWriteTool && status === "done" ? getCodeContent(name, params) : null;
+  let statusNode;
+  let statusText = "";
+  switch (status) {
+    case "running":
+      statusNode = /* @__PURE__ */ jsx(Text, { color: "yellow", children: "\u23F3" });
+      break;
+    case "done":
+      statusNode = /* @__PURE__ */ jsx(Text, { color: "green", children: "\u2713" });
+      statusText = resultSummary || "";
+      break;
+    case "denied":
+      statusNode = /* @__PURE__ */ jsx(Text, { color: "red", children: "\u2717" });
+      statusText = "denied";
+      break;
+    case "confirming":
+      statusNode = /* @__PURE__ */ jsx(Text, { color: "yellow", children: "\u26A0" });
+      statusText = "[y/N]";
+      break;
+  }
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginLeft: 2, children: [
+    /* @__PURE__ */ jsxs(Box, { gap: 1, children: [
+      statusNode,
+      /* @__PURE__ */ jsxs(Text, { color: "yellow", bold: true, children: [
+        icon,
+        " ",
+        name
+      ] }),
+      summary ? /* @__PURE__ */ jsx(Text, { dimColor: true, children: summary }) : null,
+      statusText ? /* @__PURE__ */ jsx(Text, { dimColor: true, children: statusText }) : null
+    ] }),
+    status === "done" && rawCode && /* @__PURE__ */ jsx(Box, { marginLeft: 3, marginTop: 0, children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: truncateCode(rawCode, 5) }) }),
+    status === "done" && !isWriteTool && resultContent && /* @__PURE__ */ jsx(
+      Box,
+      {
+        marginLeft: 3,
+        marginTop: 0,
+        borderStyle: "single",
+        borderColor: "gray",
+        paddingX: 1,
+        children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: resultContent })
+      }
+    ),
+    status === "denied" && denyFeedback && /* @__PURE__ */ jsxs(Box, { marginLeft: 3, gap: 1, children: [
+      /* @__PURE__ */ jsx(Text, { color: "red", children: "\u53CD\u9988:" }),
+      /* @__PURE__ */ jsx(Text, { children: denyFeedback })
+    ] })
+  ] });
+}
+var init_ToolCallLine = __esm({
+  "src/cli/tui/components/ToolCallLine.tsx"() {
+    "use strict";
+  }
+});
+
+// src/cli/tui/components/MessageBubble.tsx
+import React from "react";
+import { Box as Box2, Text as Text2 } from "ink";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var MessageBubble;
+var init_MessageBubble = __esm({
+  "src/cli/tui/components/MessageBubble.tsx"() {
+    "use strict";
+    init_ToolCallLine();
+    MessageBubble = React.memo(function MessageBubble2({ message }) {
+      const { role, blocks, isStreaming } = message;
+      const color = role === "user" ? "green" : role === "assistant" ? "cyan" : "gray";
+      const icon = role === "user" ? ">" : role === "assistant" ? "\u25C6" : "\u2022";
+      return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", marginBottom: 1, children: [
+        blocks.map((block, i) => {
+          if (block.type === "text") {
+            return /* @__PURE__ */ jsxs2(Box2, { children: [
+              i === 0 ? /* @__PURE__ */ jsxs2(Text2, { color, bold: true, children: [
+                icon,
+                " "
+              ] }) : /* @__PURE__ */ jsx2(Text2, { children: "  " }),
+              /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", flexGrow: 1, children: /* @__PURE__ */ jsx2(Text2, { children: block.text }) })
+            ] }, `text-${i}`);
+          } else {
+            return /* @__PURE__ */ jsx2(ToolCallLine, { toolCall: block.toolCall }, block.toolCall.id);
+          }
+        }),
+        blocks.length === 0 && /* @__PURE__ */ jsxs2(Box2, { children: [
+          /* @__PURE__ */ jsxs2(Text2, { color, bold: true, children: [
+            icon,
+            " "
+          ] }),
+          isStreaming && /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "..." })
+        ] })
+      ] });
+    });
+  }
+});
+
+// src/cli/tui/components/ChatArea.tsx
+import React2, { useRef } from "react";
+import { Static, Box as Box3, Text as Text3 } from "ink";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function splitMessages(messages) {
+  let staticEnd = 0;
+  for (let i = 0; i < messages.length; i++) {
+    if (messages[i].isStreaming || messages[i].confirmPending) break;
+    staticEnd = i + 1;
+  }
+  const dynamicMsgs = messages.slice(staticEnd);
+  const streamingMsg = dynamicMsgs.find((m) => m.isStreaming) || null;
+  const otherDynamic = dynamicMsgs.filter((m) => m !== streamingMsg);
+  return {
+    staticMsgs: messages.slice(0, staticEnd),
+    streamingMsg,
+    otherDynamic
+  };
+}
+function extractFromBlocks(msg, staticItems, dynamicNodes, isStreaming) {
+  let lineIdx = 0;
+  for (let bi = 0; bi < msg.blocks.length; bi++) {
+    const block = msg.blocks[bi];
+    const isLastBlock = bi === msg.blocks.length - 1;
+    if (block.type === "text") {
+      const lines = block.text.split("\n");
+      if (isStreaming && isLastBlock) {
+        const partial = lines.pop() || "";
+        for (const line of lines) {
+          staticItems.push({
+            id: `${msg.id}-L${lineIdx}`,
+            type: "line",
+            text: line,
+            isFirstLine: lineIdx === 0
+          });
+          lineIdx++;
+        }
+        if (partial || lineIdx === 0) {
+          dynamicNodes.push(
+            /* @__PURE__ */ jsxs3(Box3, { children: [
+              /* @__PURE__ */ jsx3(Text3, { color: "cyan", bold: true, children: lineIdx === 0 ? "\u25C6 " : "  " }),
+              /* @__PURE__ */ jsx3(Box3, { flexGrow: 1, children: /* @__PURE__ */ jsx3(Text3, { children: partial }) })
+            ] }, "partial")
+          );
+        }
+      } else {
+        for (const line of lines) {
+          staticItems.push({
+            id: `${msg.id}-L${lineIdx}`,
+            type: "line",
+            text: line,
+            isFirstLine: lineIdx === 0
+          });
+          lineIdx++;
+        }
+      }
+    } else if (block.type === "tool") {
+      const tc = block.toolCall;
+      const isWriteTool = tc.name === "write-file" || tc.name === "edit-file";
+      staticItems.push({
+        id: `${msg.id}-TH${tc.id}`,
+        type: "tool-header",
+        toolCall: tc
+      });
+      if (isWriteTool && tc.status === "running" && isStreaming) {
+        const lineCount = parseInt(tc.streamingContent || "0", 10);
+        dynamicNodes.push(
+          /* @__PURE__ */ jsx3(Box3, { paddingX: 1, marginLeft: 4, children: /* @__PURE__ */ jsxs3(Text3, { color: "cyan", children: [
+            "\u270E \u751F\u6210\u4E2D...",
+            lineCount > 0 ? ` ${lineCount} \u884C` : ""
+          ] }) }, `tool-progress-${tc.id}`)
+        );
+      }
+      if (tc.status === "done" || tc.status === "denied") {
+        staticItems.push({
+          id: `${msg.id}-TD${tc.id}`,
+          type: "tool-done",
+          toolCall: tc
+        });
+      }
+    }
+  }
+}
+function renderStaticItem(item) {
+  if (item.type === "message") {
+    return /* @__PURE__ */ jsx3(Box3, { paddingX: 1, children: /* @__PURE__ */ jsx3(MessageBubble, { message: item.message }) }, item.id);
+  }
+  if (item.type === "line") {
+    return /* @__PURE__ */ jsxs3(Box3, { paddingX: 1, children: [
+      /* @__PURE__ */ jsx3(Text3, { color: "cyan", bold: true, children: item.isFirstLine ? "\u25C6 " : "  " }),
+      /* @__PURE__ */ jsx3(Text3, { children: item.text })
+    ] }, item.id);
+  }
+  if (item.type === "tool-header") {
+    const tc = item.toolCall;
+    const icon = getToolIcon(tc.name);
+    const summary = getToolParamSummary(tc.name, tc.params);
+    return /* @__PURE__ */ jsx3(Box3, { paddingX: 1, marginLeft: 2, children: /* @__PURE__ */ jsxs3(Box3, { gap: 1, children: [
+      /* @__PURE__ */ jsx3(Text3, { color: "yellow", children: "\u23F3" }),
+      /* @__PURE__ */ jsxs3(Text3, { color: "yellow", bold: true, children: [
+        icon,
+        " ",
+        tc.name
+      ] }),
+      summary ? /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: summary }) : null
+    ] }) }, item.id);
+  }
+  if (item.type === "tool-done") {
+    return /* @__PURE__ */ jsx3(Box3, { paddingX: 1, marginLeft: 0, children: /* @__PURE__ */ jsx3(ToolCallLine, { toolCall: item.toolCall }) }, item.id);
+  }
+  return null;
+}
+var ChatArea;
+var init_ChatArea = __esm({
+  "src/cli/tui/components/ChatArea.tsx"() {
+    "use strict";
+    init_MessageBubble();
+    init_ToolCallLine();
+    ChatArea = React2.memo(function ChatArea2({ messages }) {
+      const { staticMsgs, streamingMsg, otherDynamic } = splitMessages(messages);
+      const streamedIds = useRef(/* @__PURE__ */ new Set());
+      if (streamingMsg) {
+        streamedIds.current.add(streamingMsg.id);
+      }
+      const currentItems = [];
+      for (const msg of staticMsgs) {
+        if (streamedIds.current.has(msg.id)) {
+          const ignore = [];
+          extractFromBlocks(msg, currentItems, ignore, false);
+        } else {
+          currentItems.push({ id: msg.id, type: "message", message: msg });
+        }
+      }
+      const dynamicNodes = [];
+      if (streamingMsg) {
+        extractFromBlocks(streamingMsg, currentItems, dynamicNodes, true);
+      }
+      const seenIds = useRef(/* @__PURE__ */ new Set());
+      const accumulated = useRef([]);
+      let hasNew = false;
+      for (const item of currentItems) {
+        if (!seenIds.current.has(item.id)) {
+          seenIds.current.add(item.id);
+          accumulated.current.push(item);
+          hasNew = true;
+        }
+      }
+      if (hasNew) {
+        accumulated.current = [...accumulated.current];
+      }
+      const staticItems = accumulated.current;
+      const showPlaceholder = streamingMsg && streamingMsg.blocks.length === 0;
+      return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", children: [
+        staticItems.length > 0 && /* @__PURE__ */ jsx3(Static, { items: staticItems, children: renderStaticItem }),
+        (dynamicNodes.length > 0 || showPlaceholder) && /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", paddingX: 1, children: [
+          showPlaceholder && /* @__PURE__ */ jsxs3(Box3, { children: [
+            /* @__PURE__ */ jsx3(Text3, { color: "cyan", bold: true, children: "\u25C6 " }),
+            /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "..." })
+          ] }),
+          dynamicNodes
+        ] }),
+        otherDynamic.map((msg) => /* @__PURE__ */ jsx3(Box3, { paddingX: 1, children: /* @__PURE__ */ jsx3(MessageBubble, { message: msg }) }, msg.id))
+      ] });
+    });
+  }
+});
+
+// src/cli/tui/components/InputArea.tsx
+import { useState } from "react";
+import { Box as Box4, Text as Text4, useInput } from "ink";
+import { Fragment, jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+function CleanTextInput({ onSubmit, placeholder }) {
+  const [value, setValue] = useState("");
+  const [cursor, setCursor] = useState(0);
+  useInput((input, key) => {
+    if (key.return) {
+      const trimmed = value.trim();
+      if (trimmed) {
+        onSubmit(trimmed);
+      }
+      setValue("");
+      setCursor(0);
+      return;
+    }
+    if (key.backspace || key.delete) {
+      if (cursor > 0) {
+        setValue((prev) => prev.slice(0, cursor - 1) + prev.slice(cursor));
+        setCursor((prev) => prev - 1);
+      }
+      return;
+    }
+    if (key.leftArrow) {
+      setCursor((prev) => Math.max(0, prev - 1));
+      return;
+    }
+    if (key.rightArrow) {
+      setCursor((prev) => Math.min(value.length, prev + 1));
+      return;
+    }
+    if (input === "a" && key.ctrl) {
+      setCursor(0);
+      return;
+    }
+    if (input === "e" && key.ctrl) {
+      setCursor(value.length);
+      return;
+    }
+    if (input === "u" && key.ctrl) {
+      setValue((prev) => prev.slice(cursor));
+      setCursor(0);
+      return;
+    }
+    if (key.ctrl || key.meta || key.escape) return;
+    if (!input || input.length === 0) return;
+    if (input.includes("\x1B") || input.includes("\0")) return;
+    if (/^(?:\[<\d+;\d+;\d+[Mm])+$/.test(input)) return;
+    if (/^\[<[0-9;Mm]*$/.test(input)) return;
+    if (input === "[5~" || input === "[6~") return;
+    for (let i = 0; i < input.length; i++) {
+      const code = input.charCodeAt(i);
+      if (code < 32 && code !== 9) return;
+      if (code === 127 || code >= 128 && code <= 159) return;
+    }
+    setValue((prev) => prev.slice(0, cursor) + input + prev.slice(cursor));
+    setCursor((prev) => prev + input.length);
+  });
+  if (value.length === 0) {
+    return /* @__PURE__ */ jsxs4(Fragment, { children: [
+      /* @__PURE__ */ jsx4(Text4, { inverse: true, children: " " }),
+      /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: placeholder || "" })
+    ] });
+  }
+  const before = value.slice(0, cursor);
+  const at = cursor < value.length ? value[cursor] : " ";
+  const after = cursor < value.length ? value.slice(cursor + 1) : "";
+  return /* @__PURE__ */ jsxs4(Fragment, { children: [
+    /* @__PURE__ */ jsx4(Text4, { children: before }),
+    /* @__PURE__ */ jsx4(Text4, { inverse: true, children: at }),
+    /* @__PURE__ */ jsx4(Text4, { children: after })
+  ] });
+}
+function InputArea({ onSubmit, isRunning }) {
+  return /* @__PURE__ */ jsxs4(Box4, { paddingX: 1, children: [
+    /* @__PURE__ */ jsx4(Text4, { color: isRunning ? "gray" : "green", bold: true, children: "> " }),
+    isRunning ? /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "\u7B49\u5F85\u56DE\u590D\u4E2D..." }) : /* @__PURE__ */ jsx4(
+      CleanTextInput,
+      {
+        onSubmit,
+        placeholder: "\u8F93\u5165\u6D88\u606F\u6216 /\u547D\u4EE4..."
+      }
+    )
+  ] });
+}
+var init_InputArea = __esm({
+  "src/cli/tui/components/InputArea.tsx"() {
+    "use strict";
+  }
+});
+
+// src/cli/tui/components/StatusBar.tsx
+import { Box as Box5, Text as Text5 } from "ink";
+import { Fragment as Fragment2, jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+function StatusBar({ agentMode, collaboration, coderWorking, isRunning, modelName, todoPlan, subAgentProgress }) {
+  const modeLabel = agentMode === "dual" ? `dual(${collaboration})` : "single";
+  const todoProgress = todoPlan ? `${todoPlan.items.filter((i) => i.status === "completed").length}/${todoPlan.items.length}` : null;
+  return /* @__PURE__ */ jsxs5(Box5, { paddingX: 1, gap: 1, children: [
+    /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "\u2500\u2500" }),
+    /* @__PURE__ */ jsx5(Text5, { bold: true, children: modeLabel }),
+    /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "\u25B6" }),
+    /* @__PURE__ */ jsx5(Text5, { bold: true, children: modelName }),
+    coderWorking && /* @__PURE__ */ jsxs5(Fragment2, { children: [
+      /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "\u2502" }),
+      /* @__PURE__ */ jsx5(Text5, { color: "yellow", children: "\u2699 coder" })
+    ] }),
+    isRunning && !coderWorking && !subAgentProgress && /* @__PURE__ */ jsxs5(Fragment2, { children: [
+      /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "\u2502" }),
+      /* @__PURE__ */ jsx5(Text5, { color: "cyan", children: "thinking..." })
+    ] }),
+    subAgentProgress && /* @__PURE__ */ jsxs5(Fragment2, { children: [
+      /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "\u2502" }),
+      /* @__PURE__ */ jsxs5(Text5, { color: "magenta", children: [
+        "\u26A1 ",
+        subAgentProgress.completed + subAgentProgress.failed,
+        "/",
+        subAgentProgress.total,
+        " agents"
+      ] })
+    ] }),
+    todoProgress && /* @__PURE__ */ jsxs5(Fragment2, { children: [
+      /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "\u2502" }),
+      /* @__PURE__ */ jsxs5(Text5, { color: "cyan", children: [
+        "plan ",
+        todoProgress
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "\u2502" }),
+    /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "/help" })
+  ] });
+}
+var init_StatusBar = __esm({
+  "src/cli/tui/components/StatusBar.tsx"() {
+    "use strict";
+  }
+});
+
+// src/cli/tui/components/ConfirmPrompt.tsx
+import { useState as useState2 } from "react";
+import { Box as Box6, Text as Text6, useInput as useInput2 } from "ink";
+import { Fragment as Fragment3, jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+function getToolDetails(toolName, params) {
+  const lines = [];
+  let label = toolName;
+  switch (toolName) {
+    case "bash":
+      label = "Bash";
+      lines.push(`\u547D\u4EE4: ${String(params["command"] || "")}`);
+      break;
+    case "write-file":
+      label = "Write";
+      lines.push(`\u6587\u4EF6: ${String(params["path"] || "")}`);
+      if (params["content"]) {
+        const content = String(params["content"]);
+        const preview = content.length > 120 ? content.slice(0, 120) + "..." : content;
+        lines.push(`\u5185\u5BB9: ${preview.split("\n").slice(0, 3).join("\n      ")}`);
+      }
+      break;
+    case "edit-file":
+      label = "Edit";
+      lines.push(`\u6587\u4EF6: ${String(params["path"] || "")}`);
+      if (params["old_string"]) {
+        const old = String(params["old_string"]);
+        const preview = old.length > 80 ? old.slice(0, 80) + "..." : old;
+        lines.push(`\u66FF\u6362: ${preview}`);
+      }
+      if (params["new_string"]) {
+        const neu = String(params["new_string"]);
+        const preview = neu.length > 80 ? neu.slice(0, 80) + "..." : neu;
+        lines.push(`\u4E3A:   ${preview}`);
+      }
+      break;
+    case "git":
+      label = "Git";
+      lines.push(`\u547D\u4EE4: git ${String(params["command"] || "")}`);
+      break;
+    default:
+      for (const [key, value] of Object.entries(params)) {
+        const str = typeof value === "string" ? value : JSON.stringify(value);
+        lines.push(`${key}: ${str.slice(0, 80)}`);
+      }
+      break;
+  }
+  return { lines, label };
+}
+function FeedbackInput({ onSubmit }) {
+  const [value, setValue] = useState2("");
+  const [cursor, setCursor] = useState2(0);
+  useInput2((input, key) => {
+    if (key.return) {
+      onSubmit(value);
+      setValue("");
+      setCursor(0);
+      return;
+    }
+    if (key.backspace || key.delete) {
+      if (cursor > 0) {
+        setValue((prev) => prev.slice(0, cursor - 1) + prev.slice(cursor));
+        setCursor((prev) => prev - 1);
+      }
+      return;
+    }
+    if (key.leftArrow) {
+      setCursor((prev) => Math.max(0, prev - 1));
+      return;
+    }
+    if (key.rightArrow) {
+      setCursor((prev) => Math.min(value.length, prev + 1));
+      return;
+    }
+    if (key.escape) {
+      onSubmit("");
+      return;
+    }
+    if (key.ctrl || key.meta) return;
+    if (!input || input.length === 0) return;
+    if (input.includes("\x1B") || input.includes("\0")) return;
+    for (let i = 0; i < input.length; i++) {
+      const code = input.charCodeAt(i);
+      if (code < 32) return;
+      if (code === 127 || code >= 128 && code <= 159) return;
+    }
+    setValue((prev) => prev.slice(0, cursor) + input + prev.slice(cursor));
+    setCursor((prev) => prev + input.length);
+  });
+  if (value.length === 0) {
+    return /* @__PURE__ */ jsxs6(Fragment3, { children: [
+      /* @__PURE__ */ jsx6(Text6, { inverse: true, children: " " }),
+      /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "\u8F93\u5165\u53CD\u9988\u6307\u4EE4\u7ED9 AI..." })
+    ] });
+  }
+  const before = value.slice(0, cursor);
+  const at = cursor < value.length ? value[cursor] : " ";
+  const after = cursor < value.length ? value.slice(cursor + 1) : "";
+  return /* @__PURE__ */ jsxs6(Fragment3, { children: [
+    /* @__PURE__ */ jsx6(Text6, { children: before }),
+    /* @__PURE__ */ jsx6(Text6, { inverse: true, children: at }),
+    /* @__PURE__ */ jsx6(Text6, { children: after })
+  ] });
+}
+function ConfirmPrompt({ confirm, onRespond }) {
+  const [selected, setSelected] = useState2(0);
+  const [feedbackMode, setFeedbackMode] = useState2(false);
+  useInput2((input, key) => {
+    if (feedbackMode) return;
+    if (key.leftArrow) {
+      setSelected((prev) => (prev - 1 + OPTIONS.length) % OPTIONS.length);
+    } else if (key.rightArrow) {
+      setSelected((prev) => (prev + 1) % OPTIONS.length);
+    } else if (key.return) {
+      onRespond(OPTIONS[selected].key);
+    } else if (input === "y" || input === "Y") {
+      onRespond("allow");
+    } else if (input === "n" || input === "N") {
+      onRespond("deny");
+    } else if (input === "a" || input === "A") {
+      onRespond("always");
+    } else if (key.tab) {
+      setFeedbackMode(true);
+    } else if (key.escape) {
+      onRespond("deny");
+    }
+  }, { isActive: !feedbackMode });
+  const { lines, label } = getToolDetails(confirm.toolName, confirm.params);
+  if (feedbackMode) {
+    return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", paddingX: 1, children: [
+      /* @__PURE__ */ jsxs6(
+        Box6,
+        {
+          flexDirection: "column",
+          borderStyle: "round",
+          borderColor: "yellow",
+          paddingX: 1,
+          children: [
+            /* @__PURE__ */ jsx6(Text6, { bold: true, color: "yellow", children: label }),
+            lines.map((line, i) => /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: line }, i))
+          ]
+        }
+      ),
+      /* @__PURE__ */ jsxs6(Box6, { paddingX: 1, gap: 1, children: [
+        /* @__PURE__ */ jsx6(Text6, { color: "cyan", children: "\u53CD\u9988: " }),
+        /* @__PURE__ */ jsx6(
+          FeedbackInput,
+          {
+            onSubmit: (text) => {
+              const trimmed = text.trim();
+              if (trimmed) {
+                onRespond({ feedback: trimmed });
+              } else {
+                setFeedbackMode(false);
+              }
+            }
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsx6(Box6, { paddingX: 1, children: /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "Enter \u53D1\u9001  Esc \u8FD4\u56DE\u9009\u62E9" }) })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", paddingX: 1, children: [
+    /* @__PURE__ */ jsxs6(
+      Box6,
+      {
+        flexDirection: "column",
+        borderStyle: "round",
+        borderColor: "yellow",
+        paddingX: 1,
+        children: [
+          /* @__PURE__ */ jsx6(Text6, { bold: true, color: "yellow", children: label }),
+          lines.map((line, i) => /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: line }, i))
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsx6(Box6, { marginTop: 0, paddingX: 1, gap: 2, children: OPTIONS.map((opt, i) => {
+      const isSelected = i === selected;
+      return /* @__PURE__ */ jsx6(Box6, { children: isSelected ? /* @__PURE__ */ jsxs6(Text6, { bold: true, color: "cyan", inverse: true, children: [
+        " ",
+        opt.label,
+        " "
+      ] }) : /* @__PURE__ */ jsxs6(Text6, { dimColor: true, children: [
+        " ",
+        opt.label,
+        " "
+      ] }) }, opt.key);
+    }) }),
+    /* @__PURE__ */ jsx6(Box6, { paddingX: 1, children: /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "\u2190 \u2192 \u9009\u62E9  Enter \u786E\u8BA4  y \u5141\u8BB8  n \u62D2\u7EDD  a \u59CB\u7EC8  Tab \u53CD\u9988" }) })
+  ] });
+}
+var OPTIONS;
+var init_ConfirmPrompt = __esm({
+  "src/cli/tui/components/ConfirmPrompt.tsx"() {
+    "use strict";
+    OPTIONS = [
+      { key: "allow", label: "\u5141\u8BB8" },
+      { key: "always", label: "\u59CB\u7EC8\u5141\u8BB8" },
+      { key: "deny", label: "\u62D2\u7EDD" }
+    ];
+  }
+});
+
+// src/cli/tui/components/TodoPanel.tsx
+import { Box as Box7, Text as Text7 } from "ink";
+import { jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
+function getStatusIcon(status) {
+  switch (status) {
+    case "completed":
+      return "\u25CF";
+    case "in-progress":
+      return "\u25D0";
+    default:
+      return "\u25CB";
+  }
+}
+function getStatusColor(status) {
+  switch (status) {
+    case "completed":
+      return "green";
+    case "in-progress":
+      return "yellow";
+    default:
+      return "gray";
+  }
+}
+function TodoPanel({ plan }) {
+  const completed = plan.items.filter((i) => i.status === "completed").length;
+  const total = plan.items.length;
+  return /* @__PURE__ */ jsxs7(
+    Box7,
+    {
+      flexDirection: "column",
+      borderStyle: "round",
+      borderColor: "cyan",
+      paddingX: 1,
+      marginBottom: 0,
+      children: [
+        /* @__PURE__ */ jsxs7(Box7, { justifyContent: "space-between", children: [
+          /* @__PURE__ */ jsx7(Text7, { bold: true, color: "cyan", children: "Plan" }),
+          /* @__PURE__ */ jsxs7(Text7, { dimColor: true, children: [
+            completed,
+            "/",
+            total
+          ] })
+        ] }),
+        plan.items.map((item) => /* @__PURE__ */ jsxs7(Box7, { gap: 1, children: [
+          /* @__PURE__ */ jsx7(Text7, { color: getStatusColor(item.status), children: getStatusIcon(item.status) }),
+          /* @__PURE__ */ jsx7(
+            Text7,
+            {
+              color: item.status === "completed" ? "green" : void 0,
+              dimColor: item.status === "pending",
+              children: item.title
+            }
+          )
+        ] }, item.id))
+      ]
+    }
+  );
+}
+var init_TodoPanel = __esm({
+  "src/cli/tui/components/TodoPanel.tsx"() {
+    "use strict";
+  }
+});
+
+// src/cli/tui/App.tsx
+import { useReducer, useCallback, useEffect, useRef as useRef2, useState as useState3 } from "react";
+import { Box as Box8, Text as Text8, useInput as useInput3 } from "ink";
+import { jsx as jsx8, jsxs as jsxs8 } from "react/jsx-runtime";
+function App({ config, client, agent, orchestrator, registry, todoStore, memoStore, subAgentTracker }) {
+  const [state, dispatch] = useReducer(
+    tuiReducer,
+    createInitialState(
+      config.model,
+      config.agent_mode,
+      config.collaboration
+    )
+  );
+  const [resetKey, setResetKey] = useState3(0);
+  const agentRef = useRef2(agent);
+  const orchestratorRef = useRef2(orchestrator);
+  const todoStoreRef = useRef2(todoStore);
+  const subAgentTrackerRef = useRef2(subAgentTracker);
+  agentRef.current = agent;
+  orchestratorRef.current = orchestrator;
+  todoStoreRef.current = todoStore;
+  subAgentTrackerRef.current = subAgentTracker;
+  useEffect(() => {
+    return todoStoreRef.current.subscribe((plan) => {
+      dispatch({ type: "SET_TODO_PLAN", plan });
+    });
+  }, []);
+  useEffect(() => {
+    let timer = null;
+    let latest = null;
+    const unsub = subAgentTrackerRef.current.subscribe((progress) => {
+      latest = progress;
+      if (progress === null) {
+        if (timer) {
+          clearTimeout(timer);
+          timer = null;
+        }
+        dispatch({ type: "SET_SUB_AGENT_PROGRESS", progress: null });
+        return;
+      }
+      if (!timer) {
+        dispatch({ type: "SET_SUB_AGENT_PROGRESS", progress });
+        timer = setTimeout(() => {
+          timer = null;
+          if (latest) dispatch({ type: "SET_SUB_AGENT_PROGRESS", progress: latest });
+        }, 2e3);
+      }
+    });
+    return () => {
+      unsub();
+      if (timer) clearTimeout(timer);
+    };
+  }, []);
+  const confirmPending = state.messages.reduce(
+    (found, msg) => found || msg.confirmPending,
+    void 0
+  );
+  useEffect(() => {
+    setStructuredConfirmHandler((toolName, params) => {
+      return new Promise((resolve7) => {
+        const id = `confirm-${Date.now()}`;
+        registerConfirmToolId(toolName, id);
+        dispatch({
+          type: "TOOL_CONFIRMING",
+          id,
+          name: toolName,
+          params,
+          resolve: (result) => {
+            if (result === "always") {
+              registry.addAutoApprove(toolName);
+              resolve7({ approved: true });
+            } else if (result === "allow") {
+              resolve7({ approved: true });
+            } else if (result === "deny") {
+              resolve7({ approved: false });
+            } else {
+              resolve7({ approved: false, feedback: result.feedback });
+            }
+          }
+        });
+      });
+    });
+    return () => {
+      setStructuredConfirmHandler(null);
+    };
+  }, [registry]);
+  const handleSubmit = useCallback(async (text) => {
+    if (text.startsWith("/")) {
+      handleSlashCommand2(text, {
+        config,
+        orchestrator: orchestratorRef.current,
+        registry,
+        dispatch,
+        setResetKey,
+        client,
+        todoStore,
+        memoStore,
+        subAgentTracker
+      });
+      return;
+    }
+    dispatch({ type: "ADD_USER_MESSAGE", text });
+    dispatch({ type: "START_ASSISTANT" });
+    dispatch({ type: "SET_RUNNING", running: true });
+    const callbacks = createBridgeCallbacks(dispatch);
+    try {
+      if (config.agent_mode === "single") {
+        await agentRef.current.run(text, callbacks);
+      } else {
+        await orchestratorRef.current.run(text, callbacks);
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      dispatch({ type: "SET_ERROR", error: msg });
+    }
+    callbacks._stopBatcher?.();
+    dispatch({ type: "FINISH_STREAMING" });
+    dispatch({ type: "SET_RUNNING", running: false });
+  }, [config]);
+  const handleConfirmResponse = useCallback((result) => {
+    if (confirmPending) {
+      confirmPending.resolve(result);
+      dispatch({ type: "CONFIRM_RESPONDED", id: "" });
+      const approved = result === "allow" || result === "always";
+      if (approved) {
+        for (const msg of state.messages) {
+          for (const block of msg.blocks) {
+            if (block.type === "tool" && block.toolCall.status === "confirming") {
+              dispatch({ type: "TOOL_EXECUTING", id: block.toolCall.id, name: block.toolCall.name, params: block.toolCall.params });
+            }
+          }
+        }
+      }
+    }
+  }, [confirmPending, state.messages]);
+  useInput3((input, key) => {
+    if (input === "c" && key.ctrl) {
+      if (state.isRunning) {
+        dispatch({ type: "SET_RUNNING", running: false });
+        dispatch({ type: "FINISH_STREAMING" });
+      } else {
+        process.exit(0);
+      }
+      return;
+    }
+    if (input === "d" && key.ctrl) {
+      process.exit(0);
+    }
+  });
+  return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx8(Box8, { flexDirection: "column", overflow: "hidden", children: /* @__PURE__ */ jsx8(ChatArea, { messages: state.messages }) }),
+    state.error && /* @__PURE__ */ jsxs8(
+      Box8,
+      {
+        borderStyle: "round",
+        borderColor: "red",
+        paddingX: 1,
+        marginBottom: 1,
+        children: [
+          /* @__PURE__ */ jsx8(Text8, { color: "red", bold: true, children: "\u2716 Error: " }),
+          /* @__PURE__ */ jsx8(Text8, { color: "red", children: state.error })
+        ]
+      }
+    ),
+    confirmPending && /* @__PURE__ */ jsx8(
+      ConfirmPrompt,
+      {
+        confirm: confirmPending,
+        onRespond: handleConfirmResponse
+      }
+    ),
+    state.todoPlan && /* @__PURE__ */ jsx8(TodoPanel, { plan: state.todoPlan }),
+    /* @__PURE__ */ jsx8(
+      InputArea,
+      {
+        onSubmit: handleSubmit,
+        isRunning: state.isRunning || !!confirmPending
+      }
+    ),
+    /* @__PURE__ */ jsx8(
+      StatusBar,
+      {
+        agentMode: state.agentMode,
+        collaboration: state.collaboration,
+        coderWorking: state.coderWorking,
+        isRunning: state.isRunning,
+        modelName: state.modelName,
+        todoPlan: state.todoPlan,
+        subAgentProgress: state.subAgentProgress
+      }
+    )
+  ] }, resetKey);
+}
+function handleSlashCommand2(input, ctx) {
+  const { config, orchestrator, registry, dispatch, setResetKey, client, todoStore, memoStore, subAgentTracker } = ctx;
+  const parts = input.trim().split(/\s+/);
+  const command = parts[0];
+  switch (command) {
+    case "/help":
+      dispatch({ type: "ADD_USER_MESSAGE", text: input });
+      dispatch({ type: "START_ASSISTANT" });
+      dispatch({
+        type: "APPEND_CONTENT",
+        text: `\u53EF\u7528\u547D\u4EE4:
+  /help                \u663E\u793A\u6B64\u5E2E\u52A9\u4FE1\u606F
+  /mode [\u6A21\u5F0F]         \u5207\u6362\u534F\u4F5C\u6A21\u5F0F (delegated/autonomous/controlled)
+  /single              \u5207\u6362\u5230\u5355 Agent \u6A21\u5F0F
+  /dual                \u5207\u6362\u5230\u53CC Agent \u6A21\u5F0F
+  /parallel            \u5207\u6362\u5E76\u884C\u5B50 Agent \u529F\u80FD on/off
+  /todo                \u5207\u6362 todo \u8BA1\u5212\u529F\u80FD on/off
+  /clear               \u6E05\u7A7A\u5BF9\u8BDD\u5386\u53F2
+  /info                \u663E\u793A\u5F53\u524D\u914D\u7F6E
+  Ctrl+C               \u53D6\u6D88\u5F53\u524D\u8BF7\u6C42 / \u9000\u51FA
+  Ctrl+D               \u9000\u51FA`
+      });
+      dispatch({ type: "FINISH_STREAMING" });
+      break;
+    case "/mode": {
+      const mode = parts[1];
+      if (!mode) {
+        dispatch({ type: "ADD_USER_MESSAGE", text: input });
+        dispatch({ type: "START_ASSISTANT" });
+        dispatch({
+          type: "APPEND_CONTENT",
+          text: `\u5F53\u524D\u534F\u4F5C\u6A21\u5F0F: ${config.collaboration}
+\u53EF\u9009: delegated, autonomous, controlled`
+        });
+        dispatch({ type: "FINISH_STREAMING" });
+      } else if (["delegated", "autonomous", "controlled"].includes(mode)) {
+        config.collaboration = mode;
+        orchestrator?.setMode(mode);
+        dispatch({ type: "SET_MODE", agentMode: config.agent_mode, collaboration: mode });
+      }
+      break;
+    }
+    case "/single":
+      config.agent_mode = "single";
+      dispatch({ type: "SET_MODE", agentMode: "single", collaboration: config.collaboration });
+      break;
+    case "/dual":
+      config.agent_mode = "dual";
+      dispatch({ type: "SET_MODE", agentMode: "dual", collaboration: config.collaboration });
+      break;
+    case "/clear":
+      dispatch({ type: "CLEAR_MESSAGES" });
+      setResetKey((prev) => prev + 1);
+      break;
+    case "/parallel": {
+      const current = config.features.parallel_agents;
+      const next = current === "on" ? "off" : "on";
+      config.features.parallel_agents = next;
+      if (next === "off") {
+        registry.unregister("spawn-agents");
+      } else if (!registry.has("spawn-agents")) {
+        registry.register(createSpawnAgentsTool(client, registry, config, subAgentTracker, memoStore));
+      }
+      dispatch({ type: "ADD_USER_MESSAGE", text: input });
+      dispatch({ type: "START_ASSISTANT" });
+      dispatch({ type: "APPEND_CONTENT", text: `\u5E76\u884C\u5B50 Agent \u529F\u80FD\u5DF2${next === "on" ? "\u5F00\u542F" : "\u5173\u95ED"}` });
+      dispatch({ type: "FINISH_STREAMING" });
+      break;
+    }
+    case "/todo": {
+      const current = config.features.todo;
+      const next = current === "on" ? "off" : "on";
+      config.features.todo = next;
+      if (next === "off") {
+        registry.unregister("todo");
+      } else if (!registry.has("todo")) {
+        registry.register(createTodoTool(todoStore));
+      }
+      dispatch({ type: "ADD_USER_MESSAGE", text: input });
+      dispatch({ type: "START_ASSISTANT" });
+      dispatch({ type: "APPEND_CONTENT", text: `Todo \u8BA1\u5212\u529F\u80FD\u5DF2${next === "on" ? "\u5F00\u542F" : "\u5173\u95ED"}` });
+      dispatch({ type: "FINISH_STREAMING" });
+      break;
+    }
+    case "/info":
+      dispatch({ type: "ADD_USER_MESSAGE", text: input });
+      dispatch({ type: "START_ASSISTANT" });
+      dispatch({
+        type: "APPEND_CONTENT",
+        text: `\u6A21\u578B: ${config.model}
+Agent \u6A21\u5F0F: ${config.agent_mode}
+\u534F\u4F5C\u6A21\u5F0F: ${config.collaboration}
+\u57FA\u7840 URL: ${config.base_url}`
+      });
+      dispatch({ type: "FINISH_STREAMING" });
+      break;
+    default:
+      dispatch({ type: "ADD_USER_MESSAGE", text: input });
+      dispatch({ type: "START_ASSISTANT" });
+      dispatch({
+        type: "APPEND_CONTENT",
+        text: `\u672A\u77E5\u547D\u4EE4: ${command}\u3002\u8F93\u5165 /help \u67E5\u770B\u5E2E\u52A9\u3002`
+      });
+      dispatch({ type: "FINISH_STREAMING" });
+      break;
+  }
+}
+var init_App = __esm({
+  "src/cli/tui/App.tsx"() {
+    "use strict";
+    init_permission();
+    init_state();
+    init_bridge();
+    init_spawn_agents();
+    init_todo();
+    init_ChatArea();
+    init_InputArea();
+    init_StatusBar();
+    init_ConfirmPrompt();
+    init_TodoPanel();
+  }
+});
+
+// src/cli/tui/index.tsx
+var tui_exports = {};
+__export(tui_exports, {
+  startTui: () => startTui
+});
+import { render } from "ink";
+import { jsx as jsx9 } from "react/jsx-runtime";
+async function startTui(options) {
+  const { config } = options;
+  const { systemPrompt } = await buildPrompt(config);
+  const registry = new ToolRegistry();
+  registerCoreTools(registry);
+  registry.setPermissions(config.permissions);
+  const client = createLLMClient({
+    apiKey: config.api_key,
+    baseURL: config.base_url,
+    model: config.model,
+    temperature: config.temperature,
+    maxTokens: config.max_tokens
+  });
+  const todoStore = new TodoStore();
+  const memoStore = new MemoStore();
+  const subAgentTracker = new SubAgentTracker();
+  if (config.features.parallel_agents === "on") {
+    registry.register(createSpawnAgentsTool(client, registry, config, subAgentTracker, memoStore));
+  }
+  if (config.features.todo === "on") {
+    registry.register(createTodoTool(todoStore));
+  }
+  registry.register(createMemoTool(memoStore));
+  const agent = new Agent(client, registry, config, systemPrompt);
+  const orchestrator = new Orchestrator(registry, config, systemPrompt, memoStore);
+  const { waitUntilExit } = render(
+    /* @__PURE__ */ jsx9(
+      App,
+      {
+        config,
+        client,
+        agent,
+        orchestrator,
+        registry,
+        todoStore,
+        memoStore,
+        subAgentTracker
+      }
+    ),
+    { patchConsole: true }
+  );
+  await waitUntilExit();
+}
+var init_tui = __esm({
+  "src/cli/tui/index.tsx"() {
+    "use strict";
+    init_client();
+    init_registry();
+    init_register();
+    init_agent();
+    init_orchestrator();
+    init_builder();
+    init_todo_store();
+    init_memo_store();
+    init_sub_agent_tracker();
+    init_spawn_agents();
+    init_todo();
+    init_memo();
+    init_App();
+  }
+});
+
+// src/cli/index.ts
+init_loader();
+init_client();
+init_registry();
+init_register();
+init_agent();
+init_orchestrator();
+init_builder();
+import { Command } from "commander";
+
+// src/cli/repl.ts
+init_client();
+init_registry();
+init_agent();
+init_orchestrator();
+init_builder();
+init_register();
+init_permission();
+init_todo_store();
+init_memo_store();
+init_spawn_agents();
+init_todo();
+init_memo();
+init_bridge();
+import * as readline from "readline";
+
+// src/cli/ui.ts
+import chalk2 from "chalk";
+import ora from "ora";
+import { marked } from "marked";
+import * as _markedTerminal from "marked-terminal";
+import { createTwoFilesPatch } from "diff";
+var markedTerminal2 = _markedTerminal.markedTerminal;
+marked.use(markedTerminal2());
+function printStream(text) {
+  process.stdout.write(text);
+}
+function printToolCall(toolName, params) {
+  let detail = "";
+  if (toolName === "bash" && params["command"]) {
+    detail = ` ${chalk2.dim(String(params["command"]).slice(0, 80))}`;
+  } else if ((toolName === "read-file" || toolName === "write-file" || toolName === "edit-file") && params["path"]) {
+    detail = ` ${chalk2.dim(String(params["path"]))}`;
+  } else if (toolName === "glob" && params["pattern"]) {
+    detail = ` ${chalk2.dim(String(params["pattern"]))}`;
+  } else if (toolName === "grep" && params["pattern"]) {
+    detail = ` ${chalk2.dim(String(params["pattern"]))}`;
+  } else if (toolName === "spawn-agents" && params["tasks"]) {
+    const tasks = params["tasks"];
+    detail = ` ${chalk2.dim(`${tasks.length} \u4E2A\u5E76\u884C\u4EFB\u52A1`)}`;
+  } else if (toolName === "todo" && params["action"]) {
+    const action = String(params["action"]);
+    const id = params["id"] ? ` [${params["id"]}]` : "";
+    detail = ` ${chalk2.dim(`${action}${id}`)}`;
+  } else if (toolName === "memo" && params["action"]) {
+    const action = String(params["action"]);
+    const key = params["key"] ? ` [${params["key"]}]` : "";
+    detail = ` ${chalk2.dim(`${action}${key}`)}`;
+  }
+  const icon = toolName === "spawn-agents" ? "\u26A1" : toolName === "todo" ? "\u{1F4CB}" : toolName === "memo" ? "\u{1F4DD}" : "\u2699";
+  console.log(chalk2.yellow(`  ${icon} ${toolName}`) + detail);
+}
+function printToolResult(toolName, result, truncated) {
+  if (truncated) {
+    console.log(chalk2.dim(`  \u2713 ${toolName} (\u8F93\u51FA\u5DF2\u622A\u65AD)`));
+  } else {
+    const lines = result.split("\n").length;
+    console.log(chalk2.dim(`  \u2713 ${toolName} (${lines} \u884C)`));
+  }
+}
+function printError(message) {
+  console.error(chalk2.red(`\u2717 ${message}`));
+}
+function printInfo(message) {
+  console.log(chalk2.cyan(`\u2139 ${message}`));
+}
+function printWarning(message) {
+  console.log(chalk2.yellow(`\u26A0 ${message}`));
+}
+function printSuccess(message) {
+  console.log(chalk2.green(`\u2713 ${message}`));
+}
+function printWelcome(modelName, mode) {
+  console.log(chalk2.bold.cyan("\n  ZenCode") + chalk2.dim(" - \u6781\u7B80 AI \u7F16\u7A0B\u52A9\u624B\n"));
+  console.log(chalk2.dim(`  \u6A21\u578B: ${modelName}`));
+  console.log(chalk2.dim(`  \u6A21\u5F0F: ${mode}`));
+  console.log(chalk2.dim(`  \u8F93\u5165 /help \u67E5\u770B\u547D\u4EE4\uFF0CCtrl+C \u9000\u51FA
+`));
+}
+
+// src/cli/repl.ts
+function handleSlashCommand(input, context) {
+  const parts = input.trim().split(/\s+/);
+  const command = parts[0];
+  switch (command) {
+    case "/help":
+      console.log(`
+\u53EF\u7528\u547D\u4EE4:
+  /help                \u663E\u793A\u6B64\u5E2E\u52A9\u4FE1\u606F
+  /mode [\u6A21\u5F0F]         \u5207\u6362\u534F\u4F5C\u6A21\u5F0F (delegated/autonomous/controlled)
+  /single              \u5207\u6362\u5230\u5355 Agent \u6A21\u5F0F
+  /dual                \u5207\u6362\u5230\u53CC Agent \u6A21\u5F0F
+  /parallel            \u5207\u6362\u5E76\u884C\u5B50 Agent \u529F\u80FD on/off
+  /todo                \u5207\u6362 todo \u8BA1\u5212\u529F\u80FD on/off
+  /clear               \u6E05\u7A7A\u5BF9\u8BDD\u5386\u53F2
+  /info                \u663E\u793A\u5F53\u524D\u914D\u7F6E
+  /exit                \u9000\u51FA
+`);
+      return true;
+    case "/mode": {
+      const mode = parts[1];
+      if (!mode) {
+        printInfo(`\u5F53\u524D\u534F\u4F5C\u6A21\u5F0F: ${context.config.collaboration}`);
+        printInfo("\u53EF\u9009: delegated, autonomous, controlled");
+        return true;
+      }
+      if (["delegated", "autonomous", "controlled"].includes(mode)) {
+        context.config.collaboration = mode;
+        context.setMode?.(mode);
+        printSuccess(`\u5DF2\u5207\u6362\u5230 ${mode} \u6A21\u5F0F`);
+      } else {
+        printError(`\u65E0\u6548\u6A21\u5F0F: ${mode}\u3002\u53EF\u9009: delegated, autonomous, controlled`);
+      }
+      return true;
+    }
+    case "/single":
+      context.config.agent_mode = "single";
+      printSuccess("\u5DF2\u5207\u6362\u5230\u5355 Agent \u6A21\u5F0F");
+      return true;
+    case "/dual":
+      context.config.agent_mode = "dual";
+      printSuccess("\u5DF2\u5207\u6362\u5230\u53CC Agent \u6A21\u5F0F");
+      return true;
+    case "/clear":
+      printSuccess("\u5BF9\u8BDD\u5386\u53F2\u5DF2\u6E05\u7A7A\uFF08\u5C06\u5728\u4E0B\u6B21\u5BF9\u8BDD\u65F6\u751F\u6548\uFF09");
+      return true;
+    case "/parallel": {
+      const current = context.config.features.parallel_agents;
+      const next = current === "on" ? "off" : "on";
+      context.config.features.parallel_agents = next;
+      if (next === "off") {
+        context.registry.unregister("spawn-agents");
+      } else if (!context.registry.has("spawn-agents")) {
+        context.registry.register(
+          createSpawnAgentsTool(context.client, context.registry, context.config, void 0, context.memoStore)
+        );
+      }
+      printSuccess(`\u5E76\u884C\u5B50 Agent \u529F\u80FD\u5DF2${next === "on" ? "\u5F00\u542F" : "\u5173\u95ED"}`);
+      return true;
+    }
+    case "/todo": {
+      const current = context.config.features.todo;
+      const next = current === "on" ? "off" : "on";
+      context.config.features.todo = next;
+      if (next === "off") {
+        context.registry.unregister("todo");
+      } else if (!context.registry.has("todo")) {
+        context.registry.register(createTodoTool(context.todoStore));
+      }
+      printSuccess(`Todo \u8BA1\u5212\u529F\u80FD\u5DF2${next === "on" ? "\u5F00\u542F" : "\u5173\u95ED"}`);
+      return true;
+    }
+    case "/info":
+      printInfo(`\u6A21\u578B: ${context.config.model}`);
+      printInfo(`Agent \u6A21\u5F0F: ${context.config.agent_mode}`);
+      printInfo(`\u534F\u4F5C\u6A21\u5F0F: ${context.config.collaboration}`);
+      printInfo(`\u57FA\u7840 URL: ${context.config.base_url}`);
+      return true;
+    case "/exit":
+      process.exit(0);
+    default:
+      printWarning(`\u672A\u77E5\u547D\u4EE4: ${command}\u3002\u8F93\u5165 /help \u67E5\u770B\u5E2E\u52A9\u3002`);
+      return true;
+  }
+}
+async function startRepl(options) {
+  const { config } = options;
+  const { systemPrompt } = await buildPrompt(config);
+  const registry = new ToolRegistry();
+  registerCoreTools(registry);
+  registry.setPermissions(config.permissions);
+  const client = createLLMClient({
+    apiKey: config.api_key,
+    baseURL: config.base_url,
+    model: config.model,
+    temperature: config.temperature,
+    maxTokens: config.max_tokens
+  });
+  const todoStore = new TodoStore();
+  const memoStore = new MemoStore();
+  if (config.features.parallel_agents === "on") {
+    registry.register(createSpawnAgentsTool(client, registry, config, void 0, memoStore));
+  }
+  if (config.features.todo === "on") {
+    registry.register(createTodoTool(todoStore));
+  }
+  registry.register(createMemoTool(memoStore));
+  let singleAgent;
+  let orchestrator;
+  if (config.agent_mode === "single") {
+    singleAgent = new Agent(client, registry, config, systemPrompt);
+  } else {
+    orchestrator = new Orchestrator(registry, config, systemPrompt, memoStore);
+  }
+  const modeLabel = config.agent_mode === "dual" ? `\u53CCAgent (${config.collaboration})` : "\u5355Agent";
+  printWelcome(config.model, modeLabel);
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: "> ",
+    historySize: 100
+  });
+  setConfirmHandler(async (promptText) => {
+    return new Promise((resolve7) => {
+      process.stdout.write(promptText);
+      const onData = (data) => {
+        process.stdin.removeListener("data", onData);
+        process.stdin.pause();
+        const answer = data.toString().trim().toLowerCase();
+        resolve7(answer === "y");
+      };
+      process.stdin.resume();
+      process.stdin.once("data", onData);
+    });
+  });
+  rl.prompt();
+  rl.on("line", async (line) => {
+    const input = line.trim();
+    if (!input) {
+      rl.prompt();
+      return;
+    }
+    if (input.startsWith("/")) {
+      const handled = handleSlashCommand(input, {
+        config,
+        orchestrator,
+        registry,
+        client,
+        todoStore,
+        memoStore,
+        setMode: (mode) => {
+          orchestrator?.setMode(mode);
+        }
+      });
+      if (handled) {
+        rl.prompt();
+        return;
+      }
+    }
+    if (config.agent_mode === "single" && !singleAgent) {
+      singleAgent = new Agent(client, registry, config, systemPrompt);
+      orchestrator = void 0;
+    } else if (config.agent_mode === "dual" && !orchestrator) {
+      orchestrator = new Orchestrator(registry, config, systemPrompt, memoStore);
+      singleAgent = void 0;
+    }
+    rl.pause();
+    let isStreaming = false;
+    const thinkFilter = createThinkFilter();
+    const callbacks = {
+      onContent: (text) => {
+        const filtered = thinkFilter(text);
+        if (!filtered) return;
+        if (!isStreaming) {
+          isStreaming = true;
+          process.stdout.write("\n");
+        }
+        printStream(filtered);
+      },
+      onToolExecuting: (name, params) => {
+        if (isStreaming) {
+          process.stdout.write("\n");
+          isStreaming = false;
+        }
+        printToolCall(name, params);
+      },
+      onToolResult: (name, result, truncated) => {
+        printToolResult(name, result, truncated);
+      },
+      onCoderStart: () => {
+        if (isStreaming) {
+          process.stdout.write("\n");
+          isStreaming = false;
+        }
+        printInfo("\u7F16\u7801 Agent \u5F00\u59CB\u5DE5\u4F5C...");
+      },
+      onCoderEnd: () => {
+        printInfo("\u7F16\u7801 Agent \u5B8C\u6210");
+      },
+      onError: (err) => {
+        if (isStreaming) {
+          process.stdout.write("\n");
+          isStreaming = false;
+        }
+        printError(err.message);
+      }
+    };
+    try {
+      if (config.agent_mode === "single" && singleAgent) {
+        await singleAgent.run(input, callbacks);
+      } else if (orchestrator) {
+        await orchestrator.run(input, callbacks);
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      printError(msg);
+    }
+    if (isStreaming) {
+      process.stdout.write("\n");
+    }
+    console.log();
+    rl.resume();
+    rl.prompt();
+  });
+  rl.on("close", () => {
+    console.log("\n\u518D\u89C1\uFF01");
+    process.exit(0);
+  });
+}
+
+// src/cli/index.ts
+init_todo_store();
+init_memo_store();
+init_spawn_agents();
+init_todo();
+init_memo();
+init_bridge();
+async function runOnce(prompt, config) {
+  const { systemPrompt } = await buildPrompt(config);
+  const registry = new ToolRegistry();
+  registerCoreTools(registry);
+  registry.setPermissions(config.permissions);
+  const client = createLLMClient({
+    apiKey: config.api_key,
+    baseURL: config.base_url,
+    model: config.model,
+    temperature: config.temperature,
+    maxTokens: config.max_tokens
+  });
+  const todoStore = new TodoStore();
+  const memoStore = new MemoStore();
+  if (config.features.parallel_agents === "on") {
+    registry.register(createSpawnAgentsTool(client, registry, config, void 0, memoStore));
+  }
+  if (config.features.todo === "on") {
+    registry.register(createTodoTool(todoStore));
+  }
+  registry.register(createMemoTool(memoStore));
+  let isStreaming = false;
+  const thinkFilter = createThinkFilter();
+  const callbacks = {
+    onContent: (text) => {
+      const filtered = thinkFilter(text);
+      if (!filtered) return;
+      if (!isStreaming) {
+        isStreaming = true;
+      }
+      printStream(filtered);
+    },
+    onToolExecuting: (name, params) => {
+      if (isStreaming) {
+        process.stdout.write("\n");
+        isStreaming = false;
+      }
+      printToolCall(name, params);
+    },
+    onToolResult: (name, result, truncated) => {
+      printToolResult(name, result, truncated);
+    },
+    onCoderStart: () => {
+      if (isStreaming) {
+        process.stdout.write("\n");
+        isStreaming = false;
+      }
+      printInfo("\u7F16\u7801 Agent \u5F00\u59CB\u5DE5\u4F5C...");
+    },
+    onCoderEnd: () => {
+      printInfo("\u7F16\u7801 Agent \u5B8C\u6210");
+    },
+    onError: (err) => {
+      printError(err.message);
+    }
+  };
+  try {
+    if (config.agent_mode === "single") {
+      const agent = new Agent(client, registry, config, systemPrompt);
+      await agent.run(prompt, callbacks);
+    } else {
+      const orchestrator = new Orchestrator(registry, config, systemPrompt, memoStore);
+      await orchestrator.run(prompt, callbacks);
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    printError(msg);
+    process.exit(1);
+  }
+  if (isStreaming) {
+    process.stdout.write("\n");
+  }
+}
+function createCli() {
+  const program2 = new Command();
+  program2.name("zencode").description("\u6781\u7B80 CLI AI \u7F16\u7A0B\u5DE5\u5177").version("0.1.0").option("-m, --model <model>", "\u6307\u5B9A\u6A21\u578B\u540D\u79F0").option("-k, --api-key <key>", "API \u5BC6\u94A5").option("-u, --base-url <url>", "API \u57FA\u7840 URL").option("--single", "\u4F7F\u7528\u5355 Agent \u6A21\u5F0F").option("--dual", "\u4F7F\u7528\u53CC Agent \u6A21\u5F0F").option("--mode <mode>", "\u534F\u4F5C\u6A21\u5F0F (delegated/autonomous/controlled)").option("--simple", "\u4F7F\u7528\u7B80\u5355 REPL \u6A21\u5F0F\uFF08\u975E\u5168\u5C4F TUI\uFF09").argument("[prompt...]", "\u76F4\u63A5\u6267\u884C\u7684\u63D0\u793A\u8BCD\uFF08\u975E\u4EA4\u4E92\u5F0F\uFF09").action(async (promptParts, opts) => {
+    const config = loadConfig(opts);
+    if (!config.api_key) {
+      printError("\u672A\u8BBE\u7F6E API \u5BC6\u94A5\u3002\u8BF7\u901A\u8FC7\u4EE5\u4E0B\u65B9\u5F0F\u4E4B\u4E00\u8BBE\u7F6E\uFF1A");
+      printError("  1. \u73AF\u5883\u53D8\u91CF ZENCODE_API_KEY");
+      printError("  2. \u914D\u7F6E\u6587\u4EF6 ~/.zencode/config.yaml \u4E2D\u8BBE\u7F6E api_key");
+      printError("  3. CLI \u53C2\u6570 --api-key");
+      process.exit(1);
+    }
+    const prompt = promptParts.join(" ");
+    if (prompt) {
+      await runOnce(prompt, config);
+    } else if (opts.simple) {
+      await startRepl({ config });
+    } else {
+      const { startTui: startTui2 } = await Promise.resolve().then(() => (init_tui(), tui_exports));
+      await startTui2({ config });
+    }
+  });
+  return program2;
+}
+
+// bin/zencode.ts
+var program = createCli();
+program.parse();
+//# sourceMappingURL=zencode.js.map