@ddlqhd/agent-sdk 0.1.0

package/dist/chunk-JF5AJQMU.cjs

@@ -0,0 +1,2788 @@
+#!/usr/bin/env node
+'use strict';
+
+var chunkCNSGZVRN_cjs = require('./chunk-CNSGZVRN.cjs');
+var promises = require('fs/promises');
+var path = require('path');
+var os = require('os');
+var zod = require('zod');
+var iconv = require('iconv-lite');
+var fg = require('fast-glob');
+var chardet = require('chardet');
+var child_process = require('child_process');
+var fs = require('fs');
+var ignore = require('ignore');
+var micromatch = require('micromatch');
+var dns = require('dns');
+var ipaddr = require('ipaddr.js');
+var readability = require('@mozilla/readability');
+var linkedom = require('linkedom');
+var TurndownService = require('turndown');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var iconv__default = /*#__PURE__*/_interopDefault(iconv);
+var fg__default = /*#__PURE__*/_interopDefault(fg);
+var ignore__default = /*#__PURE__*/_interopDefault(ignore);
+var micromatch__default = /*#__PURE__*/_interopDefault(micromatch);
+var dns__namespace = /*#__PURE__*/_interopNamespace(dns);
+var ipaddr__default = /*#__PURE__*/_interopDefault(ipaddr);
+var TurndownService__default = /*#__PURE__*/_interopDefault(TurndownService);
+
+var OUTPUT_CONFIG = {
+  /** 直接返回的最大字符数 (~12k tokens) */
+  maxDirectOutput: 5e4,
+  /** 保存到文件的最大大小 */
+  maxStorageSize: 1e7,
+  /** 摘要显示的行数 */
+  summaryHeadLines: 100,
+  summaryTailLines: 100,
+  /** 智能截断保留的行数 */
+  truncateHeadLines: 500,
+  truncateTailLines: 500,
+  /** 存储目录 */
+  storageDir: ".claude/tool-outputs/"
+};
+var FileStorageStrategy = class {
+  userBasePath;
+  constructor(userBasePath) {
+    this.userBasePath = userBasePath || os.homedir();
+  }
+  async handle(content, toolName, context) {
+    const basePath = context?.userBasePath || this.userBasePath;
+    const timestamp = Date.now();
+    const safeName = toolName.replace(/[^a-zA-Z0-9_-]/g, "_");
+    const filename = `${safeName}-${timestamp}.txt`;
+    const storageDir = path.join(basePath, OUTPUT_CONFIG.storageDir);
+    const filepath = path.join(storageDir, filename);
+    try {
+      await promises.mkdir(path.dirname(filepath), { recursive: true });
+      await promises.writeFile(filepath, content, "utf-8");
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      const lines2 = content.split("\n");
+      return {
+        content: `Output too large (${lines2.length} lines)
+
+Failed to save to file: ${errorMessage}
+
+Truncated output:
+${content.slice(0, OUTPUT_CONFIG.maxDirectOutput)}`,
+        metadata: {
+          truncated: true,
+          originalLength: content.length,
+          lineCount: lines2.length
+        }
+      };
+    }
+    const lines = content.split("\n");
+    const summary = this.generateSummary(content, lines);
+    const sizeKB = (content.length / 1024).toFixed(1);
+    return {
+      content: `Output too large (${sizeKB} KB, ${lines.length} lines)
+
+Summary:
+${summary}
+
+Full output saved to: ${filepath}
+Use 'Read' with offset/limit to view specific sections.`,
+      metadata: {
+        truncated: true,
+        originalLength: content.length,
+        storagePath: filepath,
+        lineCount: lines.length
+      }
+    };
+  }
+  generateSummary(content, lines) {
+    const { summaryHeadLines, summaryTailLines } = OUTPUT_CONFIG;
+    if (lines.length <= summaryHeadLines + summaryTailLines) {
+      return content;
+    }
+    const head = lines.slice(0, summaryHeadLines).join("\n");
+    const tail = lines.slice(-summaryTailLines).join("\n");
+    const omitted = lines.length - summaryHeadLines - summaryTailLines;
+    return `${head}
+
+... (${omitted} lines omitted) ...
+
+${tail}`;
+  }
+};
+var PaginationHintStrategy = class {
+  async handle(content, _toolName, context) {
+    const lines = content.split("\n");
+    const sizeKB = (content.length / 1024).toFixed(1);
+    const previewLines = OUTPUT_CONFIG.summaryHeadLines;
+    const filePath = this.extractFilePath(context?.args);
+    let hint = `Content is too large (${lines.length} lines, ${sizeKB} KB)
+
+`;
+    if (filePath) {
+      hint += `To read efficiently:
+`;
+      hint += `1. Use 'Read' with offset and limit:
+`;
+      hint += `   Read(file_path="${filePath}", offset=1, limit=500)
+
+`;
+      hint += `2. Use 'Grep' to search for patterns:
+`;
+      hint += `   Grep(pattern="keyword", path="${filePath}")
+
+`;
+    }
+    hint += `First ${previewLines} lines preview:
+`;
+    hint += lines.slice(0, previewLines).join("\n");
+    if (lines.length > previewLines) {
+      hint += `
+
+... (${lines.length - previewLines} more lines)`;
+    }
+    return {
+      content: hint,
+      metadata: {
+        truncated: true,
+        originalLength: content.length,
+        lineCount: lines.length
+      }
+    };
+  }
+  extractFilePath(args) {
+    if (typeof args === "object" && args !== null) {
+      const a = args;
+      if (typeof a.path === "string") return a.path;
+      if (typeof a.file_path === "string") return a.file_path;
+    }
+    return null;
+  }
+};
+var SmartTruncateStrategy = class {
+  async handle(content, _toolName, _context) {
+    const lines = content.split("\n");
+    const { truncateHeadLines, truncateTailLines, maxDirectOutput } = OUTPUT_CONFIG;
+    if (lines.length <= truncateHeadLines + truncateTailLines) {
+      const truncated = content.slice(0, maxDirectOutput) + `
+
+... [truncated, ${content.length} total chars]`;
+      return {
+        content: truncated,
+        metadata: {
+          truncated: true,
+          originalLength: content.length,
+          lineCount: lines.length
+        }
+      };
+    }
+    const head = lines.slice(0, truncateHeadLines);
+    const tail = lines.slice(-truncateTailLines);
+    const omitted = lines.length - truncateHeadLines - truncateTailLines;
+    const result = head.join("\n") + `
+
+... [${omitted} lines omitted] ...
+
+` + tail.join("\n");
+    return {
+      content: result,
+      metadata: {
+        truncated: true,
+        originalLength: content.length,
+        originalLineCount: lines.length,
+        displayedLineCount: truncateHeadLines + truncateTailLines
+      }
+    };
+  }
+};
+var OutputHandler = class {
+  strategies = /* @__PURE__ */ new Map();
+  defaultStrategy;
+  constructor(userBasePath) {
+    this.strategies.set("shell", new FileStorageStrategy(userBasePath));
+    this.strategies.set("mcp", new FileStorageStrategy(userBasePath));
+    this.strategies.set("web", new FileStorageStrategy(userBasePath));
+    this.strategies.set("filesystem", new PaginationHintStrategy());
+    this.strategies.set("search", new SmartTruncateStrategy());
+    this.defaultStrategy = new SmartTruncateStrategy();
+  }
+  /**
+   * 处理工具输出
+   * @param content 工具输出内容
+   * @param toolName 工具名称
+   * @param category 工具类别
+   * @param context 上下文信息
+   */
+  async handle(content, toolName, category, context) {
+    if (content.length <= OUTPUT_CONFIG.maxDirectOutput) {
+      return { content };
+    }
+    const strategy = this.strategies.get(category || "") || this.defaultStrategy;
+    return strategy.handle(content, toolName, context);
+  }
+  /**
+   * 注册自定义策略
+   */
+  registerStrategy(category, strategy) {
+    this.strategies.set(category, strategy);
+  }
+  /**
+   * 检查内容是否需要处理
+   */
+  needsHandling(content) {
+    return content.length > OUTPUT_CONFIG.maxDirectOutput;
+  }
+};
+function createOutputHandler(userBasePath) {
+  return new OutputHandler(userBasePath);
+}
+var ToolRegistry = class {
+  tools = /* @__PURE__ */ new Map();
+  categories = /* @__PURE__ */ new Map();
+  outputHandler;
+  hookManager = null;
+  executionPolicy;
+  constructor(config) {
+    const enableOutputHandler = config?.enableOutputHandler !== false;
+    this.outputHandler = enableOutputHandler ? createOutputHandler(config?.userBasePath) : null;
+    this.executionPolicy = config?.executionPolicy;
+  }
+  /**
+   * 工具名是否在 {@link ToolExecutionPolicy.disallowedTools} 中（无策略时为 false）。
+   */
+  isDisallowed(name) {
+    return this.executionPolicy?.disallowedTools?.includes(name) ?? false;
+  }
+  /**
+   * `allowedTools` 未设置时视为全部自动批准；已设置时仅列表内自动批准。
+   */
+  isAutoApproved(name) {
+    const allowed = this.executionPolicy?.allowedTools;
+    if (allowed === void 0) {
+      return true;
+    }
+    return allowed.includes(name);
+  }
+  async checkExecutionPolicy(name, args) {
+    const policy = this.executionPolicy;
+    if (!policy) {
+      return null;
+    }
+    if (this.isDisallowed(name)) {
+      return {
+        content: `Tool "${name}" is disallowed by configuration`,
+        isError: true
+      };
+    }
+    if (this.isAutoApproved(name)) {
+      return null;
+    }
+    const canUse = policy.canUseTool;
+    if (!canUse) {
+      return {
+        content: `Tool "${name}" requires approval: configure allowedTools or canUseTool`,
+        isError: true
+      };
+    }
+    const raw = args;
+    const input = raw !== null && raw !== void 0 && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
+    const ok = await canUse(name, input);
+    if (!ok) {
+      return {
+        content: `Tool "${name}" was denied by canUseTool`,
+        isError: true
+      };
+    }
+    return null;
+  }
+  setHookManager(manager) {
+    this.hookManager = manager;
+  }
+  getHookManager() {
+    return this.hookManager;
+  }
+  buildHookContext(event, name, toolInput, options, extra = {}) {
+    return {
+      eventType: event,
+      toolName: name,
+      toolInput,
+      timestamp: Date.now(),
+      projectDir: options?.projectDir,
+      toolCallId: options?.toolCallId,
+      ...extra
+    };
+  }
+  /**
+   * 注册工具
+   */
+  register(tool) {
+    if (this.isDisallowed(tool.name)) {
+      throw new Error(
+        `Cannot register tool "${tool.name}": it is listed in disallowedTools`
+      );
+    }
+    if (this.tools.has(tool.name)) {
+      throw new Error(`Tool "${tool.name}" is already registered`);
+    }
+    this.tools.set(tool.name, tool);
+  }
+  /**
+   * 注册多个工具
+   */
+  registerMany(tools) {
+    for (const tool of tools) {
+      this.register(tool);
+    }
+  }
+  /**
+   * 注销工具
+   */
+  unregister(name) {
+    return this.tools.delete(name);
+  }
+  /**
+   * 获取工具定义
+   */
+  get(name) {
+    return this.tools.get(name);
+  }
+  /**
+   * 获取所有工具定义
+   */
+  getAll() {
+    return Array.from(this.tools.values());
+  }
+  /**
+   * 获取工具名称列表
+   */
+  getNames() {
+    return Array.from(this.tools.keys());
+  }
+  /**
+   * 检查工具是否存在
+   */
+  has(name) {
+    return this.tools.has(name);
+  }
+  /**
+   * 获取工具数量
+   */
+  get size() {
+    return this.tools.size;
+  }
+  /**
+   * 执行工具
+   */
+  async execute(name, args, options) {
+    const hookMgr = this.hookManager;
+    const rawArgsObj = typeof args === "object" && args !== null ? args : {};
+    const policyBlock = await this.checkExecutionPolicy(name, args);
+    if (policyBlock) {
+      return policyBlock;
+    }
+    const tool = this.tools.get(name);
+    if (!tool) {
+      const ctx = this.buildHookContext("postToolUseFailure", name, rawArgsObj, options, {
+        errorMessage: `Tool "${name}" not found`,
+        failureKind: "tool_error"
+      });
+      await hookMgr?.executePostToolUseFailure(ctx);
+      return {
+        content: `Tool "${name}" not found`,
+        isError: true
+      };
+    }
+    let workingInput = rawArgsObj;
+    try {
+      workingInput = tool.parameters.parse(args);
+      if (hookMgr) {
+        const pre = await hookMgr.executePreToolUse(
+          this.buildHookContext("preToolUse", name, workingInput, options)
+        );
+        if (!pre.allowed) {
+          return {
+            content: pre.reason ?? "Blocked by hook",
+            isError: true
+          };
+        }
+        try {
+          workingInput = tool.parameters.parse(pre.updatedInput ?? workingInput);
+        } catch (err) {
+          if (err instanceof zod.z.ZodError) {
+            const msg = `Invalid arguments after hook merge for tool "${name}": ${err.errors.map((e) => e.message).join(", ")}`;
+            await hookMgr.executePostToolUseFailure(
+              this.buildHookContext("postToolUseFailure", name, workingInput, options, {
+                errorMessage: msg,
+                failureKind: "validation"
+              })
+            );
+            return { content: msg, isError: true };
+          }
+          throw err;
+        }
+      }
+      const handlerArgs = workingInput;
+      const executionContext = {
+        toolCallId: options?.toolCallId,
+        projectDir: options?.projectDir,
+        agentDepth: options?.agentDepth
+      };
+      const result = await tool.handler(handlerArgs, executionContext);
+      const toolResultRaw = result;
+      if (result.isError) {
+        await hookMgr?.executePostToolUseFailure(
+          this.buildHookContext("postToolUseFailure", name, workingInput, options, {
+            errorMessage: result.content,
+            failureKind: "tool_error"
+          })
+        );
+        return result;
+      }
+      let finalResult = result;
+      if (this.outputHandler && this.outputHandler.needsHandling(result.content)) {
+        finalResult = await this.outputHandler.handle(
+          result.content,
+          name,
+          tool.category,
+          { args: handlerArgs }
+        );
+      }
+      await hookMgr?.executePostToolUse(
+        this.buildHookContext("postToolUse", name, workingInput, options, {
+          toolResultRaw,
+          toolResultFinal: finalResult
+        })
+      );
+      return finalResult;
+    } catch (error) {
+      if (error instanceof zod.z.ZodError) {
+        const msg2 = `Invalid arguments for tool "${name}": ${error.errors.map((e) => e.message).join(", ")}`;
+        await hookMgr?.executePostToolUseFailure(
+          this.buildHookContext("postToolUseFailure", name, rawArgsObj, options, {
+            errorMessage: msg2,
+            failureKind: "validation"
+          })
+        );
+        return {
+          content: msg2,
+          isError: true
+        };
+      }
+      const msg = `Error executing tool "${name}": ${error instanceof Error ? error.message : String(error)}`;
+      await hookMgr?.executePostToolUseFailure(
+        this.buildHookContext("postToolUseFailure", name, workingInput, options, {
+          errorMessage: msg,
+          failureKind: "handler_throw"
+        })
+      );
+      return {
+        content: msg,
+        isError: true
+      };
+    }
+  }
+  /**
+   * 获取工具 Schema (用于模型调用)
+   */
+  toSchema() {
+    return this.getAll().map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      parameters: chunkCNSGZVRN_cjs.zodToJsonSchema(tool.parameters)
+    }));
+  }
+  /**
+   * 清空所有工具
+   */
+  clear() {
+    this.tools.clear();
+    this.categories.clear();
+  }
+  /**
+   * 按类别注册工具
+   */
+  registerWithCategory(category, tool) {
+    this.register(tool);
+    if (!this.categories.has(category)) {
+      this.categories.set(category, /* @__PURE__ */ new Set());
+    }
+    this.categories.get(category).add(tool.name);
+  }
+  /**
+   * 获取类别下的工具
+   */
+  getByCategory(category) {
+    const toolNames = this.categories.get(category);
+    if (!toolNames) return [];
+    return Array.from(toolNames).map((name) => this.tools.get(name)).filter((tool) => tool !== void 0);
+  }
+  /**
+   * 获取所有类别
+   */
+  getCategories() {
+    return Array.from(this.categories.keys());
+  }
+  /**
+   * 过滤工具
+   */
+  filter(predicate) {
+    return this.getAll().filter(predicate);
+  }
+  /**
+   * 搜索工具
+   */
+  search(query) {
+    const lowerQuery = query.toLowerCase();
+    return this.filter(
+      (tool) => tool.name.toLowerCase().includes(lowerQuery) || tool.description.toLowerCase().includes(lowerQuery)
+    );
+  }
+  /**
+   * 导出工具配置
+   */
+  export() {
+    return this.getAll().map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      parameters: chunkCNSGZVRN_cjs.zodToJsonSchema(tool.parameters)
+    }));
+  }
+};
+function createTool(config) {
+  return {
+    name: config.name,
+    description: config.description,
+    parameters: config.parameters,
+    handler: config.handler,
+    isDangerous: config.isDangerous,
+    category: config.category
+  };
+}
+var globalRegistry = null;
+function getGlobalRegistry() {
+  if (!globalRegistry) {
+    globalRegistry = new ToolRegistry();
+  }
+  return globalRegistry;
+}
+var SAMPLE_BYTES = 64 * 1024;
+var CJK_TIE_BREAK_ORDER = [
+  "GB18030",
+  "Big5",
+  "EUC-KR",
+  "EUC-JP",
+  "Shift_JIS"
+];
+function cjkTieBreakRank(name) {
+  const i = CJK_TIE_BREAK_ORDER.indexOf(name);
+  return i === -1 ? 100 : i;
+}
+function isCjkChardetName(name) {
+  switch (name) {
+    case "GB18030":
+    case "GBK":
+    case "Big5":
+    case "EUC-JP":
+    case "EUC-KR":
+    case "Shift_JIS":
+    case "ISO-2022-CN":
+    case "ISO-2022-JP":
+    case "ISO-2022-KR":
+      return true;
+    default:
+      return false;
+  }
+}
+function plausibleGbkDoubleBytePairCount(buf) {
+  let n = 0;
+  for (let i = 0; i < buf.length - 1; i++) {
+    const a = buf[i];
+    const b = buf[i + 1];
+    if (a >= 129 && a <= 254 && b >= 64 && b <= 254 && b !== 127) {
+      n++;
+      i++;
+    }
+  }
+  return n;
+}
+function preferGb18030OverChardetTop(buf, matches) {
+  if (matches.length === 0) return false;
+  if (plausibleGbkDoubleBytePairCount(buf) < 2) return false;
+  const top = matches[0];
+  if (!top || isCjkChardetName(top.name)) return false;
+  const maxConf = Math.max(...matches.map((m) => m.confidence));
+  const gb = matches.find((m) => {
+    const n = m.name;
+    return n === "GB18030" || n === "GBK";
+  });
+  if (!gb) return false;
+  const margin = 8;
+  if (maxConf - gb.confidence > margin) return false;
+  return true;
+}
+function isValidUtf8(buf) {
+  if (buf.length === 0) return true;
+  try {
+    new TextDecoder("utf-8", { fatal: true }).decode(buf);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function langAffinityScore(name, lang) {
+  if (!lang) return 0;
+  const zhEnc = name === "GB18030" || name === "Big5";
+  const jaEnc = name === "Shift_JIS" || name === "EUC-JP";
+  if (zhEnc && lang === "zh") return 2;
+  if (jaEnc && lang === "ja") return 2;
+  if (name === "EUC-KR" && lang === "ko") return 2;
+  if (zhEnc && (lang === "ja" || lang === "ko")) return -1;
+  if (jaEnc && (lang === "zh" || lang === "ko")) return -1;
+  if (name === "EUC-KR" && (lang === "zh" || lang === "ja")) return -1;
+  return 0;
+}
+function encodingFromBom(buf) {
+  if (buf.length >= 3 && buf[0] === 239 && buf[1] === 187 && buf[2] === 191) {
+    return "utf8";
+  }
+  if (buf.length >= 4 && buf[0] === 0 && buf[1] === 0 && buf[2] === 254 && buf[3] === 255) {
+    return "utf-32be";
+  }
+  if (buf.length >= 4 && buf[0] === 255 && buf[1] === 254 && buf[2] === 0 && buf[3] === 0) {
+    return "utf-32le";
+  }
+  if (buf.length >= 2 && buf[0] === 255 && buf[1] === 254) {
+    return "utf16le";
+  }
+  if (buf.length >= 2 && buf[0] === 254 && buf[1] === 255) {
+    return "utf-16be";
+  }
+  return null;
+}
+function chardetNameToReadEncoding(name) {
+  if (name === "mbcs") return null;
+  const table = {
+    ASCII: "utf8",
+    "UTF-8": "utf8",
+    "UTF-16LE": "utf16le",
+    "UTF-16BE": "utf-16be",
+    "UTF-32LE": "utf-32le",
+    "UTF-32BE": "utf-32be",
+    "UTF-32": "utf-32le",
+    GB18030: "gb18030",
+    GBK: "gbk",
+    Big5: "big5",
+    "EUC-JP": "euc-jp",
+    "EUC-KR": "euc-kr",
+    Shift_JIS: "shift_jis",
+    "ISO-8859-1": "latin1",
+    "ISO-8859-2": "latin2",
+    "ISO-8859-5": "iso88595",
+    "ISO-8859-6": "iso88596",
+    "ISO-8859-7": "iso88597",
+    "ISO-8859-8": "iso88598",
+    "ISO-8859-9": "latin5",
+    "ISO-2022-CN": "iso-2022-cn",
+    "ISO-2022-JP": "iso-2022-jp",
+    "ISO-2022-KR": "iso-2022-kr",
+    ISO_2022: "iso-2022-jp",
+    "KOI8-R": "koi8-r",
+    "windows-1250": "cp1250",
+    "windows-1251": "cp1251",
+    "windows-1252": "cp1252",
+    "windows-1253": "cp1253",
+    "windows-1254": "cp1254",
+    "windows-1255": "cp1255",
+    "windows-1256": "cp1256"
+  };
+  const mapped = table[name];
+  if (mapped) {
+    if (mapped === "utf8" || mapped === "utf16le" || mapped === "latin1") {
+      return mapped;
+    }
+    if (iconv__default.default.encodingExists(mapped)) {
+      return mapped;
+    }
+  }
+  const lower = name.toLowerCase().replace(/_/g, "-");
+  if (lower !== "mbcs" && iconv__default.default.encodingExists(lower)) {
+    return lower;
+  }
+  const compact = name.replace(/-/g, "").toLowerCase();
+  if (iconv__default.default.encodingExists(compact)) {
+    return compact;
+  }
+  return null;
+}
+async function readEncodingSample(filePath, fileSize) {
+  const fs = await import('fs/promises');
+  const fh = await fs.open(filePath, "r");
+  try {
+    const size = fileSize !== void 0 ? fileSize : (await fh.stat()).size;
+    const len = Math.min(SAMPLE_BYTES, size);
+    if (len === 0) {
+      return Buffer.alloc(0);
+    }
+    const buf = Buffer.allocUnsafe(len);
+    const { bytesRead } = await fh.read(buf, 0, len, 0);
+    return bytesRead < len ? buf.subarray(0, bytesRead) : buf;
+  } finally {
+    await fh.close();
+  }
+}
+function detectEncodingFromSample(buf) {
+  if (buf.length === 0) {
+    return "utf8";
+  }
+  const bom = encodingFromBom(buf);
+  if (bom) {
+    return bom;
+  }
+  if (isValidUtf8(buf)) {
+    return "utf8";
+  }
+  const matches = chardet.analyse(buf).filter(
+    (m) => m.confidence > 0 && m.name !== "ASCII" && m.name !== "mbcs"
+  );
+  matches.sort((a, b) => {
+    if (b.confidence !== a.confidence) {
+      return b.confidence - a.confidence;
+    }
+    const langDiff = langAffinityScore(b.name, b.lang) - langAffinityScore(a.name, a.lang);
+    if (langDiff !== 0) {
+      return langDiff;
+    }
+    return cjkTieBreakRank(a.name) - cjkTieBreakRank(b.name);
+  });
+  if (preferGb18030OverChardetTop(buf, matches)) {
+    const gb = matches.find((m) => {
+      const n = m.name;
+      return n === "GB18030" || n === "GBK";
+    });
+    if (gb) {
+      const enc = chardetNameToReadEncoding(gb.name);
+      if (enc && (isNativeReadEncoding(enc) || iconv__default.default.encodingExists(enc))) {
+        return enc;
+      }
+    }
+  }
+  for (const m of matches) {
+    const enc = chardetNameToReadEncoding(m.name);
+    if (enc && (isNativeReadEncoding(enc) || iconv__default.default.encodingExists(enc))) {
+      return enc;
+    }
+  }
+  return "utf8";
+}
+function isNativeReadEncoding(enc) {
+  return enc === "utf8" || enc === "utf16le" || enc === "latin1";
+}
+function normalizeFilesystemEncoding(encoding) {
+  const raw = encoding?.trim() ?? "";
+  if (raw === "") return "utf8";
+  let e = raw.toLowerCase();
+  if (e === "utf-8") e = "utf8";
+  if (e === "cp936") e = "gbk";
+  return e;
+}
+function isFilesystemEncodingSupported(normalized) {
+  return isNativeReadEncoding(normalized) || iconv__default.default.encodingExists(normalized);
+}
+async function readFileAsUnicodeString(filePath, normalized) {
+  const fs = await import('fs/promises');
+  if (isNativeReadEncoding(normalized)) {
+    return fs.readFile(filePath, {
+      encoding: normalized
+    });
+  }
+  const buf = await fs.readFile(filePath);
+  return iconv__default.default.decode(buf, normalized);
+}
+async function writeFileFromUnicodeString(filePath, text, normalized) {
+  const fs = await import('fs/promises');
+  if (isNativeReadEncoding(normalized)) {
+    await fs.writeFile(filePath, text, {
+      encoding: normalized
+    });
+  } else {
+    await fs.writeFile(filePath, iconv__default.default.encode(text, normalized));
+  }
+}
+
+// src/tools/builtin/filesystem.ts
+var DEFAULT_READ_LIMIT = 2e3;
+var MAX_LINE_LENGTH = 2e3;
+var MAX_LINE_SUFFIX = `... (line truncated to ${MAX_LINE_LENGTH} chars)`;
+var MAX_BYTES = 50 * 1024;
+var MAX_BYTES_LABEL = `${MAX_BYTES / 1024} KB`;
+var readFileTool = createTool({
+  name: "Read",
+  category: "filesystem",
+  description: `Reads a file from the local filesystem. You can access any file directly by using this tool.
+
+Usage:
+- The file_path parameter must be an absolute path, not a relative path
+- By default, it reads up to 2000 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
+- Results are returned using cat -n style, with line numbers starting at 1
+- Lines longer than 2000 characters are truncated
+- Use the offset and limit parameters to read specific line ranges of large files
+- If you read a file that exists but has empty contents you will receive an error message
+- Text encoding is detected automatically from the file (BOM, UTF-8 validity, charset analysis). You rarely need to set encoding; use it only to override detection (e.g. gbk, gb18030, cp936 maps to gbk)`,
+  parameters: zod.z.object({
+    file_path: zod.z.string().describe("The absolute path to the file to read"),
+    encoding: zod.z.string().optional().describe(
+      'Optional. Omit or use "auto" for automatic detection (default). Set only to force a specific encoding (utf8, gbk, gb18030, latin1, etc.; cp936 is treated as gbk).'
+    ),
+    offset: zod.z.number().int().min(1).optional().describe("The line number to start reading from (1-indexed). Only provide if the file is too large to read at once"),
+    limit: zod.z.number().int().min(1).optional().describe("The number of lines to read. Only provide if the file is too large to read at once")
+  }),
+  handler: async ({ file_path, encoding, offset, limit }) => {
+    try {
+      const fs = await import('fs/promises');
+      const { createReadStream } = await import('fs');
+      const { createInterface } = await import('readline');
+      const stat = await fs.stat(file_path);
+      if (!stat.isFile()) {
+        return {
+          content: `Error: ${file_path} is not a file`,
+          isError: true
+        };
+      }
+      const encTrim = encoding?.trim() ?? "";
+      const useAuto = encTrim === "" || encTrim.toLowerCase() === "auto";
+      let normalized;
+      let autoDetected = false;
+      if (useAuto) {
+        const sample = await readEncodingSample(file_path, stat.size);
+        normalized = detectEncodingFromSample(sample);
+        autoDetected = true;
+      } else {
+        normalized = normalizeFilesystemEncoding(encTrim);
+        if (!isFilesystemEncodingSupported(normalized)) {
+          return {
+            content: `Error: unsupported encoding: ${encTrim}`,
+            isError: true
+          };
+        }
+      }
+      const startLine = offset ? offset - 1 : 0;
+      const maxLines = limit ?? DEFAULT_READ_LIMIT;
+      const toDestroy = [];
+      let lineInput;
+      if (isNativeReadEncoding(normalized)) {
+        const stream = createReadStream(file_path, {
+          encoding: normalized
+        });
+        toDestroy.push(stream);
+        lineInput = stream;
+      } else {
+        const raw = createReadStream(file_path);
+        const decoded = raw.pipe(iconv__default.default.decodeStream(normalized));
+        toDestroy.push(raw, decoded);
+        lineInput = decoded;
+      }
+      const rl = createInterface({
+        input: lineInput,
+        crlfDelay: Infinity
+      });
+      const selectedLines = [];
+      let totalLines = 0;
+      let totalBytes = 0;
+      let truncatedByBytes = false;
+      let hasMoreLines = false;
+      try {
+        for await (const line of rl) {
+          totalLines++;
+          if (totalLines <= startLine) continue;
+          if (selectedLines.length >= maxLines) {
+            hasMoreLines = true;
+            continue;
+          }
+          const processedLine = line.length > MAX_LINE_LENGTH ? line.substring(0, MAX_LINE_LENGTH) + MAX_LINE_SUFFIX : line;
+          const lineBytes = Buffer.byteLength(processedLine, "utf-8") + 1;
+          if (totalBytes + lineBytes > MAX_BYTES) {
+            truncatedByBytes = true;
+            hasMoreLines = true;
+            break;
+          }
+          selectedLines.push(processedLine);
+          totalBytes += lineBytes;
+        }
+      } finally {
+        rl.close();
+        for (const s of toDestroy) {
+          s.destroy();
+        }
+      }
+      if (totalLines < startLine && !(totalLines === 0 && startLine === 0)) {
+        return {
+          content: `Error: Offset ${offset} is out of range for this file (${totalLines} lines)`,
+          isError: true
+        };
+      }
+      const numbered = selectedLines.map((line, i) => `${String(startLine + i + 1).padStart(5)}	${line}`).join("\n");
+      const lastReadLine = startLine + selectedLines.length;
+      const nextOffset = lastReadLine + 1;
+      let suffix;
+      if (truncatedByBytes) {
+        suffix = `
+
+(Output capped at ${MAX_BYTES_LABEL}. Showing lines ${offset ?? 1}-${lastReadLine}. Use offset=${nextOffset} to continue.)`;
+      } else if (hasMoreLines) {
+        suffix = `
+
+(Showing lines ${offset ?? 1}-${lastReadLine} of ${totalLines}. Use offset=${nextOffset} to continue.)`;
+      } else {
+        suffix = `
+
+(End of file - total ${totalLines} lines)`;
+      }
+      if (autoDetected) {
+        suffix += `
+
+(Auto-detected encoding: ${normalized}.)`;
+      }
+      return { content: numbered + suffix };
+    } catch (error) {
+      return {
+        content: `Error reading file: ${error instanceof Error ? error.message : String(error)}`,
+        isError: true
+      };
+    }
+  }
+});
+var writeFileTool = createTool({
+  name: "Write",
+  category: "filesystem",
+  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
+- Prefer the Edit tool for modifying existing files \u2014 it only sends the diff. Only use this tool to create new files or for complete rewrites
+- NEVER create documentation files (*.md) or README files unless explicitly requested by the User
+- Only use emojis if the user explicitly requests it. Avoid adding emojis to files unless asked
+- For non-UTF-8 files (e.g. GBK on Windows), set encoding to match what you use with Read; default is utf8`,
+  parameters: zod.z.object({
+    file_path: zod.z.string().describe("The absolute path to the file to write (must be absolute, not relative)"),
+    content: zod.z.string().describe("The content to write to the file"),
+    encoding: zod.z.string().optional().describe(
+      "File character encoding. Default utf8. Use gbk or gb18030 for legacy Chinese ANSI text; cp936 is treated as gbk."
+    )
+  }),
+  handler: async ({ file_path, content, encoding }) => {
+    try {
+      const fs = await import('fs/promises');
+      const pathModule = await import('path');
+      const normalized = normalizeFilesystemEncoding(encoding);
+      if (!isFilesystemEncodingSupported(normalized)) {
+        return {
+          content: `Error: unsupported encoding: ${encoding?.trim() || "utf8"}`,
+          isError: true
+        };
+      }
+      const dir = pathModule.dirname(file_path);
+      await fs.mkdir(dir, { recursive: true });
+      await writeFileFromUnicodeString(file_path, content, normalized);
+      return { content: `Successfully wrote to ${file_path}` };
+    } catch (error) {
+      return {
+        content: `Error writing file: ${error instanceof Error ? error.message : String(error)}`,
+        isError: true
+      };
+    }
+  }
+});
+var editTool = createTool({
+  name: "Edit",
+  category: "filesystem",
+  description: `Performs exact string replacements in files.
+
+Usage:
+- You must use the Read tool at least once in the conversation before editing. This tool will error if you attempt an edit without reading the file
+- 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: line number + tab. Everything after that is the actual file content to match. Never include any part of the line number prefix in the old_string or new_string
+- ALWAYS prefer editing existing files in the codebase. NEVER write new files unless explicitly required
+- Only use emojis if the user explicitly requests it. Avoid adding emojis to files unless asked
+- The edit will FAIL if old_string is not unique in the file. Either provide a larger string with more surrounding context to make it unique or use replace_all to change every instance of old_string
+- Use replace_all for replacing and renaming strings across the file. This parameter is useful if you want to rename a variable for instance
+- For non-UTF-8 files, set encoding to the same value you used with Read (default is utf8)`,
+  parameters: zod.z.object({
+    file_path: zod.z.string().describe("The absolute path to the file to modify"),
+    old_string: zod.z.string().describe("The text to replace"),
+    new_string: zod.z.string().describe("The text to replace it with (must be different from old_string)"),
+    replace_all: zod.z.boolean().default(false).describe("Replace all occurrences of old_string (default false)"),
+    encoding: zod.z.string().optional().describe(
+      "File character encoding. Default utf8. Use gbk or gb18030 for legacy Chinese ANSI text; cp936 is treated as gbk."
+    )
+  }),
+  handler: async ({ file_path, old_string, new_string, replace_all, encoding }) => {
+    try {
+      if (old_string === new_string) {
+        return {
+          content: "old_string and new_string must be different",
+          isError: true
+        };
+      }
+      const normalized = normalizeFilesystemEncoding(encoding);
+      if (!isFilesystemEncodingSupported(normalized)) {
+        return {
+          content: `Error: unsupported encoding: ${encoding?.trim() || "utf8"}`,
+          isError: true
+        };
+      }
+      const content = await readFileAsUnicodeString(file_path, normalized);
+      if (!content.includes(old_string)) {
+        return {
+          content: `old_string not found in ${file_path}`,
+          isError: true
+        };
+      }
+      if (!replace_all) {
+        const occurrences2 = content.split(old_string).length - 1;
+        if (occurrences2 > 1) {
+          return {
+            content: `Found ${occurrences2} matches for old_string. Provide more context to make it unique, or set replace_all to true.`,
+            isError: true
+          };
+        }
+      }
+      const newContent = replace_all ? content.replaceAll(old_string, new_string) : content.replace(old_string, new_string);
+      await writeFileFromUnicodeString(file_path, newContent, normalized);
+      const occurrences = replace_all ? content.split(old_string).length - 1 : 1;
+      return {
+        content: `Successfully edited ${file_path} (${occurrences} replacement${occurrences > 1 ? "s" : ""})`
+      };
+    } catch (error) {
+      return {
+        content: `Error editing file: ${error instanceof Error ? error.message : String(error)}`,
+        isError: true
+      };
+    }
+  }
+});
+var globTool = createTool({
+  name: "Glob",
+  category: "filesystem",
+  description: `- Fast file pattern matching tool that works with any codebase size
+- Supports glob patterns like "**/*.js" or "src/**/*.ts" (use forward slashes in patterns; works on Windows)
+- Returns matching file paths as absolute paths, sorted by modification time (newest first)
+- Dotfiles and dot-directories are excluded unless the pattern targets them (starts with "." or contains "/.")
+- 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`,
+  parameters: zod.z.object({
+    pattern: zod.z.string().describe("The glob pattern to match files against"),
+    path: zod.z.string().optional().describe("The directory to search in. If omitted, uses the agent working directory when available, otherwise the current process directory. IMPORTANT: Omit this field to use the default directory. Must be a valid directory path if provided.")
+  }),
+  handler: async ({ pattern, path: searchPath }, context) => {
+    try {
+      const fs = await import('fs/promises');
+      const pathModule = await import('path');
+      const rootDir = pathModule.resolve(searchPath || context?.projectDir || ".");
+      const normalizedPattern = pattern.replace(/\\/g, "/");
+      const includeDotfiles = normalizedPattern.startsWith(".") || normalizedPattern.includes("/.");
+      const entries = await fg__default.default(normalizedPattern, {
+        cwd: rootDir,
+        onlyFiles: true,
+        absolute: true,
+        dot: includeDotfiles,
+        suppressErrors: true
+      });
+      const matches = [];
+      for (const filePath of entries) {
+        const nativePath = pathModule.normalize(filePath);
+        try {
+          const stat = await fs.stat(nativePath);
+          if (stat.isFile()) {
+            matches.push({ path: nativePath, mtime: stat.mtimeMs });
+          }
+        } catch {
+        }
+      }
+      matches.sort((a, b) => b.mtime - a.mtime);
+      return {
+        content: matches.length > 0 ? matches.map((m) => m.path).join("\n") : "No files found"
+      };
+    } catch (error) {
+      return {
+        content: `Error searching files: ${error instanceof Error ? error.message : String(error)}`,
+        isError: true
+      };
+    }
+  }
+});
+function getFileSystemTools() {
+  return [
+    readFileTool,
+    writeFileTool,
+    editTool,
+    globTool
+  ];
+}
+var cachedShellPath = null;
+function findInPath(executable) {
+  try {
+    const result = child_process.execSync(`where ${executable}`, {
+      encoding: "utf-8",
+      timeout: 1e3
+    }).trim().split("\n")[0];
+    return result && fs.existsSync(result) ? result : null;
+  } catch {
+    return null;
+  }
+}
+function getShellPath() {
+  if (cachedShellPath !== null) {
+    return cachedShellPath;
+  }
+  if (process.platform === "win32") {
+    const bashPath = findInPath("bash");
+    if (bashPath) {
+      cachedShellPath = bashPath;
+      return bashPath;
+    }
+    const gitBashPaths = [
+      "C:\\Program Files\\Git\\bin\\bash.exe",
+      "C:\\Program Files (x86)\\Git\\bin\\bash.exe"
+    ];
+    for (const path of gitBashPaths) {
+      if (fs.existsSync(path)) {
+        cachedShellPath = path;
+        return path;
+      }
+    }
+    const pwshPath = findInPath("pwsh");
+    if (pwshPath) {
+      cachedShellPath = "pwsh";
+      return "pwsh";
+    }
+    cachedShellPath = "powershell.exe";
+    return "powershell.exe";
+  }
+  cachedShellPath = process.env.SHELL || "/bin/bash";
+  return cachedShellPath;
+}
+function getEnvironmentInfo(cwd) {
+  let isGitRepo = false;
+  try {
+    child_process.execSync("git rev-parse --is-inside-work-tree", {
+      cwd,
+      stdio: "pipe",
+      timeout: 2e3
+    });
+    isGitRepo = true;
+  } catch {
+  }
+  const shellPath = getShellPath();
+  const shell = shellPath.split(/[/\\]/).pop()?.replace(/\.exe$/i, "");
+  return {
+    cwd,
+    platform: process.platform,
+    date: (/* @__PURE__ */ new Date()).toLocaleDateString("en-US", {
+      weekday: "short",
+      year: "numeric",
+      month: "short",
+      day: "numeric"
+    }),
+    isGitRepo,
+    shell
+  };
+}
+function formatEnvironmentSection(info) {
+  const shellLine = info.shell ? `
+  Shell: ${info.shell}` : "";
+  return `
+## Environment
+
+<env>
+  Working directory: ${info.cwd}
+  Platform: ${info.platform}
+  Today's date: ${info.date}
+  Is git repo: ${info.isGitRepo ? "yes" : "no"}${shellLine}
+</env>`;
+}
+
+// src/tools/builtin/shell.ts
+var MAX_OUTPUT_SIZE = 10 * 1024 * 1024;
+var KILL_DELAY = 5e3;
+var bashTool = createTool({
+  name: "Bash",
+  category: "shell",
+  description: `Executes a given bash command and returns its output.
+
+The working directory persists between commands, but shell state does not. The shell environment is initialized from the user's profile (bash or zsh).
+
+IMPORTANT: Avoid using this tool to run find, grep, cat, head, tail, sed, awk, or echo commands, unless explicitly instructed or after you have verified that a dedicated tool cannot accomplish your task. Instead, use the appropriate dedicated tool as this will provide a much better experience for the user:
+
+ - File search: Use Glob (NOT find or ls)
+ - Content search: Use Grep (NOT grep or rg)
+ - Read files: Use Read (NOT cat/head/tail)
+ - Edit files: Use Edit (NOT sed/awk)
+ - Write files: Use Write (NOT echo >file)
+ - Communication: Output text directly (NOT echo/printf)
+
+# Instructions
+- If your command will create new directories or files, first use this tool to run ls to verify the parent directory exists and is the correct location
+- Always quote file paths that contain spaces with double quotes in your command (e.g., cd "path with spaces/file.txt")
+- If cwd is omitted, the command runs in the agent working directory when available
+- You may specify an optional timeout in milliseconds (up to 600000ms / 10 minutes). By default, your command will timeout after 120000ms (2 minutes).`,
+  parameters: zod.z.object({
+    command: zod.z.string().describe("The command to execute"),
+    description: zod.z.string().optional().describe("Clear, concise description of what this command does in active voice. Keep it brief (5-10 words)."),
+    cwd: zod.z.string().optional().describe("Working directory for the command"),
+    timeout: zod.z.number().int().min(1).max(6e5).optional().describe("Optional timeout in milliseconds (max 600000)")
+  }),
+  isDangerous: true,
+  handler: async ({ command, description: desc, cwd, timeout }, context) => {
+    return new Promise((resolve) => {
+      const shellPath = getShellPath();
+      let stdout = "";
+      let stderr = "";
+      let outputTruncated = false;
+      const effectiveTimeout = timeout ?? 12e4;
+      const child = child_process.spawn(command, [], {
+        shell: shellPath,
+        cwd: cwd ?? context?.projectDir,
+        env: { ...process.env }
+      });
+      const timer = setTimeout(() => {
+        child.kill("SIGTERM");
+        const killTimer = setTimeout(() => {
+          try {
+            child.kill("SIGKILL");
+          } catch {
+          }
+        }, KILL_DELAY);
+        child.on("exit", () => clearTimeout(killTimer));
+        resolve({
+          content: `${desc ? `[${desc}]
+` : ""}Command timed out after ${effectiveTimeout}ms`,
+          isError: true
+        });
+      }, effectiveTimeout);
+      child.stdout.on("data", (data) => {
+        if (!outputTruncated && stdout.length < MAX_OUTPUT_SIZE) {
+          stdout += data.toString();
+          if (stdout.length >= MAX_OUTPUT_SIZE) {
+            stdout += "\n[Output truncated due to size limit]";
+            outputTruncated = true;
+          }
+        }
+      });
+      child.stderr.on("data", (data) => {
+        if (!outputTruncated && stderr.length < MAX_OUTPUT_SIZE) {
+          stderr += data.toString();
+          if (stderr.length >= MAX_OUTPUT_SIZE) {
+            stderr += "\n[Output truncated due to size limit]";
+            outputTruncated = true;
+          }
+        }
+      });
+      child.on("error", (error) => {
+        clearTimeout(timer);
+        resolve({
+          content: `${desc ? `[${desc}]
+` : ""}Command failed: ${error.message}`,
+          isError: true
+        });
+      });
+      child.on("close", (code) => {
+        clearTimeout(timer);
+        const output = [];
+        if (stdout) output.push(stdout);
+        if (stderr) output.push(`STDERR:
+${stderr}`);
+        const prefix = desc ? `[${desc}]
+` : "";
+        if (code === 0) {
+          resolve({
+            content: prefix + (output.join("\n") || "Command executed successfully (no output)")
+          });
+        } else {
+          resolve({
+            content: `${prefix}Command failed (exit code ${code})
+${output.join("\n")}`,
+            isError: true
+          });
+        }
+      });
+    });
+  }
+});
+function getShellTools() {
+  return [bashTool];
+}
+var DEFAULT_GREP_HEAD_LIMIT = 250;
+var MAX_LINE_LENGTH2 = 2e3;
+var FG_IGNORE = [
+  "**/node_modules/**",
+  "**/.git/**",
+  "**/dist/**",
+  "**/build/**",
+  "**/__pycache__/**"
+];
+function truncateMatchLineForDisplay(line, regex) {
+  const max = MAX_LINE_LENGTH2;
+  if (line.length <= max) {
+    return line;
+  }
+  const safeFlags = regex.flags.replace(/g/g, "").replace(/y/g, "");
+  const re = new RegExp(regex.source, safeFlags);
+  const m = re.exec(line);
+  if (!m || m.index === void 0) {
+    return line.slice(0, max) + "...";
+  }
+  const matchStart = m.index;
+  const matchEnd = m.index + m[0].length;
+  const matchLen = matchEnd - matchStart;
+  if (matchLen >= max) {
+    return m[0].slice(0, max) + "...";
+  }
+  let start = matchStart - Math.floor((max - matchLen) / 2);
+  let end = start + max;
+  if (start < 0) {
+    start = 0;
+    end = max;
+  }
+  if (end > line.length) {
+    end = line.length;
+    start = end - max;
+  }
+  if (start < 0) {
+    start = 0;
+  }
+  if (matchStart < start) {
+    start = Math.max(0, matchEnd - max);
+    end = Math.min(line.length, start + max);
+  }
+  if (matchEnd > end) {
+    end = line.length;
+    start = Math.max(0, end - max);
+  }
+  const slice = line.slice(start, end);
+  return (start > 0 ? "..." : "") + slice + (end < line.length ? "..." : "");
+}
+var grepTool = createTool({
+  name: "Grep",
+  category: "search",
+  description: `Search file contents with ECMAScript regular expressions (line-by-line, pure Node.js; does not spawn ripgrep/grep).
+
+Usage:
+- ALWAYS use Grep for search tasks. NEVER invoke grep or rg as a Bash command.
+- Uses JavaScript RegExp semantics (not PCRE/ripgrep); very complex patterns may differ from rg.
+- Filter files with glob (e.g. "*.js", "**/*.{ts,tsx}"); brace expansion is supported.
+- Root directory search respects a .gitignore file at the search root when present.
+- Long match lines are truncated with a window centered on the match (max ${MAX_LINE_LENGTH2} chars).
+- Use the Agent tool for open-ended searches requiring multiple rounds.
+- Output: matching lines with file paths and line numbers`,
+  parameters: zod.z.object({
+    pattern: zod.z.string().describe("The regular expression pattern to search for in file contents"),
+    path: zod.z.string().optional().describe("File or directory to search in. Defaults to the agent working directory when available, otherwise current process directory."),
+    glob: zod.z.string().optional().describe('Glob pattern to filter files (e.g. "*.js", "**/*.{ts,tsx}")'),
+    case_insensitive: zod.z.boolean().default(false).describe("Case insensitive search"),
+    context: zod.z.number().int().min(0).default(0).describe("Number of lines to show before and after each match"),
+    head_limit: zod.z.number().int().min(1).default(DEFAULT_GREP_HEAD_LIMIT).describe(`Limit to the first N matching lines. Defaults to ${DEFAULT_GREP_HEAD_LIMIT}.`)
+  }),
+  handler: async ({ pattern, path: searchPath, glob: globParam, case_insensitive, context, head_limit }, toolContext) => {
+    try {
+      const fs = await import('fs/promises');
+      const pathModule = await import('path');
+      const projectBase = pathModule.resolve(toolContext?.projectDir ?? process.cwd());
+      const rootPathRaw = searchPath || toolContext?.projectDir || ".";
+      const resolvedRoot = pathModule.resolve(rootPathRaw);
+      let stat;
+      try {
+        stat = await fs.stat(resolvedRoot);
+      } catch {
+        return {
+          content: `Path does not exist: ${rootPathRaw}`,
+          isError: true
+        };
+      }
+      let regex;
+      try {
+        regex = new RegExp(pattern, case_insensitive ? "i" : "");
+      } catch (e) {
+        return {
+          content: `Invalid regex pattern: ${e instanceof Error ? e.message : String(e)}`,
+          isError: true
+        };
+      }
+      let filesToSearch = [];
+      if (stat.isFile()) {
+        if (globParam) {
+          const rel = pathModule.relative(projectBase, resolvedRoot).split(pathModule.sep).join("/");
+          if (!micromatch__default.default.isMatch(rel, globParam, { posix: true })) {
+            return {
+              content: "No matches found (path does not match glob filter)"
+            };
+          }
+        }
+        filesToSearch = [resolvedRoot];
+      } else {
+        const absolutePaths = await fg__default.default.glob(globParam ?? "**/*", {
+          cwd: resolvedRoot,
+          onlyFiles: true,
+          dot: false,
+          ignore: [...FG_IGNORE],
+          absolute: true
+        });
+        let ig = null;
+        try {
+          const giContent = await fs.readFile(pathModule.join(resolvedRoot, ".gitignore"), "utf-8");
+          ig = ignore__default.default().add(giContent);
+        } catch {
+        }
+        filesToSearch = absolutePaths.filter((abs) => {
+          const rel = pathModule.relative(resolvedRoot, abs).split(pathModule.sep).join("/");
+          if (!rel || rel.startsWith("..")) {
+            return true;
+          }
+          return !(ig && ig.ignores(rel));
+        });
+      }
+      const results = [];
+      let totalMatches = 0;
+      for (const filePath of filesToSearch) {
+        let content;
+        try {
+          content = await fs.readFile(filePath, "utf-8");
+        } catch {
+          continue;
+        }
+        const lines = content.split("\n");
+        const relDisplay = pathModule.relative(resolvedRoot, filePath).split(pathModule.sep).join("/");
+        const displayPath = relDisplay || pathModule.basename(filePath);
+        for (let i = 0; i < lines.length; i++) {
+          if (regex.test(lines[i])) {
+            totalMatches++;
+            const matchLineOut = truncateMatchLineForDisplay(lines[i], regex);
+            if (context > 0) {
+              const start = Math.max(0, i - context);
+              const end = Math.min(lines.length - 1, i + context);
+              if (start < i) {
+                for (let j = start; j < i; j++) {
+                  results.push(`${displayPath}:${j + 1}-${lines[j]}`);
+                }
+              }
+              results.push(`${displayPath}:${i + 1}:${matchLineOut}`);
+              if (end > i) {
+                for (let j = i + 1; j <= end; j++) {
+                  results.push(`${displayPath}:${j + 1}-${lines[j]}`);
+                }
+              }
+              results.push("--");
+            } else {
+              results.push(`${displayPath}:${i + 1}:${matchLineOut}`);
+            }
+            if (totalMatches >= head_limit) break;
+          }
+        }
+        if (totalMatches >= head_limit) break;
+      }
+      if (results.length === 0) {
+        return { content: "No matches found" };
+      }
+      if (results[results.length - 1] === "--") {
+        results.pop();
+      }
+      const output = results.join("\n");
+      const suffix = totalMatches >= head_limit ? `
+
+(Showing first ${head_limit} matches)` : `
+
+(${totalMatches} matches)`;
+      return { content: output + suffix };
+    } catch (error) {
+      return {
+        content: `Error searching: ${error instanceof Error ? error.message : String(error)}`,
+        isError: true
+      };
+    }
+  }
+});
+function getGrepTools() {
+  return [grepTool];
+}
+
+// src/tools/builtin/tavily-search.ts
+var TAVILY_SEARCH_URL = "https://api.tavily.com/search";
+var TAVILY_SEARCH_TIMEOUT_MS = 3e4;
+var TAVILY_MAX_INCLUDE_DOMAINS = 300;
+var TAVILY_MAX_EXCLUDE_DOMAINS = 150;
+var SEARCH_DEPTHS = /* @__PURE__ */ new Set(["basic", "advanced", "fast", "ultra-fast"]);
+function parseSearchDepthFromEnv() {
+  const raw = process.env.TAVILY_SEARCH_DEPTH?.trim().toLowerCase();
+  if (raw && SEARCH_DEPTHS.has(raw)) {
+    return raw;
+  }
+  return "basic";
+}
+function parseMaxResultsFromEnv() {
+  const raw = process.env.TAVILY_MAX_RESULTS?.trim();
+  if (!raw) {
+    return 5;
+  }
+  const n = Number.parseInt(raw, 10);
+  if (!Number.isFinite(n) || n < 1 || n > 20) {
+    return 5;
+  }
+  return n;
+}
+function truncateDomains(domains, max) {
+  if (!domains?.length) {
+    return [];
+  }
+  return domains.slice(0, max).map((d) => d.trim()).filter(Boolean);
+}
+function escapeMarkdownLinkLabel(text) {
+  return text.replace(/\\/g, "\\\\").replace(/\[/g, "\\[").replace(/\]/g, "\\]");
+}
+function formatTavilyResultsMarkdown(data) {
+  const lines = [];
+  if (data.answer) {
+    lines.push("**Summary**", "", data.answer, "");
+  }
+  const results = data.results ?? [];
+  if (results.length === 0) {
+    lines.push("No search results returned.");
+    return lines.join("\n").trim();
+  }
+  lines.push("**Results**", "");
+  for (const r of results) {
+    const title = (r.title ?? "Untitled").trim();
+    const url = (r.url ?? "").trim();
+    const snippet = (r.content ?? "").trim();
+    if (url) {
+      lines.push(`- [${escapeMarkdownLinkLabel(title)}](${url})`);
+    } else {
+      lines.push(`- ${escapeMarkdownLinkLabel(title)}`);
+    }
+    if (snippet) {
+      lines.push(`  ${snippet.replace(/\n+/g, " ")}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n").trim();
+}
+function extractErrorMessage(status, body) {
+  if (body && typeof body === "object" && "detail" in body) {
+    const detail = body.detail;
+    if (detail && typeof detail === "object" && detail !== null && "error" in detail) {
+      const err = detail.error;
+      if (typeof err === "string") {
+        return err;
+      }
+    }
+    if (typeof detail === "string") {
+      return detail;
+    }
+    if (Array.isArray(detail) && detail.length > 0) {
+      const first = detail[0];
+      if (first && typeof first === "object" && first !== null && "msg" in first) {
+        const msg = first.msg;
+        if (typeof msg === "string") {
+          return msg;
+        }
+      }
+    }
+  }
+  if (status === 401) {
+    return "Unauthorized: missing or invalid API key.";
+  }
+  if (status === 429) {
+    return "Rate limit exceeded. Try again later.";
+  }
+  return `Tavily search failed (HTTP ${status}).`;
+}
+async function tavilyWebSearch(input) {
+  const {
+    query,
+    apiKey,
+    allowed_domains,
+    blocked_domains,
+    searchDepth = parseSearchDepthFromEnv(),
+    maxResults = parseMaxResultsFromEnv()
+  } = input;
+  const include_domains = truncateDomains(allowed_domains, TAVILY_MAX_INCLUDE_DOMAINS);
+  const exclude_domains = truncateDomains(blocked_domains, TAVILY_MAX_EXCLUDE_DOMAINS);
+  const body = {
+    api_key: apiKey,
+    query,
+    search_depth: searchDepth,
+    max_results: maxResults,
+    include_domains,
+    exclude_domains
+  };
+  try {
+    const res = await fetch(TAVILY_SEARCH_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(TAVILY_SEARCH_TIMEOUT_MS)
+    });
+    const text = await res.text();
+    let json;
+    try {
+      json = text ? JSON.parse(text) : {};
+    } catch {
+      return {
+        content: `Tavily search failed: invalid JSON response (HTTP ${res.status}).`,
+        isError: true
+      };
+    }
+    if (!res.ok) {
+      const msg = extractErrorMessage(res.status, json);
+      return {
+        content: `Tavily search error: ${msg}`,
+        isError: true
+      };
+    }
+    const data = json;
+    const markdown = formatTavilyResultsMarkdown(data);
+    return { content: markdown };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      content: `Tavily search failed: ${message}`,
+      isError: true
+    };
+  }
+}
+var WEB_FETCH_DEFAULT_TIMEOUT_MS = 3e4;
+var WEB_FETCH_MAX_RESPONSE_BYTES = 2 * 1024 * 1024;
+var WEB_FETCH_MAX_OUTPUT_CHARS = 512e3;
+var WEB_FETCH_MAX_REDIRECTS = 5;
+var USER_AGENT = "Agent-SDK-WebFetch/0.1 (+https://github.com/)";
+function isBlockedAddress(addr) {
+  if (addr.kind() === "ipv4") {
+    return addr.range() !== "unicast";
+  }
+  const v6 = addr;
+  if (v6.isIPv4MappedAddress()) {
+    const v4 = v6.toIPv4Address();
+    return v4.range() !== "unicast";
+  }
+  return v6.range() !== "unicast";
+}
+function isDangerousIp(ip) {
+  try {
+    if (!ipaddr__default.default.isValid(ip)) {
+      return true;
+    }
+    const addr = ipaddr__default.default.parse(ip);
+    return isBlockedAddress(addr);
+  } catch {
+    return true;
+  }
+}
+function isBlockedHostname(hostname) {
+  const h = hostname.toLowerCase();
+  if (h === "localhost" || h === "metadata") {
+    return true;
+  }
+  if (h.endsWith(".localhost")) {
+    return true;
+  }
+  if (h === "metadata.google.internal") {
+    return true;
+  }
+  if (h.endsWith(".internal")) {
+    return true;
+  }
+  if (h.endsWith(".local")) {
+    return true;
+  }
+  return false;
+}
+function assertHttpUrl(url) {
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new Error(`Only http and https URLs are allowed, got: ${url.protocol}`);
+  }
+}
+async function assertResolvableHostSafe(hostname, lookup = dns__namespace.promises.lookup) {
+  const results = await lookup(hostname, { all: true, verbatim: true });
+  if (!results.length) {
+    throw new Error("DNS lookup returned no addresses");
+  }
+  for (const { address } of results) {
+    if (isDangerousIp(address)) {
+      throw new Error(`Refused to connect: address "${address}" is not a public endpoint`);
+    }
+  }
+}
+async function assertUrlSafeForFetch(url, lookup = dns__namespace.promises.lookup) {
+  assertHttpUrl(url);
+  const host = url.hostname;
+  if (!host) {
+    throw new Error("URL has no hostname");
+  }
+  if (isBlockedHostname(host)) {
+    throw new Error(`Refused to connect: hostname "${host}" is blocked`);
+  }
+  if (ipaddr__default.default.isValid(host)) {
+    if (isDangerousIp(host)) {
+      throw new Error(`Refused to connect: address "${host}" is not a public endpoint`);
+    }
+    return;
+  }
+  await assertResolvableHostSafe(host, lookup);
+}
+async function readResponseBodyWithCap(response, maxBytes) {
+  const cl = response.headers.get("content-length");
+  if (cl !== null && cl !== "") {
+    const n = Number.parseInt(cl, 10);
+    if (Number.isFinite(n) && n > maxBytes) {
+      throw new Error(`Response too large (Content-Length: ${n} bytes, max ${maxBytes})`);
+    }
+  }
+  if (!response.body) {
+    const buf = new Uint8Array(await response.arrayBuffer());
+    return decodeWithCap(buf, maxBytes);
+  }
+  const reader = response.body.getReader();
+  const chunks = [];
+  let total = 0;
+  let truncated = false;
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      if (!value || value.length === 0) {
+        continue;
+      }
+      if (total + value.length <= maxBytes) {
+        chunks.push(value);
+        total += value.length;
+      } else {
+        const rest = maxBytes - total;
+        if (rest > 0) {
+          chunks.push(value.slice(0, rest));
+          total += rest;
+        }
+        truncated = true;
+        await reader.cancel();
+        break;
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const merged = mergeChunks(chunks, total);
+  const dec = decodeWithCap(merged, maxBytes);
+  return { text: dec.text, truncated: dec.truncated || truncated };
+}
+function mergeChunks(chunks, total) {
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const c of chunks) {
+    out.set(c, offset);
+    offset += c.length;
+  }
+  return out;
+}
+function decodeWithCap(buf, maxBytes) {
+  const truncated = buf.length >= maxBytes;
+  const decoder = new TextDecoder("utf-8", { fatal: false });
+  return { text: decoder.decode(buf), truncated };
+}
+function primaryMimeType(contentType) {
+  if (!contentType) {
+    return "";
+  }
+  return contentType.split(";")[0]?.trim().toLowerCase() ?? "";
+}
+function htmlToMarkdown(html) {
+  const { document } = linkedom.parseHTML(html);
+  const reader = new readability.Readability(document);
+  const article = reader.parse();
+  let htmlContent = article?.content?.trim() ?? "";
+  if (!htmlContent && document.body) {
+    htmlContent = document.body.innerHTML ?? "";
+  }
+  if (!htmlContent) {
+    return "";
+  }
+  const turndown = new TurndownService__default.default({
+    headingStyle: "atx",
+    codeBlockStyle: "fenced"
+  });
+  return turndown.turndown(htmlContent).trim();
+}
+function truncateOutput(text, maxChars) {
+  if (text.length <= maxChars) {
+    return text;
+  }
+  return `${text.slice(0, maxChars)}
+
+[Output truncated to ${maxChars} characters]`;
+}
+function formatJsonText(raw) {
+  try {
+    const v = JSON.parse(raw);
+    return JSON.stringify(v, null, 2);
+  } catch {
+    return raw;
+  }
+}
+async function fetchUrlToReadableContent(urlString, options = {}) {
+  const timeoutMs = options.timeoutMs ?? WEB_FETCH_DEFAULT_TIMEOUT_MS;
+  const maxResponseBytes = options.maxResponseBytes ?? WEB_FETCH_MAX_RESPONSE_BYTES;
+  const maxOutputChars = options.maxOutputChars ?? WEB_FETCH_MAX_OUTPUT_CHARS;
+  const maxRedirects = options.maxRedirects ?? WEB_FETCH_MAX_REDIRECTS;
+  const lookup = options.dnsLookup ?? dns__namespace.promises.lookup;
+  let currentUrl;
+  try {
+    currentUrl = new URL(urlString);
+  } catch {
+    return { content: "Invalid URL", isError: true };
+  }
+  try {
+    let redirectCount = 0;
+    for (; ; ) {
+      await assertUrlSafeForFetch(currentUrl, lookup);
+      const response = await fetch(currentUrl, {
+        method: "GET",
+        redirect: "manual",
+        signal: AbortSignal.timeout(timeoutMs),
+        headers: {
+          Accept: "text/html,application/json,text/plain;q=0.9,*/*;q=0.8",
+          "User-Agent": USER_AGENT
+        }
+      });
+      const status = response.status;
+      if (status >= 300 && status < 400) {
+        const loc = response.headers.get("location");
+        if (!loc || redirectCount >= maxRedirects) {
+          return {
+            content: loc ? `Too many redirects or missing Location (HTTP ${status})` : `Redirect without Location (HTTP ${status})`,
+            isError: true
+          };
+        }
+        redirectCount++;
+        currentUrl = new URL(loc, currentUrl);
+        continue;
+      }
+      if (!response.ok) {
+        return {
+          content: `Failed to fetch: ${status} ${response.statusText}`,
+          isError: true
+        };
+      }
+      const mime = primaryMimeType(response.headers.get("content-type"));
+      const { text: rawText, truncated: bodyTruncated } = await readResponseBodyWithCap(
+        response,
+        maxResponseBytes
+      );
+      let content;
+      if (mime.includes("html") || mime === "" || mime === "application/xhtml+xml") {
+        content = htmlToMarkdown(rawText);
+      } else if (mime.includes("json") || mime.endsWith("+json")) {
+        content = formatJsonText(rawText);
+      } else {
+        content = rawText;
+      }
+      if (bodyTruncated) {
+        content = `${content}
+
+[Response body truncated at ${maxResponseBytes} bytes]`;
+      }
+      content = truncateOutput(content, maxOutputChars);
+      return { content, isError: false };
+    }
+  } catch (error) {
+    return {
+      content: `Error fetching webpage: ${formatNetworkError(error)}`,
+      isError: true
+    };
+  }
+}
+function formatNetworkError(error) {
+  if (!(error instanceof Error)) {
+    return String(error);
+  }
+  const parts = [error.message];
+  let cursor = error.cause;
+  let depth = 0;
+  while (cursor instanceof Error && depth < 4) {
+    parts.push(cursor.message);
+    cursor = cursor.cause;
+    depth++;
+  }
+  if (typeof cursor === "object" && cursor !== null && "code" in cursor) {
+    const code = cursor.code;
+    if (code && !parts.join(" ").includes(code)) {
+      parts.push(`code=${code}`);
+    }
+  }
+  return parts.join(" \u2014 ");
+}
+
+// src/tools/builtin/web.ts
+var webFetchTool = createTool({
+  name: "WebFetch",
+  category: "web",
+  description: `Fetches public http(s) URLs and returns readable markdown (HTML), formatted JSON, or plain text.
+
+Limits and behavior:
+- Only http:// and https:// are allowed; private IPs, loopback, link-local, and common metadata/local hostnames are blocked (SSRF protection).
+- Requests time out, responses are size-capped, and very long markdown may be truncated before return.
+- If the result exceeds the direct context limit, the full text is saved under your user tool-outputs directory; the tool response will include the file path\u2014use **Read** with offset and limit parameters to page through it (same pattern as large shell output).
+- Authenticated or private pages usually cannot be fetched; prefer specialized MCP tools when available.
+- Use https URLs directly when possible (no automatic http\u2192https upgrade).
+- For GitHub URLs, prefer the gh CLI via Bash when appropriate (e.g., gh pr view, gh api).`,
+  parameters: zod.z.object({
+    url: zod.z.string().describe("The URL to fetch content from")
+  }),
+  handler: async ({ url }) => {
+    const result = await fetchUrlToReadableContent(url);
+    return result.isError ? { content: result.content, isError: true } : { content: result.content };
+  }
+});
+var webSearchTool = createTool({
+  name: "WebSearch",
+  category: "web",
+  description: `- Allows searching the web and use the results to inform responses
+- Provides up-to-date information for current events and recent data
+- Returns search result information with links as markdown hyperlinks
+- Use this tool for accessing information beyond the knowledge cutoff
+- When \`TAVILY_API_KEY\` is set, uses the Tavily Search API; otherwise returns a configuration message`,
+  parameters: zod.z.object({
+    query: zod.z.string().min(2).describe("The search query to use"),
+    allowed_domains: zod.z.array(zod.z.string()).optional().describe("Only include search results from these domains"),
+    blocked_domains: zod.z.array(zod.z.string()).optional().describe("Never include search results from these domains")
+  }),
+  handler: async ({ query, allowed_domains, blocked_domains }) => {
+    const apiKey = process.env.TAVILY_API_KEY?.trim();
+    if (!apiKey) {
+      return {
+        content: `Web search is not configured. Set the TAVILY_API_KEY environment variable to enable Tavily Search, or register a custom WebSearch tool with another provider. Query was: "${query}"`,
+        isError: true
+      };
+    }
+    return tavilyWebSearch({
+      query,
+      apiKey,
+      allowed_domains,
+      blocked_domains
+    });
+  }
+});
+function getWebTools() {
+  return [webFetchTool, webSearchTool];
+}
+var tasks = /* @__PURE__ */ new Map();
+var nextId = 1;
+var taskCreateTool = createTool({
+  name: "TaskCreate",
+  category: "planning",
+  description: `Use this tool to create a structured task list for your current coding session. This helps you track progress, organize complex tasks, and demonstrate thoroughness to the user.
+
+## When to Use This Tool
+
+- Complex multi-step tasks - When a task requires 3 or more distinct steps or actions
+- Non-trivial and complex tasks - Tasks that require careful planning or multiple operations
+- User explicitly requests todo list - When the user directly asks you to use the task list
+- User provides multiple tasks - When users provide a list of things to be done
+
+## When NOT to Use
+
+- There is only a single, straightforward task
+- The task is trivial and tracking it provides no organizational benefit
+- The task can be completed in less than 3 trivial steps
+
+All tasks are created with status pending.`,
+  parameters: zod.z.object({
+    subject: zod.z.string().describe("A brief title for the task"),
+    description: zod.z.string().describe("What needs to be done"),
+    activeForm: zod.z.string().optional().describe('Present continuous form shown in spinner when in_progress (e.g., "Running tests")')
+  }),
+  handler: async ({ subject, description, activeForm }) => {
+    const id = String(nextId++);
+    const task = {
+      id,
+      subject,
+      description,
+      status: "pending",
+      ...activeForm && { activeForm }
+    };
+    tasks.set(id, task);
+    return {
+      content: `Task created [${id}]: ${subject}`,
+      metadata: { task }
+    };
+  }
+});
+var taskUpdateTool = createTool({
+  name: "TaskUpdate",
+  category: "planning",
+  description: `Use this tool to update a task in the task list.
+
+## When to Use This Tool
+
+**Mark tasks as completed:**
+- When you have completed the work described in a task
+- IMPORTANT: Always mark your assigned tasks as completed when you finish them
+
+**Delete tasks:**
+- When a task is no longer relevant or was created in error
+
+## Status Workflow
+
+Status progresses: pending \u2192 in_progress \u2192 completed`,
+  parameters: zod.z.object({
+    taskId: zod.z.string().describe("The ID of the task to update"),
+    status: zod.z.enum(["pending", "in_progress", "completed", "deleted"]).optional().describe("New status for the task"),
+    subject: zod.z.string().optional().describe("New subject for the task"),
+    description: zod.z.string().optional().describe("New description for the task"),
+    activeForm: zod.z.string().optional().describe("Present continuous form shown in spinner when in_progress")
+  }),
+  handler: async ({ taskId, status, subject, description, activeForm }) => {
+    const task = tasks.get(taskId);
+    if (!task) {
+      return {
+        content: `Task ${taskId} not found`,
+        isError: true
+      };
+    }
+    if (status === "deleted") {
+      tasks.delete(taskId);
+      return { content: `Task ${taskId} deleted` };
+    }
+    if (status) task.status = status;
+    if (subject) task.subject = subject;
+    if (description) task.description = description;
+    if (activeForm) task.activeForm = activeForm;
+    const icon = task.status === "completed" ? "x" : task.status === "in_progress" ? ">" : " ";
+    return {
+      content: `Task [${taskId}] updated: [${icon}] ${task.subject}`,
+      metadata: { task }
+    };
+  }
+});
+var taskListTool = createTool({
+  name: "TaskList",
+  category: "planning",
+  description: `Use this tool to list all tasks in the task list.
+
+## Output
+
+Returns a summary of each task:
+- id: Task identifier (use with TaskUpdate)
+- subject: Brief description of the task
+- status: pending, in_progress, or completed`,
+  parameters: zod.z.object({}),
+  handler: async () => {
+    if (tasks.size === 0) {
+      return { content: "No tasks in the list." };
+    }
+    const lines = [];
+    for (const [, task] of tasks) {
+      const icon = task.status === "completed" ? "x" : task.status === "in_progress" ? ">" : " ";
+      lines.push(`[${icon}] [${task.id}] ${task.subject}`);
+    }
+    const pending = [...tasks.values()].filter((t) => t.status === "pending").length;
+    const inProgress = [...tasks.values()].filter((t) => t.status === "in_progress").length;
+    const completed = [...tasks.values()].filter((t) => t.status === "completed").length;
+    return {
+      content: `Tasks (${completed} completed, ${inProgress} in progress, ${pending} pending):
+
+${lines.join("\n")}`
+    };
+  }
+});
+function getTaskTools() {
+  return [taskCreateTool, taskUpdateTool, taskListTool];
+}
+var questionsSchema = zod.z.object({
+  questions: zod.z.array(
+    zod.z.object({
+      question: zod.z.string().describe(
+        "The complete question to ask the user. Should be clear, specific, and end with a question mark."
+      ),
+      header: zod.z.string().describe("Very short label displayed as a chip/tag (max 30 chars)."),
+      options: zod.z.array(
+        zod.z.object({
+          label: zod.z.string().describe("The display text for this option. Should be concise (1-5 words)."),
+          description: zod.z.string().describe("Explanation of what this option means or what will happen if chosen.")
+        })
+      ).min(2).max(4).describe("The available choices for this question. Must have 2-4 options."),
+      multiSelect: zod.z.boolean().default(false).describe("Set to true to allow the user to select multiple options.")
+    })
+  ).min(1).max(4).describe("Questions to ask the user (1-4 questions)")
+});
+function formatAskUserQuestionPrompt(questions) {
+  const lines = [];
+  for (const q of questions) {
+    lines.push(`[${q.header}] ${q.question}
+`);
+    q.options.forEach((opt, i) => {
+      lines.push(`  ${i + 1}. ${opt.label} \u2014 ${opt.description}`);
+    });
+    if (q.multiSelect) {
+      lines.push("\n(Select one or more options)");
+    } else {
+      lines.push("\n(Select one option)");
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function formatAnswerSummary(questions, answers) {
+  const lines = ["", "--- User responses ---"];
+  for (const a of answers) {
+    const q = questions[a.questionIndex];
+    if (a.otherText !== void 0) {
+      lines.push(
+        `[${q.header}] Other: ${a.otherText.trim() === "" ? "(empty)" : a.otherText}`
+      );
+    } else if (a.selectedLabels.length > 0) {
+      lines.push(`[${q.header}] ${a.selectedLabels.join(", ")}`);
+    } else {
+      lines.push(`[${q.header}] (no selection)`);
+    }
+  }
+  return lines.join("\n");
+}
+function createAskUserQuestionTool(options) {
+  const resolve = options?.resolve;
+  return createTool({
+    name: "AskUserQuestion",
+    category: "interaction",
+    description: `Use this tool when you need to ask the user questions during execution. This allows you to:
+1. Gather user preferences or requirements
+2. Clarify ambiguous instructions
+3. Get decisions on implementation choices as you work
+4. Offer choices to the user about what direction to take.
+
+The host application must provide a resolver that collects answers; without it, only the question text is returned.
+
+Usage notes:
+- Users will always be able to select "Other" to provide custom text input
+- Use multiSelect: true to allow multiple answers to be selected for a question
+- If you recommend a specific option, make that the first option in the list and add "(Recommended)" at the end of the label`,
+    parameters: questionsSchema,
+    handler: async ({ questions }) => {
+      const promptText = formatAskUserQuestionPrompt(questions);
+      if (!resolve) {
+        return {
+          content: promptText,
+          metadata: { questions }
+        };
+      }
+      let answers;
+      try {
+        answers = await resolve(questions);
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return {
+          content: `AskUserQuestion failed: ${msg}`,
+          isError: true,
+          metadata: { questions }
+        };
+      }
+      const summary = formatAnswerSummary(questions, answers);
+      return {
+        content: promptText + summary,
+        metadata: { questions, answers }
+      };
+    }
+  });
+}
+var questionTool = createAskUserQuestionTool();
+function getInteractionTools(options) {
+  return [createAskUserQuestionTool(options)];
+}
+function createSkillTool(skillRegistry) {
+  return createTool({
+    name: "Skill",
+    category: "skills",
+    description: `Execute a skill within the main conversation.
+
+When users ask you to perform tasks, check if any of the available skills match. Skills provide specialized capabilities and domain knowledge.
+
+How to invoke:
+- Use this tool with the skill name and optional arguments
+- Available skills are listed in system-reminder messages in the conversation
+- When a skill matches the user's request, invoke the relevant Skill tool BEFORE generating any other response about the task
+- Do not invoke a skill that is already running`,
+    parameters: zod.z.object({
+      skill: zod.z.string().describe('The skill name. E.g., "commit", "review-pr", or "pdf"'),
+      args: zod.z.string().optional().describe("Optional arguments for the skill")
+    }),
+    handler: async ({ skill: skillName }) => {
+      try {
+        if (!skillRegistry.has(skillName)) {
+          const available = skillRegistry.getMetadataList();
+          const availableList = available.length > 0 ? available.map((s) => `- ${s.name}: ${s.description}`).join("\n") : "No skills available.";
+          return {
+            content: `Skill "${skillName}" not found.
+
+Available skills:
+${availableList}`,
+            isError: true
+          };
+        }
+        const fullContent = await skillRegistry.loadFullContent(skillName);
+        const skill = skillRegistry.get(skillName);
+        const sections = [];
+        sections.push(`# Skill: ${skill?.metadata.name || skillName}`);
+        sections.push(`Description: ${skill?.metadata.description || ""}`);
+        sections.push(`Base Path: ${skill?.path || ""}`);
+        sections.push("");
+        sections.push("---");
+        sections.push("");
+        sections.push(fullContent);
+        return {
+          content: sections.join("\n")
+        };
+      } catch (error) {
+        return {
+          content: `Error activating skill "${skillName}": ${error instanceof Error ? error.message : String(error)}`,
+          isError: true
+        };
+      }
+    }
+  });
+}
+function getSkillTools(skillRegistry) {
+  return [createSkillTool(skillRegistry)];
+}
+var subagentRequestSchema = zod.z.object({
+  prompt: zod.z.string().min(1).describe("Task prompt for the subagent. Include all required context."),
+  description: zod.z.string().optional().describe("Short 3-5 words task label for logs and metadata."),
+  subagent_type: zod.z.enum(["general-purpose", "explore"]).default("general-purpose").describe("Subagent profile/type to use."),
+  allowed_tools: zod.z.array(zod.z.string().min(1)).optional().describe("Optional allowlist of tool names for the subagent."),
+  max_iterations: zod.z.number().int().min(1).optional().describe("Maximum reasoning iterations for the subagent."),
+  timeout_ms: zod.z.number().int().min(1e3).optional().describe("Timeout for this subagent run in milliseconds."),
+  system_prompt: zod.z.string().optional().describe("Optional system prompt appended for the subagent run.")
+});
+function createAgentTool(options) {
+  return createTool({
+    name: "Agent",
+    category: "planning",
+    description: `Launch a new subagent to handle complex, multi-step tasks autonomously.
+
+The Agent tool delegates work to a dedicated subagent that runs in isolated context and returns a final result back to the parent agent.
+
+Use this tool when:
+- The task requires broader exploration or multi-step research
+- You want to keep the parent context focused and concise
+- You need a specific subagent profile (for example, explore vs general-purpose)
+
+When NOT to use this tool:
+- Reading a known file path (use Read directly)
+- Simple symbol or text lookup (use Grep/Glob directly)
+- Small scoped changes in 1-3 files that do not benefit from delegation
+
+Usage notes:
+- Always pass a short description and a complete prompt with all required context
+- Use subagent_type to select behavior; default is general-purpose
+- Subagents do not inherit parent conversation history, only the prompt you provide
+- Subagents cannot spawn other subagents (no nested Agent calls)`,
+    parameters: subagentRequestSchema,
+    handler: async (args, context) => {
+      return options.runner(args, context);
+    }
+  });
+}
+var agentTool = createAgentTool({
+  runner: async () => ({
+    content: "Agent tool runner is not configured in this runtime",
+    isError: true
+  })
+});
+function getSubagentTools() {
+  return [agentTool];
+}
+
+// src/tools/builtin/index.ts
+function getAllBuiltinTools(skillRegistry, interactionOptions) {
+  return [
+    ...getFileSystemTools(),
+    ...getShellTools(),
+    ...getGrepTools(),
+    ...getWebTools(),
+    ...getTaskTools(),
+    ...getInteractionTools(interactionOptions),
+    ...getSubagentTools(),
+    ...getSkillTools(skillRegistry)
+  ];
+}
+function getSafeBuiltinTools(skillRegistry, interactionOptions) {
+  return getAllBuiltinTools(skillRegistry, interactionOptions).filter((tool) => !tool.isDangerous);
+}
+var EVENT_JSON_TO_RUNTIME = {
+  PreToolUse: "preToolUse",
+  PostToolUse: "postToolUse",
+  PostToolUseFailure: "postToolUseFailure"
+};
+function emptyHooksSettings() {
+  return {
+    hooks: {
+      preToolUse: [],
+      postToolUse: [],
+      postToolUseFailure: []
+    }
+  };
+}
+function parseHooksSettingsFile(raw) {
+  if (!raw || typeof raw !== "object") {
+    return emptyHooksSettings();
+  }
+  const file = raw;
+  const base = emptyHooksSettings();
+  base.disableAllHooks = file.disableAllHooks;
+  if (!file.hooks || typeof file.hooks !== "object") {
+    return base;
+  }
+  for (const [jsonKey, eventType] of Object.entries(EVENT_JSON_TO_RUNTIME)) {
+    const groups = file.hooks[jsonKey];
+    if (!Array.isArray(groups)) continue;
+    for (const g of groups) {
+      if (!g || typeof g !== "object") continue;
+      const group = g;
+      const hookList = Array.isArray(group.hooks) ? group.hooks : [];
+      const normalized = {
+        matcher: typeof group.matcher === "string" ? group.matcher : void 0,
+        hooks: []
+      };
+      for (const h of hookList) {
+        if (!h || typeof h !== "object") continue;
+        const c = h;
+        if (c.type !== "command" || typeof c.command !== "string") continue;
+        normalized.hooks.push({
+          id: typeof c.id === "string" ? c.id : void 0,
+          type: "command",
+          command: c.command,
+          timeout: typeof c.timeout === "number" ? c.timeout : void 0,
+          async: typeof c.async === "boolean" ? c.async : void 0
+        });
+      }
+      if (normalized.hooks.length > 0) {
+        base.hooks[eventType].push(normalized);
+      }
+    }
+  }
+  return base;
+}
+async function loadHooksSettingsFromProject(projectDir) {
+  const path$1 = path.join(projectDir, ".claude", "settings.json");
+  try {
+    const text = await promises.readFile(path$1, "utf-8");
+    const json = JSON.parse(text);
+    return parseHooksSettingsFile(json);
+  } catch {
+    return emptyHooksSettings();
+  }
+}
+async function loadHooksSettingsFromUser() {
+  const path$1 = path.join(os.homedir(), ".claude", "settings.json");
+  try {
+    const text = await promises.readFile(path$1, "utf-8");
+    const json = JSON.parse(text);
+    return parseHooksSettingsFile(json);
+  } catch {
+    return emptyHooksSettings();
+  }
+}
+function emptyHooksRecord() {
+  return {
+    preToolUse: [],
+    postToolUse: [],
+    postToolUseFailure: []
+  };
+}
+function matchTool(toolName, matcher) {
+  if (!matcher || matcher === "*") return true;
+  try {
+    return new RegExp(matcher).test(toolName);
+  } catch {
+    return false;
+  }
+}
+function toUpperSnake(paramName) {
+  return paramName.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/[\s-]+/g, "_").toUpperCase();
+}
+function buildHookEnv(context) {
+  const env = { ...process.env };
+  env.CLAUDE_TOOL_NAME = context.toolName;
+  if (context.toolCallId) env.CLAUDE_TOOL_CALL_ID = context.toolCallId;
+  if (context.projectDir) env.CLAUDE_PROJECT_DIR = context.projectDir;
+  env.CLAUDE_HOOK_EVENT = context.eventType;
+  for (const [k, v] of Object.entries(context.toolInput)) {
+    const key = `CLAUDE_TOOL_INPUT_${toUpperSnake(k)}`;
+    env[key] = typeof v === "string" ? v : JSON.stringify(v);
+  }
+  return env;
+}
+function buildStdinPayload(context) {
+  const payload = {
+    hook_event: context.eventType,
+    tool_name: context.toolName,
+    tool_input: context.toolInput
+  };
+  if (context.toolCallId) payload.tool_call_id = context.toolCallId;
+  if (context.projectDir) payload.project_dir = context.projectDir;
+  if (context.toolResultRaw) {
+    payload.tool_result_raw = {
+      content: context.toolResultRaw.content,
+      isError: context.toolResultRaw.isError
+    };
+  }
+  if (context.toolResultFinal) {
+    payload.tool_result_final = {
+      content: context.toolResultFinal.content,
+      isError: context.toolResultFinal.isError
+    };
+  }
+  if (context.errorMessage) payload.error_message = context.errorMessage;
+  if (context.failureKind) payload.failure_kind = context.failureKind;
+  return payload;
+}
+function flattenGroups(groups) {
+  const out = [];
+  for (const g of groups) {
+    for (const hook of g.hooks) {
+      out.push({ matcher: g.matcher, hook });
+    }
+  }
+  return out;
+}
+function mergeCommandHookLayers(project, user) {
+  const projectFlat = flattenGroups(project);
+  const userFlat = flattenGroups(user);
+  const projectNoId = [];
+  const idMap = /* @__PURE__ */ new Map();
+  for (const e of projectFlat) {
+    if (e.hook.id) {
+      idMap.set(e.hook.id, e);
+    } else {
+      projectNoId.push(e);
+    }
+  }
+  const userNoId = [];
+  for (const e of userFlat) {
+    if (e.hook.id) {
+      idMap.set(e.hook.id, e);
+    } else {
+      userNoId.push(e);
+    }
+  }
+  return [...projectNoId, ...userNoId, ...idMap.values()];
+}
+function mergeDisableAll(project, user) {
+  return project === true || user === true;
+}
+function runSpawnWithStdin(command, env, stdinBody, timeoutSec) {
+  return new Promise((resolve, reject) => {
+    const child = child_process.spawn(command, {
+      shell: true,
+      env,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let stderr = "";
+    child.stderr?.on("data", (d) => {
+      stderr += d.toString("utf-8");
+    });
+    child.stdout?.on("data", () => {
+    });
+    const timeoutMs = Math.max(1, timeoutSec) * 1e3;
+    const timer = setTimeout(() => {
+      child.kill("SIGTERM");
+    }, timeoutMs);
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      reject(err);
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      resolve({ code, stderr });
+    });
+    try {
+      child.stdin?.write(stdinBody, "utf-8");
+      child.stdin?.end();
+    } catch (e) {
+      clearTimeout(timer);
+      reject(e);
+    }
+  });
+}
+function parseReasonFromStderr(stderr) {
+  const trimmed = stderr.trim();
+  if (!trimmed) return void 0;
+  try {
+    const j = JSON.parse(trimmed);
+    if (typeof j.reason === "string") return j.reason;
+  } catch {
+  }
+  return trimmed;
+}
+var HookManager = class _HookManager {
+  runtimeEnabled = true;
+  mergedDisableAll = false;
+  mergedHooks = {
+    preToolUse: [],
+    postToolUse: [],
+    postToolUseFailure: []
+  };
+  functionHooks = /* @__PURE__ */ new Map();
+  projectHooks = this.emptySettings();
+  userHooks = this.emptySettings();
+  emptySettings() {
+    return {
+      disableAllHooks: false,
+      hooks: emptyHooksRecord()
+    };
+  }
+  rebuildMerged() {
+    const events = ["preToolUse", "postToolUse", "postToolUseFailure"];
+    for (const ev of events) {
+      this.mergedHooks[ev] = mergeCommandHookLayers(
+        this.projectHooks.hooks[ev],
+        this.userHooks.hooks[ev]
+      );
+    }
+    this.mergedDisableAll = mergeDisableAll(
+      this.projectHooks.disableAllHooks,
+      this.userHooks.disableAllHooks
+    );
+  }
+  shouldRunHooks() {
+    if (!this.runtimeEnabled) return false;
+    if (this.mergedDisableAll) return false;
+    return true;
+  }
+  getHooksForEvent(event) {
+    return this.mergedHooks[event] ?? [];
+  }
+  getFunctionHooksForEvent(event) {
+    return [...this.functionHooks.values()].filter((h) => h.event === event);
+  }
+  async runCommandHook(cmd, context, phase) {
+    const env = buildHookEnv(context);
+    const stdinBody = JSON.stringify(buildStdinPayload(context));
+    const timeoutSec = cmd.timeout ?? 30;
+    try {
+      const { code, stderr } = await runSpawnWithStdin(cmd.command, env, stdinBody, timeoutSec);
+      if (phase === "pre") {
+        if (code === 0) return { allowed: true };
+        if (code === 2) {
+          return {
+            allowed: false,
+            reason: parseReasonFromStderr(stderr) ?? "Hook blocked tool execution"
+          };
+        }
+        console.error(
+          `[HookManager] PreToolUse command exited with code ${code}: ${stderr || cmd.command}`
+        );
+        return {
+          allowed: false,
+          reason: parseReasonFromStderr(stderr) ?? `Hook process exited with code ${code}`
+        };
+      }
+      if (code !== 0 && code !== null) {
+        console.error(`[HookManager] Post* hook non-zero exit (${code}): ${stderr || cmd.command}`);
+      }
+    } catch (err) {
+      console.error(`[HookManager] Command hook failed: ${cmd.command}`, err);
+      if (phase === "pre") {
+        return {
+          allowed: false,
+          reason: err instanceof Error ? err.message : String(err)
+        };
+      }
+    }
+  }
+  fireAsyncCommandHook(cmd, context) {
+    const env = buildHookEnv(context);
+    const stdinBody = JSON.stringify(buildStdinPayload(context));
+    const timeoutSec = cmd.timeout ?? 30;
+    void runSpawnWithStdin(cmd.command, env, stdinBody, timeoutSec).then(({ code, stderr }) => {
+      if (code !== 0 && code !== null) {
+        console.error(`[HookManager] async hook exit (${code}): ${stderr || cmd.command}`);
+      }
+    }).catch((err) => {
+      console.error(`[HookManager] async hook error: ${cmd.command}`, err);
+    });
+  }
+  async runFunctionHookSafe(hook, context, phase) {
+    try {
+      return await hook.handler(context);
+    } catch (err) {
+      console.error(`[HookManager] Function hook "${hook.id}" threw`, err);
+      if (phase === "pre") {
+        return {
+          allowed: false,
+          reason: err instanceof Error ? err.message : String(err)
+        };
+      }
+    }
+  }
+  register(hook) {
+    this.functionHooks.set(hook.id, hook);
+  }
+  unregister(id) {
+    return this.functionHooks.delete(id);
+  }
+  async loadProjectConfig(projectDir) {
+    this.projectHooks = await loadHooksSettingsFromProject(projectDir);
+    this.rebuildMerged();
+  }
+  async loadUserConfig() {
+    this.userHooks = await loadHooksSettingsFromUser();
+    this.rebuildMerged();
+  }
+  async discoverAndLoad(projectDir) {
+    const dir = projectDir ?? process.cwd();
+    await this.loadProjectConfig(dir);
+    await this.loadUserConfig();
+  }
+  setEnabled(enabled) {
+    this.runtimeEnabled = enabled;
+  }
+  isEnabled() {
+    return this.runtimeEnabled;
+  }
+  async executePreToolUse(context) {
+    if (!this.shouldRunHooks()) {
+      return { allowed: true, updatedInput: { ...context.toolInput } };
+    }
+    let workingInput = { ...context.toolInput };
+    for (const entry of this.getHooksForEvent("preToolUse")) {
+      if (!matchTool(context.toolName, entry.matcher)) continue;
+      const ctx = { ...context, toolInput: workingInput };
+      const result = await this.runCommandHook(entry.hook, ctx, "pre");
+      if (result?.allowed === false) {
+        return { allowed: false, reason: result.reason };
+      }
+    }
+    for (const fh of this.getFunctionHooksForEvent("preToolUse")) {
+      if (!matchTool(context.toolName, fh.matcher)) continue;
+      const ctx = { ...context, toolInput: workingInput };
+      const result = await this.runFunctionHookSafe(fh, ctx, "pre");
+      if (result?.allowed === false) {
+        return { allowed: false, reason: result.reason };
+      }
+      if (result?.updatedInput) {
+        workingInput = { ...workingInput, ...result.updatedInput };
+      }
+    }
+    return { allowed: true, updatedInput: workingInput };
+  }
+  async executePostToolUse(context) {
+    if (!this.shouldRunHooks()) return;
+    for (const entry of this.getHooksForEvent("postToolUse")) {
+      if (!matchTool(context.toolName, entry.matcher)) continue;
+      if (entry.hook.async) {
+        this.fireAsyncCommandHook(entry.hook, context);
+        continue;
+      }
+      await this.runCommandHook(entry.hook, context, "post");
+    }
+    for (const fh of this.getFunctionHooksForEvent("postToolUse")) {
+      if (!matchTool(context.toolName, fh.matcher)) continue;
+      await this.runFunctionHookSafe(fh, context, "post");
+    }
+  }
+  async executePostToolUseFailure(context) {
+    if (!this.shouldRunHooks()) return;
+    for (const entry of this.getHooksForEvent("postToolUseFailure")) {
+      if (!matchTool(context.toolName, entry.matcher)) continue;
+      if (entry.hook.async) {
+        this.fireAsyncCommandHook(entry.hook, context);
+        continue;
+      }
+      await this.runCommandHook(entry.hook, context, "post");
+    }
+    for (const fh of this.getFunctionHooksForEvent("postToolUseFailure")) {
+      if (!matchTool(context.toolName, fh.matcher)) continue;
+      await this.runFunctionHookSafe(fh, context, "post");
+    }
+  }
+  static create() {
+    return new _HookManager();
+  }
+};
+function createFunctionHook(config) {
+  return {
+    id: config.id,
+    event: config.event,
+    matcher: config.matcher,
+    description: config.description,
+    handler: config.handler
+  };
+}
+
+exports.DEFAULT_GREP_HEAD_LIMIT = DEFAULT_GREP_HEAD_LIMIT;
+exports.FileStorageStrategy = FileStorageStrategy;
+exports.HookManager = HookManager;
+exports.MAX_LINE_LENGTH = MAX_LINE_LENGTH2;
+exports.OUTPUT_CONFIG = OUTPUT_CONFIG;
+exports.OutputHandler = OutputHandler;
+exports.PaginationHintStrategy = PaginationHintStrategy;
+exports.SmartTruncateStrategy = SmartTruncateStrategy;
+exports.ToolRegistry = ToolRegistry;
+exports.agentTool = agentTool;
+exports.bashTool = bashTool;
+exports.buildHookEnv = buildHookEnv;
+exports.createAgentTool = createAgentTool;
+exports.createAskUserQuestionTool = createAskUserQuestionTool;
+exports.createFunctionHook = createFunctionHook;
+exports.createOutputHandler = createOutputHandler;
+exports.createSkillTool = createSkillTool;
+exports.createTool = createTool;
+exports.editTool = editTool;
+exports.formatAnswerSummary = formatAnswerSummary;
+exports.formatAskUserQuestionPrompt = formatAskUserQuestionPrompt;
+exports.formatEnvironmentSection = formatEnvironmentSection;
+exports.getAllBuiltinTools = getAllBuiltinTools;
+exports.getEnvironmentInfo = getEnvironmentInfo;
+exports.getFileSystemTools = getFileSystemTools;
+exports.getGlobalRegistry = getGlobalRegistry;
+exports.getGrepTools = getGrepTools;
+exports.getInteractionTools = getInteractionTools;
+exports.getSafeBuiltinTools = getSafeBuiltinTools;
+exports.getShellTools = getShellTools;
+exports.getSkillTools = getSkillTools;
+exports.getSubagentTools = getSubagentTools;
+exports.getTaskTools = getTaskTools;
+exports.getWebTools = getWebTools;
+exports.globTool = globTool;
+exports.grepTool = grepTool;
+exports.loadHooksSettingsFromProject = loadHooksSettingsFromProject;
+exports.loadHooksSettingsFromUser = loadHooksSettingsFromUser;
+exports.matchTool = matchTool;
+exports.mergeCommandHookLayers = mergeCommandHookLayers;
+exports.parseHooksSettingsFile = parseHooksSettingsFile;
+exports.questionTool = questionTool;
+exports.readFileTool = readFileTool;
+exports.subagentRequestSchema = subagentRequestSchema;
+exports.taskCreateTool = taskCreateTool;
+exports.taskListTool = taskListTool;
+exports.taskUpdateTool = taskUpdateTool;
+exports.truncateMatchLineForDisplay = truncateMatchLineForDisplay;
+exports.webFetchTool = webFetchTool;
+exports.webSearchTool = webSearchTool;
+exports.writeFileTool = writeFileTool;
+//# sourceMappingURL=chunk-JF5AJQMU.cjs.map
+//# sourceMappingURL=chunk-JF5AJQMU.cjs.map