ops-tune-workbench-plugin 0.0.0-stage → 0.0.1-beta.2

package/lib/host.js

@@ -0,0 +1,2518 @@
+// src/host/index.ts
+import { defineTool } from "@deepseek-ai/dsh-tools";
+
+// src/host/producerMetadata.ts
+import { createHash } from "node:crypto";
+import { createReadStream } from "node:fs";
+import { readFile, readdir, writeFile, stat, lstat } from "node:fs/promises";
+import { join } from "node:path";
+var metadataName = "cann-profiler-producer.json";
+var inputs = /* @__PURE__ */ new Set(["OpBasicInfo.csv", "PipeUtilization.csv", "ArithmeticUtilization.csv", "Memory.csv", "MemoryL0.csv", "MemoryUB.csv", "L2Cache.csv", "ResourceConflictRatio.csv", "visualize_data.bin", "trace.json", "PipeTrace.json"]);
+async function digests(directory) {
+  const files = {};
+  let total = 0;
+  for (const entry of (await readdir(directory, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name))) {
+    if (!inputs.has(entry.name)) continue;
+    if (!entry.isFile()) throw new Error("Producer input must be a regular file");
+    const path = join(directory, entry.name), size = (await stat(path)).size;
+    total += size;
+    if (size > 128 * 1024 * 1024 || total > 256 * 1024 * 1024) throw new Error("Producer input exceeds archive budget");
+    const hash = createHash("sha256");
+    for await (const chunk of createReadStream(path)) hash.update(chunk);
+    files[entry.name] = { bytes: size, sha256: hash.digest("hex") };
+  }
+  return files;
+}
+async function writeProducerMetadata(directory, version) {
+  if (!/^\d+\.\d+\.\d+$/.test(version)) throw new Error("Invalid profiler version");
+  const files = await digests(directory);
+  if (!Object.keys(files).length) return;
+  await writeFile(join(directory, metadataName), JSON.stringify({ schema: "cann-profiler-producer/1", tool: "msopprof", version, files }, null, 2) + "\n");
+}
+async function readProducerMetadata(directory) {
+  let contents;
+  try {
+    const info = await lstat(join(directory, metadataName));
+    if (!info.isFile() || info.size > 64 * 1024) throw new Error("Invalid profiler metadata file");
+    contents = await readFile(join(directory, metadataName), "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    throw error;
+  }
+  if (contents.length > 64 * 1024) throw new Error("Profiler metadata exceeds budget");
+  const value = JSON.parse(contents);
+  if (value.schema !== "cann-profiler-producer/1" || value.tool !== "msopprof" || typeof value.version !== "string" || !/^\d+\.\d+\.\d+$/.test(value.version)) throw new Error("Unsupported profiler metadata");
+  const actual = await digests(directory);
+  const expected = value.files;
+  if (!expected || typeof expected !== "object" || Array.isArray(expected) || !Object.keys(actual).length) throw new Error("Missing profiler input hashes");
+  if (Object.keys(actual).sort().join("\0") !== Object.keys(expected).sort().join("\0")) throw new Error("Profiler input set changed");
+  for (const [name2, file] of Object.entries(actual)) {
+    const stored = expected[name2];
+    if (!stored || stored.bytes !== file.bytes || stored.sha256 !== file.sha256) throw new Error("Profiler input hash mismatch");
+  }
+  return value.version;
+}
+
+// src/host/profilerCommand.ts
+import { dirname } from "node:path";
+function onboardInvocation(tool, output, metrics, target) {
+  return {
+    argv: tool.source === "msopprof" ? [tool.path, "--output", output, `--aic-metrics=${metrics.join(",")}`, target.exe, ...target.argv] : [tool.path, "op", "--output", output, `--aic-metrics=${metrics.join(",")}`, "--application", target.exe],
+    cwd: dirname(target.exe)
+  };
+}
+function captureMetrics(value, fallback) {
+  if (value === void 0) return fallback;
+  const verified = /* @__PURE__ */ new Set(["Default", "Roofline", "MemoryDetail", "Source", "PipeTimeline", "InstrTimeline", "Occupancy"]);
+  if (!Array.isArray(value) || value.length === 0 || !value.every((item) => typeof item === "string" && verified.has(item))) {
+    throw new Error("options.aic_metrics must select verified msopprof modes: " + [...verified].join(", "));
+  }
+  return [...new Set(value)];
+}
+
+// src/host/proc.ts
+async function spawn(ctx, input) {
+  const subprocess = ctx.get("subprocess");
+  if (subprocess !== void 0) {
+    const handle = subprocess.spawn({
+      argv: input.argv,
+      cwd: input.cwd,
+      stdio: { stdin: "ignore", stdout: { maxBytes: 16 * 1024 * 1024 }, stderr: { maxBytes: 4 * 1024 * 1024 } },
+      graceMs: 5e3,
+      signal: input.signal
+    });
+    const done = await handle.done;
+    return {
+      exitCode: done.exitCode,
+      stdout: handle.collected.stdout?.readFrom(0) ?? "",
+      stderr: handle.collected.stderr?.readFrom(0) ?? ""
+    };
+  }
+  const { spawn: nodeSpawn } = await import("node:child_process");
+  return await new Promise((resolve7, reject) => {
+    const child = nodeSpawn(input.argv[0], [...input.argv.slice(1)], { cwd: input.cwd, signal: input.signal });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString("utf8");
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString("utf8");
+    });
+    child.on("error", reject);
+    child.on("close", (exitCode) => resolve7({ exitCode, stdout, stderr }));
+  });
+}
+
+// src/host/report.ts
+import { copyFile, mkdir, readdir as readdir2, readFile as readFile2, stat as stat2 } from "node:fs/promises";
+import { basename, join as join2, relative, resolve } from "node:path";
+var SUMMARY_CATEGORY_MAX_FIELDS = 12;
+async function readCsv(path) {
+  const raw = await readFile2(path, "utf8");
+  return parseCsv(raw);
+}
+function parseCsv(raw) {
+  const text = raw.charCodeAt(0) === 65279 ? raw.slice(1) : raw;
+  const lines = text.split(/\r?\n/).filter((line) => line.length > 0);
+  if (lines.length === 0) return { headers: [], rows: [] };
+  const headers = splitCsvLine(lines[0]);
+  const rows = [];
+  for (const line of lines.slice(1)) {
+    const cells = splitCsvLine(line);
+    const row = {};
+    headers.forEach((h, i) => {
+      row[h] = cells[i] ?? "";
+    });
+    rows.push(row);
+  }
+  return { headers, rows };
+}
+function splitCsvLine(line) {
+  const cells = [];
+  let cur = "";
+  let inQuotes = false;
+  for (let i = 0; i < line.length; i++) {
+    const ch = line[i];
+    if (inQuotes) {
+      if (ch === '"') {
+        if (line[i + 1] === '"') {
+          cur += '"';
+          i++;
+        } else inQuotes = false;
+      } else cur += ch;
+    } else if (ch === '"') {
+      inQuotes = true;
+    } else if (ch === ",") {
+      cells.push(cur);
+      cur = "";
+    } else cur += ch;
+  }
+  cells.push(cur);
+  return cells;
+}
+function num(value) {
+  if (value === void 0 || value === null) return null;
+  const s = value.trim();
+  if (s === "" || s === "NA" || s === "N/A" || s === "null" || s === "NaN") return null;
+  const n = Number(s);
+  return Number.isFinite(n) ? n : null;
+}
+function pickColumn(headers, candidates) {
+  for (const c of candidates) if (headers.includes(c)) return c;
+  return null;
+}
+var PIPE_DEFS = [
+  {
+    id: "cube",
+    label: "Cube",
+    side: "cube",
+    ratioColumns: ["aic_cube_ratio", "aiv_cube_ratio", "CubeUtilization(%)", "cube_ratio", "CUBE(%)"],
+    timeColumns: ["aic_cube_time(us)", "aiv_cube_time(us)"]
+  },
+  {
+    id: "mte2",
+    label: "MTE2",
+    side: "cube",
+    ratioColumns: ["aic_mte2_ratio", "aiv_mte2_ratio", "ai_mte2_ratio", "Mte2Utilization(%)", "mte2_ratio", "MTE2(%)"],
+    timeColumns: ["aic_mte2_time(us)", "aiv_mte2_time(us)"]
+  },
+  {
+    id: "mte1",
+    label: "MTE1",
+    side: "cube",
+    ratioColumns: ["aic_mte1_ratio", "aiv_mte1_ratio", "Mte1Utilization(%)", "mte1_ratio", "MTE1(%)"],
+    timeColumns: ["aic_mte1_time(us)", "aiv_mte1_time(us)"]
+  },
+  {
+    id: "fixp",
+    label: "FixP",
+    side: "cube",
+    ratioColumns: ["aic_fixpipe_ratio", "aiv_fixpipe_ratio", "FixpipeUtilization(%)", "fixp_ratio", "FIXP(%)"],
+    timeColumns: ["aic_fixpipe_time(us)", "aiv_fixpipe_time(us)"]
+  },
+  {
+    id: "scalar",
+    label: "Scalar",
+    side: "cube",
+    ratioColumns: ["aic_scalar_ratio", "aiv_scalar_ratio", "ai_scalar_ratio", "ScalarUtilization(%)", "scalar_ratio", "SCALAR(%)"],
+    timeColumns: ["aic_scalar_time(us)", "aiv_scalar_time(us)"]
+  },
+  {
+    id: "icache",
+    label: "ICache Miss",
+    side: "cube",
+    ratioColumns: ["aic_icache_miss_rate", "ai_icache_miss_rate", "aiv_icache_miss_rate"],
+    timeColumns: []
+  },
+  {
+    id: "vector",
+    label: "Vector",
+    side: "vector",
+    ratioColumns: ["aiv_vec_ratio", "aic_vec_ratio", "VectorUtilization(%)", "vec_ratio", "VECTOR(%)"],
+    timeColumns: ["aiv_vec_time(us)", "aic_vec_time(us)"]
+  },
+  {
+    id: "mte2",
+    label: "MTE2",
+    side: "vector",
+    ratioColumns: ["aiv_mte2_ratio", "aic_mte2_ratio", "ai_mte2_ratio", "Mte2Utilization(%)", "mte2_ratio", "MTE2(%)"],
+    timeColumns: ["aiv_mte2_time(us)", "aic_mte2_time(us)"]
+  },
+  {
+    id: "mte3",
+    label: "MTE3",
+    side: "vector",
+    ratioColumns: ["aiv_mte3_ratio", "aic_mte3_ratio", "ai_mte3_ratio", "Mte3Utilization(%)", "mte3_ratio", "MTE3(%)"],
+    timeColumns: ["aiv_mte3_time(us)", "aic_mte3_time(us)"]
+  },
+  {
+    id: "scalar",
+    label: "Scalar",
+    side: "vector",
+    ratioColumns: ["aiv_scalar_ratio", "aic_scalar_ratio", "ai_scalar_ratio", "ScalarUtilization(%)", "scalar_ratio", "SCALAR(%)"],
+    timeColumns: ["aiv_scalar_time(us)", "aic_scalar_time(us)"]
+  },
+  {
+    id: "icache",
+    label: "ICache Miss",
+    side: "vector",
+    ratioColumns: ["aiv_icache_miss_rate", "ai_icache_miss_rate", "aic_icache_miss_rate"],
+    timeColumns: []
+  }
+];
+async function scanDir(dir) {
+  const shape = {
+    opSummaryPath: null,
+    opBasicInfoPath: null,
+    sections: /* @__PURE__ */ new Map(),
+    summaryJsonl: null,
+    hardwareJsonl: null,
+    pipeTrace: null
+  };
+  const SECTION_NAMES = [
+    "PipeUtilization",
+    "ArithmeticUtilization",
+    "ResourceConflictRatio",
+    "MemoryL0",
+    "L2Cache",
+    "Memory",
+    "MemoryUB",
+    "MemoryL1"
+  ];
+  const walk = async (d, depth) => {
+    let entries;
+    try {
+      entries = await readdir2(d, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      const p = join2(d, e.name);
+      if (e.isDirectory()) {
+        if (e.name === "mindstudio_profiler_output" && depth === 0) await walk(p, depth + 1);
+        continue;
+      }
+      if (e.name === "OpBasicInfo.csv" && shape.opBasicInfoPath === null) shape.opBasicInfoPath = p;
+      else if (/^op_summary_.*\.csv$/.test(e.name) && shape.opSummaryPath === null) shape.opSummaryPath = p;
+      else if (e.name === "Summary.jsonl" || e.name === "summary.jsonl") {
+        if (shape.summaryJsonl === null) shape.summaryJsonl = p;
+      } else if (e.name === "HardwareInfo.jsonl") {
+        if (shape.hardwareJsonl === null) shape.hardwareJsonl = p;
+      } else if (e.name === "PipeTrace.json") {
+        if (shape.pipeTrace === null) shape.pipeTrace = p;
+      } else {
+        const stem = e.name.replace(/\.csv$/i, "");
+        if (SECTION_NAMES.includes(stem) && !shape.sections.has(stem)) shape.sections.set(stem, p);
+      }
+    }
+  };
+  await walk(dir, 0);
+  return shape;
+}
+async function readJsonl(path) {
+  const raw = await readFile2(path, "utf8");
+  const out = [];
+  for (const line of raw.split(/\r?\n/)) {
+    const t = line.trim();
+    if (t === "") continue;
+    try {
+      out.push(JSON.parse(t));
+    } catch {
+    }
+  }
+  return out;
+}
+function asString(v) {
+  return typeof v === "string" && v !== "" ? v : null;
+}
+async function buildReportModel(input) {
+  const shape = await scanDir(input.dir);
+  const artifactDir = join2(input.archiveRoot, input.reportId);
+  await mkdir(artifactDir, { recursive: true });
+  const relPrefix = relative(process.cwd(), input.archiveRoot).split("\\").join("/");
+  const archiveRel = (name2) => `${relPrefix}/${input.reportId}/${name2}`;
+  let pipeTable = { headers: [], rows: [] };
+  const pipePath = shape.sections.get("PipeUtilization") ?? null;
+  if (pipePath !== null) pipeTable = await readCsv(pipePath);
+  const summaryJsonl = shape.summaryJsonl !== null ? await readJsonl(shape.summaryJsonl) : [];
+  const opInfoRows = summaryJsonl.filter((r) => r.category === "OpInfoSummary");
+  let summaryRow = null;
+  if (shape.opBasicInfoPath !== null) {
+    const basic = await readCsv(shape.opBasicInfoPath);
+    summaryRow = basic.rows[0] ?? null;
+  }
+  const opSummaryTable = shape.opSummaryPath !== null ? await readCsv(shape.opSummaryPath) : null;
+  const operators = [];
+  let selectedOperatorId = input.kernelName;
+  const isMsopprof = input.source === "msopprof-dir" || input.source === "msopprof";
+  const isMsprof = input.source === "msprof-dir" || input.source === "msprof";
+  const isNpuCompute = input.source === "npu-compute-dir" || input.source === "npu-compute";
+  const isSimulator = input.source === "simulator-dir" || input.source === "simulator";
+  if (isMsopprof) {
+    const name2 = summaryRow?.["Op Name"] ?? null;
+    if (name2 !== null && name2.trim() !== "") operators.push({ id: name2.trim(), label: name2.trim() });
+  } else if (isMsprof) {
+    if (opSummaryTable !== null && opSummaryTable.headers.includes("Op Name")) {
+      const seen = /* @__PURE__ */ new Set();
+      for (const row of opSummaryTable.rows) {
+        const n = (row["Op Name"] ?? "").trim();
+        if (n === "" || seen.has(n)) continue;
+        seen.add(n);
+        operators.push({ id: n, label: n });
+      }
+    }
+    if (input.kernelName === null) selectedOperatorId = null;
+  } else if (isNpuCompute) {
+    for (const r of opInfoRows) {
+      const n = asString(r["Op Name"]);
+      if (n === null) continue;
+      if (!operators.some((o) => o.id === n)) operators.push({ id: n, label: n });
+    }
+  } else if (isSimulator) {
+    for (const r of opInfoRows) {
+      const n = asString(r["Op Name"]);
+      if (n === null) continue;
+      if (!operators.some((o) => o.id === n)) operators.push({ id: n, label: n });
+    }
+    if (pipeTable.headers.includes("Op Name")) {
+      const seen = /* @__PURE__ */ new Set();
+      for (const row of pipeTable.rows) {
+        const n = (row["Op Name"] ?? "").trim();
+        if (n === "" || seen.has(n)) continue;
+        seen.add(n);
+        operators.push({ id: n, label: n });
+      }
+    }
+  }
+  if (operators.length === 0 && summaryRow?.["Op Name"] != null && summaryRow["Op Name"] !== "") {
+    operators.push({ id: summaryRow["Op Name"], label: summaryRow["Op Name"] });
+  }
+  if (operators.length === 1 && selectedOperatorId === null) selectedOperatorId = operators[0].id;
+  let pipeRows = pipeTable.rows;
+  if (input.kernelName !== null && pipeTable.headers.includes("Op Name")) {
+    pipeRows = pipeTable.rows.filter((r) => (r["Op Name"] ?? "").trim() === input.kernelName);
+  }
+  const opInfo = opInfoRows[0] ?? null;
+  const strOr = (v, fallback) => typeof v === "string" && v !== "" ? v : fallback;
+  const summary = {
+    op_name: strOr(opInfo?.["Op Name"], summaryRow?.["Op Name"]?.trim() || null),
+    op_type: strOr(opInfo?.["Op Type"], summaryRow?.["Op Type"]?.trim() || null),
+    task_duration_us: num(summaryRow?.["Task Duration(us)"]) ?? (typeof opInfo?.["Task Duration(us)"] === "number" ? opInfo["Task Duration(us)"] : null),
+    block_dim: num(summaryRow?.["Block Dim"]) ?? (typeof opInfo?.["Block Dim"] === "number" ? opInfo["Block Dim"] : null),
+    pid: strOr(opInfo?.["Pid"], summaryRow?.["Pid"]?.trim() || summaryRow?.["PID"]?.trim() || null),
+    current_freq: num(summaryRow?.["Current Freq"]) ?? (typeof opInfo?.["Current Freq"] === "number" ? opInfo["Current Freq"] : null),
+    rated_freq: num(summaryRow?.["Rated Freq"]) ?? (typeof opInfo?.["Rated Freq"] === "number" ? opInfo["Rated Freq"] : null),
+    core_count: null,
+    aic_flops: typeof opInfo?.aic_flops === "number" ? opInfo.aic_flops : null,
+    aiv_flops: typeof opInfo?.aiv_flops === "number" ? opInfo.aiv_flops : null,
+    aic_flops_theoretical: typeof opInfo?.aic_flops_theoretical === "number" ? opInfo.aic_flops_theoretical : null,
+    aiv_flops_theoretical: typeof opInfo?.aiv_flops_theoretical === "number" ? opInfo.aiv_flops_theoretical : null,
+    gm_bw_theoretical_gbs: typeof opInfo?.["aicore_gm_bw_theoretical(GB/s)"] === "number" ? opInfo["aicore_gm_bw_theoretical(GB/s)"] : null,
+    gm_read_bw: typeof opInfo?.["aicore_gm_read_bw(GB/s)"] === "number" ? opInfo["aicore_gm_read_bw(GB/s)"] : null,
+    gm_write_bw: typeof opInfo?.["aicore_gm_write_bw(GB/s)"] === "number" ? opInfo["aicore_gm_write_bw(GB/s)"] : null,
+    gm_bw_usage_rate: typeof opInfo?.["aicore_gm_bw_usage_rate(%)"] === "number" ? opInfo["aicore_gm_bw_usage_rate(%)"] : null,
+    parallel_utilization: typeof opInfo?.aicore_parallel_utilization === "number" ? opInfo.aicore_parallel_utilization : null,
+    parallel_balance: typeof opInfo?.aicore_parallel_balance === "number" ? opInfo.aicore_parallel_balance : null
+  };
+  if (summary.task_duration_us === null && opSummaryTable !== null && opSummaryTable.rows.length > 0) {
+    const row = input.kernelName !== null ? opSummaryTable.rows.find((r) => (r["Op Name"] ?? "").trim() === input.kernelName) ?? opSummaryTable.rows[0] : opSummaryTable.rows[0];
+    summary.op_name = summary.op_name ?? ((row["Op Name"] ?? "").trim() || null);
+    summary.op_type = summary.op_type ?? ((row["OP Type"] ?? row["Op Type"] ?? "").trim() || null);
+    summary.task_duration_us = num(row["Task Duration(us)"]);
+    summary.block_dim = summary.block_dim ?? num(row["Block Num"]) ?? num(row["Block Dim"]);
+  }
+  const hardwareSections = [];
+  if (shape.hardwareJsonl !== null) {
+    const hwRows = await readJsonl(shape.hardwareJsonl);
+    for (const row of hwRows) {
+      const cat = asString(row.category) ?? "Info";
+      const fields = [];
+      for (const [k, v] of Object.entries(row)) {
+        if (k === "category") continue;
+        fields.push({ key: k, value: v === null || v === void 0 ? "N/A" : String(v) });
+      }
+      hardwareSections.push({ id: cat, title: cat, fields });
+    }
+    const aiCore = hwRows.find((r) => r.category === "AI Core Information");
+    const cubeCount = typeof aiCore?.ai_cube_count === "number" ? aiCore.ai_cube_count : null;
+    const vectorCount = typeof aiCore?.ai_vector_count === "number" ? aiCore.ai_vector_count : null;
+    const coreCount = typeof aiCore?.ai_core_count === "number" ? aiCore.ai_core_count : null;
+    const opType = (summary.op_type ?? "").toLowerCase();
+    if (opType.includes("cube") || opType.includes("matrix")) summary.core_count = cubeCount ?? coreCount;
+    else if (opType.includes("vector")) summary.core_count = vectorCount ?? coreCount;
+    else summary.core_count = coreCount;
+  } else if (summaryRow !== null) {
+    hardwareSections.push({
+      id: "basic",
+      title: "OpBasicInfo",
+      fields: Object.entries(summaryRow).filter(([, v]) => v !== "").map(([key, value]) => ({ key, value }))
+    });
+  }
+  const pipeOccupancy = [];
+  for (const def of PIPE_DEFS) {
+    const ratioCol = pickColumn(pipeTable.headers, def.ratioColumns);
+    const timeCol = pickColumn(pipeTable.headers, def.timeColumns);
+    let ratio = null;
+    let absolute = null;
+    if (ratioCol !== null) {
+      const vals = pipeRows.map((r) => num(r[ratioCol])).filter((v) => v !== null);
+      ratio = vals.length > 0 ? vals.reduce((a, b) => a + b, 0) / vals.length : null;
+    }
+    if (timeCol !== null) {
+      const vals = pipeRows.map((r) => num(r[timeCol])).filter((v) => v !== null);
+      absolute = vals.length > 0 ? vals.reduce((a, b) => a + b, 0) / vals.length : null;
+    }
+    pipeOccupancy.push({
+      id: def.id,
+      label: def.label,
+      side: def.side,
+      ratio,
+      absolute_value: absolute,
+      columns: ratioCol !== null ? [ratioCol] : [],
+      time_columns: timeCol !== null ? [timeCol] : []
+    });
+  }
+  const tableIndex = [];
+  const TABLE_GROUPS = [
+    { name: "PipeUtilization", display: "PipeUtilization", group: "compute", missing: "PipeUtilization.csv \u672A\u91C7\u96C6" },
+    { name: "ArithmeticUtilization", display: "ArithmeticUtilization", group: "compute", missing: "ArithmeticUtilization.csv \u672A\u91C7\u96C6" },
+    { name: "ResourceConflictRatio", display: "ResourceConflictRatio", group: "compute", missing: "ResourceConflictRatio.csv \u672A\u91C7\u96C6" },
+    { name: "MemoryL0", display: "MemoryL0", group: "memory", missing: "MemoryL0.csv \u672A\u91C7\u96C6" },
+    { name: "L2Cache", display: "L2Cache", group: "memory", missing: "L2Cache.csv \u672A\u91C7\u96C6" },
+    { name: "Memory", display: "MemoryL1", group: "memory", missing: "Memory.csv \u672A\u91C7\u96C6" },
+    // Memory.csv displays as MemoryL1 (PARITY-MAP §5.4)
+    { name: "MemoryUB", display: "MemoryUB", group: "memory", missing: "MemoryUB.csv \u672A\u91C7\u96C6" }
+  ];
+  for (const t of TABLE_GROUPS) {
+    const src = shape.sections.get(t.name);
+    if (src === void 0) {
+      tableIndex.push({
+        file_name: `${t.name}.csv`,
+        display: t.display,
+        group: t.group,
+        header_count: 0,
+        block_ids: [],
+        row_count: 0,
+        rel_path: null,
+        bytes: 0,
+        missing_reason: t.missing
+      });
+      continue;
+    }
+    const dest = join2(artifactDir, `${t.name}.csv`);
+    await copyFile(src, dest);
+    const table = t.name === "PipeUtilization" && pipeTable.headers.length > 0 ? { headers: pipeTable.headers, rows: pipeRows } : await readCsv(src);
+    const info = await stat2(dest);
+    const blockIds = Array.from(new Set(
+      table.rows.map((r) => (r.block_id ?? "").trim()).filter((b) => b !== "")
+    ));
+    tableIndex.push({
+      file_name: `${t.name}.csv`,
+      display: t.display,
+      group: t.group,
+      header_count: table.headers.length,
+      block_ids: blockIds,
+      row_count: table.rows.length,
+      rel_path: archiveRel(`${t.name}.csv`),
+      bytes: info.size
+    });
+  }
+  const jsonlArchived = [];
+  for (const [name2, src] of [
+    ["Summary.jsonl", shape.summaryJsonl],
+    ["HardwareInfo.jsonl", shape.hardwareJsonl]
+  ]) {
+    if (src === null) continue;
+    await copyFile(src, join2(artifactDir, name2));
+    jsonlArchived.push(name2);
+  }
+  if (shape.opSummaryPath !== null) {
+    const name2 = basename(shape.opSummaryPath);
+    await copyFile(shape.opSummaryPath, join2(artifactDir, name2));
+    jsonlArchived.push(name2);
+  }
+  const arithPath = shape.sections.get("ArithmeticUtilization");
+  const arithTable = arithPath !== void 0 ? await readCsv(arithPath) : { headers: [], rows: [] };
+  const arithRows = input.kernelName !== null && arithTable.headers.includes("Op Name") ? arithTable.rows.filter((r) => (r["Op Name"] ?? "").trim() === input.kernelName) : arithTable.rows;
+  const computeSides = [];
+  {
+    const fopsCol = pickColumn(arithTable.headers, ["aic_cube_fops", "aic_flops"]);
+    const timeCol = pickColumn(arithTable.headers, ["aic_time(us)"]);
+    let measured = null;
+    if (fopsCol !== null) {
+      const vals = arithRows.map((r) => num(r[fopsCol])).filter((v) => v !== null);
+      const means = vals.length > 0 ? vals.reduce((a, b) => a + b, 0) / vals.length : null;
+      measured = means;
+    }
+    computeSides.push({
+      side: "aic",
+      measured_tflops: measured !== null && measured > 0 ? measured / 1e12 : typeof summary.aic_flops === "number" && summary.aic_flops > 0 ? summary.aic_flops / 1e12 : null,
+      peak_tflops: typeof summary.aic_flops_theoretical === "number" && summary.aic_flops_theoretical > 0 ? summary.aic_flops_theoretical / 1e12 : null
+    });
+  }
+  {
+    const fopsCol = pickColumn(arithTable.headers, ["aiv_vec_fops", "aiv_flops"]);
+    const timeCol = pickColumn(arithTable.headers, ["aiv_time(us)"]);
+    let measured = null;
+    if (fopsCol !== null) {
+      const vals = arithRows.map((r) => num(r[fopsCol])).filter((v) => v !== null);
+      measured = vals.length > 0 ? vals.reduce((a, b) => a + b, 0) / vals.length : null;
+    }
+    computeSides.push({
+      side: "aiv",
+      measured_tflops: measured !== null && measured > 0 ? measured / 1e12 : typeof summary.aiv_flops === "number" && summary.aiv_flops > 0 ? summary.aiv_flops / 1e12 : null,
+      peak_tflops: typeof summary.aiv_flops_theoretical === "number" && summary.aiv_flops_theoretical > 0 ? summary.aiv_flops_theoretical / 1e12 : null
+    });
+  }
+  void computeSides;
+  const memPath = shape.sections.get("Memory");
+  const memTable = memPath !== void 0 ? await readCsv(memPath) : { headers: [], rows: [] };
+  const memRows = input.kernelName !== null && memTable.headers.includes("Op Name") ? memTable.rows.filter((r) => (r["Op Name"] ?? "").trim() === input.kernelName) : memTable.rows;
+  const bwPeakFromMem = 1600;
+  const gmPeak = summary.gm_bw_theoretical_gbs ?? bwPeakFromMem;
+  const maxOf = (col) => {
+    if (col === null) return null;
+    const vals = memRows.map((r) => num(r[col])).filter((v) => v !== null);
+    return vals.length > 0 ? Math.max(...vals) : null;
+  };
+  const readCols = ["aic_main_mem_read_bw(GB/s)", "aiv_main_mem_read_bw(GB/s)"];
+  const writeCols = ["aic_main_mem_write_bw(GB/s)", "aiv_main_mem_write_bw(GB/s)"];
+  const readMeasured = Math.max(...readCols.map((c) => maxOf(pickColumn(memTable.headers, [c])) ?? 0)) || null;
+  const writeMeasured = Math.max(...writeCols.map((c) => maxOf(pickColumn(memTable.headers, [c])) ?? 0)) || null;
+  const bandwidthCards = [
+    {
+      id: "input",
+      sides: ["aic", "aiv"].map((side) => ({
+        side,
+        measured_gbs: maxOf(pickColumn(memTable.headers, [`${side}_main_mem_read_bw(GB/s)`])),
+        peak_gbs: gmPeak
+      }))
+    },
+    {
+      id: "output",
+      sides: ["aic", "aiv"].map((side) => ({
+        side,
+        measured_gbs: maxOf(pickColumn(memTable.headers, [`${side}_main_mem_write_bw(GB/s)`])),
+        peak_gbs: gmPeak
+      }))
+    }
+  ];
+  void readMeasured;
+  void writeMeasured;
+  const roofMix = [];
+  const mixDefs = [
+    { id: "vec_fp32", label: "Vec_FP32", cols: ["aiv_vec_fp32_ratio"] },
+    { id: "vec_fp16", label: "Vec_FP16", cols: ["aiv_vec_fp16_ratio", "aiv_vec_fp_ratio"] },
+    { id: "vec_int32", label: "Vec_INT32", cols: ["aiv_vec_int32_ratio"] },
+    { id: "vec_int16", label: "Vec_INT16", cols: ["aiv_vec_int16_ratio"] },
+    { id: "vec_misc", label: "Vec_MISC", cols: ["aiv_vec_misc_ratio"] },
+    { id: "cube_fp16", label: "Cube_FP16", cols: ["aic_cube_fp16_ratio", "aic_cube_fp_ratio"] },
+    { id: "cube_int8", label: "Cube_INT8", cols: ["aic_cube_int8_ratio", "aic_cube_int_ratio"] }
+  ];
+  for (const m of mixDefs) {
+    const col = pickColumn(arithTable.headers, m.cols);
+    if (col === null) continue;
+    const vals = arithRows.map((r) => num(r[col])).filter((v) => v !== null);
+    if (vals.length === 0) continue;
+    const mean = vals.reduce((a, b) => a + b, 0) / vals.length;
+    roofMix.push({ id: m.id, label: m.label, percent: mean <= 1.5 ? mean * 100 : mean });
+  }
+  let roofPerformance = null;
+  let roofIntensity = null;
+  {
+    const fopsCol = pickColumn(arithTable.headers, ["aiv_vec_fops", "aic_cube_fops"]);
+    const timeCol = pickColumn(arithTable.headers, ["aiv_time(us)", "aic_time(us)"]);
+    if (fopsCol !== null && timeCol !== null) {
+      const fopsVals = arithRows.map((r) => num(r[fopsCol])).filter((v) => v !== null);
+      const timeVals = arithRows.map((r) => num(r[timeCol])).filter((v) => v !== null);
+      if (fopsVals.length > 0 && timeVals.length > 0) {
+        const fops = fopsVals.reduce((a, b) => a + b, 0) / fopsVals.length;
+        const time = timeVals.reduce((a, b) => a + b, 0) / timeVals.length;
+        if (fops > 0 && time > 0) roofPerformance = fops / time / 1e6;
+        const readCol = pickColumn(memTable.headers, ["read_main_memory_datas(KB)"]);
+        const writeCol = pickColumn(memTable.headers, ["write_main_memory_datas(KB)"]);
+        if (readCol !== null || writeCol !== null) {
+          const kb = (readCol !== null ? memRows.map((r) => num(r[readCol])) : memRows.map(() => null)).map((v, i) => {
+            const w = writeCol !== null ? num(memRows[i][writeCol]) : null;
+            return (v ?? 0) + (w ?? 0);
+          }).filter((v) => v !== null && v > 0);
+          if (kb.length > 0) {
+            const kbMean = kb.reduce((a, b) => a + b, 0) / kb.length;
+            if (kbMean > 0) roofIntensity = fops / (kbMean * 1024);
+          }
+        }
+      }
+    }
+    if (roofPerformance === null && typeof summary.aiv_flops === "number" && summary.aiv_flops > 0 && summary.task_duration_us !== null) {
+      roofPerformance = summary.aiv_flops / summary.task_duration_us / 1e6;
+    }
+    if (roofPerformance === null && typeof summary.aic_flops === "number" && summary.aic_flops > 0 && summary.task_duration_us !== null) {
+      roofPerformance = summary.aic_flops / summary.task_duration_us / 1e6;
+    }
+  }
+  const roofline = {
+    points: [{
+      id: "gm",
+      label: "GM Read + Write",
+      intensity: roofIntensity,
+      performance: roofPerformance,
+      style: "solid"
+    }],
+    mix_labels: roofMix,
+    peak_compute_tops: 1,
+    // asc-toolkit self-normalized scale (Vt = 1)
+    peak_bandwidth_gbs: gmPeak
+  };
+  const l2Table = shape.sections.get("L2Cache") !== void 0 ? await readCsv(shape.sections.get("L2Cache")) : { headers: [], rows: [] };
+  const l2Rows = input.kernelName !== null && l2Table.headers.includes("Op Name") ? l2Table.rows.filter((r) => (r["Op Name"] ?? "").trim() === input.kernelName) : l2Table.rows;
+  const l0Table = shape.sections.get("MemoryL0") !== void 0 ? await readCsv(shape.sections.get("MemoryL0")) : { headers: [], rows: [] };
+  const l0Rows = input.kernelName !== null && l0Table.headers.includes("Op Name") ? l0Table.rows.filter((r) => (r["Op Name"] ?? "").trim() === input.kernelName) : l0Table.rows;
+  const ubTable = shape.sections.get("MemoryUB") !== void 0 ? await readCsv(shape.sections.get("MemoryUB")) : { headers: [], rows: [] };
+  const ubRows = input.kernelName !== null && ubTable.headers.includes("Op Name") ? ubTable.rows.filter((r) => (r["Op Name"] ?? "").trim() === input.kernelName) : ubTable.rows;
+  const maxFrom = (table, rows, candidates) => {
+    const col = pickColumn(table.headers, candidates);
+    if (col === null) return null;
+    const vals = rows.map((r) => num(r[col])).filter((v) => v !== null);
+    return vals.length > 0 ? Math.max(...vals) : null;
+  };
+  const edge = (id, from, to, unit, sourceFiles, value) => ({
+    id,
+    from,
+    to,
+    unit,
+    source_files: sourceFiles,
+    label: value === null ? null : `${value.toFixed(2)} ${unit}`
+  });
+  const allEdges = [
+    edge(
+      "gm-l2-read",
+      "gm",
+      "l2",
+      "GB/s",
+      ["Memory.csv"],
+      Math.max(
+        maxFrom(memTable, memRows, ["aic_main_mem_read_bw(GB/s)"]) ?? 0,
+        maxFrom(memTable, memRows, ["aiv_main_mem_read_bw(GB/s)"]) ?? 0
+      ) || null
+    ),
+    edge(
+      "gm-l2-write",
+      "gm",
+      "l2",
+      "GB/s",
+      ["Memory.csv"],
+      Math.max(
+        maxFrom(memTable, memRows, ["aic_main_mem_write_bw(GB/s)"]) ?? 0,
+        maxFrom(memTable, memRows, ["aiv_main_mem_write_bw(GB/s)"]) ?? 0
+      ) || null
+    ),
+    edge(
+      "l2-l1-read",
+      "l2",
+      "l1",
+      "GB/s",
+      ["Memory.csv"],
+      maxFrom(memTable, memRows, ["aic_l1_read_bw(GB/s)"])
+    ),
+    edge(
+      "l2-l1-write",
+      "l2",
+      "l1",
+      "GB/s",
+      ["Memory.csv"],
+      maxFrom(memTable, memRows, ["aic_l1_write_bw(GB/s)"])
+    ),
+    edge(
+      "l1-l0a",
+      "l1",
+      "l0a",
+      "GB/s",
+      ["MemoryL0.csv"],
+      maxFrom(l0Table, l0Rows, ["aic_l0a_read_bw(GB/s)"])
+    ),
+    edge(
+      "l1-l0b",
+      "l1",
+      "l0b",
+      "GB/s",
+      ["MemoryL0.csv"],
+      maxFrom(l0Table, l0Rows, ["aic_l0b_read_bw(GB/s)"])
+    ),
+    edge(
+      "l0a-cube",
+      "l0a",
+      "cube",
+      "GB/s",
+      ["MemoryL0.csv"],
+      maxFrom(l0Table, l0Rows, ["aic_l0a_write_bw(GB/s)"])
+    ),
+    edge(
+      "l0b-cube",
+      "l0b",
+      "cube",
+      "GB/s",
+      ["MemoryL0.csv"],
+      maxFrom(l0Table, l0Rows, ["aic_l0b_write_bw(GB/s)"])
+    ),
+    edge(
+      "l0c-cube",
+      "l0c",
+      "cube",
+      "GB/s",
+      ["MemoryL0.csv"],
+      maxFrom(l0Table, l0Rows, ["aic_l0c_read_bw_cube(GB/s)"])
+    ),
+    edge(
+      "cube-l0c",
+      "cube",
+      "l0c",
+      "GB/s",
+      ["MemoryL0.csv"],
+      maxFrom(l0Table, l0Rows, ["aic_l0c_write_bw_cube(GB/s)"])
+    ),
+    edge(
+      "l0c-l1",
+      "l0c",
+      "l1",
+      "KB",
+      ["Memory.csv"],
+      (() => {
+        const col = pickColumn(memTable.headers, ["L0C_to_L1_datas(KB)"]);
+        if (col === null) return null;
+        const vals = memRows.map((r) => num(r[col])).filter((v) => v !== null);
+        return vals.length > 0 ? Math.max(...vals) : null;
+      })()
+    ),
+    edge(
+      "l0c-l2",
+      "l0c",
+      "l2",
+      "KB",
+      ["Memory.csv"],
+      (() => {
+        const col = pickColumn(memTable.headers, ["L0C_to_GM_datas(KB)"]);
+        if (col === null) return null;
+        const vals = memRows.map((r) => num(r[col])).filter((v) => v !== null);
+        return vals.length > 0 ? Math.max(...vals) : null;
+      })()
+    ),
+    edge(
+      "ub-l2",
+      "ub",
+      "l2",
+      "GB/s",
+      ["MemoryUB.csv"],
+      maxFrom(ubTable, ubRows, ["aiv_ub_to_gm_bw(GB/s)", "aiv_ub_write_bw_gm(GB/s)"])
+    ),
+    edge(
+      "l2-ub",
+      "l2",
+      "ub",
+      "GB/s",
+      ["MemoryUB.csv"],
+      maxFrom(ubTable, ubRows, ["aiv_gm_to_ub_bw(GB/s)", "aiv_ub_read_bw_gm(GB/s)"])
+    ),
+    edge(
+      "vec-ub",
+      "vec",
+      "ub",
+      "GB/s",
+      ["MemoryUB.csv"],
+      maxFrom(ubTable, ubRows, ["aiv_ub_write_bw_vector(GB/s)"])
+    ),
+    edge(
+      "ub-vec",
+      "ub",
+      "vec",
+      "GB/s",
+      ["MemoryUB.csv"],
+      maxFrom(ubTable, ubRows, ["aiv_ub_read_bw_vector(GB/s)"])
+    )
+  ];
+  {
+    const hitCol = pickColumn(l2Table.headers, ["aic_total_hit_rate(%)", "aiv_total_hit_rate(%)"]);
+    if (hitCol !== null) {
+      const vals = l2Rows.map((r) => num(r[hitCol])).filter((v2) => v2 !== null);
+      const v = vals.length > 0 ? vals.reduce((a, b) => a + b, 0) / vals.length : null;
+      allEdges.push({
+        id: "l2-hit",
+        from: "l2",
+        to: "l2-data",
+        unit: "%",
+        source_files: ["L2Cache.csv"],
+        label: v === null ? null : `${v.toFixed(2)} %`
+      });
+    }
+  }
+  const firstBlockId = pipeRows.find((r) => (r.block_id ?? "").trim() !== "")?.block_id?.trim() ?? "0";
+  const edges = allEdges.filter((e) => e.label !== null);
+  const memory_topology = { block_id: firstBlockId, edges };
+  const summaryCategories = [];
+  for (const row of summaryJsonl) {
+    const cat = asString(row.category);
+    if (cat === null || cat === "OpInfoSummary") continue;
+    const fields = [];
+    for (const [k, v] of Object.entries(row)) {
+      if (k === "category") continue;
+      fields.push({ key: k, value: v === null || v === void 0 ? "N/A" : String(v) });
+    }
+    const existing = summaryCategories.find((c) => c.id === cat);
+    if (existing !== void 0) existing.fields.push(...fields);
+    else summaryCategories.push({ id: cat, title: cat, fields });
+  }
+  for (const c of summaryCategories) {
+    if (c.fields.length > SUMMARY_CATEGORY_MAX_FIELDS) {
+      c.fields = c.fields.slice(0, SUMMARY_CATEGORY_MAX_FIELDS);
+    }
+  }
+  let pipeTrace = {
+    time_unit: "us",
+    nest_card_tree: false,
+    event_count: 0,
+    min_time_ns: null,
+    max_time_ns: null,
+    rel_path: null,
+    bytes: 0,
+    missing_reason: "\u65E0\u65F6\u95F4\u7EBF\u4E8B\u4EF6\uFF08PipeTrace.json \u672A\u91C7\u96C6\uFF09"
+  };
+  if (shape.pipeTrace !== null) {
+    const dest = join2(artifactDir, "PipeTrace.json");
+    await copyFile(shape.pipeTrace, dest);
+    const info = await stat2(dest);
+    let eventCount = 0;
+    let minTs = null;
+    let maxEnd = null;
+    let timeUnit = "us";
+    try {
+      const parsed = JSON.parse(await readFile2(dest, "utf8"));
+      if (parsed.displayTimeUnit === "ns") timeUnit = "ns";
+      const nest = parsed.otherData?.nestCardTree === true;
+      for (const ev of parsed.traceEvents ?? []) {
+        eventCount += 1;
+        if (typeof ev.ts === "number") {
+          if (minTs === null || ev.ts < minTs) minTs = ev.ts;
+          const end = ev.ts + (typeof ev.dur === "number" ? ev.dur : 0);
+          if (maxEnd === null || end > maxEnd) maxEnd = end;
+        }
+      }
+      pipeTrace = {
+        time_unit: timeUnit,
+        nest_card_tree: nest,
+        event_count: eventCount,
+        min_time_ns: minTs,
+        max_time_ns: maxEnd,
+        rel_path: archiveRel("PipeTrace.json"),
+        bytes: info.size
+      };
+    } catch {
+      pipeTrace = {
+        time_unit: "us",
+        nest_card_tree: false,
+        event_count: 0,
+        min_time_ns: null,
+        max_time_ns: null,
+        rel_path: archiveRel("PipeTrace.json"),
+        bytes: info.size,
+        missing_reason: "PipeTrace.json \u89E3\u6790\u5931\u8D25\uFF08\u4FDD\u7559\u5F52\u6863\u539F\u6587\u4F9B\u5BA2\u6237\u7AEF\u5206\u9875\u62C9\u53D6\uFF09"
+      };
+    }
+  }
+  const capabilities = [];
+  if (pipeTrace.event_count > 0) capabilities.push("dependencies");
+  if (roofline.points[0]?.performance !== null || roofline.mix_labels.length > 0) capabilities.push("roofline");
+  if (hardwareSections.length > 0) capabilities.push("hardwareDetails");
+  if (memory_topology.edges.length > 0) capabilities.push("memoryDiagram");
+  const model = {
+    report_id: input.reportId,
+    run_id: input.runId,
+    source: input.source,
+    kind: input.kind,
+    mode: input.mode,
+    soc: input.soc,
+    label: input.label,
+    collected_at: (/* @__PURE__ */ new Date()).toISOString(),
+    artifact_dir: artifactDir,
+    operators,
+    selected_operator_id: selectedOperatorId,
+    kernel_name: input.kernelName,
+    summary,
+    pipe_occupancy: pipeOccupancy,
+    compute_card: { sides: computeSides },
+    bandwidth_cards: bandwidthCards,
+    roofline,
+    memory_topology,
+    table_index: tableIndex,
+    summary_categories: summaryCategories,
+    hardware_details: { sections: hardwareSections },
+    pipe_trace: pipeTrace,
+    capabilities,
+    verdict: null,
+    comparison: null
+  };
+  return model;
+}
+function summarizeVerdict(full, verdictScript, relPath) {
+  const findings = Array.isArray(full.findings) ? full.findings : [];
+  const skipped = Array.isArray(full.skipped) ? full.skipped : [];
+  const recommended = Array.isArray(full.recommended_next) ? full.recommended_next.map(String) : [];
+  return {
+    schema: typeof full.schema === "string" ? full.schema : void 0,
+    engine: "ops-verdict",
+    verdict_script: verdictScript,
+    verdict: typeof full.verdict === "string" ? full.verdict : void 0,
+    headline: typeof full.headline === "string" ? full.headline : void 0,
+    generated_at: typeof full.generated_at === "string" ? full.generated_at : void 0,
+    soc: typeof full.soc === "string" ? full.soc : void 0,
+    findings_count: findings.length,
+    findings: findings.map((f) => ({
+      rule_id: String(f.rule_id ?? ""),
+      ...f.severity !== void 0 ? { severity: String(f.severity) } : {},
+      ...f.confidence !== void 0 ? { confidence: String(f.confidence) } : {},
+      ...f.name !== void 0 ? { name: String(f.name) } : {}
+    })),
+    skipped_count: skipped.length,
+    recommended_next: recommended,
+    rel_path: relPath
+  };
+}
+async function buildResultChildren(artifactDir) {
+  const children = [];
+  let entries;
+  try {
+    entries = await readdir2(artifactDir, { withFileTypes: true });
+  } catch {
+    return children;
+  }
+  const TYPE_MAP = {
+    csv: "csv",
+    bin: "bin",
+    json: "json",
+    rep: "rep",
+    ncrep: "ncrep",
+    "npu-rep": "npu-rep"
+  };
+  for (const e of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+    const ext = e.name.includes(".") ? e.name.slice(e.name.lastIndexOf(".") + 1).toLowerCase() : "";
+    if (!(ext in TYPE_MAP)) continue;
+    children.push({ title: e.name, file_path: join2(artifactDir, e.name), file_type: TYPE_MAP[ext] });
+  }
+  return children;
+}
+
+// src/host/collect.ts
+var reportSeq = { n: 0 };
+function pad(n, width) {
+  return String(n).padStart(width, "0");
+}
+function newIds() {
+  const stamp = /* @__PURE__ */ new Date();
+  const reportId = `r${stamp.getFullYear()}${pad(stamp.getMonth() + 1, 2)}${pad(stamp.getDate(), 2)}-${pad(stamp.getHours(), 2)}${pad(stamp.getMinutes(), 2)}${pad(stamp.getSeconds(), 2)}-${pad(++reportSeq.n, 2)}`;
+  const runId = `run-${reportId}`;
+  return { reportId, runId };
+}
+function collectionConfigAsOptions(doc) {
+  const cfg = doc?.collection_config;
+  if (cfg === void 0 || cfg === null || typeof cfg !== "object") return void 0;
+  return cfg;
+}
+function effectiveOptions(inputOptions, stateConfig) {
+  const merged = { ...stateConfig ?? {} };
+  for (const [key, value] of Object.entries(inputOptions ?? {})) {
+    if (value === void 0 || value === null) continue;
+    const existing = merged[key];
+    if (typeof value === "object" && value !== null && !Array.isArray(value) && typeof existing === "object" && existing !== null && !Array.isArray(existing)) {
+      merged[key] = { ...existing, ...value };
+    } else {
+      merged[key] = value;
+    }
+  }
+  return merged;
+}
+function onboardOptionsToAicMetrics(onboard, isA5) {
+  const metrics = /* @__PURE__ */ new Set(["Occupancy", "KernelScale", "Default"]);
+  if (onboard?.roofline === true) metrics.add("Roofline");
+  if (isA5) {
+    if (onboard?.pcSampling === true) metrics.add("PCSampling");
+  } else if (onboard?.cacheHeatmap === true) {
+    metrics.add("PCSampling");
+  }
+  if (onboard?.operatorCodeHotspot === true) metrics.add("Source");
+  if (onboard?.operatorMetrics === true || onboard?.interCoreLoad === true) {
+    metrics.add("MemoryDetail");
+    if (onboard?.l2CacheHitRate === true || onboard?.resourceConflictRatio === true) metrics.add("ResourceConflict");
+  }
+  return [...metrics];
+}
+function newToolMetricsToSections(newTool) {
+  const SETS = {
+    basic: ["PipeUtilization", "L2Cache", "Memory"],
+    full: ["PipeUtilization", "L2Cache", "Memory", "MemoryL0", "MemoryUB"],
+    Custom: ["PipeUtilization", "L2Cache", "Memory"]
+  };
+  const metrics = newTool?.metrics;
+  if (metrics === void 0) return SETS.full;
+  if (metrics.kind === "section" && Array.isArray(metrics.sections) && metrics.sections.length > 0) {
+    return [.../* @__PURE__ */ new Set(["Pipeline", "ArithmeticUtilization", "ResourceConflictRatio", ...metrics.sections])];
+  }
+  const set = typeof metrics.set === "string" ? metrics.set : "full";
+  return SETS[set] ?? SETS.full;
+}
+async function npuAvailable(ctx, signal) {
+  try {
+    const { readdir: readdir3 } = await import("node:fs/promises");
+    const devs = await readdir3("/dev");
+    if (devs.some((d) => d.startsWith("davinci"))) return true;
+  } catch {
+  }
+  const npuSmi = await which(ctx, "npu-smi");
+  if (npuSmi !== null) {
+    try {
+      const out = await spawn(ctx, { argv: [npuSmi, "info"], cwd: process.cwd(), signal });
+      if (out.exitCode === 0) return true;
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+async function which(ctx, bin) {
+  const { access } = await import("node:fs/promises");
+  const candidates = [];
+  const toolkitHome = process.env.ASCEND_TOOLKIT_HOME ?? process.env.ASC_HOME ?? "";
+  if (toolkitHome !== "") candidates.push(`${toolkitHome}/bin/${bin}`);
+  const pathEnv = process.env.PATH ?? "";
+  for (const dir of pathEnv.split(":").filter((d) => d !== "")) candidates.push(`${dir}/${bin}`);
+  candidates.push(`/usr/local/sbin/${bin}`, `/usr/local/bin/${bin}`, `/usr/bin/${bin}`, `/bin/${bin}`);
+  for (const c of candidates) {
+    try {
+      await access(c);
+      return c;
+    } catch {
+    }
+  }
+  void ctx;
+  return null;
+}
+async function assertBlockArtifacts(dir) {
+  let listing = [];
+  try {
+    const { readdir: readdir3 } = await import("node:fs/promises");
+    const walk = async (d, depth) => {
+      let entries;
+      try {
+        entries = await readdir3(d, { withFileTypes: true });
+      } catch {
+        return;
+      }
+      for (const e of entries) {
+        const p = `${d}/${e.name}`;
+        if (e.isDirectory()) {
+          if (depth < 2) await walk(p, depth + 1);
+        } else listing.push(p);
+      }
+    };
+    await walk(dir, 0);
+    listing = listing.map((p) => p.slice(dir.length + 1));
+  } catch {
+    return { reason: `\u4EA7\u7269\u76EE\u5F55\u4E0D\u53EF\u8BFB: ${dir}`, dirListing: [] };
+  }
+  const findCsv = (pattern) => {
+    const hit = listing.find((p) => pattern.test(p.split("/").pop() ?? ""));
+    return hit === void 0 ? null : `${dir}/${hit}`;
+  };
+  const candidates = [
+    findCsv(/^op_summary_.*\.csv$/),
+    findCsv(/^PipeUtilization\.csv$/),
+    findCsv(/^OpBasicInfo\.csv$/),
+    findCsv(/^summary\.db$/)
+  ];
+  const primary = candidates.find((c) => c !== null) ?? null;
+  if (primary === null) {
+    return {
+      reason: "\u4EA7\u7269\u7F3A\u5931\uFF1A\u65E0 op_summary_*.csv / PipeUtilization.csv / OpBasicInfo.csv / summary.db\uFF08\u5BF9\u9F50 collect_board.sh assert_block_artifacts\uFF09",
+      dirListing: listing
+    };
+  }
+  if (primary.endsWith(".db")) return null;
+  try {
+    const { readFile: readFile6 } = await import("node:fs/promises");
+    const raw = await readFile6(primary, "utf8");
+    const lines = raw.split(/\r?\n/).filter((l) => l.trim() !== "");
+    if (lines.length < 2) {
+      return { reason: `\u4EA7\u7269\u7A7A\uFF08${primary} ${String(lines.length)} \u884C < 2\uFF1A\u8868\u5934+\u6570\u636E\uFF09`, dirListing: listing };
+    }
+    if (!raw.includes("Task Duration")) {
+      const hasBasic = listing.some((p) => p.endsWith("OpBasicInfo.csv"));
+      if (!hasBasic) {
+        return { reason: "Task Duration \u5217\u7F3A\u5931\u4E14\u65E0 OpBasicInfo.csv\uFF08verdict/isolation \u4E3B\u6D88\u8D39\u5B57\u6BB5\uFF09", dirListing: listing };
+      }
+    }
+  } catch (error) {
+    return { reason: `\u4EA7\u7269\u8BFB\u53D6\u5931\u8D25: ${String(error)}`, dirListing: listing };
+  }
+  return null;
+}
+async function resolveTool(config, configured, bins) {
+  if (configured !== "") {
+    try {
+      const { access } = await import("node:fs/promises");
+      await access(configured);
+      return configured;
+    } catch {
+      return null;
+    }
+  }
+  for (const bin of bins) {
+    const found = await which(null, bin);
+    if (found !== null) return found;
+  }
+  return null;
+}
+async function resolveTargetExecutable(caseDir) {
+  const { stat: stat4, readdir: readdir3 } = await import("node:fs/promises");
+  const { join: join7, resolve: resolve7 } = await import("node:path");
+  const dir = resolve7(process.cwd(), caseDir);
+  try {
+    const info = await stat4(dir);
+    if (info.isFile()) return { exe: dir, argv: [] };
+  } catch {
+  }
+  try {
+    const entries = await readdir3(dir, { withFileTypes: true });
+    const candidates = ["main", "demo", "run", "app", "kernel_harness", "timing_harness"].map((n) => entries.find((e) => e.isFile() && e.name === n)).filter((e) => e !== void 0);
+    if (candidates.length > 0) return { exe: join7(dir, candidates[0].name), argv: [] };
+    const executables = entries.filter((e) => e.isFile());
+    if (executables.length === 1) return { exe: join7(dir, executables[0].name), argv: [] };
+  } catch {
+  }
+  return { exe: dir, argv: [] };
+}
+async function realCollect(ctx, config, input, exec, tool, reportId, runId, workbenchRoot, options) {
+  const timeoutMs = config.collectTimeoutMs > 0 ? config.collectTimeoutMs : 6e5;
+  const controller = new AbortController();
+  const timer = setTimeout(() => {
+    controller.abort(new Error(`ops_collect timeout after ${String(timeoutMs)}ms`));
+  }, timeoutMs);
+  const onCallerAbort = () => {
+    controller.abort(exec.signal.reason);
+  };
+  if (exec.signal.aborted) controller.abort(exec.signal.reason);
+  else exec.signal.addEventListener("abort", onCallerAbort, { once: true });
+  try {
+    const outDir = `${workbenchRoot}/collect/${runId}`;
+    const { mkdir: mkdir3 } = await import("node:fs/promises");
+    await mkdir3(outDir, { recursive: true });
+    let producedDir = outDir;
+    const profilingDiagnostics = [];
+    if (tool.source === "msopprof" || tool.source === "msprof") {
+      const isA5 = input.soc === "a5";
+      const metrics = captureMetrics(options.aic_metrics, onboardOptionsToAicMetrics(options.onboard, isA5));
+      const target = await resolveTargetExecutable(input.case_dir);
+      const invocation = onboardInvocation({ source: tool.source, path: tool.path }, outDir, metrics, target);
+      const out = await spawn(ctx, { ...invocation, signal: controller.signal });
+      profilingDiagnostics.push(...(out.stdout + "\n" + out.stderr).split("\n").filter((line) => /data loss|Failed to parse pc|Hot spot function|Generate hot spot/.test(line)));
+      if (tool.source === "msopprof" && out.exitCode === 0) {
+        const { readdir: readdir3 } = await import("node:fs/promises");
+        const directories = (await readdir3(outDir, { withFileTypes: true })).filter((entry) => entry.isDirectory() && entry.name.startsWith("OPPROF_"));
+        if (directories.length !== 1) throw new Error("msopprof must produce one unambiguous capture directory for this run");
+        producedDir = `${outDir}/${directories[0].name}`;
+      }
+      if (out.exitCode !== 0) {
+        throw new Error(`${tool.path} \u9000\u51FA\u7801 ${String(out.exitCode)}\uFF1A${out.stderr.slice(0, 2e3)}`);
+      }
+    } else if (tool.source === "npu-compute") {
+      const sections = newToolMetricsToSections(options.new_tool);
+      const setArg = options.new_tool?.metrics?.kind === "section" ? void 0 : options.new_tool?.metrics?.set ?? config.defaultSet;
+      const target = await resolveTargetExecutable(input.case_dir);
+      const argv = [tool.path];
+      if (setArg !== void 0) argv.push("--set", setArg);
+      for (const s of sections) argv.push("--section", s);
+      if (options.new_tool?.common?.force_overwrite === true) argv.push("--force");
+      argv.push("--export", `${outDir}/report.npu-rep`, "--", target.exe);
+      const out = await spawn(ctx, { argv, cwd: process.cwd(), signal: controller.signal });
+      if (out.exitCode !== 0 || !await fileExists(`${outDir}/report.npu-rep`)) {
+        throw new Error(`npu-compute \u91C7\u96C6\u5931\u8D25\uFF08exit ${String(out.exitCode)}\uFF09\uFF1A${out.stderr.slice(0, 2e3)}`);
+      }
+      const imp = await spawn(ctx, {
+        argv: [tool.path, "--import", `${outDir}/report.npu-rep`, "--export", `${outDir}/unpacked`],
+        cwd: process.cwd(),
+        signal: controller.signal
+      });
+      const m = /unpacked=\s*(\S+)/.exec(imp.stdout + imp.stderr);
+      producedDir = m?.[1] ?? `${outDir}/unpacked`;
+    } else if (tool.source === "npusim") {
+      const target = await resolveTargetExecutable(input.case_dir);
+      const out = await spawn(ctx, {
+        argv: [tool.path, "record", target.exe, "-o", outDir, "-g"],
+        cwd: process.cwd(),
+        signal: controller.signal
+      });
+      if (out.exitCode !== 0) throw new Error(`npusim \u9000\u51FA\u7801 ${String(out.exitCode)}\uFF1A${out.stderr.slice(0, 2e3)}`);
+    }
+    const failure = await assertBlockArtifacts(producedDir);
+    if (failure !== null) {
+      throw new Error(
+        `\u4EA7\u7269\u65AD\u8A00\u672A\u8FC7\uFF1A${failure.reason}
+\u4EA7\u7269\u76EE\u5F55\u6E05\u5355\uFF08${producedDir}\uFF09\uFF1A${failure.dirListing.slice(0, 30).join(", ")}`
+      );
+    }
+    const archiveRoot = `${workbenchRoot}/reports`;
+    const report = await buildReportModel({
+      dir: producedDir,
+      reportId,
+      runId,
+      source: tool.source,
+      kind: "collection",
+      mode: input.mode ?? "onboard",
+      soc: input.soc ?? null,
+      label: input.label,
+      kernelName: null,
+      archiveRoot
+    });
+    const result = await makeResultEntry(report, producedDir);
+    const versionResult = tool.source === "msopprof" ? await spawn(ctx, { argv: [tool.path, "--version"], cwd: process.cwd(), signal: controller.signal }) : void 0;
+    const producerVersion = versionResult?.exitCode === 0 ? /msopprof\s+(\d+\.\d+\.\d+)/.exec(versionResult.stdout)?.[1] : void 0;
+    if (producerVersion) {
+      try {
+        await writeProducerMetadata(producedDir, producerVersion);
+      } catch {
+        profilingDiagnostics.push("Portable profiler provenance could not be written; the raw collection is retained.");
+      }
+    }
+    return {
+      report,
+      result,
+      raw_artifact_dir: producedDir,
+      producer_version: producerVersion,
+      profiling_diagnostics: profilingDiagnostics,
+      metrics_preview: buildMetricsPreview(report),
+      effective_options: options,
+      files_found: (await scanDir(producedDir)).sections.size > 0 ? Array.from((await scanDir(producedDir)).sections.keys()) : []
+    };
+  } finally {
+    clearTimeout(timer);
+    exec.signal.removeEventListener("abort", onCallerAbort);
+  }
+}
+async function fileExists(path) {
+  try {
+    const { stat: stat4 } = await import("node:fs/promises");
+    await stat4(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function buildMetricsPreview(report) {
+  const pipes = {};
+  for (const p of report.pipe_occupancy) {
+    const key = p.side === "cube" ? `aic_${p.id}_ratio` : `aiv_${p.id}_ratio`;
+    if (!(key in pipes)) pipes[key] = p.ratio;
+  }
+  return {
+    task_duration_us: report.summary.task_duration_us,
+    block_dim: report.summary.block_dim,
+    aicore_parallel_utilization: report.summary.parallel_utilization,
+    aicore_parallel_balance: report.summary.parallel_balance,
+    gm_bw_usage_rate: report.summary.gm_bw_usage_rate,
+    pipe_ratios: pipes
+  };
+}
+async function makeResultEntry(report, producedDir) {
+  const children = await buildResultChildren(report.artifact_dir);
+  const nested = await collectTree(producedDir, "dump");
+  return {
+    report_id: report.report_id,
+    title: report.summary.op_name ?? producedDir.split("/").at(-1) ?? report.report_id,
+    timestamp: report.collected_at,
+    marked: false,
+    source: report.source,
+    kind: report.kind,
+    dir_path: report.artifact_dir,
+    children: [...children, ...nested]
+  };
+}
+async function collectTree(dir, sub) {
+  const out = [];
+  try {
+    const { readdir: readdir3, stat: stat4 } = await import("node:fs/promises");
+    const subDir = `${dir}/${sub}`;
+    const info = await stat4(subDir).catch(() => null);
+    if (info === null || !info.isDirectory()) return out;
+    const entries = await readdir3(subDir, { withFileTypes: true });
+    const TYPE_MAP = {
+      csv: "csv",
+      bin: "bin",
+      json: "json",
+      rep: "rep",
+      ncrep: "ncrep",
+      "npu-rep": "npu-rep"
+    };
+    const kids = [];
+    for (const e of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+      if (!e.isFile()) continue;
+      const ext = e.name.includes(".") ? e.name.slice(e.name.lastIndexOf(".") + 1).toLowerCase() : "";
+      if (!(ext in TYPE_MAP)) continue;
+      kids.push({ title: e.name, file_path: `${subDir}/${e.name}`, file_type: TYPE_MAP[ext] });
+    }
+    if (kids.length > 0) out.push({ title: sub, file_path: subDir, file_type: "bin", children: kids });
+  } catch {
+  }
+  return out;
+}
+var stateDoc;
+function bindStateDoc(doc) {
+  stateDoc = doc;
+}
+async function collect(ctx, config, input, exec) {
+  const mode = input.mode ?? "onboard";
+  const workbenchRoot = await workbenchDirOf(config);
+  const { reportId, runId } = newIds();
+  const stateOptions = collectionConfigAsOptions(stateDoc);
+  const options = effectiveOptions(input.options, stateOptions);
+  if (mode === "simulate") {
+    const npusim = await resolveTool(config, config.npusimPath, ["npusim", "cannsim"]);
+    if (npusim !== null) {
+      return await realCollect(ctx, config, input, exec, { path: npusim, source: "npusim" }, reportId, runId, workbenchRoot, options);
+    }
+    throw new Error("ops_collect: npusim/cannsim \u4E0D\u53EF\u7528\uFF0C\u672A\u6267\u884C\u771F\u5B9E\u4EFF\u771F\uFF0C\u4E5F\u672A\u751F\u6210\u6F14\u793A\u6027\u80FD\u6570\u636E\u3002");
+  }
+  if (mode === "npu-compute") {
+    if (!await npuAvailable(ctx, exec.signal)) {
+      throw new Error(
+        'ops_collect: mode="npu-compute" \u9700\u8981 NPU \u786C\u4EF6\uFF0C\u4F46\u672C\u673A\u672A\u68C0\u6D4B\u5230 NPU\uFF08/dev/davinci* \u4E0E npu-smi \u5747\u4E0D\u53EF\u7528\uFF09\u3002\u8BF7\u5728\u5177\u5907 NPU \u548C\u91C7\u96C6\u5DE5\u5177\u7684\u73AF\u5883\u8FD0\u884C\uFF0C\u6216\u5BFC\u5165\u5DF2\u6709\u771F\u5B9E\u4EA7\u7269\u3002'
+      );
+    }
+    const path = await resolveTool(config, config.npuComputePath, ["npu-compute"]);
+    if (path === null) throw new Error("ops_collect: npu-compute \u5DE5\u5177\u4E0D\u53EF\u7528\uFF08npuComputePath \u672A\u914D\u7F6E\u4E14 PATH/ASCEND_TOOLKIT_HOME \u672A\u627E\u5230\uFF09\u3002");
+    return await realCollect(ctx, config, input, exec, { path, source: "npu-compute" }, reportId, runId, workbenchRoot, options);
+  }
+  if (!await npuAvailable(ctx, exec.signal)) {
+    throw new Error("ops_collect: NPU \u786C\u4EF6\u4E0D\u53EF\u7528\uFF0C\u672A\u6267\u884C\u6027\u80FD\u91C7\u96C6\uFF0C\u4E5F\u672A\u751F\u6210\u6F14\u793A\u6027\u80FD\u6570\u636E\u3002");
+  }
+  const npuCompute = await resolveTool(config, config.npuComputePath, ["npu-compute"]);
+  if (npuCompute !== null) {
+    return await realCollect(ctx, config, input, exec, { path: npuCompute, source: "npu-compute" }, reportId, runId, workbenchRoot, options);
+  }
+  const msopprof = await resolveTool(config, config.msopprofPath, ["msopprof"]);
+  if (msopprof !== null) {
+    return await realCollect(ctx, config, input, exec, { path: msopprof, source: "msopprof" }, reportId, runId, workbenchRoot, options);
+  }
+  const msprof = await resolveTool(config, config.msprofPath, ["msprof"]);
+  if (msprof !== null) {
+    return await realCollect(ctx, config, input, exec, { path: msprof, source: "msprof" }, reportId, runId, workbenchRoot, options);
+  }
+  throw new Error("ops_collect: \u672A\u627E\u5230\u771F\u5B9E\u6027\u80FD\u91C7\u96C6\u5DE5\u5177\uFF0C\u672A\u751F\u6210\u6027\u80FD\u6570\u636E\u3002");
+}
+async function workbenchDirOf(config) {
+  const base = config.workbenchDir === "" ? ".ops-tune-workbench" : config.workbenchDir;
+  const { resolve: resolve7 } = await import("node:path");
+  return resolve7(process.cwd(), base);
+}
+function defaultCollectionConfig(soc) {
+  return {
+    collection_type: "onboard",
+    onboard: {
+      interCoreLoad: true,
+      roofline: true,
+      operatorCodeHotspot: true,
+      cacheHeatmap: true,
+      pcSampling: false,
+      operatorMetrics: true,
+      cubeAndVectorInstructionTimeAndRatio: true,
+      l2CacheHitRate: true,
+      memoryReadWriteBandwidth: true,
+      l0ReadWriteBandwidth: true,
+      ubReadWriteBandwidth: true,
+      computeAndMoveUnitTimeAndRatio: true,
+      resourceConflictRatio: true
+    },
+    simulator: { memoryThroughputWaveform: false, resourceConflictRatio: true },
+    new_tool: {
+      common: { output_file: "", force_overwrite: false, command_line: "" },
+      metrics: { kind: "set", set: "basic", sections: ["PipeUtilization", "L2Cache", "Memory"] }
+    },
+    soc
+  };
+}
+function applyCollectionConfigToState(doc, soc, options) {
+  if (options !== void 0 && options !== null && typeof options === "object") {
+    doc.collection_config = options;
+    return;
+  }
+  if (doc.collection_config === void 0) {
+    doc.collection_config = defaultCollectionConfig(soc ?? "auto");
+  }
+}
+
+// src/host/import.ts
+async function importDirectory(ctx, config, input) {
+  const { resolve: resolve7 } = await import("node:path");
+  const dir = resolve7(process.cwd(), input.dir);
+  const shape = await scanDir(dir);
+  const exists = await dirExists(dir);
+  if (!exists) {
+    throw new Error(`ops_import: \u4EA7\u7269\u76EE\u5F55\u4E0D\u5B58\u5728\uFF1A${dir}`);
+  }
+  const filesFound = [];
+  if (shape.opBasicInfoPath !== null) filesFound.push("OpBasicInfo.csv");
+  if (shape.opSummaryPath !== null) filesFound.push(shape.opSummaryPath.split("/").pop());
+  for (const [name2, path] of shape.sections) {
+    if (path.startsWith(dir)) filesFound.push(path.slice(dir.length + 1));
+    else filesFound.push(name2);
+  }
+  if (shape.summaryJsonl !== null) filesFound.push("Summary.jsonl");
+  if (shape.hardwareJsonl !== null) filesFound.push("HardwareInfo.jsonl");
+  if (shape.pipeTrace !== null) filesFound.push("PipeTrace.json");
+  if (filesFound.length === 0) {
+    throw new Error(
+      `ops_import: \u76EE\u5F55\u5185\u672A\u53D1\u73B0\u53EF\u8BC6\u522B\u7684\u91C7\u96C6\u4EA7\u7269\uFF08OpBasicInfo/PipeUtilization/op_summary/Summary.jsonl \u7B49\uFF09\uFF1A${dir}`
+    );
+  }
+  const dirName = dir.split("/").filter((s) => s !== "").at(-1) ?? "";
+  const hasDumpBin = await fileExists2(`${dir}/dump/visualize_data.bin`);
+  const hasMindstudio = await dirExists(`${dir}/mindstudio_profiler_output`);
+  const summaryCategory = shape.summaryJsonl !== null || shape.sections.has("PipeUtilization");
+  let source;
+  if (dirName.startsWith("OPPROF_") || hasDumpBin && shape.opBasicInfoPath !== null) source = "msopprof-dir";
+  else if (dirName.startsWith("PROF_") || hasMindstudio) source = "msprof-dir";
+  else if (summaryCategory && shape.summaryJsonl !== null) source = "npu-compute-dir";
+  else if (shape.sections.size >= 4 && shape.pipeTrace !== null) source = "simulator-dir";
+  else if (shape.sections.has("PipeUtilization")) source = "npu-compute-dir";
+  else if (shape.opSummaryPath !== null) source = "msprof-dir";
+  else throw new Error(`ops_import: \u65E0\u6CD5\u5224\u5B9A\u4EA7\u7269\u6765\u6E90\u5F62\u6001\uFF1A${dir}`);
+  let soc = null;
+  if (source === "npu-compute-dir" || source === "simulator-dir") soc = "a5";
+  else if (shape.opBasicInfoPath !== null || source === "msopprof-dir") soc = "a2";
+  const { reportId, runId } = newIds();
+  const { resolve: resolvePath } = await import("node:path");
+  const archiveRoot = resolvePath(process.cwd(), config.workbenchDir === "" ? ".ops-tune-workbench" : config.workbenchDir, "reports");
+  const report = await buildReportModel({
+    dir,
+    reportId,
+    runId,
+    source,
+    kind: "import",
+    mode: source === "simulator-dir" ? "simulate" : "onboard",
+    soc,
+    label: input.label,
+    kernelName: input.kernel_name?.trim() !== void 0 && input.kernel_name?.trim() !== "" ? input.kernel_name.trim() : null,
+    archiveRoot
+  });
+  const children = await buildResultChildren(report.artifact_dir);
+  const result = {
+    report_id: report.report_id,
+    title: dirName !== "" ? dirName : report.report_id,
+    timestamp: report.collected_at,
+    marked: false,
+    source: report.source,
+    kind: report.kind,
+    dir_path: report.artifact_dir,
+    children
+  };
+  ctx.logger.info(`[ops-tune-workbench] ops_import ${dir} \u2192 ${source} report ${report.reportId}`);
+  let producerVersion;
+  const diagnostics = ["Original collection log unavailable; event coverage is unknown."];
+  if (source === "msopprof-dir") {
+    try {
+      producerVersion = await readProducerMetadata(dir);
+    } catch {
+      diagnostics.push("Profiler provenance did not match the imported files; producer version remains unverified.");
+    }
+  }
+  return {
+    report,
+    result,
+    files_found: filesFound,
+    producer_version: producerVersion,
+    profiling_diagnostics: diagnostics,
+    metrics_preview: {
+      task_duration_us: report.summary.task_duration_us,
+      block_dim: report.summary.block_dim,
+      op_name: report.summary.op_name,
+      pipe_ratios: Object.fromEntries(
+        report.pipe_occupancy.map((p) => [p.side === "cube" ? `aic_${p.id}_ratio` : `aiv_${p.id}_ratio`, p.ratio])
+      )
+    }
+  };
+}
+async function dirExists(path) {
+  try {
+    const { stat: stat4 } = await import("node:fs/promises");
+    const info = await stat4(path);
+    return info.isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function fileExists2(path) {
+  try {
+    const { stat: stat4 } = await import("node:fs/promises");
+    const info = await stat4(path);
+    return info.isFile();
+  } catch {
+    return false;
+  }
+}
+function importedToolValue(outcome, directory) {
+  const report = outcome.report;
+  return {
+    run_id: report.run_id,
+    report_id: report.report_id,
+    source: report.source,
+    files_found: outcome.files_found,
+    raw_artifact_dir: directory,
+    artifact_dir: report.artifact_dir,
+    ...outcome.producer_version !== void 0 ? { producer_version: outcome.producer_version } : {},
+    ...outcome.profiling_diagnostics !== void 0 ? { profiling_diagnostics: outcome.profiling_diagnostics } : {},
+    summary: report.summary,
+    metrics_preview: outcome.metrics_preview,
+    verdict_hint: "\u672A\u5224\u5B9A\uFF08\u9700 verdict_judge\uFF09"
+  };
+}
+
+// src/host/verdict.ts
+import { readFile as readFile3 } from "node:fs/promises";
+import { join as join3, relative as relative2, resolve as resolve2 } from "node:path";
+function defaultRulePacks(soc, scalar, rulesDir) {
+  const packs = ["L2-inter-core.yaml", "L1-single-core.yaml", "L0-instruction.yaml"];
+  const isA5 = soc === "a5";
+  const hasMc2Scalar = scalar !== void 0 && scalar !== "" && /t_comm_us|t_compute_us|mte2_ratio_full/.test(scalar);
+  if (isA5 && hasMc2Scalar) packs.unshift("L3-inter-card.yaml");
+  void rulesDir;
+  return packs;
+}
+function resolveRulesDir(skillDir) {
+  return resolve2(skillDir, "ops-verdict/rules");
+}
+async function resolveVerdictScript(config, skillDir) {
+  if (config.verdictScript !== "") {
+    try {
+      const { access } = await import("node:fs/promises");
+      await access(config.verdictScript);
+      return config.verdictScript;
+    } catch {
+      return null;
+    }
+  }
+  const candidate = resolve2(skillDir, "ops-verdict/scripts/verdict.py");
+  try {
+    const { access } = await import("node:fs/promises");
+    await access(candidate);
+    return candidate;
+  } catch {
+    return null;
+  }
+}
+async function pythonAvailable(ctx, pythonBin) {
+  try {
+    const out = await spawn(ctx, { argv: [pythonBin, "--version"], cwd: process.cwd(), signal: new AbortController().signal });
+    return out.exitCode === 0;
+  } catch {
+    return false;
+  }
+}
+async function fileOk(path) {
+  try {
+    const { access } = await import("node:fs/promises");
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function latestReportId(doc) {
+  const keys = Object.keys(doc.reports);
+  return keys.length > 0 ? keys[keys.length - 1] : null;
+}
+function pickReport(doc, reportId) {
+  const id = reportId !== void 0 && reportId !== "" ? reportId : latestReportId(doc);
+  if (id === null) {
+    throw new Error("verdict_judge: \u5DE5\u4F5C\u53F0\u5185\u8FD8\u6CA1\u6709\u62A5\u544A\u2014\u2014\u8BF7\u5148\u8FD0\u884C ops_collect \u6216 ops_import\u3002");
+  }
+  const report = doc.reports[id];
+  if (report === void 0) {
+    throw new Error(`verdict_judge: \u62A5\u544A\u4E0D\u5B58\u5728\uFF1A${id}\uFF08state.reports \u4E2D\u7684 id \u624D\u6709\u6548\uFF09`);
+  }
+  return report;
+}
+async function runVerdict(ctx, config, skillDir, doc, input, workbenchRoot, signal) {
+  const report = pickReport(doc, input.report_id);
+  const verdictScript = await resolveVerdictScript(config, skillDir);
+  if (verdictScript === null) {
+    throw new Error(
+      "verdict_judge: verdict.py \u4E0D\u53EF\u7528\uFF08verdictScript \u672A\u914D\u7F6E\u4E14\u5185\u7F6E skills/tool-ops-tune/ops-verdict/scripts/verdict.py \u4E0D\u5B58\u5728\uFF09\u3002\u8BF7\u5728 cordis.patch.yml \u914D\u7F6E verdictScript\uFF0C\u6216\u786E\u8BA4\u63D2\u4EF6\u5305\u5185 skills/ \u76EE\u5F55\u5B8C\u6574\u3002"
+    );
+  }
+  const pythonBin = config.pythonBin === "" ? "python3" : config.pythonBin;
+  if (!await pythonAvailable(ctx, pythonBin)) {
+    throw new Error(
+      `verdict_judge: python \u89E3\u91CA\u5668\u4E0D\u53EF\u7528\uFF08pythonBin="${pythonBin}"\uFF09\u3002verdict.py \u9700\u8981 Python >= 3.8 + PyYAML\uFF1B\u8BF7\u5728 cordis.patch.yml \u914D\u7F6E pythonBin \u6307\u5411\u53EF\u7528\u89E3\u91CA\u5668\u3002`
+    );
+  }
+  let csvInput = join3(report.artifact_dir, "PipeUtilization.csv");
+  if (!await fileOk(csvInput)) {
+    const { readdir: readdir3 } = await import("node:fs/promises");
+    let archived = [];
+    try {
+      archived = await readdir3(report.artifact_dir);
+    } catch {
+      archived = [];
+    }
+    const opSummary = archived.find((f) => /^op_summary_.*\.csv$/.test(f));
+    if (opSummary !== void 0) {
+      csvInput = join3(report.artifact_dir, opSummary);
+    } else {
+      throw new Error(
+        `verdict_judge: \u62A5\u544A ${report.report_id} \u7F3A\u5C11\u5F52\u6863 PipeUtilization.csv\uFF08verdict.py \u7684 CSV \u8F93\u5165\uFF09\u3002\u8BF7\u5BF9\u542B PipeUtilization \u4EA7\u7269\u7684\u62A5\u544A\u8FD0\u884C\u5224\u5B9A\uFF0C\u6216\u91CD\u65B0\u91C7\u96C6/\u5BFC\u5165\u3002`
+      );
+    }
+  }
+  const soc = input.soc ?? report.soc ?? void 0;
+  if (soc === void 0) {
+    throw new Error("verdict_judge: \u65E0\u6CD5\u786E\u5B9A soc\uFF08\u62A5\u544A\u6A21\u578B\u65E0 soc \u4E14\u672A\u4F20\u53C2\uFF09\u3002\u8BF7\u663E\u5F0F\u4F20 soc=a2|a3|a5\u3002");
+  }
+  const kernelName = input.kernel_name !== void 0 && input.kernel_name !== "" ? input.kernel_name : report.kernel_name ?? void 0;
+  const rulesDir = resolveRulesDir(skillDir);
+  const packs = input.rules !== void 0 && input.rules !== "" ? input.rules.split(",").map((s) => s.trim()).filter((s) => s !== "") : defaultRulePacks(soc, input.scalar, rulesDir);
+  const rulesArg = packs.map((p) => p.includes("/") ? p : join3(rulesDir, p)).join(",");
+  const outPath = join3(report.artifact_dir, "verdict.json");
+  const argv = [
+    pythonBin,
+    verdictScript,
+    "--rules",
+    rulesArg,
+    "--csv",
+    csvInput,
+    "--soc",
+    soc,
+    "-o",
+    outPath
+  ];
+  if (kernelName !== void 0) argv.push("--kernel-name", kernelName);
+  if (input.scalar !== void 0 && input.scalar !== "") argv.push("--scalar", input.scalar);
+  const out = await spawn(ctx, { argv, cwd: process.cwd(), signal });
+  if (out.exitCode === 4) {
+    throw new Error(
+      `verdict_judge: verdict.py G15 \u95E8\u7981\uFF08exit 4\uFF0C\u591A kernel \u6DF7\u91C7\u672A\u6307\u5B9A --kernel-name \u6216\u540D\u79F0\u4E0D\u5728\u96C6\u5408\u4E2D\uFF09\uFF1A
+${out.stderr.trim()}
+\u53EF\u7528 kernel \u6E05\u5355\u89C1\u4E0A\u65B9\u62A5\u9519\uFF1B\u8BF7\u7ECF ops_import \u7684 kernel_name \u53C2\u6570\u6216 verdict_judge \u7684 kernel_name \u53C2\u6570\u6307\u5B9A\u540E\u91CD\u5224\u3002`
+    );
+  }
+  if (out.exitCode !== 0) {
+    throw new Error(
+      `verdict_judge: verdict.py \u6267\u884C\u5931\u8D25\uFF08exit ${String(out.exitCode)}\uFF09\uFF1A
+${out.stderr.trim().slice(0, 4e3)}`
+    );
+  }
+  let raw;
+  try {
+    raw = JSON.parse(await readFile3(outPath, "utf8"));
+  } catch (error) {
+    throw new Error(`verdict_judge: verdict.json \u89E3\u6790\u5931\u8D25\uFF08${String(error)}\uFF09\uFF1A${outPath}`);
+  }
+  const relPath = relPathOfVerdict(workbenchRoot, outPath);
+  const verdict = summarizeVerdict(raw, verdictScript, relPath);
+  return { verdict, fullVerdict: raw, reportId: report.report_id, verdictPath: outPath };
+}
+function relPathOfVerdict(workbenchRoot, outPath) {
+  const rel = relative2(join3(workbenchRoot, ".."), outPath);
+  return rel.split("\\").join("/");
+}
+
+// src/host/baseline.ts
+import { join as join4, resolve as resolve3 } from "node:path";
+var REQUIRED_CALIBER_KEYS = ["precision", "shape", "dtype", "warmup", "repeat", "timing_method", "baseline_kind"];
+function resolveSnapshotScript(skillDir) {
+  return resolve3(skillDir, "ops-verdict/scripts/snapshot.py");
+}
+function resolveDeltaCompareScript(skillDir) {
+  return resolve3(skillDir, "ops-verdict/scripts/delta_compare.py");
+}
+function pickReportForBaseline(doc, id, what) {
+  const target = id !== void 0 && id !== "" ? id : latestReportId(doc);
+  if (target === null) {
+    throw new Error(`${what}: \u5DE5\u4F5C\u53F0\u5185\u8FD8\u6CA1\u6709\u62A5\u544A\u2014\u2014\u8BF7\u5148\u8FD0\u884C ops_collect \u6216 ops_import\u3002`);
+  }
+  const report = doc.reports[target];
+  if (report === void 0) {
+    throw new Error(`${what}: \u62A5\u544A\u4E0D\u5B58\u5728\uFF1A${target}`);
+  }
+  return report;
+}
+function validateCaliber(caliber) {
+  if (caliber === void 0 || typeof caliber !== "object") {
+    throw new Error(
+      "baseline_set: \u5BF9\u6BD4\u6A21\u5F0F\u9700\u8981 caliber \u53E3\u5F84\u53C2\u6570\u5BF9\u8C61\uFF08precision/shape/dtype/warmup/repeat/timing_method/baseline_kind \u5FC5\u586B\uFF09\uFF0C\u7531\u8C03\u7528\u65B9\u4ECE\u8C03\u4F18\u4E0A\u4E0B\u6587\u63D0\u4F9B\u2014\u2014Host \u4E0D\u7F16\u9020\u53E3\u5F84\u503C\u3002"
+    );
+  }
+  const missing = REQUIRED_CALIBER_KEYS.filter((k) => {
+    const v = caliber[k];
+    return v === void 0 || v === null || v === "";
+  });
+  if (missing.length > 0) {
+    throw new Error(
+      `baseline_set: caliber \u7F3A\u5931\u5FC5\u586B\u9879\uFF1A${missing.join(", ")}\uFF08\u53E3\u5F84\u53C2\u6570\u5FC5\u987B\u7531\u8C03\u7528\u65B9\u63D0\u4F9B\uFF0C\u7981\u6B62 Host \u7F16\u9020\uFF09\u3002\u5FC5\u586B\u5168\u96C6\uFF1Aprecision, shape, dtype, warmup, repeat, timing_method, baseline_kind\uFF1B\u53EF\u9009\uFF1Acann_version, device_id, format, tiling_key, block_dim, kernel_p50_us, kernel_p95_us\u3002`
+    );
+  }
+  return caliber;
+}
+async function runSnapshot(ctx, config, snapshotScript, report, variant, caliber, outDir, signal) {
+  const pythonBin = config.pythonBin === "" ? "python3" : config.pythonBin;
+  const resultPath = join4(outDir, "result.json");
+  const mode = report.mode === "simulate" ? "sim" : "board";
+  const argv = [
+    pythonBin,
+    snapshotScript,
+    "--op",
+    report.summary.op_name ?? "unknown",
+    "--variant",
+    variant,
+    "--mode",
+    mode,
+    "--soc",
+    report.soc ?? "a5",
+    "--precision",
+    caliber.precision,
+    "--timing-method",
+    caliber.timing_method,
+    "--baseline-kind",
+    caliber.baseline_kind,
+    "--shape",
+    caliber.shape,
+    "--dtype",
+    caliber.dtype,
+    "--warmup",
+    String(caliber.warmup),
+    "--repeat",
+    String(caliber.repeat),
+    "-o",
+    resultPath
+  ];
+  if (report.summary.task_duration_us !== null) {
+    argv.push("--kernel-avg-us", String(report.summary.task_duration_us));
+  }
+  if (caliber.cann_version !== void 0) argv.push("--cann-version", caliber.cann_version);
+  else if (report.summary.rated_freq !== null) argv.push("--cann-version", "unknown");
+  if (caliber.device_id !== void 0) argv.push("--device-id", caliber.device_id);
+  if (caliber.format !== void 0) argv.push("--format", caliber.format);
+  if (caliber.tiling_key !== void 0) argv.push("--tiling-key", caliber.tiling_key);
+  if (caliber.block_dim !== void 0) argv.push("--block-dim", String(caliber.block_dim));
+  else if (report.summary.block_dim !== null) argv.push("--block-dim", String(report.summary.block_dim));
+  if (caliber.kernel_p50_us !== void 0) argv.push("--kernel-p50-us", String(caliber.kernel_p50_us));
+  if (caliber.kernel_p95_us !== void 0) argv.push("--kernel-p95-us", String(caliber.kernel_p95_us));
+  argv.push("--no-env-probe");
+  const out = await spawn(ctx, { argv, cwd: process.cwd(), signal });
+  if (out.exitCode !== 0) {
+    throw new Error(
+      `baseline_set: snapshot.py \u6267\u884C\u5931\u8D25\uFF08exit ${String(out.exitCode)}\uFF0Cvariant=${variant}\uFF09\uFF1A
+${out.stderr.trim().slice(0, 4e3)}`
+    );
+  }
+  return { resultPath };
+}
+async function runBaseline(ctx, config, skillDir, doc, input, workbenchRoot, signal) {
+  const isCompare = input.compare_id !== void 0 && input.compare_id !== "";
+  if (!isCompare) {
+    const report = pickReportForBaseline(doc, input.report_id, "baseline_set");
+    void report;
+    return { baseline_id: input.report_id };
+  }
+  const caliber = validateCaliber(input.caliber);
+  const baselineReport = pickReportForBaseline(doc, input.report_id, "baseline_set");
+  const afterReport = pickReportForBaseline(doc, input.compare_id, "baseline_set");
+  const snapshotScript = resolveSnapshotScript(skillDir);
+  const deltaScript = resolveDeltaCompareScript(skillDir);
+  const { access } = await import("node:fs/promises");
+  for (const [label, script] of [["snapshot.py", snapshotScript], ["delta_compare.py", deltaScript]]) {
+    try {
+      await access(script);
+    } catch {
+      throw new Error(`baseline_set: ${label} \u4E0D\u53EF\u7528\uFF08${script}\uFF09\u2014\u2014\u786E\u8BA4\u63D2\u4EF6\u5305\u5185 skills/ \u76EE\u5F55\u5B8C\u6574\u3002`);
+    }
+  }
+  const pythonBin = config.pythonBin === "" ? "python3" : config.pythonBin;
+  try {
+    const probe = await spawn(ctx, { argv: [pythonBin, "--version"], cwd: process.cwd(), signal });
+    if (probe.exitCode !== 0) throw new Error("python --version failed");
+  } catch {
+    throw new Error(`baseline_set: python \u89E3\u91CA\u5668\u4E0D\u53EF\u7528\uFF08pythonBin="${pythonBin}"\uFF09\u3002`);
+  }
+  const roundSuffix = afterReport.report_id.slice(-2);
+  const baseSnap = await runSnapshot(ctx, config, snapshotScript, baselineReport, "baseline", caliber, baselineReport.artifact_dir, signal);
+  const afterSnap = await runSnapshot(ctx, config, snapshotScript, afterReport, `round-${roundSuffix}`, caliber, afterReport.artifact_dir, signal);
+  const comparisonMdPath = join4(afterReport.artifact_dir, "comparison.md");
+  const cmpOut = await spawn(ctx, {
+    argv: [pythonBin, deltaScript, "--baseline", baseSnap.resultPath, "--after", afterSnap.resultPath, "--output", comparisonMdPath],
+    cwd: process.cwd(),
+    signal
+  });
+  const stdout = cmpOut.stdout;
+  const stderr = cmpOut.stderr;
+  const conclusionText = stripPrefix(extractLine(stdout, "\u7ED3\u8BBA:") ?? extractLine(stderr, "\u7ED3\u8BBA:"), "\u7ED3\u8BBA:") ?? (cmpOut.exitCode === 2 ? `delta_compare \u62D2\u7EDD\u6BD4\u8F83\uFF08exit 2\uFF09\uFF1A${firstMeaningfulLine(stderr)}` : "");
+  const actionText = stripPrefix(extractLine(stdout, "\u5904\u7F6E:") ?? extractLine(stderr, "\u5904\u7F6E:"), "\u5904\u7F6E:") ?? "";
+  let speedup = null;
+  if (baselineReport.summary.task_duration_us !== null && afterReport.summary.task_duration_us !== null && afterReport.summary.task_duration_us > 0) {
+    speedup = baselineReport.summary.task_duration_us / afterReport.summary.task_duration_us;
+  }
+  try {
+    const { readFile: readFile6 } = await import("node:fs/promises");
+    const md = await readFile6(comparisonMdPath, "utf8");
+    const m = /\| speedup \| — \| *([0-9.]+) *\|/.exec(md);
+    if (m !== null) speedup = Number(m[1]);
+  } catch {
+  }
+  const comparison = {
+    exit_code: cmpOut.exitCode ?? -1,
+    conclusion_text: conclusionText,
+    action_text: actionText,
+    speedup,
+    hard_keys_ok: cmpOut.exitCode === 0,
+    comparison_md_path: comparisonMdPath,
+    result_json_paths: [baseSnap.resultPath, afterSnap.resultPath]
+  };
+  return { baseline_id: baselineReport.report_id, comparison };
+}
+function extractLine(text, prefix) {
+  for (const line of text.split(/\r?\n/)) {
+    const t = line.trim();
+    if (t.startsWith(prefix)) return t;
+  }
+  return null;
+}
+function stripPrefix(line, prefix) {
+  if (line === null) return null;
+  const rest = line.slice(prefix.length).trim();
+  return rest;
+}
+function firstMeaningfulLine(stderr) {
+  const lines = stderr.split(/\r?\n/).map((l) => l.trim()).filter((l) => l !== "");
+  return lines[0] ?? "";
+}
+
+// src/host/skill.ts
+import { readFile as readFile4 } from "node:fs/promises";
+import { dirname as dirname2, join as join5, resolve as resolve4 } from "node:path";
+import { fileURLToPath } from "node:url";
+var BUNDLED_SKILL_RANK = 600;
+var SKILL_SUBDOMAINS = ["ops-collect", "ops-verdict", "ops-mechanism", "ops-family", "ops-report"];
+var SKILL_TRIGGERS = ["\u7B97\u5B50\u8C03\u4F18", "\u74F6\u9888\u5224\u5B9A", "Bound \u5224\u5B9A", "\u6027\u80FD\u91C7\u96C6", "profiling \u7F16\u6392", "\u8C03\u4F18\u524D\u540E\u5BF9\u6BD4", "\u52A0\u901F\u6BD4\u7ED3\u8BBA"];
+function pluginRoot() {
+  try {
+    const here = dirname2(fileURLToPath(import.meta.url));
+    if (here.endsWith("/lib") || here.endsWith("\\lib")) return dirname2(here);
+    if (here.includes(`${"/"}src${"/"}host`)) return resolve4(here, "..", "..", "..");
+    return dirname2(here);
+  } catch {
+    return process.cwd();
+  }
+}
+function bundledSkillDir(name2) {
+  return resolve4(pluginRoot(), "skills", name2);
+}
+function parseFrontmatter(raw) {
+  if (!raw.startsWith("---")) return null;
+  const end = raw.indexOf("\n---", 3);
+  if (end === -1) return null;
+  const block = raw.slice(3, end);
+  const out = {};
+  for (const line of block.split(/\r?\n/)) {
+    const m = /^([A-Za-z_-]+):\s*(.*)$/.exec(line);
+    if (m === null) continue;
+    const key = m[1];
+    let value = m[2].trim();
+    if (value.startsWith('"') && value.endsWith('"') && value.length >= 2) value = value.slice(1, -1);
+    if (key === "name" || key === "description" || key === "whenToUse") out[key] = value;
+  }
+  return out;
+}
+async function readSkillMd(dir) {
+  try {
+    return await readFile4(join5(dir, "SKILL.md"), "utf8");
+  } catch {
+    return null;
+  }
+}
+async function resolveTuningSkill(ctx, config) {
+  const name2 = config.tuningSkill === "" ? "tool-ops-tune" : config.tuningSkill;
+  const external = config.tuningSkillDir === "" ? null : resolve4(config.tuningSkillDir);
+  const tryDir = async (dir) => {
+    const raw = await readSkillMd(dir);
+    if (raw === null) return { ok: false };
+    const fm = parseFrontmatter(raw);
+    if (fm === null) return { ok: false };
+    return { ok: true, fm };
+  };
+  if (external !== null) {
+    const ext = await tryDir(external);
+    if (ext.ok && ext.fm?.name === name2) {
+      return buildResolved(name2, external, ext.fm.description ?? "", false);
+    }
+    if (ext.ok) {
+      ctx.logger.warn(`[ops-tune-workbench] tuningSkillDir=${external} \u7684 SKILL.md frontmatter.name="${ext.fm.name ?? ""}" \u4E0E tuningSkill="${name2}" \u4E0D\u7B26 \u2192 \u56DE\u9000\u5185\u7F6E\u76EE\u5F55`);
+    } else {
+      ctx.logger.warn(`[ops-tune-workbench] tuningSkillDir=${external} \u65E0 SKILL.md \u2192 \u56DE\u9000\u5185\u7F6E\u76EE\u5F55`);
+    }
+  }
+  const bundled = bundledSkillDir(name2);
+  const b = await tryDir(bundled);
+  if (b.ok && b.fm?.name === name2) {
+    return buildResolved(name2, bundled, b.fm.description ?? "", true);
+  }
+  if (b.ok) {
+    ctx.logger.warn(`[ops-tune-workbench] \u5185\u7F6E ${bundled} \u7684 frontmatter.name="${b.fm?.name ?? ""}" \u4E0E tuningSkill="${name2}" \u4E0D\u7B26`);
+    throw new Error(
+      `ops-tune-workbench: \u5185\u7F6E\u6280\u80FD\u76EE\u5F55 ${bundled} \u7684 SKILL.md frontmatter.name \u4E3A "${b.fm?.name ?? ""}"\uFF0C\u4E0E\u914D\u7F6E tuningSkill="${name2}" \u4E0D\u7B26\u3002\u8BF7\u4FEE\u6B63\u914D\u7F6E\u6216 SKILL.md\u3002`
+    );
+  }
+  throw new Error(
+    `ops-tune-workbench: \u627E\u4E0D\u5230\u53EF\u7528\u7684\u8C03\u4F18\u6280\u80FD\u76EE\u5F55\uFF08tuningSkill="${name2}"\uFF0CtuningSkillDir="${config.tuningSkillDir}"\uFF0C\u5185\u7F6E\u76EE\u5F55 ${bundled} \u65E0 SKILL.md\uFF09\u3002\u6280\u80FD\u88C5\u8F7D\u5931\u8D25\u4E0D\u9759\u9ED8\u2014\u2014\u8BF7\u68C0\u67E5\u63D2\u4EF6\u5B89\u88C5\u5B8C\u6574\u6027\u6216\u914D\u7F6E\u3002`
+  );
+}
+function buildResolved(name2, dir, description, bundled) {
+  return {
+    name: name2,
+    dir,
+    description,
+    status: {
+      skill_name: name2,
+      skill_dir: dir,
+      entry: "SKILL.md",
+      subdomains: SKILL_SUBDOMAINS,
+      agent_layer: join5(dir, "agent/AGENTS.md"),
+      triggers: SKILL_TRIGGERS,
+      config: { tuningSkill: name2, tuningSkillDir: dir === bundledSkillDir(name2) ? "" : dir },
+      bundled
+    }
+  };
+}
+function registerSkillProvider(ctx, resolved) {
+  const skills = ctx.skills;
+  if (skills === void 0 || typeof skills.registerProvider !== "function") {
+    throw new Error(
+      "ops-tune-workbench: ctx.skills.registerProvider \u4E0D\u53EF\u7528\uFF08dsh \u672A\u88C5\u8F7D skill \u670D\u52A1\uFF0Cweb profile standard preset \u5E94\u542B dsh-skill\uFF09\u3002\u6280\u80FD\u88C5\u8F7D\u5931\u8D25\u4E0D\u9759\u9ED8\uFF08R-7\uFF09\u3002"
+    );
+  }
+  const provider = {
+    name: "ops-tune-workbench",
+    async list(_options) {
+      return [{
+        name: resolved.name,
+        description: resolved.description,
+        invocation: { modelInvocable: true, userInvocable: true },
+        source: "bundled",
+        provider: "ops-tune-workbench",
+        resourceBase: { kind: "directory", path: resolved.dir },
+        rank: BUNDLED_SKILL_RANK,
+        locator: { path: join5(resolved.dir, "SKILL.md"), directory: resolved.dir },
+        path: join5(resolved.dir, "SKILL.md")
+      }];
+    },
+    async get(candidate, _options) {
+      const name2 = candidate.name ?? resolved.name;
+      if (name2 !== resolved.name) return void 0;
+      const raw = await readSkillMd(resolved.dir);
+      if (raw === null) return void 0;
+      const fm = parseFrontmatter(raw);
+      const bodyStart = raw.startsWith("---") ? raw.indexOf("\n---", 3) + 4 : 0;
+      const content = raw.slice(bodyStart).trim();
+      return {
+        name: fm?.name ?? resolved.name,
+        description: fm?.description ?? resolved.description,
+        invocation: { modelInvocable: true, userInvocable: true },
+        source: "bundled",
+        provider: "ops-tune-workbench",
+        resourceBase: { kind: "directory", path: resolved.dir },
+        path: join5(resolved.dir, "SKILL.md"),
+        content
+      };
+    }
+  };
+  const dispose = skills.registerProvider(() => provider);
+  ctx.effect(() => dispose, "ops-tune-workbench: skill provider");
+  ctx.logger.info(`[ops-tune-workbench] skill provider registered (${resolved.name} @ ${resolved.dir}${resolved.status.bundled ? " [bundled]" : " [external]"})`);
+}
+
+// src/host/index.ts
+import { resolve as resolve6 } from "node:path";
+
+// src/host/state.ts
+import { mkdir as mkdir2, readFile as readFile5, stat as stat3, writeFile as writeFile3 } from "node:fs/promises";
+import { join as join6, resolve as resolve5 } from "node:path";
+var STATE_LINE_BUDGET = 3e3;
+var STATE_LINE_HARD_CAP = 5e3;
+var EMPTY = {
+  schema: "ops-tune-workbench.state/2",
+  updated_at: "",
+  config_echo: { tuningSkill: "", tuningSkillDir: "", skillResolvedDir: "" },
+  baseline_id: void 0,
+  results: [],
+  reports: {},
+  collection_config: void 0
+};
+async function stateDir(ctx, config, exec) {
+  const base = config.workbenchDir === "" ? ".ops-tune-workbench" : config.workbenchDir;
+  if (exec.agent === void 0) return resolve5(process.cwd(), base);
+  const wd = ctx.get("workingDirectory");
+  const root = wd === void 0 ? process.cwd() : await wd.ensure(exec.agent, exec.signal);
+  return resolve5(root, base);
+}
+async function readState(dir) {
+  try {
+    const raw = await readFile5(join6(dir, "state.json"), "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed.schema !== "ops-tune-workbench.state/2") return cloneEmpty();
+    return {
+      ...cloneEmpty(),
+      ...parsed,
+      config_echo: { ...cloneEmpty().config_echo, ...parsed.config_echo ?? {} },
+      results: parsed.results ?? [],
+      reports: parsed.reports ?? {}
+    };
+  } catch {
+    return cloneEmpty();
+  }
+}
+function cloneEmpty() {
+  return {
+    ...EMPTY,
+    config_echo: { ...EMPTY.config_echo },
+    results: [],
+    reports: {}
+  };
+}
+function serialize(doc) {
+  let text = JSON.stringify(doc, null, 2);
+  let lines = text.split("\n").length;
+  if (lines > STATE_LINE_BUDGET) {
+    slimToBudget(doc);
+    text = JSON.stringify(doc, null, 2);
+    lines = text.split("\n").length;
+  }
+  if (lines > STATE_LINE_HARD_CAP) {
+    pruneOldestReports(doc);
+    text = JSON.stringify(doc, null, 2);
+    lines = text.split("\n").length;
+  }
+  if (lines > STATE_LINE_HARD_CAP) {
+    const sections = [
+      ["results", JSON.stringify(doc.results ?? [], null, 2).split("\n").length],
+      ["reports", JSON.stringify(doc.reports ?? {}, null, 2).split("\n").length]
+    ];
+    sections.sort((a, b) => b[1] - a[1]);
+    const top = sections[0];
+    throw new Error(
+      `ops-tune-workbench state.json exceeds the hard line cap: ${String(lines)} lines > ${String(STATE_LINE_HARD_CAP)} (largest section: ${top[0]} ~${String(top[1])} lines; budget ${String(STATE_LINE_BUDGET)} already auto-slimmed). Row data must stay in artifact_dir with only indexes in state (DESIGN \xA74.2/\xA74.7).`
+    );
+  }
+  return text;
+}
+function pruneOldestReports(doc) {
+  const ids = Object.keys(doc.reports).sort();
+  const keep = /* @__PURE__ */ new Set();
+  if (doc.baseline_id !== void 0 && doc.reports[doc.baseline_id] !== void 0) keep.add(doc.baseline_id);
+  const newest = ids.at(-1);
+  if (newest !== void 0) keep.add(newest);
+  for (const id of ids) {
+    if (countLines(doc) <= STATE_LINE_BUDGET || keep.has(id)) continue;
+    delete doc.reports[id];
+    doc.results = doc.results.filter((result) => result.report_id !== id);
+  }
+}
+function slimToBudget(doc) {
+  const ids = Object.keys(doc.reports).sort();
+  for (const id of ids) {
+    if (countLines(doc) <= STATE_LINE_BUDGET) return;
+    const report = doc.reports[id];
+    if (report === void 0) continue;
+    if (report.slimmed === true) continue;
+    slimOneReport(report);
+    report.slimmed = true;
+  }
+}
+function slimOneReport(report) {
+  for (const t of report.table_index ?? []) {
+    if (t.block_ids !== void 0 && t.block_ids.length > 0) t.block_ids = [];
+  }
+  for (const e of report.memory_topology?.edges ?? []) {
+    if (e.source_files !== void 0) e.source_files = [];
+  }
+  for (const c of report.summary_categories ?? []) {
+    if (c.fields !== void 0 && c.fields.length > 4) c.fields = c.fields.slice(0, 4);
+  }
+  for (const p of report.pipe_occupancy ?? []) {
+    if (p.columns !== void 0) p.columns = [];
+    if (p.time_columns !== void 0) p.time_columns = [];
+  }
+  for (const s of report.hardware_details?.sections ?? []) {
+    if (s.fields !== void 0 && s.fields.length > 8) s.fields = s.fields.slice(0, 8);
+  }
+}
+function countLines(doc) {
+  return JSON.stringify(doc, null, 2).split("\n").length;
+}
+async function writeState(dir, doc) {
+  doc.updated_at = (/* @__PURE__ */ new Date()).toISOString();
+  const text = serialize(doc);
+  await mkdir2(dir, { recursive: true });
+  await writeFile3(join6(dir, "state.json"), text, "utf8");
+}
+async function updateState(dir, mutate) {
+  const doc = await readState(dir);
+  await mutate(doc);
+  await writeState(dir, doc);
+  return doc;
+}
+function upsertReport(doc, report) {
+  const existing = doc.reports[report.report_id];
+  if (existing === void 0) {
+    doc.reports[report.report_id] = report;
+    return;
+  }
+  const merged = { ...existing };
+  for (const [key, value] of Object.entries(report)) {
+    if (value === void 0) continue;
+    if (value === null) continue;
+    if (typeof value === "string" && value === "" && (existing[key] !== void 0 && existing[key] !== "" && existing[key] !== null)) continue;
+    merged[key] = value;
+  }
+  doc.reports[report.report_id] = merged;
+}
+function upsertResult(doc, entry) {
+  const idx = doc.results.findIndex((r) => r.report_id === entry.report_id);
+  if (idx === -1) {
+    doc.results.push(entry);
+    return;
+  }
+  const existing = doc.results[idx];
+  doc.results[idx] = { ...entry, children: entry.children.length > 0 ? entry.children : existing.children };
+}
+
+// src/host/index.ts
+var name = "ops-tune-workbench";
+var inject = ["tools", "systemPrompt", "subprocess", "skills"];
+function apply(ctx, config) {
+  const log = (message) => {
+    ctx.logger.info(`[ops-tune-workbench] ${message}`);
+  };
+  log("host plugin loaded (tool bridge ready: ops_collect / ops_import / verdict_judge / baseline_set / tuning_skill)");
+  ctx.systemPrompt.section({
+    name: "ops-tune-workbench:guide",
+    order: 2950,
+    text: [
+      "You are operating inside the \u7B97\u5B50\u8C03\u4F18\u5DE5\u4F5C\u53F0 (operator tuning workbench).",
+      "Tuning loop: collect/import metrics (ops_collect / ops_import) \u2192 obtain the rule-engine verdict (verdict_judge)",
+      "\u2192 route mechanism cards from findings[].mechanism_refs \u2192 implement one mechanism \u2192 re-collect and compare",
+      "with the same caliber (baseline_set caliber params + snapshot/delta_compare scripts).",
+      "\u94C1\u5F8B\uFF1ABound \u5224\u5B9A\u53EA\u51FA\u81EA verdict_judge \u5DE5\u5177\u7684\u8F93\u51FA\uFF08ops-verdict \u89C4\u5219\u5F15\u64CE\uFF09\uFF1B\u4F60\u53EA\u89E3\u91CA\u5224\u5B9A\u4E66\u4E2D\u7684\u8BC1\u636E\u6570\u503C\uFF0C",
+      "\u7EDD\u4E0D\u81EA\u9020 Bound \u7ED3\u8BBA\u3001\u9608\u503C\u6216\u52A0\u901F\u6BD4\u9884\u4F30\u3002\u8C03\u4F18\u524D\u540E\u5BF9\u6BD4\u7ED3\u8BBA\uFF08KEEP/REVERT/\u566A\u58F0\u5E26\uFF09\u540C\u6837\u53EA\u51FA\u81EA",
+      "snapshot/delta_compare \u811A\u672C\u7684 stdout \u539F\u6587\u4E0E\u9000\u51FA\u7801\uFF0C\u4F60\u4E0D\u6539\u5199\u5176\u8BED\u4E49\u3002",
+      "\u89E6\u53D1\u8BCD\uFF08\u7B97\u5B50\u8C03\u4F18 / \u74F6\u9888\u5224\u5B9A / \u6027\u80FD\u91C7\u96C6 / \u8C03\u4F18\u524D\u540E\u5BF9\u6BD4 / \u52A0\u901F\u6BD4\u7ED3\u8BBA\uFF09\u51FA\u73B0\u65F6\uFF0C\u4F18\u5148\u4F7F\u7528 tool-ops-tune \u6280\u80FD",
+      "\uFF08tuning_skill \u5DE5\u5177\u53EF\u67E5\u8BE2\u88C5\u8F7D\u72B6\u6001\uFF09\u5E76\u6309\u5176\u8C03\u4F18\u4E3B\u5FAA\u73AF\u6267\u884C\uFF1B\u5019\u9009\u65B9\u6848\u4E0E KEEP/REVERT \u51B3\u7B56\u5FC5\u987B\u7B49\u5F85\u7528\u6237\u62CD\u677F\u3002",
+      "\u5360\u6BD4\u6392\u5E8F\u7C7B\u805A\u5408\uFF08\u300C\u4E3B\u5BFC pipe\u300D\u300C\u6700\u5927\u5E26\u5BBD\u65B9\u5411\u300D\u7B49\uFF09\u5C5E\u4E8E\u5224\u5B9A\u4EA7\u7269\uFF1A\u91C7\u96C6\u8FD4\u56DE\u503C\u4E0D\u542B\u5B83\u4EEC\uFF0C",
+      "\u4F60\u4E5F\u4E0D\u5F97\u4EE5\u4EFB\u4F55\u6392\u5E8F/\u6BD4\u8F83\u8868\u8FF0\u66FF\u4EE3 verdict \u5224\u5B9A\u4E66\u7ED9\u51FA\u74F6\u9888\u7ED3\u8BBA\u3002"
+    ].join("\n")
+  });
+  const skillPromise = resolveTuningSkill(ctx, config);
+  void skillPromise.then(
+    (resolved) => {
+      registerSkillProvider(ctx, resolved);
+      void updateEchoedConfig(config, resolved);
+    },
+    (error) => {
+      ctx.logger.error(`[ops-tune-workbench] skill loading failed: ${String(error)}`);
+    }
+  );
+  async function updateEchoedConfig(config2, resolved) {
+    skillEcho = resolved.status;
+  }
+  let skillEcho = null;
+  void skillEcho;
+  let skillResolved = null;
+  skillPromise.then((r) => {
+    skillResolved = { name: r.name, dir: r.dir };
+  }, () => {
+  });
+  const wbRoot = () => resolve6(process.cwd(), config.workbenchDir === "" ? ".ops-tune-workbench" : config.workbenchDir);
+  async function withState(exec, mutate) {
+    const dir = await stateDir(ctx, config, exec);
+    const doc = await updateState(dir, async (d) => {
+      if (skillResolved !== null) {
+        d.config_echo = {
+          tuningSkill: skillResolved.name,
+          tuningSkillDir: config.tuningSkillDir,
+          skillResolvedDir: skillResolved.dir
+        };
+      }
+      await mutate(d);
+    });
+    return doc;
+  }
+  async function skillDir() {
+    const resolved = await skillPromise;
+    return resolved.dir;
+  }
+  ctx.tools.register(defineTool({
+    name: "ops_collect",
+    description: "\u7F16\u6392\u4E00\u6B21\u7B97\u5B50\u6027\u80FD\u91C7\u96C6\uFF08\u4E0A\u677F onboard / \u4EFF\u771F simulate / \u65B0\u5DE5\u5177 npu-compute\uFF09\uFF0C\u4EA7\u51FA\u62A5\u544A\u6A21\u578B\u5E76\u6CE8\u518C\u8FDB\u5DE5\u4F5C\u53F0\u7ED3\u679C\u5217\u8868\u3002\u7B2C 0 \u6B65\u5148\u505A NPU \u786C\u4EF6\u63A2\u6D4B\uFF08/dev/davinci* + npu-smi\uFF09\uFF1A\u65E0 NPU\u3001\u771F\u5B9E\u4EFF\u771F\u5668\u6216\u91C7\u96C6\u5DE5\u5177\u65F6\u660E\u786E\u62A5\u9519\uFF0C\u4E0D\u751F\u6210\u6F14\u793A\u6027\u80FD\u6570\u636E\uFF1B\u6709 NPU \u4E14\u5DE5\u5177\u53EF\u7528\u65F6\u8D70\u771F\u5B9E\u91C7\u96C6\u5E76\u505A\u4EA7\u7269\u65AD\u8A00\uFF08OpBasicInfo+PipeUtilization / op_summary_*.csv / \u89E3\u5305\u542B PipeUtilization.csv|summary.db\uFF0CCSV \u22652 \u884C\uFF1B\u65AD\u8A00\u4E0D\u8FC7\u5373\u62A5\u9519\uFF0C\u7EDD\u4E0D\u628A\u7A7A\u4EA7\u7269\u8BB0\u4E3A\u6210\u529F\u91C7\u96C6\uFF09\u3002options \u53C2\u6570\uFF08\u91C7\u96C6\u914D\u7F6E\u9875\u300C\u4FDD\u5B58\u914D\u7F6E/\u751F\u6210\u91C7\u96C6\u6307\u4EE4\u300D\u4EA7\u51FA\u7684 JSON\uFF09\u4F1A\u4E0E state.collection_config \u5408\u5E76\u6210\u751F\u6548\u914D\u7F6E\uFF1A\u4E0A\u677F\u9009\u9879\u7EC4\u6620\u5C04 msprof --aic-metrics\uFF08Occupancy/Roofline/Source/MemoryDetail/PCSampling/KernelScale/Default\uFF09\uFF0Cnew_tool.metrics \u6620\u5C04 npu-compute --set/--section\uFF1B\u5E26 options \u7684\u8C03\u7528\u540C\u65F6\u628A\u5B83\u6301\u4E45\u5316\u4E3A\u65B0\u7684 collection_config\u3002\u8FD4\u56DE\u503C\u53EA\u542B\u539F\u59CB\u6807\u91CF\u6307\u6807\uFF08task_duration_us\u3001block_dim\u3001\u5404 pipe \u5360\u6BD4\u8868\uFF09\uFF0C\u4E0D\u542B\u4EFB\u4F55 Bound \u7ED3\u8BBA\u2014\u2014\u5224\u5B9A\u8BF7\u8C03 verdict_judge\u3002",
+    parameters: {
+      case_dir: { type: "string", required: true, description: "\u7B97\u5B50 case/\u5DE5\u7A0B\u76EE\u5F55\uFF08\u7EDD\u5BF9\u6216\u5DE5\u4F5C\u533A\u76F8\u5BF9\u8DEF\u5F84\uFF09\u3002" },
+      mode: { type: "string", enum: ["onboard", "simulate", "npu-compute"], description: "\u91C7\u96C6\u6A21\u5F0F\uFF0C\u9ED8\u8BA4 onboard\uFF1Bsimulate \u9700\u8981\u771F\u5B9E npusim/cannsim\u3002" },
+      soc: { type: "string", enum: ["a2", "a3", "a5"], description: "\u76EE\u6807 SoC \u4EE3\u9645\u3002" },
+      label: { type: "string", description: '\u53EF\u9009\u6807\u7B7E\uFF0C\u5982 "add_custom v4 \u590D\u6D4B"\u3002' },
+      options: { type: "object", additionalProperties: true, description: "\u91C7\u96C6\u914D\u7F6E\u9009\u9879\uFF1Boptions.aic_metrics \u53EF\u663E\u5F0F\u9009\u62E9\u771F\u5B9E\u9A8C\u8BC1\u8FC7\u7684 msopprof metrics\uFF08Default/Roofline/MemoryDetail/Source/PipeTimeline/InstrTimeline/Occupancy\uFF09\u3002" }
+    },
+    timeoutMs: config.collectTimeoutMs > 0 ? config.collectTimeoutMs : 6e5,
+    output: {
+      schema: {
+        type: "object",
+        additionalProperties: true,
+        properties: {
+          run_id: { type: "string" },
+          report_id: { type: "string" },
+          source: { type: "string" },
+          mode: { type: "string" },
+          soc: { type: "string" },
+          artifact_dir: { type: "string" },
+          fallback_reason: { type: "string" },
+          summary: { type: "object", additionalProperties: true },
+          metrics_preview: { type: "object", additionalProperties: true },
+          verdict_hint: { type: "string" }
+        }
+      },
+      render: (_args, value) => [{
+        type: "text",
+        text: `\u91C7\u96C6\u5B8C\u6210\uFF08${String(value.source ?? "")}\uFF09\xB7 report ${String(value.report_id ?? "")}
+\u6307\u6807: ${JSON.stringify(value.metrics_preview)}
+\u4EA7\u7269: ${String(value.artifact_dir ?? "")}
+Bound \u5224\u5B9A\u8BF7\u8C03 verdict_judge\uFF08verdict_hint \u4EC5\u4E3A\u56FA\u5B9A\u63D0\u793A\u6587\u6848\uFF0C\u4E0D\u662F\u5224\u5B9A\uFF09\u3002`
+      }]
+    },
+    async execute(args, exec) {
+      const dir = await stateDir(ctx, config, exec);
+      const savedDoc = await readState(dir);
+      bindStateDoc(savedDoc);
+      const outcome = await collect(ctx, config, {
+        case_dir: args.case_dir,
+        mode: args.mode,
+        options: typeof args.options === "object" && args.options !== null ? args.options : void 0,
+        soc: args.soc,
+        label: args.label
+      }, exec);
+      await withState(exec, (doc) => {
+        upsertReport(doc, outcome.report);
+        upsertResult(doc, outcome.result);
+        applyCollectionConfigToState(
+          doc,
+          args.soc,
+          typeof args.options === "object" && args.options !== null ? args.options : void 0
+        );
+      });
+      const r = outcome.report;
+      const value = {
+        run_id: r.run_id,
+        report_id: r.report_id,
+        source: r.source,
+        mode: r.mode,
+        soc: r.soc,
+        artifact_dir: r.artifact_dir,
+        ...outcome.raw_artifact_dir !== void 0 ? { raw_artifact_dir: outcome.raw_artifact_dir } : {},
+        ...outcome.producer_version !== void 0 ? { producer_version: outcome.producer_version } : {},
+        ...outcome.profiling_diagnostics !== void 0 ? { profiling_diagnostics: outcome.profiling_diagnostics } : {},
+        ...outcome.fallback_reason !== void 0 ? { fallback_reason: outcome.fallback_reason } : {},
+        summary: r.summary,
+        metrics_preview: outcome.metrics_preview,
+        ...outcome.effective_options !== void 0 ? { effective_options: outcome.effective_options } : {},
+        files_found: outcome.files_found,
+        verdict_hint: "\u672A\u5224\u5B9A\uFF08\u9700 verdict_judge\uFF09"
+      };
+      return value;
+    }
+  }));
+  ctx.tools.register(defineTool({
+    name: "ops_import",
+    description: "\u5BFC\u5165\u4E00\u4E2A\u5DF2\u6709\u91C7\u96C6\u4EA7\u7269\u76EE\u5F55\uFF08msopprof OPPROF_* / msprof PROF_* / npu-compute \u89E3\u5305\u76EE\u5F55 / \u6A21\u62DF\u5668\u4EA7\u7269\uFF09\uFF0C\u6784\u5EFA\u62A5\u544A\u6A21\u578B\u8FDB\u5165\u5DE5\u4F5C\u53F0\uFF08\u5BF9\u6807\u300C\u6DFB\u52A0\u4E3A\u6027\u80FD\u8C03\u4F18\u53EF\u89C6\u5316\u89C6\u56FE\u300D\uFF09\u3002\u76EE\u5F55\u5F62\u6001\u81EA\u52A8\u5224\u6E90\uFF1Bmsprof PROF_ \u76EE\u5F55\uFF08op_summary \u542B Op Name \u5217\uFF09\u6309 Op Name \u53BB\u91CD\u679A\u4E3E\u591A\u7B97\u5B50\uFF0Ckernel_name \u672A\u6307\u5B9A\u65F6\u4E0D\u9884\u9009\uFF1B\u591A kernel CSV \u672A\u6307\u5B9A kernel_name \u65F6\u4E0D\u9884\u8FC7\u6EE4\uFF0C\u5BFC\u5165\u540E verdict_judge \u4F1A\u89E6\u53D1 G15 \u62A5\u9519\u5F15\u5BFC\u3002",
+    parameters: {
+      dir: { type: "string", required: true, description: "\u4EA7\u7269\u76EE\u5F55\uFF08\u7EDD\u5BF9\u6216\u5DE5\u4F5C\u533A\u76F8\u5BF9\u8DEF\u5F84\uFF09\u3002" },
+      label: { type: "string", description: "\u53EF\u9009\u6807\u7B7E\u3002" },
+      kernel_name: { type: "string", description: "\u591A kernel CSV \u8FC7\u6EE4\uFF08\u5199\u5165\u62A5\u544A\u6A21\u578B kernel_name \u5B57\u6BB5\uFF1Bverdict_judge \u7F3A\u7701\u627F\u63A5\uFF09\u3002" }
+    },
+    timeoutMs: 6e4,
+    output: {
+      schema: {
+        type: "object",
+        additionalProperties: true,
+        properties: {
+          run_id: { type: "string" },
+          report_id: { type: "string" },
+          source: { type: "string" },
+          files_found: { type: "array", items: { type: "string" } },
+          summary: { type: "object", additionalProperties: true },
+          metrics_preview: { type: "object", additionalProperties: true },
+          verdict_hint: { type: "string" }
+        }
+      },
+      render: (_args, value) => [{
+        type: "text",
+        text: `\u5BFC\u5165\u5B8C\u6210\uFF08${String(value.source ?? "")}\uFF09\xB7 report ${String(value.report_id ?? "")}
+\u53D1\u73B0\u4EA7\u7269: ${value.files_found.join(", ")}
+Bound \u5224\u5B9A\u8BF7\u8C03 verdict_judge\u3002`
+      }]
+    },
+    async execute(args, exec) {
+      const outcome = await importDirectory(ctx, config, {
+        dir: args.dir,
+        label: args.label,
+        kernel_name: args.kernel_name
+      });
+      await withState(exec, (doc) => {
+        upsertReport(doc, outcome.report);
+        upsertResult(doc, outcome.result);
+      });
+      return importedToolValue(outcome, args.dir);
+    }
+  }));
+  ctx.tools.register(defineTool({
+    name: "verdict_judge",
+    description: "\u5BF9\u6700\u65B0\uFF08\u6216\u6307\u5B9A\uFF09\u62A5\u544A\u8DD1 ops-verdict \u89C4\u5219\u5F15\u64CE\uFF08\u5206\u5C42\u7011\u5E03\uFF09\uFF0C\u8FD4\u56DE\u7ED3\u6784\u5316\u5224\u5B9A\u4E66\u3002\u8FD9\u662F Bound \u5224\u5B9A\u7684\u552F\u4E00\u6765\u6E90\uFF1B\u4F60\u53EA\u89E3\u91CA\u5224\u5B9A\u4E66\u4E2D\u7684\u8BC1\u636E\u6570\u503C\u3002\u89C4\u5219\u5305\u9ED8\u8BA4\u6309\u8F93\u5165\u8DEF\u7531\u8BC4\u4F30\u53EF\u8BC4\u4F30\u5C42\uFF1ACSV \u8F93\u5165 \u2192 L2,L1,L0 \u4E09\u5305\uFF1Bsoc=a5 \u4E14 scalar \u542B t_comm_us/t_compute_us \u7B49 MC\xB2 \u9694\u79BB\u6807\u91CF\u65F6\u8FFD\u52A0 L3\uFF1Bsoc/\u6307\u6807\u7F3A\u5931\u7684\u5C42\u7531\u5F15\u64CE\u4EE5 SKIPPED \u663E\u5F0F\u5448\u73B0\uFF08\u4E0D\u865A\u79F0\u56DB\u5C42\u5168\u8BC4\u4F30\uFF09\u3002\u591A kernel CSV \u672A\u6307\u5B9A kernel_name \u65F6 verdict.py G15 \u95E8\u7981 exit 4\uFF0C\u672C\u5DE5\u5177\u539F\u6837\u900F\u4F20\u62A5\u9519\u4E0E\u53EF\u7528 kernel \u6E05\u5355\uFF0C\u4E0D\u9759\u9ED8\u8DE8 kernel \u5E73\u5747\u3002verdictScript/python \u7F3A\u5931\u6216\u6267\u884C\u5931\u8D25\u65F6\u672C\u5DE5\u5177\u76F4\u63A5\u62A5\u9519\uFF08\u5224\u5B9A\u4E0D\u53EF\u6A21\u62DF\u3001\u4E0D\u964D\u7EA7\uFF09\u3002",
+    parameters: {
+      report_id: { type: "string", description: "\u62A5\u544A id\uFF1B\u9ED8\u8BA4\u6700\u65B0\u4E00\u6761\u3002" },
+      soc: { type: "string", enum: ["a2", "a3", "a5"], description: "SoC \u4EE3\u9645\uFF1B\u9ED8\u8BA4\u6309\u62A5\u544A\u6A21\u578B\u63A8\u5BFC\u3002" },
+      rules: { type: "string", description: "\u89C4\u5219\u5305\uFF08\u9017\u53F7\u5206\u9694\uFF0C\u9ED8\u8BA4\u6309\u8F93\u5165\u8DEF\u7531\uFF1AL2-inter-core.yaml,L1-single-core.yaml,L0-instruction.yaml\uFF09\u3002" },
+      scalar: { type: "string", description: "\u6807\u91CF\u6307\u6807 k=v,k=v \u900F\u4F20\uFF08\u5982 mte2_active_bw_pct_of_peak=82 \u6216 MC\xB2 \u7684 t_comm_us=420,t_compute_us=880\uFF09\u3002" },
+      kernel_name: { type: "string", description: "\u76EE\u6807 kernel\uFF1B\u7F3A\u7701\u53D6\u62A5\u544A\u6A21\u578B kernel_name \u5B57\u6BB5\uFF08ops_import \u53EF\u5199\u5165\uFF09\u3002" }
+    },
+    timeoutMs: 12e4,
+    output: {
+      schema: {
+        type: "object",
+        additionalProperties: true,
+        properties: {
+          schema: { type: "string" },
+          verdict: { type: "string" },
+          headline: { type: "string" },
+          findings: { type: "array", items: { type: "object", additionalProperties: true } },
+          skipped: { type: "array", items: { type: "object", additionalProperties: true } },
+          recommended_next: { type: "array", items: { type: "string" } }
+        }
+      },
+      render: (_args, value) => {
+        const v = value;
+        const lines = [`\u5224\u5B9A\u4E66 \xB7 ${String(v.verdict ?? "")} \u2014 ${String(v.headline ?? "")}`];
+        for (const f of v.findings ?? []) {
+          lines.push(`  HIT  [${String(f.severity)}/${String(f.confidence)}] ${String(f.rule_id)}: ${String(f.name)} (est ${String(f.speedup_range)})  evidence: ${JSON.stringify(f.evidence)}`);
+        }
+        return [{ type: "text", text: lines.join("\n") }];
+      }
+    },
+    async execute(args, exec) {
+      const dir = await skillDir();
+      const doc = await withState(exec, (d) => d);
+      const outcome = await runVerdict(ctx, config, dir, doc, {
+        report_id: args.report_id,
+        soc: args.soc,
+        rules: args.rules,
+        scalar: args.scalar,
+        kernel_name: args.kernel_name
+      }, wbRoot(), exec.signal);
+      await withState(exec, (d) => {
+        const report = d.reports[outcome.reportId];
+        if (report !== void 0) report.verdict = outcome.verdict;
+      });
+      return { ...outcome.fullVerdict, report_id: outcome.reportId };
+    }
+  }));
+  ctx.tools.register(defineTool({
+    name: "baseline_set",
+    description: "\u951A\u5B9A\u57FA\u7EBF\u62A5\u544A\uFF08report_id\uFF09\uFF0C\u6216\u5BF9\u6307\u5B9A\u62A5\u544A\u505A\u540C\u53E3\u5F84\u524D\u540E\u5BF9\u6BD4\uFF08compare_id + caliber\uFF09\u3002\u5BF9\u6BD4\u7ED3\u8BBA\u53EA\u51FA\u81EA snapshot.py/delta_compare.py\uFF08\u53E3\u5F84\u6307\u7EB9\u786C\u6821\u9A8C + \u7CBE\u5EA6\u95E8\u7981 + \u566A\u58F0\u5E26\u4E09\u6BB5\u7ED3\u8BBA\uFF09\uFF0C\u672C\u5DE5\u5177\u539F\u6837\u8FD4\u56DE\u811A\u672C\u6587\u672C\u4E0E\u9000\u51FA\u7801\u8BED\u4E49\uFF08exit 0=\u53EF\u6BD4 / 2=\u53E3\u5F84\u4E0D\u4E00\u81F4\u6216\u7CBE\u5EA6\u672A\u8FC7\u2014\u2014exit 2 \u662F\u811A\u672C\u7ED3\u8BBA\uFF0C\u4E0D\u662F\u5DE5\u5177\u5931\u8D25\uFF09\u3002caliber \u53E3\u5F84\u53C2\u6570\uFF08precision/shape/dtype/warmup/repeat/timing_method/baseline_kind \u5FC5\u586B\uFF09\u7531\u4F60\u4ECE\u8C03\u4F18\u4E0A\u4E0B\u6587\u63D0\u4F9B\uFF0C\u7F3A\u5931\u5373\u62A5\u9519\u5E76\u5217\u6E05\u5355\uFF1Bop/soc/mode/kernel_avg_us \u4ECE\u4E24\u4FA7\u62A5\u544A\u6A21\u578B\u81EA\u52A8\u53D6\u503C\uFF0CHost \u4E0D\u7F16\u9020\u53E3\u5F84\u3002",
+    parameters: {
+      report_id: { type: "string", description: "\u951A\u5B9A\uFF1A\u8981\u8BBE\u4E3A\u57FA\u7EBF\u7684\u62A5\u544A id\u3002\u5BF9\u6BD4\uFF1A\u57FA\u7EBF\u4FA7\u62A5\u544A id\uFF08\u9ED8\u8BA4 state.baseline_id\uFF09\u3002" },
+      compare_id: { type: "string", description: "\u5BF9\u6BD4\u6A21\u5F0F\uFF1A\u5F85\u5BF9\u6BD4\uFF08\u4F18\u5316\u540E\uFF09\u7684\u62A5\u544A id\u3002\u4F20\u6B64\u53C2\u5373\u8FDB\u5165\u5BF9\u6BD4\u6A21\u5F0F\u3002" },
+      caliber: {
+        type: "object",
+        additionalProperties: true,
+        description: '\u53E3\u5F84\u53C2\u6570\u5BF9\u8C61\uFF08\u5BF9\u6BD4\u6A21\u5F0F\u5FC5\u586B\uFF09\uFF1Aprecision:"pass"|"fail"\u3001shape\u3001dtype\u3001warmup:int\u3001repeat:int\u3001timing_method:"event"|"sim"|"msprof"|"msprof_task_duration"|"profiler_summary"\u3001baseline_kind:"system"|"self_before_after"\uFF1B\u53EF\u9009 cann_version/device_id/format/tiling_key/block_dim/kernel_p50_us/kernel_p95_us\u3002'
+      }
+    },
+    timeoutMs: 12e4,
+    output: {
+      schema: {
+        type: "object",
+        additionalProperties: true,
+        properties: {
+          baseline_id: { type: "string" },
+          comparison: {
+            type: "object",
+            additionalProperties: true,
+            properties: {
+              exit_code: { type: "integer" },
+              conclusion_text: { type: "string" },
+              action_text: { type: "string" },
+              speedup: { type: "number" },
+              hard_keys_ok: { type: "boolean" },
+              comparison_md_path: { type: "string" },
+              result_json_paths: { type: "array", items: { type: "string" } }
+            }
+          }
+        }
+      },
+      render: (_args, value) => {
+        const v = value;
+        if (v.comparison === void 0) {
+          return [{ type: "text", text: `\u57FA\u7EBF\u5DF2\u951A\u5B9A\uFF1A${v.baseline_id}` }];
+        }
+        const c = v.comparison;
+        return [{
+          type: "text",
+          text: `\u524D\u540E\u5BF9\u6BD4 \xB7 exit ${String(c.exit_code)}\uFF08${c.hard_keys_ok ? "\u53EF\u6BD4" : "\u53E3\u5F84\u4E0D\u4E00\u81F4\u6216\u7CBE\u5EA6\u672A\u8FC7"}\uFF09
+\u7ED3\u8BBA: ${c.conclusion_text}
+\u5904\u7F6E: ${c.action_text}
+comparison.md: ${c.comparison_md_path}` + (c.speedup === null ? "" : `
+speedup: ${String(c.speedup)}x`)
+        }];
+      }
+    },
+    async execute(args, exec) {
+      const dir = await skillDir();
+      const anchorId = args.report_id !== void 0 && args.report_id !== "" ? args.report_id : (await withState(exec, (d) => d)).baseline_id;
+      const input = {
+        report_id: args.compare_id === void 0 || args.compare_id === "" ? args.report_id : anchorId ?? args.report_id,
+        compare_id: args.compare_id,
+        caliber: args.caliber
+      };
+      const outcome = await runBaseline(ctx, config, dir, await withState(exec, (d) => d), input, wbRoot(), exec.signal);
+      await withState(exec, (d) => {
+        d.baseline_id = outcome.baseline_id;
+        if (outcome.comparison !== void 0) {
+          const report = d.reports[args.compare_id];
+          if (report !== void 0) report.comparison = outcome.comparison;
+        }
+      });
+      const value = {
+        baseline_id: outcome.baseline_id,
+        ...outcome.comparison !== void 0 ? { comparison: outcome.comparison } : {}
+      };
+      return value;
+    }
+  }));
+  ctx.tools.register(defineTool({
+    name: "tuning_skill",
+    description: "\u8FD4\u56DE\u5F53\u524D\u751F\u6548\u7684\u8C03\u4F18\u6280\u80FD\u88C5\u8F7D\u4FE1\u606F\uFF08\u540D\u79F0/\u8DEF\u5F84/SKILL.md \u5165\u53E3/\u4E94\u5B50\u57DF/Agent \u7F16\u6392\u5C42/\u89E6\u53D1\u8BCD/\u914D\u7F6E\u56DE\u663E\uFF09\uFF0C\u5E76\u8BF4\u660E\u5982\u4F55\u6309\u6280\u80FD\u6D41\u7A0B\u6267\u884C\u6700\u5C0F\u8C03\u4F18\u73AF\uFF08fixture \u2192 \u91C7\u96C6/\u5BFC\u5165 \u2192 verdict \u5224\u5B9A \u2192 \u673A\u5236\u8DEF\u7531 \u2192 \u5019\u9009\u65B9\u6848\uFF09\u3002\u672C\u5DE5\u5177\u53EA\u505A\u72B6\u6001\u8BF4\u660E\u4E0E\u8DEF\u7531\u6307\u5F15\uFF0C\u4E0D\u6267\u884C\u5224\u5B9A\uFF1B\u771F\u6B63\u7684\u6280\u80FD\u547D\u4E2D\u8D70 dsh \u539F\u751F skill \u5DE5\u5177\u3002",
+    parameters: {
+      action: { type: "string", enum: ["status"], description: "\u56FA\u5B9A\u4E3A status\uFF08\u9ED8\u8BA4\uFF09\u3002" }
+    },
+    timeoutMs: 1e4,
+    output: {
+      schema: {
+        type: "object",
+        additionalProperties: true,
+        properties: {
+          skill_name: { type: "string" },
+          skill_dir: { type: "string" },
+          entry: { type: "string" },
+          subdomains: { type: "array", items: { type: "string" } },
+          agent_layer: { type: "string" },
+          triggers: { type: "array", items: { type: "string" } },
+          config: { type: "object", additionalProperties: true }
+        }
+      },
+      render: (_args, value) => [{
+        type: "text",
+        text: `\u8C03\u4F18\u6280\u80FD\uFF1A${String(value.skill_name)} @ ${String(value.skill_dir)}
+\u5B50\u57DF: ${value.subdomains.join(" / ")}
+\u89E6\u53D1\u8BCD: ${value.triggers.join("\u3001")}
+\u5224\u5B9A\u7EAA\u5F8B\uFF1ABound \u5224\u5B9A\u53EA\u51FA\u81EA verdict_judge\uFF08ops-verdict \u5F15\u64CE\uFF09\u3002`
+      }]
+    },
+    async execute(_args, _exec) {
+      const resolved = await skillPromise;
+      return resolved.status;
+    }
+  }));
+}
+export {
+  apply,
+  inject,
+  name
+};