@linghun/tools 0.1.1 → 0.1.3

package/dist/index.js

@@ -1,64 +1,89 @@
+import {
+  formatFetchOutput,
+  webFetch
+} from "./chunk-4UHQWBFA.js";
 import {
   applyDomainFilter,
   bingSearch,
   formatSearchOutput
 } from "./chunk-EPIB4FSE.js";
 import {
-  formatFetchOutput,
-  webFetch
-} from "./chunk-4UHQWBFA.js";
+  runBashServiceLifecycleAction,
+  startBashService
+} from "./chunk-236QJATI.js";
 import {
   createTool
 } from "./chunk-MMJX44V6.js";
 import {
   toolPrompts
-} from "./chunk-3JCXABUK.js";
+} from "./chunk-F7UOI3YR.js";
 import {
   toolUserFacingNames
-} from "./chunk-QNZMO55X.js";
+} from "./chunk-J7O24FJB.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-MFHY7PBM.js";
-import "./chunk-SZFZPQGL.js";
-import "./chunk-XZWSO5CM.js";
-import "./chunk-LGZOG7IQ.js";
-import "./chunk-ZYAEUABC.js";
-import "./chunk-SWK6XRZQ.js";
 import "./chunk-VJDLOFCF.js";
 import "./chunk-3RP665TH.js";
 import "./chunk-IOC3BSPT.js";
-import "./chunk-DN3KJZRV.js";
-import "./chunk-2U4BZXAI.js";
-import "./chunk-ITBZHMZQ.js";
+import "./chunk-LGZOG7IQ.js";
+import "./chunk-ZYAEUABC.js";
+import "./chunk-SWK6XRZQ.js";
+import "./chunk-YR4HWOR2.js";
+import "./chunk-VAFW24RN.js";
 import "./chunk-TZ6QK52L.js";
 import "./chunk-K3YDFDLP.js";
-import "./chunk-HNIVNZIS.js";
+import "./chunk-GI5XI4HN.js";
+import "./chunk-WEWXKRKL.js";
+import "./chunk-A6FUAM64.js";
+import "./chunk-YCO6C7KF.js";
+import "./chunk-4567YAXM.js";
+import "./chunk-XZWSO5CM.js";
+import "./chunk-SZFZPQGL.js";
 import "./chunk-WLQ7DGMG.js";
 import "./chunk-SQP6SJRP.js";
 import "./chunk-BRG64AEC.js";
 import "./chunk-AZCQL24J.js";
 import "./chunk-HUIZOB4A.js";
 import "./chunk-MK3YP2VR.js";
-import "./chunk-VZWMPUSS.js";
-import "./chunk-E75PYM7V.js";
-import "./chunk-GAWMEMXB.js";
+import "./chunk-HNIVNZIS.js";
 import "./chunk-7ZOADACP.js";
 import "./chunk-H5OOD2OS.js";
 import "./chunk-IQP3XE32.js";
+import "./chunk-Z3H6SZBS.js";
+import "./chunk-ITBZHMZQ.js";
+import "./chunk-2U4BZXAI.js";
+import {
+  checkArtifact
+} from "./chunk-SPAD4DZS.js";
+import "./chunk-2DIXRINW.js";
+import "./chunk-PKMIDA5A.js";
+import "./chunk-GAWMEMXB.js";
+import {
+  inspectBinaryFile
+} from "./chunk-XG6HNLY6.js";
+import {
+  interpretCommandResult
+} from "./chunk-FI4YPDFE.js";
 
 // src/index.ts
 import { spawn } from "child_process";
 import { createHash, randomUUID } from "crypto";
+import { closeSync, createWriteStream, openSync } from "fs";
 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 MAX_READ_SNIPPET_RANGES = 20;
+var MAX_READ_SNIPPET_LINES = 120;
+var MAX_READ_SNIPPET_OUTPUT_CHARS = 2e5;
+var SOURCE_PACK_DEFAULT_LIMIT = 6;
+var SOURCE_PACK_MAX_LIMIT = 12;
+var SOURCE_PACK_CONTEXT_LINES = 8;
+var SOURCE_PACK_MAX_TERMS = 6;
 var BASH_PREVIEW_LIMIT = 3e4;
 var BASH_TIMEOUT_MS = 12e4;
 var MAX_TODO_ITEMS = 100;
@@ -66,13 +91,16 @@ var SEARCH_EXCLUDED_DIR_NAMES = ["node_modules", "dist", ".git", ".codebase-memo
 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()) {
+function createToolContext(workspaceRoot = process.cwd(), options = {}) {
   return {
     workspaceRoot: resolve(workspaceRoot),
     changedFiles: [],
     todos: [],
     readSnapshots: {},
-    patchSummaries: {}
+    sourcePackCandidates: options.sourcePackCandidates,
+    patchSummaries: {},
+    recentDiagnostics: [],
+    services: []
   };
 }
 async function runTool(name, input, context) {
@@ -116,6 +144,52 @@ var toolDefinitions = {
     getToolUseSummary: (input) => `Read ${input.path}`,
     getActivityDescription: (input) => `Reading ${input.path}`
   }),
+  ReadSnippets: defineTool({
+    name: "ReadSnippets",
+    title: "\u8BFB\u53D6\u4EE3\u7801\u7247\u6BB5",
+    description: "\u4E00\u6B21\u8BFB\u53D6\u591A\u4E2A\u5DE5\u4F5C\u533A\u6587\u4EF6\u8303\u56F4\u3002",
+    permission: {
+      risk: "low",
+      scope: "workspace",
+      reason: "\u53EA\u8BFB\u67E5\u770B\u591A\u4E2A\u6587\u4EF6\u7247\u6BB5\u3002",
+      phase06Mode: "metadata-only"
+    },
+    isReadOnly: true,
+    isConcurrencySafe: true,
+    lifecycle: {
+      ...readOnlyLifecycle(),
+      maxResultSizeChars: MAX_READ_SNIPPET_OUTPUT_CHARS + 2e3
+    },
+    validateInput: validateReadSnippetsInput,
+    call: readSnippetsTool,
+    prompt: () => toolPrompts.ReadSnippets,
+    userFacingName: () => toolUserFacingNames.ReadSnippets,
+    getToolUseSummary: (input) => `ReadSnippets ${input.ranges.length} ranges`,
+    getActivityDescription: (input) => `Reading ${input.ranges.length} snippets`
+  }),
+  SourcePack: defineTool({
+    name: "SourcePack",
+    title: "\u5B9A\u4F4D\u4EE3\u7801\u7247\u6BB5",
+    description: "\u6309\u67E5\u8BE2\u5B9A\u4F4D\u5E76\u8FD4\u56DE\u5019\u9009\u4EE3\u7801\u7247\u6BB5\u3002",
+    permission: {
+      risk: "low",
+      scope: "workspace",
+      reason: "\u53EA\u8BFB\u641C\u7D22\u5E76\u8FD4\u56DE\u5019\u9009\u4EE3\u7801\u7247\u6BB5\u3002",
+      phase06Mode: "metadata-only"
+    },
+    isReadOnly: true,
+    isConcurrencySafe: true,
+    lifecycle: {
+      ...readOnlyLifecycle(),
+      maxResultSizeChars: MAX_READ_SNIPPET_OUTPUT_CHARS + 2e3
+    },
+    validateInput: validateSourcePackInput,
+    call: sourcePackTool,
+    prompt: () => toolPrompts.SourcePack,
+    userFacingName: () => toolUserFacingNames.SourcePack,
+    getToolUseSummary: (input) => `SourcePack ${input.query}`,
+    getActivityDescription: (input) => `Locating snippets for ${input.query}`
+  }),
   Write: defineTool({
     name: "Write",
     title: "\u5199\u5165\u6587\u4EF6",
@@ -234,7 +308,7 @@ var toolDefinitions = {
     call: bashTool,
     prompt: () => toolPrompts.Bash,
     userFacingName: () => toolUserFacingNames.Bash,
-    getToolUseSummary: (input) => `Bash ${input.command}`,
+    getToolUseSummary: (input) => input.artifact ? `Bash artifact ${input.artifact.path}` : input.binary ? `Bash binary ${input.binary.path}` : `Bash ${input.command}`,
     getActivityDescription: () => "Running command"
   }),
   Todo: defineTool({
@@ -420,6 +494,46 @@ function validateReadInput(input) {
     limit: readOptionalPositiveInteger(record, "limit", "Read")
   };
 }
+function validateReadSnippetsInput(input) {
+  const record = validateRecord(input, "ReadSnippets");
+  const ranges = record.ranges;
+  if (!Array.isArray(ranges) || ranges.length === 0) {
+    throw new Error("ReadSnippets.ranges \u5FC5\u987B\u662F\u975E\u7A7A\u6570\u7EC4\u3002");
+  }
+  if (ranges.length > MAX_READ_SNIPPET_RANGES) {
+    throw new Error(`ReadSnippets.ranges \u6700\u591A ${MAX_READ_SNIPPET_RANGES} \u4E2A\u8303\u56F4\u3002`);
+  }
+  return {
+    ranges: ranges.map((item, index) => {
+      const range = validateRecord(item, "ReadSnippets");
+      const start = readPositiveLineNumber(range, "start", "ReadSnippets");
+      const end = readPositiveLineNumber(range, "end", "ReadSnippets");
+      if (end < start) {
+        throw new Error(`ReadSnippets.ranges[${index}].end \u5FC5\u987B\u5927\u4E8E\u7B49\u4E8E start\u3002`);
+      }
+      return {
+        path: readString(range, "path", "ReadSnippets"),
+        start,
+        end
+      };
+    })
+  };
+}
+function validateSourcePackInput(input) {
+  const record = validateRecord(input, "SourcePack");
+  const limit = readOptionalPositiveInteger(record, "limit", "SourcePack");
+  return {
+    query: readString(record, "query", "SourcePack"),
+    limit: limit === void 0 ? void 0 : Math.min(Math.max(limit, 1), SOURCE_PACK_MAX_LIMIT)
+  };
+}
+function readPositiveLineNumber(record, key, toolName) {
+  const value = record[key];
+  if (!Number.isInteger(value) || value < 1) {
+    throw new Error(`${toolName}.${key} \u5FC5\u987B\u662F 1-based \u6B63\u6574\u6570\u884C\u53F7\u3002`);
+  }
+  return value;
+}
 function validateWriteInput(input) {
   const record = validateRecord(input, "Write");
   return {
@@ -472,12 +586,122 @@ function validateGlobInput(input) {
   };
 }
 function validateBashInput(input) {
+  const record = validateRecord(input, "Bash");
+  const command = readOptionalString(record, "command", "Bash");
+  const binary = validateOptionalBashBinaryInspect(record.binary);
+  const artifact = validateOptionalBashArtifactCheck(record.artifact);
+  const service = validateOptionalBashServiceInput(record.service);
+  const serviceAction = isBashServiceLifecycleAction(service);
+  if (command === void 0 && binary === void 0 && artifact === void 0 && !serviceAction) {
+    throw new Error("Bash.command\u3001Bash.binary\u3001Bash.artifact \u6216 Bash.service action \u5FC5\u987B\u63D0\u4F9B\u4E00\u4E2A\u3002");
+  }
+  const modeCount = [
+    command !== void 0,
+    binary !== void 0,
+    artifact !== void 0,
+    serviceAction
+  ].filter(Boolean).length;
+  if (modeCount > 1 || (binary !== void 0 || artifact !== void 0) && service !== void 0) {
+    throw new Error("Bash.command\u3001Bash.binary\u3001Bash.artifact \u548C Bash.service \u4E0D\u80FD\u6DF7\u7528\u3002");
+  }
+  if (service !== void 0 && !serviceAction && command === void 0) {
+    throw new Error("Bash.service readiness \u5FC5\u987B\u548C Bash.command \u4E00\u8D77\u4F7F\u7528\u3002");
+  }
+  const runInBackground = record.runInBackground === true || record.run_in_background === true;
+  return {
+    command,
+    timeoutMs: readOptionalPositiveInteger(record, "timeoutMs", "Bash"),
+    service,
+    binary,
+    artifact,
+    ...runInBackground ? { runInBackground: true } : {}
+  };
+}
+function validateOptionalBashBinaryInspect(input) {
+  if (input === void 0) return void 0;
+  if (isEmptyOptionalObject(input)) return void 0;
+  const record = validateRecord(input, "Bash");
+  return {
+    path: readString(record, "path", "Bash"),
+    previewBytes: readOptionalPositiveInteger(record, "previewBytes", "Bash")
+  };
+}
+function validateOptionalBashArtifactCheck(input) {
+  if (input === void 0) return void 0;
+  if (isEmptyOptionalObject(input)) return void 0;
   const record = validateRecord(input, "Bash");
   return {
-    command: readString(record, "command", "Bash"),
-    timeoutMs: readOptionalPositiveInteger(record, "timeoutMs", "Bash")
+    path: readString(record, "path", "Bash"),
+    expectHeader: readOptionalString(record, "expectHeader", "Bash"),
+    expectMagic: readOptionalString(record, "expectMagic", "Bash"),
+    json: readOptionalBoolean(record, "json", "Bash"),
+    executable: readOptionalBoolean(record, "executable", "Bash"),
+    protectPaths: readOptionalStringArray(record, "protectPaths", "Bash"),
+    text: validateOptionalBashArtifactTextCheck(record.text),
+    preserve: validateOptionalBashArtifactPreserveCheck(record.preserve)
   };
 }
+function validateOptionalBashServiceInput(input) {
+  if (input === void 0) return void 0;
+  if (isEmptyOptionalObject(input)) return void 0;
+  const record = validateRecord(input, "Bash");
+  const action = readOptionalString(record, "action", "Bash");
+  if (action !== void 0) {
+    if (action === "fetch") {
+      const url = readString(record, "url", "Bash");
+      validateHttpUrl(url);
+      return {
+        action,
+        url,
+        expectStatus: readOptionalPositiveInteger(record, "expectStatus", "Bash"),
+        bodyContains: readOptionalStringOrStringArray(record, "bodyContains", "Bash"),
+        timeoutMs: readOptionalPositiveInteger(record, "timeoutMs", "Bash"),
+        retry: readOptionalPositiveInteger(record, "retry", "Bash"),
+        intervalMs: readOptionalPositiveInteger(record, "intervalMs", "Bash")
+      };
+    }
+    if (action === "status" || action === "probe" || action === "logs" || action === "stop") {
+      return {
+        action,
+        serviceId: readString(record, "serviceId", "Bash"),
+        ...action === "logs" ? { tailBytes: readOptionalPositiveInteger(record, "tailBytes", "Bash") } : {}
+      };
+    }
+    throw new Error("Bash.service.action \u5FC5\u987B\u662F status/probe/logs/stop/fetch\u3002");
+  }
+  const type = readString(record, "type", "Bash");
+  const timeoutMs = readOptionalPositiveInteger(record, "timeoutMs", "Bash");
+  const intervalMs = readOptionalPositiveInteger(record, "intervalMs", "Bash");
+  if (type === "tcp") {
+    const rawPort = record.port;
+    if (!Number.isInteger(rawPort) || rawPort <= 0) {
+      throw new Error("Bash.service.port \u5FC5\u987B\u662F\u6B63\u6574\u6570\u3002");
+    }
+    const port = rawPort;
+    if (port > 65535) {
+      throw new Error("Bash.service.port \u5FC5\u987B\u5728 1-65535 \u8303\u56F4\u5185\u3002");
+    }
+    return {
+      type,
+      port,
+      host: readOptionalString(record, "host", "Bash"),
+      timeoutMs,
+      intervalMs
+    };
+  }
+  if (type === "http") {
+    const url = readString(record, "url", "Bash");
+    validateHttpUrl(url);
+    return { type, url, timeoutMs, intervalMs };
+  }
+  throw new Error("Bash.service.type \u5FC5\u987B\u662F tcp \u6216 http\u3002");
+}
+function isEmptyOptionalObject(input) {
+  return input === null || typeof input === "object" && !Array.isArray(input) && Object.keys(input).length === 0;
+}
+function isBashServiceLifecycleAction(input) {
+  return Boolean(input && "action" in input);
+}
 function validateTodoInput(input) {
   const record = validateRecord(input, "Todo");
   const action = readString(record, "action", "Todo");
@@ -535,6 +759,53 @@ function readOptionalStringArray(record, key, toolName) {
   }
   return value;
 }
+function readOptionalBoolean(record, key, toolName) {
+  const value = record[key];
+  if (value === void 0) return void 0;
+  if (typeof value !== "boolean") {
+    throw new Error(`${toolName}.${key} \u5FC5\u987B\u662F boolean \u6216 undefined\u3002`);
+  }
+  return value;
+}
+function readOptionalStringOrStringArray(record, key, toolName) {
+  const value = record[key];
+  if (value === void 0) return void 0;
+  if (typeof value === "string") return value;
+  if (Array.isArray(value) && value.every((item) => typeof item === "string")) return value;
+  throw new Error(`${toolName}.${key} \u5FC5\u987B\u662F\u5B57\u7B26\u4E32\u3001\u5B57\u7B26\u4E32\u6570\u7EC4\u6216 undefined\u3002`);
+}
+function validateOptionalBashArtifactTextCheck(input) {
+  if (input === void 0) return void 0;
+  const record = validateRecord(input, "Bash");
+  return {
+    exact: readOptionalString(record, "exact", "Bash"),
+    contains: readOptionalStringOrStringArray(record, "contains", "Bash"),
+    lineSet: readOptionalStringArray(record, "lineSet", "Bash")
+  };
+}
+function validateOptionalBashArtifactPreserveCheck(input) {
+  if (input === void 0) return void 0;
+  const record = validateRecord(input, "Bash");
+  const mode = readString(record, "mode", "Bash");
+  if (mode !== "rawPreserve" && mode !== "compareNormalizedHtml") {
+    throw new Error("Bash.artifact.preserve.mode \u5FC5\u987B\u662F rawPreserve \u6216 compareNormalizedHtml\u3002");
+  }
+  return {
+    mode,
+    expectedPath: readOptionalString(record, "expectedPath", "Bash"),
+    expectedText: readOptionalString(record, "expectedText", "Bash")
+  };
+}
+function validateHttpUrl(url) {
+  try {
+    const parsed = new URL(url);
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+      throw new Error("protocol");
+    }
+  } catch {
+    throw new Error("Bash.service.url \u5FC5\u987B\u662F http/https URL\u3002");
+  }
+}
 async function readTool(input, context) {
   const filePath = resolveWorkspacePath(context.workspaceRoot, input.path);
   const content = await readFile(filePath, "utf8");
@@ -566,6 +837,183 @@ async function readTool(input, context) {
     truncated
   };
 }
+async function readSnippetsTool(input, context) {
+  const ranges = [];
+  let remainingChars = MAX_READ_SNIPPET_OUTPUT_CHARS;
+  let safetyTruncated = false;
+  for (const range of input.ranges) {
+    const requestedEnd = range.end;
+    const boundedEnd = Math.min(range.end, range.start + MAX_READ_SNIPPET_LINES - 1);
+    const rangeLineTruncated = boundedEnd < requestedEnd;
+    try {
+      const filePath = resolveWorkspacePath(context.workspaceRoot, range.path);
+      const content = await readFile(filePath, "utf8");
+      const info = await stat(filePath);
+      rememberReadSnapshot(context, filePath, content, info);
+      const lines = splitContentLines(content);
+      const selected = lines.slice(range.start - 1, boundedEnd);
+      const actualEnd = selected.length > 0 ? range.start + selected.length - 1 : range.start - 1;
+      const numbered = selected.map((line, index) => `${range.start + index}	${line}`).join("\n");
+      const capped = applySnippetSafetyCap(numbered, remainingChars);
+      remainingChars -= capped.usedChars;
+      safetyTruncated ||= capped.truncated;
+      ranges.push({
+        path: relativePath(context.workspaceRoot, filePath),
+        start: range.start,
+        end: actualEnd,
+        content: capped.content,
+        requestedStart: range.start,
+        requestedEnd,
+        totalLines: lines.length,
+        truncated: rangeLineTruncated || capped.truncated
+      });
+      if (capped.truncated) {
+        remainingChars = 0;
+      }
+    } catch (error) {
+      ranges.push({
+        path: range.path,
+        start: range.start,
+        end: boundedEnd,
+        content: "",
+        requestedStart: range.start,
+        requestedEnd,
+        truncated: rangeLineTruncated,
+        error: formatDiagnosticError(error)
+      });
+    }
+  }
+  const text = formatReadSnippetsOutput(ranges, safetyTruncated);
+  const okCount = ranges.filter((range) => !range.error).length;
+  return {
+    text,
+    summary: `ReadSnippets: ${okCount}/${ranges.length} ranges`,
+    data: {
+      ranges,
+      count: okCount,
+      requestedRanges: input.ranges.length,
+      safetyTruncated
+    },
+    truncated: ranges.some((range) => range.truncated) || safetyTruncated
+  };
+}
+function applySnippetSafetyCap(content, remainingChars) {
+  if (remainingChars <= 0) {
+    return {
+      content: "...\uFF08\u7ED3\u679C\u5DF2\u622A\u65AD\uFF0C\u540E\u7EED\u5185\u5BB9\u7701\u7565\uFF1B\u5982\u9700\u7CBE\u8BFB\u8BF7\u6307\u5B9A\u66F4\u5C0F\u8303\u56F4\u3002\uFF09",
+      usedChars: 0,
+      truncated: true
+    };
+  }
+  if (content.length <= remainingChars) {
+    return { content, usedChars: content.length, truncated: false };
+  }
+  const suffix = "\n...\uFF08\u7ED3\u679C\u5DF2\u622A\u65AD\uFF0C\u540E\u7EED\u5185\u5BB9\u7701\u7565\uFF1B\u5982\u9700\u7CBE\u8BFB\u8BF7\u6307\u5B9A\u66F4\u5C0F\u8303\u56F4\u3002\uFF09";
+  const sliceLength = Math.max(0, remainingChars - suffix.length);
+  return {
+    content: `${content.slice(0, sliceLength)}${suffix}`,
+    usedChars: remainingChars,
+    truncated: true
+  };
+}
+function formatReadSnippetsOutput(ranges, safetyTruncated) {
+  const lines = [];
+  for (const range of ranges) {
+    const header = `${range.path}:${range.start}-${range.end}`;
+    if (range.error) {
+      lines.push(`${header}
+ERROR: ${range.error}`);
+      continue;
+    }
+    lines.push(`${header}
+${range.content}`);
+    if (range.truncated) {
+      lines.push("...\uFF08\u8BE5\u8303\u56F4\u5DF2\u622A\u65AD\uFF1B\u53EF\u7EE7\u7EED\u8BFB\u53D6\u540E\u7EED\u8303\u56F4\u3002\uFF09");
+    }
+  }
+  if (safetyTruncated) {
+    lines.push("...\uFF08\u7ED3\u679C\u5DF2\u622A\u65AD\uFF0C\u540E\u7EED\u5185\u5BB9\u7701\u7565\uFF1B\u5982\u9700\u7CBE\u8BFB\u8BF7\u6307\u5B9A\u66F4\u5C0F\u8303\u56F4\u3002\uFF09");
+  }
+  return lines.join("\n\n");
+}
+async function sourcePackTool(input, context) {
+  const limit = input.limit ?? SOURCE_PACK_DEFAULT_LIMIT;
+  const terms = extractSourcePackTerms(input.query);
+  if (terms.length === 0) {
+    return {
+      text: "empty: query did not contain searchable terms.",
+      summary: "SourcePack: 0 snippets",
+      data: { query: input.query, snippets: [], count: 0, empty: true }
+    };
+  }
+  const matchResult = await findSourcePackMatches(input.query, terms, context, limit * 4);
+  const snippets = [];
+  const seen = /* @__PURE__ */ new Set();
+  let remainingChars = MAX_READ_SNIPPET_OUTPUT_CHARS;
+  let safetyTruncated = false;
+  for (const match of matchResult.matches) {
+    if (snippets.length >= limit) break;
+    const start = match.start ?? Math.max(1, match.line - SOURCE_PACK_CONTEXT_LINES);
+    const end = match.end ?? match.line + SOURCE_PACK_CONTEXT_LINES;
+    const key = `${match.path}:${start}:${end}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    try {
+      const filePath = resolveWorkspacePath(context.workspaceRoot, match.path);
+      const content = await readFile(filePath, "utf8");
+      const info = await stat(filePath);
+      rememberReadSnapshot(context, filePath, content, info);
+      const lines = splitContentLines(content);
+      const boundedEnd = Math.min(end, lines.length);
+      const selected = lines.slice(start - 1, boundedEnd);
+      const numbered = selected.map((line, index) => `${start + index}	${line}`).join("\n");
+      const capped = applySnippetSafetyCap(numbered, remainingChars);
+      remainingChars -= capped.usedChars;
+      safetyTruncated ||= capped.truncated;
+      snippets.push({
+        path: relativePath(context.workspaceRoot, filePath),
+        start,
+        end: boundedEnd,
+        content: capped.content,
+        requestedStart: start,
+        requestedEnd: end,
+        totalLines: lines.length,
+        truncated: capped.truncated,
+        reason: match.reason ?? `matched "${match.term}" at line ${match.line}`,
+        confidence: estimateSourcePackConfidence(input.query, match),
+        source: match.source
+      });
+      if (capped.truncated) {
+        break;
+      }
+    } catch {
+      continue;
+    }
+  }
+  if (snippets.length === 0) {
+    return {
+      text: "empty: no matching source snippets found.",
+      summary: "SourcePack: 0 snippets",
+      data: { query: input.query, snippets: [], count: 0, empty: true }
+    };
+  }
+  const text = formatSourcePackOutput(snippets, safetyTruncated);
+  return {
+    text,
+    summary: `SourcePack: ${snippets.length} snippets`,
+    data: {
+      query: input.query,
+      snippets,
+      count: snippets.length,
+      searchedTerms: terms,
+      source: matchResult.source,
+      fallback: matchResult.source !== "index",
+      candidatePaths: unique(snippets.map((snippet) => snippet.path)),
+      safetyTruncated
+    },
+    truncated: safetyTruncated || snippets.some((snippet) => snippet.truncated)
+  };
+}
 function splitContentLines(content) {
   if (content.length === 0) {
     return [];
@@ -734,11 +1182,70 @@ function sanitizeSecrets(text) {
   return sanitized;
 }
 async function bashTool(input, context) {
+  if (input.artifact) {
+    return checkArtifact({
+      input: input.artifact,
+      target: resolveArtifactPath(context, input.artifact.path),
+      protectPaths: (input.artifact.protectPaths ?? []).map((path) => resolveArtifactPath(context, path)),
+      context
+    });
+  }
+  if (input.binary) {
+    return inspectBinaryFile(input.binary, resolveWorkspacePath(context.workspaceRoot, input.binary.path));
+  }
+  if (!input.command) {
+    if (isBashServiceLifecycleAction(input.service)) {
+      return runBashServiceLifecycleAction(input.service, context);
+    }
+    throw new Error("Bash.command\u3001Bash.binary \u6216 Bash.service action \u5FC5\u987B\u63D0\u4F9B\u4E00\u4E2A\u3002");
+  }
   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);
+  if (input.service && !isBashServiceLifecycleAction(input.service)) {
+    const readiness = withDefaultServiceReadiness(input.service, context);
+    return startBashService({
+      command: adapted.command,
+      logCommand: adapted.logCommand ?? adapted.command,
+      cwd: context.workspaceRoot,
+      fullOutputPath,
+      readiness,
+      context,
+      abortSignal: context.abortSignal,
+      onProgress: (stream, text) => void context.onProgress?.({ toolName: "Bash", stream, text }),
+      trackChildProcess: context.trackChildProcess,
+      sanitizeText: sanitizeSecrets
+    });
+  }
+  if (input.runInBackground === true) {
+    const taskId = randomUUID();
+    void runBackgroundBash({
+      taskId,
+      command: adapted.command,
+      originalCommand: input.command,
+      cwd: context.workspaceRoot,
+      timeoutMs,
+      fullOutputPath,
+      adapter: adapted.adapter,
+      logCommand: adapted.logCommand,
+      retainAfterReturn: isHeadlessBenchContext(context),
+      abortSignal: context.abortSignal,
+      trackChildProcess: context.trackChildProcess,
+      onComplete: context.onBackgroundBashComplete
+    });
+    return {
+      text: `\u547D\u4EE4\u5DF2\u5728\u540E\u53F0\u542F\u52A8\u3002
+taskId: ${taskId}
+outputPath: ${fullOutputPath}`,
+      data: {
+        backgroundTaskId: taskId,
+        outputPath: fullOutputPath,
+        command: sanitizeSecrets(input.command)
+      }
+    };
+  }
   const result = await runShell(
     adapted.command,
     context.workspaceRoot,
@@ -752,23 +1259,35 @@ async function bashTool(input, context) {
     `original command ${summarizeOriginalShellCommand(input.command)}`
   ];
   const commandForLog = adapted.logCommand ?? adapted.command;
-  const fullText = [
+  const sanitizedShellOutput = sanitizeSecrets(result.output);
+  const cmdInterpretation = interpretCommandResult(input.command, result.exitCode);
+  const rawFullText = [
     `$ ${sanitizeSecrets(commandForLog)}`,
     ...adapterLines,
     `exit code ${result.exitCode}`,
     `outcome ${result.outcome}`,
+    ...cmdInterpretation.message ? [`returnCodeInterpretation: ${cmdInterpretation.message}`] : [],
     "",
-    sanitizeSecrets(result.output)
+    sanitizedShellOutput
   ].join("\n");
+  const diagnostics = createBashOutcomeDiagnostics(result.outcome);
+  const fullText = rawFullText;
   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;
   const details = createBashDetails(fullOutputPath, fullText);
+  const data = adapted.adapter === "native" ? { exitCode: result.exitCode, outcome: result.outcome } : { exitCode: result.exitCode, outcome: result.outcome, adapter: adapted.adapter };
+  const outputData = {
+    ...data,
+    ...cmdInterpretation.message ? { returnCodeInterpretation: cmdInterpretation.message } : {},
+    ...cmdInterpretation.isError === false && result.exitCode !== 0 ? { isError: false } : {},
+    ...diagnostics.length > 0 ? { diagnostics } : {}
+  };
   return {
     text: preview,
     details,
-    data: adapted.adapter === "native" ? { exitCode: result.exitCode, outcome: result.outcome } : { exitCode: result.exitCode, outcome: result.outcome, adapter: adapted.adapter },
+    data: outputData,
     truncated,
     fullOutputPath
   };
@@ -782,6 +1301,513 @@ function createBashDetails(fullOutputPath, fullText) {
     ...tailLines(fullText, 80)
   ].join("\n");
 }
+var BINARY_HINT_EXTENSIONS = [
+  ".bin",
+  ".elf",
+  ".o",
+  ".so",
+  ".a",
+  ".exe",
+  ".dll",
+  ".7z",
+  ".zip",
+  ".gz",
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".pdf",
+  ".sqlite",
+  ".db"
+];
+var ARTIFACT_HINT_EXTENSIONS = [
+  ".txt",
+  ".json",
+  ".out",
+  ".log",
+  ".py",
+  ".html",
+  ".htm",
+  ".csv",
+  ".yaml",
+  ".yml",
+  ".toml",
+  ".md",
+  ".sh",
+  ".bin",
+  ".elf",
+  ".zip",
+  ".7z",
+  ".png",
+  ".pdf",
+  ".sqlite",
+  ".db"
+];
+function parseBashCommandIntent(command, _context) {
+  const tokens = tokenizeShellLike(command);
+  const segments = splitCommandSegments(tokens);
+  const commandNames = [];
+  const parsedSegments = [];
+  const binaryCandidates = /* @__PURE__ */ new Set();
+  const artifactCandidates = /* @__PURE__ */ new Set();
+  const serviceCandidates = [];
+  for (const segment of segments) {
+    const parsed = parseCommandSegment(segment.tokens);
+    if (!parsed) continue;
+    commandNames.push(parsed.commandName);
+    parsedSegments.push({
+      commandName: parsed.commandName,
+      argv: parsed.argv,
+      background: segment.background || parsed.background,
+      redirections: collectSegmentRedirections(parsed.argv)
+    });
+    collectSegmentBinaryCandidates(parsed, binaryCandidates);
+    collectSegmentArtifactCandidates(parsed, artifactCandidates);
+    serviceCandidates.push(...collectSegmentServiceCandidates(parsed));
+  }
+  return {
+    binaryCandidates: [...binaryCandidates],
+    serviceCandidates: dedupeServiceCandidates(serviceCandidates),
+    artifactCandidates: [...artifactCandidates],
+    backgroundLikely: isBackgroundLikely(segments, serviceCandidates),
+    commandNames: unique(commandNames.filter(Boolean)),
+    segments: parsedSegments,
+    hasShellControl: segments.length !== 1 || tokens.some((token) => isCommandSeparator(token))
+  };
+}
+var BINARY_COMMAND_NAMES = /* @__PURE__ */ new Set(["file", "xxd", "readelf", "objdump", "hexdump", "strings", "7z", "7za", "unzip", "tar"]);
+var SHELL_RESERVED_COMMAND_NAMES = /* @__PURE__ */ new Set([
+  "if",
+  "then",
+  "else",
+  "elif",
+  "fi",
+  "for",
+  "while",
+  "until",
+  "do",
+  "done",
+  "case",
+  "esac",
+  "in",
+  "function",
+  "coproc"
+]);
+var SHELL_SYNTAX_COMMAND_NAMES = /* @__PURE__ */ new Set([
+  "[",
+  "[[",
+  "test",
+  "{",
+  "}",
+  "(",
+  ")",
+  "!",
+  ":",
+  "true",
+  "false"
+]);
+var ARTIFACT_PRODUCING_COMMAND_NAMES = /* @__PURE__ */ new Set(["touch", "tee"]);
+var ARTIFACT_PRODUCING_TOKENS = /* @__PURE__ */ new Set(["write", "wrote", "written", "create", "created", "generate", "generated", "build", "built", "output"]);
+function canSafelyAliasPythonCommand(intent) {
+  const segment = intent.segments[0];
+  return intent.segments.length === 1 && !intent.hasShellControl && segment?.commandName === "python" && !segment.background && segment.redirections.length === 0;
+}
+function tokenizeShellLike(command) {
+  const tokens = [];
+  let current = "";
+  let quote;
+  let escaped = false;
+  const push = () => {
+    if (current.length > 0) tokens.push(current);
+    current = "";
+  };
+  for (let index = 0; index < command.length; index += 1) {
+    const char = command[index] ?? "";
+    if (escaped) {
+      current += char;
+      escaped = false;
+      continue;
+    }
+    if (char === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (quote) {
+      if (char === quote) quote = void 0;
+      else current += char;
+      continue;
+    }
+    if (char === "'" || char === '"') {
+      quote = char;
+      continue;
+    }
+    if (/\s/u.test(char)) {
+      push();
+      continue;
+    }
+    if (char === ">" && /^\d+$/u.test(current)) {
+      const prefix = current;
+      current = "";
+      let redirect = `${prefix}>`;
+      if (command[index + 1] === ">") {
+        redirect += ">";
+        index += 1;
+      }
+      if (command[index + 1] === "&") {
+        redirect += "&";
+        index += 1;
+        while (index + 1 < command.length && /[A-Za-z0-9_/-]/u.test(command[index + 1] ?? "")) {
+          redirect += command[index + 1];
+          index += 1;
+        }
+      }
+      tokens.push(redirect);
+      continue;
+    }
+    if (char === "(" && current.length === 0) {
+      push();
+      tokens.push(char);
+      continue;
+    }
+    if ((char === "{" || char === "}") && current.length === 0) {
+      push();
+      tokens.push(char);
+      continue;
+    }
+    if (char === ")" && !current.includes("$(")) {
+      push();
+      tokens.push(char);
+      continue;
+    }
+    if (char === "|" || char === ";" || char === "&" || char === ">") {
+      push();
+      const next = command[index + 1];
+      if (char === "&" && next === "&" || char === ">" && next === ">") {
+        tokens.push(`${char}${next}`);
+        index += 1;
+      } else {
+        tokens.push(char);
+      }
+      continue;
+    }
+    current += char;
+  }
+  push();
+  return tokens;
+}
+function isCommandSeparator(token) {
+  return token === "|" || token === "&&" || token === ";" || token === "&";
+}
+function splitCommandSegments(tokens) {
+  const segments = [];
+  let current = [];
+  for (const token of tokens) {
+    if (!isCommandSeparator(token)) {
+      current.push(token);
+      continue;
+    }
+    if (current.length > 0) {
+      segments.push({ tokens: current, background: token === "&" });
+      current = [];
+    }
+  }
+  if (current.length > 0) segments.push({ tokens: current, background: false });
+  return segments;
+}
+function parseCommandSegment(tokens) {
+  const env = /* @__PURE__ */ new Map();
+  let index = 0;
+  while (index < tokens.length && isShellGroupBoundaryToken(tokens[index] ?? "")) {
+    index += 1;
+  }
+  while (index < tokens.length && isEnvironmentAssignment(tokens[index] ?? "")) {
+    const [name, ...rest] = (tokens[index] ?? "").split("=");
+    if (name) env.set(name.toUpperCase(), rest.join("="));
+    index += 1;
+  }
+  if (index >= tokens.length) return void 0;
+  let commandToken = tokens[index] ?? "";
+  if (commandToken === "nohup" || commandToken === "setsid" || commandToken === "time") {
+    index += 1;
+    commandToken = tokens[index] ?? "";
+  }
+  if (isShellReservedCommandToken(commandToken)) return void 0;
+  if (isShellSyntaxCommandToken(commandToken)) return void 0;
+  if (!commandToken) return void 0;
+  const commandName = stripExecutableToken(commandToken);
+  if (!commandName || isShellReservedCommandToken(commandName) || isShellSyntaxCommandToken(commandName)) {
+    return void 0;
+  }
+  return {
+    commandName,
+    argv: tokens.slice(index + 1).filter((token) => !isShellGroupBoundaryToken(token)),
+    env,
+    background: tokens.includes("disown")
+  };
+}
+function collectSegmentBinaryCandidates(segment, target) {
+  if (BINARY_COMMAND_NAMES.has(segment.commandName)) {
+    for (const token of segment.argv) {
+      if (!isOptionToken(token)) addPathCandidate(target, token);
+    }
+  }
+  for (const token of segment.argv) {
+    if (isBinarySuffix(token)) addPathCandidate(target, token);
+  }
+}
+function collectSegmentArtifactCandidates(segment, target) {
+  for (let index = 0; index < segment.argv.length; index += 1) {
+    const token = segment.argv[index] ?? "";
+    if (token === ">" || token === ">>") {
+      addPathCandidate(target, segment.argv[index + 1] ?? "");
+      index += 1;
+      continue;
+    }
+    if (isOutputFlag(token)) {
+      addPathCandidate(target, segment.argv[index + 1] ?? "");
+      index += 1;
+      continue;
+    }
+    if (isArtifactSuffix(token) && isArtifactProducingCommand(segment.commandName, segment.argv)) {
+      addPathCandidate(target, token);
+    }
+  }
+}
+function collectSegmentRedirections(argv) {
+  const redirections = [];
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index] ?? "";
+    if (token !== ">" && token !== ">>") continue;
+    const target = argv[index + 1] ?? "";
+    if (target) redirections.push({ operator: token, target });
+    index += 1;
+  }
+  return redirections;
+}
+function collectSegmentServiceCandidates(segment) {
+  const candidates = [];
+  const envPort = parsePort(segment.env.get("PORT"));
+  const explicit = findExplicitServiceTarget(segment.argv, envPort);
+  if (isPythonHttpServer(segment)) {
+    const port = findFirstPortToken(segment.argv) ?? envPort ?? 8e3;
+    candidates.push(createServiceIntent("http-server", port, "high", "python -m http.server"));
+    return candidates;
+  }
+  if (segment.commandName === "uvicorn") {
+    if (explicit) candidates.push(createServiceIntent("framework-server", explicit.port, "high", explicit.evidence, explicit.host));
+    return candidates;
+  }
+  if (segment.commandName === "flask" && segment.argv[0]?.toLowerCase() === "run") {
+    if (explicit) candidates.push(createServiceIntent("framework-server", explicit.port, "high", explicit.evidence, explicit.host));
+    return candidates;
+  }
+  if (segment.commandName === "gunicorn") {
+    const bind = findGunicornBindTarget(segment.argv);
+    if (bind) candidates.push(createServiceIntent("framework-server", bind.port, "high", bind.evidence, bind.host));
+    return candidates;
+  }
+  if (isPackageScriptCommand(segment)) {
+    if (explicit) candidates.push(createServiceIntent("package-script", explicit.port, "medium", explicit.evidence, explicit.host));
+    return candidates;
+  }
+  if (isJsRuntimeCommand(segment.commandName)) {
+    if (explicit) candidates.push(createServiceIntent("explicit-port", explicit.port, "medium", explicit.evidence, explicit.host));
+    return candidates;
+  }
+  if (explicit && isKnownServiceCommand(segment.commandName)) {
+    candidates.push(createServiceIntent("explicit-port", explicit.port, "medium", explicit.evidence, explicit.host));
+  }
+  return candidates;
+}
+function createServiceIntent(kind, port, confidence, evidence, host = "127.0.0.1") {
+  return { kind, host: normalizeServiceHost(host), port, confidence, evidence };
+}
+function isPythonHttpServer(segment) {
+  return (segment.commandName === "python" || segment.commandName === "python3") && hasAdjacentTokens(segment.argv, "-m", "http.server");
+}
+function findExplicitServiceTarget(argv, envPort) {
+  let host = "127.0.0.1";
+  if (envPort) return { host, port: envPort, evidence: "PORT=" };
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index] ?? "";
+    if (token === "--host") host = normalizeServiceHost(argv[index + 1] ?? host);
+    if (token === "--port" || token === "-p") {
+      const port = parsePort(argv[index + 1]);
+      if (port) return { host, port, evidence: token };
+    }
+    const inlinePort = parseInlineOptionPort(token);
+    if (inlinePort) return { host, port: inlinePort, evidence: token.split("=")[0] ?? token };
+    const target = parseHostPortToken(token);
+    if (target?.port) return { host: target.host ?? host, port: target.port, evidence: "host:port" };
+  }
+  return void 0;
+}
+function findGunicornBindTarget(argv) {
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index] ?? "";
+    if (token !== "-b" && token !== "--bind") continue;
+    const target = parseHostPortToken(argv[index + 1] ?? "");
+    if (target?.port) return { host: target.host ?? "127.0.0.1", port: target.port, evidence: token };
+  }
+  return void 0;
+}
+function findFirstPortToken(argv) {
+  for (const token of argv) {
+    const port = parsePort(token);
+    if (port) return port;
+  }
+  return void 0;
+}
+function parseInlineOptionPort(token) {
+  if (!token.startsWith("--port=") && !token.startsWith("-p=")) return void 0;
+  return parsePort(token.slice(token.indexOf("=") + 1));
+}
+function parsePort(value) {
+  if (!value || !/^\d{1,5}$/u.test(value)) return void 0;
+  return normalizePort(Number(value));
+}
+function isPackageScriptCommand(segment) {
+  if (segment.commandName !== "npm" && segment.commandName !== "pnpm" && segment.commandName !== "yarn") return false;
+  const command = segment.argv[0]?.toLowerCase();
+  const script = segment.argv[1]?.toLowerCase();
+  return command === "start" || command === "dev" || command === "test-server" || command === "run" && (script === "start" || script === "dev" || script === "test-server");
+}
+function isJsRuntimeCommand(commandName) {
+  return commandName === "node" || commandName === "deno" || commandName === "bun";
+}
+function isKnownServiceCommand(commandName) {
+  return commandName === "grpc";
+}
+function normalizeServiceHost(host) {
+  return "127.0.0.1";
+}
+function isBackgroundLikely(segments, serviceCandidates) {
+  return segments.some(
+    (segment) => segment.background || segment.tokens[0] === "nohup" || segment.tokens[0] === "setsid" || segment.tokens.includes("disown")
+  ) || serviceCandidates.some(
+    (candidate) => candidate.kind === "http-server" || candidate.kind === "framework-server" || candidate.kind === "package-script"
+  );
+}
+function stripExecutableToken(token) {
+  const normalized = token.replace(/^\(+/u, "").replace(/\)+$/u, "");
+  if (normalized.includes("/") || normalized.includes("\\")) {
+    return normalized.replace(/\.(?:exe|cmd|bat)$/iu, "");
+  }
+  return basename(normalized).replace(/\.(?:exe|cmd|bat)$/iu, "").toLowerCase();
+}
+function addPathCandidate(target, token) {
+  if (!isStaticPathCandidate(token)) return;
+  target.add(token.replaceAll("\\", "/"));
+}
+function isOptionToken(token) {
+  return token.startsWith("-") && !/^-?\d+$/u.test(token);
+}
+function isOutputFlag(token) {
+  return token === "-o" || token === "--output" || token === "--out" || token === "--dest" || token === "--file";
+}
+function isEnvironmentAssignment(token) {
+  return /^[A-Za-z_][A-Za-z0-9_]*=.*$/u.test(token);
+}
+function isShellReservedCommandToken(token) {
+  return SHELL_RESERVED_COMMAND_NAMES.has(token.toLowerCase());
+}
+function isShellSyntaxCommandToken(token) {
+  return SHELL_SYNTAX_COMMAND_NAMES.has(token.toLowerCase());
+}
+function isShellGroupBoundaryToken(token) {
+  return token === "(" || token === ")" || token === "{" || token === "}";
+}
+function isStaticPathCandidate(token) {
+  if (!token || isOptionToken(token) || token.includes("://")) return false;
+  if (token.includes("$") || token.includes("`")) return false;
+  if (/^(?:\d+)?>{1,2}(?:&\d+)?$/u.test(token)) return false;
+  if (token === "|" || token === ";" || token === "&" || token === "<") return false;
+  if (isShellGroupBoundaryToken(token) || isShellSyntaxCommandToken(token)) return false;
+  if (/^\d+$/u.test(token)) return false;
+  if (token === "/dev/null" || token === "/dev/stdout" || token === "/dev/stderr") return false;
+  return true;
+}
+function isBinarySuffix(token) {
+  return BINARY_HINT_EXTENSIONS.some((extension) => token.toLowerCase().endsWith(extension));
+}
+function isArtifactSuffix(token) {
+  return ARTIFACT_HINT_EXTENSIONS.some((extension) => token.toLowerCase().endsWith(extension));
+}
+function isArtifactProducingCommand(commandName, tokens) {
+  if (!commandName) return false;
+  if (ARTIFACT_PRODUCING_COMMAND_NAMES.has(commandName)) return true;
+  return tokens.some((token) => ARTIFACT_PRODUCING_TOKENS.has(token.toLowerCase()));
+}
+function parseHostPortToken(token) {
+  const url = tryParseLocalUrl(token);
+  if (url) return url;
+  const separator = token.lastIndexOf(":");
+  if (separator <= 0) return void 0;
+  const host = token.slice(0, separator).replace(/^\[(.*)\]$/u, "$1");
+  const port = normalizePort(Number(token.slice(separator + 1)));
+  if (!port || !isLocalHost(host)) return void 0;
+  return normalizeHostPort(host, port);
+}
+function tryParseLocalUrl(token) {
+  try {
+    const url = new URL(token);
+    if (url.protocol !== "http:" && url.protocol !== "https:") return void 0;
+    if (!isLocalHost(url.hostname)) return void 0;
+    const port = normalizePort(Number(url.port));
+    if (!port) return void 0;
+    return normalizeHostPort(url.hostname, port);
+  } catch {
+    return void 0;
+  }
+}
+function isLocalHost(host) {
+  return host === "localhost" || host === "127.0.0.1" || host === "0.0.0.0" || host === "::1";
+}
+function hasAdjacentTokens(tokens, first, second) {
+  return tokens.some(
+    (token, index) => token.toLowerCase() === first && tokens[index + 1]?.toLowerCase() === second
+  );
+}
+function normalizePort(value) {
+  return Number.isInteger(value) && value > 0 && value <= 65535 ? value : void 0;
+}
+function dedupeServiceCandidates(candidates) {
+  const seen = /* @__PURE__ */ new Set();
+  return candidates.filter((candidate) => {
+    const key = `${candidate.host}:${candidate.port}:${candidate.kind}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+function normalizeHostPort(host, port) {
+  if (!Number.isInteger(port) || port <= 0 || port > 65535) return void 0;
+  return { host: host === "0.0.0.0" || host === "localhost" ? "127.0.0.1" : host.replace(/^\[(.*)\]$/u, "$1"), port };
+}
+function isHeadlessBenchContext(context) {
+  const record = context;
+  return record.headlessBench?.enabled === true || record.isHeadlessBench === true;
+}
+function withDefaultServiceReadiness(readiness, context) {
+  if (readiness.timeoutMs !== void 0) return readiness;
+  const hasReadinessRisk = (context.recentDiagnostics ?? []).some(
+    (diagnostic) => diagnostic.type === "service_readiness" || diagnostic.type === "timeout"
+  );
+  const timeoutMs = hasReadinessRisk ? 15e3 : isHeadlessBenchContext(context) ? 1e4 : 5e3;
+  return { ...readiness, timeoutMs };
+}
+function createBashOutcomeDiagnostics(outcome) {
+  if (outcome === "timeout") {
+    return [
+      {
+        type: "timeout",
+        severity: "recoverable",
+        evidence: "Bash outcome timeout",
+        suggestion: "Run the smallest focused check first and avoid repeating long blind commands."
+      }
+    ];
+  }
+  return [];
+}
 function tailLines(text, limit) {
   const lines = text.split(/\r?\n/u);
   return lines.slice(Math.max(0, lines.length - limit));
@@ -1156,6 +2182,14 @@ function resolveWorkspacePath(workspaceRoot, inputPath) {
 function relativePath(workspaceRoot, filePath) {
   return relative(workspaceRoot, filePath).replaceAll("\\", "/") || ".";
 }
+function resolveArtifactPath(context, inputPath) {
+  const absolute = resolveWorkspacePath(context.workspaceRoot, inputPath);
+  return {
+    input: inputPath,
+    absolute,
+    relative: relativePath(context.workspaceRoot, absolute)
+  };
+}
 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");
@@ -1407,6 +2441,149 @@ async function tryRipgrepFiles(input, context, root, limit) {
   if (!result) return null;
   return { matches: result.lines.slice(0, limit), truncated: result.truncated };
 }
+async function findSourcePackMatches(query, terms, context, limit) {
+  const indexMatches = sourcePackMatchesFromCandidates(query, context.sourcePackCandidates, limit);
+  if (indexMatches.length > 0) {
+    return { source: "index", matches: indexMatches };
+  }
+  const rgMatches = await tryRipgrepSourcePack(terms, context, limit);
+  if (rgMatches && rgMatches.length > 0) {
+    return { source: "rg", matches: rgMatches };
+  }
+  const matches = [];
+  for await (const filePath of listFiles(context.workspaceRoot, () => matches.length >= limit)) {
+    const content = await safeReadText(filePath, context);
+    if (content === null) continue;
+    const rel = relativePath(context.workspaceRoot, filePath);
+    const pathTerm = terms.find((item) => rel.toLowerCase().includes(item.toLowerCase()));
+    if (pathTerm) {
+      matches.push({
+        path: rel,
+        line: 1,
+        text: rel,
+        term: pathTerm,
+        source: "file_name",
+        confidence: 0.35,
+        reason: `fallback file name matched "${pathTerm}"`
+      });
+      if (matches.length >= limit) break;
+    }
+    const lines = content.split(/\r?\n/u);
+    for (const [index, line] of lines.entries()) {
+      const lower = line.toLowerCase();
+      const term = terms.find((item) => lower.includes(item.toLowerCase()));
+      if (!term) continue;
+      matches.push({
+        path: rel,
+        line: index + 1,
+        text: line,
+        term,
+        source: "local_scan",
+        confidence: 0.4,
+        reason: `fallback local scan matched "${term}" at line ${index + 1}`
+      });
+      if (matches.length >= limit) break;
+    }
+  }
+  return { source: matches[0]?.source ?? "local_scan", matches };
+}
+async function tryRipgrepSourcePack(terms, context, limit) {
+  const args = [
+    "--line-number",
+    "--no-heading",
+    "--color",
+    "never",
+    "--hidden",
+    "--no-ignore",
+    "--max-columns",
+    "500",
+    "-i",
+    "-F",
+    ...createRgExcludeArgs(context.workspaceRoot, context.workspaceRoot)
+  ];
+  for (const term of terms) {
+    args.push("-e", term);
+  }
+  args.push(".");
+  const result = await runRipgrep(
+    args,
+    context,
+    limit,
+    (line) => normalizeRgGrepLine(line, context.workspaceRoot)
+  );
+  if (!result) return null;
+  return result.lines.flatMap((line) => parseSourcePackRgLine(line, terms));
+}
+function parseSourcePackRgLine(line, terms) {
+  const firstColon = line.indexOf(":");
+  const secondColon = firstColon < 0 ? -1 : line.indexOf(":", firstColon + 1);
+  if (firstColon < 0 || secondColon < 0) return [];
+  const lineNumber = Number.parseInt(line.slice(firstColon + 1, secondColon), 10);
+  if (!Number.isInteger(lineNumber)) return [];
+  const text = line.slice(secondColon + 1).trim();
+  const lower = text.toLowerCase();
+  const term = terms.find((item) => lower.includes(item.toLowerCase())) ?? terms[0];
+  return [
+    {
+      path: line.slice(0, firstColon),
+      line: lineNumber,
+      text,
+      term,
+      source: "rg",
+      confidence: 0.6,
+      reason: `rg matched "${term}" at line ${lineNumber}`
+    }
+  ];
+}
+function sourcePackMatchesFromCandidates(query, candidates, limit) {
+  if (!candidates || candidates.length === 0) return [];
+  const terms = extractSourcePackTerms(query);
+  return candidates.slice(0, limit).map((candidate) => {
+    const start = Math.max(1, candidate.start);
+    const end = Math.max(start, candidate.end);
+    const term = terms[0] ?? query;
+    return {
+      path: candidate.path,
+      line: start,
+      text: candidate.reason ?? candidate.path,
+      term,
+      source: "index",
+      start,
+      end,
+      confidence: candidate.confidence ?? 0.85,
+      reason: candidate.reason ?? `index candidate for "${query}"`
+    };
+  });
+}
+function extractSourcePackTerms(query) {
+  const terms = query.split(/[^\p{L}\p{N}_.$/@-]+/u).map((term) => term.trim()).filter((term) => term.length >= 2 && !/^\d+$/u.test(term));
+  return unique(terms).slice(0, SOURCE_PACK_MAX_TERMS);
+}
+function estimateSourcePackConfidence(query, match) {
+  if (match.confidence !== void 0) return match.confidence;
+  const queryTerms = extractSourcePackTerms(query);
+  const haystack = `${match.path} ${match.text}`.toLowerCase();
+  const hitCount = queryTerms.filter((term) => haystack.includes(term.toLowerCase())).length;
+  const base = match.source === "index" ? 0.7 : match.source === "rg" ? 0.45 : 0.25;
+  const cap = match.source === "index" ? 0.95 : match.source === "rg" ? 0.75 : 0.55;
+  return Math.min(cap, base + hitCount * 0.15);
+}
+function formatSourcePackOutput(snippets, safetyTruncated) {
+  const lines = [];
+  for (const snippet of snippets) {
+    lines.push(
+      [
+        `${snippet.path}:${snippet.start}-${snippet.end}`,
+        `source: ${snippet.source}; reason: ${snippet.reason}; confidence: ${snippet.confidence.toFixed(2)}`,
+        snippet.content
+      ].join("\n")
+    );
+  }
+  if (safetyTruncated) {
+    lines.push("...\uFF08\u7ED3\u679C\u5DF2\u622A\u65AD\uFF0C\u540E\u7EED\u5185\u5BB9\u7701\u7565\uFF1B\u5982\u9700\u7CBE\u8BFB\u8BF7\u6307\u5B9A\u66F4\u5C0F\u8303\u56F4\u3002\uFF09");
+  }
+  return lines.join("\n\n");
+}
 function createRgExcludeArgs(root, workspaceRoot) {
   const searchRootRel = stripCurrentDirectoryPrefix(
     relative(workspaceRoot, root).replaceAll("\\", "/")
@@ -1645,6 +2822,198 @@ function runShell(command, cwd, timeoutMs, signal, onProgress, trackChildProcess
     });
   });
 }
+var STALL_THRESHOLD_MS = 45e3;
+var PROMPT_PATTERNS = [
+  /\(y\/n\)\s*$/i,
+  /\[y\/n\]\s*$/i,
+  /\(yes\/no\)\s*$/i,
+  /Press Enter/i,
+  /Continue\?/i,
+  /Overwrite\?/i,
+  /password[:\s]*$/i,
+  /passphrase[:\s]*$/i,
+  /\?\s*$/
+];
+function looksLikePrompt(tail) {
+  const lastLine = tail.split(/\r?\n/).filter(Boolean).pop() ?? "";
+  return PROMPT_PATTERNS.some((re) => re.test(lastLine));
+}
+async function runBackgroundBash(opts) {
+  const {
+    taskId,
+    command,
+    originalCommand,
+    cwd,
+    timeoutMs,
+    fullOutputPath,
+    adapter,
+    logCommand,
+    retainAfterReturn,
+    abortSignal,
+    onProgress,
+    trackChildProcess,
+    onComplete
+  } = opts;
+  await mkdir(dirname(fullOutputPath), { recursive: true }).catch(() => {
+  });
+  const fileStream = createWriteStream(fullOutputPath, { encoding: "utf8" });
+  const commandForLog = logCommand ?? command;
+  const header = [
+    `$ ${sanitizeSecrets(commandForLog)}`,
+    ...adapter !== "native" ? [`adapter ${adapter}`, `original command ${summarizeOriginalShellCommand(originalCommand)}`] : [],
+    ""
+  ].join("\n");
+  fileStream.write(header);
+  const detached = process.platform !== "win32";
+  if (retainAfterReturn) {
+    fileStream.write("\n[background] retained process started\n");
+    await new Promise((resolveEnd) => fileStream.end(resolveEnd));
+    const outFd = openSync(fullOutputPath, "a");
+    const errFd = openSync(fullOutputPath, "a");
+    const child2 = spawn(command, {
+      cwd,
+      shell: true,
+      windowsHide: true,
+      detached,
+      stdio: ["ignore", outFd, errFd]
+    });
+    closeSync(outFd);
+    closeSync(errFd);
+    child2.unref();
+    trackChildProcess?.(child2, {
+      detached,
+      cwd,
+      label: `BashBg:${command.slice(0, 80)}`,
+      retainAfterExit: true
+    });
+    onComplete?.({
+      taskId,
+      exitCode: 0,
+      outcome: "completed",
+      outputPath: fullOutputPath,
+      command: sanitizeSecrets(originalCommand)
+    });
+    return;
+  }
+  const child = spawn(command, { cwd, shell: true, windowsHide: true, detached });
+  trackChildProcess?.(child, {
+    detached,
+    cwd,
+    label: `BashBg:${command.slice(0, 80)}`,
+    retainAfterExit: detached
+  });
+  let tailBuffer = "";
+  let lastOutputTime = Date.now();
+  let stallTimer;
+  let settled = false;
+  let outcome = "completed";
+  const resetStallTimer = () => {
+    lastOutputTime = Date.now();
+    if (stallTimer) clearTimeout(stallTimer);
+    stallTimer = setTimeout(checkStall, STALL_THRESHOLD_MS);
+  };
+  const checkStall = () => {
+    if (Date.now() - lastOutputTime >= STALL_THRESHOLD_MS && looksLikePrompt(tailBuffer)) {
+      const msg = "\n[stall watchdog] \u68C0\u6D4B\u5230\u4EA4\u4E92\u5F0F\u63D0\u793A\uFF0C\u53EF\u80FD\u9700\u8981\u7528\u6237\u8F93\u5165\u3002\n";
+      fileStream.write(msg);
+      onProgress?.("system", msg);
+    }
+  };
+  const finish = (exitCode) => {
+    if (settled) return;
+    settled = true;
+    if (stallTimer) clearTimeout(stallTimer);
+    clearTimeout(timer);
+    abortSignal?.removeEventListener("abort", onAbort);
+    const footer = `
+exit code ${exitCode}
+outcome ${outcome}
+`;
+    fileStream.write(footer);
+    fileStream.end();
+    onComplete?.({
+      taskId,
+      exitCode,
+      outcome,
+      outputPath: fullOutputPath,
+      command: sanitizeSecrets(originalCommand)
+    });
+  };
+  const requestStop = async (force) => {
+    if (process.platform === "win32" && child.pid) {
+      await stopWindowsProcessTree(child.pid, cwd);
+      return;
+    }
+    const sig = force ? "SIGKILL" : "SIGTERM";
+    if (detached && child.pid) {
+      try {
+        process.kill(-child.pid, sig);
+      } catch {
+        child.kill(sig);
+      }
+    } else {
+      child.kill(sig);
+    }
+  };
+  const FORCE_KILL_WAIT_MS = 3e3;
+  const waitForCloseOrForceKill = () => {
+    const forceTimer = setTimeout(() => {
+      void requestStop(true);
+      setTimeout(() => finish(1), 500);
+    }, FORCE_KILL_WAIT_MS);
+    child.once("close", () => {
+      clearTimeout(forceTimer);
+    });
+  };
+  const onAbort = () => {
+    if (settled) return;
+    outcome = "cancelled";
+    const msg = "\n[cancelled] \u5DE5\u5177\u8C03\u7528\u5DF2\u53D6\u6D88\uFF0C\u6B63\u5728\u7EC8\u6B62\u5B50\u8FDB\u7A0B\u3002\n";
+    fileStream.write(msg);
+    onProgress?.("system", msg);
+    void requestStop(false);
+    waitForCloseOrForceKill();
+  };
+  const timer = setTimeout(() => {
+    if (settled) return;
+    outcome = "timeout";
+    const msg = `
+[timeout] \u547D\u4EE4\u8D85\u65F6\uFF1A\u8D85\u8FC7 ${timeoutMs}ms\uFF0C\u5DF2\u7EC8\u6B62\u3002
+`;
+    fileStream.write(msg);
+    onProgress?.("system", msg);
+    void requestStop(false);
+    waitForCloseOrForceKill();
+  }, timeoutMs);
+  if (abortSignal?.aborted) {
+    onAbort();
+    return;
+  }
+  abortSignal?.addEventListener("abort", onAbort, { once: true });
+  child.stdout.on("data", (chunk) => {
+    const text = decodeShellChunk(chunk);
+    fileStream.write(text);
+    tailBuffer = (tailBuffer + text).slice(-2e3);
+    resetStallTimer();
+    onProgress?.("stdout", text);
+  });
+  child.stderr.on("data", (chunk) => {
+    const text = decodeShellChunk(chunk);
+    fileStream.write(text);
+    tailBuffer = (tailBuffer + text).slice(-2e3);
+    resetStallTimer();
+    onProgress?.("stderr", text);
+  });
+  child.on("close", (code) => {
+    finish(code ?? 1);
+  });
+  child.on("error", (err) => {
+    fileStream.write(`
+[error] ${err.message}
+`);
+    finish(1);
+  });
+}
 function decodeShellChunk(chunk) {
   const utf8 = chunk.toString("utf8");
   if (process.platform !== "win32") return utf8;
@@ -1772,14 +3141,21 @@ function unique(items) {
 }
 var __testGlobToRegExp = globToRegExp;
 var __testDecodeShellChunk = decodeShellChunk;
+var __testParseBashCommandIntent = parseBashCommandIntent;
+var __testCanSafelyAliasPythonCommand = canSafelyAliasPythonCommand;
+var __testRunBackgroundBash = runBackgroundBash;
 export {
+  __testCanSafelyAliasPythonCommand,
   __testDecodeShellChunk,
   __testGlobToRegExp,
+  __testParseBashCommandIntent,
+  __testRunBackgroundBash,
   adaptShellCommand,
   adaptShellCommandForPlatform,
   builtInTools,
   createTool,
   createToolContext,
+  interpretCommandResult,
   runTool,
   toolRegistryStatus
 };