@fuxi-ailabs/dsh-eval-ux 0.0.0-stage → 1.0.0

package/dist/index.js

@@ -0,0 +1,1182 @@
+// src/config.ts
+var defaultConfig = {
+  manualSkillPaths: []
+};
+function expandHome(value, home = process.env.HOME ?? "~") {
+  if (value === "~") return home;
+  if (value.startsWith("~/")) return `${home}${value.slice(1)}`;
+  return value;
+}
+function normalizeConfig(input) {
+  const paths = Array.isArray(input?.manualSkillPaths) ? input.manualSkillPaths.filter((item) => typeof item === "string" && item.trim().length > 0) : [];
+  return {
+    manualSkillPaths: [...new Set(paths.map((item) => expandHome(item.trim())))]
+  };
+}
+
+// src/host/endpoint.ts
+import { readFile as readFile4, readdir as readdir2, rm as rm2, stat as stat4 } from "node:fs/promises";
+import os3 from "node:os";
+import path4 from "node:path";
+
+// src/host/catalog.ts
+import { createHash } from "node:crypto";
+import { readFile as readFile2, readdir, stat as stat2 } from "node:fs/promises";
+import path2 from "node:path";
+
+// src/host/manual-paths.ts
+import { mkdir, readFile, rename, stat, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+function storeFile() {
+  return path.join(process.env.DSH_HOME ?? path.join(os.homedir(), ".dsh"), "dsh-eval-ux", "manual-paths.json");
+}
+function legacyStoreFile() {
+  return path.join(process.env.DSH_HOME ?? path.join(os.homedir(), ".dsh"), "dsh-sift-workbench", "manual-paths.json");
+}
+async function readPaths(file) {
+  try {
+    const parsed = JSON.parse(await readFile(file, "utf8"));
+    return Array.isArray(parsed.paths) ? parsed.paths.filter((item) => typeof item === "string" && item.trim().length > 0) : [];
+  } catch {
+    return void 0;
+  }
+}
+async function readUserPaths() {
+  const current = await readPaths(storeFile());
+  if (current) return current;
+  const legacy = await readPaths(legacyStoreFile());
+  if (!legacy?.length) return legacy ?? [];
+  try {
+    await writeUserPaths(legacy);
+  } catch {
+  }
+  return legacy;
+}
+async function writeUserPaths(paths) {
+  const file = storeFile();
+  await mkdir(path.dirname(file), { recursive: true });
+  const temp = `${file}.${process.pid}.tmp`;
+  await writeFile(temp, JSON.stringify({ paths }, null, 2), "utf8");
+  await rename(temp, file);
+}
+function unique(paths) {
+  return [...new Set(paths)];
+}
+async function readManualPathEntries(config) {
+  const configPaths = config.manualSkillPaths.map((item) => path.resolve(expandHome(item)));
+  const userPaths = (await readUserPaths()).map((item) => path.resolve(expandHome(item)));
+  return [
+    ...unique(configPaths).map((item) => ({ path: item, source: "config" })),
+    ...unique(userPaths.filter((item) => !configPaths.includes(item))).map((item) => ({ path: item, source: "user" }))
+  ];
+}
+async function addManualPath(rawPath) {
+  const value = rawPath.trim();
+  if (!value) throw new Error("\u8DEF\u5F84\u4E0D\u80FD\u4E3A\u7A7A");
+  const resolved = path.resolve(expandHome(value));
+  const info = await stat(resolved).catch(() => void 0);
+  if (!info) throw new Error(`\u8DEF\u5F84\u4E0D\u5B58\u5728: ${resolved}`);
+  if (!info.isDirectory() && !info.isFile()) throw new Error(`\u4E0D\u662F\u6587\u4EF6\u6216\u76EE\u5F55: ${resolved}`);
+  if (info.isFile() && !resolved.toLowerCase().endsWith(".md")) throw new Error("\u6587\u4EF6\u8DEF\u5F84\u5FC5\u987B\u662F Markdown");
+  const userPaths = await readUserPaths();
+  const normalized = unique([...userPaths.map((item) => path.resolve(expandHome(item))), resolved]);
+  await writeUserPaths(normalized);
+  return normalized.map((item) => ({ path: item, source: "user" }));
+}
+
+// src/host/catalog.ts
+function stableId(source, filePath, name2) {
+  return createHash("sha256").update(`${source}\0${filePath ?? ""}\0${name2}`).digest("hex").slice(0, 20);
+}
+function toView(summary) {
+  return {
+    id: stableId(summary.source || "unknown", summary.path, summary.name),
+    name: summary.name,
+    description: summary.description || "",
+    source: summary.source || "unknown",
+    provider: summary.provider || "unknown",
+    ...summary.path ? { path: summary.path } : {},
+    ...summary.resourceBase?.kind === "directory" && summary.resourceBase.path ? { resourceBasePath: summary.resourceBase.path, resourceBaseKind: "directory" } : summary.resourceBase?.kind ? { resourceBaseKind: summary.resourceBase.kind } : {},
+    modelInvocable: summary.invocation?.modelInvocable !== false,
+    userInvocable: summary.invocation?.userInvocable !== false
+  };
+}
+function uniq(items) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const item of items) byId.set(item.id, item);
+  return [...byId.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+function skillPathKey(skill) {
+  const candidate = skill.path ?? (skill.resourceBaseKind === "directory" && skill.resourceBasePath ? path2.join(skill.resourceBasePath, "SKILL.md") : void 0);
+  if (!candidate) return void 0;
+  const normalized = path2.normalize(path2.resolve(candidate));
+  return process.platform === "darwin" || process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}
+function uniqByPath(items) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const skill of uniq(items)) {
+    const key = skillPathKey(skill);
+    if (key && seen.has(key)) continue;
+    if (key) seen.add(key);
+    result.push(skill);
+  }
+  return result;
+}
+function isSystem(source) {
+  return source === "bundled";
+}
+function isManualSource(source) {
+  return source === "custom";
+}
+function isProject(source) {
+  return source.startsWith("project-");
+}
+function isUser(source) {
+  return !isSystem(source) && !isManualSource(source) && !isProject(source);
+}
+function scalar(frontmatter, key) {
+  const match = frontmatter.match(new RegExp(`^${key}\\s*:\\s*(.+)$`, "m"));
+  if (!match) return "";
+  let value = match[1].trim();
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    value = value.slice(1, -1);
+  }
+  return value;
+}
+function parseManualSkill(filePath, content) {
+  const match = content.match(/^---\s*\n([\s\S]*?)\n---(?:\n|$)/);
+  if (!match) return void 0;
+  const frontmatter = match[1];
+  const name2 = scalar(frontmatter, "name") || path2.basename(path2.dirname(filePath));
+  if (!name2) return void 0;
+  const description = scalar(frontmatter, "description");
+  return {
+    id: stableId("manual-path", filePath, name2),
+    name: name2,
+    description,
+    source: "manual-path",
+    provider: "configured-path",
+    path: filePath,
+    resourceBasePath: path2.dirname(filePath),
+    resourceBaseKind: "directory",
+    modelInvocable: true,
+    userInvocable: true
+  };
+}
+async function exists(filePath) {
+  try {
+    await stat2(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function skillFilesAt(configuredPath, warnings) {
+  let info;
+  try {
+    info = await stat2(configuredPath);
+  } catch {
+    warnings.push(`\u624B\u52A8\u8DEF\u5F84\u4E0D\u5B58\u5728: ${configuredPath}`);
+    return [];
+  }
+  if (info.isFile()) return configuredPath.toLowerCase().endsWith(".md") ? [configuredPath] : [];
+  if (!info.isDirectory()) return [];
+  const direct = path2.join(configuredPath, "SKILL.md");
+  if (await exists(direct)) return [direct];
+  const files = [];
+  let entries = [];
+  try {
+    entries = await readdir(configuredPath);
+  } catch (error) {
+    warnings.push(`\u8BFB\u53D6\u624B\u52A8\u8DEF\u5F84\u5931\u8D25 ${configuredPath}: ${error instanceof Error ? error.message : String(error)}`);
+    return [];
+  }
+  for (const entry of entries.sort()) {
+    const candidate = path2.join(configuredPath, entry, "SKILL.md");
+    if (await exists(candidate)) files.push(candidate);
+  }
+  return files;
+}
+async function readManualSkills(paths, warnings) {
+  const skills = [];
+  for (const configuredPath of paths) {
+    for (const filePath of await skillFilesAt(configuredPath, warnings)) {
+      try {
+        const content = await readFile2(filePath, "utf8");
+        const skill = parseManualSkill(filePath, content);
+        if (skill) skills.push(skill);
+        else warnings.push(`\u624B\u52A8 skill \u7F3A\u5C11\u6709\u6548 frontmatter: ${filePath}`);
+      } catch (error) {
+        warnings.push(`\u8BFB\u53D6\u624B\u52A8 skill \u5931\u8D25 ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+  }
+  return uniq(skills);
+}
+function withTimeout(promise, timeoutMs, message) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error(message)), timeoutMs);
+    promise.then(
+      (value) => {
+        clearTimeout(timer);
+        resolve(value);
+      },
+      (error) => {
+        clearTimeout(timer);
+        reject(error);
+      }
+    );
+  });
+}
+function skillsService(ctx) {
+  const skills = ctx.get("skills");
+  if (!skills || typeof skills.list !== "function") {
+    throw new Error("\u5BBF\u4E3B\u672A\u6302\u8F7D skills \u670D\u52A1");
+  }
+  return skills;
+}
+function currentAgentScope(ctx, warnings) {
+  try {
+    const agents = ctx.get("agents");
+    return agents && typeof agents.list === "function" ? agents.list()[0] : void 0;
+  } catch (error) {
+    warnings.push(`\u8BFB\u53D6 live agent \u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`);
+    return void 0;
+  }
+}
+async function currentCatalogSkills(skills, scope, cwd, warnings) {
+  try {
+    return await withTimeout(
+      skills.list({ cwd, ...scope ? { scope } : {} }),
+      4e3,
+      "\u8BFB\u53D6\u5F53\u524D skill catalog \u8D85\u65F6"
+    );
+  } catch (error) {
+    warnings.push(`\u8BFB\u53D6\u5F53\u524D skill catalog \u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`);
+    return [];
+  }
+}
+async function buildSkillCatalog(ctx, config) {
+  const fetchedAt = Date.now();
+  const warnings = [];
+  let skills;
+  try {
+    skills = skillsService(ctx);
+  } catch (error) {
+    const manualPaths2 = await readManualPathEntries(config);
+    const manual2 = await readManualSkills(manualPaths2.map((entry) => entry.path), warnings);
+    return {
+      ok: false,
+      error: error instanceof Error ? error.message : String(error),
+      warnings,
+      system: [],
+      user: [],
+      manual: manual2,
+      manualPaths: manualPaths2,
+      workspaces: [],
+      fetchedAt
+    };
+  }
+  let workspaces = [];
+  try {
+    const registry = ctx.get("workspaceRegistry");
+    workspaces = registry && typeof registry.list === "function" ? registry.list() : [];
+  } catch (error) {
+    warnings.push(`\u8BFB\u53D6 workspace \u5217\u8868\u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  const scope = currentAgentScope(ctx, warnings);
+  const globalCwd = workspaces[0]?.path ?? process.cwd();
+  const summaries = await currentCatalogSkills(skills, scope, globalCwd, warnings);
+  const views = summaries.map(toView);
+  const workspaceGroups = await Promise.all(workspaces.map(async (workspace) => {
+    const base = {
+      id: `workspace:${workspace.id}`,
+      kind: "workspace",
+      title: workspace.title || workspace.path,
+      workspaceId: workspace.id,
+      skills: []
+    };
+    try {
+      const listed = await withTimeout(
+        skills.list({ cwd: workspace.path, ...scope ? { scope } : {} }),
+        4e3,
+        `\u8BFB\u53D6\u5DE5\u4F5C\u533A ${workspace.title || workspace.path} \u8D85\u65F6`
+      );
+      return {
+        ...base,
+        skills: uniq(listed.filter((skill) => isProject(skill.source)).map(toView))
+      };
+    } catch (error) {
+      warnings.push(`\u8BFB\u53D6\u5DE5\u4F5C\u533A ${workspace.title || workspace.path} \u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`);
+      return base;
+    }
+  }));
+  const manualPaths = await readManualPathEntries(config);
+  const knownSkills = uniq([
+    ...views.filter((skill) => !isManualSource(skill.source)),
+    ...workspaceGroups.flatMap((group) => group.skills)
+  ]);
+  const knownPaths = new Set(knownSkills.map(skillPathKey).filter((key) => Boolean(key)));
+  const manual = uniqByPath([
+    ...views.filter((skill) => isManualSource(skill.source)),
+    ...await readManualSkills(manualPaths.map((entry) => entry.path), warnings)
+  ]).filter((skill) => {
+    const key = skillPathKey(skill);
+    return !key || !knownPaths.has(key);
+  });
+  return {
+    ok: true,
+    warnings,
+    system: uniq(views.filter((skill) => isSystem(skill.source))),
+    user: uniq(views.filter((skill) => isUser(skill.source))),
+    manual,
+    manualPaths,
+    workspaces: workspaceGroups,
+    fetchedAt
+  };
+}
+
+// src/host/eval-suite.ts
+import { readFile as readFile3, rename as rename2, rm, stat as stat3, writeFile as writeFile2 } from "node:fs/promises";
+import os2 from "node:os";
+import path3 from "node:path";
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function stringValue(value) {
+  return typeof value === "string" ? value : "";
+}
+function stringArray(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function assertionViews(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter(isRecord).map((item) => ({
+    name: stringValue(item.name),
+    type: stringValue(item.type),
+    params: isRecord(item.params) ? item.params : {},
+    ...stringValue(item.tier) ? { tier: stringValue(item.tier) } : {}
+  }));
+}
+function evalCaseView(value, index) {
+  if (!isRecord(value)) return void 0;
+  const prompt = stringValue(value.prompt);
+  if (!prompt) return void 0;
+  return {
+    id: typeof value.id === "number" ? value.id : index + 1,
+    name: stringValue(value.name),
+    prompt,
+    expectedOutput: stringValue(value.expected_output),
+    level: stringValue(value.level) || "L1",
+    expectations: stringArray(value.expectations),
+    assertions: assertionViews(value.assertions),
+    rationale: stringValue(value.rationale),
+    confidence: typeof value.confidence === "number" ? value.confidence : null,
+    flags: stringArray(value.flags)
+  };
+}
+function skillDirectory(skillPath) {
+  const resolved = path3.resolve(skillPath);
+  return path3.basename(resolved).toLowerCase().endsWith(".md") ? path3.dirname(resolved) : resolved;
+}
+function defaultPhaseOutput(skillPath, phase) {
+  const home = process.env.DSH_HOME ?? path3.join(os2.homedir(), ".dsh");
+  const leaf = path3.basename(skillPath).toLowerCase().endsWith(".md") ? path3.basename(path3.dirname(skillPath)) : path3.basename(skillPath);
+  const safe = leaf.replace(/[^\p{L}\p{N}._-]+/gu, "-").replace(/^-+|-+$/g, "") || "skill";
+  return path3.join(home, "eval-runs", safe, phase);
+}
+async function exists2(filePath) {
+  return stat3(filePath).then(() => true).catch(() => false);
+}
+async function readJson(filePath) {
+  try {
+    return JSON.parse(await readFile3(filePath, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+async function readEvalSuite(skillPath) {
+  const resolvedSkill = path3.resolve(skillPath);
+  const directory = skillDirectory(resolvedSkill);
+  const evalsPath = path3.join(directory, "evals", "evals.json");
+  const baselinePath = path3.join(directory, "evals", "baseline.json");
+  const baselineMetaPath = path3.join(directory, "evals", "baseline.meta.json");
+  const coveragePath = path3.join(directory, "evals", "coverage-report.json");
+  const managedEvalOutput = defaultPhaseOutput(resolvedSkill, "eval");
+  const legacyEvalOutput = path3.resolve("output");
+  const managedBenchmark = path3.join(managedEvalOutput, "benchmark.json");
+  const legacyBenchmark = path3.join(legacyEvalOutput, "benchmark.json");
+  const evalOutputDir = await exists2(managedBenchmark) ? managedEvalOutput : await exists2(legacyBenchmark) ? legacyEvalOutput : managedEvalOutput;
+  const benchmarkPath = path3.join(evalOutputDir, "benchmark.json");
+  const gatePath = path3.join(evalOutputDir, "gate.json");
+  const reportPath = path3.join(evalOutputDir, "report.html");
+  const scorecardPath = path3.join(evalOutputDir, "scorecard.json");
+  const triggerOutputDir = defaultPhaseOutput(resolvedSkill, "trigger");
+  const triggerReportJson = path3.join(triggerOutputDir, "trigger-report.json");
+  const triggerReportHtml = path3.join(triggerOutputDir, "trigger-report.html");
+  const artifacts = {
+    evalOutputDir,
+    benchmarkPath,
+    benchmarkExists: await exists2(benchmarkPath),
+    gatePath,
+    gateExists: await exists2(gatePath),
+    reportPath,
+    reportExists: await exists2(reportPath),
+    scorecardPath,
+    scorecardExists: await exists2(scorecardPath),
+    triggerOutputDir,
+    triggerReportJson,
+    triggerReportHtml,
+    triggerReportExists: await exists2(triggerReportJson)
+  };
+  const base = {
+    ok: true,
+    exists: false,
+    skillPath: resolvedSkill,
+    evalsPath,
+    skillName: "",
+    total: 0,
+    assertions: 0,
+    expectations: 0,
+    levels: {},
+    flags: [],
+    attention: 0,
+    cases: [],
+    triggerProbes: { total: 0, shouldTrigger: 0, shouldNotTrigger: 0 },
+    baseline: { exists: false, path: baselinePath },
+    artifacts
+  };
+  let fileInfo;
+  try {
+    fileInfo = await stat3(evalsPath);
+  } catch {
+    return base;
+  }
+  const data = await readJson(evalsPath);
+  if (!isRecord(data)) {
+    return { ...base, ok: false, error: "evals.json \u65E0\u6CD5\u89E3\u6790", ...fileInfo ? { mtimeMs: fileInfo.mtimeMs } : {} };
+  }
+  const rawCases = Array.isArray(data.evals) ? data.evals : [];
+  const cases = rawCases.map(evalCaseView).filter((item) => item !== void 0);
+  const rawProbes = Array.isArray(data.trigger_probes) ? data.trigger_probes.filter(isRecord) : [];
+  const shouldTrigger = rawProbes.filter((probe) => probe.expect_trigger === true).length;
+  const triggerProbes = {
+    total: rawProbes.length,
+    shouldTrigger,
+    shouldNotTrigger: rawProbes.length - shouldTrigger
+  };
+  const levels = {};
+  for (const item of cases) levels[item.level] = (levels[item.level] ?? 0) + 1;
+  const flags = [...new Set(cases.flatMap((item) => item.flags))];
+  const attention = cases.filter((item) => item.flags.some((flag) => flag.startsWith("degraded:")) || item.assertions.length === 0).length;
+  const baselineInfo = await readJson(baselineMetaPath);
+  const coverageData = await readJson(coveragePath);
+  const scorecardData = await readJson(scorecardPath);
+  const benchmarkData = await readJson(benchmarkPath);
+  const coveragePoints = isRecord(coverageData) && Array.isArray(coverageData.points) ? coverageData.points : void 0;
+  const coverageItems = coveragePoints?.filter(isRecord).map((point) => ({
+    label: stringValue(point.label),
+    sourceQuote: stringValue(point.source_quote),
+    coveredBy: Array.isArray(point.covered_by) ? point.covered_by.filter((id) => typeof id === "number" && Number.isInteger(id)) : []
+  }));
+  const lastEval = isRecord(benchmarkData) ? (() => {
+    const metadata = isRecord(benchmarkData.metadata) ? benchmarkData.metadata : {};
+    const summary = isRecord(benchmarkData.run_summary) ? benchmarkData.run_summary : {};
+    const configurations = Object.entries(summary).filter(([name2, value]) => name2 !== "delta" && isRecord(value)).map(([name2, value]) => {
+      const row = value;
+      const passRate = isRecord(row.pass_rate) && typeof row.pass_rate.mean === "number" ? row.pass_rate.mean : null;
+      const tokens = isRecord(row.tokens) && typeof row.tokens.mean === "number" ? row.tokens.mean : null;
+      const durationSeconds = isRecord(row.time_seconds) && typeof row.time_seconds.mean === "number" ? row.time_seconds.mean : null;
+      return { name: name2, passRate, tokens, durationSeconds };
+    });
+    const comparisonRaw = isRecord(benchmarkData.comparison_summary) ? benchmarkData.comparison_summary : void 0;
+    const comparison = comparisonRaw ? {
+      labelA: stringValue(comparisonRaw.label_a) || "A",
+      labelB: stringValue(comparisonRaw.label_b) || "B",
+      valid: typeof comparisonRaw.valid === "number" ? comparisonRaw.valid : 0,
+      aWins: typeof comparisonRaw.a_wins === "number" ? comparisonRaw.a_wins : 0,
+      bWins: typeof comparisonRaw.b_wins === "number" ? comparisonRaw.b_wins : 0,
+      ties: typeof comparisonRaw.ties === "number" ? comparisonRaw.ties : 0,
+      winRate: typeof comparisonRaw.win_rate === "number" ? comparisonRaw.win_rate : null
+    } : void 0;
+    return {
+      ...stringValue(metadata.timestamp) ? { timestamp: stringValue(metadata.timestamp) } : {},
+      evalsCount: Array.isArray(metadata.evals_run) ? metadata.evals_run.length : 0,
+      ...typeof metadata.runs_per_configuration === "number" ? { runsPerConfiguration: metadata.runs_per_configuration } : {},
+      configurations,
+      ...comparison ? { comparison } : {}
+    };
+  })() : void 0;
+  const scorecard = isRecord(scorecardData) ? {
+    score: typeof scorecardData.score === "number" ? scorecardData.score : 0,
+    maxScore: typeof scorecardData.max_score === "number" ? scorecardData.max_score : 0,
+    category: stringValue(scorecardData.category),
+    checks: Array.isArray(scorecardData.checks) ? scorecardData.checks.filter(isRecord).map((check) => ({
+      name: stringValue(check.name),
+      passed: check.passed === true,
+      message: stringValue(check.message)
+    })) : []
+  } : void 0;
+  return {
+    ...base,
+    exists: true,
+    mtimeMs: fileInfo.mtimeMs,
+    skillName: stringValue(data.skill_name),
+    total: cases.length,
+    assertions: cases.reduce((sum, item) => sum + item.assertions.length, 0),
+    expectations: cases.reduce((sum, item) => sum + item.expectations.length, 0),
+    levels,
+    flags,
+    attention,
+    cases,
+    triggerProbes,
+    ...scorecard ? { scorecard } : {},
+    ...lastEval ? { lastEval } : {},
+    baseline: {
+      exists: await stat3(baselinePath).then(() => true).catch(() => false),
+      path: baselinePath,
+      ...isRecord(baselineInfo) && stringValue(baselineInfo.frozen_at) ? { frozenAt: stringValue(baselineInfo.frozen_at) } : {},
+      ...isRecord(baselineInfo) && stringValue(baselineInfo.target_skill_version) ? { skillVersion: stringValue(baselineInfo.target_skill_version) } : {}
+    },
+    ...coveragePoints ? {
+      coverage: {
+        exists: true,
+        path: coveragePath,
+        points: coverageItems?.length ?? 0,
+        gaps: coverageItems?.filter((point) => point.coveredBy.length === 0).length ?? 0,
+        items: coverageItems
+      }
+    } : {}
+  };
+}
+async function deleteEvalSuite(skillPath) {
+  const directory = skillDirectory(skillPath);
+  const evalsDir = path3.join(directory, "evals");
+  const candidates = [
+    "evals.json",
+    "baseline.json",
+    "baseline.meta.json",
+    "coverage-report.json",
+    "coverage-report.html"
+  ];
+  const deleted = [];
+  for (const name2 of candidates) {
+    const file = path3.join(evalsDir, name2);
+    try {
+      await stat3(file);
+      await rm(file, { force: true });
+      deleted.push(file);
+    } catch {
+    }
+  }
+  return { ok: true, deleted, evalsDir };
+}
+async function deleteEvalCase(skillPath, id) {
+  const directory = skillDirectory(skillPath);
+  const evalsPath = path3.join(directory, "evals", "evals.json");
+  const data = await readJson(evalsPath);
+  if (!isRecord(data) || !Array.isArray(data.evals)) {
+    return { ok: false, removed: 0, remaining: 0, error: "evals.json \u4E0D\u5B58\u5728\u6216\u65E0\u6CD5\u89E3\u6790" };
+  }
+  const before = data.evals.length;
+  const next = data.evals.filter((item) => !isRecord(item) || item.id !== id);
+  const removed = before - next.length;
+  if (removed === 0) return { ok: false, removed: 0, remaining: before, error: `\u627E\u4E0D\u5230\u9898\u76EE #${id}` };
+  const updated = { ...data, evals: next };
+  const temp = `${evalsPath}.${process.pid}.tmp`;
+  await writeFile2(temp, JSON.stringify(updated, null, 2), "utf8");
+  await rename2(temp, evalsPath);
+  return { ok: true, removed, remaining: next.length };
+}
+
+// src/host/endpoint.ts
+var SKILL_CATALOG_ENDPOINT_PATH = "/api/dsh-eval-ux/catalog";
+var MANUAL_PATHS_ENDPOINT_PATH = "/api/dsh-eval-ux/manual-paths";
+var OPERATIONS_ENDPOINT_PATH = "/api/dsh-eval-ux/operations";
+var OPERATIONS_STREAM_ENDPOINT_PATH = "/api/dsh-eval-ux/operations/stream";
+var EVAL_SUITE_ENDPOINT_PATH = "/api/dsh-eval-ux/eval-suite";
+var EVAL_CASE_ENDPOINT_PATH = "/api/dsh-eval-ux/eval-case";
+var RUN_HISTORY_ENDPOINT_PATH = "/api/dsh-eval-ux/run-history";
+var REPORT_ENDPOINT_PATH = "/api/dsh-eval-ux/report";
+function json(payload, status = 200) {
+  return new Response(JSON.stringify(payload), {
+    status,
+    headers: {
+      "content-type": "application/json; charset=utf-8",
+      "cache-control": "no-store",
+      "x-content-type-options": "nosniff"
+    }
+  });
+}
+function failure(error, warnings = []) {
+  return {
+    ok: false,
+    error: error instanceof Error ? error.message : String(error),
+    warnings,
+    system: [],
+    user: [],
+    manual: [],
+    manualPaths: [],
+    workspaces: [],
+    fetchedAt: Date.now()
+  };
+}
+async function handleSkillCatalogRequest(ctx, config, _request) {
+  try {
+    const payload = await buildSkillCatalog(ctx, config);
+    return json(payload, payload.ok ? 200 : 503);
+  } catch (error) {
+    return json(failure(error), 500);
+  }
+}
+async function handleManualPathsRequest(ctx, config, request) {
+  if (request.method !== "POST") return json(failure("\u53EA\u652F\u6301 POST"), 405);
+  try {
+    const body = await request.json();
+    if (typeof body.path !== "string") throw new Error("path \u5FC5\u987B\u662F\u5B57\u7B26\u4E32");
+    await addManualPath(body.path);
+    const payload = await buildSkillCatalog(ctx, config);
+    return json(payload, payload.ok ? 200 : 503);
+  } catch (error) {
+    return json(failure(error), 400);
+  }
+}
+async function handleReportRequest(request) {
+  const url = new URL(request.url);
+  const skillPath = url.searchParams.get("skillPath")?.trim();
+  if (!skillPath) return json({ ok: false, error: "skillPath \u5FC5\u586B" }, 400);
+  const suite = await readEvalSuite(skillPath);
+  if (!suite.artifacts.reportExists) return json({ ok: false, error: "report.html \u5C1A\u672A\u751F\u6210" }, 404);
+  try {
+    const html = await readFile4(suite.artifacts.reportPath, "utf8");
+    return new Response(html, {
+      status: 200,
+      headers: {
+        "content-type": "text/html; charset=utf-8",
+        "cache-control": "no-store",
+        "content-security-policy": "sandbox allow-scripts allow-downloads; default-src 'self' data: blob: 'unsafe-inline' 'unsafe-eval'",
+        "x-content-type-options": "nosniff"
+      }
+    });
+  } catch (error) {
+    return json({ ok: false, error: error instanceof Error ? error.message : String(error) }, 500);
+  }
+}
+function registerSkillCatalogEndpoints(ctx, config) {
+  if (typeof ctx.inject !== "function") return;
+  ctx.inject(["connection"], (connectionCtx) => {
+    const connection = connectionCtx.get("connection");
+    if (!connection?.fetch) return;
+    connectionCtx.effect?.(() => {
+      const registered = [
+        connection.fetch.register({
+          path: SKILL_CATALOG_ENDPOINT_PATH,
+          methods: ["GET"],
+          requestBody: "buffered",
+          fetch: (request) => handleSkillCatalogRequest(connectionCtx, config, request)
+        }),
+        connection.fetch.register({
+          path: MANUAL_PATHS_ENDPOINT_PATH,
+          methods: ["POST"],
+          requestBody: "buffered",
+          fetch: (request) => handleManualPathsRequest(connectionCtx, config, request)
+        }),
+        connection.fetch.register({
+          path: OPERATIONS_STREAM_ENDPOINT_PATH,
+          methods: ["POST"],
+          requestBody: "buffered",
+          fetch: (request) => handleOperationStreamRequest(connectionCtx, request)
+        }),
+        connection.fetch.register({
+          path: OPERATIONS_ENDPOINT_PATH,
+          methods: ["POST"],
+          requestBody: "buffered",
+          fetch: (request) => handleOperationRequest(connectionCtx, request)
+        }),
+        connection.fetch.register({
+          path: REPORT_ENDPOINT_PATH,
+          methods: ["GET"],
+          requestBody: "buffered",
+          fetch: (request) => handleReportRequest(request)
+        }),
+        connection.fetch.register({
+          path: RUN_HISTORY_ENDPOINT_PATH,
+          methods: ["GET", "DELETE"],
+          requestBody: "buffered",
+          fetch: (request) => handleRunHistoryRequest(request)
+        }),
+        connection.fetch.register({
+          path: EVAL_SUITE_ENDPOINT_PATH,
+          methods: ["GET", "DELETE"],
+          requestBody: "buffered",
+          fetch: (request) => handleEvalSuiteRequest(request)
+        }),
+        connection.fetch.register({
+          path: EVAL_CASE_ENDPOINT_PATH,
+          methods: ["DELETE"],
+          requestBody: "buffered",
+          fetch: (request) => handleEvalCaseRequest(request)
+        })
+      ];
+      return () => {
+        for (const route of registered) void route.then((dispose) => dispose());
+      };
+    }, "dsh-eval-ux: skill catalog endpoints");
+  });
+}
+function stringField(body, name2) {
+  const value = body[name2];
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function numberField(body, name2) {
+  const value = body[name2];
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : void 0;
+}
+function boolField(body, name2) {
+  return typeof body[name2] === "boolean" ? body[name2] : void 0;
+}
+function skillDirectory2(skillPath) {
+  return path4.basename(skillPath).toLowerCase().endsWith(".md") ? path4.dirname(skillPath) : skillPath;
+}
+function deriveEvalsPath(skillPath) {
+  return path4.join(skillDirectory2(skillPath), "evals", "evals.json");
+}
+function deriveBenchmarkPath(skillPath) {
+  return path4.join(skillDirectory2(skillPath), "evals", "benchmark.json");
+}
+function defaultRunOutput(skillPath) {
+  const home = process.env.DSH_HOME ?? path4.join(os3.homedir(), ".dsh");
+  const leaf = path4.basename(skillDirectory2(skillPath)).replace(/[^\p{L}\p{N}._-]+/gu, "-").replace(/^-+|-+$/g, "") || "skill";
+  return path4.join(home, "eval-runs", leaf, "run");
+}
+function preview(value, max = 1600) {
+  const text = typeof value === "string" ? value : JSON.stringify(value, null, 2);
+  if (typeof text !== "string") return "";
+  return text.length <= max ? text : `${text.slice(0, max)}
+\u2026`;
+}
+async function listRunDirs(outputDir) {
+  try {
+    const entries = await readdir2(outputDir, { withFileTypes: true });
+    const candidates = await Promise.all(entries.filter((entry) => entry.isDirectory() && entry.name.startsWith("run-")).map(async (entry) => {
+      const full = path4.join(outputDir, entry.name);
+      const info = await stat4(full).catch(() => void 0);
+      return info ? { full, mtimeMs: info.mtimeMs } : void 0;
+    }));
+    return candidates.filter((item) => item !== void 0).sort((a, b) => b.mtimeMs - a.mtimeMs);
+  } catch {
+    return [];
+  }
+}
+async function readRunArtifactSummary(output, preferredRunDir) {
+  const outputDir = path4.resolve(output);
+  const runDir = preferredRunDir ?? (await listRunDirs(outputDir))[0]?.full;
+  if (!runDir) return void 0;
+  const runInfo = await stat4(runDir).catch(() => void 0);
+  let debug = {};
+  try {
+    const value = JSON.parse(await readFile4(path4.join(runDir, "run_debug.json"), "utf8"));
+    if (value && typeof value === "object" && !Array.isArray(value)) debug = value;
+  } catch {
+  }
+  const transcriptPath = await stat4(path4.join(runDir, "transcript.jsonl")).then(() => path4.join(runDir, "transcript.jsonl")).catch(() => void 0);
+  const tools = [];
+  let sessionCwd;
+  if (transcriptPath) {
+    try {
+      const lines = (await readFile4(transcriptPath, "utf8")).split("\n");
+      const byId = /* @__PURE__ */ new Map();
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        let event;
+        try {
+          event = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        if (event.type === "session" && typeof event.cwd === "string") {
+          sessionCwd = event.cwd;
+          continue;
+        }
+        if (event.type === "tool_call") {
+          const id = typeof event.callId === "string" ? event.callId : `tool-${tools.length + 1}`;
+          const tool = {
+            id,
+            name: typeof event.tool === "string" ? event.tool : "tool",
+            status: "running",
+            input: preview(event.input),
+            result: ""
+          };
+          tools.push(tool);
+          byId.set(id, tool);
+        } else if (event.type === "tool_result") {
+          const id = typeof event.callId === "string" ? event.callId : "";
+          const tool = byId.get(id);
+          if (tool) {
+            tool.status = typeof event.status === "string" ? event.status : "completed";
+            tool.result = preview(event.result);
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  const rawToolCalls = debug.tool_calls && typeof debug.tool_calls === "object" && !Array.isArray(debug.tool_calls) ? Object.entries(debug.tool_calls).filter(([, count]) => typeof count === "number").map(([name2, count]) => ({ name: name2, count })) : [];
+  return {
+    runId: path4.basename(runDir),
+    ...runInfo ? { updatedAt: runInfo.mtimeMs } : {},
+    outputDir,
+    runDir,
+    ...transcriptPath ? { transcriptPath } : {},
+    ...sessionCwd ? { sessionCwd } : {},
+    ...typeof debug.executor === "string" ? { executor: debug.executor } : {},
+    ...typeof debug.task === "string" ? { task: debug.task } : {},
+    ...typeof debug.duration_ms === "number" ? { durationMs: debug.duration_ms } : {},
+    ...typeof debug.total_tokens === "number" ? { totalTokens: debug.total_tokens } : {},
+    ...typeof debug.num_turns === "number" ? { numTurns: debug.num_turns } : {},
+    ...typeof debug.stop_reason === "string" ? { stopReason: debug.stop_reason } : {},
+    ...typeof debug.result_text === "string" ? { resultText: debug.result_text } : {},
+    toolCalls: rawToolCalls,
+    tools
+  };
+}
+async function readRunHistory(skillPath) {
+  const skillRoot = path4.resolve(skillDirectory2(skillPath));
+  const managedOutput = defaultRunOutput(skillPath);
+  const legacyOutput = path4.resolve("output");
+  const candidates = [.../* @__PURE__ */ new Set([managedOutput, legacyOutput])];
+  const records = [];
+  for (const outputDir of candidates) {
+    const dirs = await listRunDirs(outputDir);
+    const found = (await Promise.all(dirs.map((dir) => readRunArtifactSummary(outputDir, dir.full)))).filter((record) => record !== void 0);
+    if (outputDir === managedOutput) {
+      records.push(...found.map((record) => ({
+        ...record,
+        source: "managed",
+        historyId: `managed:${record.runId ?? path4.basename(record.runDir ?? "run")}`
+      })));
+    } else {
+      records.push(...found.filter((record) => record.sessionCwd !== void 0 && path4.resolve(record.sessionCwd) === skillRoot).map((record) => ({
+        ...record,
+        source: "legacy",
+        historyId: `legacy:${record.runId ?? path4.basename(record.runDir ?? "run")}`
+      })));
+    }
+  }
+  return records.sort((a, b) => (b.updatedAt ?? 0) - (a.updatedAt ?? 0));
+}
+async function handleRunHistoryRequest(request) {
+  const url = new URL(request.url);
+  const skillPath = url.searchParams.get("skillPath")?.trim();
+  if (!skillPath) return json({ ok: false, error: "skillPath \u5FC5\u586B" }, 400);
+  const outputDir = defaultRunOutput(skillPath);
+  if (request.method === "GET") {
+    return json({ ok: true, skillPath, outputDir, records: await readRunHistory(skillPath) });
+  }
+  if (request.method !== "DELETE") return json({ ok: false, error: "\u53EA\u652F\u6301 GET / DELETE" }, 405);
+  const runId = url.searchParams.get("runId")?.trim();
+  const source = url.searchParams.get("source") === "legacy" ? "legacy" : "managed";
+  try {
+    if (runId) {
+      if (!/^run-[A-Za-z0-9._-]+$/.test(runId)) return json({ ok: false, error: "runId \u975E\u6CD5" }, 400);
+      const targetRoot = source === "legacy" ? path4.resolve("output") : outputDir;
+      await rm2(path4.join(targetRoot, runId), { recursive: true, force: true });
+    } else {
+      const legacyRecords = (await readRunHistory(skillPath)).filter((record) => record.source === "legacy" && record.runId);
+      await Promise.all([
+        rm2(outputDir, { recursive: true, force: true }),
+        ...legacyRecords.map((record) => rm2(path4.join(path4.resolve("output"), record.runId), { recursive: true, force: true }))
+      ]);
+    }
+    return json({ ok: true, skillPath, outputDir, records: await readRunHistory(skillPath) });
+  } catch (error) {
+    return json({ ok: false, error: error instanceof Error ? error.message : String(error) }, 500);
+  }
+}
+var activeOperations = /* @__PURE__ */ new Map();
+async function handleOperationStreamRequest(ctx, request) {
+  if (request.method !== "POST") return json({ ok: false, error: "\u53EA\u652F\u6301 POST" }, 405);
+  let body;
+  try {
+    const parsed = await request.json();
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("\u8BF7\u6C42\u4F53\u5FC5\u987B\u662F\u5BF9\u8C61");
+    body = parsed;
+  } catch (error) {
+    return json({ ok: false, error: error instanceof Error ? error.message : String(error) }, 400);
+  }
+  const action = typeof body.action === "string" ? body.action : "";
+  const skillPath = typeof body.skillPath === "string" ? body.skillPath.trim() : "";
+  if (!action || !skillPath) return json({ ok: false, error: "action \u548C skillPath \u5FC5\u586B" }, 400);
+  const operationKey = path4.resolve(skillPath);
+  if (activeOperations.has(operationKey)) {
+    return json({ ok: false, error: "\u8BE5 Skill \u5DF2\u6709\u64CD\u4F5C\u6B63\u5728\u8FD0\u884C\uFF0C\u8BF7\u7B49\u5F85\u5B8C\u6210\u6216\u5148\u53D6\u6D88" }, 409);
+  }
+  const controller = new AbortController();
+  activeOperations.set(operationKey, controller);
+  const encodedBody = JSON.stringify(body);
+  const encoder = new TextEncoder();
+  const stream = new ReadableStream({
+    start(streamController) {
+      let closed = false;
+      const send = (event) => {
+        if (closed) return;
+        try {
+          streamController.enqueue(encoder.encode(`${JSON.stringify(event)}
+`));
+        } catch {
+          closed = true;
+        }
+      };
+      void (async () => {
+        send({ type: "start", action, skillPath, startedAt: Date.now() });
+        try {
+          const response = await handleOperationRequest(ctx, new Request(request.url, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: encodedBody
+          }), {
+            signal: controller.signal,
+            onOutput: (streamName, chunk) => send({ type: "output", stream: streamName, text: chunk })
+          });
+          const payload = await response.json();
+          if (!response.ok || payload.ok === false) send({ type: "error", result: payload, error: String(payload.error ?? `HTTP ${response.status}`) });
+          else send({ type: "done", result: payload });
+        } catch (error) {
+          send({ type: "error", error: error instanceof Error ? error.message : String(error) });
+        } finally {
+          activeOperations.delete(operationKey);
+          closed = true;
+          try {
+            streamController.close();
+          } catch {
+          }
+        }
+      })();
+    },
+    cancel() {
+      controller.abort();
+      activeOperations.delete(operationKey);
+    }
+  });
+  return new Response(stream, {
+    status: 200,
+    headers: {
+      "content-type": "application/x-ndjson; charset=utf-8",
+      "cache-control": "no-store, no-transform",
+      "x-content-type-options": "nosniff"
+    }
+  });
+}
+async function handleOperationRequest(ctx, request, hooks) {
+  if (request.method !== "POST") return json(failure("\u53EA\u652F\u6301 POST"), 405);
+  try {
+    const body = await request.json();
+    const action = stringField(body, "action");
+    const skillPath = stringField(body, "skillPath");
+    if (!action || !skillPath) throw new Error("action \u548C skillPath \u5FC5\u586B");
+    const service = ctx.get("evalSuite");
+    if (!service) throw new Error("evalSuite \u670D\u52A1\u4E0D\u53EF\u7528\uFF0C\u8BF7\u5148\u5B89\u88C5 dsh-eval-suite");
+    const common = {
+      ...stringField(body, "cwd") ? { cwd: stringField(body, "cwd") } : {},
+      ...stringField(body, "model") ? { model: stringField(body, "model") } : {},
+      ...numberField(body, "timeoutMs") ? { timeoutMs: numberField(body, "timeoutMs") } : {},
+      ...hooks?.onOutput ? { onOutput: hooks.onOutput } : {},
+      ...hooks?.signal ? { signal: hooks.signal } : {}
+    };
+    let result;
+    let runOutputDir;
+    if (action === "init") {
+      result = await service.init({
+        skillPath,
+        ...common,
+        ...stringField(body, "output") ? { output: stringField(body, "output") } : {},
+        generatePrompts: boolField(body, "generatePrompts"),
+        numEvals: numberField(body, "numEvals"),
+        append: boolField(body, "append"),
+        fromTranscript: stringField(body, "fromTranscript"),
+        focus: stringField(body, "focus"),
+        triggerProbes: boolField(body, "triggerProbes"),
+        kind: stringField(body, "kind")
+      });
+    } else if (action === "add") {
+      result = await service.add({
+        skillPath,
+        ...common,
+        idea: stringField(body, "idea"),
+        prompt: stringField(body, "prompt"),
+        ...Array.isArray(body.expectation) ? { expectation: body.expectation.filter((item) => typeof item === "string") } : {},
+        level: stringField(body, "level"),
+        kind: stringField(body, "kind"),
+        dryRun: boolField(body, "dryRun")
+      });
+    } else if (action === "coverage") {
+      result = await service.coverage({
+        skillPath,
+        ...common,
+        output: stringField(body, "output"),
+        evalsPath: stringField(body, "evalsPath"),
+        augment: boolField(body, "augment"),
+        kind: stringField(body, "kind")
+      });
+    } else if (action === "inspect") {
+      result = await service.inspect({
+        evalsPath: stringField(body, "evalsPath") ?? deriveEvalsPath(skillPath),
+        ...common,
+        json: true
+      });
+    } else if (action === "freeze") {
+      result = await service.freeze({
+        evalsPath: stringField(body, "evalsPath") ?? deriveEvalsPath(skillPath),
+        ...common,
+        name: stringField(body, "name"),
+        output: stringField(body, "output"),
+        skillVersion: stringField(body, "skillVersion")
+      });
+    } else if (action === "eval") {
+      result = await service.evaluate({
+        skillPath,
+        ...common,
+        ...stringField(body, "executor") ? { executor: stringField(body, "executor") } : {},
+        evalsPath: stringField(body, "evalsPath") ?? deriveEvalsPath(skillPath),
+        skillB: stringField(body, "skillB"),
+        labelA: stringField(body, "labelA"),
+        labelB: stringField(body, "labelB"),
+        kind: stringField(body, "kind"),
+        runs: numberField(body, "runs"),
+        workers: numberField(body, "workers"),
+        timeoutSeconds: numberField(body, "timeoutSeconds"),
+        maxTurns: numberField(body, "maxTurns"),
+        maxRetries: numberField(body, "maxRetries"),
+        scoring: stringField(body, "scoring"),
+        compliance: boolField(body, "compliance"),
+        calibration: boolField(body, "calibration"),
+        securityGate: boolField(body, "securityGate"),
+        output: stringField(body, "output"),
+        format: stringField(body, "format"),
+        evalSamples: stringField(body, "evalSamples"),
+        evalIds: stringField(body, "evalIds"),
+        changedFrom: stringField(body, "changedFrom")
+      });
+    } else if (action === "trigger") {
+      result = await service.trigger({
+        skillPath,
+        ...common,
+        ...stringField(body, "executor") ? { executor: stringField(body, "executor") } : {},
+        evalsPath: stringField(body, "evalsPath") ?? deriveEvalsPath(skillPath),
+        output: stringField(body, "output"),
+        runs: numberField(body, "runs"),
+        timeoutSeconds: numberField(body, "timeoutSeconds"),
+        maxTurns: numberField(body, "maxTurns")
+      });
+    } else if (action === "run") {
+      const task = stringField(body, "task");
+      if (!task) throw new Error("run \u9700\u8981 task");
+      runOutputDir = stringField(body, "output") ?? defaultRunOutput(skillPath);
+      result = await service.execute({
+        skillPath,
+        task,
+        ...common,
+        cwd: stringField(body, "cwd"),
+        runs: numberField(body, "runs"),
+        timeoutSeconds: numberField(body, "timeoutSeconds"),
+        maxTurns: numberField(body, "maxTurns"),
+        executor: stringField(body, "executor"),
+        output: runOutputDir,
+        securityGate: boolField(body, "securityGate")
+      });
+    } else if (action === "gate") {
+      result = await service.gate({
+        benchmarkPath: stringField(body, "benchmarkPath") ?? deriveBenchmarkPath(skillPath),
+        ...common,
+        minWinRate: numberField(body, "minWinRate"),
+        minValid: numberField(body, "minValid"),
+        programmaticGuard: boolField(body, "programmaticGuard"),
+        candidate: stringField(body, "candidate"),
+        mustPass: stringField(body, "mustPass"),
+        baseline: stringField(body, "baseline"),
+        strictDrift: boolField(body, "strictDrift"),
+        output: stringField(body, "output")
+      });
+    } else if (action === "report") {
+      result = await service.report({
+        workspace: skillDirectory2(skillPath),
+        ...common,
+        benchmarkPath: stringField(body, "benchmarkPath"),
+        previousPath: stringField(body, "previousPath"),
+        scorecardPath: stringField(body, "scorecardPath")
+      });
+    } else {
+      throw new Error(`\u672A\u77E5 action: ${action}`);
+    }
+    if (runOutputDir) {
+      const runSummary = await readRunArtifactSummary(runOutputDir);
+      return json({ ...result && typeof result === "object" ? result : {}, ...runSummary ? { runSummary } : {} });
+    }
+    return json(result);
+  } catch (error) {
+    return json(failure(error), 400);
+  }
+}
+async function handleEvalSuiteRequest(request) {
+  const url = new URL(request.url);
+  const skillPath = url.searchParams.get("skillPath")?.trim();
+  if (!skillPath) return json({ ok: false, error: "skillPath \u5FC5\u586B", exists: false }, 400);
+  try {
+    if (request.method === "DELETE") return json(await deleteEvalSuite(skillPath));
+    return json(await readEvalSuite(skillPath));
+  } catch (error) {
+    return json({ ok: false, error: error instanceof Error ? error.message : String(error), exists: false }, 500);
+  }
+}
+async function handleEvalCaseRequest(request) {
+  if (request.method !== "DELETE") return json({ ok: false, error: "\u53EA\u652F\u6301 DELETE" }, 405);
+  const url = new URL(request.url);
+  const skillPath = url.searchParams.get("skillPath")?.trim();
+  const id = Number(url.searchParams.get("id"));
+  if (!skillPath || !Number.isInteger(id)) return json({ ok: false, error: "skillPath \u548C id \u5FC5\u586B" }, 400);
+  try {
+    return json(await deleteEvalCase(skillPath, id));
+  } catch (error) {
+    return json({ ok: false, error: error instanceof Error ? error.message : String(error) }, 500);
+  }
+}
+
+// src/index.ts
+var name = "dsh-eval-ux";
+var inject = [];
+function apply(ctx, config) {
+  const resolved = normalizeConfig(config);
+  registerSkillCatalogEndpoints(ctx, resolved);
+  process.stderr.write(`[dsh-eval-ux] ready \u2014 catalog enabled \xB7 manualPaths=${resolved.manualSkillPaths.length}
+`);
+}
+export {
+  EVAL_CASE_ENDPOINT_PATH,
+  EVAL_SUITE_ENDPOINT_PATH,
+  MANUAL_PATHS_ENDPOINT_PATH,
+  OPERATIONS_ENDPOINT_PATH,
+  OPERATIONS_STREAM_ENDPOINT_PATH,
+  REPORT_ENDPOINT_PATH,
+  RUN_HISTORY_ENDPOINT_PATH,
+  SKILL_CATALOG_ENDPOINT_PATH,
+  apply,
+  buildSkillCatalog,
+  defaultConfig,
+  deleteEvalCase,
+  deleteEvalSuite,
+  handleEvalCaseRequest,
+  handleEvalSuiteRequest,
+  handleManualPathsRequest,
+  handleOperationRequest,
+  handleOperationStreamRequest,
+  handleReportRequest,
+  handleRunHistoryRequest,
+  handleSkillCatalogRequest,
+  inject,
+  name,
+  normalizeConfig,
+  readEvalSuite,
+  registerSkillCatalogEndpoints
+};