@linghun/tools 0.1.0

package/dist/index.js

@@ -0,0 +1,1753 @@
+import {
+  applyDomainFilter,
+  bingSearch,
+  formatSearchOutput
+} from "./chunk-EPIB4FSE.js";
+import {
+  formatFetchOutput,
+  webFetch
+} from "./chunk-4UHQWBFA.js";
+import {
+  createTool
+} from "./chunk-MMJX44V6.js";
+import {
+  toolPrompts
+} from "./chunk-KGDJAST5.js";
+import {
+  toolUserFacingNames
+} from "./chunk-NKWRH36V.js";
+import "./chunk-4EZHIDZ6.js";
+import "./chunk-YR4HWOR2.js";
+import "./chunk-VAFW24RN.js";
+import "./chunk-I3Z4OKMS.js";
+import "./chunk-PS2ZOFZ6.js";
+import "./chunk-NPKLGVDQ.js";
+import "./chunk-VJDLOFCF.js";
+import "./chunk-3RP665TH.js";
+import "./chunk-IOC3BSPT.js";
+import "./chunk-LGZOG7IQ.js";
+import "./chunk-ZYAEUABC.js";
+import "./chunk-SWK6XRZQ.js";
+import "./chunk-AZCQL24J.js";
+import "./chunk-HUIZOB4A.js";
+import "./chunk-MK3YP2VR.js";
+import "./chunk-RBHQ5WNR.js";
+import "./chunk-HNIVNZIS.js";
+import "./chunk-K3YDFDLP.js";
+import "./chunk-4567YAXM.js";
+import "./chunk-XZWSO5CM.js";
+import "./chunk-SZFZPQGL.js";
+import "./chunk-DN3KJZRV.js";
+import "./chunk-2U4BZXAI.js";
+import "./chunk-ITBZHMZQ.js";
+import "./chunk-WLQ7DGMG.js";
+import "./chunk-SQP6SJRP.js";
+import "./chunk-BRG64AEC.js";
+import "./chunk-VZWMPUSS.js";
+import "./chunk-E75PYM7V.js";
+import "./chunk-GAWMEMXB.js";
+import "./chunk-7ZOADACP.js";
+import "./chunk-H5OOD2OS.js";
+import "./chunk-IQP3XE32.js";
+
+// src/index.ts
+import { spawn } from "child_process";
+import { createHash, randomUUID } from "crypto";
+import { mkdir, readFile, readdir, stat, writeFile } from "fs/promises";
+import { basename, dirname, isAbsolute, join, relative, resolve } from "path";
+var toolRegistryStatus = "ready";
+var DEFAULT_LIMIT = 200;
+var DEFAULT_SEARCH_LIMIT = 100;
+var DEFAULT_TOOL_TEXT_LIMIT = 5e4;
+var BASH_PREVIEW_LIMIT = 3e4;
+var BASH_TIMEOUT_MS = 12e4;
+var MAX_TODO_ITEMS = 100;
+var SEARCH_EXCLUDED_DIR_NAMES = ["node_modules", "dist", ".git", ".codebase-memory"];
+var SEARCH_EXCLUDED_PATH_PREFIXES = [".linghun/logs", ".linghun/agent-runs", ".linghun/failures"];
+var SEARCH_EXCLUDED_FILE_SUFFIXES = [".tsbuildinfo"];
+var RG_TIMEOUT_MS = 3e4;
+function createToolContext(workspaceRoot = process.cwd()) {
+  return {
+    workspaceRoot: resolve(workspaceRoot),
+    changedFiles: [],
+    todos: [],
+    readSnapshots: {},
+    patchSummaries: {}
+  };
+}
+async function runTool(name, input, context) {
+  const tool = builtInTools[name];
+  if (!tool) {
+    throw new Error(`\u672A\u77E5\u5DE5\u5177\uFF1A${name}`);
+  }
+  if (!tool.lifecycle.enabled) {
+    throw new Error(`\u5DE5\u5177\u5DF2\u7981\u7528\uFF1A${name}\u3002\u5EFA\u8BAE\uFF1A\u8FD0\u884C /features \u6216 /doctor \u67E5\u770B\u5F53\u524D\u80FD\u529B\u8FB9\u754C\u3002`);
+  }
+  const validatedInput = tool.validateInput(input);
+  const output = await tool.call(validatedInput, context);
+  return {
+    id: randomUUID(),
+    name,
+    input: validatedInput,
+    output: normalizeToolOutput(output, tool)
+  };
+}
+function defineTool(definition) {
+  return createTool(definition);
+}
+var toolDefinitions = {
+  Read: defineTool({
+    name: "Read",
+    title: "\u8BFB\u53D6\u6587\u4EF6",
+    description: "\u8BFB\u53D6\u5DE5\u4F5C\u533A\u6587\u4EF6\u5185\u5BB9\u3002",
+    permission: {
+      risk: "low",
+      scope: "workspace",
+      reason: "\u53EA\u8BFB\u67E5\u770B\u6587\u4EF6\u5185\u5BB9\u3002",
+      phase06Mode: "metadata-only"
+    },
+    isReadOnly: true,
+    isConcurrencySafe: true,
+    lifecycle: readOnlyLifecycle(),
+    validateInput: validateReadInput,
+    call: readTool,
+    prompt: () => toolPrompts.Read,
+    userFacingName: () => toolUserFacingNames.Read,
+    getToolUseSummary: (input) => `Read ${input.path}`,
+    getActivityDescription: (input) => `Reading ${input.path}`
+  }),
+  Write: defineTool({
+    name: "Write",
+    title: "\u5199\u5165\u6587\u4EF6",
+    description: "\u5728\u5DE5\u4F5C\u533A\u5185\u5199\u5165\u5B8C\u6574\u6587\u4EF6\u5185\u5BB9\u3002",
+    permission: {
+      risk: "medium",
+      scope: "workspace",
+      reason: "\u4F1A\u4FEE\u6539\u5DE5\u4F5C\u533A\u6587\u4EF6\uFF0CPhase 06 \u5C06\u63A5\u5165\u6743\u9650\u5BA1\u6279\u3002",
+      phase06Mode: "metadata-only"
+    },
+    isReadOnly: false,
+    isConcurrencySafe: false,
+    lifecycle: writeLifecycle(),
+    validateInput: validateWriteInput,
+    call: writeTool,
+    prompt: () => toolPrompts.Write,
+    userFacingName: () => toolUserFacingNames.Write,
+    getToolUseSummary: (input) => `Write ${input.path}`,
+    getActivityDescription: (input) => `Writing ${input.path}`
+  }),
+  Edit: defineTool({
+    name: "Edit",
+    title: "\u7F16\u8F91\u6587\u4EF6",
+    description: "\u5728\u5DE5\u4F5C\u533A\u5185\u505A\u552F\u4E00\u5B57\u7B26\u4E32\u66FF\u6362\u3002",
+    permission: {
+      risk: "low",
+      scope: "workspace",
+      reason: "\u4F1A\u5728\u5DE5\u4F5C\u533A\u5185\u505A\u5355\u6587\u4EF6\u552F\u4E00\u5B57\u7B26\u4E32\u66FF\u6362\uFF0C\u5C5E\u4E8E\u4F4E\u98CE\u9669\u7F16\u8F91\u3002",
+      phase06Mode: "metadata-only"
+    },
+    isReadOnly: false,
+    isConcurrencySafe: false,
+    lifecycle: writeLifecycle(),
+    validateInput: validateEditInput,
+    call: editTool,
+    prompt: () => toolPrompts.Edit,
+    userFacingName: () => toolUserFacingNames.Edit,
+    getToolUseSummary: (input) => `Edit ${input.path}`,
+    getActivityDescription: (input) => `Editing ${input.path}`
+  }),
+  MultiEdit: defineTool({
+    name: "MultiEdit",
+    title: "\u6279\u91CF\u7F16\u8F91\u6587\u4EF6",
+    description: "\u5728\u540C\u4E00\u6587\u4EF6\u5185\u6309\u987A\u5E8F\u505A\u591A\u4E2A\u552F\u4E00\u5B57\u7B26\u4E32\u66FF\u6362\u3002",
+    permission: {
+      risk: "medium",
+      scope: "workspace",
+      reason: "\u4F1A\u4FEE\u6539\u5DE5\u4F5C\u533A\u6587\u4EF6\uFF0C\u5E76\u9010\u9879\u8981\u6C42 oldText \u552F\u4E00\u3002",
+      phase06Mode: "metadata-only"
+    },
+    isReadOnly: false,
+    isConcurrencySafe: false,
+    lifecycle: writeLifecycle(),
+    validateInput: validateMultiEditInput,
+    call: multiEditTool,
+    prompt: () => toolPrompts.MultiEdit,
+    userFacingName: () => toolUserFacingNames.MultiEdit,
+    getToolUseSummary: (input) => `MultiEdit ${input.path} (${input.edits.length} edits)`,
+    getActivityDescription: (input) => `Editing ${input.path}`
+  }),
+  Grep: defineTool({
+    name: "Grep",
+    title: "\u641C\u7D22\u6587\u672C",
+    description: "\u5728\u5DE5\u4F5C\u533A\u5185\u6309\u6B63\u5219\u641C\u7D22\u6587\u672C\u3002",
+    permission: {
+      risk: "low",
+      scope: "workspace",
+      reason: "\u53EA\u8BFB\u641C\u7D22\u6587\u4EF6\u5185\u5BB9\u3002",
+      phase06Mode: "metadata-only"
+    },
+    isReadOnly: true,
+    isConcurrencySafe: true,
+    lifecycle: readOnlyLifecycle(),
+    validateInput: validateGrepInput,
+    call: grepTool,
+    prompt: () => toolPrompts.Grep,
+    userFacingName: () => toolUserFacingNames.Grep,
+    getToolUseSummary: (input) => `Grep ${input.pattern}`,
+    getActivityDescription: (input) => `Searching ${input.path ?? "."}`
+  }),
+  Glob: defineTool({
+    name: "Glob",
+    title: "\u5339\u914D\u6587\u4EF6",
+    description: "\u5728\u5DE5\u4F5C\u533A\u5185\u6309 glob \u6A21\u5F0F\u5339\u914D\u6587\u4EF6\u3002",
+    permission: {
+      risk: "low",
+      scope: "workspace",
+      reason: "\u53EA\u8BFB\u5217\u51FA\u6587\u4EF6\u8DEF\u5F84\u3002",
+      phase06Mode: "metadata-only"
+    },
+    isReadOnly: true,
+    isConcurrencySafe: true,
+    lifecycle: readOnlyLifecycle(),
+    validateInput: validateGlobInput,
+    call: globTool,
+    prompt: () => toolPrompts.Glob,
+    userFacingName: () => toolUserFacingNames.Glob,
+    getToolUseSummary: (input) => `Glob ${input.pattern}`,
+    getActivityDescription: (input) => `Matching ${input.path ?? "."}`
+  }),
+  Bash: defineTool({
+    name: "Bash",
+    title: "\u6267\u884C\u547D\u4EE4",
+    description: "\u5728\u5DE5\u4F5C\u533A\u5185\u6267\u884C shell \u547D\u4EE4\u5E76\u4FDD\u5B58\u5B8C\u6574\u65E5\u5FD7\u3002",
+    permission: {
+      risk: "high",
+      scope: "command",
+      reason: "\u4F1A\u6267\u884C\u672C\u5730\u547D\u4EE4\uFF1BPhase 05 \u4EC5\u58F0\u660E\u98CE\u9669\uFF0CPhase 06 \u63A5\u5165\u5BA1\u6279\u3002",
+      phase06Mode: "metadata-only"
+    },
+    isReadOnly: false,
+    isConcurrencySafe: false,
+    isLongRunning: true,
+    lifecycle: bashLifecycle(),
+    validateInput: validateBashInput,
+    call: bashTool,
+    prompt: () => toolPrompts.Bash,
+    userFacingName: () => toolUserFacingNames.Bash,
+    getToolUseSummary: (input) => `Bash ${input.command}`,
+    getActivityDescription: () => "Running command"
+  }),
+  Todo: defineTool({
+    name: "Todo",
+    title: "\u4EFB\u52A1\u5217\u8868",
+    description: "\u7EF4\u62A4\u5F53\u524D\u4F1A\u8BDD\u4EFB\u52A1\u3001\u5B8C\u6210\u9879\u548C\u963B\u585E\u9879\u3002",
+    permission: {
+      risk: "low",
+      scope: "session",
+      reason: "\u53EA\u4FEE\u6539\u5F53\u524D\u4F1A\u8BDD\u5185\u4EFB\u52A1\u72B6\u6001\u3002",
+      phase06Mode: "metadata-only"
+    },
+    isReadOnly: false,
+    isConcurrencySafe: false,
+    lifecycle: sessionLifecycle(),
+    validateInput: validateTodoInput,
+    call: todoTool,
+    prompt: () => toolPrompts.Todo,
+    userFacingName: () => toolUserFacingNames.Todo,
+    getToolUseSummary: (input) => `Todo ${input.action}`,
+    getActivityDescription: (input) => `Updating todo ${input.action}`
+  }),
+  Diff: defineTool({
+    name: "Diff",
+    title: "\u6539\u52A8\u6458\u8981",
+    description: "\u8F93\u51FA\u672C\u8F6E\u5DE5\u5177\u6539\u52A8\u6587\u4EF6\u5217\u8868\u548C\u6458\u8981\u3002",
+    permission: {
+      risk: "low",
+      scope: "workspace",
+      reason: "\u53EA\u8BFB\u6C47\u603B\u672C\u8F6E changedFiles\u3002",
+      phase06Mode: "metadata-only"
+    },
+    isReadOnly: true,
+    isConcurrencySafe: true,
+    lifecycle: readOnlyLifecycle(),
+    validateInput: validateDiffInput,
+    call: diffTool,
+    prompt: () => toolPrompts.Diff,
+    userFacingName: () => toolUserFacingNames.Diff,
+    getToolUseSummary: () => "Diff summary",
+    getActivityDescription: () => "Summarizing changes"
+  }),
+  WebSearch: defineTool({
+    name: "WebSearch",
+    title: "\u641C\u7D22\u7F51\u9875",
+    description: "\u901A\u8FC7 Bing \u641C\u7D22\u4E92\u8054\u7F51\uFF0C\u8FD4\u56DE\u6807\u9898\u3001\u94FE\u63A5\u548C\u6458\u8981\u3002\u96F6 API Key\uFF0C\u56FD\u5185\u76F4\u8FDE\u3002",
+    permission: {
+      risk: "low",
+      scope: "session",
+      reason: "\u53EA\u8BFB\u641C\u7D22\u516C\u5F00\u7F51\u9875\u4FE1\u606F\uFF0C\u4E0D\u6D89\u53CA\u5DE5\u4F5C\u533A\u6587\u4EF6\u3002",
+      phase06Mode: "metadata-only"
+    },
+    isReadOnly: true,
+    isConcurrencySafe: true,
+    lifecycle: {
+      enabled: true,
+      destructive: false,
+      interruptBehavior: "abortable",
+      maxResultSizeChars: 2e4
+    },
+    validateInput: validateWebSearchInput,
+    call: webSearchTool,
+    prompt: () => toolPrompts.WebSearch,
+    userFacingName: () => toolUserFacingNames.WebSearch,
+    getToolUseSummary: (input) => `\u641C\u7D22 "${input.query}"`,
+    getActivityDescription: (input) => `\u641C\u7D22\u7F51\u9875: ${input.query}`
+  }),
+  WebFetch: defineTool({
+    name: "WebFetch",
+    title: "\u6293\u53D6\u7F51\u9875",
+    description: "\u6293\u53D6\u6307\u5B9A URL \u7684\u7F51\u9875\u5185\u5BB9\u5E76\u8F6C\u4E3A\u7EAF\u6587\u672C\u3002\u96F6 API Key\u3002",
+    permission: {
+      risk: "low",
+      scope: "session",
+      reason: "\u53EA\u8BFB\u6293\u53D6\u516C\u5F00\u7F51\u9875\u5185\u5BB9\uFF0C\u5185\u7F51\u5730\u5740\u5DF2\u62E6\u622A\u3002",
+      phase06Mode: "metadata-only"
+    },
+    isReadOnly: true,
+    isConcurrencySafe: true,
+    lifecycle: {
+      enabled: true,
+      destructive: false,
+      interruptBehavior: "abortable",
+      maxResultSizeChars: 6e4
+    },
+    validateInput: validateWebFetchInput,
+    call: webFetchTool,
+    prompt: () => toolPrompts.WebFetch,
+    userFacingName: () => toolUserFacingNames.WebFetch,
+    getToolUseSummary: (input) => `Fetch ${input.url}`,
+    getActivityDescription: (input) => `\u6293\u53D6\u7F51\u9875: ${input.url}`
+  })
+};
+var builtInTools = toolDefinitions;
+function readOnlyLifecycle() {
+  return {
+    enabled: true,
+    destructive: false,
+    interruptBehavior: "abortable",
+    maxResultSizeChars: DEFAULT_TOOL_TEXT_LIMIT
+  };
+}
+function writeLifecycle() {
+  return {
+    enabled: true,
+    destructive: true,
+    interruptBehavior: "best-effort",
+    maxResultSizeChars: DEFAULT_TOOL_TEXT_LIMIT
+  };
+}
+function bashLifecycle() {
+  return {
+    enabled: true,
+    destructive: true,
+    interruptBehavior: "abortable",
+    maxResultSizeChars: BASH_PREVIEW_LIMIT
+  };
+}
+function sessionLifecycle() {
+  return {
+    enabled: true,
+    destructive: false,
+    interruptBehavior: "not-supported",
+    maxResultSizeChars: DEFAULT_TOOL_TEXT_LIMIT
+  };
+}
+function normalizeToolOutput(output, tool) {
+  if (output.text.length <= tool.lifecycle.maxResultSizeChars) {
+    return output;
+  }
+  const preview = `${output.text.slice(0, tool.lifecycle.maxResultSizeChars)}
+...\uFF08\u8F93\u51FA\u5DF2\u622A\u65AD\uFF0C\u5B8C\u6574\u5185\u5BB9\u89C1 details/fullOutputPath \u6216 transcript\uFF09`;
+  return {
+    ...output,
+    text: preview,
+    preview: output.preview ?? preview,
+    details: output.details ?? output.text,
+    truncated: true
+  };
+}
+function validateRecord(input, toolName) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    throw new Error(`${toolName} \u8F93\u5165\u5FC5\u987B\u662F\u5BF9\u8C61\u3002\u5EFA\u8BAE\uFF1A\u6309\u5DE5\u5177 schema \u4F20\u5165 JSON object\u3002`);
+  }
+  return input;
+}
+function readString(record, key, toolName) {
+  const value = record[key];
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`${toolName}.${key} \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32\u3002`);
+  }
+  return value;
+}
+function readOptionalString(record, key, toolName) {
+  const value = record[key];
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value !== "string") {
+    throw new Error(`${toolName}.${key} \u5FC5\u987B\u662F\u5B57\u7B26\u4E32\u3002`);
+  }
+  return value;
+}
+function normalizeOptionalWorkspacePath(path) {
+  if (path === void 0) return void 0;
+  return path.trim().length === 0 ? void 0 : path;
+}
+function readOptionalPositiveInteger(record, key, toolName) {
+  const value = record[key];
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!Number.isInteger(value) || value < 0) {
+    throw new Error(`${toolName}.${key} \u5FC5\u987B\u662F\u975E\u8D1F\u6574\u6570\u3002`);
+  }
+  return value;
+}
+function validateReadInput(input) {
+  const record = validateRecord(input, "Read");
+  return {
+    path: readString(record, "path", "Read"),
+    offset: readOptionalPositiveInteger(record, "offset", "Read"),
+    limit: readOptionalPositiveInteger(record, "limit", "Read")
+  };
+}
+function validateWriteInput(input) {
+  const record = validateRecord(input, "Write");
+  return {
+    path: readString(record, "path", "Write"),
+    content: readString(record, "content", "Write"),
+    expectedHash: readOptionalString(record, "expectedHash", "Write")
+  };
+}
+function validateEditInput(input) {
+  const record = validateRecord(input, "Edit");
+  return {
+    path: readString(record, "path", "Edit"),
+    oldText: readString(record, "oldText", "Edit"),
+    newText: readString(record, "newText", "Edit"),
+    expectedHash: readOptionalString(record, "expectedHash", "Edit")
+  };
+}
+function validateMultiEditInput(input) {
+  const record = validateRecord(input, "MultiEdit");
+  const edits = record.edits;
+  if (!Array.isArray(edits) || edits.length === 0) {
+    throw new Error("MultiEdit.edits \u5FC5\u987B\u662F\u975E\u7A7A\u6570\u7EC4\u3002");
+  }
+  return {
+    path: readString(record, "path", "MultiEdit"),
+    expectedHash: readOptionalString(record, "expectedHash", "MultiEdit"),
+    edits: edits.map((item) => {
+      const edit = validateRecord(item, "MultiEdit");
+      return {
+        oldText: readString(edit, "oldText", "MultiEdit"),
+        newText: readString(edit, "newText", "MultiEdit")
+      };
+    })
+  };
+}
+function validateGrepInput(input) {
+  const record = validateRecord(input, "Grep");
+  return {
+    pattern: readString(record, "pattern", "Grep"),
+    path: normalizeOptionalWorkspacePath(readOptionalString(record, "path", "Grep")),
+    limit: readOptionalPositiveInteger(record, "limit", "Grep")
+  };
+}
+function validateGlobInput(input) {
+  const record = validateRecord(input, "Glob");
+  return {
+    pattern: readString(record, "pattern", "Glob"),
+    path: normalizeOptionalWorkspacePath(readOptionalString(record, "path", "Glob")),
+    limit: readOptionalPositiveInteger(record, "limit", "Glob")
+  };
+}
+function validateBashInput(input) {
+  const record = validateRecord(input, "Bash");
+  return {
+    command: readString(record, "command", "Bash"),
+    timeoutMs: readOptionalPositiveInteger(record, "timeoutMs", "Bash")
+  };
+}
+function validateTodoInput(input) {
+  const record = validateRecord(input, "Todo");
+  const action = readString(record, "action", "Todo");
+  if (action === "list") {
+    return { action };
+  }
+  if (action === "add") {
+    return { action, content: readString(record, "content", "Todo") };
+  }
+  if (action === "start" || action === "done" || action === "block") {
+    return {
+      action,
+      id: readString(record, "id", "Todo"),
+      content: readOptionalString(record, "content", "Todo"),
+      evidence: readOptionalString(record, "evidence", "Todo")
+    };
+  }
+  throw new Error("Todo.action \u5FC5\u987B\u662F list/add/start/done/block\u3002");
+}
+function validateDiffInput(input) {
+  const record = validateRecord(input ?? {}, "Diff");
+  const files = record.files;
+  if (files === void 0) {
+    return {};
+  }
+  if (!Array.isArray(files) || !files.every((item) => typeof item === "string")) {
+    throw new Error("Diff.files \u5FC5\u987B\u662F\u5B57\u7B26\u4E32\u6570\u7EC4\u3002");
+  }
+  return { files };
+}
+function validateWebSearchInput(input) {
+  const record = validateRecord(input, "WebSearch");
+  const query = readString(record, "query", "WebSearch");
+  const num_results = readOptionalPositiveInteger(record, "num_results", "WebSearch") ?? 8;
+  const rawAllowedDomains = readOptionalStringArray(record, "allowed_domains", "WebSearch");
+  const rawBlockedDomains = readOptionalStringArray(record, "blocked_domains", "WebSearch");
+  const allowed_domains = rawAllowedDomains && rawAllowedDomains.length > 0 ? rawAllowedDomains : void 0;
+  const blocked_domains = rawBlockedDomains && rawBlockedDomains.length > 0 ? rawBlockedDomains : void 0;
+  if (allowed_domains && blocked_domains) {
+    throw new Error("WebSearch: allowed_domains \u548C blocked_domains \u4E0D\u80FD\u540C\u65F6\u4F7F\u7528\u3002");
+  }
+  return { query, num_results, allowed_domains, blocked_domains };
+}
+function validateWebFetchInput(input) {
+  const record = validateRecord(input, "WebFetch");
+  const url = readString(record, "url", "WebFetch");
+  const prompt = readOptionalString(record, "prompt", "WebFetch");
+  return { url, prompt };
+}
+function readOptionalStringArray(record, key, toolName) {
+  const value = record[key];
+  if (value === void 0) return void 0;
+  if (!Array.isArray(value) || !value.every((item) => typeof item === "string")) {
+    throw new Error(`${toolName}.${key} \u5FC5\u987B\u662F\u5B57\u7B26\u4E32\u6570\u7EC4\u6216 undefined\u3002`);
+  }
+  return value;
+}
+async function readTool(input, context) {
+  const filePath = resolveWorkspacePath(context.workspaceRoot, input.path);
+  const content = await readFile(filePath, "utf8");
+  const info = await stat(filePath);
+  rememberReadSnapshot(context, filePath, content, info);
+  const lines = splitContentLines(content);
+  const offset = Math.max(input.offset ?? 0, 0);
+  const limit = Math.max(input.limit ?? DEFAULT_LIMIT, 1);
+  const selected = lines.slice(offset, offset + limit);
+  const truncated = offset > 0 || offset + limit < lines.length;
+  const textLines = selected.map((line, index) => `${offset + index + 1}	${line}`);
+  if (truncated) {
+    textLines.push(
+      `...\uFF08\u53EA\u663E\u793A\u8BFB\u53D6\u7A97\u53E3\uFF1A\u9009\u4E2D ${selected.length} \u884C / \u5168\u6587 ${lines.length} \u884C\uFF1B\u4E0D\u662F\u5B8C\u6574\u6587\u4EF6\uFF09`
+    );
+  }
+  return {
+    text: textLines.join("\n"),
+    data: {
+      path: relativePath(context.workspaceRoot, filePath),
+      lines: selected.length,
+      selectedLines: selected.length,
+      windowLines: selected.length,
+      totalLines: lines.length,
+      contentLines: lines.length,
+      hash: hashText(content),
+      newline: detectNewlineStyle(content)
+    },
+    truncated
+  };
+}
+function splitContentLines(content) {
+  if (content.length === 0) {
+    return [];
+  }
+  return content.replace(/\r?\n$/, "").split(/\r?\n/);
+}
+async function writeTool(input, context) {
+  const filePath = resolveWorkspacePath(context.workspaceRoot, input.path);
+  const before = await readExistingFile(filePath);
+  const readGuard = ensureReadBeforeEdit(context, filePath, before, input.expectedHash);
+  await mkdir(dirname(filePath), { recursive: true });
+  await writeFile(filePath, input.content, "utf8");
+  const afterInfo = await stat(filePath);
+  rememberReadSnapshot(context, filePath, input.content, afterInfo);
+  recordChangedFile(context, filePath);
+  return createEditOutput(
+    context,
+    "Write",
+    filePath,
+    before?.content ?? "",
+    input.content,
+    readGuard
+  );
+}
+async function editTool(input, context) {
+  const filePath = resolveWorkspacePath(context.workspaceRoot, input.path);
+  const before = await readExistingFile(filePath);
+  if (!before) {
+    throw new Error(
+      `\u6587\u4EF6\u4E0D\u5B58\u5728\uFF1A${relativePath(context.workspaceRoot, filePath)}\u3002\u5EFA\u8BAE\uFF1A\u786E\u8BA4\u8DEF\u5F84\u6216\u6539\u7528 Write \u521B\u5EFA\u65B0\u6587\u4EF6\u3002`
+    );
+  }
+  const readGuard = ensureReadBeforeEdit(context, filePath, before, input.expectedHash);
+  try {
+    ensureUnique(before.content, input.oldText);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "\u552F\u4E00\u6027\u68C0\u67E5\u5931\u8D25\u3002";
+    throw new Error(`${message} \u5EFA\u8BAE\uFF1A\u91CD\u65B0 Read \u6587\u4EF6\uFF0C\u786E\u8BA4\u6700\u65B0\u5185\u5BB9\u540E\u518D\u63D0\u4EA4\u53EF\u552F\u4E00\u5339\u914D\u7684\u7F16\u8F91\u3002`);
+  }
+  const next = before.content.replace(input.oldText, input.newText);
+  await writeFile(filePath, next, "utf8");
+  const afterInfo = await stat(filePath);
+  rememberReadSnapshot(context, filePath, next, afterInfo);
+  recordChangedFile(context, filePath);
+  return createEditOutput(context, "Edit", filePath, before.content, next, readGuard);
+}
+async function multiEditTool(input, context) {
+  const filePath = resolveWorkspacePath(context.workspaceRoot, input.path);
+  if (!Array.isArray(input.edits) || input.edits.length === 0) {
+    throw new Error("MultiEdit \u9700\u8981\u81F3\u5C11 1 \u4E2A edits \u9879\u3002\u5EFA\u8BAE\uFF1A\u4F20\u5165 edits=[{oldText,newText}]\u3002");
+  }
+  const before = await readExistingFile(filePath);
+  if (!before) {
+    throw new Error(
+      `\u6587\u4EF6\u4E0D\u5B58\u5728\uFF1A${relativePath(context.workspaceRoot, filePath)}\u3002\u5EFA\u8BAE\uFF1A\u786E\u8BA4\u8DEF\u5F84\u6216\u6539\u7528 Write \u521B\u5EFA\u65B0\u6587\u4EF6\u3002`
+    );
+  }
+  const readGuard = ensureReadBeforeEdit(context, filePath, before, input.expectedHash);
+  let content = before.content;
+  for (const [index, edit] of input.edits.entries()) {
+    try {
+      ensureUnique(content, edit.oldText);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "\u552F\u4E00\u6027\u68C0\u67E5\u5931\u8D25\u3002";
+      throw new Error(
+        `\u7B2C ${index + 1} \u4E2A\u7F16\u8F91\u5931\u8D25\uFF1A${message} \u5EFA\u8BAE\uFF1A\u91CD\u65B0 Read \u6587\u4EF6\uFF0C\u786E\u8BA4\u6700\u65B0\u5185\u5BB9\u540E\u518D\u6309\u987A\u5E8F\u63D0\u4EA4\u552F\u4E00\u5339\u914D\u7247\u6BB5\u3002`
+      );
+    }
+    content = content.replace(edit.oldText, edit.newText);
+  }
+  await writeFile(filePath, content, "utf8");
+  const afterInfo = await stat(filePath);
+  rememberReadSnapshot(context, filePath, content, afterInfo);
+  recordChangedFile(context, filePath);
+  return createEditOutput(
+    context,
+    "MultiEdit",
+    filePath,
+    before.content,
+    content,
+    readGuard,
+    input.edits.length
+  );
+}
+async function grepTool(input, context) {
+  const root = resolveWorkspacePath(context.workspaceRoot, input.path ?? ".");
+  const expression = createGrepExpression(input.pattern);
+  const limit = input.limit ?? DEFAULT_SEARCH_LIMIT;
+  const rgMatches = await tryRipgrepSearch(input, context, root, limit);
+  if (rgMatches) {
+    return {
+      text: rgMatches.matches.length === 0 ? "\u672A\u627E\u5230\u5339\u914D\u5185\u5BB9\u3002" : rgMatches.matches.join("\n"),
+      data: { count: rgMatches.matches.length, backend: "rg" },
+      truncated: rgMatches.truncated
+    };
+  }
+  const matches = [];
+  for await (const filePath of listFiles(root, () => matches.length >= limit)) {
+    const content = await safeReadText(filePath, context);
+    if (content === null) {
+      continue;
+    }
+    const lines = content.split(/\r?\n/);
+    for (const [index, line] of lines.entries()) {
+      if (expression.test(line)) {
+        matches.push(`${relativePath(context.workspaceRoot, filePath)}:${index + 1}: ${line}`);
+        if (matches.length >= limit) {
+          break;
+        }
+      }
+    }
+  }
+  return {
+    text: matches.length === 0 ? "\u672A\u627E\u5230\u5339\u914D\u5185\u5BB9\u3002" : matches.join("\n"),
+    data: { count: matches.length },
+    truncated: matches.length >= limit
+  };
+}
+function createGrepExpression(pattern) {
+  if (pattern.startsWith("(?i)")) {
+    return new RegExp(pattern.slice(4), "i");
+  }
+  return new RegExp(pattern);
+}
+async function globTool(input, context) {
+  const root = resolveWorkspacePath(context.workspaceRoot, input.path ?? ".");
+  const limit = input.limit ?? DEFAULT_SEARCH_LIMIT;
+  const rgMatches = await tryRipgrepFiles(input, context, root, limit);
+  if (rgMatches) {
+    return {
+      text: rgMatches.matches.length === 0 ? "\u672A\u627E\u5230\u5339\u914D\u6587\u4EF6\u3002" : rgMatches.matches.join("\n"),
+      data: { count: rgMatches.matches.length, backend: "rg" },
+      truncated: rgMatches.truncated
+    };
+  }
+  const matcher = globToRegExp(input.pattern);
+  const matches = [];
+  for await (const filePath of listFiles(root, () => matches.length >= limit)) {
+    const rel = relativePath(context.workspaceRoot, filePath);
+    if (matcher.test(rel) || matcher.test(basename(filePath))) {
+      matches.push(rel);
+    }
+    if (matches.length >= limit) {
+      break;
+    }
+  }
+  return {
+    text: matches.length === 0 ? "\u672A\u627E\u5230\u5339\u914D\u6587\u4EF6\u3002" : matches.join("\n"),
+    data: { count: matches.length },
+    truncated: matches.length >= limit
+  };
+}
+var SECRET_PATTERNS = [
+  [/(?:-H\s+|--header\s+)?["']?\s*[Aa]uthorization\s*:\s*Bearer\s+\S+/g, "Authorization: Bearer [REDACTED]"],
+  [/(?:-H\s+|--header\s+)?["']?\s*[Aa]uthorization\s*:\s*Basic\s+\S+/g, "Authorization: Basic [REDACTED]"],
+  [/(?:-H\s+|--header\s+)?["']?\s*[Xx]-(?:[Aa]pi|[Ff]unctions|[Aa]uth|[Tt]oken)[- ]?[Kk]ey\s*:\s*\S+/g, (m) => `${m.split(":")[0]}: [REDACTED_HEADER]`],
+  [/--(?:token|api-key|api[_\-]?key|secret|access[_\-]?token|pat)\s+["']?\s*\S+/g, (m) => `${m.split(/\s+/)[0] ?? m} [REDACTED]`],
+  [/(?:AWS_SECRET_ACCESS_KEY|AWS_ACCESS_KEY_ID|AZURE_OPENAI_API_KEY|GITHUB_TOKEN|GITLAB_TOKEN|NPM_TOKEN|DOCKER_PASSWORD|OPENAI_API_KEY|ANTHROPIC_API_KEY|GOOGLE_API_KEY|COHERE_API_KEY|HF_TOKEN|HUGGINGFACE_TOKEN|DEEPSEEK_API_KEY)\s*[=:]\s*\S+/gi, (m) => `${m.split(/[=:]/)[0] ?? m}=[REDACTED_ENV]`],
+  [/(?:SECRET|TOKEN|KEY|PASSWORD|PASSWD)\s*[=:]\s*\S{8,}/gi, (m) => `${m.split(/[=:]/)[0] ?? m}=[REDACTED]`]
+];
+function sanitizeSecrets(text) {
+  let sanitized = text;
+  for (const [pattern, replacement] of SECRET_PATTERNS) {
+    sanitized = typeof replacement === "string" ? sanitized.replace(pattern, replacement) : sanitized.replace(pattern, replacement);
+  }
+  return sanitized;
+}
+async function bashTool(input, context) {
+  const logRoot = context.logRoot ?? join(context.workspaceRoot, ".linghun", "logs", "tools");
+  await mkdir(logRoot, { recursive: true });
+  const fullOutputPath = join(logRoot, `bash-${Date.now()}-${randomUUID()}.log`);
+  const timeoutMs = input.timeoutMs ?? BASH_TIMEOUT_MS;
+  const adapted = adaptShellCommand(input.command);
+  const result = await runShell(
+    adapted.command,
+    context.workspaceRoot,
+    timeoutMs,
+    context.abortSignal,
+    (stream, text) => void context.onProgress?.({ toolName: "Bash", stream, text })
+  );
+  const adapterLines = adapted.command === input.command && adapted.adapter === "native" ? [] : [
+    `adapter ${adapted.adapter}`,
+    `original command ${summarizeOriginalShellCommand(input.command)}`
+  ];
+  const commandForLog = adapted.logCommand ?? adapted.command;
+  const fullText = [
+    `$ ${sanitizeSecrets(commandForLog)}`,
+    ...adapterLines,
+    `exit code ${result.exitCode}`,
+    `outcome ${result.outcome}`,
+    "",
+    sanitizeSecrets(result.output)
+  ].join("\n");
+  await writeFile(fullOutputPath, fullText, "utf8");
+  const truncated = fullText.length > BASH_PREVIEW_LIMIT;
+  const preview = truncated ? `${fullText.slice(0, BASH_PREVIEW_LIMIT)}
+...\uFF08\u8F93\u51FA\u5DF2\u622A\u65AD\uFF0C\u5B8C\u6574\u65E5\u5FD7\u89C1 fullOutputPath\uFF09` : fullText;
+  return {
+    text: preview,
+    data: adapted.adapter === "native" ? { exitCode: result.exitCode, outcome: result.outcome } : { exitCode: result.exitCode, outcome: result.outcome, adapter: adapted.adapter },
+    truncated,
+    fullOutputPath
+  };
+}
+function adaptShellCommand(command) {
+  return adaptShellCommandForPlatform(command, process.platform);
+}
+function adaptShellCommandForPlatform(command, platform) {
+  if (platform !== "win32") return { command, adapter: "native" };
+  const heredoc = convertNodeHereDocForPowerShell(command);
+  if (heredoc) return heredoc;
+  if (looksLikeUnsupportedUnixMultiline(command)) {
+    return createBlockedPowerShellAdapter(
+      "Unsupported multi-line Unix shell syntax on Windows PowerShell; use PowerShell-safe commands or Node one-liners."
+    );
+  }
+  const converted = convertUnixPipelineForPowerShell(command);
+  if (converted) return { command: converted, adapter: "powershell-adapted" };
+  const readOnlyCommand = convertUnixReadOnlyCommandForPowerShell(command);
+  if (readOnlyCommand) return readOnlyCommand;
+  if (looksLikeUnsupportedUnixPipeline(command)) {
+    const message = "Unsupported Unix pipeline on Windows PowerShell; use PowerShell-safe commands or Node one-liners.";
+    return createBlockedPowerShellAdapter(message);
+  }
+  const unsupportedReadOnlyCommand = blockUnsupportedUnixReadOnlyCommand(command);
+  if (unsupportedReadOnlyCommand) return unsupportedReadOnlyCommand;
+  return { command, adapter: "native" };
+}
+function convertNodeHereDocForPowerShell(command) {
+  const normalized = command.replace(/\r\n/gu, "\n");
+  const match = normalized.match(
+    /^node\s+(-)?\s*<<\s*(['"]?)([A-Za-z_][\w.-]*)\2\s*\n([\s\S]*)\n\3\s*$/u
+  );
+  if (!match) return void 0;
+  const mode = match[1] === "-" ? "stdin" : "script";
+  const body = match[4] ?? "";
+  if (!body.trim()) {
+    return createBlockedPowerShellAdapter("Unsupported empty node here-doc on Windows PowerShell.");
+  }
+  const extension = ".cjs";
+  const bodyBase64 = Buffer.from(body, "utf8").toString("base64");
+  const script = [
+    "$ErrorActionPreference='Stop'",
+    "$dir = Join-Path ([System.IO.Path]::GetTempPath()) ('linghun-node-heredoc-' + [guid]::NewGuid().ToString('N'))",
+    "[System.IO.Directory]::CreateDirectory($dir) | Out-Null",
+    `$script = Join-Path $dir ('script${extension}')`,
+    `$body = [System.Text.Encoding]::UTF8.GetString([System.Convert]::FromBase64String(${quotePowerShellString(bodyBase64)}))`,
+    "[System.IO.File]::WriteAllText($script, $body, [System.Text.UTF8Encoding]::new($false))",
+    "try {",
+    "  & node $script",
+    "  exit $LASTEXITCODE",
+    "} finally {",
+    "  Remove-Item -LiteralPath $dir -Recurse -Force -ErrorAction SilentlyContinue",
+    "}"
+  ].join("; ");
+  return {
+    command: ["powershell.exe -NoProfile -NonInteractive -Command", quoteCmdArg(script)].join(" "),
+    adapter: "powershell-adapted",
+    logCommand: `powershell.exe -NoProfile -NonInteractive -Command <node here-doc adapter: ${mode}>`
+  };
+}
+function createBlockedPowerShellAdapter(message) {
+  return {
+    command: `powershell.exe -NoProfile -NonInteractive -Command "Write-Error ${quotePowerShellString(message)}; exit 1"`,
+    adapter: "blocked",
+    logCommand: `powershell.exe -NoProfile -NonInteractive -Command <blocked: ${message}>`
+  };
+}
+function convertUnixPipelineForPowerShell(command) {
+  const normalized = command.trim();
+  const findSed = normalized.match(
+    /^find\s+(.+?)\s+-type\s+f\s*\|\s*sed\s+-n\s+['"]?1,(\d+)p['"]?$/iu
+  );
+  if (findSed) {
+    const root = stripShellQuotes(findSed[1] ?? ".");
+    const first = Number.parseInt(findSed[2] ?? "0", 10);
+    if (Number.isFinite(first) && first > 0) {
+      return [
+        "powershell.exe -NoProfile -NonInteractive -Command",
+        quoteCmdArg(
+          `$ErrorActionPreference='Stop'; Get-ChildItem -LiteralPath ${quotePowerShellString(root)} -File -Recurse | Select-Object -First ${first} | ForEach-Object { $_.FullName }`
+        )
+      ].join(" ");
+    }
+  }
+  const findHead = normalized.match(
+    /^find\s+((?:"[^"]+"|'[^']+'|[^\s|]+))(?:\s+-type\s+f)?\s*\|\s*head\s+-n\s+(\d+)$/iu
+  );
+  if (findHead) {
+    const root = stripShellQuotes(findHead[1] ?? ".");
+    const first = Number.parseInt(findHead[2] ?? "0", 10);
+    if (Number.isFinite(first) && first > 0) {
+      return [
+        "powershell.exe -NoProfile -NonInteractive -Command",
+        quoteCmdArg(
+          `$ErrorActionPreference='Stop'; Get-ChildItem -LiteralPath ${quotePowerShellString(root)} -File -Recurse | Select-Object -First ${first} | ForEach-Object { $_.FullName }`
+        )
+      ].join(" ");
+    }
+  }
+  const sedHead = normalized.match(/^sed\s+-n\s+['"]?1,(\d+)p['"]?\s+(.+)$/iu);
+  if (sedHead) {
+    const first = Number.parseInt(sedHead[1] ?? "0", 10);
+    const file = stripShellQuotes(sedHead[2] ?? "");
+    if (Number.isFinite(first) && first > 0 && file) {
+      return [
+        "powershell.exe -NoProfile -NonInteractive -Command",
+        quoteCmdArg(
+          `$ErrorActionPreference='Stop'; Get-Content -LiteralPath ${quotePowerShellString(file)} -TotalCount ${first}`
+        )
+      ].join(" ");
+    }
+  }
+  const headFile = normalized.match(/^head\s+-n\s+(\d+)\s+(.+)$/iu);
+  if (headFile) {
+    const first = Number.parseInt(headFile[1] ?? "0", 10);
+    const file = stripShellQuotes(headFile[2] ?? "");
+    if (Number.isFinite(first) && first > 0 && file) {
+      return [
+        "powershell.exe -NoProfile -NonInteractive -Command",
+        quoteCmdArg(
+          `$ErrorActionPreference='Stop'; Get-Content -LiteralPath ${quotePowerShellString(file)} -TotalCount ${first}`
+        )
+      ].join(" ");
+    }
+  }
+  return void 0;
+}
+function convertUnixReadOnlyCommandForPowerShell(command) {
+  const tokens = tokenizeSimpleShellCommand(command);
+  if (!tokens) return void 0;
+  const [program = "", ...args] = tokens;
+  const lowerProgram = program.toLowerCase();
+  let script;
+  if (lowerProgram === "cat") {
+    if (args.length === 1) {
+      script = `Get-Content -LiteralPath ${quotePowerShellString(args[0] ?? "")}`;
+    }
+  } else if (lowerProgram === "ls") {
+    script = convertLsForPowerShell(args);
+  } else if (lowerProgram === "grep") {
+    script = convertGrepForPowerShell(args);
+  } else if (lowerProgram === "pwd") {
+    if (args.length === 0) script = "Get-Location | ForEach-Object { $_.Path }";
+  } else if (lowerProgram === "which") {
+    if (args.length === 1) {
+      script = [
+        `$cmd = Get-Command -ErrorAction Stop ${quotePowerShellString(args[0] ?? "")}`,
+        "if ($cmd.Source) { $cmd.Source } elseif ($cmd.Path) { $cmd.Path } else { $cmd.Name }"
+      ].join("; ");
+    }
+  }
+  if (!script) return void 0;
+  return {
+    command: [
+      "powershell.exe -NoProfile -NonInteractive -Command",
+      quoteCmdArg(`$ErrorActionPreference='Stop'; ${script}`)
+    ].join(" "),
+    adapter: "powershell-adapted"
+  };
+}
+function convertLsForPowerShell(args) {
+  let force = false;
+  let path = ".";
+  for (const arg of args) {
+    if (arg === "-a" || arg === "-la" || arg === "-al") {
+      force = true;
+      continue;
+    }
+    if (arg === "-l") {
+      continue;
+    }
+    if (arg.startsWith("-")) return void 0;
+    if (path !== ".") return void 0;
+    path = arg;
+  }
+  const forceArg = force ? " -Force" : "";
+  return `Get-ChildItem -LiteralPath ${quotePowerShellString(path)}${forceArg}`;
+}
+function convertGrepForPowerShell(args) {
+  const recursive = args[0] === "-R" || args[0] === "-r";
+  const offset = recursive ? 1 : 0;
+  const pattern = args[offset];
+  const target = args[offset + 1];
+  if (!pattern || !target || args.length !== offset + 2) return void 0;
+  if (recursive) {
+    return [
+      `Get-ChildItem -LiteralPath ${quotePowerShellString(target)} -File -Recurse`,
+      `Select-String -Pattern ${quotePowerShellString(pattern)}`
+    ].join(" | ");
+  }
+  return `Select-String -Pattern ${quotePowerShellString(pattern)} -LiteralPath ${quotePowerShellString(target)}`;
+}
+function looksLikeUnsupportedUnixPipeline(command) {
+  return /\bfind\s+.+\|\s*(?:sed|head)\b/iu.test(command) || /\b(?:cat|grep|ls|find|sed|head)\b.+\|\s*(?:sed|head|grep|awk|xargs)\b/isu.test(command) || /\bsed\s+-n\b/iu.test(command) || /\bhead\s+-n\b/iu.test(command);
+}
+function looksLikeUnsupportedUnixMultiline(command) {
+  const normalized = command.replace(/\r\n/gu, "\n");
+  if (!/\n/u.test(normalized)) return false;
+  if (/<<\s*['"]?[A-Za-z_][\w.-]*['"]?/u.test(normalized)) return true;
+  return normalized.split("\n").some((line) => /^\s*(?:cat|ls|grep|find|sed|head|which|pwd)\b/iu.test(line));
+}
+function blockUnsupportedUnixReadOnlyCommand(command) {
+  const tokens = tokenizeSimpleShellCommand(command);
+  const program = tokens?.[0]?.toLowerCase() ?? command.trim().match(/^(\w+)/u)?.[1]?.toLowerCase();
+  if (!program || !["cat", "ls", "grep", "pwd", "which"].includes(program)) return void 0;
+  return createBlockedPowerShellAdapter(
+    `Unsupported ${program} form on Windows PowerShell; use a simple read-only form or a PowerShell-safe command.`
+  );
+}
+function tokenizeSimpleShellCommand(command) {
+  const trimmed = command.trim();
+  if (!trimmed || /[\r\n|;&<>]/u.test(trimmed)) return void 0;
+  const tokens = [];
+  let current = "";
+  let quote;
+  for (let index = 0; index < trimmed.length; index += 1) {
+    const char = trimmed[index];
+    if (!char) continue;
+    if (quote) {
+      if (char === quote) {
+        quote = void 0;
+        continue;
+      }
+      current += char;
+      continue;
+    }
+    if (char === "'" || char === '"') {
+      quote = char;
+      continue;
+    }
+    if (/\s/u.test(char)) {
+      if (current) {
+        tokens.push(current);
+        current = "";
+      }
+      continue;
+    }
+    current += char;
+  }
+  if (quote) return void 0;
+  if (current) tokens.push(current);
+  return tokens.length > 0 ? tokens : void 0;
+}
+function stripShellQuotes(value) {
+  const trimmed = value.trim();
+  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+function quotePowerShellString(value) {
+  return `'${value.replace(/'/gu, "''")}'`;
+}
+function quoteCmdArg(value) {
+  return `"${value.replace(/"/gu, '\\"')}"`;
+}
+function summarizeOriginalShellCommand(command) {
+  if (!/\n/u.test(command)) return command;
+  const lines = command.split(/\r?\n/u);
+  const firstLine = lines[0]?.trim() || "multi-line command";
+  return `${firstLine} <${lines.length} lines>`;
+}
+async function todoTool(input, context) {
+  if (input.action === "add") {
+    if (context.todos.length >= MAX_TODO_ITEMS) {
+      throw new Error(`Todo \u5DF2\u8FBE\u5230\u4E0A\u9650 ${MAX_TODO_ITEMS} \u6761\u3002\u5EFA\u8BAE\uFF1A\u5148\u5B8C\u6210\u6216\u6E05\u7406\u65E7 Todo\u3002`);
+    }
+    const id = String(context.todos.length + 1);
+    context.todos.push({
+      id,
+      content: input.content,
+      status: "pending"
+    });
+    return {
+      text: `Todo created: id=${id}
+${formatTodos(context.todos)}`,
+      data: { items: context.todos, createdId: id }
+    };
+  }
+  if (input.action === "start") {
+    const item = findTodo(context.todos, input.id, input.content);
+    for (const todo of context.todos) {
+      if (todo.status === "in_progress") {
+        todo.status = "pending";
+      }
+    }
+    item.status = "in_progress";
+    item.evidence = input.evidence ?? item.evidence;
+  }
+  if (input.action === "done") {
+    const item = findTodo(context.todos, input.id, input.content);
+    item.status = "completed";
+    item.evidence = input.evidence ?? item.evidence;
+  }
+  if (input.action === "block") {
+    const item = findTodo(context.todos, input.id, input.content);
+    item.status = "blocked";
+    item.evidence = input.evidence ?? item.evidence;
+  }
+  return {
+    text: formatTodos(context.todos),
+    data: { items: context.todos }
+  };
+}
+async function diffTool(input, context) {
+  const changedFiles = unique(input.files ?? context.changedFiles);
+  const patchSummaries = context.patchSummaries ?? {};
+  const addedLines = changedFiles.reduce(
+    (total, file) => total + (patchSummaries[file]?.addedLines ?? 0),
+    0
+  );
+  const removedLines = changedFiles.reduce(
+    (total, file) => total + (patchSummaries[file]?.removedLines ?? 0),
+    0
+  );
+  const riskyFiles = changedFiles.filter(
+    (file) => file.includes(".env") || file.startsWith(".git/")
+  );
+  const summary = {
+    changedFiles,
+    addedLines,
+    removedLines,
+    summary: changedFiles.length === 0 ? "\u672C\u8F6E\u6682\u65E0\u5DE5\u5177\u5199\u5165\u6539\u52A8\u3002" : `\u672C\u8F6E\u5DE5\u5177\u6539\u52A8 ${changedFiles.length} \u4E2A\u6587\u4EF6\uFF0C+${addedLines} -${removedLines}\u3002`,
+    riskyFiles
+  };
+  return {
+    text: `${summary.summary}
+${changedFiles.map((file) => `- ${file}`).join("\n")}`.trim(),
+    data: summary
+  };
+}
+async function webSearchTool(input, _context) {
+  const start = Date.now();
+  const result = await bingSearch(input);
+  if (!result.ok) {
+    return {
+      text: `WebSearch failed: ${result.error}`,
+      data: {
+        query: input.query,
+        results: [],
+        searches: 1,
+        count: 0,
+        durationMs: Date.now() - start,
+        error: result.error
+      }
+    };
+  }
+  const filtered = applyDomainFilter(
+    result.results,
+    input.allowed_domains,
+    input.blocked_domains
+  );
+  return formatSearchOutput(input.query, filtered, Date.now() - start);
+}
+async function webFetchTool(input, _context) {
+  const start = Date.now();
+  const result = await webFetch(input);
+  return formatFetchOutput(input.url, result, Date.now() - start);
+}
+function resolveWorkspacePath(workspaceRoot, inputPath) {
+  if (!inputPath) {
+    throw new Error("\u8DEF\u5F84\u4E0D\u80FD\u4E3A\u7A7A\u3002\u5EFA\u8BAE\uFF1A\u4F20\u5165\u5DE5\u4F5C\u533A\u5185\u76F8\u5BF9\u8DEF\u5F84\u3002");
+  }
+  const target = resolve(workspaceRoot, inputPath);
+  const rel = relative(workspaceRoot, target);
+  if (rel.startsWith("..") || isAbsolute(rel) || rel === "" && target !== resolve(workspaceRoot)) {
+    throw new Error(`\u8DEF\u5F84\u8D8A\u754C\uFF1A${inputPath}\u3002\u5EFA\u8BAE\uFF1A\u53EA\u64CD\u4F5C\u5F53\u524D\u5DE5\u4F5C\u533A\u5185\u6587\u4EF6\u3002`);
+  }
+  return target;
+}
+function relativePath(workspaceRoot, filePath) {
+  return relative(workspaceRoot, filePath).replaceAll("\\", "/") || ".";
+}
+function ensureUnique(content, oldText) {
+  if (!oldText) {
+    throw new Error("oldText \u4E0D\u80FD\u4E3A\u7A7A\u3002\u5EFA\u8BAE\uFF1A\u63D0\u4F9B\u8DB3\u591F\u4E0A\u4E0B\u6587\u7684\u552F\u4E00\u7247\u6BB5\u3002");
+  }
+  const count = content.split(oldText).length - 1;
+  if (count === 0) {
+    throw new Error("\u672A\u627E\u5230 oldText\u3002\u5EFA\u8BAE\uFF1A\u5148 Read \u6587\u4EF6\u786E\u8BA4\u6700\u65B0\u5185\u5BB9\u3002");
+  }
+  if (count > 1) {
+    throw new Error(`oldText \u51FA\u73B0 ${count} \u6B21\uFF0C\u4E0D\u552F\u4E00\u3002\u5EFA\u8BAE\uFF1A\u589E\u52A0\u4E0A\u4E0B\u6587\u540E\u91CD\u8BD5\u3002`);
+  }
+}
+function recordChangedFile(context, filePath) {
+  context.changedFiles = unique([
+    ...context.changedFiles,
+    relativePath(context.workspaceRoot, filePath)
+  ]);
+}
+async function readExistingFile(filePath) {
+  try {
+    const [content, info] = await Promise.all([readFile(filePath, "utf8"), stat(filePath)]);
+    return { content, hash: hashText(content), mtimeMs: info.mtimeMs, size: info.size };
+  } catch (error) {
+    const code = typeof error === "object" && error !== null ? error.code : void 0;
+    if (code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+}
+function ensureReadBeforeEdit(context, filePath, before, expectedHash) {
+  if (!before) {
+    return { source: "new-file" };
+  }
+  const rel = relativePath(context.workspaceRoot, filePath);
+  if (expectedHash) {
+    if (expectedHash !== before.hash) {
+      throw new Error(
+        `\u6587\u4EF6\u5DF2\u53D8\u5316\uFF1A${rel} \u5F53\u524D hash \u4E0E expectedHash \u4E0D\u4E00\u81F4\u3002\u5EFA\u8BAE\uFF1A\u91CD\u65B0 Read \u6587\u4EF6\u540E\u6309\u6700\u65B0\u5185\u5BB9\u91CD\u8BD5\uFF0C\u907F\u514D\u8986\u76D6\u5916\u90E8\u4FEE\u6539\u3002`
+      );
+    }
+    return { source: "expectedHash", beforeHash: before.hash };
+  }
+  const snapshot = context.readSnapshots?.[rel];
+  if (!snapshot) {
+    throw new Error(
+      `\u7F16\u8F91\u524D\u672A\u8BFB\u53D6\uFF1A${rel}\u3002\u5EFA\u8BAE\uFF1A\u5148\u8FD0\u884C Read \u83B7\u53D6\u6700\u65B0\u5185\u5BB9\uFF0C\u6216\u4F20\u5165 expectedHash \u540E\u518D\u6267\u884C\u5199\u5165\u3002`
+    );
+  }
+  if (snapshot.hash !== before.hash || snapshot.mtimeMs !== before.mtimeMs || snapshot.size !== before.size) {
+    throw new Error(
+      `\u6587\u4EF6\u5DF2\u53D8\u5316\uFF1A${rel} \u81EA\u4E0A\u6B21 Read \u540E\u88AB\u4FEE\u6539\u3002\u5EFA\u8BAE\uFF1A\u91CD\u65B0 Read \u6587\u4EF6\u540E\u6309\u6700\u65B0\u5185\u5BB9\u91CD\u8BD5\uFF0C\u907F\u514D\u9759\u9ED8\u8986\u76D6\u3002`
+    );
+  }
+  return { source: "read-snapshot", beforeHash: before.hash };
+}
+function rememberReadSnapshot(context, filePath, content, info) {
+  const rel = relativePath(context.workspaceRoot, filePath);
+  context.readSnapshots = {
+    ...context.readSnapshots ?? {},
+    [rel]: { path: rel, hash: hashText(content), mtimeMs: info.mtimeMs, size: info.size }
+  };
+}
+function createEditOutput(context, operation, filePath, before, after, readGuard, editCount = 1) {
+  const rel = relativePath(context.workspaceRoot, filePath);
+  const summary = createPatchSummary([rel], before, after);
+  context.patchSummaries = { ...context.patchSummaries ?? {}, [rel]: summary };
+  const newlineBefore = detectNewlineStyle(before);
+  const newlineAfter = detectNewlineStyle(after);
+  const text = [
+    `${operation} \u5DF2\u5B8C\u6210\uFF1A${rel}`,
+    `- \u8865\u4E01\uFF1A+${summary.addedLines} -${summary.removedLines}`,
+    `- \u6539\u52A8\u6587\u4EF6\uFF1A${rel}`,
+    "- \u8BFB\u53D6\u4FDD\u62A4\uFF1A\u5DF2\u542F\u7528",
+    `- \u6362\u884C\uFF1A${newlineBefore} -> ${newlineAfter}`,
+    "- \u4E0B\u4E00\u6B65\uFF1A\u7528 Diff \u6216 /details \u67E5\u770B\u8865\u4E01\u6458\u8981\uFF1B\u9700\u8981\u7EE7\u7EED\u7F16\u8F91\u8BF7\u57FA\u4E8E\u6700\u65B0\u5185\u5BB9\u3002"
+  ].join("\n");
+  return {
+    text,
+    summary: `${operation} ${rel}: +${summary.addedLines} -${summary.removedLines}; changed files 1`,
+    preview: text,
+    details: createPatchDetails(operation, rel, before, after, readGuard, editCount),
+    data: {
+      ...summary,
+      operation,
+      editCount,
+      readGuard: readGuard.source,
+      beforeHash: readGuard.beforeHash,
+      afterHash: hashText(after),
+      newlineBefore,
+      newlineAfter,
+      encoding: "utf8"
+    },
+    changedFiles: [rel]
+  };
+}
+function createPatchSummary(changedFiles, before, after) {
+  const beforeLines = before.length > 0 ? before.split(/\r?\n/u) : [];
+  const afterLines = after.length > 0 ? after.split(/\r?\n/u) : [];
+  const common = /* @__PURE__ */ new Map();
+  for (const line of beforeLines) {
+    common.set(line, (common.get(line) ?? 0) + 1);
+  }
+  let unchanged = 0;
+  for (const line of afterLines) {
+    const count = common.get(line) ?? 0;
+    if (count > 0) {
+      unchanged += 1;
+      common.set(line, count - 1);
+    }
+  }
+  const addedLines = Math.max(afterLines.length - unchanged, 0);
+  const removedLines = Math.max(beforeLines.length - unchanged, 0);
+  return {
+    changedFiles,
+    addedLines,
+    removedLines,
+    summary: `\u7F16\u8F91\u6539\u52A8 ${changedFiles.length} \u4E2A\u6587\u4EF6\uFF0C+${addedLines} -${removedLines}\u3002`,
+    riskyFiles: changedFiles.filter((file) => file.includes(".env") || file.startsWith(".git/"))
+  };
+}
+function createPatchDetails(operation, rel, before, after, readGuard, editCount) {
+  const beforeLines = before.split(/\r?\n/u);
+  const afterLines = after.split(/\r?\n/u);
+  return [
+    `operation: ${operation}`,
+    `file: ${rel}`,
+    `edit count: ${editCount}`,
+    "read protection: enabled",
+    "encoding: utf8",
+    `newline: ${detectNewlineStyle(before)} -> ${detectNewlineStyle(after)}`,
+    "--- before (first changed context)",
+    ...previewChangedLines(beforeLines, afterLines, "-"),
+    "+++ after (first changed context)",
+    ...previewChangedLines(afterLines, beforeLines, "+")
+  ].join("\n");
+}
+function previewChangedLines(primary, other, marker) {
+  const limit = 12;
+  const changed = primary.filter((line, index) => other[index] !== line).slice(0, limit);
+  if (changed.length === 0) {
+    return [`${marker} <no line-level preview; content hash changed or unchanged>`];
+  }
+  return changed.map((line) => `${marker} ${line}`);
+}
+function hashText(content) {
+  return createHash("sha256").update(content, "utf8").digest("hex");
+}
+function detectNewlineStyle(content) {
+  const crlf = (content.match(/\r\n/gu) ?? []).length;
+  const lf = (content.match(/(?<!\r)\n/gu) ?? []).length;
+  if (crlf > 0 && lf > 0) return "mixed";
+  if (crlf > 0) return "crlf";
+  if (lf > 0) return "lf";
+  return "none";
+}
+async function* listFiles(root, shouldStop, searchRoot = root) {
+  if (shouldStop?.()) return;
+  const current = await stat(root);
+  if (current.isFile()) {
+    yield root;
+    return;
+  }
+  const entries = await readdir(root, { withFileTypes: true });
+  for (const entry of entries) {
+    if (shouldStop?.()) return;
+    const entryPath = join(root, entry.name);
+    if (isDefaultSearchExcludedPath(entryPath, searchRoot, entry)) {
+      continue;
+    }
+    if (entry.isDirectory()) {
+      yield* listFiles(entryPath, shouldStop, searchRoot);
+      continue;
+    }
+    if (entry.isFile()) {
+      yield entryPath;
+    }
+  }
+}
+function isDefaultSearchExcludedPath(entryPath, searchRoot, entry) {
+  if (entry.isDirectory() && SEARCH_EXCLUDED_DIR_NAMES.includes(entry.name)) {
+    return true;
+  }
+  if (entry.isFile() && SEARCH_EXCLUDED_FILE_SUFFIXES.some((suffix) => entry.name.endsWith(suffix))) {
+    return true;
+  }
+  const rel = stripCurrentDirectoryPrefix(relative(searchRoot, entryPath).replaceAll("\\", "/"));
+  return SEARCH_EXCLUDED_PATH_PREFIXES.some(
+    (prefix) => rel === prefix || rel.startsWith(`${prefix}/`)
+  );
+}
+async function safeReadText(filePath, context) {
+  try {
+    return await readFile(filePath, "utf8");
+  } catch (error) {
+    await context.onProgress?.({
+      toolName: "Grep",
+      stream: "system",
+      text: `read skipped: ${relativePath(context.workspaceRoot, filePath)} (${formatDiagnosticError(error)})`
+    });
+    return null;
+  }
+}
+function formatDiagnosticError(error) {
+  return error instanceof Error ? error.message.replace(/\s+/g, " ").trim() : String(error);
+}
+async function tryRipgrepSearch(input, context, root, limit) {
+  const args = [
+    "--line-number",
+    "--no-heading",
+    "--color",
+    "never",
+    "--hidden",
+    "--no-ignore",
+    "--max-columns",
+    "500",
+    ...createRgExcludeArgs(root, context.workspaceRoot)
+  ];
+  const pattern = input.pattern.startsWith("(?i)") ? input.pattern.slice(4) : input.pattern;
+  if (input.pattern.startsWith("(?i)")) {
+    args.push("-i");
+  }
+  args.push("-e", pattern, relativePath(context.workspaceRoot, root));
+  const result = await runRipgrep(
+    args,
+    context,
+    limit,
+    (line) => normalizeRgGrepLine(line, context.workspaceRoot)
+  );
+  if (!result) return null;
+  const matches = result.lines.slice(0, limit);
+  return { matches, truncated: result.truncated };
+}
+async function tryRipgrepFiles(input, context, root, limit) {
+  const args = [
+    "--files",
+    "--color",
+    "never",
+    "--hidden",
+    "--no-ignore",
+    ...createRgExcludeArgs(root, context.workspaceRoot)
+  ];
+  args.push(relativePath(context.workspaceRoot, root));
+  const matcher = globToRegExp(input.pattern);
+  const result = await runRipgrep(args, context, limit, (line) => {
+    const normalized = normalizeRgPath(line, context.workspaceRoot, root);
+    return matcher.test(normalized) || matcher.test(basename(normalized)) ? normalized : null;
+  });
+  if (!result) return null;
+  return { matches: result.lines.slice(0, limit), truncated: result.truncated };
+}
+function createRgExcludeArgs(root, workspaceRoot) {
+  const searchRootRel = stripCurrentDirectoryPrefix(
+    relative(workspaceRoot, root).replaceAll("\\", "/")
+  );
+  return [
+    ...SEARCH_EXCLUDED_DIR_NAMES.filter(
+      (dir) => !isExplicitExcludedDirRoot(searchRootRel, dir)
+    ).map((dir) => `!**/${dir}/**`),
+    ...SEARCH_EXCLUDED_PATH_PREFIXES.filter((path) => !isSameOrInside(searchRootRel, path)).map(
+      (path) => `!**/${path}/**`
+    ),
+    ...SEARCH_EXCLUDED_FILE_SUFFIXES.filter((suffix) => !searchRootRel.endsWith(suffix)).map(
+      (suffix) => `!**/*${suffix}`
+    )
+  ].flatMap((pattern) => ["--glob", pattern]);
+}
+function isExplicitExcludedDirRoot(searchRootRel, dir) {
+  return searchRootRel === dir || searchRootRel.endsWith(`/${dir}`);
+}
+function isSameOrInside(value, parent) {
+  return value === parent || value.startsWith(`${parent}/`);
+}
+function normalizeRgPath(line, workspaceRoot, root) {
+  const filePath = resolve(workspaceRoot, line);
+  const rel = relative(root, filePath);
+  if (rel.startsWith("..") || isAbsolute(rel)) {
+    return stripCurrentDirectoryPrefix(line.replaceAll("\\", "/"));
+  }
+  return stripCurrentDirectoryPrefix(rel.replaceAll("\\", "/"));
+}
+function normalizeRgGrepLine(line, workspaceRoot) {
+  const firstColon = line.indexOf(":");
+  if (firstColon < 0) return normalizeRgPath(line, workspaceRoot, workspaceRoot);
+  const secondColon = line.indexOf(":", firstColon + 1);
+  if (secondColon < 0) return normalizeRgPath(line, workspaceRoot, workspaceRoot);
+  const file = normalizeRgPath(line.slice(0, firstColon), workspaceRoot, workspaceRoot);
+  return `${file}${line.slice(firstColon)}`;
+}
+function stripCurrentDirectoryPrefix(value) {
+  return value.replace(/^\.\/+/u, "");
+}
+async function runRipgrep(args, context, limit, mapLine = (line) => line) {
+  return new Promise((resolvePromise) => {
+    const child = spawn("rg", args, {
+      cwd: context.workspaceRoot,
+      shell: false,
+      windowsHide: true
+    });
+    const lines = [];
+    let pending = "";
+    let stderr = "";
+    let resolved = false;
+    let killedForLimit = false;
+    const timeout = setTimeout(() => {
+      if (!resolved) {
+        child.kill();
+      }
+    }, RG_TIMEOUT_MS);
+    const abort = () => child.kill();
+    context.abortSignal?.addEventListener("abort", abort, { once: true });
+    const finish = (value) => {
+      if (resolved) return;
+      resolved = true;
+      clearTimeout(timeout);
+      context.abortSignal?.removeEventListener("abort", abort);
+      resolvePromise(value);
+    };
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      pending += chunk;
+      const parts = pending.split(/\r?\n/u);
+      pending = parts.pop() ?? "";
+      for (const line of parts) {
+        if (!line) continue;
+        const mapped = mapLine(line);
+        if (!mapped) continue;
+        lines.push(mapped);
+        if (lines.length >= limit) {
+          killedForLimit = true;
+          child.kill();
+          break;
+        }
+      }
+    });
+    child.stderr.setEncoding("utf8");
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.on("error", () => finish(null));
+    child.on("close", (code) => {
+      if (pending && lines.length < limit) {
+        const mapped = mapLine(pending);
+        if (mapped) {
+          lines.push(mapped);
+        }
+      }
+      if (killedForLimit) {
+        finish({ lines, truncated: true });
+        return;
+      }
+      if (code === 0 || code === 1) {
+        finish({ lines, truncated: false });
+        return;
+      }
+      if (stderr) {
+        finish(null);
+        return;
+      }
+      finish(null);
+    });
+  });
+}
+function globToRegExp(pattern) {
+  const startsWithDoubleStarSlash = pattern.startsWith("**/");
+  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "::DOUBLE_STAR::").replace(/\*/g, "[^/]*").replace(/::DOUBLE_STAR::/g, ".*").replace(/\?/g, ".");
+  let result = `^${escaped}$`;
+  if (startsWithDoubleStarSlash) {
+    result = result.replace(/^\^\.\*\//u, "^(?:.*/)?");
+  }
+  return new RegExp(result);
+}
+function runShell(command, cwd, timeoutMs, signal, onProgress) {
+  return new Promise((resolvePromise) => {
+    const child = spawn(command, { cwd, shell: true, windowsHide: true });
+    let output = "";
+    let settled = false;
+    let forcedKillTimer;
+    let stoppingOutcome;
+    let childClosed = false;
+    const finish = (exitCode, nextOutput = output, outcome = "completed") => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timer);
+      if (forcedKillTimer && outcome === "completed") {
+        clearTimeout(forcedKillTimer);
+      }
+      signal?.removeEventListener("abort", onAbort);
+      resolvePromise({ exitCode, output: nextOutput, outcome });
+    };
+    const waitForChildClose = () => new Promise((resolveClose) => {
+      if (childClosed || child.exitCode !== null || child.signalCode !== null) {
+        resolveClose();
+        return;
+      }
+      child.once("close", () => resolveClose());
+    });
+    const requestStop = async (force) => {
+      if (process.platform === "win32" && child.pid) {
+        await stopWindowsProcessTree(child.pid, cwd);
+        return;
+      }
+      child.kill(force ? "SIGKILL" : "SIGTERM");
+      if (force) {
+        await waitForChildClose();
+      }
+    };
+    const scheduleForceStop = () => {
+      forcedKillTimer = setTimeout(() => {
+        void requestStop(true);
+      }, 1e3);
+    };
+    const onAbort = async () => {
+      const message = "\n\u5DE5\u5177\u8C03\u7528\u5DF2\u53D6\u6D88\uFF0C\u6B63\u5728\u7EC8\u6B62\u5B50\u8FDB\u7A0B\u3002";
+      output += message;
+      onProgress?.("system", `${message}
+`);
+      stoppingOutcome = "cancelled";
+      if (process.platform === "win32") {
+        await requestStop(true);
+      } else {
+        void requestStop(false);
+        scheduleForceStop();
+      }
+      finish(1, output, "cancelled");
+    };
+    const timer = setTimeout(() => {
+      void handleTimeout();
+    }, timeoutMs);
+    const handleTimeout = async () => {
+      const message = `
+\u547D\u4EE4\u8D85\u65F6\uFF1A\u8D85\u8FC7 ${timeoutMs}ms\uFF0C\u5DF2\u5C1D\u8BD5\u7EC8\u6B62\u5B50\u8FDB\u7A0B\u3002`;
+      output += message;
+      onProgress?.("system", `${message}
+`);
+      stoppingOutcome = "timeout";
+      if (process.platform === "win32") {
+        await requestStop(true);
+      } else {
+        void requestStop(false);
+        scheduleForceStop();
+      }
+      finish(1, output, "timeout");
+    };
+    if (signal?.aborted) {
+      onAbort();
+      return;
+    }
+    signal?.addEventListener("abort", onAbort, { once: true });
+    child.stdout.on("data", (chunk) => {
+      const text = decodeShellChunk(chunk);
+      output += text;
+      onProgress?.("stdout", text);
+    });
+    child.stderr.on("data", (chunk) => {
+      const text = decodeShellChunk(chunk);
+      output += text;
+      onProgress?.("stderr", text);
+    });
+    child.on("close", (code) => {
+      childClosed = true;
+      if (stoppingOutcome) {
+        return;
+      }
+      finish(code ?? 1);
+    });
+    child.on("error", (error) => {
+      finish(1, `\u547D\u4EE4\u6267\u884C\u5931\u8D25\uFF1A${error.message}`);
+    });
+  });
+}
+function decodeShellChunk(chunk) {
+  const utf8 = chunk.toString("utf8");
+  if (process.platform !== "win32") return utf8;
+  if (!utf8.includes("\uFFFD")) return utf8;
+  try {
+    const decoder = new TextDecoder("gb18030", { fatal: false });
+    const gbk = decoder.decode(chunk);
+    const utf8Errors = utf8.split("\uFFFD").length - 1;
+    const gbkErrors = gbk.split("\uFFFD").length - 1;
+    if (gbkErrors < utf8Errors) return gbk;
+  } catch {
+  }
+  return utf8;
+}
+async function stopWindowsProcessTree(rootPid, cwd) {
+  const deadline = Date.now() + 900;
+  await taskkillWindowsPids([rootPid]);
+  while (Date.now() < deadline) {
+    await stopWindowsWorkspaceProcesses(rootPid, cwd);
+    await sleep(50);
+  }
+}
+function sleep(ms) {
+  return new Promise((resolveSleep) => setTimeout(resolveSleep, ms));
+}
+function taskkillWindowsPids(pids) {
+  return new Promise((resolveStop) => {
+    const uniquePids = [...new Set(pids.filter((pid) => Number.isInteger(pid) && pid > 0))];
+    if (uniquePids.length === 0) {
+      resolveStop();
+      return;
+    }
+    const args = [...uniquePids.flatMap((pid) => ["/pid", String(pid)]), "/t", "/f"];
+    const killer = spawn("taskkill", args, { windowsHide: true });
+    const stopTimeout = setTimeout(() => {
+      killer.kill("SIGKILL");
+      resolveStop();
+    }, 750);
+    const finishStop = () => {
+      clearTimeout(stopTimeout);
+      resolveStop();
+    };
+    killer.on("error", finishStop);
+    killer.on("close", finishStop);
+  });
+}
+function stopWindowsWorkspaceProcesses(rootPid, cwd) {
+  return new Promise((resolveStop) => {
+    const script = `
+$rootPid = ${rootPid}
+$cwd = ${JSON.stringify(cwd)}
+$rows = @(Get-CimInstance Win32_Process | Select-Object ProcessId,ParentProcessId,CommandLine)
+$children = @{}
+foreach ($row in $rows) {
+  $parent = [int]$row.ParentProcessId
+  if (-not $children.ContainsKey($parent)) { $children[$parent] = @() }
+  $children[$parent] += [int]$row.ProcessId
+}
+$queue = New-Object System.Collections.Generic.Queue[int]
+$seen = New-Object 'System.Collections.Generic.HashSet[int]'
+$queue.Enqueue($rootPid)
+$pids = @()
+while ($queue.Count -gt 0) {
+  $pid = $queue.Dequeue()
+  if (-not $seen.Add($pid)) { continue }
+  $pids += $pid
+  if ($children.ContainsKey($pid)) {
+    foreach ($childPid in $children[$pid]) { $queue.Enqueue($childPid) }
+  }
+}
+$cwdLower = $cwd.ToLowerInvariant()
+foreach ($row in $rows) {
+  $cmd = [string]$row.CommandLine
+  if ($cmd.ToLowerInvariant().Contains($cwdLower)) { $pids += [int]$row.ProcessId }
+}
+$pids = $pids | Sort-Object -Unique
+foreach ($targetPid in $pids) {
+  if ($targetPid -gt 0 -and $targetPid -ne $PID) {
+    Stop-Process -Id $targetPid -Force -ErrorAction SilentlyContinue
+  }
+}
+`;
+    const killer = spawn("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", script], {
+      windowsHide: true
+    });
+    const stopTimeout = setTimeout(() => {
+      killer.kill("SIGKILL");
+      resolveStop();
+    }, 900);
+    const finishStop = () => {
+      clearTimeout(stopTimeout);
+      resolveStop();
+    };
+    killer.on("error", finishStop);
+    killer.on("close", finishStop);
+  });
+}
+function findTodo(items, id, content) {
+  const item = items.find((todo) => todo.id === id);
+  if (item) return item;
+  const normalizedContent = normalizeTodoContent(content);
+  if (normalizedContent) {
+    const matches = items.filter((todo) => normalizeTodoContent(todo.content) === normalizedContent);
+    if (matches.length === 1) return matches[0];
+    if (matches.length > 1) {
+      throw new Error(`\u672A\u627E\u5230\u552F\u4E00 Todo\uFF1A${id}\u3002content \u5339\u914D\u5230 ${matches.length} \u6761\uFF1B\u5EFA\u8BAE\uFF1A\u5148\u8FD0\u884C /todo \u67E5\u770B\u5F53\u524D\u4EFB\u52A1\u3002`);
+    }
+  }
+  throw new Error(`\u672A\u627E\u5230 Todo\uFF1A${id}\u3002\u5EFA\u8BAE\uFF1A\u5148\u8FD0\u884C /todo \u67E5\u770B\u5F53\u524D\u4EFB\u52A1\u3002`);
+}
+function normalizeTodoContent(content) {
+  return (content ?? "").trim().replace(/\s+/gu, " ");
+}
+function formatTodos(items) {
+  if (items.length === 0) {
+    return "\u5F53\u524D\u6CA1\u6709 Todo\u3002";
+  }
+  return items.map((item) => {
+    const evidence = item.evidence ? `\uFF08${item.evidence}\uFF09` : "";
+    return `${item.id}. [${item.status}] ${item.content}${evidence}`;
+  }).join("\n");
+}
+function unique(items) {
+  return [...new Set(items)];
+}
+var __testGlobToRegExp = globToRegExp;
+var __testDecodeShellChunk = decodeShellChunk;
+export {
+  __testDecodeShellChunk,
+  __testGlobToRegExp,
+  adaptShellCommand,
+  adaptShellCommandForPlatform,
+  builtInTools,
+  createTool,
+  createToolContext,
+  runTool,
+  toolRegistryStatus
+};