skilltest 0.5.0 → 0.7.0

package/dist/index.js

@@ -1,11 +1,15 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import fs7 from "node:fs";
+import fs11 from "node:fs";
 import path6 from "node:path";
 import { fileURLToPath } from "node:url";
 import { Command } from "commander";
 
+// src/commands/lint.ts
+import fs6 from "node:fs/promises";
+import { z as z6 } from "zod";
+
 // src/core/skill-parser.ts
 import fs from "node:fs/promises";
 import path from "node:path";
@@ -577,24 +581,6 @@ function runContentChecks(context) {
       message: "No obvious vague placeholder phrasing found."
     });
   }
-  if (context.frontmatter.rawFrontmatter && /[<>]/.test(context.frontmatter.rawFrontmatter)) {
-    issues.push({
-      id: "content.frontmatter-angle-brackets",
-      checkId: "content:angle-brackets",
-      title: "Frontmatter Angle Brackets",
-      status: "warn",
-      message: "Frontmatter contains angle bracket characters (< or >), which can be misinterpreted in some agents.",
-      suggestion: "Remove XML-like tags from frontmatter values when possible."
-    });
-  } else {
-    issues.push({
-      id: "content.frontmatter-angle-brackets",
-      checkId: "content:angle-brackets",
-      title: "Frontmatter Angle Brackets",
-      status: "pass",
-      message: "No angle bracket tokens detected in frontmatter."
-    });
-  }
   const secretsIssue = buildSecretsIssue(context);
   if (secretsIssue) {
     issues.push(secretsIssue);
@@ -947,6 +933,24 @@ function runFrontmatterChecks(context) {
       message: "license field is present."
     });
   }
+  if (context.frontmatter.rawFrontmatter && /[<>]/.test(context.frontmatter.rawFrontmatter)) {
+    issues.push({
+      id: "frontmatter.angle-brackets",
+      checkId: "frontmatter:angle-brackets",
+      title: "Frontmatter Angle Brackets",
+      status: "warn",
+      message: "Frontmatter contains angle bracket characters (< or >), which can be misinterpreted in some agents.",
+      suggestion: "Remove XML-like tags from frontmatter values when possible."
+    });
+  } else {
+    issues.push({
+      id: "frontmatter.angle-brackets",
+      checkId: "frontmatter:angle-brackets",
+      title: "Frontmatter Angle Brackets",
+      status: "pass",
+      message: "No angle bracket tokens detected in frontmatter."
+    });
+  }
   if (description && description.trim() !== "" && !descriptionLooksActionable(description)) {
     issues.push({
       id: "frontmatter.description.triggerability",
@@ -1366,6 +1370,739 @@ async function runLinter(inputPath, options = {}) {
   };
 }
 
+// src/reporters/html.ts
+function escapeHtml(value) {
+  return String(value ?? "").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function formatPercent(value) {
+  return `${(value * 100).toFixed(1)}%`;
+}
+function formatLineRange(startLine, endLine) {
+  if (startLine === void 0) {
+    return null;
+  }
+  if (endLine === void 0 || endLine === startLine) {
+    return `line ${startLine}`;
+  }
+  return `lines ${startLine}-${endLine}`;
+}
+function badgeLabel(status) {
+  if (status === "pass") {
+    return "PASS";
+  }
+  if (status === "warn") {
+    return "WARN";
+  }
+  if (status === "fail") {
+    return "FAIL";
+  }
+  return "SKIP";
+}
+function renderBadge(status) {
+  return `<span class="badge ${status}">${badgeLabel(status)}</span>`;
+}
+function renderStatCards(stats) {
+  return `<div class="stats-grid">${stats.map(
+    (stat) => `
+        <div class="stat-card${stat.status ? ` status-${stat.status}` : ""}">
+          <div class="stat-label">${escapeHtml(stat.label)}</div>
+          <div class="stat-value">${escapeHtml(stat.value)}</div>
+          ${stat.note ? `<div class="stat-note">${escapeHtml(stat.note)}</div>` : ""}
+        </div>
+      `
+  ).join("")}</div>`;
+}
+function renderMetaItems(items) {
+  if (items.length === 0) {
+    return "";
+  }
+  return `<div class="meta-grid">${items.map(
+    (item) => `
+        <div class="meta-item">
+          <span class="meta-label">${escapeHtml(item.label)}</span>
+          <span class="meta-value">${escapeHtml(item.value)}</span>
+        </div>
+      `
+  ).join("")}</div>`;
+}
+function renderHeaderCard(commandName, heading, target, stats, metaItems) {
+  return `
+    <section class="card header-card">
+      <div class="eyebrow">skilltest ${escapeHtml(commandName)}</div>
+      <h1>${escapeHtml(heading)}</h1>
+      <div class="target-line">target: ${escapeHtml(target)}</div>
+      ${renderMetaItems(metaItems)}
+      ${renderStatCards(stats)}
+    </section>
+  `;
+}
+function renderSectionCard(title, body) {
+  return `
+    <section class="card">
+      <h2>${escapeHtml(title)}</h2>
+      ${body}
+    </section>
+  `;
+}
+function renderMessageRow(status, title, message, details) {
+  return `
+    <div class="row">
+      <div class="row-header">
+        <div class="row-title">${escapeHtml(title)}</div>
+        ${renderBadge(status)}
+      </div>
+      <div class="row-body">${escapeHtml(message)}</div>
+      ${details ?? ""}
+    </div>
+  `;
+}
+function renderDetails(summary, content) {
+  return `
+    <details class="detail-block">
+      <summary>${escapeHtml(summary)}</summary>
+      <div class="detail-content">${content}</div>
+    </details>
+  `;
+}
+function renderPreBlock(content) {
+  return `<pre>${escapeHtml(content)}</pre>`;
+}
+function renderDefinitionList(items) {
+  return `<div class="definition-list">${items.map(
+    (item) => `
+        <div class="definition-item">
+          <div class="definition-label">${escapeHtml(item.label)}</div>
+          <div class="definition-value">${escapeHtml(item.value)}</div>
+        </div>
+      `
+  ).join("")}</div>`;
+}
+function countSkippedSecurityPatterns(issues) {
+  return issues.reduce((total, issue) => total + (issue.skippedPatterns?.length ?? 0), 0);
+}
+function renderLintIssueRow(issue) {
+  const lineRange = formatLineRange(issue.startLine, issue.endLine);
+  const detailBlocks = [];
+  if (issue.suggestion) {
+    detailBlocks.push(renderDetails("Suggestion", `<p>${escapeHtml(issue.suggestion)}</p>`));
+  }
+  if (issue.skippedPatterns && issue.skippedPatterns.length > 0) {
+    const patternItems = issue.skippedPatterns.map(
+      (pattern) => `
+          <div class="definition-item">
+            <div class="definition-label">${escapeHtml(pattern.label)}</div>
+            <div class="definition-value">${escapeHtml(
+        `${pattern.zoneType} lines ${pattern.startLine}-${pattern.endLine}`
+      )}</div>
+          </div>
+        `
+    ).join("");
+    detailBlocks.push(renderDetails("Skipped security patterns", `<div class="definition-list">${patternItems}</div>`));
+  }
+  return `
+    <div class="row">
+      <div class="row-header">
+        <div>
+          <div class="row-title">${escapeHtml(issue.title)}</div>
+          <div class="row-subtitle">${escapeHtml(issue.checkId)}</div>
+        </div>
+        ${renderBadge(issue.status)}
+      </div>
+      <div class="row-body">${escapeHtml(issue.message)}</div>
+      ${renderDefinitionList(
+    [
+      lineRange ? { label: "Location", value: lineRange } : null,
+      { label: "Check ID", value: issue.checkId }
+    ].filter((item) => item !== null)
+  )}
+      ${detailBlocks.join("")}
+    </div>
+  `;
+}
+function renderLintIssueList(report) {
+  const skippedSecurityPatterns = countSkippedSecurityPatterns(report.issues);
+  const rows = report.issues.map((issue) => renderLintIssueRow(issue)).join("");
+  const info = skippedSecurityPatterns > 0 ? `<p class="info-line">Skipped security patterns in examples/comments: ${escapeHtml(skippedSecurityPatterns)}</p>` : "";
+  return `<div class="row-list">${rows}</div>${info}`;
+}
+function renderTriggerCaseRow(testCase) {
+  const details = testCase.rawModelResponse ? renderDetails("Model response", renderPreBlock(testCase.rawModelResponse)) : "";
+  return `
+    <div class="row">
+      <div class="row-header">
+        <div>
+          <div class="row-title">${escapeHtml(testCase.query)}</div>
+          <div class="row-subtitle">${escapeHtml(
+    `expected=${testCase.expected} actual=${testCase.actual} should_trigger=${String(testCase.shouldTrigger)}`
+  )}</div>
+        </div>
+        ${renderBadge(testCase.matched ? "pass" : "fail")}
+      </div>
+      ${renderDefinitionList([
+    { label: "Expected", value: testCase.expected },
+    { label: "Actual", value: testCase.actual }
+  ])}
+      ${details}
+    </div>
+  `;
+}
+function promptStatus(promptResult) {
+  if (promptResult.totalAssertions === 0) {
+    return "skip";
+  }
+  if (promptResult.passedAssertions === promptResult.totalAssertions) {
+    return "pass";
+  }
+  if (promptResult.passedAssertions === 0) {
+    return "fail";
+  }
+  return "warn";
+}
+function renderAssertionRow(assertion) {
+  return renderDetails(
+    `${badgeLabel(assertion.passed ? "pass" : "fail")} ${assertion.assertion}`,
+    renderPreBlock(assertion.evidence)
+  );
+}
+function renderEvalPromptRow(promptResult) {
+  const assertionDetails = promptResult.assertions.map((assertion) => renderAssertionRow(assertion)).join("");
+  const responseDetails = renderDetails("Full model response", renderPreBlock(promptResult.response));
+  return `
+    <div class="row">
+      <div class="row-header">
+        <div>
+          <div class="row-title">${escapeHtml(promptResult.prompt)}</div>
+          <div class="row-subtitle">${escapeHtml(
+    `${promptResult.passedAssertions}/${promptResult.totalAssertions} assertions passed`
+  )}</div>
+        </div>
+        ${renderBadge(promptStatus(promptResult))}
+      </div>
+      <div class="row-body">${escapeHtml(promptResult.responseSummary)}</div>
+      ${renderDefinitionList([
+    { label: "Passed assertions", value: String(promptResult.passedAssertions) },
+    { label: "Total assertions", value: String(promptResult.totalAssertions) }
+  ])}
+      ${renderDetails("Assertion evidence", assertionDetails || `<p>No assertions.</p>`)}
+      ${responseDetails}
+    </div>
+  `;
+}
+function gateStatus(value) {
+  if (value === null) {
+    return "skip";
+  }
+  return value ? "pass" : "fail";
+}
+function renderGateCard(title, status, message) {
+  return `
+    <div class="gate-card">
+      <div class="row-header">
+        <div class="row-title">${escapeHtml(title)}</div>
+        ${renderBadge(status)}
+      </div>
+      <div class="row-body">${escapeHtml(message)}</div>
+    </div>
+  `;
+}
+function renderCollapsibleSection(title, summary, body, status) {
+  return `
+    <details class="section-card" open>
+      <summary>
+        <span class="section-title">${escapeHtml(title)}</span>
+        <span class="section-summary">${renderBadge(status)} ${escapeHtml(summary)}</span>
+      </summary>
+      <div class="section-body">${body}</div>
+    </details>
+  `;
+}
+function resolveOptionalTarget(result, fallback) {
+  return result.target ?? fallback;
+}
+function renderHtmlDocument(title, body) {
+  return `<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title>${escapeHtml(title)}</title>
+    <style>
+      :root {
+        color-scheme: light;
+        --bg: #f5f5f5;
+        --surface: #ffffff;
+        --surface-muted: #fafafa;
+        --border: #d4d4d8;
+        --text: #111827;
+        --muted: #6b7280;
+        --pass: #22c55e;
+        --warn: #eab308;
+        --fail: #ef4444;
+        --skip: #6b7280;
+        --shadow: 0 10px 30px rgba(15, 23, 42, 0.08);
+      }
+
+      * {
+        box-sizing: border-box;
+      }
+
+      body {
+        margin: 0;
+        background: linear-gradient(180deg, #fafafa 0%, #f4f4f5 100%);
+        color: var(--text);
+        font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;
+        line-height: 1.5;
+      }
+
+      .container {
+        max-width: 1120px;
+        margin: 0 auto;
+        padding: 24px 16px 40px;
+      }
+
+      .card,
+      .section-card {
+        background: var(--surface);
+        border: 1px solid var(--border);
+        border-radius: 16px;
+        box-shadow: var(--shadow);
+        margin-bottom: 16px;
+      }
+
+      .card {
+        padding: 20px;
+      }
+
+      .header-card h1,
+      .card h2 {
+        margin: 0 0 10px;
+        font-size: 1.25rem;
+      }
+
+      .eyebrow {
+        margin-bottom: 10px;
+        color: var(--muted);
+        font-size: 0.78rem;
+        letter-spacing: 0.08em;
+        text-transform: uppercase;
+      }
+
+      .target-line,
+      .info-line {
+        color: var(--muted);
+        overflow-wrap: anywhere;
+      }
+
+      .meta-grid,
+      .stats-grid,
+      .gate-grid,
+      .definition-list {
+        display: grid;
+        gap: 12px;
+      }
+
+      .meta-grid,
+      .gate-grid,
+      .definition-list {
+        grid-template-columns: repeat(auto-fit, minmax(220px, 1fr));
+      }
+
+      .stats-grid {
+        grid-template-columns: repeat(auto-fit, minmax(140px, 1fr));
+        margin-top: 16px;
+      }
+
+      .meta-grid {
+        margin-top: 14px;
+      }
+
+      .meta-item,
+      .definition-item,
+      .stat-card,
+      .gate-card {
+        background: var(--surface-muted);
+        border: 1px solid var(--border);
+        border-radius: 12px;
+        padding: 12px;
+      }
+
+      .meta-item,
+      .definition-item {
+        display: flex;
+        justify-content: space-between;
+        gap: 12px;
+      }
+
+      .meta-label,
+      .definition-label,
+      .stat-label {
+        color: var(--muted);
+        font-size: 0.82rem;
+      }
+
+      .meta-value,
+      .definition-value {
+        text-align: right;
+        overflow-wrap: anywhere;
+      }
+
+      .stat-value {
+        margin-top: 4px;
+        font-size: 1.3rem;
+        font-weight: 700;
+      }
+
+      .stat-note {
+        margin-top: 6px;
+        color: var(--muted);
+        font-size: 0.82rem;
+      }
+
+      .status-pass {
+        border-color: rgba(34, 197, 94, 0.35);
+      }
+
+      .status-warn {
+        border-color: rgba(234, 179, 8, 0.35);
+      }
+
+      .status-fail {
+        border-color: rgba(239, 68, 68, 0.35);
+      }
+
+      .status-skip {
+        border-color: rgba(107, 114, 128, 0.35);
+      }
+
+      .row-list {
+        display: grid;
+        gap: 12px;
+      }
+
+      .row {
+        border: 1px solid var(--border);
+        border-radius: 12px;
+        padding: 14px;
+        background: var(--surface-muted);
+      }
+
+      .row-header {
+        display: flex;
+        justify-content: space-between;
+        align-items: flex-start;
+        gap: 12px;
+      }
+
+      .row-title {
+        font-weight: 700;
+        overflow-wrap: anywhere;
+      }
+
+      .row-subtitle {
+        margin-top: 4px;
+        color: var(--muted);
+        font-size: 0.84rem;
+        overflow-wrap: anywhere;
+      }
+
+      .row-body {
+        margin-top: 10px;
+        overflow-wrap: anywhere;
+      }
+
+      .badge {
+        display: inline-flex;
+        align-items: center;
+        justify-content: center;
+        min-width: 58px;
+        padding: 3px 10px;
+        border-radius: 999px;
+        border: 1px solid currentColor;
+        font-size: 0.76rem;
+        font-weight: 700;
+        letter-spacing: 0.04em;
+        white-space: nowrap;
+      }
+
+      .badge.pass {
+        color: #15803d;
+        background: rgba(34, 197, 94, 0.14);
+      }
+
+      .badge.warn {
+        color: #a16207;
+        background: rgba(234, 179, 8, 0.18);
+      }
+
+      .badge.fail {
+        color: #b91c1c;
+        background: rgba(239, 68, 68, 0.14);
+      }
+
+      .badge.skip {
+        color: #4b5563;
+        background: rgba(107, 114, 128, 0.14);
+      }
+
+      details {
+        margin-top: 10px;
+      }
+
+      details summary {
+        cursor: pointer;
+        color: var(--muted);
+      }
+
+      .detail-block {
+        border-top: 1px dashed var(--border);
+        padding-top: 10px;
+      }
+
+      .detail-content p {
+        margin: 0;
+      }
+
+      .section-card summary {
+        display: flex;
+        justify-content: space-between;
+        align-items: center;
+        gap: 12px;
+        padding: 18px 20px;
+        list-style: none;
+      }
+
+      .section-card summary::-webkit-details-marker {
+        display: none;
+      }
+
+      .section-title {
+        font-size: 1rem;
+        font-weight: 700;
+        color: var(--text);
+      }
+
+      .section-summary {
+        display: inline-flex;
+        align-items: center;
+        gap: 8px;
+        color: var(--muted);
+        text-align: right;
+      }
+
+      .section-body {
+        padding: 0 20px 20px;
+      }
+
+      .gate-grid {
+        margin-top: 12px;
+      }
+
+      pre {
+        margin: 0;
+        padding: 12px;
+        background: #f8fafc;
+        border: 1px solid var(--border);
+        border-radius: 10px;
+        white-space: pre-wrap;
+        word-break: break-word;
+        overflow-wrap: anywhere;
+      }
+
+      ul {
+        margin: 0;
+        padding-left: 20px;
+      }
+
+      @media (max-width: 720px) {
+        .container {
+          padding: 16px 12px 28px;
+        }
+
+        .row-header,
+        .section-card summary,
+        .meta-item,
+        .definition-item {
+          flex-direction: column;
+          align-items: flex-start;
+        }
+
+        .meta-value,
+        .definition-value,
+        .section-summary {
+          text-align: left;
+        }
+      }
+    </style>
+  </head>
+  <body>
+    <main class="container">
+      ${body}
+    </main>
+  </body>
+</html>`;
+}
+function renderLintHtml(report) {
+  const passRate = report.summary.total === 0 ? 0 : report.summary.passed / report.summary.total;
+  const body = [
+    renderHeaderCard(
+      "lint",
+      "Static Analysis Report",
+      report.target,
+      [
+        { label: "Pass rate", value: formatPercent(passRate), note: `${report.summary.passed}/${report.summary.total} passed` },
+        { label: "Warnings", value: String(report.summary.warnings), status: report.summary.warnings > 0 ? "warn" : "pass" },
+        { label: "Failures", value: String(report.summary.failures), status: report.summary.failures > 0 ? "fail" : "pass" },
+        { label: "Checks", value: String(report.summary.total) }
+      ],
+      [{ label: "Target", value: report.target }]
+    ),
+    renderSectionCard("Lint Issues", renderLintIssueList(report))
+  ].join("");
+  return renderHtmlDocument(`skilltest lint - ${report.target}`, body);
+}
+function renderTriggerHtml(result) {
+  const htmlResult = result;
+  const target = resolveOptionalTarget(htmlResult, result.skillName);
+  const matchedCount = result.cases.filter((testCase) => testCase.matched).length;
+  const matchRate = result.cases.length === 0 ? 0 : matchedCount / result.cases.length;
+  const body = [
+    renderHeaderCard(
+      "trigger",
+      result.skillName,
+      target,
+      [
+        { label: "Match rate", value: formatPercent(matchRate), note: `${matchedCount}/${result.cases.length} matched` },
+        { label: "Precision", value: formatPercent(result.metrics.precision) },
+        { label: "Recall", value: formatPercent(result.metrics.recall) },
+        { label: "F1", value: formatPercent(result.metrics.f1), status: result.metrics.f1 >= 0.8 ? "pass" : "warn" }
+      ],
+      [
+        { label: "Provider", value: result.provider },
+        { label: "Model", value: result.model },
+        { label: "Seed", value: result.seed !== void 0 ? String(result.seed) : "none" },
+        { label: "Queries", value: String(result.queries.length) }
+      ]
+    ),
+    renderSectionCard("Trigger Cases", `<div class="row-list">${result.cases.map((testCase) => renderTriggerCaseRow(testCase)).join("")}</div>`),
+    renderSectionCard(
+      "Suggestions",
+      `<ul>${result.suggestions.map((suggestion) => `<li>${escapeHtml(suggestion)}</li>`).join("")}</ul>`
+    )
+  ].join("");
+  return renderHtmlDocument(`skilltest trigger - ${result.skillName}`, body);
+}
+function renderEvalHtml(result) {
+  const htmlResult = result;
+  const target = resolveOptionalTarget(htmlResult, result.skillName);
+  const passRate = result.summary.totalAssertions === 0 ? 0 : result.summary.passedAssertions / result.summary.totalAssertions;
+  const body = [
+    renderHeaderCard(
+      "eval",
+      result.skillName,
+      target,
+      [
+        {
+          label: "Assertion pass rate",
+          value: formatPercent(passRate),
+          note: `${result.summary.passedAssertions}/${result.summary.totalAssertions} passed`
+        },
+        { label: "Prompts", value: String(result.summary.totalPrompts) },
+        { label: "Model", value: result.model },
+        { label: "Grader", value: result.graderModel }
+      ],
+      [
+        { label: "Provider", value: result.provider },
+        { label: "Execution model", value: result.model },
+        { label: "Grader model", value: result.graderModel },
+        { label: "Prompts", value: String(result.prompts.length) }
+      ]
+    ),
+    renderSectionCard("Eval Prompts", `<div class="row-list">${result.results.map((promptResult) => renderEvalPromptRow(promptResult)).join("")}</div>`)
+  ].join("");
+  return renderHtmlDocument(`skilltest eval - ${result.skillName}`, body);
+}
+function renderCheckHtml(result) {
+  const skillName = result.trigger?.skillName ?? result.eval?.skillName ?? result.target;
+  const triggerBody = result.trigger ? `<div class="row-list">${result.trigger.cases.map((testCase) => renderTriggerCaseRow(testCase)).join("")}</div>
+       <div class="card" style="margin-top: 16px;">
+         <h2>Trigger Suggestions</h2>
+         <ul>${result.trigger.suggestions.map((suggestion) => `<li>${escapeHtml(suggestion)}</li>`).join("")}</ul>
+       </div>` : renderMessageRow("skip", "Trigger skipped", result.triggerSkippedReason ?? "Skipped.");
+  const evalBody = result.eval ? `<div class="row-list">${result.eval.results.map((promptResult) => renderEvalPromptRow(promptResult)).join("")}</div>` : renderMessageRow("skip", "Eval skipped", result.evalSkippedReason ?? "Skipped.");
+  const lintStatus = result.gates.lintPassed ? "pass" : "fail";
+  const triggerStatus = gateStatus(result.gates.triggerPassed);
+  const evalStatus = gateStatus(result.gates.evalPassed);
+  const overallStatus = result.gates.overallPassed ? "pass" : "fail";
+  const header = renderHeaderCard(
+    "check",
+    skillName,
+    result.target,
+    [
+      { label: "Overall gate", value: badgeLabel(overallStatus), status: overallStatus },
+      {
+        label: "Trigger F1",
+        value: result.gates.triggerF1 !== null ? formatPercent(result.gates.triggerF1) : "skipped",
+        status: triggerStatus
+      },
+      {
+        label: "Eval pass rate",
+        value: result.gates.evalAssertPassRate !== null ? formatPercent(result.gates.evalAssertPassRate) : "skipped",
+        status: evalStatus
+      },
+      {
+        label: "Lint result",
+        value: `${result.lint.summary.failures} fail / ${result.lint.summary.warnings} warn`,
+        status: lintStatus
+      }
+    ],
+    [
+      { label: "Provider", value: result.provider },
+      { label: "Model", value: result.model },
+      { label: "Grader model", value: result.graderModel },
+      {
+        label: "Thresholds",
+        value: `min-f1=${result.thresholds.minF1.toFixed(2)} min-assert-pass-rate=${result.thresholds.minAssertPassRate.toFixed(2)}`
+      }
+    ]
+  );
+  const lintSection = renderCollapsibleSection(
+    "Lint",
+    `${result.lint.summary.passed}/${result.lint.summary.total} passed, ${result.lint.summary.warnings} warnings, ${result.lint.summary.failures} failures`,
+    renderLintIssueList(result.lint),
+    lintStatus
+  );
+  const triggerSection = renderCollapsibleSection(
+    "Trigger",
+    result.trigger ? `f1=${formatPercent(result.trigger.metrics.f1)} precision=${formatPercent(result.trigger.metrics.precision)} recall=${formatPercent(result.trigger.metrics.recall)}` : result.triggerSkippedReason ?? "Skipped.",
+    triggerBody,
+    triggerStatus
+  );
+  const evalSection = renderCollapsibleSection(
+    "Eval",
+    result.eval ? `assertion pass rate=${formatPercent(result.gates.evalAssertPassRate ?? 0)} (${result.eval.summary.passedAssertions}/${result.eval.summary.totalAssertions})` : result.evalSkippedReason ?? "Skipped.",
+    evalBody,
+    evalStatus
+  );
+  const qualityGate = renderSectionCard(
+    "Quality Gate",
+    `<div class="gate-grid">
+      ${renderGateCard("Lint gate", lintStatus, result.gates.lintPassed ? "Lint passed." : "Lint failed.")}
+      ${renderGateCard(
+      "Trigger gate",
+      triggerStatus,
+      result.gates.triggerPassed === null ? result.triggerSkippedReason ?? "Skipped." : `required ${result.thresholds.minF1.toFixed(2)}, actual ${result.gates.triggerF1?.toFixed(2) ?? "n/a"}`
+    )}
+      ${renderGateCard(
+      "Eval gate",
+      evalStatus,
+      result.gates.evalPassed === null ? result.evalSkippedReason ?? "Skipped." : `required ${result.thresholds.minAssertPassRate.toFixed(2)}, actual ${result.gates.evalAssertPassRate?.toFixed(2) ?? "n/a"}`
+    )}
+      ${renderGateCard("Overall", overallStatus, result.gates.overallPassed ? "All quality gates passed." : "One or more gates failed.")}
+    </div>`
+  );
+  return renderHtmlDocument(`skilltest check - ${skillName}`, [header, lintSection, triggerSection, evalSection, qualityGate].join(""));
+}
+
 // src/reporters/terminal.ts
 import { Chalk } from "chalk";
 function getChalkInstance(enableColor) {
@@ -1378,7 +2115,7 @@ function renderIssueLine(issue, c) {
   return `  ${label} ${issue.title}
       ${issue.message}${detail}`;
 }
-function countSkippedSecurityPatterns(issues) {
+function countSkippedSecurityPatterns2(issues) {
   return issues.reduce((total, issue) => {
     if (!issue.checkId.startsWith("security:")) {
       return total;
@@ -1398,13 +2135,13 @@ function renderLintReport(report, enableColor) {
     `\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518`
   ];
   const renderedIssues = report.issues.map((issue) => renderIssueLine(issue, c)).join("\n");
-  const skippedSecurityPatterns = countSkippedSecurityPatterns(report.issues);
+  const skippedSecurityPatterns = countSkippedSecurityPatterns2(report.issues);
   const infoLine = skippedSecurityPatterns > 0 ? `
   ${c.cyan("\u2139")} ${skippedSecurityPatterns} security pattern(s) found in code examples/comments (not flagged)` : "";
   return `${headerLines.join("\n")}
 ${renderedIssues}${infoLine}`;
 }
-function formatPercent(value) {
+function formatPercent2(value) {
   return `${(value * 100).toFixed(1)}%`;
 }
 function renderTriggerReport(result, enableColor, verbose) {
@@ -1416,7 +2153,7 @@ function renderTriggerReport(result, enableColor, verbose) {
   lines.push(`\u2502 skill: ${result.skillName}`);
   lines.push(`\u2502 provider/model: ${result.provider}/${result.model}`);
   lines.push(
-    `\u2502 precision: ${formatPercent(result.metrics.precision)}  recall: ${formatPercent(result.metrics.recall)}  f1: ${formatPercent(result.metrics.f1)}`
+    `\u2502 precision: ${formatPercent2(result.metrics.precision)}  recall: ${formatPercent2(result.metrics.recall)}  f1: ${formatPercent2(result.metrics.f1)}`
   );
   lines.push(
     `\u2502 TP ${result.metrics.truePositives}  TN ${result.metrics.trueNegatives}  FP ${result.metrics.falsePositives}  FN ${result.metrics.falseNegatives}`
@@ -1490,7 +2227,7 @@ function renderCheckReport(result, enableColor, verbose) {
   for (const issue of lintIssues) {
     lines.push(renderIssueLine(issue, c));
   }
-  const skippedSecurityPatterns = countSkippedSecurityPatterns(result.lint.issues);
+  const skippedSecurityPatterns = countSkippedSecurityPatterns2(result.lint.issues);
   if (skippedSecurityPatterns > 0) {
     lines.push(`  ${c.cyan("\u2139")} ${skippedSecurityPatterns} security pattern(s) found in code examples/comments (not flagged)`);
   }
@@ -1498,7 +2235,7 @@ function renderCheckReport(result, enableColor, verbose) {
   lines.push("Trigger");
   if (result.trigger) {
     lines.push(
-      `- ${triggerGate} f1=${formatPercent(result.trigger.metrics.f1)} (precision=${formatPercent(result.trigger.metrics.precision)} recall=${formatPercent(result.trigger.metrics.recall)})`
+      `- ${triggerGate} f1=${formatPercent2(result.trigger.metrics.f1)} (precision=${formatPercent2(result.trigger.metrics.precision)} recall=${formatPercent2(result.trigger.metrics.recall)})`
     );
     lines.push(
       `  TP ${result.trigger.metrics.truePositives} TN ${result.trigger.metrics.trueNegatives} FP ${result.trigger.metrics.falsePositives} FN ${result.trigger.metrics.falseNegatives}`
@@ -1517,7 +2254,7 @@ function renderCheckReport(result, enableColor, verbose) {
   if (result.eval) {
     const passRate = result.gates.evalAssertPassRate ?? 0;
     lines.push(
-      `- ${evalGate} assertion pass rate=${formatPercent(passRate)} (${result.eval.summary.passedAssertions}/${result.eval.summary.totalAssertions})`
+      `- ${evalGate} assertion pass rate=${formatPercent2(passRate)} (${result.eval.summary.passedAssertions}/${result.eval.summary.totalAssertions})`
     );
     for (const promptResult of result.eval.results) {
       const failedAssertions = promptResult.assertions.filter((assertion) => !assertion.passed);
@@ -1577,12 +2314,13 @@ function extractJsonObject(raw) {
   }
   throw new Error("Grader did not return a JSON object.");
 }
-async function gradeResponse(options) {
-  const assertionList = options.assertions && options.assertions.length > 0 ? options.assertions : [
-    "The response follows the skill instructions faithfully.",
-    "The response is well-structured and actionable.",
-    "The response addresses the user prompt directly."
-  ];
+var DEFAULT_ASSERTIONS = [
+  "The response follows the skill instructions faithfully.",
+  "The response is well-structured and actionable.",
+  "The response addresses the user prompt directly."
+];
+function buildGraderPrompts(options) {
+  const assertions = options.assertions && options.assertions.length > 0 ? options.assertions : DEFAULT_ASSERTIONS;
   const systemPrompt = [
     "You are a strict evaluator for agent skill outputs.",
     "Assess each assertion and return JSON only.",
@@ -1599,15 +2337,78 @@ async function gradeResponse(options) {
     options.modelResponse,
     "",
     "Assertions to evaluate:",
-    assertionList.map((assertion, index) => `${index + 1}. ${assertion}`).join("\n")
+    assertions.map((assertion, index) => `${index + 1}. ${assertion}`).join("\n")
   ].join("\n");
-  const raw = await options.provider.sendMessage(systemPrompt, userPrompt, { model: options.model });
+  return {
+    assertions,
+    systemPrompt,
+    userPrompt
+  };
+}
+function parseGraderOutput(raw) {
   const parsed = graderOutputSchema.safeParse(extractJsonObject(raw));
   if (!parsed.success) {
     throw new Error(`Failed to parse grader output: ${parsed.error.issues[0]?.message ?? "invalid grader JSON"}`);
   }
   return parsed.data.assertions;
 }
+async function gradeResponse(options) {
+  const prompts = buildGraderPrompts(options);
+  const raw = await options.provider.sendMessage(prompts.systemPrompt, prompts.userPrompt, { model: options.model });
+  return parseGraderOutput(raw);
+}
+
+// src/utils/concurrency.ts
+async function pMap(items, fn, concurrency) {
+  if (!Number.isInteger(concurrency) || concurrency < 1) {
+    throw new Error("pMap concurrency must be an integer greater than or equal to 1.");
+  }
+  if (items.length === 0) {
+    return [];
+  }
+  const results = new Array(items.length);
+  return new Promise((resolve, reject) => {
+    let nextIndex = 0;
+    let completed = 0;
+    let rejected = false;
+    const launchNext = () => {
+      if (rejected) {
+        return;
+      }
+      if (completed === items.length) {
+        resolve(results);
+        return;
+      }
+      if (nextIndex >= items.length) {
+        return;
+      }
+      const currentIndex = nextIndex;
+      nextIndex += 1;
+      Promise.resolve().then(() => fn(items[currentIndex], currentIndex)).then((result) => {
+        if (rejected) {
+          return;
+        }
+        results[currentIndex] = result;
+        completed += 1;
+        if (completed === items.length) {
+          resolve(results);
+          return;
+        }
+        launchNext();
+      }).catch((error) => {
+        if (rejected) {
+          return;
+        }
+        rejected = true;
+        reject(error);
+      });
+    };
+    const initialWorkers = Math.min(concurrency, items.length);
+    for (let workerIndex = 0; workerIndex < initialWorkers; workerIndex += 1) {
+      launchNext();
+    }
+  });
+}
 
 // src/core/eval-runner.ts
 var evalPromptSchema = z3.object({
@@ -1655,34 +2456,37 @@ async function generatePrompts(skill, provider, model, count) {
 }
 async function runEval(skill, options) {
   const prompts = options.prompts && options.prompts.length > 0 ? evalPromptArraySchema.parse(options.prompts) : await generatePrompts(skill, options.provider, options.model, options.numRuns);
-  const results = [];
-  for (const evalPrompt of prompts) {
-    const systemPrompt = [
-      "You are an AI assistant with an activated skill.",
-      "Follow this SKILL.md content exactly where applicable.",
-      "",
-      skill.raw
-    ].join("\n");
-    const response = await options.provider.sendMessage(systemPrompt, evalPrompt.prompt, { model: options.model });
-    const gradedAssertions = await gradeResponse({
-      provider: options.provider,
-      model: options.graderModel,
-      skillName: skill.frontmatter.name,
-      skillBody: skill.content,
-      userPrompt: evalPrompt.prompt,
-      modelResponse: response,
-      assertions: evalPrompt.assertions
-    });
-    const passedAssertions2 = gradedAssertions.filter((assertion) => assertion.passed).length;
-    results.push({
-      prompt: evalPrompt.prompt,
-      assertions: gradedAssertions,
-      responseSummary: response.slice(0, 200),
-      response,
-      passedAssertions: passedAssertions2,
-      totalAssertions: gradedAssertions.length
-    });
-  }
+  const systemPrompt = [
+    "You are an AI assistant with an activated skill.",
+    "Follow this SKILL.md content exactly where applicable.",
+    "",
+    skill.raw
+  ].join("\n");
+  const results = await pMap(
+    prompts,
+    async (evalPrompt) => {
+      const response = await options.provider.sendMessage(systemPrompt, evalPrompt.prompt, { model: options.model });
+      const gradedAssertions = await gradeResponse({
+        provider: options.provider,
+        model: options.graderModel,
+        skillName: skill.frontmatter.name,
+        skillBody: skill.content,
+        userPrompt: evalPrompt.prompt,
+        modelResponse: response,
+        assertions: evalPrompt.assertions
+      });
+      const passedAssertions2 = gradedAssertions.filter((assertion) => assertion.passed).length;
+      return {
+        prompt: evalPrompt.prompt,
+        assertions: gradedAssertions,
+        responseSummary: response.slice(0, 200),
+        response,
+        passedAssertions: passedAssertions2,
+        totalAssertions: gradedAssertions.length
+      };
+    },
+    options.concurrency ?? 5
+  );
   const totalAssertions = results.reduce((total, result) => total + result.totalAssertions, 0);
   const passedAssertions = results.reduce((total, result) => total + result.passedAssertions, 0);
   return {
@@ -1707,6 +2511,7 @@ var triggerQuerySchema = z4.object({
   should_trigger: z4.boolean()
 });
 var triggerQueryArraySchema = z4.array(triggerQuerySchema);
+var triggerNumQueriesSchema = z4.number().int().min(2).refine((value) => value % 2 === 0, "numQueries must be an even number.");
 var FAKE_SKILLS = [
   { name: "code-review", description: "Reviews code changes for bugs, regressions, and maintainability issues." },
   { name: "api-tester", description: "Designs and runs REST API tests, validating status codes and response shapes." },
@@ -1747,6 +2552,9 @@ function shuffle(values, rng) {
 function sample(values, count, rng) {
   return shuffle(values, rng).slice(0, Math.max(0, Math.min(count, values.length)));
 }
+function validateNumQueries(numQueries) {
+  return triggerNumQueriesSchema.parse(numQueries);
+}
 function parseJsonArrayFromModelOutput(raw) {
   const trimmed = raw.trim();
   if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
@@ -1761,6 +2569,7 @@ function parseJsonArrayFromModelOutput(raw) {
   throw new Error("Model did not return a JSON array.");
 }
 async function generateQueriesWithModel(skill, provider, model, numQueries) {
+  validateNumQueries(numQueries);
   const shouldTriggerCount = Math.floor(numQueries / 2);
   const shouldNotTriggerCount = numQueries - shouldTriggerCount;
   const systemPrompt = [
@@ -1805,6 +2614,29 @@ function parseDecision(rawResponse, skillNames) {
   }
   return "unrecognized";
 }
+function prepareTriggerQueries(skill, queries, seed) {
+  const rng = createRng(seed);
+  return queries.map((testQuery) => {
+    const fakeCount = 5 + Math.floor(rng() * 5);
+    const fakeSkills = sample(FAKE_SKILLS, fakeCount, rng);
+    const allSkills = shuffle(
+      [
+        ...fakeSkills,
+        {
+          name: skill.frontmatter.name,
+          description: skill.frontmatter.description
+        }
+      ],
+      rng
+    );
+    return {
+      testQuery,
+      fakeSkills,
+      allSkills,
+      skillListText: allSkills.map((entry) => `- ${entry.name}: ${entry.description}`).join("\n")
+    };
+  });
+}
 function calculateMetrics(skillName, cases) {
   let truePositives = 0;
   let trueNegatives = 0;
@@ -1857,43 +2689,36 @@ function buildSuggestions(metrics) {
   return suggestions;
 }
 async function runTriggerTest(skill, options) {
-  const rng = createRng(options.seed);
   const queries = options.queries && options.queries.length > 0 ? triggerQueryArraySchema.parse(options.queries) : await generateQueriesWithModel(skill, options.provider, options.model, options.numQueries);
-  const results = [];
   const skillName = skill.frontmatter.name;
-  for (const testQuery of queries) {
-    const fakeCount = 5 + Math.floor(rng() * 5);
-    const fakeSkills = sample(FAKE_SKILLS, fakeCount, rng);
-    const allSkills = shuffle([
-      ...fakeSkills,
-      {
-        name: skill.frontmatter.name,
-        description: skill.frontmatter.description
-      }
-    ], rng);
-    const skillListText = allSkills.map((entry) => `- ${entry.name}: ${entry.description}`).join("\n");
-    const systemPrompt = [
-      "You are selecting one skill to activate for a user query.",
-      "Choose the single best matching skill name from the provided list, or 'none' if no skill is a good fit.",
-      "Respond with only the skill name or 'none'."
-    ].join(" ");
-    const userPrompt = [`Available skills:`, skillListText, "", `User query: ${testQuery.query}`].join("\n");
-    const rawResponse = await options.provider.sendMessage(systemPrompt, userPrompt, { model: options.model });
-    const decision = parseDecision(
-      rawResponse,
-      allSkills.map((entry) => entry.name)
-    );
-    const expected = testQuery.should_trigger ? skillName : "none";
-    const matched = testQuery.should_trigger ? decision === skillName : decision !== skillName;
-    results.push({
-      query: testQuery.query,
-      shouldTrigger: testQuery.should_trigger,
-      expected,
-      actual: decision,
-      matched,
-      rawModelResponse: options.verbose ? rawResponse : void 0
-    });
-  }
+  const preparedQueries = prepareTriggerQueries(skill, queries, options.seed);
+  const systemPrompt = [
+    "You are selecting one skill to activate for a user query.",
+    "Choose the single best matching skill name from the provided list, or 'none' if no skill is a good fit.",
+    "Respond with only the skill name or 'none'."
+  ].join(" ");
+  const results = await pMap(
+    preparedQueries,
+    async ({ testQuery, allSkills, skillListText }) => {
+      const userPrompt = [`Available skills:`, skillListText, "", `User query: ${testQuery.query}`].join("\n");
+      const rawResponse = await options.provider.sendMessage(systemPrompt, userPrompt, { model: options.model });
+      const decision = parseDecision(
+        rawResponse,
+        allSkills.map((entry) => entry.name)
+      );
+      const expected = testQuery.should_trigger ? skillName : "none";
+      const matched = testQuery.should_trigger ? decision === skillName : decision !== skillName;
+      return {
+        query: testQuery.query,
+        shouldTrigger: testQuery.should_trigger,
+        expected,
+        actual: decision,
+        matched,
+        rawModelResponse: options.verbose ? rawResponse : void 0
+      };
+    },
+    options.concurrency ?? 5
+  );
   const metrics = calculateMetrics(skillName, results);
   return {
     skillName,
@@ -2059,6 +2884,9 @@ function writeError(error, asJson) {
 }
 
 // src/commands/lint.ts
+var lintCliSchema = z6.object({
+  html: z6.string().optional()
+});
 async function handleLintCommand(targetPath, options) {
   try {
     const report = await runLinter(targetPath, { suppress: options.suppress });
@@ -2067,6 +2895,9 @@ async function handleLintCommand(targetPath, options) {
     } else {
       writeResult(renderLintReport(report, options.color), false);
     }
+    if (options.html) {
+      await fs6.writeFile(options.html, renderLintHtml(report), "utf8");
+    }
     if (lintFails(report, options.failOn)) {
       process.exitCode = 1;
     }
@@ -2076,74 +2907,85 @@ async function handleLintCommand(targetPath, options) {
   }
 }
 function registerLintCommand(program) {
-  program.command("lint").description("Run static lint checks against a SKILL.md file or skill directory.").argument("<path-to-skill>", "Path to SKILL.md or skill directory").action(async (targetPath, _commandOptions, command) => {
+  program.command("lint").description("Run static lint checks against a SKILL.md file or skill directory.").argument("<path-to-skill>", "Path to SKILL.md or skill directory").option("--html <path>", "Write an HTML report to the given file path").action(async (targetPath, _commandOptions, command) => {
     const globalOptions = getGlobalCliOptions(command);
     const config = getResolvedConfig(command);
+    const parsedCli = lintCliSchema.safeParse(command.opts());
+    if (!parsedCli.success) {
+      writeError(new Error(parsedCli.error.issues[0]?.message ?? "Invalid lint options."), globalOptions.json);
+      process.exitCode = 2;
+      return;
+    }
     await handleLintCommand(targetPath, {
       ...globalOptions,
       failOn: config.lint.failOn,
-      suppress: config.lint.suppress
+      suppress: config.lint.suppress,
+      html: parsedCli.data.html
     });
   });
 }
 
 // src/commands/trigger.ts
+import fs8 from "node:fs/promises";
 import ora from "ora";
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 
 // src/utils/config.ts
-import fs6 from "node:fs/promises";
+import fs7 from "node:fs/promises";
 import path5 from "node:path";
-import { z as z6 } from "zod";
-var providerNameSchema = z6.enum(["anthropic", "openai"]);
-var lintFailOnSchema = z6.enum(["error", "warn"]);
-var lintConfigSchema = z6.object({
+import { z as z7 } from "zod";
+var providerNameSchema = z7.enum(["anthropic", "openai"]);
+var lintFailOnSchema = z7.enum(["error", "warn"]);
+var lintConfigSchema = z7.object({
   failOn: lintFailOnSchema.optional(),
-  suppress: z6.array(z6.string().min(1)).optional()
+  suppress: z7.array(z7.string().min(1)).optional()
 }).strict();
-var triggerConfigSchema = z6.object({
-  numQueries: z6.number().int().min(2).refine((value) => value % 2 === 0, "trigger.numQueries must be an even number."),
-  threshold: z6.number().min(0).max(1).optional(),
-  seed: z6.number().int().optional()
+var triggerConfigSchema = z7.object({
+  numQueries: z7.number().int().min(2).refine((value) => value % 2 === 0, "trigger.numQueries must be an even number."),
+  threshold: z7.number().min(0).max(1).optional(),
+  seed: z7.number().int().optional()
 }).strict().partial();
-var evalConfigSchema = z6.object({
-  numRuns: z6.number().int().min(1).optional(),
-  threshold: z6.number().min(0).max(1).optional(),
-  promptFile: z6.string().min(1).optional(),
-  assertionsFile: z6.string().min(1).optional()
+var evalConfigSchema = z7.object({
+  numRuns: z7.number().int().min(1).optional(),
+  threshold: z7.number().min(0).max(1).optional(),
+  promptFile: z7.string().min(1).optional(),
+  assertionsFile: z7.string().min(1).optional()
 }).strict().partial();
-var skilltestConfigSchema = z6.object({
+var skilltestConfigSchema = z7.object({
   provider: providerNameSchema.optional(),
-  model: z6.string().min(1).optional(),
-  json: z6.boolean().optional(),
+  model: z7.string().min(1).optional(),
+  json: z7.boolean().optional(),
+  concurrency: z7.number().int().min(1).optional(),
   lint: lintConfigSchema.optional(),
   trigger: triggerConfigSchema.optional(),
   eval: evalConfigSchema.optional()
 }).strict();
-var resolvedSkilltestConfigSchema = z6.object({
+var resolvedSkilltestConfigSchema = z7.object({
   provider: providerNameSchema,
-  model: z6.string().min(1),
-  json: z6.boolean(),
-  lint: z6.object({
+  model: z7.string().min(1),
+  json: z7.boolean(),
+  concurrency: z7.number().int().min(1),
+  lint: z7.object({
     failOn: lintFailOnSchema,
-    suppress: z6.array(z6.string().min(1))
+    suppress: z7.array(z7.string().min(1))
   }),
-  trigger: z6.object({
-    numQueries: z6.number().int().min(2).refine((value) => value % 2 === 0, "trigger.numQueries must be an even number."),
-    threshold: z6.number().min(0).max(1),
-    seed: z6.number().int().optional()
+  trigger: z7.object({
+    numQueries: z7.number().int().min(2).refine((value) => value % 2 === 0, "trigger.numQueries must be an even number."),
+    threshold: z7.number().min(0).max(1),
+    seed: z7.number().int().optional()
   }),
-  eval: z6.object({
-    numRuns: z6.number().int().min(1),
-    threshold: z6.number().min(0).max(1),
-    promptFile: z6.string().min(1).optional(),
-    assertionsFile: z6.string().min(1).optional()
+  eval: z7.object({
+    numRuns: z7.number().int().min(1),
+    threshold: z7.number().min(0).max(1),
+    promptFile: z7.string().min(1).optional(),
+    assertionsFile: z7.string().min(1).optional()
   })
 });
 var DEFAULT_SKILLTEST_CONFIG = {
   provider: "anthropic",
   model: "claude-sonnet-4-5-20250929",
   json: false,
+  concurrency: 5,
   lint: {
     failOn: "error",
     suppress: []
@@ -2172,7 +3014,7 @@ function buildConfigValidationError(error, sourceLabel) {
 async function readJsonObject(filePath, label) {
   let raw;
   try {
-    raw = await fs6.readFile(filePath, "utf8");
+    raw = await fs7.readFile(filePath, "utf8");
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     throw new Error(`Failed to read ${label}: ${message}`);
@@ -2205,7 +3047,7 @@ async function loadConfigFromNearestPackageJson(startDirectory) {
     const packageJsonPath = path5.join(currentDirectory, "package.json");
     if (await pathExists(packageJsonPath)) {
       const raw = await readJsonObject(packageJsonPath, packageJsonPath);
-      const packageJsonSchema = z6.object({
+      const packageJsonSchema = z7.object({
         skilltestrc: skilltestConfigSchema.optional()
       }).passthrough();
       const parsed = packageJsonSchema.safeParse(raw);
@@ -2250,6 +3092,7 @@ function mergeConfigLayers(configFile = {}, cliFlags = {}, baseDirectory = proce
     provider: cliFlags.provider ?? configFile.provider ?? DEFAULT_SKILLTEST_CONFIG.provider,
     model: cliFlags.model ?? configFile.model ?? DEFAULT_SKILLTEST_CONFIG.model,
     json: cliFlags.json ?? configFile.json ?? DEFAULT_SKILLTEST_CONFIG.json,
+    concurrency: cliFlags.concurrency ?? configFile.concurrency ?? DEFAULT_SKILLTEST_CONFIG.concurrency,
     lint: {
       failOn: cliFlags.lint?.failOn ?? configFile.lint?.failOn ?? DEFAULT_SKILLTEST_CONFIG.lint.failOn,
       suppress: cliFlags.lint?.suppress ?? configFile.lint?.suppress ?? DEFAULT_SKILLTEST_CONFIG.lint.suppress
@@ -2293,6 +3136,9 @@ function extractCliConfigOverrides(command) {
   if (command.getOptionValueSource("model") === "cli") {
     overrides.model = getTypedOptionValue(command, "model");
   }
+  if ((command.name() === "trigger" || command.name() === "eval" || command.name() === "check") && command.getOptionValueSource("concurrency") === "cli") {
+    overrides.concurrency = getTypedOptionValue(command, "concurrency");
+  }
   if ((command.name() === "trigger" || command.name() === "check") && command.getOptionValueSource("numQueries") === "cli") {
     overrides.trigger = {
       ...overrides.trigger,
@@ -2322,7 +3168,6 @@ async function resolveConfigContext(targetPath, cliFlags) {
   const skillDirectoryConfig = await resolveSkillDirectoryConfig(targetPath);
   if (skillDirectoryConfig) {
     return {
-      configFile: skillDirectoryConfig.configFile,
       ...skillDirectoryConfig,
       config: mergeConfigLayers(skillDirectoryConfig.configFile, cliFlags, skillDirectoryConfig.sourceDirectory)
     };
@@ -2331,7 +3176,6 @@ async function resolveConfigContext(targetPath, cliFlags) {
   const cwdConfig = await loadConfigFromJsonFile(cwdConfigPath);
   if (cwdConfig) {
     return {
-      configFile: cwdConfig.configFile,
       ...cwdConfig,
       config: mergeConfigLayers(cwdConfig.configFile, cliFlags, cwdConfig.sourceDirectory)
     };
@@ -2339,7 +3183,6 @@ async function resolveConfigContext(targetPath, cliFlags) {
   const packageJsonConfig = await loadConfigFromNearestPackageJson(cwd);
   if (packageJsonConfig) {
     return {
-      configFile: packageJsonConfig.configFile,
       ...packageJsonConfig,
       config: mergeConfigLayers(packageJsonConfig.configFile, cliFlags, packageJsonConfig.sourceDirectory)
     };
@@ -2547,12 +3390,14 @@ function createProvider(providerName, apiKeyOverride) {
 }
 
 // src/commands/trigger.ts
-var triggerCliSchema = z7.object({
-  queries: z7.string().optional(),
-  saveQueries: z7.string().optional(),
-  seed: z7.number().int().optional(),
-  verbose: z7.boolean().optional(),
-  apiKey: z7.string().optional()
+var triggerCliSchema = z8.object({
+  queries: z8.string().optional(),
+  saveQueries: z8.string().optional(),
+  seed: z8.number().int().optional(),
+  concurrency: z8.number().int().min(1).optional(),
+  html: z8.string().optional(),
+  verbose: z8.boolean().optional(),
+  apiKey: z8.string().optional()
 });
 var DEFAULT_ANTHROPIC_MODEL = "claude-sonnet-4-5-20250929";
 var DEFAULT_OPENAI_MODEL = "gpt-4.1-mini";
@@ -2597,6 +3442,7 @@ async function handleTriggerCommand(targetPath, options) {
       queries,
       numQueries: options.numQueries,
       seed: options.seed,
+      concurrency: options.concurrency,
       verbose: options.verbose
     });
     if (options.saveQueries) {
@@ -2608,6 +3454,13 @@ async function handleTriggerCommand(targetPath, options) {
     } else {
       writeResult(renderTriggerOutputWithSeed(renderTriggerReport(result, options.color, options.verbose), result.seed), false);
     }
+    if (options.html) {
+      const htmlResult = {
+        ...result,
+        target: targetPath
+      };
+      await fs8.writeFile(options.html, renderTriggerHtml(htmlResult), "utf8");
+    }
   } catch (error) {
     spinner?.stop();
     writeError(error, options.json);
@@ -2615,7 +3468,7 @@ async function handleTriggerCommand(targetPath, options) {
   }
 }
 function registerTriggerCommand(program) {
-  program.command("trigger").description("Evaluate whether a skill description triggers correctly.").argument("<path-to-skill>", "Path to SKILL.md or skill directory").option("--model <model>", "Model to use").option("--provider <provider>", "LLM provider: anthropic|openai").option("--queries <path>", "Path to custom test queries JSON").option("--num-queries <n>", "Number of auto-generated queries", (value) => Number.parseInt(value, 10)).option("--seed <number>", "RNG seed for reproducible results", (value) => Number.parseInt(value, 10)).option("--save-queries <path>", "Save generated queries to a JSON file").option("--api-key <key>", "API key override").option("--verbose", "Show full model decisions").action(async (targetPath, _commandOptions, command) => {
+  program.command("trigger").description("Evaluate whether a skill description triggers correctly.").argument("<path-to-skill>", "Path to SKILL.md or skill directory").option("--model <model>", "Model to use").option("--provider <provider>", "LLM provider: anthropic|openai").option("--queries <path>", "Path to custom test queries JSON").option("--num-queries <n>", "Number of auto-generated queries", (value) => Number.parseInt(value, 10)).option("--seed <number>", "RNG seed for reproducible results", (value) => Number.parseInt(value, 10)).option("--concurrency <n>", "Maximum in-flight trigger requests", (value) => Number.parseInt(value, 10)).option("--html <path>", "Write an HTML report to the given file path").option("--save-queries <path>", "Save generated queries to a JSON file").option("--api-key <key>", "API key override").option("--verbose", "Show full model decisions").action(async (targetPath, _commandOptions, command) => {
     const globalOptions = getGlobalCliOptions(command);
     const config = getResolvedConfig(command);
     const parsedCli = triggerCliSchema.safeParse(command.opts());
@@ -2632,6 +3485,8 @@ function registerTriggerCommand(program) {
       numQueries: config.trigger.numQueries,
       saveQueries: parsedCli.data.saveQueries,
       seed: parsedCli.data.seed ?? config.trigger.seed,
+      concurrency: config.concurrency,
+      html: parsedCli.data.html,
       verbose: Boolean(parsedCli.data.verbose),
       apiKey: parsedCli.data.apiKey
     });
@@ -2639,14 +3494,17 @@ function registerTriggerCommand(program) {
 }
 
 // src/commands/eval.ts
+import fs9 from "node:fs/promises";
 import ora2 from "ora";
-import { z as z8 } from "zod";
-var evalCliSchema = z8.object({
-  prompts: z8.string().optional(),
-  graderModel: z8.string().optional(),
-  saveResults: z8.string().optional(),
-  verbose: z8.boolean().optional(),
-  apiKey: z8.string().optional()
+import { z as z9 } from "zod";
+var evalCliSchema = z9.object({
+  prompts: z9.string().optional(),
+  graderModel: z9.string().optional(),
+  saveResults: z9.string().optional(),
+  concurrency: z9.number().int().min(1).optional(),
+  html: z9.string().optional(),
+  verbose: z9.boolean().optional(),
+  apiKey: z9.string().optional()
 });
 var DEFAULT_ANTHROPIC_MODEL2 = "claude-sonnet-4-5-20250929";
 var DEFAULT_OPENAI_MODEL2 = "gpt-4.1-mini";
@@ -2686,6 +3544,7 @@ async function handleEvalCommand(targetPath, options, command) {
       model,
       graderModel,
       numRuns: options.numRuns,
+      concurrency: options.concurrency,
       prompts
     });
     if (options.saveResults) {
@@ -2697,6 +3556,13 @@ async function handleEvalCommand(targetPath, options, command) {
     } else {
       writeResult(renderEvalReport(result, options.color, options.verbose), false);
     }
+    if (options.html) {
+      const htmlResult = {
+        ...result,
+        target: targetPath
+      };
+      await fs9.writeFile(options.html, renderEvalHtml(htmlResult), "utf8");
+    }
   } catch (error) {
     spinner?.stop();
     writeError(error, options.json);
@@ -2704,7 +3570,7 @@ async function handleEvalCommand(targetPath, options, command) {
   }
 }
 function registerEvalCommand(program) {
-  program.command("eval").description("Run end-to-end skill execution and quality evaluation.").argument("<path-to-skill>", "Path to SKILL.md or skill directory").option("--prompts <path>", "Path to eval prompts JSON").option("--model <model>", "Model to execute prompts").option("--grader-model <model>", "Model used for grading (defaults to --model)").option("--provider <provider>", "LLM provider: anthropic|openai").option("--save-results <path>", "Save full evaluation results to JSON").option("--api-key <key>", "API key override").option("--verbose", "Show full model responses").action(async (targetPath, _commandOptions, command) => {
+  program.command("eval").description("Run end-to-end skill execution and quality evaluation.").argument("<path-to-skill>", "Path to SKILL.md or skill directory").option("--prompts <path>", "Path to eval prompts JSON").option("--model <model>", "Model to execute prompts").option("--grader-model <model>", "Model used for grading (defaults to --model)").option("--provider <provider>", "LLM provider: anthropic|openai").option("--concurrency <n>", "Maximum in-flight eval prompt runs", (value) => Number.parseInt(value, 10)).option("--html <path>", "Write an HTML report to the given file path").option("--save-results <path>", "Save full evaluation results to JSON").option("--api-key <key>", "API key override").option("--verbose", "Show full model responses").action(async (targetPath, _commandOptions, command) => {
     const globalOptions = getGlobalCliOptions(command);
     const config = getResolvedConfig(command);
     const parsedCli = evalCliSchema.safeParse(command.opts());
@@ -2722,9 +3588,11 @@ function registerEvalCommand(program) {
         graderModel: parsedCli.data.graderModel,
         provider: config.provider,
         saveResults: parsedCli.data.saveResults,
+        html: parsedCli.data.html,
         verbose: Boolean(parsedCli.data.verbose),
         apiKey: parsedCli.data.apiKey,
-        numRuns: config.eval.numRuns
+        numRuns: config.eval.numRuns,
+        concurrency: config.concurrency
       },
       command
     );
@@ -2732,8 +3600,9 @@ function registerEvalCommand(program) {
 }
 
 // src/commands/check.ts
+import fs10 from "node:fs/promises";
 import ora3 from "ora";
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 
 // src/core/check-runner.ts
 function calculateEvalAssertPassRate(result) {
@@ -2764,23 +3633,33 @@ async function runCheck(inputPath, options) {
       evalSkippedReason = `Skipped: skill could not be parsed strictly (${message}).`;
     }
     if (parsedSkill) {
-      options.onStage?.("trigger");
-      trigger = await runTriggerTest(parsedSkill, {
+      const triggerOptions = {
         provider: options.provider,
         model: options.model,
         queries: options.queries,
         numQueries: options.numQueries,
         seed: options.triggerSeed,
+        concurrency: options.concurrency,
         verbose: options.verbose
-      });
-      options.onStage?.("eval");
-      evalResult = await runEval(parsedSkill, {
+      };
+      const evalOptions = {
         provider: options.provider,
         model: options.model,
         graderModel: options.graderModel,
         numRuns: options.evalNumRuns,
-        prompts: options.prompts
-      });
+        prompts: options.prompts,
+        concurrency: options.concurrency
+      };
+      if ((options.concurrency ?? 5) === 1) {
+        options.onStage?.("trigger");
+        trigger = await runTriggerTest(parsedSkill, triggerOptions);
+        options.onStage?.("eval");
+        evalResult = await runEval(parsedSkill, evalOptions);
+      } else {
+        options.onStage?.("trigger");
+        options.onStage?.("eval");
+        [trigger, evalResult] = await Promise.all([runTriggerTest(parsedSkill, triggerOptions), runEval(parsedSkill, evalOptions)]);
+      }
     }
   }
   const triggerF1 = trigger ? trigger.metrics.f1 : null;
@@ -2815,15 +3694,17 @@ async function runCheck(inputPath, options) {
 }
 
 // src/commands/check.ts
-var checkCliSchema = z9.object({
-  graderModel: z9.string().optional(),
-  apiKey: z9.string().optional(),
-  queries: z9.string().optional(),
-  seed: z9.number().int().optional(),
-  prompts: z9.string().optional(),
-  saveResults: z9.string().optional(),
-  continueOnLintFail: z9.boolean().optional(),
-  verbose: z9.boolean().optional()
+var checkCliSchema = z10.object({
+  graderModel: z10.string().optional(),
+  apiKey: z10.string().optional(),
+  queries: z10.string().optional(),
+  seed: z10.number().int().optional(),
+  prompts: z10.string().optional(),
+  concurrency: z10.number().int().min(1).optional(),
+  html: z10.string().optional(),
+  saveResults: z10.string().optional(),
+  continueOnLintFail: z10.boolean().optional(),
+  verbose: z10.boolean().optional()
 });
 var DEFAULT_ANTHROPIC_MODEL3 = "claude-sonnet-4-5-20250929";
 var DEFAULT_OPENAI_MODEL3 = "gpt-4.1-mini";
@@ -2882,6 +3763,7 @@ async function handleCheckCommand(targetPath, options, command) {
       triggerSeed: options.triggerSeed,
       prompts,
       evalNumRuns: options.numRuns,
+      concurrency: options.concurrency,
       minF1: options.minF1,
       minAssertPassRate: options.minAssertPassRate,
       continueOnLintFail: options.continueOnLintFail,
@@ -2894,10 +3776,8 @@ async function handleCheckCommand(targetPath, options, command) {
           spinner.text = "Running lint checks...";
         } else if (stage === "parse") {
           spinner.text = "Parsing skill for model evaluations...";
-        } else if (stage === "trigger") {
-          spinner.text = "Running trigger test suite...";
-        } else if (stage === "eval") {
-          spinner.text = "Running end-to-end eval suite...";
+        } else if (stage === "trigger" || stage === "eval") {
+          spinner.text = "Running trigger and eval suites...";
         }
       }
     });
@@ -2913,6 +3793,9 @@ async function handleCheckCommand(targetPath, options, command) {
         false
       );
     }
+    if (options.html) {
+      await fs10.writeFile(options.html, renderCheckHtml(result), "utf8");
+    }
     process.exitCode = result.gates.overallPassed ? 0 : 1;
   } catch (error) {
     spinner?.stop();
@@ -2921,7 +3804,7 @@ async function handleCheckCommand(targetPath, options, command) {
   }
 }
 function registerCheckCommand(program) {
-  program.command("check").description("Run lint + trigger + eval with threshold-based quality gates.").argument("<path-to-skill>", "Path to SKILL.md or skill directory").option("--provider <provider>", "LLM provider: anthropic|openai").option("--model <model>", "Model for trigger/eval runs").option("--grader-model <model>", "Model used for grading (defaults to --model)").option("--api-key <key>", "API key override").option("--queries <path>", "Path to custom trigger queries JSON").option("--num-queries <n>", "Number of auto-generated trigger queries", (value) => Number.parseInt(value, 10)).option("--seed <number>", "RNG seed for reproducible results", (value) => Number.parseInt(value, 10)).option("--prompts <path>", "Path to eval prompts JSON").option("--min-f1 <n>", "Minimum required trigger F1 score (0-1)", (value) => Number.parseFloat(value)).option("--min-assert-pass-rate <n>", "Minimum required eval assertion pass rate (0-1)", (value) => Number.parseFloat(value)).option("--save-results <path>", "Save combined check results to JSON").option("--continue-on-lint-fail", "Continue trigger/eval stages even when lint has failures").option("--verbose", "Show detailed trigger/eval output sections").action(async (targetPath, _commandOptions, command) => {
+  program.command("check").description("Run lint + trigger + eval with threshold-based quality gates.").argument("<path-to-skill>", "Path to SKILL.md or skill directory").option("--provider <provider>", "LLM provider: anthropic|openai").option("--model <model>", "Model for trigger/eval runs").option("--grader-model <model>", "Model used for grading (defaults to --model)").option("--api-key <key>", "API key override").option("--queries <path>", "Path to custom trigger queries JSON").option("--num-queries <n>", "Number of auto-generated trigger queries", (value) => Number.parseInt(value, 10)).option("--seed <number>", "RNG seed for reproducible results", (value) => Number.parseInt(value, 10)).option("--prompts <path>", "Path to eval prompts JSON").option("--concurrency <n>", "Maximum in-flight trigger/eval tasks", (value) => Number.parseInt(value, 10)).option("--html <path>", "Write an HTML report to the given file path").option("--min-f1 <n>", "Minimum required trigger F1 score (0-1)", (value) => Number.parseFloat(value)).option("--min-assert-pass-rate <n>", "Minimum required eval assertion pass rate (0-1)", (value) => Number.parseFloat(value)).option("--save-results <path>", "Save combined check results to JSON").option("--continue-on-lint-fail", "Continue trigger/eval stages even when lint has failures").option("--verbose", "Show detailed trigger/eval output sections").action(async (targetPath, _commandOptions, command) => {
     const globalOptions = getGlobalCliOptions(command);
     const config = getResolvedConfig(command);
     const parsedCli = checkCliSchema.safeParse(command.opts());
@@ -2944,6 +3827,8 @@ function registerCheckCommand(program) {
         minF1: config.trigger.threshold,
         minAssertPassRate: config.eval.threshold,
         numRuns: config.eval.numRuns,
+        concurrency: config.concurrency,
+        html: parsedCli.data.html,
         lintFailOn: config.lint.failOn,
         lintSuppress: config.lint.suppress,
         triggerSeed: parsedCli.data.seed ?? config.trigger.seed,
@@ -2961,7 +3846,7 @@ function resolveVersion() {
   try {
     const currentFilePath = fileURLToPath(import.meta.url);
     const packageJsonPath = path6.resolve(path6.dirname(currentFilePath), "..", "package.json");
-    const raw = fs7.readFileSync(packageJsonPath, "utf8");
+    const raw = fs11.readFileSync(packageJsonPath, "utf8");
     const parsed = JSON.parse(raw);
     return parsed.version ?? "0.0.0";
   } catch {