@zhongqian97-code/ecode 0.5.33 → 0.5.35

package/dist/chunk-VM35XIBY.js

@@ -0,0 +1,1951 @@
+#!/usr/bin/env node
+const _ew=process.emitWarning.bind(process);process.emitWarning=function(w,...a){if((w?.message??w)?.includes?.('punycode'))return;_ew(w,...a);};
+import {
+  createSessionMetadata,
+  updateSessionMetadata,
+  writeSessionMetadata
+} from "./chunk-O4YFKL3N.js";
+
+// src/providers/openai.ts
+import OpenAI from "openai";
+function createOpenAIProvider(profile) {
+  const THINK_END = "</think>";
+  const openai = new OpenAI({
+    baseURL: profile.baseUrl,
+    apiKey: profile.apiKey
+  });
+  const capabilities = Object.freeze(
+    Object.defineProperties({}, {
+      supportsTools: { value: true, writable: false, enumerable: true, configurable: false },
+      supportsReasoningStream: { value: true, writable: false, enumerable: true, configurable: false },
+      supportsImages: { value: false, writable: false, enumerable: true, configurable: false },
+      supportsJsonSchema: { value: true, writable: false, enumerable: true, configurable: false }
+    })
+  );
+  return {
+    capabilities,
+    /**
+     * stream 方法向 LLM 发起一次流式对话请求，返回异步可迭代的 chunk 序列。
+     *
+     * 实现细节：
+     * - 使用 `Symbol.asyncIterator` + async generator 实现懒执行：
+     *   只有调用方执行 `for await` 时才真正发起 HTTP 请求，避免浪费连接
+     * - 内部维护两个累加器：
+     *   1. `tcAccumulator`：按 index 聚合工具调用的分片参数（JSON 字符串）
+     *   2. `reasoningAccumulator`：拼接思考链的所有分片文本
+     * - 只在最终 chunk（`finish_reason !== null`）中 yield done=true 的完整信息
+     *
+     * @param messages  完整的对话历史，包含 user/assistant/tool 所有轮次
+     * @param tools     可选的工具列表，不传或传空数组时不附加 tools 字段
+     * @param signal    可选的 AbortSignal，用于取消请求
+     */
+    stream(messages, tools, signal) {
+      return {
+        [Symbol.asyncIterator]: async function* () {
+          var _a, _b, _c;
+          let thinkPhase = "pre";
+          let scanningForClose = false;
+          let closeSearchBuffer = "";
+          let visibleTextTail = "";
+          function rememberVisibleText(text) {
+            if (!text) return;
+            visibleTextTail = (visibleTextTail + text).slice(-256);
+          }
+          function hasNearbyVisibleOpenThink(maxDistance = 4) {
+            const openIdx = visibleTextTail.lastIndexOf("<think>");
+            const closeIdx = visibleTextTail.lastIndexOf(THINK_END);
+            if (openIdx === -1 || openIdx < closeIdx) return false;
+            return visibleTextTail.length - (openIdx + "<think>".length) <= maxDistance;
+          }
+          function processContent(raw) {
+            if (!raw) return { text: "", thinking: "" };
+            if (thinkPhase === "post") return { text: raw, thinking: "" };
+            if (thinkPhase === "pre") {
+              if (raw.startsWith("<think>")) {
+                thinkPhase = "in";
+                raw = raw.slice(7);
+              } else {
+                thinkPhase = "post";
+                return { text: raw, thinking: "" };
+              }
+            }
+            const endIdx = raw.indexOf(THINK_END);
+            if (endIdx === -1) return { text: "", thinking: raw };
+            const thinking = raw.slice(0, endIdx);
+            thinkPhase = "post";
+            return { text: raw.slice(endIdx + THINK_END.length), thinking };
+          }
+          const requestParams = {
+            model: profile.model,
+            messages,
+            stream: true,
+            stream_options: { include_usage: true }
+          };
+          if (tools && tools.length > 0) {
+            requestParams.tools = tools;
+          }
+          const response = await openai.chat.completions.create(
+            requestParams,
+            signal ? { signal } : void 0
+          );
+          const tcAccumulator = /* @__PURE__ */ new Map();
+          let reasoningAccumulator = "";
+          const reasoningDetailsAcc = /* @__PURE__ */ new Map();
+          for await (const chunk of response) {
+            const choice = chunk.choices[0];
+            if (!choice) continue;
+            const delta = choice.delta;
+            if (delta.reasoning_content) {
+              reasoningAccumulator += delta.reasoning_content;
+            }
+            if (delta.reasoning_details && delta.reasoning_details.length > 0) {
+              scanningForClose = true;
+              for (const rd of delta.reasoning_details) {
+                const id = rd.id ?? "";
+                const text = rd.text ?? "";
+                if (!reasoningDetailsAcc.has(id)) {
+                  reasoningDetailsAcc.set(id, {
+                    type: rd.type ?? "reasoning.text",
+                    id,
+                    format: rd.format ?? "",
+                    index: rd.index ?? 0,
+                    text: ""
+                  });
+                }
+                const existing = reasoningDetailsAcc.get(id);
+                existing.text += text;
+                if (!delta.reasoning_content && text) {
+                  reasoningAccumulator += text;
+                }
+              }
+            }
+            if (delta.tool_calls) {
+              for (const tc of delta.tool_calls) {
+                if (!tcAccumulator.has(tc.index)) {
+                  tcAccumulator.set(tc.index, {
+                    id: tc.id ?? "",
+                    name: ((_a = tc.function) == null ? void 0 : _a.name) ?? "",
+                    arguments: ""
+                  });
+                }
+                const existing = tcAccumulator.get(tc.index);
+                if (tc.id) existing.id = tc.id;
+                if ((_b = tc.function) == null ? void 0 : _b.name) existing.name = tc.function.name;
+                existing.arguments += ((_c = tc.function) == null ? void 0 : _c.arguments) ?? "";
+              }
+            }
+            const isLast = choice.finish_reason != null;
+            let rawToProcess;
+            if (delta.reasoning_details && delta.reasoning_details.length > 0) {
+              rawToProcess = "";
+            } else if (scanningForClose) {
+              closeSearchBuffer += delta.content ?? "";
+              const closeIdx = closeSearchBuffer.indexOf(THINK_END);
+              if (closeIdx !== -1) {
+                const openIdx = closeSearchBuffer.lastIndexOf("<think>", closeIdx);
+                const hasNearbyLiteralPair = openIdx !== -1 && closeIdx - (openIdx + "<think>".length) <= 8;
+                const afterClose = closeSearchBuffer.slice(closeIdx + THINK_END.length);
+                rawToProcess = hasNearbyLiteralPair ? closeSearchBuffer : afterClose.length > 0 ? afterClose : closeSearchBuffer.slice(0, closeIdx);
+                scanningForClose = false;
+                closeSearchBuffer = "";
+                thinkPhase = "post";
+              } else if (isLast) {
+                rawToProcess = closeSearchBuffer;
+                scanningForClose = false;
+                closeSearchBuffer = "";
+                thinkPhase = "post";
+              } else {
+                rawToProcess = "";
+              }
+            } else {
+              rawToProcess = delta.content ?? "";
+            }
+            if (thinkPhase === "post" && rawToProcess.endsWith(THINK_END) && !rawToProcess.includes("<think>") && !hasNearbyVisibleOpenThink()) {
+              rawToProcess = rawToProcess.slice(0, -THINK_END.length);
+            }
+            const { text: filteredText, thinking: thinkContent } = processContent(rawToProcess);
+            rememberVisibleText(filteredText);
+            if (thinkContent) {
+              reasoningAccumulator += thinkContent;
+            }
+            if (isLast) {
+              const rawUsage = chunk.usage;
+              yield {
+                text: filteredText,
+                done: true,
+                finishReason: choice.finish_reason,
+                // tcAccumulator 为空说明本轮没有工具调用，传 undefined 而非空数组，
+                // 让调用方用 if (chunk.toolCalls) 做简洁判断
+                toolCalls: tcAccumulator.size > 0 ? Array.from(tcAccumulator.values()) : void 0,
+                reasoning: reasoningAccumulator || void 0,
+                // reasoningDetails 仅在流中出现过结构化推理时返回（MiniMax 兼容）
+                reasoningDetails: reasoningDetailsAcc.size > 0 ? Array.from(reasoningDetailsAcc.values()) : void 0,
+                // 将 snake_case 的原始字段映射为 camelCase，对外接口保持一致
+                usage: rawUsage ? {
+                  promptTokens: rawUsage.prompt_tokens,
+                  completionTokens: rawUsage.completion_tokens,
+                  totalTokens: rawUsage.total_tokens
+                } : void 0
+              };
+            } else {
+              const incrementalReasoning = delta.reasoning_content || thinkContent || (delta.reasoning_details && delta.reasoning_details.length > 0 ? delta.reasoning_details.map((rd) => rd.text ?? "").join("") : void 0) || void 0;
+              yield {
+                text: filteredText,
+                reasoning: incrementalReasoning || void 0,
+                done: false
+              };
+            }
+          }
+        }
+      };
+    }
+  };
+}
+
+// src/providers/index.ts
+function createProvider(profile) {
+  return createOpenAIProvider(profile);
+}
+function resolveActiveProfile(config, providerName) {
+  var _a, _b;
+  if (providerName !== void 0) {
+    const profile = (_a = config.providers) == null ? void 0 : _a[providerName];
+    if (!profile) {
+      throw new Error(`Provider '${providerName}' not found`);
+    }
+    return profile;
+  }
+  if (config.defaultProvider) {
+    const profile = (_b = config.providers) == null ? void 0 : _b[config.defaultProvider];
+    if (profile) return profile;
+  }
+  if (config.providers) {
+    if (config.providers["default"]) {
+      return config.providers["default"];
+    }
+    const first = Object.values(config.providers)[0];
+    if (first) return first;
+  }
+  return {
+    baseUrl: config.baseUrl,
+    apiKey: config.apiKey,
+    model: config.model
+  };
+}
+
+// src/skills/loader.ts
+import { readFile, readdir, stat } from "fs/promises";
+import { join, dirname, basename, resolve, sep } from "path";
+function parseFrontmatter(content) {
+  const FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
+  const match = FRONTMATTER_RE.exec(content);
+  if (!match) {
+    return { data: {}, body: content };
+  }
+  const rawFrontmatter = match[1];
+  const body = match[2] ?? "";
+  const data = {};
+  for (const line of rawFrontmatter.split(/\r?\n/)) {
+    const colonIdx = line.indexOf(":");
+    if (colonIdx === -1) continue;
+    const key = line.slice(0, colonIdx).trim();
+    const value = line.slice(colonIdx + 1).trim();
+    if (key) {
+      data[key] = value;
+    }
+  }
+  return { data, body };
+}
+function isTrustedSkillPath(skillDir, trustedDirs) {
+  const normalized = resolve(skillDir);
+  for (const trusted of trustedDirs) {
+    const normalizedTrusted = resolve(trusted);
+    if (normalized === normalizedTrusted || normalized.startsWith(normalizedTrusted + sep)) {
+      return true;
+    }
+  }
+  return false;
+}
+async function fileExists(filePath) {
+  try {
+    await stat(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function loadTools(skillDir) {
+  const toolsJsonPath = join(skillDir, "tools.json");
+  if (!await fileExists(toolsJsonPath)) return [];
+  let raw;
+  try {
+    raw = await readFile(toolsJsonPath, "utf-8");
+  } catch {
+    return [];
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(parsed)) return [];
+  const tools = [];
+  for (const item of parsed) {
+    if (typeof item === "object" && item !== null && typeof item["name"] === "string" && typeof item["description"] === "string") {
+      const entry = item;
+      tools.push({
+        name: entry["name"],
+        description: entry["description"],
+        parameters: entry["parameters"] ?? {},
+        scriptPath: join(skillDir, `${entry["name"]}.sh`)
+      });
+    }
+  }
+  return tools;
+}
+async function loadSkillFile(skillMdPath) {
+  const content = await readFile(skillMdPath, "utf-8");
+  const { data, body } = parseFrontmatter(content);
+  const skillDir = dirname(skillMdPath);
+  const dirName = basename(skillDir);
+  const [tools, hasPreScript, hasPostScript] = await Promise.all([
+    loadTools(skillDir),
+    fileExists(join(skillDir, "pre.sh")),
+    fileExists(join(skillDir, "post.sh"))
+  ]);
+  return {
+    name: data["name"] ?? dirName,
+    description: data["description"] ?? "",
+    body,
+    source: skillMdPath,
+    tools,
+    preScript: hasPreScript ? join(skillDir, "pre.sh") : null,
+    postScript: hasPostScript ? join(skillDir, "post.sh") : null
+  };
+}
+async function loadSkillsFromDir(dir) {
+  let entries;
+  try {
+    entries = await readdir(dir);
+  } catch {
+    return [];
+  }
+  const skills = [];
+  for (const entry of entries) {
+    const entryPath = join(dir, entry);
+    let entryStat;
+    try {
+      entryStat = await stat(entryPath);
+    } catch {
+      continue;
+    }
+    if (!entryStat.isDirectory()) continue;
+    const skillMdPath = join(entryPath, "SKILL.md");
+    try {
+      await stat(skillMdPath);
+    } catch {
+      continue;
+    }
+    const skill = await loadSkillFile(skillMdPath);
+    skills.push(skill);
+  }
+  return skills.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+// src/tools/read.ts
+import * as fs from "fs/promises";
+var READ_TOOL = {
+  type: "function",
+  function: {
+    name: "read",
+    description: "\u8BFB\u53D6\u6587\u4EF6\u5185\u5BB9\u3002\u4F7F\u7528 offset\uFF080-based \u884C\u7D22\u5F15\uFF09\u548C limit \u53EF\u8BFB\u53D6\u6307\u5B9A\u884C\u8303\u56F4\uFF0C\u9002\u5408\u5927\u6587\u4EF6\u5C40\u90E8\u9605\u8BFB\u3002",
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "\u6587\u4EF6\u7684\u7EDD\u5BF9\u8DEF\u5F84\u6216\u76F8\u5BF9\u8DEF\u5F84\u3002" },
+        offset: { type: "number", description: "\u8D77\u59CB\u884C\u7D22\u5F15\uFF080-based\uFF0C\u9ED8\u8BA4 0\uFF09\u3002" },
+        limit: { type: "number", description: "\u6700\u591A\u8FD4\u56DE\u7684\u884C\u6570\u3002" }
+      },
+      required: ["path"]
+    }
+  }
+};
+async function readFile3(params) {
+  const { path: path7, offset = 0, limit } = params;
+  let raw;
+  try {
+    raw = await fs.readFile(path7, "utf8");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return `Error reading ${path7}: ${msg}`;
+  }
+  const lines = raw.split("\n");
+  const sliced = limit !== void 0 ? lines.slice(offset, offset + limit) : lines.slice(offset);
+  return sliced.map((line, i) => `${String(offset + i + 1).padStart(4)} ${line}`).join("\n");
+}
+
+// src/tools/glob.ts
+import * as fs2 from "fs/promises";
+import * as path from "path";
+var GLOB_TOOL = {
+  type: "function",
+  function: {
+    name: "glob",
+    description: "Find files matching a glob pattern. Returns relative paths (one per line). Default excludes node_modules, .git and hidden dirs; pass includeHidden=true to include them.",
+    parameters: {
+      type: "object",
+      properties: {
+        pattern: { type: "string", description: "Glob pattern, e.g. '**/*.ts', 'src/**', '*.md'" },
+        cwd: { type: "string", description: "Base directory to search in (default: current working directory)" },
+        includeHidden: { type: "boolean", description: "If true, include hidden files/dirs (starting with '.')" },
+        limit: { type: "number", description: "Max number of results to return (default 100)" }
+      },
+      required: ["pattern"]
+    }
+  }
+};
+function globToRegex(pattern) {
+  const hasSlash = pattern.includes("/");
+  const DSS = "\0DSS\0";
+  const DS = "\0DS\0";
+  const SS = "\0SS\0";
+  const QQ = "\0QQ\0";
+  let p = pattern.replace(/\*\*\//g, DSS).replace(/\*\*/g, DS).replace(/\*/g, SS).replace(/\?/g, QQ);
+  p = p.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+  p = p.replace(new RegExp(DSS, "g"), "(.*/)?").replace(new RegExp(DS, "g"), ".*").replace(new RegExp(SS, "g"), "[^/]*").replace(new RegExp(QQ, "g"), "[^/]");
+  if (!hasSlash) {
+  }
+  return new RegExp(`^${p}$`);
+}
+async function walk(dir, cwd, regex, includeHidden, results, total, limit) {
+  let entries;
+  try {
+    entries = await fs2.readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  entries.sort((a, b) => a.name.localeCompare(b.name));
+  for (const entry of entries) {
+    const name = entry.name;
+    if (name === "node_modules") continue;
+    if (!includeHidden && name.startsWith(".")) continue;
+    const abs = path.join(dir, name);
+    const rel = path.relative(cwd, abs);
+    if (entry.isDirectory()) {
+      await walk(abs, cwd, regex, includeHidden, results, total, limit);
+    } else if (entry.isFile()) {
+      const relPosix = rel.split(path.sep).join("/");
+      if (regex.test(relPosix)) {
+        total.count++;
+        if (results.length < limit) {
+          results.push(relPosix);
+        }
+      }
+    }
+  }
+}
+async function globFiles(params) {
+  const {
+    pattern,
+    cwd = process.cwd(),
+    includeHidden = false,
+    limit = 100
+  } = params;
+  try {
+    const stat4 = await fs2.stat(cwd);
+    if (!stat4.isDirectory()) {
+      return `Error: ${cwd} is not a directory`;
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return `Error: ${msg}`;
+  }
+  const regex = globToRegex(pattern);
+  const results = [];
+  const total = { count: 0 };
+  await walk(cwd, cwd, regex, includeHidden, results, total, limit);
+  if (results.length === 0) {
+    return `No files found matching pattern: ${pattern}`;
+  }
+  results.sort();
+  let output = results.join("\n");
+  if (total.count > limit) {
+    output += `
+... (truncated, ${total.count} total matches)`;
+  }
+  return output;
+}
+
+// src/tools/grep.ts
+import * as fs3 from "fs/promises";
+import * as path2 from "path";
+var GREP_TOOL = {
+  type: "function",
+  function: {
+    name: "grep",
+    description: "\u5728\u6587\u4EF6\u4E2D\u641C\u7D22\u6B63\u5219\u8868\u8FBE\u5F0F\u6A21\u5F0F\u3002\u8FD4\u56DE file:linenum:content \u683C\u5F0F\uFF0Ccontext \u884C\u7528 -- \u5206\u9694\u3002",
+    parameters: {
+      type: "object",
+      properties: {
+        pattern: { type: "string", description: "\u6B63\u5219\u8868\u8FBE\u5F0F\u6A21\u5F0F\u3002" },
+        path: { type: "string", description: "\u641C\u7D22\u7684\u6587\u4EF6\u6216\u76EE\u5F55\u8DEF\u5F84\uFF08\u9ED8\u8BA4\u5F53\u524D\u76EE\u5F55\uFF09\u3002" },
+        cwd: { type: "string", description: "\u5DE5\u4F5C\u76EE\u5F55\uFF08\u9ED8\u8BA4 process.cwd()\uFF09\u3002" },
+        context: { type: "number", description: "\u5339\u914D\u524D\u540E\u7684\u4E0A\u4E0B\u6587\u884C\u6570\uFF08\u9ED8\u8BA4 0\uFF09\u3002" },
+        includeHidden: { type: "boolean", description: "\u662F\u5426\u5305\u542B\u9690\u85CF\u76EE\u5F55\uFF08\u9ED8\u8BA4 false\uFF09\u3002" },
+        limit: { type: "number", description: "\u6700\u5927\u8FD4\u56DE\u5339\u914D\u6570\uFF08\u9ED8\u8BA4 50\uFF09\u3002" }
+      },
+      required: ["pattern"]
+    }
+  }
+};
+async function searchFile(absFile, displayFile, regex, matches, totalCount, limit) {
+  let text;
+  try {
+    text = await fs3.readFile(absFile, "utf8");
+  } catch {
+    return;
+  }
+  const lines = text.split("\n");
+  const lastIdx = lines.length - 1;
+  for (let i = 0; i < lines.length; i++) {
+    if (i === lastIdx && lines[i] === "") continue;
+    if (regex.test(lines[i])) {
+      totalCount.count++;
+      if (matches.length < limit) {
+        matches.push({ file: displayFile, line: i + 1, content: lines[i] });
+      }
+    }
+  }
+}
+async function walkDir(dir, cwd, regex, includeHidden, matches, totalCount, limit) {
+  let entries;
+  try {
+    entries = await fs3.readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  entries.sort((a, b) => a.name.localeCompare(b.name));
+  for (const entry of entries) {
+    const name = entry.name;
+    if (name === "node_modules") continue;
+    if (!includeHidden && name.startsWith(".")) continue;
+    const abs = path2.join(dir, name);
+    if (entry.isDirectory()) {
+      await walkDir(abs, cwd, regex, includeHidden, matches, totalCount, limit);
+    } else if (entry.isFile()) {
+      const rel = path2.relative(cwd, abs).split(path2.sep).join("/");
+      await searchFile(abs, rel, regex, matches, totalCount, limit);
+    }
+  }
+}
+async function renderWithContext(entries, contextLines) {
+  const outputLines = [];
+  for (const { absFile, displayFile, matches: fileMatches } of entries) {
+    let allLines = [];
+    try {
+      const text = await fs3.readFile(absFile, "utf8");
+      allLines = text.split("\n");
+    } catch {
+    }
+    if (allLines.length === 0) {
+      for (const m of fileMatches) {
+        outputLines.push(`${displayFile}:${m.line}:${m.content}`);
+      }
+      continue;
+    }
+    const ranges = [];
+    for (const m of fileMatches) {
+      const start = Math.max(0, m.line - 1 - contextLines);
+      const end = Math.min(allLines.length - 1, m.line - 1 + contextLines);
+      const last = ranges[ranges.length - 1];
+      if (last && start <= last.end + 1) {
+        last.end = Math.max(last.end, end);
+      } else {
+        ranges.push({ start, end });
+      }
+    }
+    for (let ri = 0; ri < ranges.length; ri++) {
+      if (ri > 0) outputLines.push("--");
+      const { start, end } = ranges[ri];
+      for (let i = start; i <= end; i++) {
+        if (i === allLines.length - 1 && allLines[i] === "") continue;
+        outputLines.push(`${displayFile}:${i + 1}:${allLines[i]}`);
+      }
+    }
+  }
+  return outputLines;
+}
+async function grepFiles(params) {
+  const {
+    pattern,
+    path: searchPath = ".",
+    cwd = process.cwd(),
+    context = 0,
+    includeHidden = false,
+    limit = 50
+  } = params;
+  let regex;
+  try {
+    regex = new RegExp(pattern);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return `Error: Invalid regex: ${msg}`;
+  }
+  const target = path2.isAbsolute(searchPath) ? searchPath : path2.resolve(cwd, searchPath);
+  let stat4;
+  try {
+    stat4 = await fs3.stat(target);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return `Error: ${msg}`;
+  }
+  const matches = [];
+  const totalCount = { count: 0 };
+  if (stat4.isFile()) {
+    await searchFile(target, searchPath, regex, matches, totalCount, limit);
+  } else if (stat4.isDirectory()) {
+    await walkDir(target, target, regex, includeHidden, matches, totalCount, limit);
+  } else {
+    return `Error: ${target} is neither a file nor a directory`;
+  }
+  if (matches.length === 0 && totalCount.count === 0) {
+    return "No matches found";
+  }
+  const matchesByFile = /* @__PURE__ */ new Map();
+  for (const m of matches) {
+    let group = matchesByFile.get(m.file);
+    if (!group) {
+      group = [];
+      matchesByFile.set(m.file, group);
+    }
+    group.push(m);
+  }
+  let outputLines;
+  if (context > 0) {
+    const baseDir = stat4.isDirectory() ? target : path2.dirname(target);
+    const entries = Array.from(matchesByFile.entries()).map(([displayFile, fileMatches]) => {
+      const absFile = path2.isAbsolute(displayFile) ? displayFile : path2.resolve(baseDir, displayFile);
+      return { absFile, displayFile, matches: fileMatches };
+    });
+    outputLines = await renderWithContext(entries, context);
+  } else {
+    outputLines = [];
+    for (const m of matches) {
+      outputLines.push(`${m.file}:${m.line}:${m.content}`);
+    }
+  }
+  let output = outputLines.join("\n");
+  if (totalCount.count > limit) {
+    const extra = totalCount.count - limit;
+    output += `
+... (truncated, ${extra} more matches)`;
+  }
+  return output;
+}
+
+// src/tools/web_fetch.ts
+import * as http from "http";
+import * as https from "https";
+var WEB_FETCH_TOOL = {
+  type: "function",
+  function: {
+    name: "web_fetch",
+    description: "Fetch a URL and extract its text content. Supports HTML, plain text and markdown pages. Returns a structured response with headers and extracted content.",
+    parameters: {
+      type: "object",
+      properties: {
+        url: { type: "string", description: "The URL to fetch (http or https only)." },
+        extract_mode: {
+          type: "string",
+          enum: ["text", "markdown"],
+          description: "How to extract content from HTML: 'markdown' (default) preserves headings/lists as markdown, 'text' strips all tags."
+        },
+        max_chars: {
+          type: "number",
+          description: "Maximum characters to return (default 20000, max 100000)."
+        },
+        timeout_ms: {
+          type: "number",
+          description: "Request timeout in milliseconds (default 20000, min 1000, max 60000)."
+        }
+      },
+      required: ["url"]
+    }
+  }
+};
+var CACHE_TTL = 6e5;
+var CACHE_MAX = 64;
+var cache = /* @__PURE__ */ new Map();
+function cacheGet(key) {
+  const entry = cache.get(key);
+  if (!entry) return void 0;
+  if (Date.now() - entry.at > CACHE_TTL) {
+    cache.delete(key);
+    return void 0;
+  }
+  return entry.result;
+}
+function cacheSet(key, result) {
+  if (cache.size >= CACHE_MAX) {
+    const oldest = cache.keys().next().value;
+    if (oldest !== void 0) cache.delete(oldest);
+  }
+  cache.set(key, { at: Date.now(), result });
+}
+function isPrivateHost(hostname) {
+  if (hostname === "localhost" || hostname === "0.0.0.0" || hostname === "::1") return true;
+  if (hostname.endsWith(".local")) return true;
+  const v4 = hostname.match(/^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/);
+  if (v4) {
+    const [, a, b] = v4.map(Number);
+    if (a === 127) return true;
+    if (a === 10) return true;
+    if (a === 192 && b === 168) return true;
+    if (a === 172 && b >= 16 && b <= 31) return true;
+    if (a === 0) return true;
+  }
+  return false;
+}
+function validateWebFetchUrl(rawUrl) {
+  let parsed;
+  try {
+    parsed = new URL(rawUrl);
+  } catch {
+    return { ok: false, error: `invalid URL: ${rawUrl}` };
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    return { ok: false, error: `unsupported protocol: ${parsed.protocol}` };
+  }
+  if (parsed.username || parsed.password) {
+    return { ok: false, error: "URL must not contain credentials" };
+  }
+  if (isPrivateHost(parsed.hostname)) {
+    return { ok: false, error: `host is private/local: ${parsed.hostname}` };
+  }
+  return { ok: true, parsed };
+}
+function rootHost(hostname) {
+  const parts = hostname.split(".");
+  return parts.length > 2 ? parts.slice(-2).join(".") : hostname;
+}
+function isSameOrWwwHost(a, b) {
+  if (a === b) return true;
+  const ra = rootHost(a);
+  const rb = rootHost(b);
+  return ra === rb && (a === `www.${ra}` || b === `www.${ra}` || a === ra || b === ra);
+}
+function extractHtmlText(html, mode) {
+  let s = html;
+  s = s.replace(/<script[\s\S]*?<\/script>/gi, "");
+  s = s.replace(/<style[\s\S]*?<\/style>/gi, "");
+  s = s.replace(/<!--[\s\S]*?-->/g, "");
+  if (mode === "markdown") {
+    s = s.replace(/<pre[^>]*>\s*<code[^>]*>([\s\S]*?)<\/code>\s*<\/pre>/gi, (_, code) => {
+      const decoded = decodeEntities(code);
+      return `
+
+\`\`\`
+${decoded}
+\`\`\`
+
+`;
+    });
+    s = s.replace(/<code[^>]*>([\s\S]*?)<\/code>/gi, (_, code) => `\`${code}\``);
+    for (let n = 1; n <= 6; n++) {
+      const hashes = "#".repeat(n);
+      s = s.replace(new RegExp(`<h${n}[^>]*>`, "gi"), `
+
+${hashes} `);
+      s = s.replace(new RegExp(`</h${n}>`, "gi"), "\n\n");
+    }
+    s = s.replace(/<li[^>]*>/gi, "\n- ");
+  } else {
+    for (let n = 1; n <= 6; n++) {
+      s = s.replace(new RegExp(`<h${n}[^>]*>`, "gi"), "\n\n");
+      s = s.replace(new RegExp(`</h${n}>`, "gi"), "\n\n");
+    }
+    s = s.replace(/<li[^>]*>/gi, "\n");
+  }
+  s = s.replace(/<\/p>/gi, "\n\n");
+  s = s.replace(/<p[^>]*>/gi, "\n\n");
+  s = s.replace(/<\/div>/gi, "\n");
+  s = s.replace(/<br\s*\/?>/gi, "\n");
+  s = s.replace(/<\/li>/gi, "\n");
+  s = s.replace(/<[^>]+>/g, "");
+  s = decodeEntities(s);
+  s = s.replace(/[ \t]+/g, " ");
+  s = s.replace(/\n{3,}/g, "\n\n");
+  return s.trim();
+}
+function decodeEntities(s) {
+  return s.replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'");
+}
+function statusText(status) {
+  const map = {
+    200: "OK",
+    201: "Created",
+    204: "No Content",
+    301: "Moved Permanently",
+    302: "Found",
+    303: "See Other",
+    307: "Temporary Redirect",
+    308: "Permanent Redirect",
+    400: "Bad Request",
+    401: "Unauthorized",
+    403: "Forbidden",
+    404: "Not Found",
+    405: "Method Not Allowed",
+    429: "Too Many Requests",
+    500: "Internal Server Error",
+    502: "Bad Gateway",
+    503: "Service Unavailable"
+  };
+  return map[status] ?? String(status);
+}
+async function nodeHttpFetch(url, signal) {
+  return new Promise((resolve4, reject) => {
+    const parsed = new URL(url);
+    const isHttps = parsed.protocol === "https:";
+    const lib = isHttps ? https : http;
+    const onAbort = () => {
+      req.destroy();
+      const err = new Error("The user aborted a request.");
+      err.name = "AbortError";
+      reject(err);
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    const req = lib.request(
+      {
+        hostname: parsed.hostname,
+        port: parsed.port ? parseInt(parsed.port, 10) : isHttps ? 443 : 80,
+        path: (parsed.pathname || "/") + parsed.search,
+        method: "GET",
+        headers: {
+          Accept: "text/html, text/plain, text/markdown, application/xhtml+xml, */*",
+          "User-Agent": "ecode-web-fetch/0.1"
+        }
+      },
+      (res) => {
+        const status = res.statusCode ?? 0;
+        const rawHeaders = res.headers;
+        const headerObj = {
+          get(name) {
+            const val = rawHeaders[name.toLowerCase()];
+            if (val == null) return null;
+            return Array.isArray(val) ? val.join(", ") : String(val);
+          }
+        };
+        const chunks = [];
+        res.on("data", (chunk) => chunks.push(chunk));
+        res.on("end", () => {
+          signal.removeEventListener("abort", onAbort);
+          const body = Buffer.concat(chunks).toString("utf8");
+          resolve4({
+            status,
+            url,
+            headers: headerObj,
+            text: () => Promise.resolve(body)
+          });
+        });
+        res.on("error", (err) => {
+          signal.removeEventListener("abort", onAbort);
+          reject(err);
+        });
+      }
+    );
+    req.on("error", (err) => {
+      signal.removeEventListener("abort", onAbort);
+      reject(err);
+    });
+    req.end();
+  });
+}
+async function fetchWithRedirects(url, timeoutMs, signal) {
+  let current = url;
+  let hops = 0;
+  const MAX_REDIRECTS = 5;
+  const originalHost = new URL(url).hostname;
+  const useFetch = typeof fetch !== "undefined";
+  while (hops <= MAX_REDIRECTS) {
+    const response = useFetch ? await fetch(current, {
+      redirect: "manual",
+      signal,
+      headers: {
+        Accept: "text/html, text/plain, text/markdown, application/xhtml+xml, */*",
+        "User-Agent": "ecode-web-fetch/0.1"
+      }
+    }) : await nodeHttpFetch(current, signal);
+    const status = response.status;
+    if (status >= 300 && status < 400) {
+      const location = response.headers.get("location");
+      if (!location) {
+        return { response, finalUrl: current };
+      }
+      const nextUrl = new URL(location, current).toString();
+      const nextHost = new URL(nextUrl).hostname;
+      if (!isSameOrWwwHost(originalHost, nextHost)) {
+        throw new Error(`redirect to different host is not allowed automatically (-> ${nextUrl})`);
+      }
+      current = nextUrl;
+      hops++;
+      continue;
+    }
+    return { response, finalUrl: current };
+  }
+  throw new Error(`too many redirects (> ${MAX_REDIRECTS})`);
+}
+async function webFetch(params) {
+  const {
+    url,
+    extract_mode = "markdown",
+    max_chars: rawMaxChars = 2e4,
+    timeout_ms: rawTimeout = 2e4
+  } = params;
+  const maxChars = Math.min(Math.max(rawMaxChars, 1), 1e5);
+  const timeoutMs = Math.min(Math.max(rawTimeout, 1e3), 6e4);
+  const validation = validateWebFetchUrl(url);
+  if (!validation.ok) {
+    return `Error fetching ${url}: ${validation.error}`;
+  }
+  const cacheKey = `${url}:${extract_mode}:${maxChars}`;
+  const cached = cacheGet(cacheKey);
+  if (cached !== void 0) return cached;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  let response;
+  let finalUrl;
+  try {
+    ({ response, finalUrl } = await fetchWithRedirects(url, timeoutMs, controller.signal));
+  } catch (err) {
+    clearTimeout(timer);
+    if (err instanceof Error && err.name === "AbortError") {
+      return `Error fetching ${url}: request timed out after ${timeoutMs}ms`;
+    }
+    const msg = err instanceof Error ? err.message : String(err);
+    return `Error fetching ${url}: ${msg}`;
+  } finally {
+    clearTimeout(timer);
+  }
+  if (response.url) {
+    let resolvedHost;
+    try {
+      resolvedHost = new URL(response.url).hostname;
+    } catch {
+      resolvedHost = validation.parsed.hostname;
+    }
+    if (!isSameOrWwwHost(validation.parsed.hostname, resolvedHost)) {
+      return `Error fetching ${url}: redirect to different host is not allowed automatically (-> ${response.url})`;
+    }
+  }
+  const status = response.status;
+  const contentTypeHeader = response.headers.get("content-type") ?? "";
+  const mimeType = contentTypeHeader.split(";")[0].trim().toLowerCase();
+  if (status >= 400) {
+    return `Error fetching ${url}: HTTP ${status} ${statusText(status)}`;
+  }
+  const supportedTypes = ["text/html", "text/plain", "text/markdown", "application/xhtml+xml"];
+  if (mimeType && !supportedTypes.includes(mimeType)) {
+    return `Error fetching ${url}: unsupported content-type ${mimeType}`;
+  }
+  let body;
+  try {
+    body = await response.text();
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return `Error fetching ${url}: failed to read response body: ${msg}`;
+  }
+  let extracted;
+  if (mimeType === "text/plain" || mimeType === "text/markdown") {
+    extracted = body;
+  } else {
+    extracted = extractHtmlText(body, extract_mode);
+  }
+  const truncated = extracted.length > maxChars;
+  const content = truncated ? extracted.slice(0, maxChars) : extracted;
+  const result = [
+    `URL: ${url}`,
+    `Final-URL: ${finalUrl}`,
+    `Status: ${status} ${statusText(status)}`,
+    `Content-Type: ${contentTypeHeader || "(none)"}`,
+    `Bytes: ${body.length}`,
+    `Extract-Mode: ${extract_mode}`,
+    `Truncated: ${truncated ? "yes" : "no"}`,
+    "",
+    "<content>",
+    content,
+    "</content>"
+  ].join("\n");
+  cacheSet(cacheKey, result);
+  return result;
+}
+
+// src/logger.ts
+import * as fs4 from "fs";
+import * as path3 from "path";
+function createLogger(logDir, sessionStart) {
+  fs4.mkdirSync(logDir, { recursive: true });
+  const filename = sessionStart.toISOString().replace(/:/g, "-").replace(/\..+/, "") + ".jsonl";
+  const filePath = path3.join(logDir, filename);
+  return {
+    filePath,
+    /**
+     * 将单条日志条目序列化为 JSON 并同步追加到文件（末尾加换行符）。
+     *
+     * 使用 appendFileSync 而非 appendFile（异步版本）的原因：
+     * 进程崩溃或 Ctrl-C 退出时，异步写操作可能尚未完成，导致最后几条记录丢失。
+     * 同步写入虽然阻塞事件循环，但日志条目通常很小（< 1KB），延迟可忽略。
+     *
+     * 写入失败时输出到 stderr 而非抛出异常，防止日志错误中断正常业务流程。
+     */
+    append(entry) {
+      try {
+        fs4.appendFileSync(filePath, JSON.stringify(entry) + "\n");
+      } catch (err) {
+        process.stderr.write(`[logger] Failed to write log entry: ${err}
+`);
+      }
+    }
+  };
+}
+
+// src/tools/bash.ts
+import { exec } from "child_process";
+var DEFAULT_TIMEOUT_MS = 3e4;
+function executeBash(cmd, timeoutMs = DEFAULT_TIMEOUT_MS) {
+  return new Promise((resolve4) => {
+    exec(cmd, { timeout: timeoutMs }, (err, stdout, stderr) => {
+      if (err) {
+        const exitCode = err.code ?? 1;
+        resolve4({ stdout: stdout ?? "", stderr: stderr ?? "", exitCode });
+      } else {
+        resolve4({ stdout: stdout ?? "", stderr: stderr ?? "", exitCode: 0 });
+      }
+    });
+  });
+}
+
+// src/tools/write.ts
+import * as fs5 from "fs/promises";
+import * as path4 from "path";
+var WRITE_TOOL = {
+  type: "function",
+  function: {
+    name: "write",
+    description: "\u5C06\u5185\u5BB9\u5199\u5165\u6587\u4EF6\uFF08\u8986\u76D6\u6A21\u5F0F\uFF09\uFF0C\u81EA\u52A8\u521B\u5EFA\u7236\u76EE\u5F55\u3002\u5199\u5165\u524D\u8BF7\u5148\u7528 read \u786E\u8BA4\u73B0\u6709\u5185\u5BB9\u3002",
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "\u6587\u4EF6\u7684\u7EDD\u5BF9\u8DEF\u5F84\u6216\u76F8\u5BF9\u8DEF\u5F84\u3002" },
+        content: { type: "string", description: "\u8981\u5199\u5165\u7684\u5B8C\u6574\u5185\u5BB9\u3002" }
+      },
+      required: ["path", "content"]
+    }
+  }
+};
+async function writeFile2(params) {
+  const { path: filePath, content } = params;
+  try {
+    await fs5.mkdir(path4.dirname(filePath), { recursive: true });
+    await fs5.writeFile(filePath, content, "utf8");
+    return `Written ${filePath}`;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return `Error writing ${filePath}: ${msg}`;
+  }
+}
+
+// src/tools/edit.ts
+import * as fs6 from "fs/promises";
+var EDIT_TOOL = {
+  type: "function",
+  function: {
+    name: "edit",
+    description: "\u5728\u6587\u4EF6\u4E2D\u7CBE\u786E\u66FF\u6362\u4E00\u6BB5\u5B57\u7B26\u4E32\u3002old_string \u5728\u6587\u4EF6\u4E2D\u5FC5\u987B\u552F\u4E00\u51FA\u73B0\u2014\u2014\u82E5\u6709\u6B67\u4E49\u8BF7\u63D0\u4F9B\u66F4\u591A\u4E0A\u4E0B\u6587\u3002",
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "\u6587\u4EF6\u7684\u7EDD\u5BF9\u8DEF\u5F84\u6216\u76F8\u5BF9\u8DEF\u5F84\u3002" },
+        old_string: { type: "string", description: "\u8981\u67E5\u627E\u7684\u7CBE\u786E\u5B57\u7B26\u4E32\uFF08\u5728\u6587\u4EF6\u4E2D\u5FC5\u987B\u552F\u4E00\uFF09\u3002" },
+        new_string: { type: "string", description: "\u66FF\u6362\u540E\u7684\u5B57\u7B26\u4E32\u3002" }
+      },
+      required: ["path", "old_string", "new_string"]
+    }
+  }
+};
+async function editFile(params) {
+  const { path: path7, old_string, new_string } = params;
+  let content;
+  try {
+    content = await fs6.readFile(path7, "utf8");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return `Error reading ${path7}: ${msg}`;
+  }
+  const count = countOccurrences(content, old_string);
+  if (count === 0) {
+    return `Error: old_string not found in ${path7}`;
+  }
+  if (count > 1) {
+    return `Error: old_string appears ${count} times in ${path7} (ambiguous \u2014 add more context)`;
+  }
+  const updated = content.replace(old_string, new_string);
+  try {
+    await fs6.writeFile(path7, updated, "utf8");
+    return `Edited ${path7}`;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return `Error writing ${path7}: ${msg}`;
+  }
+}
+function countOccurrences(haystack, needle) {
+  if (needle === "") return 0;
+  let count = 0;
+  let pos = 0;
+  while ((pos = haystack.indexOf(needle, pos)) !== -1) {
+    count++;
+    pos += needle.length;
+  }
+  return count;
+}
+
+// src/tools/apply_patch.ts
+import * as fs7 from "fs/promises";
+import * as path5 from "path";
+var APPLY_PATCH_TOOL = {
+  type: "function",
+  function: {
+    name: "apply_patch",
+    description: "\u5C06 unified diff \u683C\u5F0F\u7684 patch \u5E94\u7528\u5230\u6587\u4EF6\u3002\u652F\u6301 context \u4E0A\u4E0B\u6587\u884C\u6A21\u7CCA\u5B9A\u4F4D\uFF08\u5141\u8BB8\u5C11\u91CF\u884C\u53F7\u504F\u79FB\uFF09\u3002",
+    parameters: {
+      type: "object",
+      properties: {
+        patch: {
+          type: "string",
+          description: "Unified diff \u683C\u5F0F\u7684 patch \u5185\u5BB9\u3002"
+        },
+        file: {
+          type: "string",
+          description: "\u76EE\u6807\u6587\u4EF6\u8DEF\u5F84\uFF08\u53EF\u9009\uFF0C\u82E5 patch \u4E2D\u5305\u542B --- / +++ \u5934\u5219\u4ECE\u4E2D\u89E3\u6790\uFF09\u3002"
+        },
+        cwd: {
+          type: "string",
+          description: "\u5DE5\u4F5C\u76EE\u5F55\uFF08\u9ED8\u8BA4 process.cwd()\uFF09\u3002"
+        },
+        dryRun: {
+          type: "boolean",
+          description: "\u82E5\u4E3A true\uFF0C\u4EC5\u6821\u9A8C patch \u662F\u5426\u80FD\u5E94\u7528\uFF0C\u4E0D\u4FEE\u6539\u6587\u4EF6\uFF08\u9ED8\u8BA4 false\uFF09\u3002"
+        }
+      },
+      required: ["patch"]
+    }
+  }
+};
+function parseFilePath(patch) {
+  for (const line of patch.split("\n")) {
+    if (line.startsWith("+++ ")) {
+      let p = line.slice(4).trim();
+      if (p.startsWith("b/")) p = p.slice(2);
+      if (p === "/dev/null" || p === "") return null;
+      return p;
+    }
+  }
+  return null;
+}
+function parseHunkHeader(header) {
+  const m = header.match(/^@@\s+-(\d+)(?:,(\d+))?\s+\+\d+(?:,\d+)?\s+@@/);
+  if (!m) return null;
+  const oldStart = parseInt(m[1], 10) - 1;
+  const oldCount = m[2] !== void 0 ? parseInt(m[2], 10) : 1;
+  return { oldStart, oldCount };
+}
+function parseHunks(patch) {
+  const rawLines = patch.split("\n");
+  const hunks = [];
+  let current = null;
+  for (const raw of rawLines) {
+    if (raw.startsWith("diff --git ")) continue;
+    if (raw.startsWith("--- ") || raw.startsWith("+++ ")) continue;
+    if (raw.startsWith("\\ ")) continue;
+    if (raw.startsWith("@@ ")) {
+      const parsed = parseHunkHeader(raw);
+      if (!parsed) continue;
+      current = {
+        header: raw,
+        oldStart: parsed.oldStart,
+        oldCount: parsed.oldCount,
+        lines: []
+      };
+      hunks.push(current);
+      continue;
+    }
+    if (current === null) continue;
+    if (raw.startsWith("+")) {
+      current.lines.push({ kind: "add", content: raw.slice(1) });
+    } else if (raw.startsWith("-")) {
+      current.lines.push({ kind: "remove", content: raw.slice(1) });
+    } else if (raw.startsWith(" ")) {
+      current.lines.push({ kind: "context", content: raw.slice(1) });
+    }
+  }
+  return hunks;
+}
+var FUZZY_RADIUS = 3;
+function fuzzyFind(fileLines, hunk, suggestedStart) {
+  const expected = hunk.lines.filter((l) => l.kind === "context" || l.kind === "remove").map((l) => l.content);
+  if (expected.length === 0) {
+    return Math.max(0, Math.min(suggestedStart, fileLines.length));
+  }
+  const lo = Math.max(0, suggestedStart - FUZZY_RADIUS);
+  const hi = Math.min(
+    fileLines.length - expected.length,
+    suggestedStart + FUZZY_RADIUS
+  );
+  for (let start = lo; start <= hi; start++) {
+    let match = true;
+    for (let i = 0; i < expected.length; i++) {
+      if (fileLines[start + i] !== expected[i]) {
+        match = false;
+        break;
+      }
+    }
+    if (match) return start;
+  }
+  return null;
+}
+function applyHunk(fileLines, hunk, actualStart) {
+  const oldLineCount = hunk.lines.filter(
+    (l) => l.kind === "context" || l.kind === "remove"
+  ).length;
+  const newBlock = [];
+  for (const hl of hunk.lines) {
+    if (hl.kind === "context" || hl.kind === "add") {
+      newBlock.push(hl.content);
+    }
+  }
+  return [
+    ...fileLines.slice(0, actualStart),
+    ...newBlock,
+    ...fileLines.slice(actualStart + oldLineCount)
+  ];
+}
+async function applyPatch(params) {
+  const { patch, file: fileParam, cwd = process.cwd(), dryRun = false } = params;
+  let filePath;
+  if (fileParam) {
+    filePath = path5.isAbsolute(fileParam) ? fileParam : path5.resolve(cwd, fileParam);
+  } else {
+    const parsed = parseFilePath(patch);
+    if (!parsed) {
+      return "Error: no target file path found in patch headers (--- / +++ missing) and no 'file' param provided";
+    }
+    filePath = path5.isAbsolute(parsed) ? parsed : path5.resolve(cwd, parsed);
+  }
+  let originalContent;
+  try {
+    originalContent = await fs7.readFile(filePath, "utf8");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return `Error: ${msg}`;
+  }
+  const hasTrailingNewline = originalContent.endsWith("\n");
+  const rawLines = originalContent.split("\n");
+  let fileLines = hasTrailingNewline ? rawLines.slice(0, -1) : rawLines;
+  const hunks = parseHunks(patch);
+  if (hunks.length === 0) {
+    return `Error: no valid hunks found in patch`;
+  }
+  let lineOffset = 0;
+  for (const hunk of hunks) {
+    const suggestedStart = hunk.oldStart + lineOffset;
+    const actualStart = fuzzyFind(fileLines, hunk, suggestedStart);
+    if (actualStart === null) {
+      return `Error: hunk ${hunk.header} does not apply (context mismatch)`;
+    }
+    const addCount = hunk.lines.filter((l) => l.kind === "add").length;
+    const removeCount = hunk.lines.filter((l) => l.kind === "remove").length;
+    fileLines = applyHunk(fileLines, hunk, actualStart);
+    lineOffset += addCount - removeCount;
+  }
+  const displayPath = path5.relative(cwd, filePath) || filePath;
+  if (dryRun) {
+    return `Patch applies cleanly to ${displayPath} (dry run)`;
+  }
+  const newContent = fileLines.join("\n") + (hasTrailingNewline ? "\n" : "");
+  try {
+    await fs7.writeFile(filePath, newContent, "utf8");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return `Error: failed to write file: ${msg}`;
+  }
+  return `Applied ${hunks.length} hunk(s) to ${displayPath}`;
+}
+
+// src/tools/todo.ts
+var TODO_TOOL = {
+  type: "function",
+  function: {
+    name: "todo",
+    description: "\u7BA1\u7406\u5F53\u524D\u4F1A\u8BDD\u7684\u4EFB\u52A1\u6E05\u5355\u3002op=read \u8BFB\u53D6\uFF0Cop=write \u5168\u91CF\u8986\u5199\uFF0Cop=update \u66F4\u65B0\u5355\u9879\u3002",
+    parameters: {
+      type: "object",
+      properties: {
+        op: {
+          type: "string",
+          enum: ["read", "write", "update"],
+          description: "\u64CD\u4F5C\u7C7B\u578B\u3002"
+        },
+        todos: {
+          type: "array",
+          description: "write \u64CD\u4F5C\uFF1A\u5168\u91CF\u66FF\u6362\u7684\u4EFB\u52A1\u5217\u8868\u3002",
+          items: {
+            type: "object",
+            properties: {
+              id: { type: "string" },
+              content: { type: "string" },
+              status: {
+                type: "string",
+                enum: ["pending", "in_progress", "completed", "cancelled"]
+              }
+            },
+            required: ["id", "content", "status"]
+          }
+        },
+        id: {
+          type: "string",
+          description: "update \u64CD\u4F5C\uFF1A\u76EE\u6807\u4EFB\u52A1\u7684\u552F\u4E00 id\u3002"
+        },
+        status: {
+          type: "string",
+          enum: ["pending", "in_progress", "completed", "cancelled"],
+          description: "update \u64CD\u4F5C\uFF1A\u65B0\u72B6\u6001\uFF08\u53EF\u9009\uFF09\u3002"
+        },
+        content: {
+          type: "string",
+          description: "update \u64CD\u4F5C\uFF1A\u65B0\u5185\u5BB9\uFF08\u53EF\u9009\uFF09\u3002"
+        }
+      },
+      required: ["op"]
+    }
+  }
+};
+var _todos = [];
+var STATUS_SYMBOL = {
+  pending: "[ ]",
+  in_progress: "[~]",
+  completed: "[x]",
+  cancelled: "[-]"
+};
+function opRead() {
+  if (_todos.length === 0) {
+    return "(no todos)";
+  }
+  return _todos.map((item) => `- ${STATUS_SYMBOL[item.status]} ${item.id}: ${item.content}`).join("\n");
+}
+function opWrite(params) {
+  if (params.todos === void 0) {
+    return "Error: write operation requires 'todos' parameter";
+  }
+  _todos = params.todos.map((t) => ({ ...t }));
+  return `Wrote ${_todos.length} todos.`;
+}
+function opUpdate(params) {
+  if (params.id === void 0) {
+    return "Error: update operation requires 'id' parameter";
+  }
+  if (params.status === void 0 && params.content === void 0) {
+    return "Error: update operation requires at least 'status' or 'content' parameter";
+  }
+  const idx = _todos.findIndex((t) => t.id === params.id);
+  if (idx === -1) {
+    return `Error: todo '${params.id}' not found`;
+  }
+  const updated = {
+    ..._todos[idx],
+    ...params.status !== void 0 ? { status: params.status } : {},
+    ...params.content !== void 0 ? { content: params.content } : {}
+  };
+  _todos = [
+    ..._todos.slice(0, idx),
+    updated,
+    ..._todos.slice(idx + 1)
+  ];
+  return `Updated todo ${params.id}.`;
+}
+function todo(params) {
+  switch (params.op) {
+    case "read":
+      return opRead();
+    case "write":
+      return opWrite(params);
+    case "update":
+      return opUpdate(params);
+    default: {
+      const unknownOp = params.op;
+      return `Error: unknown op '${unknownOp}'`;
+    }
+  }
+}
+
+// src/tools/task.ts
+import * as crypto from "crypto";
+import * as path6 from "path";
+
+// src/subagent/runtime.ts
+async function runSubagentRuntime(options) {
+  const { messages: initial, tools, provider, maxTurns, executeToolCall, onOutput } = options;
+  const messages = [...initial];
+  let turnCount = 0;
+  while (turnCount < maxTurns) {
+    turnCount++;
+    let assistantText = "";
+    const toolCalls = [];
+    for await (const chunk of provider.stream(messages, tools)) {
+      if (chunk.text) {
+        assistantText += chunk.text;
+        onOutput == null ? void 0 : onOutput(chunk.text);
+      }
+      if (chunk.done && chunk.toolCalls) {
+        toolCalls.push(...chunk.toolCalls);
+      }
+    }
+    if (toolCalls.length === 0) {
+      messages.push({ role: "assistant", content: assistantText });
+      return { success: true, finalText: assistantText, turnCount };
+    }
+    messages.push({
+      role: "assistant",
+      content: assistantText || null,
+      tool_calls: toolCalls.map((tc) => ({
+        id: tc.id,
+        type: "function",
+        function: { name: tc.name, arguments: tc.arguments }
+      }))
+    });
+    for (const tc of toolCalls) {
+      const result = await executeToolCall(tc);
+      messages.push({ role: "tool", tool_call_id: tc.id, content: result });
+    }
+  }
+  return {
+    success: false,
+    finalText: "",
+    turnCount,
+    error: `Subagent exceeded max turns (${maxTurns})`
+  };
+}
+
+// src/repl.ts
+import * as readline from "readline";
+
+// src/safety.ts
+var ALLOWLIST = [
+  "ls",
+  "cat",
+  "pwd",
+  "echo",
+  "head",
+  "tail",
+  "wc",
+  "date",
+  "whoami",
+  "which",
+  "printenv"
+  // "env" 故意排除：env <CMD> 会执行任意子命令，不适合 allow 级别。
+  // 仅显示环境变量的 printenv 保留在白名单。
+];
+var DEFAULT_DANGER_LIST = [
+  "rm -rf",
+  "sudo",
+  "chmod",
+  "chown",
+  "mkfs",
+  "dd",
+  "fdisk",
+  "kill",
+  "pkill",
+  "killall",
+  "reboot",
+  "shutdown",
+  "halt",
+  "curl -X DELETE",
+  "wget --delete-after"
+];
+var INDIRECT_EXEC_LIST = [
+  "xargs",
+  "python -c",
+  "python3 -c",
+  "node -e",
+  "perl -e",
+  "ruby -e",
+  // eval 执行任意字符串作为 shell 命令，无论 payload 内容如何都视为危险。
+  // 与 xargs/python -c 的性质相同：执行能力本身就是风险。
+  "eval"
+];
+function hasFindExec(cmd) {
+  return /^find(\s|$)/.test(cmd) && /\s-exec(\s|$)/.test(cmd);
+}
+function matchesEntry(cmd, entry) {
+  return cmd === entry || cmd.startsWith(entry + " ");
+}
+function splitByControlOps(cmd) {
+  const segments = [];
+  let current = "";
+  let inSingle = false;
+  let inDouble = false;
+  let i = 0;
+  while (i < cmd.length) {
+    const ch = cmd[i];
+    if (ch === "'" && !inDouble) {
+      inSingle = !inSingle;
+      current += ch;
+      i++;
+      continue;
+    }
+    if (ch === '"' && !inSingle) {
+      inDouble = !inDouble;
+      current += ch;
+      i++;
+      continue;
+    }
+    if (inSingle || inDouble) {
+      if (inDouble && ch === "\\" && i + 1 < cmd.length) {
+        current += ch + cmd[i + 1];
+        i += 2;
+      } else {
+        current += ch;
+        i++;
+      }
+      continue;
+    }
+    if (ch === "&" && cmd[i + 1] === "&") {
+      segments.push(current.trim());
+      current = "";
+      i += 2;
+      continue;
+    }
+    if (ch === "|" && cmd[i + 1] === "|") {
+      segments.push(current.trim());
+      current = "";
+      i += 2;
+      continue;
+    }
+    if (ch === ";" || ch === "|") {
+      segments.push(current.trim());
+      current = "";
+      i++;
+      continue;
+    }
+    current += ch;
+    i++;
+  }
+  segments.push(current.trim());
+  return segments.filter((s) => s.length > 0);
+}
+function stripShellWrapper(cmd) {
+  const trimmed = cmd.trim();
+  const shellMatch = trimmed.match(/^(bash|sh)\s+([\s\S]*)/);
+  if (!shellMatch) return trimmed;
+  let rest = shellMatch[2];
+  let hasCFlag = false;
+  while (rest.length > 0) {
+    const flagMatch = rest.match(/^(-\w+)\s*([\s\S]*)/);
+    if (!flagMatch) break;
+    const flag = flagMatch[1];
+    rest = flagMatch[2];
+    if (flag.includes("c")) {
+      hasCFlag = true;
+      rest = rest.trimStart();
+      break;
+    }
+    rest = rest.trimStart();
+  }
+  if (!hasCFlag || !rest.length) return trimmed;
+  if (rest.startsWith('"')) {
+    const m = rest.match(/^"((?:[^"\\]|\\.)*)"/);
+    if (m) return m[1];
+  } else if (rest.startsWith("'")) {
+    const m = rest.match(/^'([^']*)'/);
+    if (m) return m[1];
+  } else {
+    const m = rest.match(/^(\S+)/);
+    if (m) return m[1];
+  }
+  return trimmed;
+}
+function stripEnvWrapper(cmd) {
+  const trimmed = cmd.trim();
+  if (!trimmed.startsWith("env ") && trimmed !== "env") return trimmed;
+  let rest = trimmed.slice(3).trimStart();
+  while (rest.length > 0) {
+    const assignMatch = rest.match(/^(\w+=\S*)\s*([\s\S]*)/);
+    if (!assignMatch) break;
+    rest = assignMatch[2].trimStart();
+  }
+  if (!rest.length) return trimmed;
+  return rest;
+}
+function stripCommandWrapper(cmd) {
+  const trimmed = cmd.trim();
+  const m = trimmed.match(/^command\s+([\s\S]+)/);
+  if (m) return m[1].trimStart();
+  return trimmed;
+}
+function classifyCommand(cmd, dangerPatterns, _depth = 0) {
+  const trimmed = cmd.trim();
+  const patterns = dangerPatterns ?? DEFAULT_DANGER_LIST;
+  if (_depth < 5) {
+    const shellInner = stripShellWrapper(trimmed);
+    if (shellInner !== trimmed) {
+      if (classifyCommand(shellInner.trim(), dangerPatterns, _depth + 1) === "danger") return "danger";
+      return "normal";
+    }
+    const envInner = stripEnvWrapper(trimmed);
+    if (envInner !== trimmed) {
+      if (classifyCommand(envInner.trim(), dangerPatterns, _depth + 1) === "danger") return "danger";
+      return "normal";
+    }
+    const commandInner = stripCommandWrapper(trimmed);
+    if (commandInner !== trimmed) {
+      if (classifyCommand(commandInner.trim(), dangerPatterns, _depth + 1) === "danger") return "danger";
+      return "normal";
+    }
+  }
+  const segments = splitByControlOps(trimmed);
+  if (segments.length > 1) {
+    for (const seg of segments) {
+      if (classifyCommand(seg, dangerPatterns, _depth + 1) === "danger") {
+        return "danger";
+      }
+    }
+    return "normal";
+  }
+  for (const entry of patterns) {
+    if (matchesEntry(trimmed, entry)) return "danger";
+  }
+  for (const entry of INDIRECT_EXEC_LIST) {
+    if (matchesEntry(trimmed, entry)) return "danger";
+  }
+  if (hasFindExec(trimmed)) return "danger";
+  for (const entry of ALLOWLIST) {
+    if (matchesEntry(trimmed, entry)) return "allow";
+  }
+  return "normal";
+}
+
+// src/prompts.ts
+var DEFAULT_SYSTEM_PROMPT = `You are ecode, a terminal-based coding assistant focused on software engineering work.
+
+Your job is to help the user complete coding tasks accurately, efficiently, and safely. Prefer doing useful work over discussing work abstractly, but do not pretend to have done things you did not do.
+
+# Core behavior
+
+- Treat the user's request as a real software engineering task unless they clearly ask for pure explanation.
+- Read relevant code before proposing or making changes.
+- Understand the local context before editing. Do not guess how the codebase works when you can inspect it.
+- Prefer the simplest approach that fully solves the requested problem.
+- Do not add features, refactors, configurability, abstractions, or cleanups that were not requested unless they are necessary to complete the task correctly.
+- Do not make speculative improvements for hypothetical future needs.
+- If an approach fails, diagnose the reason before switching tactics. Do not blindly retry the same failing action.
+
+# Editing discipline
+
+- Prefer dedicated file tools over shell commands when available.
+- Use read-like tools to inspect files, edit/patch tools to modify files, and write tools only when replacing full file content is the right choice.
+- Do not use shell tricks as a substitute for structured file operations when a dedicated tool exists.
+- Make the smallest coherent change that solves the problem.
+- Do not create new files unless they are actually needed.
+- Do not rewrite large files when a targeted edit is enough.
+- Preserve existing code style unless the task explicitly requires style changes.
+- Do not add comments unless they help explain a non-obvious constraint or decision.
+
+# Tool usage
+
+- Prefer dedicated tools over bash for file reading, file editing, search, patching, and task tracking.
+- Use bash for commands that are genuinely shell-oriented: tests, builds, git inspection, package manager commands, environment inspection, and other terminal operations.
+- When there are multiple independent lookups, do them efficiently. When steps depend on each other, do them in order.
+- Treat tool output as evidence. Base conclusions on what you actually observed.
+- If tool output is noisy, extract and carry forward only the important facts.
+
+# Safety and confirmation
+
+- Be careful with destructive, irreversible, or externally visible actions.
+- Ask before actions like deleting important files, overwriting significant uncommitted work, force-pushing, changing remote state, sending messages, or performing other hard-to-reverse operations.
+- Do not treat a previous approval as blanket approval for future risky actions.
+- If the user denies a risky action, do not immediately retry the same action. Adjust your plan.
+- Safety checks are a convenience layer, not a guarantee. Act cautiously even when a command appears allowed.
+
+# Verification and honesty
+
+- When you change code, verify the result when practical: run tests, type checks, linters, builds, or the narrowest useful validation step.
+- Prefer the smallest meaningful verification rather than expensive blanket verification when the task is local and narrow.
+- If you could not verify something, say so plainly.
+- Never claim success, passing tests, or completed work unless the evidence supports it.
+- If a command failed, a test failed, or verification is incomplete, report that accurately.
+
+# Communication style
+
+- Be concise, direct, and useful.
+- Give short progress updates when starting multi-step work, when you discover something important, when changing direction, or when blocked.
+- Do not narrate every obvious tool call.
+- Do not pad responses with filler, hype, or unnecessary repetition.
+- When reporting completion, lead with what changed, then include relevant verification or blockers.
+- When you need user input, ask for the single most important missing decision.
+
+# Scope control
+
+- Solve the requested problem completely, but do not quietly widen scope.
+- If you notice an adjacent issue that matters, mention it briefly and separate it from the requested task.
+- Favor correctness and clarity over cleverness.
+
+# Failure mode handling
+
+- If paths, commands, or assumptions are wrong, correct course based on inspection rather than defending the original plan.
+- If you are blocked by missing information, say exactly what is missing.
+- If you are blocked by tool limits, choose the next best bounded action instead of stalling.`;
+
+// src/repl.ts
+var SKIP_MESSAGE = "Command skipped by user.";
+var BASH_TOOL = {
+  type: "function",
+  function: {
+    name: "bash",
+    description: "Execute a shell command and return its output.",
+    parameters: {
+      type: "object",
+      properties: {
+        command: { type: "string", description: "The shell command to run." }
+      },
+      required: ["command"]
+    }
+  }
+};
+async function handleBashTool(command, deps) {
+  const { confirm, print, dangerousPatterns, autoApproveNormal } = deps;
+  const cls = classifyCommand(command, dangerousPatterns);
+  if (cls === "normal") {
+    if (!autoApproveNormal) {
+      const ok = await confirm(`Execute command: ${command}
+Proceed? (y/n) `);
+      if (!ok) return SKIP_MESSAGE;
+    }
+  } else if (cls === "danger") {
+    print(`\u26A0\uFE0F  DANGEROUS COMMAND: ${command}`);
+    const first = await confirm("Are you sure? (y/n) ");
+    if (!first) return SKIP_MESSAGE;
+    const second = await confirm(
+      "Confirm again \u2014 this is destructive. Continue? (y/n) "
+    );
+    if (!second) return SKIP_MESSAGE;
+  }
+  const result = await deps.executeBash(command);
+  let output = "";
+  if (result.stdout) output += result.stdout;
+  if (result.stderr) output += result.stderr;
+  if (result.exitCode !== 0) output += `
+[exit code: ${result.exitCode}]`;
+  return output || "(no output)";
+}
+
+// src/tools/task.ts
+var TASK_TOOL = {
+  type: "function",
+  function: {
+    name: "task",
+    description: "Delegate a well-defined subtask to an isolated child agent. The child agent runs its own agentic loop, executes tools, and returns a single result. Use this when a subtask is independent, well-scoped, and benefits from a clean context.",
+    parameters: {
+      type: "object",
+      properties: {
+        description: {
+          type: "string",
+          description: "Short title for the subtask (used in logs and status output)."
+        },
+        prompt: {
+          type: "string",
+          description: "Full task instructions for the child agent."
+        },
+        context: {
+          type: "string",
+          description: "Optional additional context to pass to the child agent."
+        },
+        cwd: {
+          type: "string",
+          description: "Working directory for the child agent (defaults to current directory)."
+        },
+        model: {
+          type: "string",
+          description: "Optional model override for the child agent."
+        },
+        max_turns: {
+          type: "number",
+          description: "Maximum agentic loop turns for the child agent (default: 8)."
+        }
+      },
+      required: ["description", "prompt"]
+    }
+  }
+};
+var SUBAGENT_SYSTEM_PROMPT = `You are a focused subagent executing a delegated task on behalf of a parent agent.
+
+Rules:
+- Complete the task independently using the tools available to you.
+- Do not ask the human clarifying questions for routine operations \u2014 make reasonable decisions.
+- When done, return a clear, concise result.
+- If you are blocked, describe the blocker and the minimum next step needed.
+- You cannot delegate tasks to other agents.`;
+var SUBAGENT_TOOLS = [
+  BASH_TOOL,
+  READ_TOOL,
+  WRITE_TOOL,
+  EDIT_TOOL,
+  GLOB_TOOL,
+  GREP_TOOL,
+  APPLY_PATCH_TOOL,
+  TODO_TOOL
+];
+async function handleTaskTool(args, deps) {
+  const { description, prompt, context, max_turns = 8 } = args;
+  const { provider, print = () => void 0, logDir } = deps;
+  const taskId = crypto.randomUUID().slice(0, 8);
+  let logger;
+  if (logDir) {
+    logger = createLogger(logDir, /* @__PURE__ */ new Date());
+    const meta = createSessionMetadata(logger.filePath, "subagent");
+    writeSessionMetadata(logger.filePath, {
+      ...meta,
+      title: `[subagent] ${description}`
+    });
+  }
+  const userContent = context ? `Context:
+${context}
+
+Task:
+${prompt}` : prompt;
+  const messages = [
+    { role: "system", content: SUBAGENT_SYSTEM_PROMPT },
+    { role: "user", content: userContent }
+  ];
+  if (logger) {
+    logger.append({ ts: (/* @__PURE__ */ new Date()).toISOString(), role: "user", content: userContent });
+  }
+  const bashDeps = {
+    executeBash,
+    confirm: async () => false,
+    // danger commands will be denied
+    print,
+    autoApproveNormal: true
+  };
+  const executeToolCall = async (tc) => {
+    let result;
+    if (tc.name === "bash") {
+      const tcArgs = JSON.parse(tc.arguments);
+      result = await handleBashTool(tcArgs.command, bashDeps);
+    } else if (tc.name === "read") {
+      const tcArgs = JSON.parse(tc.arguments);
+      result = await readFile3(tcArgs);
+    } else if (tc.name === "write") {
+      const tcArgs = JSON.parse(tc.arguments);
+      result = await writeFile2(tcArgs);
+    } else if (tc.name === "edit") {
+      const tcArgs = JSON.parse(tc.arguments);
+      result = await editFile(tcArgs);
+    } else if (tc.name === "glob") {
+      const tcArgs = JSON.parse(tc.arguments);
+      result = await globFiles(tcArgs);
+    } else if (tc.name === "grep") {
+      const tcArgs = JSON.parse(tc.arguments);
+      result = await grepFiles(tcArgs);
+    } else if (tc.name === "apply_patch") {
+      const tcArgs = JSON.parse(tc.arguments);
+      result = await applyPatch(tcArgs);
+    } else if (tc.name === "todo") {
+      const tcArgs = JSON.parse(tc.arguments);
+      result = todo(tcArgs);
+    } else {
+      result = `Unknown tool: ${tc.name}`;
+    }
+    if (logger) {
+      logger.append({
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        role: "tool",
+        content: result,
+        tool_call_id: tc.id
+      });
+    }
+    return result;
+  };
+  const runtime = await runSubagentRuntime({
+    messages,
+    tools: SUBAGENT_TOOLS,
+    provider,
+    maxTurns: max_turns,
+    executeToolCall,
+    onOutput: (text) => print(text)
+  });
+  if (logger) {
+    logger.append({
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      role: "assistant",
+      content: runtime.finalText || runtime.error || null
+    });
+    updateSessionMetadata(logger.filePath, {
+      lastActivity: (/* @__PURE__ */ new Date()).toISOString(),
+      turnCount: runtime.turnCount,
+      title: `[subagent] ${description}`
+    });
+  }
+  const logLine = logger ? `log_file: ${path6.basename(logger.filePath)}
+` : "";
+  if (!runtime.success) {
+    return [
+      `task_id: ${taskId}`,
+      `description: ${description}`,
+      logLine.trim(),
+      "",
+      `<task_result>`,
+      `Error: ${runtime.error ?? "Subagent failed"}`,
+      `</task_result>`
+    ].filter((l) => l !== "" || l === "").join("\n").replace(/\n{3,}/g, "\n\n");
+  }
+  return [
+    `task_id: ${taskId}`,
+    `description: ${description}`,
+    logLine.trim(),
+    "",
+    `<task_result>`,
+    runtime.finalText,
+    `</task_result>`
+  ].join("\n").replace(/\n{3,}/g, "\n\n");
+}
+
+export {
+  createProvider,
+  resolveActiveProfile,
+  isTrustedSkillPath,
+  loadSkillsFromDir,
+  READ_TOOL,
+  readFile3 as readFile,
+  GLOB_TOOL,
+  globFiles,
+  GREP_TOOL,
+  grepFiles,
+  WEB_FETCH_TOOL,
+  webFetch,
+  createLogger,
+  DEFAULT_SYSTEM_PROMPT,
+  classifyCommand,
+  executeBash,
+  WRITE_TOOL,
+  writeFile2 as writeFile,
+  EDIT_TOOL,
+  editFile,
+  APPLY_PATCH_TOOL,
+  applyPatch,
+  TODO_TOOL,
+  todo,
+  TASK_TOOL,
+  handleTaskTool,
+  SKIP_MESSAGE,
+  BASH_TOOL,
+  handleBashTool
+};