@aipanel/dsh-plugin 1.3.4 → 1.3.6

package/dist/index.js

@@ -38,16 +38,219 @@ var VUE_DEVTOOLS_TIMELINE_INCLUDES = [
 ];
 var DEFAULT_TIMELINE_INCLUDE = VUE_DEVTOOLS_TIMELINE_INCLUDE.SLOW;
 var MUTATING_TOOLS = /* @__PURE__ */ new Set(["write", "edit", "apply_patch"]);
-var OPENCODE_ENV = {
-  CONFIG_DIR: "OPENCODE_CONFIG_DIR",
-  CONTEXT_API_URL: "OPENCODE_CONTEXT_API_URL",
-  VITE_LOGS_API_URL: "OPENCODE_VITE_LOGS_API_URL",
-  LOG_FILES_JSON: "OPENCODE_LOG_FILES_JSON",
-  VERBOSE: "OPENCODE_VERBOSE",
-  ENABLE_LINT: "OPENCODE_ENABLE_LINT",
-  VUE_DEVTOOLS_API_URL: "OPENCODE_VUE_DEVTOOLS_API_URL",
-  WORKSPACE: "OPENCODE_WORKSPACE"
+
+// ../../core/es/common/diagnostics.mjs
+var COMMAND_CHECK_TIMEOUT_MS = 6e4;
+var SOURCE_EXTENSIONS = [
+  ".js",
+  ".jsx",
+  ".ts",
+  ".tsx",
+  ".mjs",
+  ".cjs",
+  ".mts",
+  ".cts",
+  ".vue"
+];
+function matchesExtensions(filePath, extensions) {
+  if (!extensions?.length) return true;
+  const base = filePath.replace(/\\/g, "/").split("/").pop() ?? "";
+  const dot = base.lastIndexOf(".");
+  if (dot <= 0) return false;
+  return extensions.includes(base.slice(dot).toLowerCase());
+}
+var BUILTIN_LINTERS = {
+  eslint: {
+    label: "ESLint",
+    package: "eslint",
+    args: ["--format", "json", "{files}"],
+    projectArgs: ["--format", "json", "."],
+    extensions: [...SOURCE_EXTENSIONS],
+    format: "eslint-json"
+  },
+  oxlint: {
+    label: "oxlint",
+    package: "oxlint",
+    args: ["--format=json", "--ignore-pattern", "node_modules", "{files}"],
+    projectArgs: ["--format=json", "--ignore-pattern", "node_modules", "."],
+    extensions: [...SOURCE_EXTENSIONS],
+    format: "oxlint-json"
+  },
+  stylelint: {
+    label: "Stylelint",
+    package: "stylelint",
+    args: ["--formatter", "json", "{files}"],
+    projectArgs: ["--formatter", "json", "**/*.{css,scss,less}"],
+    extensions: [".css", ".scss", ".less"],
+    format: "stylelint-json"
+  }
 };
+var DEFAULT_MAX_FINDINGS_PER_SECTION = 3;
+var DEFAULT_MAX_MESSAGE_CHARS = 4e3;
+var DEFAULT_BUILTIN_CHECKS = Object.freeze([
+  Object.freeze({ builtin: "eslint" }),
+  Object.freeze({ builtin: "oxlint" }),
+  Object.freeze({ builtin: "typecheck" })
+]);
+var DEFAULT_DIAGNOSTICS_POLICY = Object.freeze({
+  checks: DEFAULT_BUILTIN_CHECKS.map((check) => ({ ...check })),
+  auto: true,
+  exposeTool: true,
+  severity: "warning",
+  maxFindingsPerSection: DEFAULT_MAX_FINDINGS_PER_SECTION,
+  maxMessageChars: DEFAULT_MAX_MESSAGE_CHARS
+});
+function isCommandCheck(check) {
+  return !("builtin" in check);
+}
+function isLinterPreset(check) {
+  return "builtin" in check && check.builtin !== "typecheck";
+}
+function isTypecheckCheck(check) {
+  return "builtin" in check && check.builtin === "typecheck";
+}
+function checkRunsInPhase(check, phase) {
+  const run = check.run ?? "both";
+  return run === "both" || run === phase;
+}
+var FORMATS = [
+  "text",
+  "tsc",
+  "eslint-json",
+  "oxlint-json",
+  "stylelint-json",
+  "aipanel-json"
+];
+var RUNS = ["edit", "manual", "both"];
+function normalizeExtensions(raw) {
+  if (!Array.isArray(raw)) return void 0;
+  const extensions = raw.filter((item) => typeof item === "string" && item.trim() !== "").map((item) => {
+    const trimmed = item.trim().toLowerCase();
+    return trimmed.startsWith(".") ? trimmed : `.${trimmed}`;
+  });
+  return extensions.length > 0 ? [...new Set(extensions)] : void 0;
+}
+function normalizeArgs(raw) {
+  if (!Array.isArray(raw)) return void 0;
+  const args = raw.filter((item) => typeof item === "string");
+  return args.length > 0 ? args : void 0;
+}
+function normalizeCheck(raw) {
+  if (!raw || typeof raw !== "object") return void 0;
+  const value = raw;
+  const run = RUNS.includes(value.run) ? value.run : void 0;
+  const extensions = normalizeExtensions(value.extensions);
+  const cwd = typeof value.cwd === "string" && value.cwd ? { cwd: value.cwd } : {};
+  const timeout = typeof value.timeoutMs === "number" && Number.isFinite(value.timeoutMs) && value.timeoutMs > 0 ? { timeoutMs: Math.floor(value.timeoutMs) } : {};
+  const format = FORMATS.includes(value.format) ? { format: value.format } : {};
+  if (value.builtin !== void 0) {
+    if (value.builtin === "typecheck") {
+      return {
+        builtin: "typecheck",
+        ...run ? { run } : {},
+        ...extensions ? { extensions } : {}
+      };
+    }
+    if (typeof value.builtin === "string" && value.builtin in BUILTIN_LINTERS) {
+      const presetArgs = normalizeArgs(value.args);
+      const presetProjectArgs = normalizeArgs(value.projectArgs);
+      return {
+        builtin: value.builtin,
+        ...presetArgs ? { args: presetArgs } : {},
+        ...presetProjectArgs ? { projectArgs: presetProjectArgs } : {},
+        ...extensions ? { extensions } : {},
+        ...run ? { run } : {},
+        ...format,
+        ...cwd,
+        ...timeout
+      };
+    }
+    return void 0;
+  }
+  if (typeof value.name !== "string" || !value.name) return void 0;
+  const command = typeof value.command === "string" && value.command ? value.command : void 0;
+  const bin = typeof value.bin === "string" && value.bin ? value.bin : void 0;
+  if (!command && !bin) return void 0;
+  const args = normalizeArgs(value.args);
+  const projectArgs = normalizeArgs(value.projectArgs);
+  return {
+    name: value.name,
+    ...command ? { command } : {},
+    ...bin ? { bin } : {},
+    ...args ? { args } : {},
+    ...projectArgs ? { projectArgs } : {},
+    ...extensions ? { extensions } : {},
+    ...cwd,
+    ...run ? { run } : {},
+    ...format,
+    ...typeof value.adapter === "string" && value.adapter ? { adapter: value.adapter } : {},
+    ...timeout
+  };
+}
+function normalizeChecks(raw, onInvalid) {
+  if (raw === void 0) return void 0;
+  if (!Array.isArray(raw)) {
+    onInvalid("diagnostics.checks \u5FC5\u987B\u662F\u6570\u7EC4\uFF0C\u5DF2\u56DE\u9000\u4E3A\u5185\u7F6E\u68C0\u67E5");
+    return void 0;
+  }
+  const checks = [];
+  for (const item of raw) {
+    const check = normalizeCheck(item);
+    if (check) checks.push(check);
+    else onInvalid(`diagnostics.checks \u542B\u975E\u6CD5\u68C0\u67E5\u9879\uFF0C\u5DF2\u8DF3\u8FC7\uFF1A${JSON.stringify(item)}`);
+  }
+  if (checks.length === 0) {
+    onInvalid("diagnostics.checks \u5F52\u4E00\u5316\u540E\u4E3A\u7A7A\uFF0C\u5DF2\u56DE\u9000\u4E3A\u5185\u7F6E\u68C0\u67E5");
+    return void 0;
+  }
+  return checks;
+}
+function normalizeBoolean(raw, fallback) {
+  return typeof raw === "boolean" ? raw : fallback;
+}
+function isValidPositiveInt(raw) {
+  return typeof raw === "number" && Number.isFinite(raw) && raw >= 1;
+}
+function normalizePositiveInt(raw, fallback) {
+  return isValidPositiveInt(raw) ? Math.floor(raw) : fallback;
+}
+function resolveDiagnosticsPolicy(layers, onInvalid = () => {
+}) {
+  let policy = {
+    ...DEFAULT_DIAGNOSTICS_POLICY,
+    checks: DEFAULT_BUILTIN_CHECKS.map((check) => ({ ...check }))
+  };
+  for (const layer of layers) {
+    if (!layer || typeof layer !== "object") continue;
+    const checks = normalizeChecks(layer.checks, onInvalid);
+    if (layer.severity !== void 0 && layer.severity !== "error" && layer.severity !== "warning") {
+      onInvalid(`diagnostics.severity \u53D6\u503C\u975E\u6CD5\uFF08${String(layer.severity)}\uFF09\uFF0C\u5DF2\u56DE\u9000\u4E0A\u4E00\u5C42`);
+    }
+    if (layer.maxFindingsPerSection !== void 0 && !isValidPositiveInt(layer.maxFindingsPerSection)) {
+      onInvalid("diagnostics.maxFindingsPerSection \u5FC5\u987B\u662F \u2265 1 \u7684\u6574\u6570\uFF0C\u5DF2\u56DE\u9000\u4E0A\u4E00\u5C42");
+    }
+    if (layer.maxMessageChars !== void 0 && !isValidPositiveInt(layer.maxMessageChars)) {
+      onInvalid("diagnostics.maxMessageChars \u5FC5\u987B\u662F \u2265 1 \u7684\u6574\u6570\uFF0C\u5DF2\u56DE\u9000\u4E0A\u4E00\u5C42");
+    }
+    for (const key of ["auto", "exposeTool"]) {
+      if (layer[key] !== void 0 && typeof layer[key] !== "boolean") {
+        onInvalid(`diagnostics.${key} \u5FC5\u987B\u662F\u5E03\u5C14\u503C\uFF0C\u5DF2\u56DE\u9000\u4E0A\u4E00\u5C42`);
+      }
+    }
+    policy = {
+      checks: checks ? checks.map((check) => ({ ...check })) : policy.checks,
+      auto: normalizeBoolean(layer.auto, policy.auto),
+      exposeTool: normalizeBoolean(layer.exposeTool, policy.exposeTool),
+      severity: layer.severity === "error" || layer.severity === "warning" ? layer.severity : policy.severity,
+      maxFindingsPerSection: normalizePositiveInt(
+        layer.maxFindingsPerSection,
+        policy.maxFindingsPerSection
+      ),
+      maxMessageChars: normalizePositiveInt(layer.maxMessageChars, policy.maxMessageChars)
+    };
+  }
+  return policy;
+}
 
 // ../../core/es/common/logger-core.mjs
 var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
@@ -299,28 +502,16 @@ var PerformanceTimer = class {
 // ../../core/es/node/diagnostics.mjs
 import fs from "node:fs";
 import path from "node:path";
+import { pathToFileURL } from "node:url";
 import { execa } from "execa";
 import { createRequire } from "node:module";
 var log2 = createNodeLogger("Diagnostics");
-var JS_EXTENSIONS = /* @__PURE__ */ new Set([
-  ".js",
-  ".jsx",
-  ".ts",
-  ".tsx",
-  ".mjs",
-  ".cjs",
-  ".mts",
-  ".cts",
-  ".vue"
-]);
-function isJsFile(filePath) {
-  return JS_EXTENSIONS.has(path.extname(filePath));
-}
+var JS_EXTENSIONS = new Set(SOURCE_EXTENSIONS);
 var DIAGNOSTICS_TOOL_DESCRIPTION = [
-  "\u8FD0\u884C Lint\uFF08ESLint / oxlint\uFF09\u4E0E TypeScript \u7C7B\u578B\u8BCA\u65AD\uFF0C\u8FD4\u56DE\u8BCA\u65AD\u7ED3\u679C\u3002",
+  "\u8FD0\u884C\u9879\u76EE\u914D\u7F6E\u7684\u4EE3\u7801\u68C0\u67E5\uFF08\u9ED8\u8BA4 Lint \u4E0E TypeScript \u7C7B\u578B\u8BCA\u65AD\uFF09\uFF0C\u8FD4\u56DE\u8BCA\u65AD\u7ED3\u679C\u3002",
   "",
   "**\u652F\u6301\u7684\u6587\u4EF6\u7C7B\u578B**\uFF1A",
-  `- Lint\uFF1AJavaScript / TypeScript / Vue \u6E90\u7801\uFF08${[...JS_EXTENSIONS].map((e) => `*${e}`).join(" ")}\uFF09\uFF1B\u4E24\u5F15\u64CE\u5747\u5B89\u88C5\u65F6\u5E76\u884C\u4E92\u8865\u8FD0\u884C\uFF08\u8BCA\u65AD\u6309\u6765\u6E90\u6807\u6CE8\uFF09`,
+  `- Lint\uFF1AJavaScript / TypeScript / Vue \u6E90\u7801\uFF08${[...JS_EXTENSIONS].map((e) => `*${e}`).join(" ")}\uFF09\uFF1B\u9879\u76EE\u540C\u65F6\u88C5\u6709 ESLint \u4E0E oxlint \u65F6\u4E92\u8865\u8FD0\u884C\uFF08\u8BCA\u65AD\u6309\u6765\u6E90\u6807\u6CE8\uFF09`,
   "- TypeScript \u7C7B\u578B\u68C0\u67E5\uFF1A*.ts *.tsx *.vue",
   "",
   "**\u4F55\u65F6\u4F7F\u7528\u6B64\u5DE5\u5177**\uFF1A",
@@ -350,53 +541,14 @@ function resolvePackageBin(basePkgJson, pkgName, binName) {
     }
   });
 }
-var _eslintClassByBase = /* @__PURE__ */ new Map();
-function loadESLint(workspace) {
-  const basePkgJson = path.join(workspace, "package.json");
-  return cachedResolve(_eslintClassByBase, basePkgJson, () => {
-    log2.debug("Loading eslint", { workspace });
-    try {
-      const req = createRequire(basePkgJson);
-      const eslintModule = req("eslint");
-      const eslintClass = eslintModule.ESLint ?? eslintModule.FlatESLint ?? null;
-      log2.debug("eslint loaded", { hasClass: !!eslintClass });
-      return eslintClass;
-    } catch (e) {
-      log2.warn("eslint not found", { error: e.message });
-      return null;
-    }
-  });
-}
-async function lintFiles(pattern, cwd, warnLimit = 5) {
-  const eslintClass = loadESLint(cwd);
-  const [eslintOutput, oxlintOutput] = await Promise.all([
-    eslintClass ? runEslintFiles(eslintClass, pattern, cwd, warnLimit) : Promise.resolve(null),
-    runOxlintFiles(pattern, cwd, warnLimit)
-  ]);
-  const engines = [];
-  const texts = [];
-  const diagnostics = [];
-  for (const output of [eslintOutput, oxlintOutput]) {
-    if (!output) continue;
-    engines.push(...output.engines ?? []);
-    if (output.text) texts.push(output.text);
-    diagnostics.push(...output.diagnostics ?? []);
-  }
-  if (engines.length === 0) {
-    return {
-      text: `[Lint] \u672A\u8FD0\u884C\uFF1A\u65E0\u6CD5\u5728 workspace "${cwd}" \u89E3\u6790\u5230 eslint \u6216 oxlint`,
-      diagnostics: []
-    };
-  }
-  return { text: texts.join("\n\n") || void 0, diagnostics, engines };
-}
-function formatLintMessages(messages, engine, warnLimit) {
-  if (messages.length === 0) return { engines: [engine.label] };
+function formatLintMessages(messages, engine, warnLimit, minSeverity = "warning") {
   const ESLINT_ERROR = 2;
   const ESLINT_WARN = 1;
+  const kept = minSeverity === "error" ? messages.filter((m) => m.severity === ESLINT_ERROR) : messages;
+  if (kept.length === 0) return {};
   const lines = [];
-  const errors = messages.filter((m) => m.severity === ESLINT_ERROR);
-  const warnings = messages.filter((m) => m.severity === ESLINT_WARN);
+  const errors = kept.filter((m) => m.severity === ESLINT_ERROR);
+  const warnings = kept.filter((m) => m.severity === ESLINT_WARN);
   if (errors.length > 0) {
     lines.push(
       ...errors.map(
@@ -426,35 +578,9 @@ function formatLintMessages(messages, engine, warnLimit) {
   }));
   return {
     text: lines.length > 0 ? lines.join("\n") : void 0,
-    diagnostics,
-    engines: [engine.label]
+    diagnostics
   };
 }
-async function runEslintFiles(eslintClass, pattern, cwd, warnLimit) {
-  try {
-    const eslint = new eslintClass({ cwd });
-    const results = await eslint.lintFiles(pattern);
-    const messages = results.flatMap(
-      (r) => (r.messages ?? []).map((m) => ({ ...m, filePath: r.filePath }))
-    );
-    log2.debug("ESLint lint", {
-      pattern,
-      fileCount: results.length,
-      messageCount: messages.length
-    });
-    return formatLintMessages(messages, { label: "ESLint", source: "eslint" }, warnLimit);
-  } catch (err) {
-    log2.warn("ESLint failed", { pattern, error: err.message });
-    return {
-      text: `[ESLint] \u8FD0\u884C\u5931\u8D25\uFF1A${err.message}\uFF08\u4EC5\u663E\u793A TypeScript \u8BCA\u65AD\uFF09`,
-      diagnostics: [],
-      engines: ["ESLint"]
-    };
-  }
-}
-function resolveOxlintBin(workspace) {
-  return resolvePackageBin(path.join(workspace, "package.json"), "oxlint", "oxlint");
-}
 function oxlintRuleName(code) {
   if (!code) return null;
   const match = /\(([^)]*)\)$/.exec(code);
@@ -497,39 +623,6 @@ function parseOxlintOutput(stdout, cwd) {
     ];
   });
 }
-async function runOxlintFiles(pattern, cwd, warnLimit) {
-  const bin = resolveOxlintBin(cwd);
-  if (!bin) return {};
-  const result = await execa(
-    "node",
-    [bin, "--format=json", "--ignore-pattern", "node_modules", pattern],
-    { cwd, timeout: 6e4, maxBuffer: 50 * 1024 * 1024, reject: false }
-  );
-  if (result.timedOut || result.isTerminated || result.isMaxBuffer) {
-    log2.warn("oxlint timed out", { pattern });
-    return {
-      text: "[oxlint] \u8FD0\u884C\u5931\u8D25\uFF1A\u68C0\u67E5\u8D85\u65F6\uFF0C\u8BF7\u5C1D\u8BD5\u7F29\u5C0F\u68C0\u67E5\u8303\u56F4\u3002",
-      diagnostics: [],
-      engines: ["oxlint"]
-    };
-  }
-  try {
-    const messages = parseOxlintOutput(result.stdout, cwd);
-    log2.debug("oxlint lint", {
-      pattern,
-      messageCount: messages.length,
-      stderr: result.stderr || void 0
-    });
-    return formatLintMessages(messages, { label: "oxlint", source: "oxlint" }, warnLimit);
-  } catch (e) {
-    log2.warn("oxlint failed", { pattern, error: e.message });
-    return {
-      text: `[oxlint] \u8FD0\u884C\u5931\u8D25\uFF1A${e.message}`,
-      diagnostics: [],
-      engines: ["oxlint"]
-    };
-  }
-}
 var BUNDLED_ENGINE_KEY = "<bundled>";
 var _engineCache = /* @__PURE__ */ new Map();
 var _tsVersionCache = /* @__PURE__ */ new Map();
@@ -820,47 +913,9 @@ async function runTypeChecksForFiles(files, cwd) {
   }
   return results;
 }
-async function runAllChecks(pattern, cwd) {
-  log2.debug("runAllChecks", { pattern, cwd });
-  const [eslintOutput, tscOutput] = await Promise.all([
-    lintFiles(pattern, cwd),
-    runTypeCheck(pattern, cwd)
-  ]);
-  return { eslintOutput, tscOutput };
-}
-async function runAllChecksForFiles(files, cwd) {
-  const targets = [...new Set(files.map((file) => path.resolve(file)))];
-  const tscByFile = await runTypeChecksForFiles(targets, cwd);
-  const results = /* @__PURE__ */ new Map();
-  for (const file of targets) {
-    results.set(file, {
-      eslintOutput: await lintFiles(file, cwd),
-      tscOutput: tscByFile.get(file) ?? { rawOutput: "", exitCode: 0 }
-    });
-  }
-  return results;
-}
-async function runProjectDiagnostics(workspace) {
-  const tscDirs = fs.existsSync(path.join(workspace, "tsconfig.json")) ? [workspace] : findAllTsconfigDirs(workspace);
-  log2.debug("Tsc dirs to check", { count: tscDirs.length, dirs: tscDirs });
-  const [eslintOutput, ...tscOutputs] = await Promise.all([
-    lintFiles(".", workspace, 10),
-    ...tscDirs.map((dir) => runTypeCheck(void 0, dir))
-  ]);
-  const mergedTsc = {
-    rawOutput: tscOutputs.flatMap((o) => o.rawOutput).filter(Boolean).join("\n"),
-    exitCode: tscOutputs.reduce((max, o) => Math.max(max, o.exitCode), 0),
-    diagnostics: tscOutputs.flatMap((o) => o.diagnostics ?? []),
-    source: tscOutputs.find((o) => o.source)?.source
-  };
-  return { eslintOutput, tscOutput: mergedTsc };
-}
 function tscSectionTitle(tscOutput) {
   return tscOutput.source ?? "tsc";
 }
-function lintSectionTitle(lintOutput) {
-  return lintOutput.engines?.length ? lintOutput.engines.join(" + ") : "ESLint";
-}
 function omittedFindingsHint(omitted) {
   return `\u2026\u8FD8\u6709 ${omitted} \u6761\uFF0C\u5B8C\u6574\u7ED3\u679C\u8BF7\u8C03\u7528 run_diagnostics`;
 }
@@ -872,25 +927,482 @@ function boundFindings(text, maxFindings) {
     "\n"
   );
 }
-function formatDiagnosticsSections(title, eslintOutput, tscOutput, options = {}) {
-  const lintLines = boundFindings(eslintOutput.text, options.maxFindingsPerSection);
-  const tscLines = boundFindings(tscOutput.rawOutput.trim(), options.maxFindingsPerSection);
-  const parts = [];
-  if (!options.onlyFindings || lintLines) {
-    parts.push(`## ${lintSectionTitle(eslintOutput)}
-
-` + (lintLines || "\u6CA1\u6709\u53D1\u73B0\u95EE\u9898"));
+function displayPath(cwd, file) {
+  const rel = path.relative(cwd, file);
+  return rel.startsWith("..") || path.isAbsolute(rel) ? file : rel;
+}
+function targetFiles(target) {
+  if (target.kind === "file") return [path.resolve(target.file)];
+  if (target.kind === "edited") return [...new Set(target.files.map((file) => path.resolve(file)))];
+  return [];
+}
+function splitsByFile(target) {
+  return target.kind === "edited";
+}
+function filterBySeverity(items, severity) {
+  return severity === "error" ? items.filter((item) => item.severity === SEVERITY_ERROR) : [...items];
+}
+function renderDiagnosticLines(items) {
+  return items.map((item) => {
+    const level = item.severity === SEVERITY_ERROR ? "ERROR" : "WARN";
+    const file = item.file ?? "";
+    const { line, character } = item.range.start;
+    return `${level} [${file}:${line + 1}:${character + 1}] ${item.message}`;
+  }).join("\n");
+}
+function entryToDiagnosticItem(entry, source) {
+  return {
+    file: entry.file,
+    severity: entry.severity === "error" ? SEVERITY_ERROR : SEVERITY_WARN,
+    range: {
+      start: { line: entry.line - 1, character: entry.column - 1 },
+      end: { line: entry.line - 1, character: entry.column - 1 }
+    },
+    message: entry.message,
+    source
+  };
+}
+function normalizeEntries(value, source) {
+  if (value === void 0) return [];
+  if (!Array.isArray(value)) throw new Error("diagnostics \u5FC5\u987B\u662F\u6570\u7EC4");
+  return value.map((raw, index) => {
+    const at = `diagnostics[${index}]`;
+    if (!raw || typeof raw !== "object") throw new Error(`${at} \u5FC5\u987B\u662F\u5BF9\u8C61`);
+    const entry = raw;
+    if (typeof entry.file !== "string" || !entry.file)
+      throw new Error(`${at}.file \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32`);
+    if (typeof entry.line !== "number" || entry.line < 1)
+      throw new Error(`${at}.line \u5FC5\u987B\u662F \u2265 1 \u7684\u6570\u5B57`);
+    if (typeof entry.column !== "number" || entry.column < 1)
+      throw new Error(`${at}.column \u5FC5\u987B\u662F \u2265 1 \u7684\u6570\u5B57`);
+    if (entry.severity !== "error" && entry.severity !== "warning")
+      throw new Error(`${at}.severity \u5FC5\u987B\u662F "error" \u6216 "warning"`);
+    if (typeof entry.message !== "string") throw new Error(`${at}.message \u5FC5\u987B\u662F\u5B57\u7B26\u4E32`);
+    return entryToDiagnosticItem(entry, source);
+  });
+}
+function extractJsonValue(raw) {
+  const trimmed = raw.trim();
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    const starts = [raw.indexOf("{"), raw.indexOf("[")].filter((index) => index >= 0);
+    if (starts.length === 0) throw new Error("\u672A\u627E\u5230 JSON \u8F93\u51FA");
+    const start = Math.min(...starts);
+    const close = raw[start] === "{" ? "}" : "]";
+    const end = raw.lastIndexOf(close);
+    if (end <= start) throw new Error("\u672A\u627E\u5230 JSON \u8F93\u51FA");
+    return JSON.parse(raw.slice(start, end + 1));
   }
-  if (!options.onlyFindings || tscLines) {
-    parts.push(`## ${tscSectionTitle(tscOutput)}
-
-` + (tscLines || "\u6CA1\u6709\u53D1\u73B0\u7C7B\u578B\u9519\u8BEF"));
+}
+function parseEslintJson(raw, cwd) {
+  const parsed = extractJsonValue(raw);
+  if (!Array.isArray(parsed)) throw new Error("\u9876\u5C42\u5FC5\u987B\u662F\u6570\u7EC4");
+  const all = parsed.flatMap(
+    (file) => (file.messages ?? []).map((message) => ({
+      ...message,
+      filePath: file.filePath ? path.resolve(cwd, file.filePath) : ""
+    }))
+  );
+  return {
+    messages: all.filter((message) => message.filePath && !isEslintIgnoreNotice(message)),
+    ignored: all.filter((message) => message.filePath && isEslintIgnoreNotice(message)).map((m) => m.filePath)
+  };
+}
+function isEslintIgnoreNotice(message) {
+  return (message.ruleId ?? null) === null && typeof message.message === "string" && message.message.startsWith("File ignored because");
+}
+function filterTscOutputBySeverity(rawOutput, minSeverity) {
+  if (minSeverity === "warning" || !rawOutput) return rawOutput;
+  const errorLinePat = /^(.+?)\((\d+),(\d+)\):\s+(error|warning)\s+TS\d+:/;
+  const kept = [];
+  let keep = false;
+  for (const line of rawOutput.split("\n")) {
+    const match = errorLinePat.exec(line);
+    if (match) keep = match[4] === "error";
+    else if (!/^\s/.test(line)) keep = false;
+    if (keep) kept.push(line);
+  }
+  return kept.join("\n");
+}
+function applyTscSeverity(result, minSeverity) {
+  if (minSeverity === "warning") return result;
+  return {
+    ...result,
+    rawOutput: filterTscOutputBySeverity(result.rawOutput, minSeverity),
+    diagnostics: (result.diagnostics ?? []).filter((item) => item.severity === SEVERITY_ERROR)
+  };
+}
+function emptySectionText(kind, phase, severity) {
+  if (phase !== "manual") return void 0;
+  if (kind === "typecheck") return "\u6CA1\u6709\u53D1\u73B0\u7C7B\u578B\u9519\u8BEF";
+  return severity === "error" ? "\u6CA1\u6709\u53D1\u73B0\u9519\u8BEF" : "\u6CA1\u6709\u53D1\u73B0\u95EE\u9898";
+}
+function buildSection(name2, target, outcome, phase, severity, kind) {
+  const diagnostics = filterBySeverity(outcome.diagnostics ?? [], severity);
+  const explicit = (outcome.text ?? "").trim();
+  const body = explicit || (diagnostics.length > 0 ? renderDiagnosticLines(diagnostics) : emptySectionText(kind, phase, severity) ?? "");
+  const notes = phase === "manual" ? (outcome.notes ?? []).filter(Boolean) : [];
+  const text = [body, ...notes].filter(Boolean).join("\n\n");
+  return {
+    name: name2,
+    ...target ? { target } : {},
+    ...text ? { text } : {},
+    diagnostics
+  };
+}
+function resolveCommandSource(check, cwd) {
+  if (check.command) {
+    return { command: check.command, prefix: [], label: check.command };
+  }
+  const binName = check.bin;
+  const bin = resolvePackageBin(path.join(cwd, "package.json"), binName, binName);
+  if (!bin) {
+    return {
+      command: "node",
+      prefix: [],
+      label: binName,
+      error: `\u9879\u76EE\u91CC\u89E3\u6790\u4E0D\u5230 ${binName}\uFF08\u8BF7\u5148\u5B89\u88C5\u8BE5\u4F9D\u8D56\uFF0C\u6216\u6539\u7528 command \u6307\u5B9A\u53EF\u6267\u884C\u6587\u4EF6\uFF09`
+    };
+  }
+  return { command: "node", prefix: [bin], label: binName };
+}
+async function runCommand(check, source, argv, cwd) {
+  const result = await execa(source.command, [...source.prefix, ...argv], {
+    cwd,
+    timeout: check.timeoutMs ?? COMMAND_CHECK_TIMEOUT_MS,
+    maxBuffer: 10 * 1024 * 1024,
+    reject: false,
+    stdin: "ignore"
+  });
+  return {
+    stdout: String(result.stdout ?? ""),
+    stderr: String(result.stderr ?? ""),
+    exitCode: typeof result.exitCode === "number" ? result.exitCode : void 0,
+    failed: result.failed,
+    timedOut: Boolean(result.timedOut || result.isTerminated),
+    overflowed: Boolean(result.isMaxBuffer),
+    message: result.originalMessage
+  };
+}
+function commandFailureText(check, source, outcome) {
+  if (outcome.timedOut) {
+    return `[${check.name}] \u8FD0\u884C\u5931\u8D25\uFF1A\u68C0\u67E5\u8D85\u65F6\uFF08${check.timeoutMs ?? COMMAND_CHECK_TIMEOUT_MS}ms\uFF09\uFF0C\u53EF\u63D0\u9AD8 diagnostics.timeoutMs \u6216\u7F29\u5C0F\u68C0\u67E5\u8303\u56F4\u3002`;
+  }
+  if (outcome.overflowed) return `[${check.name}] \u8FD0\u884C\u5931\u8D25\uFF1A\u8F93\u51FA\u8D85\u8FC7\u4E0A\u9650\uFF0C\u8BF7\u7F29\u5C0F\u68C0\u67E5\u8303\u56F4\u3002`;
+  if (outcome.failed && outcome.exitCode === void 0) {
+    return `[${check.name}] \u8FD0\u884C\u5931\u8D25\uFF1A\u65E0\u6CD5\u6267\u884C ${source.label}\uFF08${outcome.message ?? "spawn failed"}\uFF09\u3002`;
+  }
+  return void 0;
+}
+function rawCommandOutput(outcome) {
+  return [outcome.stdout, outcome.stderr].map((text) => text.trim()).filter(Boolean).join("\n");
+}
+function expandArgs(args, files) {
+  return args.flatMap((arg) => {
+    if (arg === "{file}") return files[0] ? [files[0]] : [];
+    if (arg === "{files}") return [...files];
+    return [
+      arg.replace(
+        /\{file\}|\{files\}/g,
+        (match) => match === "{file}" ? files[0] ?? "" : files.join(" ")
+      )
+    ];
+  });
+}
+async function runAdapterModule(check, outcome, cwd, files) {
+  const adapterPath = path.resolve(cwd, check.adapter);
+  const fail = (reason) => ({
+    text: `[${check.name}] \u9002\u914D\u5668\u4E0D\u53EF\u7528\uFF1A${check.adapter}\uFF08${reason}\uFF09`,
+    diagnostics: []
+  });
+  let moduleExports;
+  try {
+    moduleExports = await import(pathToFileURL(adapterPath).href);
+  } catch (error) {
+    return fail(error instanceof Error ? error.message : String(error));
+  }
+  if (typeof moduleExports.default !== "function") {
+    return fail("\u6A21\u5757\u5FC5\u987B default export \u4E00\u4E2A\u9002\u914D\u5668\u51FD\u6570");
+  }
+  const input = {
+    name: check.name,
+    stdout: outcome.stdout,
+    stderr: outcome.stderr,
+    exitCode: outcome.exitCode,
+    files: [...files],
+    cwd
+  };
+  let output;
+  try {
+    output = await moduleExports.default(
+      input
+    );
+  } catch (error) {
+    return fail(error instanceof Error ? error.message : String(error));
+  }
+  if (!output || typeof output !== "object") return fail("\u9002\u914D\u5668\u5FC5\u987B\u8FD4\u56DE\u5BF9\u8C61");
+  try {
+    const diagnostics = normalizeEntries(output.diagnostics, check.name);
+    return { text: diagnostics.length > 0 ? void 0 : output.text, diagnostics };
+  } catch (error) {
+    return fail(error instanceof Error ? error.message : String(error));
+  }
+}
+function parseStylelintJson(raw, cwd) {
+  const parsed = extractJsonValue(raw);
+  if (!Array.isArray(parsed)) throw new Error("\u9876\u5C42\u5FC5\u987B\u662F\u6570\u7EC4");
+  return parsed.flatMap((file) => {
+    const filePath = file.source ? path.resolve(cwd, file.source) : "";
+    if (!filePath) return [];
+    return (file.warnings ?? []).map((warning) => ({
+      severity: warning.severity === "error" ? 2 : 1,
+      line: warning.line ?? 1,
+      column: warning.column ?? 1,
+      endLine: warning.endLine,
+      endColumn: warning.endColumn,
+      message: warning.text ?? "\u672A\u77E5\u8BCA\u65AD",
+      ruleId: warning.rule ?? null,
+      filePath
+    }));
+  });
+}
+function adaptBuiltinFormat(format, check, raw, cwd, severity) {
+  const lintFromMessages = (messages) => {
+    const output = formatLintMessages(
+      messages,
+      { label: check.name, source: check.name },
+      10,
+      severity
+    );
+    return { text: output.text, diagnostics: output.diagnostics ?? [] };
+  };
+  switch (format) {
+    case "tsc":
+      return {
+        text: filterTscOutputBySeverity(raw, severity),
+        diagnostics: parseTscDiags(raw, void 0, cwd, check.name)
+      };
+    case "eslint-json": {
+      const { messages, ignored } = parseEslintJson(raw, cwd);
+      return {
+        ...lintFromMessages(messages),
+        notes: ignored.map((file) => `${file} \u4E0D\u5728 ESLint \u914D\u7F6E\u8303\u56F4\u5185\uFF0C\u672A\u68C0\u67E5`)
+      };
+    }
+    case "oxlint-json":
+      return lintFromMessages(parseOxlintOutput(raw, cwd));
+    case "stylelint-json":
+      return lintFromMessages(parseStylelintJson(raw, cwd));
+    case "aipanel-json": {
+      const value = extractJsonValue(raw);
+      const payload = Array.isArray(value) ? { diagnostics: value } : value;
+      const diagnostics = normalizeEntries(payload?.diagnostics, check.name);
+      return { text: diagnostics.length > 0 ? void 0 : payload?.text, diagnostics };
+    }
+    case "text":
+    default:
+      return { text: raw, diagnostics: [] };
+  }
+}
+function expandLinterPreset(check) {
+  const spec = BUILTIN_LINTERS[check.builtin];
+  return {
+    name: spec.label,
+    bin: spec.bin ?? spec.package,
+    args: check.args ?? [...spec.args],
+    ...check.projectArgs ?? spec.projectArgs ? { projectArgs: [...check.projectArgs ?? spec.projectArgs ?? []] } : {},
+    extensions: check.extensions ?? [...spec.extensions],
+    format: check.format ?? spec.format,
+    ...check.run ? { run: check.run } : {},
+    ...check.cwd ? { cwd: check.cwd } : {},
+    ...check.timeoutMs ? { timeoutMs: check.timeoutMs } : {}
+  };
+}
+async function runCommandCheck(check, target, phase, severity, optional = false) {
+  const cwd = check.cwd ? path.resolve(target.cwd, check.cwd) : target.cwd;
+  const args = check.args ?? [];
+  const hasPlaceholder = args.some((arg) => arg.includes("{file}") || arg.includes("{files}"));
+  const perFile = args.some((arg) => arg.includes("{file}"));
+  const split = splitsByFile(target);
+  const targeted = target.kind !== "project";
+  const files = targeted ? targetFiles(target).filter((file) => matchesExtensions(file, check.extensions)) : [];
+  if (targeted && hasPlaceholder && files.length === 0) {
+    log2.debug("skip command check: no matching file target", { name: check.name, phase });
+    return [];
+  }
+  const source = resolveCommandSource(check, cwd);
+  if (source.error) {
+    if (optional && phase === "edit") {
+      log2.debug("skip uninstalled builtin linter", { name: check.name });
+      return [];
+    }
+    const text = optional ? `[${check.name}] \u672A\u8FD0\u884C\uFF1A${source.error}` : `[${check.name}] ${source.error}`;
+    return [buildSection(check.name, void 0, { text }, phase, severity, "command")];
+  }
+  const execute = async (argvTemplate, fileSet) => {
+    const outcome = await runCommand(check, source, expandArgs(argvTemplate, fileSet), cwd);
+    const failure = commandFailureText(check, source, outcome);
+    if (failure) return { text: failure, diagnostics: [] };
+    const raw = rawCommandOutput(outcome);
+    try {
+      if (check.adapter) return await runAdapterModule(check, outcome, cwd, fileSet);
+      return adaptBuiltinFormat(check.format ?? "text", check, raw, cwd, severity);
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      const excerpt = raw.replace(/\s+/g, " ").trim().slice(0, 200);
+      return {
+        text: `[${check.name}] \u8FD0\u884C\u5931\u8D25\uFF1A\u8F93\u51FA\u89E3\u6790\u5931\u8D25\uFF08${reason}\uFF09${excerpt ? `\uFF1A${excerpt}` : ""}`,
+        diagnostics: []
+      };
+    }
+  };
+  const targetLabel = (file) => split ? displayPath(target.cwd, file) : void 0;
+  if (!hasPlaceholder) {
+    return [
+      buildSection(check.name, void 0, await execute(args, []), phase, severity, "command")
+    ];
+  }
+  if (target.kind === "project") {
+    if (!check.projectArgs) {
+      log2.debug("skip command check: no project args", { name: check.name });
+      return [];
+    }
+    return [
+      buildSection(
+        check.name,
+        void 0,
+        await execute(check.projectArgs, []),
+        phase,
+        severity,
+        "command"
+      )
+    ];
+  }
+  if (perFile) {
+    const sections = [];
+    for (const file of files) {
+      const produced2 = await execute(args, [file]);
+      sections.push(
+        buildSection(check.name, targetLabel(file), produced2, phase, severity, "command")
+      );
+    }
+    return sections;
+  }
+  const produced = await execute(args, files);
+  const label = files.length === 1 ? targetLabel(files[0]) : void 0;
+  return [buildSection(check.name, label, produced, phase, severity, "command")];
+}
+async function runProjectTypeCheck(workspace, severity) {
+  const dirs = fs.existsSync(path.join(workspace, "tsconfig.json")) ? [workspace] : findAllTsconfigDirs(workspace);
+  log2.debug("Tsc dirs to check", { count: dirs.length, dirs });
+  const results = await Promise.all(dirs.map((dir) => runTypeCheck(void 0, dir)));
+  return applyTscSeverity(
+    {
+      rawOutput: results.flatMap((output) => output.rawOutput).filter(Boolean).join("\n"),
+      exitCode: results.reduce((max, output) => Math.max(max, output.exitCode), 0),
+      diagnostics: results.flatMap((output) => output.diagnostics ?? []),
+      source: results.find((output) => output.source)?.source
+    },
+    severity
+  );
+}
+async function runTypecheckCheck(check, target, phase, severity) {
+  const cwd = target.cwd;
+  const split = splitsByFile(target);
+  const files = target.kind === "project" ? [] : targetFiles(target).filter(
+    (file) => matchesExtensions(file, check.extensions ?? SOURCE_EXTENSIONS)
+  );
+  if (target.kind !== "project" && files.length === 0) {
+    log2.debug("skip builtin check: no matching file target", { builtin: check.builtin, phase });
+    return [];
   }
-  if (parts.length === 0) return "";
-  const body = parts.join("\n\n");
-  return title ? `${title}
+  if (split) {
+    const results = await runTypeChecksForFiles(files, cwd);
+    return files.map((file) => {
+      const result2 = applyTscSeverity(
+        results.get(path.resolve(file)) ?? { rawOutput: "", exitCode: 0 },
+        severity
+      );
+      return buildSection(
+        tscSectionTitle(result2),
+        displayPath(cwd, file),
+        { text: result2.rawOutput.trim(), diagnostics: result2.diagnostics },
+        phase,
+        severity,
+        "typecheck"
+      );
+    });
+  }
+  const result = target.kind === "file" ? applyTscSeverity(await runTypeCheck(files[0], cwd), severity) : await runProjectTypeCheck(cwd, severity);
+  return [
+    buildSection(
+      tscSectionTitle(result),
+      void 0,
+      { text: result.rawOutput.trim(), diagnostics: result.diagnostics },
+      phase,
+      severity,
+      "typecheck"
+    )
+  ];
+}
+async function runDiagnostics(target, policy, phase) {
+  const checks = policy.checks.filter((check) => checkRunsInPhase(check, phase));
+  log2.debug("runDiagnostics", { phase, target: target.kind, checks: checks.length });
+  const results = await Promise.all(
+    checks.map((check) => {
+      if (isTypecheckCheck(check)) {
+        return runTypecheckCheck(check, target, phase, policy.severity);
+      }
+      if (isLinterPreset(check)) {
+        return runCommandCheck(expandLinterPreset(check), target, phase, policy.severity, true);
+      }
+      if (isCommandCheck(check)) {
+        return runCommandCheck(check, target, phase, policy.severity);
+      }
+      return Promise.resolve([]);
+    })
+  );
+  const sections = results.flat().filter((section) => section.text !== void 0 || section.diagnostics.length > 0);
+  if (sections.length === 0 && phase === "manual") {
+    return {
+      sections: [
+        {
+          name: "\u68C0\u67E5",
+          text: "\u6CA1\u6709\u53EF\u8FD0\u884C\u7684\u68C0\u67E5\uFF1A\u5DF2\u914D\u7F6E\u7684\u68C0\u67E5\u90FD\u4E0D\u5339\u914D\u672C\u8F6E\u76EE\u6807\uFF08\u68C0\u67E5\u7684 extensions / run \u9636\u6BB5 / \u76EE\u6807\u7C7B\u578B\uFF09\u3002",
+          diagnostics: []
+        }
+      ]
+    };
+  }
+  return { sections };
+}
+function collectDiagnostics(result) {
+  return result.sections.flatMap((section) => section.diagnostics);
+}
+function renderDiagnostics(result, options = {}) {
+  const sections = options.onlyFindings ? result.sections.filter((section) => (section.text ?? "").trim()) : result.sections;
+  if (sections.length === 0) return "";
+  const groups = /* @__PURE__ */ new Map();
+  for (const section of sections) {
+    const key = section.target ?? "";
+    const group = groups.get(key);
+    if (group) group.push(section);
+    else groups.set(key, [section]);
+  }
+  const blocks = [];
+  for (const [key, group] of groups) {
+    const body = group.map((section) => {
+      const text = boundFindings(section.text, options.maxFindingsPerSection);
+      return `## ${section.name}
+
+${text || "\u6CA1\u6709\u53D1\u73B0\u95EE\u9898"}`;
+    }).join("\n\n");
+    blocks.push(key ? `### ${key}
 
-${body}` : body;
+${body}` : body);
+  }
+  return blocks.join("\n\n");
 }
 
 // ../../core/es/common/utils.mjs
@@ -1149,8 +1661,6 @@ function buildPluginMessage(text, notice) {
     source
   };
 }
-var DIAGNOSTICS_MESSAGE_MAX_CHARS = 4e3;
-var MAX_FINDINGS_PER_SECTION = 3;
 function editTarget(exec) {
   const rawArgs = exec.arguments;
   const filePath = typeof rawArgs?.file_path === "string" ? rawArgs.file_path : rawArgs?.filePath;
@@ -1161,7 +1671,7 @@ function registerPendingEdit(pending, exec, result, decision, cwd) {
   if (result.isError) return;
   if (decision.kind !== "accept") return;
   const filePath = editTarget(exec);
-  if (!filePath || !isJsFile(filePath)) return;
+  if (!filePath) return;
   const { agent } = exec;
   if (!agent) return;
   let files = pending.get(agent);
@@ -1171,36 +1681,24 @@ function registerPendingEdit(pending, exec, result, decision, cwd) {
   }
   files.add(path2.resolve(cwd, filePath));
 }
-function truncateDiagnostics(text) {
-  if (text.length <= DIAGNOSTICS_MESSAGE_MAX_CHARS) return text;
-  return `${text.slice(0, DIAGNOSTICS_MESSAGE_MAX_CHARS)}
+function truncateDiagnostics(text, maxChars) {
+  if (text.length <= maxChars) return text;
+  return `${text.slice(0, maxChars)}
 
 \u2026\uFF08\u8BCA\u65AD\u8F93\u51FA\u8FC7\u957F\uFF0C\u5DF2\u622A\u65AD\uFF1B\u53EF\u8C03\u7528 run_diagnostics \u67E5\u770B\u5B8C\u6574\u7ED3\u679C\uFF09`;
 }
-async function collectPendingDiagnostics(pending, cwd) {
+async function collectPendingDiagnostics(pending, cwd, policy) {
   const files = [...pending];
-  const checks = await runAllChecksForFiles(files, cwd).catch(
-    () => /* @__PURE__ */ new Map()
+  const result = await runDiagnostics({ kind: "edited", files, cwd }, policy, "edit").catch(
+    () => ({ sections: [] })
   );
-  const empty = {
-    eslintOutput: {},
-    tscOutput: { rawOutput: "", exitCode: 0 }
-  };
-  const blocks = [];
-  for (const file of files) {
-    const { eslintOutput, tscOutput } = checks.get(file) ?? empty;
-    const section = formatDiagnosticsSections(
-      `### ${path2.relative(cwd, file)}`,
-      eslintOutput,
-      tscOutput,
-      { onlyFindings: true, maxFindingsPerSection: MAX_FINDINGS_PER_SECTION }
-    );
-    if (!section) continue;
-    blocks.push(section);
-  }
-  return blocks.length > 0 ? truncateDiagnostics(`\u81EA\u52A8\u8BCA\u65AD\uFF08\u7F16\u8F91\u540E\uFF09\uFF1A
+  const text = renderDiagnostics(result, {
+    onlyFindings: true,
+    maxFindingsPerSection: policy.maxFindingsPerSection
+  });
+  return text ? truncateDiagnostics(`\u81EA\u52A8\u8BCA\u65AD\uFF08\u7F16\u8F91\u540E\uFF09\uFF1A
 
-${blocks.join("\n\n")}`) : "";
+${text}`, policy.maxMessageChars) : "";
 }
 function toDiagnosticEntries(items) {
   return items.map((d) => ({
@@ -1211,17 +1709,14 @@ function toDiagnosticEntries(items) {
     message: d.message
   }));
 }
-function buildDiagnosticsCanonical(title, eslintOutput, tscOutput) {
+function buildDiagnosticsCanonical(title, result) {
   return {
     title,
-    sections: [
-      { title: lintSectionTitle(eslintOutput), text: eslintOutput.text || "\u6CA1\u6709\u53D1\u73B0\u95EE\u9898" },
-      { title: tscSectionTitle(tscOutput), text: tscOutput.rawOutput.trim() || "\u6CA1\u6709\u53D1\u73B0\u7C7B\u578B\u9519\u8BEF" }
-    ],
-    diagnostics: [
-      ...toDiagnosticEntries(eslintOutput.diagnostics ?? []),
-      ...toDiagnosticEntries(tscOutput.diagnostics ?? [])
-    ]
+    sections: result.sections.map((section) => ({
+      title: section.target ? `${section.target} \xB7 ${section.name}` : section.name,
+      text: section.text ?? "\u6CA1\u6709\u53D1\u73B0\u95EE\u9898"
+    })),
+    diagnostics: toDiagnosticEntries(collectDiagnostics(result))
   };
 }
 function renderDiagnosticsText(value) {
@@ -1296,13 +1791,15 @@ function applyProviderSettings(ctx, config) {
 }
 function apply(ctx, config = {}) {
   const cwd = config.cwd ?? process.cwd();
-  const enableDiagnostics = config.enableDiagnostics ?? false;
-  const autoDiagnose = config.autoDiagnose ?? process.env[OPENCODE_ENV.ENABLE_LINT] === "1";
+  const policy = resolveDiagnosticsPolicy(
+    [DEFAULT_DIAGNOSTICS_POLICY, config.diagnostics],
+    (message) => log4.warn(message)
+  );
   const vitePort = config.vitePort ?? 0;
   const viteHost = config.viteHost;
   const contextApiPath = config.contextApiPath ?? CONTEXT_API_PATH;
   const tools = ctx.tools;
-  if (enableDiagnostics) {
+  if (policy.exposeTool) {
     const diagnosticsTool = {
       name: "run_diagnostics",
       description: DIAGNOSTICS_TOOL_DESCRIPTION,
@@ -1353,7 +1850,7 @@ function apply(ctx, config = {}) {
           },
           required: ["title", "sections", "diagnostics"]
         },
-        // canonical → 模型可见文本（## ESLint / ## vue-tsc 分区，与 formatDiagnosticsSections 一致）
+        // canonical → 模型可见文本（分区标题由配置的检查给出，与 renderDiagnostics 一致）
         render: (_args, value) => [
           { type: "text", text: renderDiagnosticsText(value) }
         ],
@@ -1364,27 +1861,28 @@ function apply(ctx, config = {}) {
       },
       async execute(args) {
         const filePath = args?.filePath;
+        let target;
+        let title;
         if (typeof filePath === "string" && filePath) {
           const resolved = path2.resolve(cwd, filePath);
           if (!fs2.existsSync(resolved)) throw new Error(`\u6587\u4EF6\u4E0D\u5B58\u5728: ${resolved}`);
-          const { eslintOutput: eslintOutput2, tscOutput: tscOutput2 } = await runAllChecks(resolved, cwd);
-          return buildDiagnosticsCanonical(
-            `\u8BCA\u65AD\u7ED3\u679C: ${path2.relative(cwd, resolved)}`,
-            eslintOutput2,
-            tscOutput2
-          );
+          target = { kind: "file", file: resolved, cwd };
+          title = `\u8BCA\u65AD\u7ED3\u679C: ${path2.relative(cwd, resolved)}`;
+        } else {
+          target = { kind: "project", cwd };
+          title = "\u5168\u91CF\u8BCA\u65AD\u7ED3\u679C";
         }
-        const { eslintOutput, tscOutput } = await runProjectDiagnostics(cwd);
-        return buildDiagnosticsCanonical("\u5168\u91CF\u8BCA\u65AD\u7ED3\u679C", eslintOutput, tscOutput);
+        return buildDiagnosticsCanonical(title, await runDiagnostics(target, policy, "manual"));
       }
     };
     tools.register(diagnosticsTool);
+  }
+  if (policy.auto) {
     const pendingEdits = /* @__PURE__ */ new WeakMap();
     ctx.on(
       "tools/post-execute",
       async (exec, result, next) => {
         const decision = await next();
-        if (!autoDiagnose) return decision;
         registerPendingEdit(pendingEdits, exec, result, decision, cwd);
         return decision;
       }
@@ -1393,12 +1891,11 @@ function apply(ctx, config = {}) {
       "agent/pre-step",
       async ({ agent }, next) => {
         const decision = await next();
-        if (!autoDiagnose) return decision;
         const files = pendingEdits.get(agent);
         if (!files || files.size === 0) return decision;
         pendingEdits.delete(agent);
         if (decision.kind === "reject") return decision;
-        const text = await collectPendingDiagnostics(files, cwd);
+        const text = await collectPendingDiagnostics(files, cwd, policy);
         if (!text) return decision;
         return {
           ...decision,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aipanel/dsh-plugin",
-  "version": "1.3.4",
+  "version": "1.3.6",
   "type": "module",
   "description": "AIPanel for DeepSeek Harness (dsh)：注入审查工具 run_diagnostics、编辑后自动诊断。",
   "main": "./dist/index.js",
@@ -16,7 +16,7 @@
     "vue-tsc": "^3.3.9"
   },
   "devDependencies": {
-    "@aipanel/core": "1.3.4",
+    "@aipanel/core": "1.3.6",
     "@deepseek-ai/cordis": "~4.0.4",
     "@deepseek-ai/dsh-agent": "^0.1.7-alpha.2",
     "@deepseek-ai/dsh-llm": "^0.1.7-alpha.2",