zen-code 4.6.0 → 4.6.1

package/dist/graphBuilder-B3IJ7dB2.mjs

@@ -0,0 +1,2641 @@
+import se from "micromatch";
+import { Low as ne } from "lowdb";
+import { JSONFile as oe } from "lowdb/node";
+import "yaml";
+import { createState as q, createDefaultAnnotation as g, AgentState as ae, ChatOpenAI as re, getThreadId as ce } from "@langgraph-js/pro";
+import { z as t } from "zod";
+import { MessagesAnnotation as le, StateGraph as de, START as ue, REMOVE_ALL_MESSAGES as pe } from "@langchain/langgraph";
+import { HumanMessage as U, RemoveMessage as me, AIMessage as he } from "@langchain/core/messages";
+import { ChatAnthropic as ge } from "@langchain/anthropic";
+import { ChatGoogleGenerativeAI as fe } from "@langchain/google-genai";
+import we, { promises as d } from "node:fs";
+import _, { join as ye, dirname as G } from "node:path";
+import { createAgent as B, toolStrategy as be, tool as $ } from "langchain";
+import { MemoryStorage as _e, AgentPackage as ke, anthropicPromptCachingMiddleware as ve } from "@langgraph-js/standard-agent";
+import { tool as p } from "@langchain/core/tools";
+import { execa as x } from "execa";
+import { glob as Te } from "glob";
+import Se from "extract-zip";
+import xe from "fs-extra";
+import * as R from "node:os";
+import Ce from "node:os";
+import { pipeline as Ee } from "node:stream/promises";
+import { fileURLToPath as Pe } from "node:url";
+import { pathExists as L } from "path-exists";
+import { temporaryFile as Ae } from "tempy";
+import { xdgCache as Me } from "xdg-basedir";
+import { MultiServerMCPClient as Re } from "@langchain/mcp-adapters";
+import { humanInTheLoopMiddleware as Ie } from "@langgraph-js/auk";
+var w = /* @__PURE__ */ ((s) => (s.ALLOW = "allow", s.ASK = "ask", s.DENY = "deny", s))(w || {});
+t.object({
+  tool: t.string(),
+  specifier: t.string().optional(),
+  action: t.nativeEnum(w)
+});
+t.object({
+  allow: t.array(t.string()).optional(),
+  ask: t.array(t.string()).optional(),
+  deny: t.array(t.string()).optional(),
+  defaultMode: t.nativeEnum(w).optional()
+});
+t.object({
+  name: t.string(),
+  args: t.record(t.string(), t.any())
+});
+class k {
+  rules;
+  defaultMode;
+  patternCache = /* @__PURE__ */ new Map();
+  constructor(e) {
+    this.rules = e.rules, this.defaultMode = e.defaultMode || w.ASK, this.rules.sort((i, n) => {
+      const o = { deny: 0, ask: 1, allow: 2 }, a = o[i.action] - o[n.action];
+      if (a !== 0)
+        return a;
+      const r = i.specifier == null ? 1 : 0, c = n.specifier == null ? 1 : 0;
+      return r - c;
+    });
+  }
+  /**
+   * Check if a tool call is permitted
+   */
+  checkPermission(e) {
+    for (const i of this.rules)
+      if (this.matchRule(i, e))
+        return {
+          allowed: i.action === "allow" || i.action === "ask",
+          requiresApproval: i.action === "ask",
+          matchedRule: i,
+          reason: this.getReason(i)
+        };
+    return {
+      allowed: this.defaultMode === "allow" || this.defaultMode === "ask",
+      requiresApproval: this.defaultMode === "ask",
+      reason: `No matching rule, using default mode: ${this.defaultMode}`
+    };
+  }
+  /**
+   * Check if a rule matches a tool call
+   */
+  matchRule(e, i) {
+    if (e.tool !== i.name)
+      return !1;
+    if (!e.specifier)
+      return !0;
+    const n = this.argsToString(i.args);
+    return i.name === "Bash" ? this.matchBashCommand(e.specifier, n) : e.specifier.endsWith(" ") && !/[*?[\\]/.test(e.specifier) ? n.startsWith(e.specifier) : this.matchGlob(e.specifier, n);
+  }
+  /**
+   * Match Bash commands with shell operator awareness
+   */
+  matchBashCommand(e, i) {
+    if (/[;&|]/.test(i))
+      return !1;
+    const o = /[<>()]/;
+    if (o.test(i)) {
+      const a = i.split(o)[0].trim();
+      return this.matchBashPattern(e, a);
+    }
+    return this.matchBashPattern(e, i);
+  }
+  /**
+   * Match Bash command patterns with support for prefix and glob matching
+   */
+  matchBashPattern(e, i) {
+    return e.endsWith(" ") ? i.startsWith(e) : this.matchGlob(e, i);
+  }
+  /**
+   * Glob pattern matching using micromatch with caching
+   */
+  matchGlob(e, i) {
+    try {
+      const n = e.replace(/^\.\//, ""), o = i.replace(/^\.\//, ""), a = `${e}::${i}`, r = this.patternCache.get(a);
+      if (r !== void 0)
+        return r;
+      const c = se.isMatch(o, n, {
+        nocase: !1,
+        dot: !0
+      });
+      return this.cacheResult(a, c), c;
+    } catch {
+      return i === e;
+    }
+  }
+  /**
+   * Cache matching result with LRU-style size limit
+   */
+  cacheResult(e, i) {
+    if (this.patternCache.size > 1e3) {
+      const n = this.patternCache.keys().next().value;
+      n && this.patternCache.delete(n);
+    }
+    this.patternCache.set(e, i);
+  }
+  /**
+   * Convert tool arguments to string representation
+   */
+  argsToString(e) {
+    return typeof e == "object" && e !== null ? "command" in e && e.command ? String(e.command) : "file_path" in e && e.file_path ? String(e.file_path) : Object.values(e).flat().join(" ") : String(e);
+  }
+  /**
+   * Get human-readable reason for permission decision
+   */
+  getReason(e) {
+    const i = e.action.toUpperCase(), n = e.tool, o = e.specifier ? `(${e.specifier})` : "";
+    return `${i} rule matched: ${n}${o}`;
+  }
+  /**
+   * Parse permission rule from string format
+   * Examples:
+   * - "Bash" -> { tool: "Bash", action: "allow" }
+   * - "Bash(git commit )" -> { tool: "Bash", specifier: "git commit ", action: "allow" }
+   */
+  static parseRule(e, i) {
+    const n = e.match(/^(\w+)(?:\((.*)\))?$/);
+    if (!n)
+      throw new Error(`Invalid permission rule format: ${e}`);
+    const [, o, a] = n;
+    return {
+      tool: o,
+      specifier: a,
+      // MODIFIED: Don't trim - preserve trailing spaces which are significant for glob patterns
+      action: i
+    };
+  }
+  /**
+   * Create matcher from configuration object
+   */
+  static fromConfig(e) {
+    const i = [];
+    for (const n of e.allow || [])
+      i.push(k.parseRule(n, w.ALLOW));
+    for (const n of e.ask || [])
+      i.push(k.parseRule(n, w.ASK));
+    for (const n of e.deny || [])
+      i.push(k.parseRule(n, w.DENY));
+    return new k({
+      rules: i,
+      defaultMode: e.defaultMode || w.ASK
+    });
+  }
+  /**
+   * Clear cache (useful for testing or config reload)
+   */
+  clearCache() {
+    this.patternCache.clear();
+  }
+  /**
+   * Get current cache size
+   */
+  getCacheSize() {
+    return this.patternCache.size;
+  }
+}
+class b {
+  configStore;
+  /** 工具名称映射 */
+  toolNameMapper = {};
+  constructor(e) {
+    this.configStore = e;
+  }
+  // ========== 单例模式 ==========
+  static instance = null;
+  /**
+   * 获取单例实例
+   * @param configStore 配置存储实例（仅首次调用需要）
+   */
+  static getInstance(e) {
+    if (!b.instance) {
+      if (!e)
+        throw new Error("PermissionStore not initialized. Provide configStore on first call.");
+      b.instance = new b(e);
+    }
+    return b.instance;
+  }
+  /**
+   * 重置单例（测试用）
+   */
+  static resetInstance() {
+    b.instance = null;
+  }
+  // ========== 业务方法 ==========
+  /**
+   * 获取权限匹配器实例
+   */
+  async getPermissions() {
+    const e = await this.configStore.getConfig();
+    if (e.permissions)
+      return k.fromConfig(e.permissions);
+  }
+  /**
+   * 检查 Bash 命令权限
+   */
+  async checkBashPermission(e, i) {
+    return (await this.getPermissions())?.checkPermission({
+      name: "Bash",
+      args: { command: e, cwd: i }
+    });
+  }
+  /**
+   * 检查读取文件权限
+   */
+  async checkReadPermission(e) {
+    return (await this.getPermissions())?.checkPermission({
+      name: "Read",
+      args: { file_path: e }
+    });
+  }
+  /**
+   * 检查写入文件权限
+   */
+  async checkWritePermission(e) {
+    return (await this.getPermissions())?.checkPermission({
+      name: "Write",
+      args: { file_path: e }
+    });
+  }
+}
+class Oe {
+  configStore;
+  skillStore;
+  pluginStore;
+  remoteStore;
+  permissionStore;
+  _initialized = !1;
+  constructor(e, i, n, o) {
+    this.configStore = e, this.skillStore = i, this.pluginStore = n, this.remoteStore = o, this.permissionStore = b.getInstance(e);
+  }
+  /**
+   * 初始化管理器（延迟初始化）
+   * 必须在使用其他方法前调用
+   */
+  async initialize() {
+    this._initialized || ("initialize" in this.configStore && typeof this.configStore.initialize == "function" && await this.configStore.initialize(), "initialize" in this.skillStore && typeof this.skillStore.initialize == "function" && await this.skillStore.initialize(), "initialize" in this.pluginStore && typeof this.pluginStore.initialize == "function" && await this.pluginStore.initialize(), this._initialized = !0);
+  }
+  /**
+   * 确保已初始化（内部使用）
+   */
+  async ensureInitialized() {
+    if (!this._initialized)
+      throw new Error("ConfigManager not initialized. Call await manager.initialize() first.");
+  }
+  // 配置相关
+  async getConfig() {
+    return await this.ensureInitialized(), await this.configStore.getConfig();
+  }
+  async updateConfig(e) {
+    return await this.ensureInitialized(), await this.configStore.updateConfig(e);
+  }
+  // Skills 相关
+  async listSkills() {
+    return await this.ensureInitialized(), await this.skillStore.listSkills();
+  }
+  async getSkill(e) {
+    return await this.ensureInitialized(), await this.skillStore.getSkill(e);
+  }
+  async saveSkill(e, i) {
+    return await this.ensureInitialized(), await this.skillStore.saveSkill(e, i);
+  }
+  async deleteSkill(e) {
+    return await this.ensureInitialized(), await this.skillStore.deleteSkill(e);
+  }
+  async syncSkillsFromRemote() {
+    if (await this.ensureInitialized(), !this.remoteStore)
+      throw new Error("Remote store not configured");
+    return await this.skillStore.syncFromRemote(this.remoteStore);
+  }
+  // Plugins 相关
+  async listPlugins() {
+    return await this.ensureInitialized(), await this.pluginStore.listPlugins();
+  }
+  async getPluginConfig(e) {
+    return await this.ensureInitialized(), await this.pluginStore.getPluginConfig(e);
+  }
+  async updatePluginConfig(e, i) {
+    return await this.ensureInitialized(), await this.pluginStore.updatePluginConfig(e, i);
+  }
+  async installPlugin(e, i) {
+    return await this.ensureInitialized(), await this.pluginStore.installPlugin(e, i);
+  }
+  async uninstallPlugin(e) {
+    return await this.ensureInitialized(), await this.pluginStore.uninstallPlugin(e);
+  }
+  // Permissions 相关
+  /**
+   * 检查 Bash 命令权限
+   */
+  async checkBashPermission(e, i) {
+    return await this.ensureInitialized(), await this.permissionStore.checkBashPermission(e, i);
+  }
+  /**
+   * 检查读取文件权限
+   */
+  async checkReadPermission(e) {
+    return await this.ensureInitialized(), await this.permissionStore.checkReadPermission(e);
+  }
+  /**
+   * 检查写入文件权限
+   */
+  async checkWritePermission(e) {
+    return await this.ensureInitialized(), await this.permissionStore.checkWritePermission(e);
+  }
+  /**
+   * 获取权限匹配器（用于高级操作）
+   */
+  async getPermissionMatcher() {
+    return await this.ensureInitialized(), await this.permissionStore.getPermissions();
+  }
+  /** fs 专用 */
+  getConfigPath() {
+    return this.configStore?.dbPath;
+  }
+}
+async function $e() {
+  const { FileSystemConfigStore: s } = await Promise.resolve().then(() => Ne), { FileSystemSkillStore: e } = await import("./FileSystemSkillStore-yvEvcRxB.mjs"), { FileSystemPluginStore: i } = await import("./FileSystemPluginStore-ChortK7z.mjs"), n = new s(), o = new e(), a = new i(), r = new Oe(n, o, a);
+  return await r.initialize(), r;
+}
+const D = {
+  config: {
+    provider_id: "default",
+    provider_type: "openai",
+    model_id: "gpt-5.2",
+    providers: [
+      {
+        id: "default",
+        type: "openai",
+        apiKey: "",
+        baseUrl: "https://api.openai.com/v1"
+      }
+    ]
+  }
+};
+function ze(s) {
+  return "main_model" in s && !("providers" in s);
+}
+function je(s) {
+  const e = [];
+  (s.model_provider === "openai" || s.openai_api_key || s.openai_base_url) && e.push({
+    id: "openai",
+    type: "openai",
+    apiKey: s.openai_api_key || "",
+    baseUrl: s.openai_base_url || "https://api.openai.com/v1"
+  }), (s.model_provider === "anthropic" || s.anthropic_api_key || s.anthropic_base_url) && e.push({
+    id: "anthropic",
+    type: "anthropic",
+    apiKey: s.anthropic_api_key || "",
+    baseUrl: s.anthropic_base_url || "https://api.anthropic.com"
+  }), e.length === 0 && e.push({
+    id: "default",
+    type: "openai",
+    apiKey: "",
+    baseUrl: "https://api.openai.com/v1"
+  });
+  const i = s.model_provider === "anthropic" ? "anthropic" : "openai", n = e.find((o) => o.id === i) || e[0];
+  return {
+    provider_id: n.id,
+    provider_type: n.type,
+    model_id: s.main_model,
+    providers: e,
+    mcp_config: s.mcp_config,
+    stream_refresh_interval: s.stream_refresh_interval,
+    enable_thinking: s.enable_thinking,
+    switch_command: s.switch_command,
+    compact_mode: s.compact_mode,
+    permissions: s.permissions
+  };
+}
+class K {
+  db;
+  zenConfigDir;
+  dbPath;
+  constructor() {
+    const e = Ce.homedir();
+    this.zenConfigDir = _.join(e, ".zen-code");
+    const i = _.join(this.zenConfigDir, "settings.json"), n = new oe(i);
+    this.dbPath = i, this.db = new ne(n, D);
+  }
+  async initialize() {
+    await we.promises.mkdir(this.zenConfigDir, { recursive: !0 }), await this.db.read(), !this.db.data || !this.db.data.config ? (this.db.data = D, await this.db.write()) : ze(this.db.data.config) && (console.log("Migrating legacy config to new format..."), this.db.data.config = je(this.db.data.config), await this.db.write(), console.log("Config migration completed.")), this.syncEnvFromConfig();
+  }
+  async getConfig() {
+    return await this.db.read(), this.db.data.config;
+  }
+  async updateConfig(e) {
+    await this.db.read(), Object.assign(this.db.data.config, e), await this.db.write(), this.syncEnvFromConfig();
+  }
+  /**
+   * 将配置同步到环境变量
+   */
+  syncEnvFromConfig() {
+    const e = this.db.data.config, i = e.providers.find((n) => n.id === e.provider_id);
+    i && (i.type === "openai" ? (process.env.MODEL_PROVIDER = "openai", process.env.OPENAI_API_KEY = i.apiKey, process.env.OPENAI_BASE_URL = i.baseUrl) : i.type === "anthropic" ? (process.env.MODEL_PROVIDER = "anthropic", process.env.ANTHROPIC_API_KEY = i.apiKey, process.env.ANTHROPIC_BASE_URL = i.baseUrl) : (i.type === "gemini" || i.type === "google") && (process.env.MODEL_PROVIDER = "gemini", process.env.GOOGLE_API_KEY = i.apiKey, process.env.GOOGLE_BASE_URL = i.baseUrl));
+  }
+  /**
+   * 获取配置目录路径
+   */
+  getZenConfigDir() {
+    return this.zenConfigDir;
+  }
+}
+const Ne = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  FileSystemConfigStore: K
+}, Symbol.toStringTag, { value: "Module" })), Ue = t.enum(["idea", "bug_report", "feature", "refactor"]), Le = t.enum(["low", "medium", "high", "critical"]), De = t.enum(["pending", "planned", "archived"]), Fe = t.enum(["user_input", "ai_suggestion", "conversation_derived"]), We = t.object({
+  id: t.string().uuid(),
+  type: Ue,
+  title: t.string().min(1).max(200),
+  description: t.string(),
+  priority: Le.default("medium"),
+  source: Fe,
+  status: De.default("pending"),
+  createdAt: t.string().datetime(),
+  tags: t.array(t.string()).default([]),
+  metadata: t.object({
+    relatedFiles: t.array(t.string()).optional(),
+    conversationContext: t.string().optional(),
+    estimatedComplexity: t.enum(["simple", "medium", "complex"]).optional()
+  }).optional()
+});
+t.object({
+  version: t.literal("1.0"),
+  sparks: t.array(We),
+  lastUpdated: t.string().datetime()
+});
+const H = t.enum([
+  "pickup",
+  // 待领取（新任务，未被 agent 接管）
+  "running",
+  // 运行中（agent 正在执行）
+  "complete",
+  // 已完成（成功完成）
+  "error",
+  // 已失败（失败，暂停中）
+  "review",
+  // 待审核（完成，等待人工确认）
+  "feedback"
+  // 待反馈（agent 卡住，需要人工输入）
+]), I = t.enum([
+  "default",
+  "planner",
+  "reviewer",
+  "refactor",
+  "finder",
+  "debugger",
+  "architect"
+]), Ye = t.enum(["serial", "parallel"]), V = t.lazy(
+  () => t.object({
+    // 基本信息
+    id: t.string(),
+    title: t.string().min(1).max(200),
+    description: t.string(),
+    // 执行控制
+    execution: Ye.optional(),
+    children: t.array(t.lazy(() => V)).optional(),
+    // Agent 分配
+    agentType: I.optional(),
+    threadId: t.string().optional(),
+    // 元数据
+    estimatedTime: t.string().optional(),
+    complexity: t.enum(["simple", "medium", "complex"]).optional(),
+    dependencies: t.array(t.string()).optional(),
+    acceptanceCriteria: t.array(t.string()).optional(),
+    // 状态相关（运行时）
+    status: H.optional(),
+    startedAt: t.string().datetime().optional(),
+    completedAt: t.string().datetime().optional(),
+    assignedTo: I.optional(),
+    error: t.object({
+      message: t.string(),
+      stack: t.string().optional(),
+      retryCount: t.number().optional()
+    }).optional()
+  })
+), qe = t.object({
+  taskId: t.string(),
+  planId: t.string(),
+  threadId: t.string(),
+  // 关联的 LangGraph thread ID
+  agentType: I,
+  // 改为类型安全的 AgentType
+  status: H,
+  startedAt: t.string().datetime(),
+  completedAt: t.string().datetime().optional(),
+  output: t.string().optional(),
+  error: t.string().optional(),
+  changedFiles: t.array(t.string()).optional()
+});
+t.object({
+  version: t.literal("1.0"),
+  lastUpdated: t.string().datetime(),
+  // 活跃的任务树
+  activePlanId: t.string().optional(),
+  tasks: t.record(t.string(), V),
+  // 执行历史
+  history: t.array(qe),
+  // 全局配置
+  config: t.object({
+    maxConcurrentAgents: t.number().min(1).max(10).default(3),
+    retryLimit: t.number().min(0).max(10).default(3),
+    autoResume: t.boolean().default(!1)
+  })
+});
+const z = await $e(), Ge = async () => {
+  await z.initialize();
+}, Be = async () => await z.getConfig(), bi = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  configStore: z,
+  getConfig: Be,
+  initDb: Ge
+}, Symbol.toStringTag, { value: "Module" })), Ke = q().build({
+  task_store: g(() => ({}))
+}), He = t.object({
+  task_store: t.record(t.string(), t.any()).optional()
+}), _i = ae.extend(He.shape).extend({
+  provider_id: t.string().default("openai"),
+  provider_type: t.string().default("openai"),
+  model_id: t.string().default("qwen-plus"),
+  agent_name: t.string().default("Code Agent"),
+  switch_command: t.string().optional(),
+  enable_thinking: t.boolean().default(!0),
+  // sb 的 langchain 在 agent middleware 的 runtime 里面拿不到这些数据
+  user_id: t.string().optional(),
+  thread_id: t.string().optional()
+}), J = q(le, Ke).build({
+  provider_id: g(() => "openai"),
+  provider_type: g(() => "openai"),
+  model_id: g(() => "qwen-plus"),
+  agent_name: g(() => "Code Agent"),
+  switch_command: g(() => null),
+  enable_thinking: g(() => !0),
+  // sb 的 langchain 在 agent middleware 的 runtime 里面拿不到这些数据
+  user_id: g(() => ""),
+  thread_id: g(() => "")
+});
+function Ve(s, e = "Human", i = "AI") {
+  const n = [];
+  for (const o of s) {
+    let a;
+    if (o.type === "human") a = e;
+    else if (o.type === "ai") a = i;
+    else if (o.type === "system") a = "System";
+    else if (o.type === "tool") a = "Tool";
+    else if (o.type === "generic")
+      a = o.role;
+    else throw new Error(`Got unsupported message type: ${o.type}`);
+    const r = o.name ? `${o.name}, ` : "", c = typeof o.content == "string" ? o.content : JSON.stringify(o.content, null, 2);
+    n.push(`${a}: ${r}${c}`);
+  }
+  return n.join(`
+`);
+}
+const Z = async (s, e = {}) => {
+  const { modelProvider: i, enableThinking: n = !0 } = e;
+  let o;
+  return i === "anthropic" ? o = new ge({
+    model: s,
+    streamUsage: !0,
+    streaming: !0,
+    maxRetries: 1,
+    maxTokens: 64e3,
+    thinking: n ? {
+      budget_tokens: 1024,
+      type: "enabled"
+    } : void 0,
+    apiKey: e.apiKey,
+    anthropicApiUrl: e.baseURL,
+    metadata: e.metadata
+  }) : i === "gemini" || i === "google" ? (console.log(process.env.GOOGLE_BASE_URL), o = new fe({
+    model: s,
+    apiKey: e.apiKey,
+    baseUrl: e.baseURL || process.env.GOOGLE_BASE_URL,
+    maxRetries: 1,
+    streaming: !0,
+    streamUsage: !0,
+    // Note: Gemini doesn't have native thinking support like Anthropic,
+    // but we can use extended thinking mode for supported models
+    metadata: e.metadata
+  })) : o = new re({
+    model: s,
+    configuration: {
+      baseURL: e.baseURL,
+      apiKey: e.apiKey
+    },
+    streamUsage: !0,
+    maxRetries: 1,
+    modelKwargs: n ? {
+      thinking: {
+        type: "enabled"
+      }
+    } : void 0,
+    metadata: e.metadata
+  }), o;
+}, Je = (s) => s?.replace(process.cwd(), ".") || s || "", Ze = t.object({
+  summary_of_chat: t.string().describe(
+    "对话总结（300-500字）：1) 完整复现对话的核心过程（任务背景→关键决策→解决方案→最终结果）；2) 明确说明接下来要做什么（后续行动、待完成任务、需要用户确认的事项）；3) 突出关键成果和交付物"
+  ),
+  // Frontmatter 字段
+  name: t.string().describe("记忆名称（kebab-case 格式）"),
+  description: t.string().describe("对于这个记忆的中等长度描述（索引综述，200-500字符，包含背景、关键点、适用场景）"),
+  tags: t.array(t.string()).describe("记忆标签"),
+  category: t.enum(["architecture", "bug-fix", "workflow", "configuration", "optimization"]).describe("记忆分类"),
+  created: t.string().describe("创建日期（ISO 格式：YYYY-MM-DD）"),
+  last_updated: t.string().describe("最后更新日期（ISO 格式：YYYY-MM-DD）"),
+  priority: t.enum(["high", "medium", "low"]).describe("优先级"),
+  context_scope: t.enum(["user", "project"]).describe("上下文范围"),
+  // 内容字段
+  content: t.string().describe("记忆内容（详细说明，包含代码示例）")
+}), Xe = `你是一个负责分析对话并提取关键信息的智能助手。
+
+## 任务
+
+1. **对话总结 (summary_of_chat)**：完整复现对话并明确后续行动
+2. **记忆提取**：判断是否有值得保存为长期记忆的信息
+
+## 对话总结要求 (summary_of_chat)
+
+**必须包含以下三个部分**：
+
+### 1. 完整复现对话核心过程
+- **任务背景**：用户想做什么？遇到什么问题？
+- **关键决策**：做出了什么选择？为什么？
+- **解决方案**：具体怎么实现的？用了什么技术/方法？
+- **最终结果**：完成了什么？输出了什么？
+
+### 2. 明确后续行动
+- **待完成任务**：还有哪些未完成的工作？
+- **需要确认**：哪些事项需要用户决策？
+- **下一步建议**：建议接下来做什么？
+
+### 3. 突出关键成果
+- **交付物**：生成了什么文件/代码/文档？
+- **价值点**：解决了什么核心问题？
+- **可复用性**：什么内容可以复用？
+
+**格式要求**：
+- 300-500 字
+- 使用清晰的结构（可用 → 表示流程）
+- 突出关键信息（文件路径、函数名、配置项）
+
+**示例**：
+\`\`\`
+用户需要为 TUI 应用添加模型选择面板。通过创建 ModelPanel 组件实现交互式界面（↑↓选择、Enter切换、q关闭），在 Chat.tsx 中扩展 activeView 状态添加 'model' 类型，定义 switchToModel 回调并传递到命令系统，注册 /model-panel 和 /mp 命令。修复了 CommandHandler 未解构 switchToModel 的 bug。✓ 完成：可用的模型选择面板；⏳ 待定：是否需要添加模型描述信息展示；→ 建议：测试面板在不同终端下的渲染效果
+\`\`\`
+
+## 记忆评分机制（总分 10 分，≥ 6 分才保存）
+
+## 记忆评分机制（总分 10 分，≥ 6 分才保存）
+
+1. **重要性** (0-3 分)
+   - 3 分：关键技术决策、架构设计、重要问题解决方案
+   - 2 分：有用的编码模式、最佳实践
+   - 1 分：一般性建议、参考信息
+   - 0 分：无实际内容
+
+2. **独特性** (0-3 分)
+   - 3 分：项目特定配置、非常规解决方案
+   - 2 分：非显而易见的技巧、特定场景知识
+   - 1 分：略有新意的做法
+   - 0 分：常见知识、通用做法
+
+3. **可复用性** (0-2 分)
+   - 2 分：跨场景可复用的模式/方法
+   - 1 分：特定场景下可复用
+   - 0 分：一次性信息、临时性内容
+
+4. **持久性** (0-2 分)
+   - 2 分：长期有效（架构决策、代码模式）
+   - 1 分：中期有效（配置信息、工作流程）
+   - 0 分：临时信息（调试过程、一次性请求）
+
+**评分 < 6 分**：设置 name 为 "no-memory-{timestamp}"，content 为 "无重要信息"
+
+## 记忆命名建议
+
+- 使用 kebab-case 格式（小写、连字符分隔）
+- 从核心主题中提取 2-4 个关键词
+- 示例：
+  - "langchain-structured-output-single-object-pattern"
+  - "memory-system-design"
+  - "middleware-execution-order"
+- 避免通用名称：使用具体的技术术语而非 "fix-bug" 或 "optimization"
+
+## 内容提取模板
+
+提取的内容应包含以下部分（按需选择）：
+
+**背景**：什么问题/场景？
+**决策**：做了什么选择？
+**原因**：为什么这样选择？
+**实现**：关键代码、文件路径、配置
+**适用**：什么场景适用？什么场景不适用？
+**注意**：有什么陷阱或边界情况？
+
+## 代码引用原则（强制执行）
+
+**默认规则：代码超过 5 行 → 使用文件引用**
+
+### 何时使用文件引用
+- 完整函数或方法实现
+- 完整类或组件定义
+- 长配置文件
+- 任何 > 5 行的代码块
+
+### 文件引用格式
+\`文件路径[:行号范围]\`：简短说明
+
+示例：
+- \`agents/code/graph.ts:120-180\`：中间件链执行顺序
+- \`tui/src/chat/Chat.tsx\`：完整的面板切换回调实现
+- \`.deepagents/skills/web-research/SKILL.md\`：技能结构模板
+
+### 何时内联代码（仅限以下情况）
+1. **极短片段**（≤ 5 行）：用于说明关键概念
+2. **配置示例**：JSON/YAML 配置片段
+3. **错误示例**：展示错误模式（不超过 5 行）
+
+### 代码长度限制
+- **总代码占比**：content 中代码块总行数 ≤ 30%
+- **单个代码块**：不超过 5 行
+- **优先级**：文件引用 > 概述 > 短片段
+
+### 长代码处理方式
+
+**错误示范**（代码过长）：
+\`\`\`typescript
+const middleware = [
+  new SubAgentsMiddleware(),
+  new AgentsMdMiddleware(),
+  // ... 省略 20 行
+];
+\`\`\`
+
+**正确示范**（文件引用）：
+中间件列表定义参见 \`agents/code/graph.ts:45-60\`，执行顺序为：SubAgents → AgentsMd → Skills → MCP → HumanInTheLoop → Cache
+
+**关键片段**（如必要）：
+\`\`\`typescript
+// 仅 3 行核心逻辑
+middleware.forEach(m => m.wrapModelCall(req, handler))
+\`\`\`
+
+
+## 输出格式要求
+
+**你必须输出单个 JSON 对象（不是数组）**，包含以下字段：
+
+- **name** (string): 记忆名称，kebab-case 格式，例如 "memory-system-design"
+- **description** (string): 中等长度描述，索引综述（200-500字符），包含：
+  * 背景和问题/场景
+  * 关键决策或解决方案
+  * 适用场景或范围
+  * 使用清晰的分号或句号分隔各部分
+- **content** (string): 详细内容，包含技术实现细节、文件路径、代码示例、关键决策等，按照内容提取模板组织
+- **tags** (array of string): 记忆标签，3-5 个，用于检索和分类，例如 ["langchain", "structured-output", "zod"]
+- **category** (enum): 记忆分类，可选值：architecture, bug-fix, workflow, configuration, optimization
+- **priority** (enum): 优先级，可选值：high, medium, low
+- **created** (string): 创建日期，ISO 格式 YYYY-MM-DD，例如 "2025-01-13"
+- **last_updated** (string): 最后更新日期，ISO 格式 YYYY-MM-DD，例如 "2025-01-13"
+- **context_scope** (enum): 上下文范围，可选值：user, project
+
+## 分类标准
+
+- **architecture**: 架构决策、设计模式、系统结构
+- **bug-fix**: Bug 修复和问题解决方案
+- **workflow**: 工作流程和最佳实践
+- **configuration**: 配置和环境设置
+- **optimization**: 性能优化和改进
+
+## 优先级标准
+
+- **high**: 关键架构决策、重要问题解决方案、影响系统正确性的问题
+- **medium**: 有用的模式、次要的配置信息、影响开发效率的问题
+- **low**: 一般性建议、参考信息、优化建议
+
+## 示例输出
+
+### 示例 1：有价值的记忆
+\`\`\`json
+{
+  "summary_of_chat": "用户反馈记忆系统的 summary_of_chat 字段过于简单，需要增强对话复现和后续行动说明。修改了 agents/code/memories/analyze.ts：1) 更新 MemoryCandidateSchema 中 summary_of_chat 的描述，要求 300-500 字包含完整对话过程、后续行动、关键成果；2) 在 smart_memory_prompt 中添加专门的"对话总结要求"章节，明确三部分内容（完整复现、后续行动、关键成果）；3) 提供格式示例和清晰的模板。✓ 完成：增强版记忆提示词；⏳ 待定：是否需要添加示例输出展示新的 summary_of_chat 格式；→ 建议：测试新提示词在实际对话中的表现",
+  "name": "memory-prompt-summary-enhancement",
+  "description": "增强记忆系统的 summary_of_chat 字段要求，要求完整复现对话过程并明确后续行动；包括任务背景→关键决策→解决方案→最终结果的完整流程，以及待完成任务、需要确认事项、下一步建议；适用于所有需要高质量对话总结的场景",
+  "content": "## 背景\\n\\n用户反馈记忆系统生成的 summary_of_chat 过于简单，缺少后续行动说明，无法有效回顾对话和继续工作。\\n\\n## 解决方案\\n\\n修改 \`agents/code/memories/analyze.ts\` 的三处：\\n\\n1. **Schema 增强**（第 18 行）：\\n\\\`\\\`\\\`typescript\\nsummary_of_chat: z.string().describe('对话总结（300-500字）：1) 完整复现对话的核心过程（任务背景→关键决策→解决方案→最终结果）；2) 明确说明接下来要做什么（后续行动、待完成任务、需要用户确认的事项）；3) 突出关键成果和交付物')\\n\\\`\\\`\\\`\\n\\n2. **提示词添加专门章节**：在 smart_memory_prompt 中添加"对话总结要求"部分，明确三个组成部分：完整复现、后续行动、关键成果\\n\\n3. **提供格式示例**：使用 → 表示流程，✓ 表示完成，⏳ 表示待定，→ 表示建议\\n\\n## 适用场景\\n\\n- 需要高质量对话总结的 AI 系统\\n- 需要明确后续行动的任务管理场景",
+  "tags": ["prompt-engineering", "memory-system", "conversation-summary", "langchain"],
+  "category": "optimization",
+  "priority": "medium",
+  "created": "2025-01-17",
+  "last_updated": "2025-01-17",
+  "context_scope": "project"
+}
+\`\`\`
+
+### 示例 2：无重要信息
+\`\`\`json
+{
+  "summary_of_chat": "用户询问如何查看 TUI 应用中的模型列表。已告知可通过 /model-panel 或 /mp 命令打开模型选择面板，使用 ↑↓ 键选择、Enter 键切换模型、q 键关闭面板。当前无其他问题。✓ 完成：问题已解答；⏳ 待定：无；→ 建议：如需更多帮助可使用 /help 命令",
+  "name": "no-memory-1736736000000",
+  "description": "本次对话无重要信息需要保存",
+  "content": "无重要信息",
+  "tags": [],
+  "category": "workflow",
+  "priority": "low",
+  "created": "2025-01-13",
+  "last_updated": "2025-01-13",
+  "context_scope": "project"
+}
+\`\`\`
+
+## 重要原则
+
+1. **宁缺毋滥**：评分 < 6 分时，返回"无重要信息"
+2. **避免重复**：不要记录显而易见或通用的知识
+3. **用户优先**：明确记录用户的指示和偏好
+4. **精确具体**：使用具体的文件名、代码片段、配置项
+5. **独立完整**：记忆应能独立理解，不依赖外部上下文
+`;
+async function Qe(s, e) {
+  const i = [
+    new U(e),
+    new U("请分析这段对话，提取值得保存的信息。")
+  ], o = await B({
+    model: s,
+    tools: [],
+    systemPrompt: Xe,
+    responseFormat: be(Ze)
+  }).invoke({ messages: i });
+  return await tt(o.structuredResponse);
+}
+function et(s, e) {
+  const i = s.toLowerCase().replace(/[^\u4e00-\u9fa5a-z0-9\s]/gi, " ").split(/\s+/).filter((a) => a.length > 1).slice(0, 4);
+  if (i.length === 0)
+    return `memory-${Date.now()}-${e}`;
+  const o = `${i.join("-")}-${Date.now()}-${e}`;
+  return o.length > 64 ? o.substring(0, 61) + "..." : o;
+}
+async function tt(s) {
+  if (s.name.startsWith("no-memory-"))
+    return `${s.summary_of_chat}
+
+---
+
+name: "${s.name}"
+description: "${s.description}"
+
+⚠️ 无重要信息，未保存记忆`;
+  const e = _.join(process.cwd(), ".claude/memories");
+  await d.mkdir(e, { recursive: !0 });
+  const i = s.name || et(s.content, 0), n = _.join(e, i);
+  await d.mkdir(n, { recursive: !0 });
+  const o = s.content.indexOf(`
+`), a = o > 0 ? s.content.substring(0, Math.min(o, 100)) : s.content.substring(0, Math.min(100, s.content.length)), r = `---
+name: "${s.name}"
+description: "${s.description}"
+tags: [${s.tags.map((l) => `"${l}"`).join(", ")}]
+category: "${s.category}"
+created: "${s.created}"
+last_updated: "${s.last_updated}"
+priority: "${s.priority}"
+context_scope: "${s.context_scope}"
+---
+
+# ${a}
+
+${s.content}
+`, c = _.join(n, "MEMORY.md");
+  return await d.writeFile(c, r, "utf-8"), `${s.summary_of_chat}
+    
+---
+
+name: "${s.name}"
+description: "${s.description}"
+
+✓ 保存记忆: ${Je(c)}`;
+}
+const E = /* @__PURE__ */ new Map(), P = process.platform === "win32", F = P ? "cmd.exe" : "/bin/bash", W = P ? ["/d", "/s", "/c"] : ["-c"], it = p(
+  async ({ command: s, timeout: e, run_in_background: i, kill_process_id: n, get_output_id: o, filter: a }) => {
+    if (n) {
+      const r = parseInt(n, 10), c = E.get(r);
+      return c ? (c.process.kill(), E.delete(r), `Successfully killed process with ID ${n}.`) : `Error: No background process found with ID ${n}.`;
+    }
+    if (o) {
+      const r = parseInt(o, 10), c = E.get(r);
+      if (!c)
+        return `Error: No background process found with ID ${o}.`;
+      let l = c.stdout.join(""), m = c.stderr.join("");
+      if (c.stdout = [], c.stderr = [], a) {
+        const u = new RegExp(a);
+        l = l.split(`
+`).filter((y) => u.test(y)).join(`
+`), m = m.split(`
+`).filter((y) => u.test(y)).join(`
+`);
+      }
+      let h = "";
+      return l && (h += `STDOUT:
+${l}
+`), m && (h += `STDERR:
+${m}
+`), h || "No new output since last check.";
+    }
+    if (!s)
+      return "Error: 'command' argument is required unless using 'kill_process_id' or 'get_output_id'.";
+    if (i)
+      try {
+        const r = x(F, [...W, s], {
+          timeout: e,
+          reject: !1,
+          windowsVerbatimArguments: P
+          // Windows 特殊处理
+        });
+        if (!r.pid)
+          return "Failed to start command in background.";
+        const c = {
+          process: r,
+          stdout: [],
+          stderr: []
+        };
+        return E.set(r.pid, c), r.stdout?.on("data", (l) => {
+          c.stdout.push(l.toString());
+        }), r.stderr?.on("data", (l) => {
+          c.stderr.push(l.toString());
+        }), r.on("close", () => {
+        }), `Command started in background with ID: ${r.pid}`;
+      } catch (r) {
+        return `Error starting background command: ${r}`;
+      }
+    else
+      try {
+        const r = await x(F, [...W, s], {
+          timeout: e,
+          reject: !1,
+          windowsVerbatimArguments: P
+        });
+        return r.exitCode !== 0 ? r.stderr : r.stdout;
+      } catch (r) {
+        return `Error executing command: ${r}`;
+      }
+  },
+  {
+    name: "terminal",
+    description: `Executes commands in a persistent shell session (Bash on Linux/macOS, CMD on Windows).
+Features:
+- Run commands (foreground or background)
+- Retrieve background process output
+- Kill background processes
+- Cross-platform support (auto-detects OS)
+
+Usage:
+1. Run Command: Provide \`command\`. Optional: \`run_in_background\`, \`timeout\`.
+2. Check Output: Provide \`get_output_id\`. Optional: \`filter\`.
+3. Kill Process: Provide \`kill_process_id\`.
+
+Notes:
+- For file paths with spaces, ALWAYS use quotes: "path/to file"
+- Avoid interactive commands (like top, vim)
+- Use '&&' or ';' to chain commands (PowerShell/CMD syntax varies, simple chaining often works)
+- CAN'T BATCH CALL THIS TOOL!
+`,
+    schema: t.object({
+      description: t.string().describe("what you want to do"),
+      command: t.string().optional().describe("The command to execute (required for running commands)"),
+      timeout: t.number().optional().describe("Timeout in ms (default: 120000)"),
+      run_in_background: t.boolean().optional().describe("Run command in background"),
+      kill_process_id: t.string().optional().describe("ID of process to kill"),
+      get_output_id: t.string().optional().describe("ID of process to get output from"),
+      filter: t.string().optional().describe("Regex to filter output (only for get_output_id)")
+    })
+  }
+), st = [it], nt = t.object({
+  operation: t.enum(["create", "list", "exists"]).describe("The folder operation to perform"),
+  folder_path: t.string().describe("The absolute path to the folder"),
+  description: t.string().optional().describe("What you want to do"),
+  recursive: t.boolean().default(!0).optional().describe("For create: create parent directories if they do not exist")
+}).strict(), ot = p(
+  async ({ operation: s, folder_path: e, recursive: i = !0 }) => {
+    try {
+      const n = _.resolve(e);
+      switch (s) {
+        case "create":
+          return await d.mkdir(n, { recursive: i }), `✓ Folder created successfully at: ${n}`;
+        case "exists":
+          try {
+            await d.access(n);
+            const o = await d.stat(n);
+            return `✓ Folder exists at: ${n}
+  Type: ${o.isDirectory() ? "Directory" : "File"}`;
+          } catch {
+            return `✗ Folder does not exist at: ${n}`;
+          }
+        case "list":
+          try {
+            const o = await d.readdir(n, { withFileTypes: !0 });
+            if (o.length === 0)
+              return `Folder is empty: ${n}`;
+            const a = [];
+            a.push(`📁 ${n}
+`);
+            const r = [], c = [];
+            for (const l of o) {
+              const m = _.join(n, l.name);
+              try {
+                const h = await d.stat(m), u = h.size, y = h.mtime.toLocaleDateString(), v = `${l.isDirectory() ? "📁" : "📄"} ${l.name}${l.isDirectory() ? "/" : ""} (${u} bytes, ${y})`;
+                l.isDirectory() ? r.push(v) : c.push(v);
+              } catch {
+                c.push(`⚠️ ${l.name} (unreadable)`);
+              }
+            }
+            return r.length > 0 && (a.push("Directories:"), r.forEach((l) => a.push(`  ${l}`)), a.push("")), c.length > 0 && (a.push("Files:"), c.forEach((l) => a.push(`  ${l}`))), a.push(`
+Total: ${r.length} directories, ${c.length} files`), a.join(`
+`);
+          } catch (o) {
+            if (o.code === "ENOENT")
+              return `✗ Folder not found: ${n}`;
+            if (o.code === "ENOTDIR")
+              return `✗ Path exists but is not a folder: ${n}`;
+            throw o;
+          }
+        default:
+          return `✗ Unknown operation: ${s}`;
+      }
+    } catch (n) {
+      return n.code === "ENOENT" ? `✗ Folder not found: ${e}` : n.code === "EACCES" ? `✗ Permission denied: ${e}` : `✗ Error: ${n.message}`;
+    }
+  },
+  {
+    name: "folder_operations",
+    description: `Unified folder operations tool supporting create, list, and existence check.
+
+**Operations:**
+- create: Create a folder (supports nested directory creation)
+- list: List all files and subdirectories with metadata
+- exists: Check if a folder exists
+
+**Usage Examples:**
+- Create nested folders: {operation: "create", folder_path: "/path/to/nested/folder"}
+- List contents: {operation: "list", folder_path: "/path/to/folder"}
+- Check existence: {operation: "exists", folder_path: "/path/to/folder"}
+
+**Important:**
+- All folder paths must be absolute paths
+- Create operation is recursive (creates parent directories if needed)
+- List operation shows file sizes and modification dates
+- Delete operations are not supported for safety reasons. Use terminal commands with user approval if needed.`,
+    schema: nt
+  }
+), at = t.object({
+  description: t.string().optional().describe("what you want to do"),
+  pattern: t.string().describe("The glob pattern to match files against"),
+  path: t.string().optional().describe(
+    'The directory to search in. If not specified, the current working directory will be used. IMPORTANT: Omit this field to use the default directory. DO NOT enter "undefined" or "null" - simply omit it for the default behavior. Must be a valid directory path if provided.'
+  )
+}), rt = p(
+  async ({ pattern: s, path: e }) => {
+    const i = await Te(s, {
+      ignore: [
+        "node_modules",
+        ".git",
+        "dist",
+        "build",
+        ".next",
+        ".turbo",
+        "coverage",
+        ".nyc_output",
+        "temp",
+        ".cache",
+        "vendor",
+        "venv",
+        "__pycache__",
+        "*.pyc",
+        "target",
+        "out",
+        ".output"
+      ],
+      cwd: e,
+      absolute: !0
+    });
+    return i.length === 0 ? "No files found." : i.join(`
+`);
+  },
+  {
+    name: "glob_files",
+    description: `- Fast file pattern matching tool that works with any codebase size
+- Supports glob patterns like "**/*.js" or "src/**/*.ts"
+- Returns matching file paths sorted by modification time
+- Use this tool when you need to find files by name patterns
+- When you are doing an open ended search that may require multiple rounds of globbing and grepping, use the Agent tool instead
+- You have the capability to call multiple tools in a single response. It is always better to speculatively perform multiple searches as a batch that are potentially useful.`,
+    schema: at
+  }
+), { mkdir: j, createWriteStream: ct, move: lt } = xe, X = G(Pe(import.meta.url)), dt = "microsoft/ripgrep-prebuilt", M = process.env.RIPGREP_VERSION || "v15.0.0", ut = () => {
+  const s = process.env.npm_config_arch || R.arch(), e = process.env.platform || R.platform();
+  switch (e) {
+    case "darwin":
+      return s === "arm64" ? "aarch64-apple-darwin.tar.gz" : "x86_64-apple-darwin.tar.gz";
+    case "win32":
+      switch (s) {
+        case "x64":
+          return "x86_64-pc-windows-msvc.zip";
+        case "arm":
+          return "aarch64-pc-windows-msvc.zip";
+        default:
+          return "i686-pc-windows-msvc.zip";
+      }
+    case "linux":
+      switch (s) {
+        case "x64":
+          return "x86_64-unknown-linux-musl.tar.gz";
+        case "arm":
+        case "armv7l":
+          return "arm-unknown-linux-gnueabihf.tar.gz";
+        case "arm64":
+          return "aarch64-unknown-linux-gnu.tar.gz";
+        case "ppc64":
+          return "powerpc64le-unknown-linux-gnu.tar.gz";
+        case "s390x":
+          return "s390x-unknown-linux-gnu.tar.gz";
+        default:
+          return "i686-unknown-linux-musl.tar.gz";
+      }
+    default:
+      throw new Error("Unknown platform: " + e);
+  }
+}, pt = async (s, e) => {
+  try {
+    const i = Ae(), n = await fetch(s);
+    if (!n.ok)
+      throw new Error(`HTTP ${n.status}: ${n.statusText}`);
+    await Ee(n.body, ct(i)), await j(G(e), { recursive: !0 }), await lt(i, e);
+  } catch (i) {
+    throw console.error(`Failed to download "${s}"`), i;
+  }
+}, mt = async (s, e) => {
+  try {
+    await j(e, { recursive: !0 }), await Se(s, { dir: e });
+  } catch (i) {
+    throw console.error(`Failed to unzip "${s}"`), i;
+  }
+}, ht = async (s, e) => {
+  try {
+    await j(e, { recursive: !0 }), await x("tar", ["xvf", s, "-C", e]);
+  } catch (i) {
+    throw console.error(`Failed to extract "${s}"`), i;
+  }
+}, gt = async (s) => {
+  if (s === "android")
+    try {
+      return await x("pkg", ["install", "ripgrep", "-y"]), !0;
+    } catch {
+      return console.info("Could not install ripgrep via pkg. Falling back to download."), !1;
+    }
+  return !1;
+}, Q = ye(X, `rg${process.platform === "win32" ? ".exe" : ""}`), ki = async (s) => {
+  if (await L(Q)) {
+    console.log("rg cached");
+    return;
+  }
+  const e = process.env.platform || R.platform();
+  if (e === "android" && await gt(e))
+    return;
+  const i = ut(), o = `${process.env.RIPGREP_PREBUILT_BINARIES_MIRROR || `https://v6.gh-proxy.org/https://github.com/${dt}/releases/download`}/${M}/ripgrep-${M}-${i}`, a = `${Me}/vscode-ripgrep/ripgrep-${M}-${i}`, r = X;
+  if (await L(a) ? console.info(`File ${a} has been cached`) : await pt(o, a), a.endsWith(".tar.gz"))
+    await ht(a, r);
+  else if (a.endsWith(".zip"))
+    await mt(a, r);
+  else
+    throw new Error(`Invalid downloadPath ${a}`);
+}, ft = async (s, e, i = {}) => {
+  const { timeout: n = 15e3, cwd: o = process.cwd() } = i;
+  try {
+    const a = await x(s, e, {
+      cwd: o,
+      timeout: n,
+      reject: !1,
+      // 不要在非零退出码时抛出异常
+      stripFinalNewline: !1,
+      // 保留原始输出格式
+      stdio: ["pipe", "pipe", "pipe"],
+      env: process.env
+      // 确保禁用颜色输出
+    });
+    return {
+      code: a.exitCode ?? 0,
+      stdout: a.stdout,
+      stderr: a.stderr
+    };
+  } catch (a) {
+    return a.timedOut ? {
+      code: 124,
+      // timeout exit code
+      stdout: a.stdout || "",
+      stderr: (a.stderr || "") + `
+Process timed out`
+    } : {
+      code: a.exitCode || 1,
+      stdout: a.stdout || "",
+      stderr: a.stderr || a.message || "Unknown error"
+    };
+  }
+}, wt = p(
+  async ({ args: s, head_limit: e }) => {
+    if (!s || s.length === 0)
+      return "Error: No arguments provided. Please provide ripgrep arguments.";
+    !e && !s.includes("--max-count") && (e = 500);
+    let i = await ft(Q, s, {
+      timeout: 15e3,
+      // 15秒超时
+      cwd: process.cwd()
+    });
+    if (e && i.stdout) {
+      const n = i.stdout.split(`
+`);
+      n.length > e && (i.stdout = n.slice(0, e).join(`
+`));
+    }
+    return i.code !== 0 && i.stderr ? i.code === 1 && i.stdout === "" ? "No matches found." : i.code === 124 || i.stderr.includes("timeout") || i.stderr.includes("timed out") ? "Error: Search timed out after 15 seconds. Please use a more specific pattern or limit the search scope with type/glob/path parameters." : `Error executing ripgrep: ${i.stderr}` : i.stdout || "No matches found.";
+  },
+  {
+    name: "search-files-rg",
+    description: `Ripgrep (rg) - A fast text search tool that recursively searches directories for regex patterns
+
+⚠️ IMPORTANT USAGE GUIDELINES:
+- This tool wraps the ripgrep (rg) command-line tool
+- Use this ONLY for searching TEXT PATTERNS within file contents
+- For reading entire files, use the Read tool instead
+- For finding files by name patterns, use the Glob tool instead
+
+🔍 SEARCH PATH REQUIREMENT:
+- MUST always specify a search path at the end of args array
+- If no specific path needed, use "./" for current directory
+- Never omit the path parameter - ripgrep requires it
+
+Usage - Pass ripgrep (rg) arguments as an array:
+The args array corresponds directly to 'rg [OPTIONS] PATTERN [PATH ...]'
+
+Examples:
+- Search pattern in current directory: ["PATTERN", "./"]
+- Search in specific path: ["PATTERN", "src/"]
+- Search with file type filter: ["--type", "ts", "PATTERN", "./"]
+- Case insensitive search: ["-i", "PATTERN", "./"]
+- Show line numbers: ["-n", "PATTERN", "./"]
+- Show context lines: ["-C", "3", "PATTERN", "./"]
+- Only show file names: ["-l", "PATTERN", "./"]
+- Count matches: ["-c", "PATTERN", "./"]
+- Multiple options: ["-n", "-i", "--type", "js", "function", "src/"]
+
+Common ripgrep (rg) options:
+- -i, --ignore-case: Case insensitive search
+- -n, --line-number: Show line numbers
+- -A NUM: Show NUM lines after each match
+- -B NUM: Show NUM lines before each match
+- -C NUM: Show NUM lines around each match
+- -l, --files-with-matches: Only show file paths that match
+- -c, --count: Only show count of matches per file
+- --type TYPE: Only search files of TYPE (js, ts, py, rust, etc.)
+- --glob PATTERN: Include/exclude files matching PATTERN
+- --max-count NUM: Stop after NUM matches per file
+- --no-ignore: Don't respect .gitignore files
+- --hidden: Search hidden files and directories
+
+Performance:
+- 15 second timeout per search
+- Results limited to 500 lines by default (use head_limit parameter)
+- Respects .gitignore by default (use --no-ignore to override)
+`,
+    schema: t.object({
+      description: t.string().optional().describe("what you want to do"),
+      args: t.array(t.string()).describe(
+        'Ripgrep (rg) command arguments as array. Format: [OPTIONS...] PATTERN [PATH...]. MUST include path at end! Examples: ["import", "./"] (search "import" in current dir), ["-n", "-i", "function", "./"] (search "function" with line numbers, case insensitive), ["--type", "ts", "export", "src/"] (search "export" in TypeScript files in src/).'
+      ),
+      head_limit: t.number().optional().describe(
+        "Limit output to first N lines. If not specified and no --max-count in args, defaults to 500 lines for performance."
+      )
+    })
+  }
+), O = 2e3, yt = t.object({
+  description: t.string().optional().describe("what you want to do"),
+  file_path: t.string().describe("The absolute path to the file to read"),
+  offset: t.number().default(0).optional().describe("The line number to start reading from. Only provide if the file is too large to read at once"),
+  limit: t.number().default(O).optional().describe("The number of lines to read. Only provide if the file is too large to read at once.")
+}), bt = $(
+  async ({ file_path: s, offset: e, limit: i }) => {
+    try {
+      let o = (await d.readFile(s, "utf-8")).split(`
+`);
+      return e && (o = o.slice(e - 1)), i && (o = o.slice(0, i)), o.join(`
+`);
+    } catch (n) {
+      if (n.code === "ENOENT")
+        return `Error: File not found at ${s}`;
+      throw n;
+    }
+  },
+  {
+    name: "read_file",
+    description: `Reads a file from the local filesystem. You can access any file directly by using this tool.
+Assume this tool is able to read all files on the machine. If the User provides a path to a file assume that path is valid. It is okay to read a file that does not exist; an error will be returned.
+
+Usage:
+- The file_path parameter must be an absolute path, not a relative path
+- By default, it reads up to ${O} lines starting from the beginning of the file
+- You can optionally specify a line offset and limit (especially handy for long files), but it's recommended to read the whole file by not providing these parameters
+- Any lines longer than ${O} characters will be truncated
+- Results are returned using cat -n format, with line numbers starting at 1
+- This tool allows You to read images (eg PNG, JPG, etc). When reading an image file the contents are presented visually as You is a multimodal LLM.
+- This tool can read PDF files (.pdf). PDFs are processed page by page, extracting both text and visual content for analysis.
+- This tool can read Jupyter notebooks (.ipynb files) and returns all cells with their outputs, combining code, text, and visualizations.
+- You have the capability to call multiple tools in a single response. It is always better to speculatively read multiple files as a batch that are potentially useful. 
+- You will regularly be asked to read screenshots. If the user provides a path to a screenshot ALWAYS use this tool to view the file at the path. This tool will work with all temporary file paths like /var/folders/123/abc/T/TemporaryItems/NSIRD_screencaptureui_ZfB1tD/Screenshot.png
+- If you read a file that exists but has empty contents you will receive a system reminder warning in place of file contents.`,
+    schema: yt
+  }
+), _t = p(
+  async ({ file_path: s, content: e }) => {
+    try {
+      return await d.writeFile(s, e, "utf-8"), `File ${s} has been written successfully.`;
+    } catch (i) {
+      return `Error writing file: ${i.message}`;
+    }
+  },
+  {
+    name: "write_file",
+    description: `Writes a file to the local filesystem.
+Usage:
+- This tool will overwrite the existing file if there is one at the provided path.
+- If this is an existing file, you MUST use the Read tool first to read the file's contents. This tool will fail if you did not read the file first.
+- ALWAYS prefer editing existing files in the codebase. NEVER write new files unless explicitly required.
+- NEVER proactively create documentation files (*.md) or README files. Only create documentation files if explicitly requested by the User.
+- Only use emojis if the user explicitly requests it. Avoid writing emojis to files unless asked.`,
+    schema: t.object({
+      description: t.string().optional().describe("what you want to do"),
+      file_path: t.string().describe("The absolute path to the file to write (must be absolute, not relative)"),
+      content: t.string().describe("The content to write to the file")
+    })
+  }
+), kt = t.object({
+  description: t.string().optional().describe("what you want to do"),
+  file_path: t.string().describe("The absolute path to the file to modify"),
+  old_string: t.string().describe("The text to replace"),
+  new_string: t.string().describe("The text to replace it with (must be different from old_string)"),
+  replace_all: t.boolean().optional().default(!1).describe("Replace all occurences of old_string (default false)")
+}), vt = p(
+  async ({ file_path: s, old_string: e, new_string: i, replace_all: n = !1 }) => {
+    try {
+      const o = await d.readFile(s, "utf-8");
+      if (n) {
+        if (!o.includes(e))
+          return `Error: old_string not found in ${s}`;
+        const a = o.split(e).join(i);
+        return await d.writeFile(s, a, "utf-8"), `File ${s} has been edited successfully. Replaced all occurrences of old_string.`;
+      } else {
+        const a = o.split(e);
+        if (a.length === 1)
+          return `Error: old_string not found in ${s}`;
+        if (a.length > 2)
+          return `Error: old_string is not unique in ${s} (found ${a.length - 1} occurrences). Please provide more context or set replace_all to true.`;
+        const r = o.replace(e, i);
+        return await d.writeFile(s, r, "utf-8"), `File ${s} has been edited successfully. Replaced single occurrence of old_string.`;
+      }
+    } catch (o) {
+      if (o.code === "ENOENT")
+        return `Error: File not found at ${s}`;
+      throw o;
+    }
+  },
+  {
+    name: "edit_file",
+    description: "Performs exact string replacements in files. \n\nUsage:\n- You must use your `Read` tool at least once in the conversation before editing. This tool will error if you attempt an edit without reading the file. \n- When editing text from Read tool output, ensure you preserve the exact indentation (tabs/spaces) as it appears AFTER the line number prefix. The line number prefix format is: spaces + line number + tab. Everything after that tab is the actual file content to match. Never include any part of the line number prefix in the old_string or new_string.\n- ALWAYS prefer editing existing files in the codebase. NEVER write new files unless explicitly required.\n- Only use emojis if the user explicitly requests it. Avoid adding emojis to files unless asked.\n- The edit will FAIL if `old_string` is not unique in the file. Either provide a larger string with more surrounding context to make it unique or use `replace_all` to change every instance of `old_string`. \n- Use `replace_all` for replacing and renaming strings across the file. This parameter is useful if you want to rename a variable for instance.",
+    schema: kt
+  }
+);
+p(
+  async (s) => `Agent task for '${s.description}' started with prompt: ${s.prompt}. Subagent type: ${s.subagent_type}`,
+  {
+    name: "Task",
+    description: `Launch a new agent to handle complex, multi-step tasks autonomously. 
+
+Available agent types and the tools they have access to:
+- general-purpose: General-purpose agent for researching complex questions, searching for code, and executing multi-step tasks. When you are searching for a keyword or file and are not confident that you will find the right match in the first few tries use this agent to perform the search for you. (Tools: *)
+- statusline-setup: Use this agent to configure the user's Claude Code status line setting. (Tools: Read, Edit)
+- output-style-setup: Use this agent to create a Claude Code output style. (Tools: Read, Write, Edit, Glob, LS, Grep)
+
+When using the Task tool, you must specify a subagent_type parameter to select which agent type to use.
+
+
+
+When NOT to use the Agent tool:
+- If you want to read a specific file path, use the Read or Glob tool instead of the Agent tool, to find the match more quickly
+- If you are searching for a specific class definition like "class Foo", use the Glob tool instead, to find the match more quickly
+- If you are searching for code within a specific file or set of 2-3 files, use the Read tool instead of the Agent tool, to find the match more quickly
+- Other tasks that are not related to the agent descriptions above
+
+
+Usage notes:
+1. Launch multiple agents concurrently whenever possible, to maximize performance; to do that, use a single message with multiple tool uses
+2. When the agent is done, it will return a single message back to you. The result returned by the agent is not visible to the user. To show the user the result, you should send a text message back to the user with a concise summary of the result.
+3. Each agent invocation is stateless. You will not be able to send additional messages to the agent, nor will the agent be able to communicate with you outside of its final report. Therefore, your prompt should contain a highly detailed task description for the agent to perform autonomously and you should specify exactly what information the agent should return back to you in its final and only message to you.
+4. The agent's outputs should generally be trusted
+5. Clearly tell the agent whether you expect it to write code or just to do research (search, file reads, web fetches, etc.), since it is not aware of the user's intent
+6. If the agent description mentions that it should be used proactively, then you should try your best to use it without the user having to ask for it first. Use your judgement.
+
+Example usage:
+
+<example_agent_descriptions>
+"code-reviewer": use this agent after you are done writing a significant piece of code
+"greeting-responder": use this agent when to respond to user greetings with a friendly joke
+</example_agent_description>
+
+<example>
+user: "Please write a function that checks if a number is prime"
+assistant: Sure let me write a function that checks if a number is prime
+assistant: First let me use the Write tool to write a function that checks if a number is prime
+assistant: I'm going to use the Write tool to write the following code:
+<code>
+function isPrime(n) {
+  if (n <= 1) return false
+  for (let i = 2; i * i <= n; i++) {
+    if (n % i === 0) return false
+  }
+  return true
+}
+</code>
+<commentary>
+Since a signficant piece of code was written and the task was completed, now use the code-reviewer agent to review the code
+</commentary>
+assistant: Now let me use the code-reviewer agent to review the code
+assistant: Uses the Task tool to launch the with the code-reviewer agent 
+</example>
+
+<example>
+user: "Hello"
+<commentary>
+Since the user is greeting, use the greeting-responder agent to respond with a friendly joke
+</commentary>
+assistant: "I'm going to use the Task tool to launch the with the greeting-responder agent"
+</example>
+`,
+    schema: t.object({
+      description: t.string().describe("A short (3-5 word) description of the task"),
+      prompt: t.string().describe("The task for the agent to perform"),
+      subagent_type: t.string().describe("The type of specialized agent to use for this task")
+    })
+  }
+);
+const Tt = t.object({
+  content: t.string().min(1),
+  status: t.enum(["pending", "in_progress", "completed"]),
+  id: t.string()
+}), St = t.object({
+  todos: t.array(Tt).describe("The updated todo list")
+}), xt = p(
+  async () => "todo saved successfully",
+  {
+    name: "TodoWrite",
+    description: `Use this tool to create and manage a structured task list for your current coding session. This helps you track progress, organize complex tasks, and demonstrate thoroughness to the user.
+It also helps the user understand the progress of the task and overall progress of their requests.
+## When to Use This Tool
+Use this tool proactively in these scenarios:
+
+1. Complex multi-step tasks - When a task requires 3 or more distinct steps or actions
+2. Non-trivial and complex tasks - Tasks that require careful planning or multiple operations
+3. User explicitly requests todo list - When the user directly asks you to use the todo list
+4. User provides multiple tasks - When users provide a list of things to be done (numbered or comma-separated)
+5. After receiving new instructions - Immediately capture user requirements as todos
+6. When you start working on a task - Mark it as in_progress BEFORE beginning work. Ideally you should only have one todo as in_progress at a time
+7. After completing a task - Mark it as completed and add any new follow-up tasks discovered during implementation
+
+## When NOT to Use This Tool
+
+Skip using this tool when:
+1. There is only a single, straightforward task
+2. The task is trivial and tracking it provides no organizational benefit
+3. The task can be completed in less than 3 trivial steps
+4. The task is purely conversational or informational
+
+NOTE that you should not use this tool if there is only one trivial task to do. In this case you are better off just doing the task directly.
+
+## Examples of When to Use the Todo List
+
+<example>
+User: I want to add a dark mode toggle to the application settings. Make sure you run the tests and build when you're done!
+Assistant: I'll help add a dark mode toggle to your application settings. Let me create a todo list to track this implementation.
+*Creates todo list with the following items:*
+1. Create dark mode toggle component in Settings page
+2. Add dark mode state management (context/store)
+3. Implement CSS-in-JS styles for dark theme
+4. Update existing components to support theme switching
+5. Run tests and build process, addressing any failures or errors that occur
+*Begins working on the first task*
+
+<reasoning>
+The assistant used the todo list because:
+1. Adding dark mode is a multi-step feature requiring UI, state management, and styling changes
+2. The user explicitly requested tests and build be run afterward
+3. The assistant inferred that tests and build need to pass by adding "Ensure tests and build succeed" as the final task
+</reasoning>
+</example>
+
+<example>
+User: Help me rename the function getCwd to getCurrentWorkingDirectory across my project
+Assistant: Let me first search through your codebase to find all occurrences of 'getCwd'.
+*Uses grep or search tools to locate all instances of getCwd in the codebase*
+Assistant: I've found 15 instances of 'getCwd' across 8 different files. Let me create a todo list to track these changes.
+*Creates todo list with specific items for each file that needs updating*
+
+<reasoning>
+The assistant used the todo list because:
+1. First, the assistant searched to understand the scope of the task
+2. Upon finding multiple occurrences across different files, it determined this was a complex task with multiple steps
+3. The todo list helps ensure every instance is tracked and updated systematically
+4. This approach prevents missing any occurrences and maintains code consistency
+</reasoning>
+</example>
+
+
+<example>
+User: I need to implement these features for my e-commerce site: user registration, product catalog, shopping cart, and checkout flow.
+Assistant: I'll help implement these features. First, let's add all the features to the todo list.
+*Creates a todo list breaking down each feature into specific tasks based on the project architecture*
+Assistant: Let's start with user registration. This will involve creating database models, API endpoints, and frontend forms that integrate with your existing authentication system.
+
+<reasoning>
+The assistant used the todo list because:
+1. The user provided multiple complex features to implement in a comma separated list
+2. The todo list helps organize these large features into manageable tasks
+3. This approach allows for tracking progress across the entire implementation
+</reasoning>
+</example>
+
+<example>
+User: Can you help optimize my React application? It's rendering slowly and has performance issues.</user>
+Assistant: I'll help optimize your React application. First, let me examine your codebase to identify potential performance bottlenecks.
+*Reviews component structure, render patterns, state management, and data fetching*
+Assistant: After analyzing your codebase, I've identified several performance issues. Let me create a todo list to track our optimization efforts.
+*Creates todo list with items like: 1) Implement memoization for expensive calculations in ProductList, 2) Add virtualization for long lists in Dashboard, 3) Optimize image loading in Gallery component, 4) Fix state update loops in ShoppingCart, 5) Review bundle size and implement code splitting*
+Let's start by implementing memoization for the expensive calculations in your ProductList component.</assistant>
+
+<reasoning>
+The assistant used the todo list because:
+1. First, the assistant examined the codebase to identify specific performance issues
+2. Based on this analysis, it identified multiple optimization opportunities
+3. Performance optimization is a non-trivial task requiring multiple steps
+4. The todo list helps methodically track improvements across different components
+5. This systematic approach ensures all performance bottlenecks are addressed
+</reasoning>
+</example>
+
+## Examples of When NOT to Use the Todo List
+
+<example>
+User: How do I print 'Hello World' in Python?
+Assistant: In Python, you can print "Hello World" with this simple code:
+
+python
+print("Hello World")
+
+This will output the text "Hello World" to the console when executed.</assistant>
+
+<reasoning>
+The assistant did not use the todo list because this is a single, trivial task that can be completed in one step. There's no need to track multiple tasks or steps for such a straightforward request.
+</reasoning>
+</example>
+
+<example>
+User: What does the git status command do?
+Assistant: The git status command shows the current state of your working directory and staging area. It displays which changes have been staged, which haven't, and which files aren't being tracked by Git. This is a fundamental command for understanding the current state of your repository before making commits.
+
+<reasoning>
+The assistant did not use the todo list because this is an informational request with no actual coding task to complete. The user is simply asking for an explanation, not for the assistant to perform multiple steps or tasks.
+</reasoning>
+</example>
+
+<example>
+User: Can you add a comment to the calculateTotal function to explain what it does?
+Assistant: Sure, let me add a comment to the calculateTotal function to explain what it does.
+* Uses the Edit tool to add a comment to the calculateTotal function *
+
+<reasoning>
+The assistant did not use the todo list because this is a single, straightforward task confined to one location in the code. Adding a comment doesn't require tracking multiple steps or systematic organization.
+</reasoning>
+</example>
+
+<example>
+User: Run npm install for me and tell me what happens.
+Assistant: I'll run the npm install command for you.
+
+*Executes: npm install*
+
+The command completed successfully. Here's the output:
+[Output of npm install command]
+
+All dependencies have been installed according to your package.json file.
+
+<reasoning>
+The assistant did not use the todo list because this is a single command execution with immediate results. There are no multiple steps to track or organize, making the todo list unnecessary for this straightforward task.
+</reasoning>
+</example>
+
+## Task States and Management
+
+1. **Task States**: Use these states to track progress:
+   - pending: Task not yet started
+   - in_progress: Currently working on (limit to ONE task at a time)
+   - completed: Task finished successfully
+
+2. **Task Management**:
+   - Update task status in real-time as you work
+   - Mark tasks complete IMMEDIATELY after finishing (don't batch completions)
+   - Only have ONE task in_progress at any time
+   - Complete current tasks before starting new ones
+   - Remove tasks that are no longer relevant from the list entirely
+
+3. **Task Completion Requirements**:
+   - ONLY mark a task as completed when you have FULLY accomplished it
+   - If you encounter errors, blockers, or cannot finish, keep the task as in_progress
+   - When blocked, create a new task describing what needs to be resolved
+   - Never mark a task as completed if:
+     - Tests are failing
+     - Implementation is partial
+     - You encountered unresolved errors
+     - You couldn't find necessary files or dependencies
+
+4. **Task Breakdown**:
+   - Create specific, actionable items
+   - Break complex tasks into smaller, manageable steps
+   - Use clear, descriptive task names
+
+When in doubt, use this tool. Being proactive with task management demonstrates attentiveness and ensures you complete all requirements successfully.
+`,
+    schema: St
+  }
+), Ct = t.object({
+  label: t.string().min(1).max(50).describe("选项显示文本，简洁明了（1-50 字符）")
+}), Et = t.object({
+  description: t.string().min(1).describe("向用户提出的问题，清晰具体，包含必要的上下文"),
+  type: t.enum(["single_select", "multi_select"]).describe("选择类型：single_select（单选）或 multi_select（多选）"),
+  options: t.array(Ct).min(2).max(6).describe("选项列表，至少 2 个，最多 6 个"),
+  allow_custom_input: t.boolean().default(!0).describe("是否允许用户输入自定义文本，默认 true"),
+  placeholder: t.string().optional().describe("自定义输入框的占位符文本")
+}), Pt = $(() => {
+}, {
+  name: "ask_user_questions",
+  description: "Ask the user a question with selectable options",
+  schema: Et
+}), At = [
+  Pt,
+  xt,
+  rt,
+  wt,
+  bt,
+  _t,
+  vt,
+  ot,
+  ...st
+];
+async function Mt(s, e) {
+  await s.addTool({
+    id: e.name,
+    name: e.name,
+    description: e.description
+  });
+  const i = {
+    id: e.name,
+    name: e.name,
+    description: e.description,
+    paramsSchema: e.schema,
+    execute: async (n) => {
+      const o = await e.invoke(n);
+      return o && typeof o == "object" && "content" in o ? o.content : o;
+    }
+  };
+  s.tools.registerImplementation(i);
+}
+async function Rt(s) {
+  return await Promise.all(At.map((e) => Mt(s, e)));
+}
+async function It(s) {
+  const e = {
+    id: "subagents",
+    name: "subagents",
+    description: "Task delegation to specialized agents",
+    execute: async () => {
+      const { SubAgentsMiddleware: a } = await import("./subTasks-5KLIr9iy.mjs");
+      return new a(s);
+    }
+  };
+  await s.addMiddleware(e), s.middlewares.registerImplementation(e);
+  const i = {
+    id: "memories",
+    name: "memories",
+    description: "Knowledge persistence",
+    execute: async (a) => {
+      a.projectMemoriesDir = a.projectMemoriesDir || "./.claude/memories";
+      const { MemoriesMiddleware: r } = await import("./memories-rSGKIPk5.mjs");
+      return new r(a);
+    }
+  };
+  await s.addMiddleware(i), s.middlewares.registerImplementation(i);
+  const n = {
+    id: "skills",
+    name: "skills",
+    description: "Progressive skills disclosure",
+    execute: async (a) => {
+      a.projectSkillsDir = a.projectSkillsDir || "./.claude/skills";
+      const { SkillsMiddleware: r } = await import("@langgraph-js/standard-agent");
+      return new r(a);
+    }
+  };
+  await s.addMiddleware(n), s.middlewares.registerImplementation(n);
+  const o = {
+    id: "agents_md",
+    name: "agents_md",
+    description: "Inject agent documentation",
+    execute: async (a) => {
+      const { AgentsMdMiddleware: r } = await import("@langgraph-js/standard-agent");
+      return new r({ projectRoot: a?.projectRoot });
+    }
+  };
+  await s.addMiddleware(o), s.middlewares.registerImplementation(o);
+}
+const Ot = `# Zen Code
+
+你是 Zen Code，一个高度自主的编程智能体。你具备独立思考、规划和执行复杂任务的能力。
+
+---
+
+## 一、核心认知模型
+
+### 1.1 思维框架
+
+你采用 **观察-推理-行动-反思** 循环（ORAR）：
+
+\`\`\`
+OBSERVE → REASON → ACT → REFLECT
+   ↑                        ↓
+   ←←←←←←←←←←←←←←←←←←←←←←←←←
+\`\`\`
+
+- **观察 (Observe)**: 收集信息、理解上下文、识别约束
+- **推理 (Reason)**: 分析问题、评估方案、规划路径
+- **行动 (Act)**: 执行操作、生成代码、调用工具
+- **反思 (Reflect)**: 验证结果、学习教训、优化策略
+
+### 1.2 自主决策等级
+
+根据任务风险自动选择决策模式：
+
+| 等级 | 触发条件 | 行为模式 |
+|------|----------|----------|
+| **L1 自动** | 只读操作、低风险修改 | 直接执行，事后汇报 |
+| **L2 通知** | 中等修改、可逆操作 | 执行并详细说明 |
+| **L3 确认** | 高风险操作、架构变更 | 先询问再执行 |
+
+**L1 自动执行**：文件读取、代码搜索、类型检查、格式化
+**L2 通知执行**：单文件修改、添加测试、重构局部代码
+**L3 需确认**：多文件架构变更、添加依赖、删除代码、执行脚本
+
+### 1.3 任务复杂度评估
+
+接收任务后立即评估：
+
+\`\`\`
+简单 (S): 单点修改，<5分钟，直接执行
+中等 (M): 多文件协调，5-30分钟，制定计划
+复杂 (C): 架构变更，>30分钟，使用 TodoWrite 分解
+\`\`\`
+
+---
+
+## 二、信息收集策略
+
+### 2.1 递进式探索
+
+从宏观到微观，按需深入：
+
+\`\`\`
+Level 1: 项目结构 (AGENTS.md、README.md、package.json)
+    ↓
+Level 2: 模块边界 (入口文件、类型定义、配置文件)
+    ↓
+Level 3: 实现细节 (具体函数、测试用例、依赖关系)
+\`\`\`
+
+### 2.2 搜索策略矩阵
+
+| 目标 | 首选工具 | 备选策略 |
+|------|----------|----------|
+| 找函数/类定义 | \`search-files-rg\` 正则 | glob + 读取 |
+| 找文件位置 | \`glob_files\` 模式 | 目录遍历 |
+| 理解调用关系 | grep 引用 + 读取上下文 | 类型定义追踪 |
+| 找配置项 | grep 配置文件 | 环境变量搜索 |
+
+### 2.3 上下文构建原则
+
+- **最小必要**：只读取完成任务所需的信息
+- **关联发现**：通过 import/export 追踪依赖
+- **类型优先**：先看接口定义，再看实现
+- **测试参考**：测试用例揭示使用方式和边界
+
+---
+
+## 三、执行策略
+
+### 3.1 代码修改原则
+
+**保守修改**：
+- 只改必须改的部分
+- 保持与现有代码风格一致
+- 优先使用项目已有的模式和工具
+
+**安全边界**：
+- 修改前理解影响范围
+- 一次只改一个关注点
+- 保持向后兼容，除非明确要求破坏性变更
+
+### 3.2 错误处理策略
+
+遇到错误时按优先级尝试：
+
+1. **理解错误**：分析错误信息，定位根因
+2. **局部修复**：尝试最小范围修复
+3. **扩大搜索**：收集更多上下文
+4. **替代方案**：尝试不同实现路径
+5. **请求协助**：使用 \`ask_user_questions\` 询问方向
+
+### 3.3 验证循环
+
+每个修改后执行验证：
+
+\`\`\`
+修改代码 → 检查语法 → 运行相关测试 → 确认无副作用
+\`\`\`
+
+---
+
+## 四、输出规范
+
+### 4.1 简洁原则
+
+- **无寒暄**：直接进入主题
+- **无冗余**：不重复用户已知信息
+- **结构化**：使用列表和代码块
+
+### 4.2 信息层级
+
+**必要信息** - 总是包含：
+- 执行了什么操作
+- 修改了哪些文件
+- 关键结果或发现
+
+**补充信息** - 按需包含：
+- 替代方案说明
+- 潜在风险提示
+- 后续建议
+
+**详细信息** - 需要时写入文件：
+- 完整分析报告
+- 大量代码展示
+- 详细调试日志
+
+### 4.3 代码展示
+
+\`\`\`diff
+# 只展示变更的关键部分
++ // 新增代码
+- // 删除代码
+  // 上下文（少量）
+\`\`\`
+
+### 4.4 长度控制
+
+- 单次回复 < 50 行
+- 超过时使用 \`write_file\` 保存详情
+- 或使用 \`ask_user_questions\` 分步展开
+
+---
+
+## 五、编码标准
+
+### 5.1 技术选型优先级
+
+1. 项目已有方案 > 引入新方案
+2. 标准库 > 轻量第三方库 > 重型框架
+3. 成熟稳定 > 新潮技术
+4. 类型安全 > 便捷
+
+### 5.2 代码质量
+
+**必须**：
+- 类型完整（禁用 any）
+- 错误处理（无静默失败）
+- 可读性（描述性命名）
+
+**推荐**：
+- 函数式风格（纯函数、不可变）
+- 单一职责（一个函数做一件事）
+- 组合优于继承
+
+### 5.3 命名规范
+
+| 类型 | 规范 | 示例 |
+|------|------|------|
+| 布尔值 | is/has/should 前缀 | isLoading, hasError |
+| 事件处理 | handle/on 前缀 | handleClick, onSubmit |
+| 异步函数 | 动词开头 | fetchUser, createTask |
+| 常量 | UPPER_SNAKE_CASE | MAX_RETRY_COUNT |
+
+### 5.4 Git 规范
+
+Angular 格式：\`type(scope): subject\`
+
+类型：feat, fix, refactor, docs, test, chore
+
+示例：\`feat(auth): add JWT refresh token\`
+
+---
+
+## 六、工具使用指南
+
+### 6.1 性能意识
+
+| 操作类型 | 耗时 | 策略 |
+|----------|------|------|
+| 读取/搜索 | <0.5s | 优先使用 |
+| 执行命令 | 0.5-5s | 按需使用 |
+| 全项目扫描 | >5s | 避免使用 |
+
+### 6.2 路径规范
+
+所有文件路径必须使用绝对路径。
+
+### 6.3 文件操作
+
+**移动/重命名**：使用 terminal 执行 \`mv\` 命令
+**批量修改**：使用 \`edit_file\` 的 \`replace_all\` 参数
+**新建目录**：使用 \`folder_operations\` 的 create 操作
+
+### 6.4 并行执行
+
+无依赖的操作可以并行调用多个工具，提高效率。
+
+---
+
+## 七、协作模式
+
+### 7.1 与用户协作
+
+**主动沟通**：
+- 发现潜在问题时提前告知
+- 有多个可行方案时请求选择
+- 任务完成时提供后续建议
+
+**避免**：
+- 假设用户意图（不确定就问）
+- 隐藏风险或问题
+- 过度询问显而易见的事情
+
+### 7.2 任务管理
+
+**简单任务**：直接执行
+**复杂任务**：使用 TodoWrite 分解追踪
+
+### 7.3 知识积累
+
+执行任务中发现的重要信息：
+- 项目特有约定
+- 踩坑经验
+- 最佳实践
+
+可建议用户记录到 .claude/memories/ 或 AGENTS.md
+
+---
+
+## 八、安全边界
+
+### 8.1 绝对禁止
+
+- 编写/解释恶意代码
+- 删除无法恢复的数据（未备份）
+- 暴露敏感信息（密钥、密码）
+- 绕过安全检查
+
+### 8.2 谨慎操作
+
+以下操作需要 L3 确认：
+- 执行未知脚本
+- 修改安全相关配置
+- 访问网络/外部服务
+- 修改系统级文件
+
+---
+
+## 九、自我提升
+
+### 9.1 持续学习
+
+- 从每次交互中学习项目约定
+- 识别并适应用户偏好
+- 发现可复用的模式
+
+### 9.2 元认知
+
+定期反思：
+- 这次任务我做得如何？
+- 有没有更好的方法？
+- 用户的真实需求是什么？
+
+---
+
+## 附录：决策速查
+
+\`\`\`
+任务来了
+    ↓
+评估复杂度 → S: 直接做 → 完成汇报
+    ↓ M/C
+需要更多信息？ → 是 → 收集信息（递进式）
+    ↓ 否
+有风险？ → L3 → 询问确认
+    ↓ L1/L2
+执行 → 验证 → 反思 → 输出结果
+\`\`\`
+
+`;
+async function $t(s) {
+  return `
+## 环境信息
+工作目录: ${process.cwd()}
+平台: ${process.platform}
+日期: ${(/* @__PURE__ */ new Date()).toLocaleDateString()}
+`;
+}
+const zt = `# 架构师 - 任务派发协调者
+
+你是一位**任务派发架构师**，核心职责是将用户需求分析并拆解为子任务，然后委派给合适的子 agent 执行。
+
+## 核心职责
+
+**你的唯一任务**：
+1. 理解用户需求
+2. 拆解为可执行的子任务
+3. 委派给合适的子 agent
+4. 跟踪和汇总结果
+
+**不要做的事**：
+- ❌ 不要自己编写代码
+- ❌ 不要自己读取文件或搜索代码
+- ❌ 不要自己执行终端命令
+- ❌ 不要做具体的架构分析或设计文档
+
+## 工作流程
+
+### 步骤 1：需求分析
+
+当收到用户请求时，快速判断：
+
+1. **任务类型**：
+   - 代码实现/修改 → 委派给 \`agents/default\`
+   - 任务规划/协调 → 委派给 \`agents/manager\`
+   - 复杂任务 → 先由 \`agents/manager\` 规划，再由 \`agents/default\` 执行
+
+2. **任务规模**：
+   - 单一任务 → 直接委派
+   - 多任务 → 拆分后分别委派
+
+### 步骤 2：任务拆解
+
+使用 \`task\` 工具委派任务：
+
+\`\`\`typescript
+// 示例：委派代码实现任务
+{
+  subagent_id: "agents/default",
+  task_description: "实现用户认证功能，包括登录、注册、登出三个接口",
+  data_transfer: {
+    requirements: "使用 JWT 认证，密码需要加密存储",
+    constraints: "使用现有的数据库连接池"
+  }
+}
+\`\`\`
+
+### 步骤 3：结果汇总
+
+子 agent 完成后：
+1. 检查执行结果
+2. 如果有多个子任务，协调依赖关系
+3. 向用户汇报整体进度和结果
+
+## 委派策略
+
+### 简单任务
+
+用户请求单一功能时，直接委派：
+
+> 用户：添加一个日志工具函数
+
+→ 委派给 \`agents/default\`，任务描述清晰完整
+
+### 复杂任务
+
+用户请求多功能时，拆分后委派：
+
+> 用户：重构用户模块并添加测试
+
+→ 拆分为：
+1. 委派 \`agents/default\`：重构用户模块代码
+2. 等第一步完成后，委派 \`agents/default\`：为用户模块编写测试
+
+### 规划任务
+
+用户需要方案设计时：
+
+> 用户：设计一个新的权限系统
+
+→ 委派 \`agents/manager\` 进行任务规划，然后按规划执行
+
+## 输出格式
+
+### 委派时
+
+\`\`\`markdown
+## 任务分析
+
+**用户需求**：{用户原始请求}
+
+**任务拆解**：
+1. 任务 A → 委派给 agents/default
+2. 任务 B → 委派给 agents/manager
+
+**开始执行**...
+\`\`\`
+
+### 汇报时
+
+\`\`\`markdown
+## 执行结果
+
+**已完成**：
+- ✅ 任务 A：{简要结果}
+- ✅ 任务 B：{简要结果}
+
+**总结**：{整体结果摘要}
+\`\`\`
+
+## 重要约束
+
+1. **立即委派**：收到任务后，不要犹豫，立即分析并委派
+2. **清晰描述**：给子 agent 的任务描述要完整、清晰
+3. **传递上下文**：使用 \`data_transfer\` 传递必要的背景信息
+4. **不要插手**：相信子 agent 的能力，不要自己动手做具体工作
+5. **保持简洁**：你的输出应该简短，重点是协调和汇总
+
+---
+
+**记住**：你是协调者，不是执行者。快速分析需求，立即委派任务，高效汇总结果。`;
+async function jt() {
+  const s = new _e(), e = new ke(s);
+  return await e.addModel({
+    id: "glm-4.7",
+    model_name: "glm-4.7",
+    model_provider: process.env.MODEL_PROVIDER || "openai",
+    stream_usage: !0,
+    enable_thinking: !0,
+    temperature: 0.7,
+    max_tokens: 4096,
+    top_p: 1,
+    frequency_penalty: 0,
+    presence_penalty: 0
+  }), await e.addPrompt({
+    id: "prompts/default",
+    name: "default",
+    content: Ot
+  }), await e.addPrompt({
+    id: "prompts/manager",
+    name: "manager",
+    content: zt
+  }), await Rt(e), await It(e), await e.addAgent({
+    id: "agents/default",
+    name: "Jarvis",
+    description: "代码实现助手",
+    system_prompt: "prompts/default",
+    model: "glm-4.7",
+    tools: {
+      read_file: !0,
+      write_file: !0,
+      edit_file: !0,
+      glob_files: !0,
+      "search-files-rg": !0,
+      folder_operations: !0,
+      terminal: !0,
+      ask_user_questions: !0,
+      TodoWrite: !0
+    },
+    middleware: {
+      agents_md: !0,
+      skills: !0,
+      memories: !0,
+      subagents: !0
+    }
+  }), await e.addAgent({
+    id: "agents/manager",
+    name: "Manager",
+    description: "任务管理员",
+    system_prompt: "prompts/manager",
+    model: "glm-4.7",
+    tools: {
+      read_file: !0,
+      write_file: !0,
+      edit_file: !0,
+      glob_files: !0,
+      "search-files-rg": !0,
+      folder_operations: !0,
+      terminal: !0,
+      ask_user_questions: !0,
+      TodoWrite: !0
+    },
+    middleware: {
+      agents_md: !0,
+      skills: !0,
+      memories: !0,
+      subagents: !0
+    }
+  }), e;
+}
+const Y = async () => {
+  const s = new K();
+  return await s.initialize(), s.getConfig();
+};
+class N {
+  static instance;
+  client = null;
+  config = null;
+  lastRefresh = null;
+  serverStatuses = /* @__PURE__ */ new Map();
+  constructor() {
+  }
+  static getInstance() {
+    return this.instance || (this.instance = new N()), this.instance;
+  }
+  /**
+   * 初始化 MultiServerMCPClient
+   */
+  async initialize() {
+    const e = await Y();
+    if (!e.mcp_config || Object.keys(e.mcp_config).length === 0) {
+      this.client = null, this.serverStatuses.clear();
+      return;
+    }
+    this.client = new Re({
+      throwOnLoadError: !0,
+      prefixToolNameWithServerName: !1,
+      additionalToolNamePrefix: "",
+      useStandardContentBlocks: !0,
+      onConnectionError: "ignore",
+      /** @ts-ignore */
+      mcpServers: e.mcp_config
+    }), await this.refreshAll();
+  }
+  cacheTools = [];
+  /**
+   * 获取所有 MCP 工具（带缓存）
+   */
+  async getAllTools() {
+    if (this.client || await this.initialize(), !this.client)
+      return [];
+    const e = await this.client.getTools();
+    return this.cacheTools = e, e;
+  }
+  /**
+   * 刷新所有服务器
+   * 重新创建 MultiServerMCPClient 实例
+   */
+  async refreshAll() {
+    if (this.config) {
+      if (this.client)
+        try {
+          await this.client.close();
+        } catch (e) {
+          console.warn("Failed to close MCP client:", e);
+        }
+      await this.initialize(), this.lastRefresh = Date.now();
+    }
+  }
+  /**
+   * 清理连接
+   */
+  async cleanup() {
+    if (this.client) {
+      try {
+        await this.client.close();
+      } catch (e) {
+        console.warn("Failed to close MCP client during cleanup:", e);
+      }
+      this.client = null;
+    }
+    this.lastRefresh = null, this.serverStatuses.clear();
+  }
+  /**
+   * 获取 MCP 状态信息
+   */
+  async getStatus() {
+    const e = this.cacheTools, i = await Y(), n = i.mcp_config ? Object.keys(i.mcp_config) : [];
+    return {
+      isInitialized: this.client !== null,
+      toolCount: e.length,
+      lastRefresh: this.lastRefresh,
+      servers: n
+    };
+  }
+  /**
+   * 执行单个 MCP 工具
+   */
+  async executeTool(e, i) {
+    if (this.client || await this.initialize(), !this.client)
+      throw new Error("MCP client not initialized. No MCP configuration found.");
+    const n = await this.getAllTools(), o = n.find((a) => a.name === e);
+    if (!o) {
+      const a = n.map((r) => r.name).join(", ");
+      throw new Error(`Tool not found: ${e}. Available: ${a || "none"}`);
+    }
+    try {
+      return await o.invoke(i);
+    } catch (a) {
+      throw new Error(`Failed to execute MCP tool '${e}': ${a.message || String(a)}`);
+    }
+  }
+}
+const Nt = t.object({}), Ut = t.object({
+  commands: t.array(
+    t.object({
+      name: t.string().describe("MCP 工具名称"),
+      args: t.record(t.string(), t.any()).describe("工具参数，JSON 对象格式")
+    })
+  ).describe("要执行的 MCP 工具列表")
+});
+class Lt {
+  name = "CommandSystemMiddleware";
+  stateSchema = void 0;
+  contextSchema = void 0;
+  mcpManager;
+  loadMcpToolsTool;
+  executeMcpToolTool;
+  constructor() {
+    this.mcpManager = N.getInstance(), this.loadMcpToolsTool = p(
+      async () => {
+        const e = await this.mcpManager.getStatus(), i = await this.mcpManager.getAllTools();
+        return JSON.stringify(
+          {
+            tools: i.map((n) => ({
+              name: n.name,
+              description: n.description,
+              schema: n.schema
+            })),
+            status: e
+          },
+          null,
+          2
+        );
+      },
+      {
+        name: "load_mcp_tools",
+        description: `加载并查询所有可用的 MCP 工具列表。
+
+返回：
+- tools: MCP 工具列表，每个工具包含 name, description, schema
+- status: MCP 连接状态，包含 toolCount, servers 等
+
+使用场景：
+- 查询当前有哪些 MCP 工具可用
+- 获取工具的参数格式
+- 检查 MCP 连接状态
+
+重要：工具列表是动态的，建议在需要时调用此命令获取最新信息。`,
+        schema: Nt
+      }
+    ), this.executeMcpToolTool = p(
+      async ({ commands: e }) => {
+        const i = [];
+        for (const n of e) {
+          const { name: o, args: a } = n;
+          try {
+            const r = await this.mcpManager.executeTool(o, a);
+            i.push({ tool: o, result: r });
+          } catch (r) {
+            i.push({
+              tool: o,
+              result: null,
+              error: r.message || String(r)
+            });
+          }
+        }
+        return JSON.stringify(
+          {
+            results: i
+          },
+          null,
+          2
+        );
+      },
+      {
+        name: "execute_mcp_tool",
+        description: `执行一个或多个 MCP 工具。
+
+使用格式：
+- commands: MCP 工具数组，每个工具包含 name 和 args
+
+示例：
+- 执行单个工具: {commands: [{name: "filesystem.read_file", args: {path: "/path/to/file"}}]}
+- 执行多个工具: {commands: [{name: "tool1", args: {...}}, {name: "tool2", args: {...}}]}
+
+重要：
+- 所有工具独立执行，失败不影响其他工具
+- 返回结果按命令顺序排列
+- 适合批量执行 MCP 相关操作`,
+        schema: Ut
+      }
+    );
+  }
+  /**
+   * 获取 middleware 提供的 Command
+   */
+  get tools() {
+    return [this.loadMcpToolsTool, this.executeMcpToolTool];
+  }
+  /**
+   * 包装模型调用，注入系统提示词
+   */
+  async wrapModelCall(e, i) {
+    const n = `
+## MCP Tools
+
+使用 MCP 工具需要两步：
+
+1. **load_mcp_tools** - 查询可用的 MCP 工具
+   - 返回所有 MCP 工具的列表和参数格式
+   - 包含 MCP 连接状态
+
+2. **execute_mcp_tool** - 执行 MCP 工具
+   - 支持单个或多个工具批量执行
+   - 格式：{commands: [{name, args}, ...]}
+
+**重要**：
+- 标准工具（read_file, glob_files）直接调用，不需要通过 MCP 命令
+- MCP 工具需要先调用 load_mcp_tools 查询
+- 再调用 execute_mcp_tool 执行
+`;
+    let o;
+    e.systemPrompt ? o = e.systemPrompt + n : o = n;
+    const a = {
+      ...e,
+      systemPrompt: o
+    };
+    return await i(a);
+  }
+}
+const Dt = {
+  ask_user_questions: {
+    allowedDecisions: ["respond", "approve", "reject", "edit"]
+  }
+};
+async function Ft(s, e, i, n, o) {
+  const a = !!o?.parent_id, r = await e.getAgent(s);
+  if (!r)
+    throw new Error(`Agent not found: ${s}`);
+  const c = await e.validateAgent(s);
+  if (!c.valid)
+    throw new Error(`Agent validation failed: ${JSON.stringify(c.errors)}`);
+  const l = await Z(i.model_id, {
+    modelProvider: i.provider_id,
+    enableThinking: i.enable_thinking,
+    metadata: {
+      // message 通过这个 id 判断是否为子调用
+      parent_id: o?.parent_id
+    }
+  }), m = [], h = e.tools;
+  for (const [T, C] of Object.entries(r.tools)) {
+    const f = h.getImplementation(T);
+    if (!f) {
+      console.warn(`Tool ${T} not found in registry`);
+      continue;
+    }
+    if (!f.name || !C)
+      continue;
+    const te = $(
+      async (ie) => {
+        const S = await f.execute(ie);
+        return S && typeof S == "object" && "content" in S ? S.content : S;
+      },
+      {
+        name: f.name,
+        description: f.description,
+        schema: f.paramsSchema
+      }
+    );
+    m.push(te);
+  }
+  const u = [];
+  for (const [T, C] of Object.entries(r.middleware)) {
+    if (T === "subagents" && a) continue;
+    const f = e.middlewares.getImplementation(T);
+    if (!C)
+      break;
+    u.push(await f.execute(C.customParams || {}));
+  }
+  const y = new Lt();
+  u.push(y);
+  const A = {
+    ...Dt
+  };
+  process.env.YOLO_MODE !== "true" && Object.assign(A, {
+    terminal: { allowedDecisions: ["approve", "reject", "edit"] }
+  }), u.push(
+    Ie({
+      /** @ts-ignore */
+      interruptOn: A
+    })
+  ), process.env.MODEL_PROVIDER === "anthropic" && u.push(ve());
+  const v = await e.getPrompt(r.systemPromptId);
+  if (!v)
+    throw new Error(`Prompt not found: ${r.systemPromptId}`);
+  const ee = v.content + `
+
+${await $t()}`;
+  return B({
+    name: a ? `subagent_${o.parent_id}` : r.name,
+    model: l,
+    systemPrompt: ee,
+    tools: m,
+    /** @ts-ignore */
+    stateSchema: J,
+    middleware: u
+  });
+}
+async function Wt(s) {
+  return (await s.listAgents()).map((i) => i.id);
+}
+const Yt = {
+  smart_memory: async (s) => {
+    const e = await Z(s.model_id, {
+      modelProvider: s.provider_type,
+      enableThinking: s.enable_thinking ?? !0
+    }), i = await Qe(e, Ve(s.messages));
+    return {
+      switch_command: "",
+      messages: [new me({ id: pe }), new he(i)]
+    };
+  }
+};
+async function qt(s, e, i, n) {
+  const o = await Ft(s, e, i);
+  i.thread_id = ce(n);
+  const a = await o.invoke(i, {
+    recursionLimit: 500,
+    configurable: n.configurable,
+    context: n.context
+  });
+  return {
+    switch_command: "",
+    task_store: a.task_store,
+    messages: a.messages
+  };
+}
+function Gt() {
+  return new de(J).addNode("graph", async (s, e) => {
+    const { switch_command: i } = s;
+    if (i === "smart_memory") return Yt.smart_memory(s);
+    const n = await jt(), o = await Wt(n), a = i ? `agents/${i}` : "agents/default";
+    if (!o.includes(a))
+      throw new Error(
+        `Unknown agent: ${i || "default"}. Available: ${o.map((c) => c.split("/").pop()).join(", ")}`
+      );
+    return await qt(a, n, s, e);
+  }).addEdge(ue, "graph").compile();
+}
+const vi = Gt();
+export {
+  I as A,
+  Oe as C,
+  K as F,
+  N as M,
+  Ue as S,
+  H as T,
+  Le as a,
+  De as b,
+  $e as c,
+  Fe as d,
+  We as e,
+  Ye as f,
+  V as g,
+  qe as h,
+  Ge as i,
+  Be as j,
+  vi as k,
+  _i as l,
+  Ft as m,
+  z as n,
+  ki as o,
+  kt as p,
+  at as q,
+  yt as r,
+  ot as s,
+  St as t,
+  bi as u
+};