skilltest 0.3.0 → 0.4.0

package/dist/index.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import fs5 from "node:fs";
-import path5 from "node:path";
+import fs7 from "node:fs";
+import path6 from "node:path";
 import { fileURLToPath } from "node:url";
 import { Command } from "commander";
 
@@ -194,6 +194,7 @@ function runCompatibilityChecks(context) {
   if (hasAllowedTools) {
     issues.push({
       id: "compat.allowed-tools",
+      checkId: "compat:frontmatter",
       title: "Platform-Specific Frontmatter",
       status: "warn",
       message: "Frontmatter includes allowed-tools, which is typically Claude-specific.",
@@ -202,6 +203,7 @@ function runCompatibilityChecks(context) {
   } else {
     issues.push({
       id: "compat.allowed-tools",
+      checkId: "compat:frontmatter",
       title: "Platform-Specific Frontmatter",
       status: "pass",
       message: "No known provider-specific frontmatter keys detected."
@@ -211,6 +213,7 @@ function runCompatibilityChecks(context) {
     const platform = mentionsClaudeOnly ? "Claude" : "Codex";
     issues.push({
       id: "compat.provider-phrasing",
+      checkId: "compat:provider-language",
       title: "Provider-Specific Language",
       status: "warn",
       message: `Skill body appears tuned to ${platform}-specific behavior.`,
@@ -219,6 +222,7 @@ function runCompatibilityChecks(context) {
   } else {
     issues.push({
       id: "compat.provider-phrasing",
+      checkId: "compat:provider-language",
       title: "Provider-Specific Language",
       status: "pass",
       message: "Skill body appears provider-neutral."
@@ -227,6 +231,7 @@ function runCompatibilityChecks(context) {
   const likelyCompatibility = hasAllowedTools || mentionsClaudeOnly || mentionsCodexOnly ? "Likely compatible with some agents, but includes platform-specific assumptions." : "Likely broadly compatible across Anthropic, OpenAI/Codex-style, and other markdown skill runners.";
   issues.push({
     id: "compat.summary",
+    checkId: "compat:summary",
     title: "Compatibility Hint",
     status: hasAllowedTools || mentionsClaudeOnly || mentionsCodexOnly ? "warn" : "pass",
     message: likelyCompatibility
@@ -258,6 +263,7 @@ function runContentChecks(context) {
   if (!/^#{1,6}\s+\S+/m.test(body)) {
     issues.push({
       id: "content.headers",
+      checkId: "content:headers",
       title: "Section Headers",
       status: "warn",
       message: "No markdown headers found in SKILL.md body.",
@@ -266,6 +272,7 @@ function runContentChecks(context) {
   } else {
     issues.push({
       id: "content.headers",
+      checkId: "content:headers",
       title: "Section Headers",
       status: "pass",
       message: "SKILL.md contains markdown section headers."
@@ -275,6 +282,7 @@ function runContentChecks(context) {
   if (!hasExamples) {
     issues.push({
       id: "content.examples",
+      checkId: "content:examples",
       title: "Examples",
       status: "warn",
       message: "No examples detected in SKILL.md body.",
@@ -283,6 +291,7 @@ function runContentChecks(context) {
   } else {
     issues.push({
       id: "content.examples",
+      checkId: "content:examples",
       title: "Examples",
       status: "pass",
       message: "Examples were detected in SKILL.md."
@@ -292,6 +301,7 @@ function runContentChecks(context) {
   if (vagueMatches.length > 0) {
     issues.push({
       id: "content.vagueness",
+      checkId: "content:vagueness",
       title: "Instruction Specificity",
       status: "warn",
       message: "Potentially vague instruction phrases detected.",
@@ -300,6 +310,7 @@ function runContentChecks(context) {
   } else {
     issues.push({
       id: "content.vagueness",
+      checkId: "content:vagueness",
       title: "Instruction Specificity",
       status: "pass",
       message: "No obvious vague placeholder phrasing found."
@@ -308,6 +319,7 @@ function runContentChecks(context) {
   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.",
@@ -316,6 +328,7 @@ function runContentChecks(context) {
   } 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."
@@ -330,6 +343,7 @@ function runContentChecks(context) {
   if (secretHits.size > 0) {
     issues.push({
       id: "content.secrets",
+      checkId: "content:secrets",
       title: "Hardcoded Secrets",
       status: "fail",
       message: `Potential secrets detected (${Array.from(secretHits).join(", ")}).`,
@@ -338,6 +352,7 @@ function runContentChecks(context) {
   } else {
     issues.push({
       id: "content.secrets",
+      checkId: "content:secrets",
       title: "Hardcoded Secrets",
       status: "pass",
       message: "No obvious API keys or secrets patterns were detected."
@@ -346,6 +361,7 @@ function runContentChecks(context) {
   if (bodyLines.length < 10) {
     issues.push({
       id: "content.body-length",
+      checkId: "content:body-length",
       title: "Body Completeness",
       status: "warn",
       message: `SKILL.md body has only ${bodyLines.length} non-empty lines.`,
@@ -354,6 +370,7 @@ function runContentChecks(context) {
   } else {
     issues.push({
       id: "content.body-length",
+      checkId: "content:body-length",
       title: "Body Completeness",
       status: "pass",
       message: `SKILL.md body has ${bodyLines.length} non-empty lines.`
@@ -362,6 +379,7 @@ function runContentChecks(context) {
   if (description && description.length < 50) {
     issues.push({
       id: "content.description-length",
+      checkId: "content:description-length",
       title: "Description Specificity",
       status: "warn",
       message: `Description length is ${description.length} characters, which may be too vague for reliable triggering.`,
@@ -370,6 +388,7 @@ function runContentChecks(context) {
   } else if (description) {
     issues.push({
       id: "content.description-length",
+      checkId: "content:description-length",
       title: "Description Specificity",
       status: "pass",
       message: "Description length is sufficient for triggerability heuristics."
@@ -461,6 +480,7 @@ async function runDisclosureChecks(context) {
   if (context.skill.lineCount > 200 && !await pathExists(referencesDir)) {
     issues.push({
       id: "disclosure.skill-split",
+      checkId: "disclosure:progressive-disclosure",
       title: "Progressive Disclosure",
       status: "warn",
       message: "SKILL.md exceeds 200 lines and no references/ directory is present.",
@@ -469,6 +489,7 @@ async function runDisclosureChecks(context) {
   } else {
     issues.push({
       id: "disclosure.skill-split",
+      checkId: "disclosure:progressive-disclosure",
       title: "Progressive Disclosure",
       status: "pass",
       message: "Top-level file length and references/ usage look reasonable."
@@ -496,6 +517,7 @@ async function runDisclosureChecks(context) {
   if (nonRelativeOrEscaping.length > 0) {
     issues.push({
       id: "disclosure.relative-path-root",
+      checkId: "disclosure:path-scope",
       title: "Reference Path Scope",
       status: "fail",
       message: `Found non-relative or out-of-root references: ${nonRelativeOrEscaping.join(", ")}`,
@@ -504,6 +526,7 @@ async function runDisclosureChecks(context) {
   } else {
     issues.push({
       id: "disclosure.relative-path-root",
+      checkId: "disclosure:path-scope",
       title: "Reference Path Scope",
       status: "pass",
       message: "All detected file references are relative and scoped to skill root."
@@ -513,6 +536,7 @@ async function runDisclosureChecks(context) {
   if (chainDepth > 1) {
     issues.push({
       id: "disclosure.reference-depth",
+      checkId: "disclosure:reference-depth",
       title: "Reference Chain Depth",
       status: "warn",
       message: "Deep reference chains detected (>1 level).",
@@ -521,6 +545,7 @@ async function runDisclosureChecks(context) {
   } else {
     issues.push({
       id: "disclosure.reference-depth",
+      checkId: "disclosure:reference-depth",
       title: "Reference Chain Depth",
       status: "pass",
       message: "Reference depth is shallow and easy to navigate."
@@ -530,6 +555,7 @@ async function runDisclosureChecks(context) {
   if (normalizedReferences.some((item) => item.includes("../"))) {
     issues.push({
       id: "disclosure.parent-traversal",
+      checkId: "disclosure:parent-traversal",
       title: "Parent Traversal",
       status: "warn",
       message: "References include parent-directory traversal (../).",
@@ -538,6 +564,7 @@ async function runDisclosureChecks(context) {
   } else {
     issues.push({
       id: "disclosure.parent-traversal",
+      checkId: "disclosure:parent-traversal",
       title: "Parent Traversal",
       status: "pass",
       message: "No parent-directory traversal references detected."
@@ -568,6 +595,7 @@ function runFrontmatterChecks(context) {
   if (!context.frontmatter.hasFrontmatter) {
     issues.push({
       id: "frontmatter.exists",
+      checkId: "frontmatter:exists",
       title: "Frontmatter Presence",
       status: "fail",
       message: "SKILL.md is missing YAML frontmatter delimited by --- blocks.",
@@ -578,6 +606,7 @@ function runFrontmatterChecks(context) {
   if (context.frontmatter.error) {
     issues.push({
       id: "frontmatter.valid-yaml",
+      checkId: "frontmatter:yaml",
       title: "Frontmatter YAML",
       status: "fail",
       message: `Frontmatter is not valid YAML: ${context.frontmatter.error}`,
@@ -587,6 +616,7 @@ function runFrontmatterChecks(context) {
   }
   issues.push({
     id: "frontmatter.valid-yaml",
+    checkId: "frontmatter:yaml",
     title: "Frontmatter YAML",
     status: "pass",
     message: "Frontmatter exists and parses correctly."
@@ -596,6 +626,7 @@ function runFrontmatterChecks(context) {
   if (!name) {
     issues.push({
       id: "frontmatter.name.required",
+      checkId: "frontmatter:name",
       title: "Frontmatter Name",
       status: "fail",
       message: "Missing required frontmatter field: name.",
@@ -604,6 +635,7 @@ function runFrontmatterChecks(context) {
   } else if (name.length > 64) {
     issues.push({
       id: "frontmatter.name.length",
+      checkId: "frontmatter:name",
       title: "Frontmatter Name Length",
       status: "fail",
       message: `name is too long (${name.length} chars, max 64).`,
@@ -612,6 +644,7 @@ function runFrontmatterChecks(context) {
   } else if (!SKILL_NAME_REGEX.test(name)) {
     issues.push({
       id: "frontmatter.name.format",
+      checkId: "frontmatter:name",
       title: "Frontmatter Name Format",
       status: "fail",
       message: "name must be lowercase alphanumeric with single hyphen separators only.",
@@ -620,6 +653,7 @@ function runFrontmatterChecks(context) {
   } else {
     issues.push({
       id: "frontmatter.name.valid",
+      checkId: "frontmatter:name",
       title: "Frontmatter Name",
       status: "pass",
       message: "name is present and follows naming conventions."
@@ -629,6 +663,7 @@ function runFrontmatterChecks(context) {
   if (!description || description.trim() === "") {
     issues.push({
       id: "frontmatter.description.required",
+      checkId: "frontmatter:description",
       title: "Frontmatter Description",
       status: "fail",
       message: "Missing required frontmatter field: description.",
@@ -637,6 +672,7 @@ function runFrontmatterChecks(context) {
   } else if (description.length > 1024) {
     issues.push({
       id: "frontmatter.description.length",
+      checkId: "frontmatter:description",
       title: "Frontmatter Description Length",
       status: "fail",
       message: `description is too long (${description.length} chars, max 1024).`,
@@ -645,6 +681,7 @@ function runFrontmatterChecks(context) {
   } else {
     issues.push({
       id: "frontmatter.description.valid",
+      checkId: "frontmatter:description",
       title: "Frontmatter Description",
       status: "pass",
       message: "description is present and within allowed length."
@@ -654,6 +691,7 @@ function runFrontmatterChecks(context) {
   if (!license || license.trim() === "") {
     issues.push({
       id: "frontmatter.license.recommended",
+      checkId: "frontmatter:license",
       title: "Frontmatter License",
       status: "warn",
       message: "No license field found in frontmatter.",
@@ -662,6 +700,7 @@ function runFrontmatterChecks(context) {
   } else {
     issues.push({
       id: "frontmatter.license.present",
+      checkId: "frontmatter:license",
       title: "Frontmatter License",
       status: "pass",
       message: "license field is present."
@@ -670,6 +709,7 @@ function runFrontmatterChecks(context) {
   if (description && description.trim() !== "" && !descriptionLooksActionable(description)) {
     issues.push({
       id: "frontmatter.description.triggerability",
+      checkId: "frontmatter:triggerability",
       title: "Description Trigger Clarity",
       status: "warn",
       message: "Description should explain both what the skill does and when it should be used.",
@@ -678,6 +718,7 @@ function runFrontmatterChecks(context) {
   } else if (description) {
     issues.push({
       id: "frontmatter.description.triggerability",
+      checkId: "frontmatter:triggerability",
       title: "Description Trigger Clarity",
       status: "pass",
       message: "Description appears to cover both capability and usage context."
@@ -751,6 +792,7 @@ function runSecurityChecks(context) {
   if (dangerousCommandHits.length > 0) {
     issues.push({
       id: "security.dangerous-command-patterns",
+      checkId: "security:dangerous-commands",
       title: "Dangerous Command Patterns",
       status: "fail",
       message: `Potentially dangerous command instruction patterns found: ${dangerousCommandHits.join(", ")}.`,
@@ -759,6 +801,7 @@ function runSecurityChecks(context) {
   } else {
     issues.push({
       id: "security.dangerous-command-patterns",
+      checkId: "security:dangerous-commands",
       title: "Dangerous Command Patterns",
       status: "pass",
       message: "No high-risk destructive or direct pipe-to-shell patterns detected."
@@ -768,6 +811,7 @@ function runSecurityChecks(context) {
   if (exfiltrationHits.length > 0) {
     issues.push({
       id: "security.exfiltration-patterns",
+      checkId: "security:exfiltration",
       title: "Sensitive Data Exfiltration",
       status: "fail",
       message: `Possible sensitive data exfiltration patterns found: ${exfiltrationHits.join(", ")}.`,
@@ -776,6 +820,7 @@ function runSecurityChecks(context) {
   } else {
     issues.push({
       id: "security.exfiltration-patterns",
+      checkId: "security:exfiltration",
       title: "Sensitive Data Exfiltration",
       status: "pass",
       message: "No obvious credential access/exfiltration instructions detected."
@@ -785,6 +830,7 @@ function runSecurityChecks(context) {
   if (escalationHits.length > 0) {
     issues.push({
       id: "security.privilege-escalation",
+      checkId: "security:privilege-escalation",
       title: "Privilege Escalation Language",
       status: "warn",
       message: `Potentially risky privilege/execution language detected: ${escalationHits.join(", ")}.`,
@@ -793,6 +839,7 @@ function runSecurityChecks(context) {
   } else {
     issues.push({
       id: "security.privilege-escalation",
+      checkId: "security:privilege-escalation",
       title: "Privilege Escalation Language",
       status: "pass",
       message: "No obvious privilege-escalation language detected."
@@ -802,6 +849,7 @@ function runSecurityChecks(context) {
   if (hasShellActivity && !SAFETY_GUARDRAIL_PATTERN.test(skillText)) {
     issues.push({
       id: "security.safety-guardrails",
+      checkId: "security:missing-guardrails",
       title: "Execution Safety Guardrails",
       status: "warn",
       message: "Shell/tool execution is present, but no explicit safety guardrails were detected.",
@@ -810,6 +858,7 @@ function runSecurityChecks(context) {
   } else {
     issues.push({
       id: "security.safety-guardrails",
+      checkId: "security:missing-guardrails",
       title: "Execution Safety Guardrails",
       status: "pass",
       message: hasShellActivity ? "Shell/tool execution instructions include at least one safety guardrail." : "No shell/tool execution instructions detected."
@@ -846,6 +895,7 @@ async function runStructureChecks(context) {
   if (context.skill.lineCount > 500) {
     issues.push({
       id: "structure.skill-size",
+      checkId: "structure:file-size",
       title: "SKILL.md Size",
       status: "warn",
       message: `SKILL.md is ${context.skill.lineCount} lines (recommended max is 500).`,
@@ -854,6 +904,7 @@ async function runStructureChecks(context) {
   } else {
     issues.push({
       id: "structure.skill-size",
+      checkId: "structure:file-size",
       title: "SKILL.md Size",
       status: "pass",
       message: `SKILL.md length is ${context.skill.lineCount} lines.`
@@ -870,6 +921,7 @@ async function runStructureChecks(context) {
         oversizedWithoutToc += 1;
         issues.push({
           id: `structure.references.toc.${toPosixPath(path4.relative(context.skill.skillRoot, file))}`,
+          checkId: "structure:toc",
           title: "Reference File Navigation",
           status: "warn",
           message: `${toPosixPath(path4.relative(context.skill.skillRoot, file))} is ${lineCount} lines and has no table of contents.`,
@@ -880,6 +932,7 @@ async function runStructureChecks(context) {
     if (oversizedWithoutToc === 0) {
       issues.push({
         id: "structure.references.toc",
+        checkId: "structure:toc",
         title: "Reference File Navigation",
         status: "pass",
         message: "No oversized reference files missing a table of contents."
@@ -888,6 +941,7 @@ async function runStructureChecks(context) {
   } else {
     issues.push({
       id: "structure.references.toc",
+      checkId: "structure:toc",
       title: "Reference File Navigation",
       status: "pass",
       message: "No references/ directory found, so no long reference files to validate."
@@ -916,6 +970,7 @@ async function runStructureChecks(context) {
     if (missing.length > 0) {
       issues.push({
         id: `structure.${category.key}.exists`,
+        checkId: "structure:references",
         title: category.title,
         status: "fail",
         message: `Missing referenced ${category.key} file(s): ${missing.join(", ")}`,
@@ -924,6 +979,7 @@ async function runStructureChecks(context) {
     } else {
       issues.push({
         id: `structure.${category.key}.exists`,
+        checkId: "structure:references",
         title: category.title,
         status: "pass",
         message: `All referenced ${category.key} files exist.`
@@ -934,6 +990,7 @@ async function runStructureChecks(context) {
   if (missingGeneric.length > 0) {
     issues.push({
       id: "structure.relative-links.broken",
+      checkId: "structure:references",
       title: "Relative Links",
       status: "fail",
       message: `Broken relative path reference(s): ${missingGeneric.join(", ")}`,
@@ -942,6 +999,7 @@ async function runStructureChecks(context) {
   } else {
     issues.push({
       id: "structure.relative-links.broken",
+      checkId: "structure:references",
       title: "Relative Links",
       status: "pass",
       message: "No broken generic relative file references were found."
@@ -971,7 +1029,13 @@ function summarizeIssues(issues) {
   }
   return summary;
 }
-async function runLinter(inputPath) {
+function lintFails(report, failOn) {
+  if (report.summary.failures > 0) {
+    return true;
+  }
+  return failOn === "warn" && report.summary.warnings > 0;
+}
+async function runLinter(inputPath, options = {}) {
   const skill = await loadSkillFile(inputPath);
   const frontmatter = parseFrontmatter(skill.raw);
   const context = {
@@ -985,10 +1049,12 @@ async function runLinter(inputPath) {
   issues.push(...runSecurityChecks(context));
   issues.push(...await runDisclosureChecks(context));
   issues.push(...runCompatibilityChecks(context));
+  const suppress = new Set(options.suppress ?? []);
+  const filteredIssues = issues.filter((issue) => !suppress.has(issue.checkId));
   return {
     target: inputPath,
-    issues,
-    summary: summarizeIssues(issues)
+    issues: filteredIssues,
+    summary: summarizeIssues(filteredIssues)
   };
 }
 
@@ -1159,71 +1225,165 @@ function renderCheckReport(result, enableColor, verbose) {
   return lines.join("\n");
 }
 
-// src/reporters/json.ts
-function renderJson(value) {
-  return JSON.stringify(value, null, 2);
-}
-
 // src/commands/common.ts
-function getGlobalCliOptions(command) {
-  const options = command.optsWithGlobals();
-  return {
-    json: Boolean(options.json),
-    color: options.color !== false
-  };
-}
-function writeResult(value, asJson) {
-  if (asJson) {
-    process.stdout.write(`${renderJson(value)}
-`);
-    return;
+import fs5 from "node:fs/promises";
+import { z as z5 } from "zod";
+
+// src/core/eval-runner.ts
+import { z as z3 } from "zod";
+
+// src/core/grader.ts
+import { z as z2 } from "zod";
+var gradedAssertionSchema = z2.object({
+  assertion: z2.string(),
+  passed: z2.boolean(),
+  evidence: z2.string()
+});
+var graderOutputSchema = z2.object({
+  assertions: z2.array(gradedAssertionSchema)
+});
+function extractJsonObject(raw) {
+  const trimmed = raw.trim();
+  if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
+    return JSON.parse(trimmed);
   }
-  process.stdout.write(`${String(value)}
-`);
+  const start = trimmed.indexOf("{");
+  const end = trimmed.lastIndexOf("}");
+  if (start >= 0 && end > start) {
+    return JSON.parse(trimmed.slice(start, end + 1));
+  }
+  throw new Error("Grader did not return a JSON object.");
 }
-function writeError(error, asJson) {
-  const message = error instanceof Error ? error.message : String(error);
-  if (asJson) {
-    process.stdout.write(`${renderJson({ error: message })}
-`);
-    return;
+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."
+  ];
+  const systemPrompt = [
+    "You are a strict evaluator for agent skill outputs.",
+    "Assess each assertion and return JSON only.",
+    'Required output format: {"assertions":[{"assertion":"...","passed":true|false,"evidence":"..."}]}'
+  ].join(" ");
+  const userPrompt = [
+    `Skill: ${options.skillName}`,
+    "Skill instructions:",
+    options.skillBody,
+    "",
+    `User prompt: ${options.userPrompt}`,
+    "",
+    "Model response:",
+    options.modelResponse,
+    "",
+    "Assertions to evaluate:",
+    assertionList.map((assertion, index) => `${index + 1}. ${assertion}`).join("\n")
+  ].join("\n");
+  const raw = await options.provider.sendMessage(systemPrompt, userPrompt, { model: options.model });
+  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"}`);
   }
-  process.stderr.write(`Error: ${message}
-`);
+  return parsed.data.assertions;
 }
 
-// src/commands/lint.ts
-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) => {
-    const globalOptions = getGlobalCliOptions(command);
-    try {
-      const report = await runLinter(targetPath);
-      if (globalOptions.json) {
-        writeResult(report, true);
-      } else {
-        writeResult(renderLintReport(report, globalOptions.color), false);
-      }
-      if (report.summary.failures > 0) {
-        process.exitCode = 1;
-      }
-    } catch (error) {
-      writeError(error, globalOptions.json);
-      process.exitCode = 2;
+// src/core/eval-runner.ts
+var evalPromptSchema = z3.object({
+  prompt: z3.string().min(1),
+  assertions: z3.array(z3.string().min(1)).optional()
+});
+var evalPromptArraySchema = z3.array(evalPromptSchema);
+function extractJsonArray(raw) {
+  const trimmed = raw.trim();
+  if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+    return JSON.parse(trimmed);
+  }
+  const start = trimmed.indexOf("[");
+  const end = trimmed.lastIndexOf("]");
+  if (start >= 0 && end > start) {
+    return JSON.parse(trimmed.slice(start, end + 1));
+  }
+  throw new Error("Model did not return a JSON array.");
+}
+async function generatePrompts(skill, provider, model, count) {
+  const systemPrompt = [
+    "You generate realistic evaluation prompts for an agent skill.",
+    "Return JSON only.",
+    'Format: [{"prompt":"...","assertions":["...", "..."]}]',
+    "Assertions should be concrete and checkable."
+  ].join(" ");
+  const userPrompt = [
+    `Skill name: ${skill.frontmatter.name}`,
+    `Skill description: ${skill.frontmatter.description}`,
+    "Skill instructions:",
+    skill.content,
+    "",
+    `Generate ${count} prompts that stress the main capabilities and likely edge cases.`,
+    "Each prompt should include 2-4 assertions."
+  ].join("\n");
+  const raw = await provider.sendMessage(systemPrompt, userPrompt, { model });
+  const parsed = evalPromptArraySchema.safeParse(extractJsonArray(raw));
+  if (!parsed.success) {
+    throw new Error(`Failed to parse generated eval prompts: ${parsed.error.issues[0]?.message ?? "invalid prompt JSON"}`);
+  }
+  if (parsed.data.length !== count) {
+    throw new Error(`Expected ${count} prompts, got ${parsed.data.length}.`);
+  }
+  return parsed.data;
+}
+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 totalAssertions = results.reduce((total, result) => total + result.totalAssertions, 0);
+  const passedAssertions = results.reduce((total, result) => total + result.passedAssertions, 0);
+  return {
+    skillName: skill.frontmatter.name,
+    model: options.model,
+    graderModel: options.graderModel,
+    provider: options.provider.name,
+    prompts,
+    results,
+    summary: {
+      totalPrompts: results.length,
+      totalAssertions,
+      passedAssertions
     }
-  });
+  };
 }
 
-// src/commands/trigger.ts
-import ora from "ora";
-import { z as z3 } from "zod";
-
 // src/core/trigger-tester.ts
-import { z as z2 } from "zod";
-var triggerQuerySchema = z2.object({
-  query: z2.string().min(1),
-  should_trigger: z2.boolean()
+import { z as z4 } from "zod";
+var triggerQuerySchema = z4.object({
+  query: z4.string().min(1),
+  should_trigger: z4.boolean()
 });
-var triggerQueryArraySchema = z2.array(triggerQuerySchema);
+var triggerQueryArraySchema = z4.array(triggerQuerySchema);
 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." },
@@ -1241,16 +1401,23 @@ var FAKE_SKILLS = [
   { name: "test-generator", description: "Generates unit and integration test cases from feature requirements." },
   { name: "prompt-tuner", description: "Improves prompts for reliability, formatting, and failure handling." }
 ];
-function shuffle(values) {
+function createSeededRandom(seed) {
+  let state = seed >>> 0;
+  return () => {
+    state = state * 1664525 + 1013904223 >>> 0;
+    return state / 4294967296;
+  };
+}
+function shuffle(values, random = Math.random) {
   const copy = [...values];
   for (let index = copy.length - 1; index > 0; index -= 1) {
-    const swapIndex = Math.floor(Math.random() * (index + 1));
+    const swapIndex = Math.floor(random() * (index + 1));
     [copy[index], copy[swapIndex]] = [copy[swapIndex], copy[index]];
   }
   return copy;
 }
-function sample(values, count) {
-  return shuffle(values).slice(0, Math.max(0, Math.min(count, values.length)));
+function sample(values, count, random = Math.random) {
+  return shuffle(values, random).slice(0, Math.max(0, Math.min(count, values.length)));
 }
 function parseJsonArrayFromModelOutput(raw) {
   const trimmed = raw.trim();
@@ -1362,19 +1529,20 @@ function buildSuggestions(metrics) {
   return suggestions;
 }
 async function runTriggerTest(skill, options) {
+  const random = options.seed === void 0 ? Math.random : createSeededRandom(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(Math.random() * 4);
-    const fakeSkills = sample(FAKE_SKILLS, fakeCount);
+    const fakeCount = 5 + Math.floor(random() * 4);
+    const fakeSkills = sample(FAKE_SKILLS, fakeCount, random);
     const allSkills = shuffle([
       ...fakeSkills,
       {
         name: skill.frontmatter.name,
         description: skill.frontmatter.description
       }
-    ]);
+    ], random);
     const skillListText = allSkills.map((entry) => `- ${entry.name}: ${entry.description}`).join("\n");
     const systemPrompt = [
       "You are selecting one skill to activate for a user query.",
@@ -1410,74 +1578,517 @@ async function runTriggerTest(skill, options) {
   };
 }
 
-// src/utils/config.ts
-function resolveApiKey(provider, override) {
-  if (override && override.trim() !== "") {
-    return override.trim();
+// src/reporters/json.ts
+function renderJson(value) {
+  return JSON.stringify(value, null, 2);
+}
+
+// src/commands/common.ts
+var executionContextByCommand = /* @__PURE__ */ new WeakMap();
+var singleEvalPromptSchema = z5.object({
+  prompt: z5.string().min(1),
+  assertions: z5.array(z5.string().min(1)).optional()
+});
+var promptStringArraySchema = z5.array(z5.string().min(1));
+var assertionsObjectSchema = z5.object({
+  assertions: z5.array(z5.string().min(1))
+});
+function parseJsonIfPossible(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return raw;
   }
-  if (provider === "anthropic") {
-    const envValue2 = process.env.ANTHROPIC_API_KEY?.trim();
-    if (envValue2) {
-      return envValue2;
-    }
-    throw new Error(
-      "No Anthropic API key found. Set ANTHROPIC_API_KEY environment variable or pass --api-key flag."
-    );
+}
+function normalizeEvalPrompts(value, sourceLabel) {
+  const promptArray = evalPromptArraySchema.safeParse(value);
+  if (promptArray.success) {
+    return promptArray.data;
   }
-  const envValue = process.env.OPENAI_API_KEY?.trim();
-  if (envValue) {
-    return envValue;
+  const singlePrompt = singleEvalPromptSchema.safeParse(value);
+  if (singlePrompt.success) {
+    return [singlePrompt.data];
   }
-  throw new Error("No OpenAI API key found. Set OPENAI_API_KEY environment variable or pass --api-key flag.");
+  const promptStrings = promptStringArraySchema.safeParse(value);
+  if (promptStrings.success) {
+    return promptStrings.data.map((prompt) => ({ prompt }));
+  }
+  if (typeof value === "string" && value.trim() !== "") {
+    return [{ prompt: value.trim() }];
+  }
+  throw new Error(
+    `Invalid eval prompt source at ${sourceLabel}. Expected plain text, a JSON prompt object, or a JSON array of prompts.`
+  );
 }
-
-// src/providers/anthropic.ts
-import Anthropic from "@anthropic-ai/sdk";
-function wait(ms) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, ms);
-  });
+function parseAssertionsFromText(raw) {
+  return raw.split(/\r?\n/).map((line) => line.trim().replace(/^[-*]\s+/, "").replace(/^\d+\.\s+/, "")).filter((line) => line.length > 0);
 }
-function isRateLimitError(error) {
-  if (!error || typeof error !== "object") {
-    return false;
+function normalizeAssertions(value, sourceLabel) {
+  const assertionArray = z5.array(z5.string().min(1)).safeParse(value);
+  if (assertionArray.success) {
+    return assertionArray.data;
   }
-  const maybeStatus = error.status;
-  if (maybeStatus === 429) {
-    return true;
+  const assertionObject = assertionsObjectSchema.safeParse(value);
+  if (assertionObject.success) {
+    return assertionObject.data.assertions;
   }
-  const maybeMessage = error.message;
-  if (typeof maybeMessage === "string" && /rate limit/i.test(maybeMessage)) {
-    return true;
+  if (typeof value === "string") {
+    const assertions = parseAssertionsFromText(value);
+    if (assertions.length > 0) {
+      return assertions;
+    }
   }
-  return false;
+  throw new Error(
+    `Invalid eval assertions source at ${sourceLabel}. Expected JSON string[], { assertions: string[] }, or newline-delimited text.`
+  );
 }
-var AnthropicProvider = class {
-  name = "anthropic";
-  client;
-  constructor(apiKey) {
-    this.client = new Anthropic({ apiKey });
+function setCommandExecutionContext(command, context) {
+  executionContextByCommand.set(command, context);
+}
+function getCommandExecutionContext(command) {
+  const context = executionContextByCommand.get(command);
+  if (!context) {
+    throw new Error(`Missing resolved config for command '${command.name()}'.`);
   }
-  async sendMessage(systemPrompt, userMessage, options) {
-    let lastError;
-    for (let attempt = 0; attempt < 3; attempt += 1) {
-      try {
-        const response = await this.client.messages.create({
-          model: options.model,
-          max_tokens: 2048,
-          system: systemPrompt,
-          messages: [
-            {
-              role: "user",
-              content: userMessage
-            }
-          ]
-        });
-        const textBlocks = response.content.filter((block) => block.type === "text");
-        const text = textBlocks.map((block) => block.text).join("\n").trim();
-        if (text.length === 0) {
-          throw new Error("Model returned an empty response.");
-        }
+  return context;
+}
+function getResolvedConfig(command) {
+  return getCommandExecutionContext(command).config;
+}
+function getGlobalCliOptions(command) {
+  const options = command.optsWithGlobals();
+  const context = executionContextByCommand.get(command);
+  return {
+    json: context?.config.json ?? Boolean(options.json),
+    color: options.color !== false
+  };
+}
+async function loadTriggerQueriesFile(filePath) {
+  const loaded = await readJsonFile(filePath);
+  const parsed = triggerQueryArraySchema.safeParse(loaded);
+  if (!parsed.success) {
+    throw new Error(`Invalid --queries JSON: ${parsed.error.issues[0]?.message ?? "unknown format issue"}`);
+  }
+  return parsed.data;
+}
+async function loadEvalPromptsJson(filePath) {
+  const loaded = await readJsonFile(filePath);
+  const parsed = evalPromptArraySchema.safeParse(loaded);
+  if (!parsed.success) {
+    throw new Error(`Invalid --prompts JSON: ${parsed.error.issues[0]?.message ?? "unknown format issue"}`);
+  }
+  return parsed.data;
+}
+async function loadConfiguredEvalPrompts(command) {
+  const context = getCommandExecutionContext(command);
+  const promptFile = context.config.eval.promptFile;
+  const assertionsFile = context.config.eval.assertionsFile;
+  if (!promptFile && !assertionsFile) {
+    return void 0;
+  }
+  if (!promptFile && assertionsFile) {
+    throw new Error("Config field eval.assertionsFile requires eval.promptFile.");
+  }
+  const promptRaw = await fs5.readFile(promptFile, "utf8");
+  let prompts = normalizeEvalPrompts(parseJsonIfPossible(promptRaw), promptFile);
+  if (assertionsFile) {
+    const assertionsRaw = await fs5.readFile(assertionsFile, "utf8");
+    const assertions = normalizeAssertions(parseJsonIfPossible(assertionsRaw), assertionsFile);
+    prompts = prompts.map((prompt) => ({
+      prompt: prompt.prompt,
+      assertions: [...assertions]
+    }));
+  }
+  const numRunsWasExplicit = context.configFile?.eval?.numRuns !== void 0;
+  if (numRunsWasExplicit && prompts.length === 1 && context.config.eval.numRuns > 1) {
+    const promptTemplate = prompts[0];
+    prompts = Array.from({ length: context.config.eval.numRuns }, () => ({
+      prompt: promptTemplate.prompt,
+      assertions: promptTemplate.assertions ? [...promptTemplate.assertions] : void 0
+    }));
+  }
+  return prompts;
+}
+function writeResult(value, asJson) {
+  if (asJson) {
+    process.stdout.write(`${renderJson(value)}
+`);
+    return;
+  }
+  process.stdout.write(`${String(value)}
+`);
+}
+function writeError(error, asJson) {
+  const message = error instanceof Error ? error.message : String(error);
+  if (asJson) {
+    process.stdout.write(`${renderJson({ error: message })}
+`);
+    return;
+  }
+  process.stderr.write(`Error: ${message}
+`);
+}
+
+// src/commands/lint.ts
+async function handleLintCommand(targetPath, options) {
+  try {
+    const report = await runLinter(targetPath, { suppress: options.suppress });
+    if (options.json) {
+      writeResult(report, true);
+    } else {
+      writeResult(renderLintReport(report, options.color), false);
+    }
+    if (lintFails(report, options.failOn)) {
+      process.exitCode = 1;
+    }
+  } catch (error) {
+    writeError(error, options.json);
+    process.exitCode = 2;
+  }
+}
+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) => {
+    const globalOptions = getGlobalCliOptions(command);
+    const config = getResolvedConfig(command);
+    await handleLintCommand(targetPath, {
+      ...globalOptions,
+      failOn: config.lint.failOn,
+      suppress: config.lint.suppress
+    });
+  });
+}
+
+// src/commands/trigger.ts
+import ora from "ora";
+import { z as z7 } from "zod";
+
+// src/utils/config.ts
+import fs6 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({
+  failOn: lintFailOnSchema.optional(),
+  suppress: z6.array(z6.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()
+}).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()
+}).strict().partial();
+var skilltestConfigSchema = z6.object({
+  provider: providerNameSchema.optional(),
+  model: z6.string().min(1).optional(),
+  json: z6.boolean().optional(),
+  lint: lintConfigSchema.optional(),
+  trigger: triggerConfigSchema.optional(),
+  eval: evalConfigSchema.optional()
+}).strict();
+var resolvedSkilltestConfigSchema = z6.object({
+  provider: providerNameSchema,
+  model: z6.string().min(1),
+  json: z6.boolean(),
+  lint: z6.object({
+    failOn: lintFailOnSchema,
+    suppress: z6.array(z6.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()
+  }),
+  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()
+  })
+});
+var DEFAULT_SKILLTEST_CONFIG = {
+  provider: "anthropic",
+  model: "claude-sonnet-4-5-20250929",
+  json: false,
+  lint: {
+    failOn: "error",
+    suppress: []
+  },
+  trigger: {
+    numQueries: 20,
+    threshold: 0.8
+  },
+  eval: {
+    numRuns: 5,
+    threshold: 0.9
+  }
+};
+function formatIssuePath(issuePath) {
+  if (issuePath.length === 0) {
+    return "root";
+  }
+  return issuePath.map(String).join(".");
+}
+function buildConfigValidationError(error, sourceLabel) {
+  const issue = error.issues[0];
+  const issuePath = formatIssuePath(issue?.path ?? []);
+  const issueMessage = issue?.message ?? "Invalid config value.";
+  return new Error(`Invalid skilltest config in ${sourceLabel} at ${issuePath}: ${issueMessage}`);
+}
+async function readJsonObject(filePath, label) {
+  let raw;
+  try {
+    raw = await fs6.readFile(filePath, "utf8");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to read ${label}: ${message}`);
+  }
+  try {
+    return JSON.parse(raw);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Invalid JSON in ${label}: ${message}`);
+  }
+}
+async function loadConfigFromJsonFile(filePath) {
+  if (!await pathExists(filePath)) {
+    return null;
+  }
+  const raw = await readJsonObject(filePath, filePath);
+  const parsed = skilltestConfigSchema.safeParse(raw);
+  if (!parsed.success) {
+    throw buildConfigValidationError(parsed.error, filePath);
+  }
+  return {
+    configFile: parsed.data,
+    sourcePath: filePath,
+    sourceDirectory: path5.dirname(filePath)
+  };
+}
+async function loadConfigFromNearestPackageJson(startDirectory) {
+  let currentDirectory = path5.resolve(startDirectory);
+  while (true) {
+    const packageJsonPath = path5.join(currentDirectory, "package.json");
+    if (await pathExists(packageJsonPath)) {
+      const raw = await readJsonObject(packageJsonPath, packageJsonPath);
+      const packageJsonSchema = z6.object({
+        skilltestrc: skilltestConfigSchema.optional()
+      }).passthrough();
+      const parsed = packageJsonSchema.safeParse(raw);
+      if (!parsed.success) {
+        throw buildConfigValidationError(parsed.error, `${packageJsonPath}#skilltestrc`);
+      }
+      if (!parsed.data.skilltestrc) {
+        return null;
+      }
+      return {
+        configFile: parsed.data.skilltestrc,
+        sourcePath: packageJsonPath,
+        sourceDirectory: currentDirectory
+      };
+    }
+    const parentDirectory = path5.dirname(currentDirectory);
+    if (parentDirectory === currentDirectory) {
+      return null;
+    }
+    currentDirectory = parentDirectory;
+  }
+}
+async function resolveSkillDirectoryConfig(targetPath) {
+  if (!targetPath) {
+    return null;
+  }
+  try {
+    const { skillRoot } = await resolveSkillPath(targetPath);
+    return loadConfigFromJsonFile(path5.join(skillRoot, ".skilltestrc"));
+  } catch {
+    return null;
+  }
+}
+function resolveConfigRelativePath(baseDirectory, value) {
+  if (!value) {
+    return void 0;
+  }
+  return path5.resolve(baseDirectory, value);
+}
+function mergeConfigLayers(configFile = {}, cliFlags = {}, baseDirectory = process.cwd()) {
+  const merged = {
+    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,
+    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
+    },
+    trigger: {
+      numQueries: cliFlags.trigger?.numQueries ?? configFile.trigger?.numQueries ?? DEFAULT_SKILLTEST_CONFIG.trigger.numQueries,
+      threshold: cliFlags.trigger?.threshold ?? configFile.trigger?.threshold ?? DEFAULT_SKILLTEST_CONFIG.trigger.threshold,
+      seed: cliFlags.trigger?.seed ?? configFile.trigger?.seed
+    },
+    eval: {
+      numRuns: cliFlags.eval?.numRuns ?? configFile.eval?.numRuns ?? DEFAULT_SKILLTEST_CONFIG.eval.numRuns,
+      threshold: cliFlags.eval?.threshold ?? configFile.eval?.threshold ?? DEFAULT_SKILLTEST_CONFIG.eval.threshold,
+      promptFile: resolveConfigRelativePath(
+        baseDirectory,
+        cliFlags.eval?.promptFile ?? configFile.eval?.promptFile ?? DEFAULT_SKILLTEST_CONFIG.eval.promptFile
+      ),
+      assertionsFile: resolveConfigRelativePath(
+        baseDirectory,
+        cliFlags.eval?.assertionsFile ?? configFile.eval?.assertionsFile ?? DEFAULT_SKILLTEST_CONFIG.eval.assertionsFile
+      )
+    }
+  };
+  return resolvedSkilltestConfigSchema.parse(merged);
+}
+function getTypedOptionValue(command, key) {
+  const options = command.optsWithGlobals();
+  const value = options[key];
+  if (value === void 0) {
+    return void 0;
+  }
+  return value;
+}
+function extractCliConfigOverrides(command) {
+  const overrides = {};
+  if (command.getOptionValueSourceWithGlobals("json") === "cli") {
+    overrides.json = Boolean(getTypedOptionValue(command, "json"));
+  }
+  if (command.getOptionValueSource("provider") === "cli") {
+    overrides.provider = getTypedOptionValue(command, "provider");
+  }
+  if (command.getOptionValueSource("model") === "cli") {
+    overrides.model = getTypedOptionValue(command, "model");
+  }
+  if ((command.name() === "trigger" || command.name() === "check") && command.getOptionValueSource("numQueries") === "cli") {
+    overrides.trigger = {
+      ...overrides.trigger,
+      numQueries: getTypedOptionValue(command, "numQueries")
+    };
+  }
+  if (command.name() === "check" && command.getOptionValueSource("minF1") === "cli") {
+    overrides.trigger = {
+      ...overrides.trigger,
+      threshold: getTypedOptionValue(command, "minF1")
+    };
+  }
+  if (command.name() === "check" && command.getOptionValueSource("minAssertPassRate") === "cli") {
+    overrides.eval = {
+      ...overrides.eval,
+      threshold: getTypedOptionValue(command, "minAssertPassRate")
+    };
+  }
+  const parsed = skilltestConfigSchema.safeParse(overrides);
+  if (!parsed.success) {
+    throw buildConfigValidationError(parsed.error, "CLI flags");
+  }
+  return parsed.data;
+}
+async function resolveConfigContext(targetPath, cliFlags) {
+  const cwd = process.cwd();
+  const skillDirectoryConfig = await resolveSkillDirectoryConfig(targetPath);
+  if (skillDirectoryConfig) {
+    return {
+      configFile: skillDirectoryConfig.configFile,
+      ...skillDirectoryConfig,
+      config: mergeConfigLayers(skillDirectoryConfig.configFile, cliFlags, skillDirectoryConfig.sourceDirectory)
+    };
+  }
+  const cwdConfigPath = path5.join(cwd, ".skilltestrc");
+  const cwdConfig = await loadConfigFromJsonFile(cwdConfigPath);
+  if (cwdConfig) {
+    return {
+      configFile: cwdConfig.configFile,
+      ...cwdConfig,
+      config: mergeConfigLayers(cwdConfig.configFile, cliFlags, cwdConfig.sourceDirectory)
+    };
+  }
+  const packageJsonConfig = await loadConfigFromNearestPackageJson(cwd);
+  if (packageJsonConfig) {
+    return {
+      configFile: packageJsonConfig.configFile,
+      ...packageJsonConfig,
+      config: mergeConfigLayers(packageJsonConfig.configFile, cliFlags, packageJsonConfig.sourceDirectory)
+    };
+  }
+  return {
+    configFile: null,
+    config: mergeConfigLayers({}, cliFlags, cwd),
+    sourcePath: null,
+    sourceDirectory: cwd
+  };
+}
+function resolveApiKey(provider, override) {
+  if (override && override.trim() !== "") {
+    return override.trim();
+  }
+  if (provider === "anthropic") {
+    const envValue2 = process.env.ANTHROPIC_API_KEY?.trim();
+    if (envValue2) {
+      return envValue2;
+    }
+    throw new Error(
+      "No Anthropic API key found. Set ANTHROPIC_API_KEY environment variable or pass --api-key flag."
+    );
+  }
+  const envValue = process.env.OPENAI_API_KEY?.trim();
+  if (envValue) {
+    return envValue;
+  }
+  throw new Error("No OpenAI API key found. Set OPENAI_API_KEY environment variable or pass --api-key flag.");
+}
+
+// src/providers/anthropic.ts
+import Anthropic from "@anthropic-ai/sdk";
+function wait(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+function isRateLimitError(error) {
+  if (!error || typeof error !== "object") {
+    return false;
+  }
+  const maybeStatus = error.status;
+  if (maybeStatus === 429) {
+    return true;
+  }
+  const maybeMessage = error.message;
+  if (typeof maybeMessage === "string" && /rate limit/i.test(maybeMessage)) {
+    return true;
+  }
+  return false;
+}
+var AnthropicProvider = class {
+  name = "anthropic";
+  client;
+  constructor(apiKey) {
+    this.client = new Anthropic({ apiKey });
+  }
+  async sendMessage(systemPrompt, userMessage, options) {
+    let lastError;
+    for (let attempt = 0; attempt < 3; attempt += 1) {
+      try {
+        const response = await this.client.messages.create({
+          model: options.model,
+          max_tokens: 2048,
+          system: systemPrompt,
+          messages: [
+            {
+              role: "user",
+              content: userMessage
+            }
+          ]
+        });
+        const textBlocks = response.content.filter((block) => block.type === "text");
+        const text = textBlocks.map((block) => block.text).join("\n").trim();
+        if (text.length === 0) {
+          throw new Error("Model returned an empty response.");
+        }
         return text;
       } catch (error) {
         lastError = error;
@@ -1607,14 +2218,11 @@ function createProvider(providerName, apiKeyOverride) {
 }
 
 // src/commands/trigger.ts
-var triggerOptionsSchema = z3.object({
-  model: z3.string(),
-  provider: z3.enum(["anthropic", "openai"]),
-  queries: z3.string().optional(),
-  numQueries: z3.number().int().min(2),
-  saveQueries: z3.string().optional(),
-  verbose: z3.boolean().optional(),
-  apiKey: z3.string().optional()
+var triggerCliSchema = z7.object({
+  queries: z7.string().optional(),
+  saveQueries: z7.string().optional(),
+  verbose: z7.boolean().optional(),
+  apiKey: z7.string().optional()
 });
 var DEFAULT_ANTHROPIC_MODEL = "claude-sonnet-4-5-20250929";
 var DEFAULT_OPENAI_MODEL = "gpt-4.1-mini";
@@ -1624,230 +2232,84 @@ function resolveModel(provider, model) {
   }
   return model;
 }
-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", DEFAULT_ANTHROPIC_MODEL).option("--provider <provider>", "LLM provider: anthropic|openai", "anthropic").option("--queries <path>", "Path to custom test queries JSON").option("--num-queries <n>", "Number of auto-generated queries", (value) => Number.parseInt(value, 10), 20).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 parsedOptions = triggerOptionsSchema.safeParse(commandOptions);
-    if (!parsedOptions.success) {
-      writeError(new Error(parsedOptions.error.issues[0]?.message ?? "Invalid trigger options."), globalOptions.json);
-      process.exitCode = 2;
-      return;
+async function handleTriggerCommand(targetPath, options) {
+  const spinner = options.json || !process.stdout.isTTY ? null : ora("Preparing trigger evaluation...").start();
+  try {
+    if (spinner) {
+      spinner.text = "Parsing skill...";
     }
-    const options = parsedOptions.data;
-    const spinner = globalOptions.json || !process.stdout.isTTY ? null : ora("Preparing trigger evaluation...").start();
-    try {
-      if (options.numQueries % 2 !== 0) {
-        throw new Error("--num-queries must be an even number so the suite can split should/should-not trigger cases.");
-      }
-      if (spinner) {
-        spinner.text = "Parsing skill...";
-      }
-      const skill = await parseSkillStrict(targetPath);
-      if (spinner) {
-        spinner.text = "Initializing model provider...";
-      }
-      const provider = createProvider(options.provider, options.apiKey);
-      let queries = void 0;
-      if (options.queries) {
-        if (spinner) {
-          spinner.text = "Loading custom trigger queries...";
-        }
-        const loaded = await readJsonFile(options.queries);
-        const parsedQueries = triggerQueryArraySchema.safeParse(loaded);
-        if (!parsedQueries.success) {
-          throw new Error(`Invalid --queries JSON: ${parsedQueries.error.issues[0]?.message ?? "unknown format issue"}`);
-        }
-        queries = parsedQueries.data;
-      }
+    const skill = await parseSkillStrict(targetPath);
+    if (spinner) {
+      spinner.text = "Initializing model provider...";
+    }
+    const provider = createProvider(options.provider, options.apiKey);
+    let queries = void 0;
+    if (options.queries) {
       if (spinner) {
-        spinner.text = "Running trigger simulations...";
-      }
-      const model = resolveModel(options.provider, options.model);
-      const result = await runTriggerTest(skill, {
-        model,
-        provider,
-        queries,
-        numQueries: options.numQueries,
-        verbose: Boolean(options.verbose)
-      });
-      if (options.saveQueries) {
-        await writeJsonFile(options.saveQueries, result.queries);
-      }
-      spinner?.stop();
-      if (globalOptions.json) {
-        writeResult(result, true);
-      } else {
-        writeResult(renderTriggerReport(result, globalOptions.color, Boolean(options.verbose)), false);
+        spinner.text = "Loading custom trigger queries...";
       }
-    } catch (error) {
-      spinner?.stop();
-      writeError(error, globalOptions.json);
-      process.exitCode = 2;
+      queries = await loadTriggerQueriesFile(options.queries);
     }
-  });
-}
-
-// src/commands/eval.ts
-import ora2 from "ora";
-import { z as z6 } from "zod";
-
-// src/core/eval-runner.ts
-import { z as z5 } from "zod";
-
-// src/core/grader.ts
-import { z as z4 } from "zod";
-var gradedAssertionSchema = z4.object({
-  assertion: z4.string(),
-  passed: z4.boolean(),
-  evidence: z4.string()
-});
-var graderOutputSchema = z4.object({
-  assertions: z4.array(gradedAssertionSchema)
-});
-function extractJsonObject(raw) {
-  const trimmed = raw.trim();
-  if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
-    return JSON.parse(trimmed);
-  }
-  const start = trimmed.indexOf("{");
-  const end = trimmed.lastIndexOf("}");
-  if (start >= 0 && end > start) {
-    return JSON.parse(trimmed.slice(start, end + 1));
-  }
-  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."
-  ];
-  const systemPrompt = [
-    "You are a strict evaluator for agent skill outputs.",
-    "Assess each assertion and return JSON only.",
-    'Required output format: {"assertions":[{"assertion":"...","passed":true|false,"evidence":"..."}]}'
-  ].join(" ");
-  const userPrompt = [
-    `Skill: ${options.skillName}`,
-    "Skill instructions:",
-    options.skillBody,
-    "",
-    `User prompt: ${options.userPrompt}`,
-    "",
-    "Model response:",
-    options.modelResponse,
-    "",
-    "Assertions to evaluate:",
-    assertionList.map((assertion, index) => `${index + 1}. ${assertion}`).join("\n")
-  ].join("\n");
-  const raw = await options.provider.sendMessage(systemPrompt, userPrompt, { model: options.model });
-  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;
-}
-
-// src/core/eval-runner.ts
-var evalPromptSchema = z5.object({
-  prompt: z5.string().min(1),
-  assertions: z5.array(z5.string().min(1)).optional()
-});
-var evalPromptArraySchema = z5.array(evalPromptSchema);
-function extractJsonArray(raw) {
-  const trimmed = raw.trim();
-  if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
-    return JSON.parse(trimmed);
-  }
-  const start = trimmed.indexOf("[");
-  const end = trimmed.lastIndexOf("]");
-  if (start >= 0 && end > start) {
-    return JSON.parse(trimmed.slice(start, end + 1));
-  }
-  throw new Error("Model did not return a JSON array.");
-}
-async function generatePrompts(skill, provider, model, count) {
-  const systemPrompt = [
-    "You generate realistic evaluation prompts for an agent skill.",
-    "Return JSON only.",
-    'Format: [{"prompt":"...","assertions":["...", "..."]}]',
-    "Assertions should be concrete and checkable."
-  ].join(" ");
-  const userPrompt = [
-    `Skill name: ${skill.frontmatter.name}`,
-    `Skill description: ${skill.frontmatter.description}`,
-    "Skill instructions:",
-    skill.content,
-    "",
-    `Generate ${count} prompts that stress the main capabilities and likely edge cases.`,
-    "Each prompt should include 2-4 assertions."
-  ].join("\n");
-  const raw = await provider.sendMessage(systemPrompt, userPrompt, { model });
-  const parsed = evalPromptArraySchema.safeParse(extractJsonArray(raw));
-  if (!parsed.success) {
-    throw new Error(`Failed to parse generated eval prompts: ${parsed.error.issues[0]?.message ?? "invalid prompt JSON"}`);
-  }
-  if (parsed.data.length !== count) {
-    throw new Error(`Expected ${count} prompts, got ${parsed.data.length}.`);
-  }
-  return parsed.data;
-}
-async function runEval(skill, options) {
-  const prompts = options.prompts && options.prompts.length > 0 ? evalPromptArraySchema.parse(options.prompts) : await generatePrompts(skill, options.provider, options.model, 5);
-  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
+    if (spinner) {
+      spinner.text = "Running trigger simulations...";
+    }
+    const model = resolveModel(options.provider, options.model);
+    const result = await runTriggerTest(skill, {
+      model,
+      provider,
+      queries,
+      numQueries: options.numQueries,
+      seed: options.seed,
+      verbose: options.verbose
     });
+    if (options.saveQueries) {
+      await writeJsonFile(options.saveQueries, result.queries);
+    }
+    spinner?.stop();
+    if (options.json) {
+      writeResult(result, true);
+    } else {
+      writeResult(renderTriggerReport(result, options.color, options.verbose), false);
+    }
+  } catch (error) {
+    spinner?.stop();
+    writeError(error, options.json);
+    process.exitCode = 2;
   }
-  const totalAssertions = results.reduce((total, result) => total + result.totalAssertions, 0);
-  const passedAssertions = results.reduce((total, result) => total + result.passedAssertions, 0);
-  return {
-    skillName: skill.frontmatter.name,
-    model: options.model,
-    graderModel: options.graderModel,
-    provider: options.provider.name,
-    prompts,
-    results,
-    summary: {
-      totalPrompts: results.length,
-      totalAssertions,
-      passedAssertions
+}
+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("--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());
+    if (!parsedCli.success) {
+      writeError(new Error(parsedCli.error.issues[0]?.message ?? "Invalid trigger options."), globalOptions.json);
+      process.exitCode = 2;
+      return;
     }
-  };
+    await handleTriggerCommand(targetPath, {
+      ...globalOptions,
+      model: config.model,
+      provider: config.provider,
+      queries: parsedCli.data.queries,
+      numQueries: config.trigger.numQueries,
+      saveQueries: parsedCli.data.saveQueries,
+      seed: config.trigger.seed,
+      verbose: Boolean(parsedCli.data.verbose),
+      apiKey: parsedCli.data.apiKey
+    });
+  });
 }
 
 // src/commands/eval.ts
-var evalOptionsSchema = z6.object({
-  prompts: z6.string().optional(),
-  model: z6.string(),
-  graderModel: z6.string().optional(),
-  provider: z6.enum(["anthropic", "openai"]),
-  saveResults: z6.string().optional(),
-  verbose: z6.boolean().optional(),
-  apiKey: z6.string().optional()
+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()
 });
 var DEFAULT_ANTHROPIC_MODEL2 = "claude-sonnet-4-5-20250929";
 var DEFAULT_OPENAI_MODEL2 = "gpt-4.1-mini";
@@ -1857,69 +2319,84 @@ function resolveModel2(provider, model) {
   }
   return model;
 }
-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", DEFAULT_ANTHROPIC_MODEL2).option("--grader-model <model>", "Model used for grading (defaults to --model)").option("--provider <provider>", "LLM provider: anthropic|openai", "anthropic").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 parsedOptions = evalOptionsSchema.safeParse(commandOptions);
-    if (!parsedOptions.success) {
-      writeError(new Error(parsedOptions.error.issues[0]?.message ?? "Invalid eval options."), globalOptions.json);
-      process.exitCode = 2;
-      return;
+async function handleEvalCommand(targetPath, options, command) {
+  const spinner = options.json || !process.stdout.isTTY ? null : ora2("Preparing evaluation...").start();
+  try {
+    if (spinner) {
+      spinner.text = "Parsing skill...";
     }
-    const options = parsedOptions.data;
-    const spinner = globalOptions.json || !process.stdout.isTTY ? null : ora2("Preparing evaluation...").start();
-    try {
-      if (spinner) {
-        spinner.text = "Parsing skill...";
-      }
-      const skill = await parseSkillStrict(targetPath);
-      if (spinner) {
-        spinner.text = "Initializing model provider...";
-      }
-      const provider = createProvider(options.provider, options.apiKey);
-      let prompts = void 0;
-      if (options.prompts) {
-        if (spinner) {
-          spinner.text = "Loading test prompts...";
-        }
-        const loaded = await readJsonFile(options.prompts);
-        const parsedPrompts = evalPromptArraySchema.safeParse(loaded);
-        if (!parsedPrompts.success) {
-          throw new Error(`Invalid --prompts JSON: ${parsedPrompts.error.issues[0]?.message ?? "unknown format issue"}`);
-        }
-        prompts = parsedPrompts.data;
-      }
+    const skill = await parseSkillStrict(targetPath);
+    if (spinner) {
+      spinner.text = "Initializing model provider...";
+    }
+    const provider = createProvider(options.provider, options.apiKey);
+    let prompts = void 0;
+    if (options.prompts) {
       if (spinner) {
-        spinner.text = "Running eval prompts and grading responses...";
+        spinner.text = "Loading test prompts...";
       }
-      const model = resolveModel2(options.provider, options.model);
-      const graderModel = options.graderModel ?? model;
-      const result = await runEval(skill, {
-        provider,
-        model,
-        graderModel,
-        prompts
-      });
-      if (options.saveResults) {
-        await writeJsonFile(options.saveResults, result);
-      }
-      spinner?.stop();
-      if (globalOptions.json) {
-        writeResult(result, true);
-      } else {
-        writeResult(renderEvalReport(result, globalOptions.color, Boolean(options.verbose)), false);
-      }
-    } catch (error) {
-      spinner?.stop();
-      writeError(error, globalOptions.json);
+      prompts = await loadEvalPromptsJson(options.prompts);
+    } else {
+      prompts = await loadConfiguredEvalPrompts(command);
+    }
+    if (spinner) {
+      spinner.text = "Running eval prompts and grading responses...";
+    }
+    const model = resolveModel2(options.provider, options.model);
+    const graderModel = options.graderModel ?? model;
+    const result = await runEval(skill, {
+      provider,
+      model,
+      graderModel,
+      numRuns: options.numRuns,
+      prompts
+    });
+    if (options.saveResults) {
+      await writeJsonFile(options.saveResults, result);
+    }
+    spinner?.stop();
+    if (options.json) {
+      writeResult(result, true);
+    } else {
+      writeResult(renderEvalReport(result, options.color, options.verbose), false);
+    }
+  } catch (error) {
+    spinner?.stop();
+    writeError(error, options.json);
+    process.exitCode = 2;
+  }
+}
+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) => {
+    const globalOptions = getGlobalCliOptions(command);
+    const config = getResolvedConfig(command);
+    const parsedCli = evalCliSchema.safeParse(command.opts());
+    if (!parsedCli.success) {
+      writeError(new Error(parsedCli.error.issues[0]?.message ?? "Invalid eval options."), globalOptions.json);
       process.exitCode = 2;
+      return;
     }
+    await handleEvalCommand(
+      targetPath,
+      {
+        ...globalOptions,
+        prompts: parsedCli.data.prompts,
+        model: config.model,
+        graderModel: parsedCli.data.graderModel,
+        provider: config.provider,
+        saveResults: parsedCli.data.saveResults,
+        verbose: Boolean(parsedCli.data.verbose),
+        apiKey: parsedCli.data.apiKey,
+        numRuns: config.eval.numRuns
+      },
+      command
+    );
   });
 }
 
 // src/commands/check.ts
 import ora3 from "ora";
-import { z as z7 } from "zod";
+import { z as z9 } from "zod";
 
 // src/core/check-runner.ts
 function calculateEvalAssertPassRate(result) {
@@ -1930,8 +2407,8 @@ function calculateEvalAssertPassRate(result) {
 }
 async function runCheck(inputPath, options) {
   options.onStage?.("lint");
-  const lint = await runLinter(inputPath);
-  const lintPassed = lint.summary.failures === 0;
+  const lint = await runLinter(inputPath, { suppress: options.lintSuppress });
+  const lintPassed = !lintFails(lint, options.lintFailOn);
   let trigger = null;
   let evalResult = null;
   let triggerSkippedReason;
@@ -1956,6 +2433,7 @@ async function runCheck(inputPath, options) {
         model: options.model,
         queries: options.queries,
         numQueries: options.numQueries,
+        seed: options.triggerSeed,
         verbose: options.verbose
       });
       options.onStage?.("eval");
@@ -1963,6 +2441,7 @@ async function runCheck(inputPath, options) {
         provider: options.provider,
         model: options.model,
         graderModel: options.graderModel,
+        numRuns: options.evalNumRuns,
         prompts: options.prompts
       });
     }
@@ -1999,19 +2478,14 @@ async function runCheck(inputPath, options) {
 }
 
 // src/commands/check.ts
-var checkOptionsSchema = z7.object({
-  provider: z7.enum(["anthropic", "openai"]),
-  model: z7.string(),
-  graderModel: z7.string().optional(),
-  apiKey: z7.string().optional(),
-  queries: z7.string().optional(),
-  numQueries: z7.number().int().min(2),
-  prompts: z7.string().optional(),
-  minF1: z7.number().min(0).max(1),
-  minAssertPassRate: z7.number().min(0).max(1),
-  saveResults: z7.string().optional(),
-  continueOnLintFail: z7.boolean().optional(),
-  verbose: z7.boolean().optional()
+var checkCliSchema = z9.object({
+  graderModel: z9.string().optional(),
+  apiKey: z9.string().optional(),
+  queries: z9.string().optional(),
+  prompts: z9.string().optional(),
+  saveResults: z9.string().optional(),
+  continueOnLintFail: z9.boolean().optional(),
+  verbose: z9.boolean().optional()
 });
 var DEFAULT_ANTHROPIC_MODEL3 = "claude-sonnet-4-5-20250929";
 var DEFAULT_OPENAI_MODEL3 = "gpt-4.1-mini";
@@ -2021,106 +2495,110 @@ function resolveModel3(provider, model) {
   }
   return model;
 }
-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", "anthropic").option("--model <model>", "Model for trigger/eval runs", DEFAULT_ANTHROPIC_MODEL3).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), 20).option("--prompts <path>", "Path to eval prompts JSON").option("--min-f1 <n>", "Minimum required trigger F1 score (0-1)", (value) => Number.parseFloat(value), 0.8).option(
-    "--min-assert-pass-rate <n>",
-    "Minimum required eval assertion pass rate (0-1)",
-    (value) => Number.parseFloat(value),
-    0.9
-  ).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 parsedOptions = checkOptionsSchema.safeParse(commandOptions);
-    if (!parsedOptions.success) {
-      writeError(new Error(parsedOptions.error.issues[0]?.message ?? "Invalid check options."), globalOptions.json);
-      process.exitCode = 2;
-      return;
-    }
-    const options = parsedOptions.data;
-    if (options.numQueries % 2 !== 0) {
-      writeError(
-        new Error("--num-queries must be an even number so the suite can split should/should-not trigger cases."),
-        globalOptions.json
-      );
-      process.exitCode = 2;
-      return;
+async function handleCheckCommand(targetPath, options, command) {
+  const spinner = options.json || !process.stdout.isTTY ? null : ora3("Preparing check run...").start();
+  try {
+    if (spinner) {
+      spinner.text = "Initializing model provider...";
     }
-    const spinner = globalOptions.json || !process.stdout.isTTY ? null : ora3("Preparing check run...").start();
-    try {
+    const provider = createProvider(options.provider, options.apiKey);
+    let queries = void 0;
+    if (options.queries) {
       if (spinner) {
-        spinner.text = "Initializing model provider...";
+        spinner.text = "Loading custom trigger queries...";
       }
-      const provider = createProvider(options.provider, options.apiKey);
-      let queries = void 0;
-      if (options.queries) {
-        if (spinner) {
-          spinner.text = "Loading custom trigger queries...";
-        }
-        const loadedQueries = await readJsonFile(options.queries);
-        const parsedQueries = triggerQueryArraySchema.safeParse(loadedQueries);
-        if (!parsedQueries.success) {
-          throw new Error(
-            `Invalid --queries JSON: ${parsedQueries.error.issues[0]?.message ?? "unknown format issue"}`
-          );
-        }
-        queries = parsedQueries.data;
+      queries = await loadTriggerQueriesFile(options.queries);
+    }
+    let prompts = void 0;
+    if (options.prompts) {
+      if (spinner) {
+        spinner.text = "Loading eval prompts...";
       }
-      let prompts = void 0;
-      if (options.prompts) {
-        if (spinner) {
-          spinner.text = "Loading eval prompts...";
-        }
-        const loadedPrompts = await readJsonFile(options.prompts);
-        const parsedPrompts = evalPromptArraySchema.safeParse(loadedPrompts);
-        if (!parsedPrompts.success) {
-          throw new Error(
-            `Invalid --prompts JSON: ${parsedPrompts.error.issues[0]?.message ?? "unknown format issue"}`
-          );
+      prompts = await loadEvalPromptsJson(options.prompts);
+    } else {
+      prompts = await loadConfiguredEvalPrompts(command);
+    }
+    const model = resolveModel3(options.provider, options.model);
+    const graderModel = options.graderModel ?? model;
+    const result = await runCheck(targetPath, {
+      provider,
+      model,
+      graderModel,
+      lintFailOn: options.lintFailOn,
+      lintSuppress: options.lintSuppress,
+      queries,
+      numQueries: options.numQueries,
+      triggerSeed: options.triggerSeed,
+      prompts,
+      evalNumRuns: options.numRuns,
+      minF1: options.minF1,
+      minAssertPassRate: options.minAssertPassRate,
+      continueOnLintFail: options.continueOnLintFail,
+      verbose: options.verbose,
+      onStage: (stage) => {
+        if (!spinner) {
+          return;
         }
-        prompts = parsedPrompts.data;
-      }
-      const model = resolveModel3(options.provider, options.model);
-      const graderModel = options.graderModel ?? model;
-      const result = await runCheck(targetPath, {
-        provider,
-        model,
-        graderModel,
-        queries,
-        numQueries: options.numQueries,
-        prompts,
-        minF1: options.minF1,
-        minAssertPassRate: options.minAssertPassRate,
-        continueOnLintFail: Boolean(options.continueOnLintFail),
-        verbose: Boolean(options.verbose),
-        onStage: (stage) => {
-          if (!spinner) {
-            return;
-          }
-          if (stage === "lint") {
-            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...";
-          }
+        if (stage === "lint") {
+          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...";
         }
-      });
-      if (options.saveResults) {
-        await writeJsonFile(options.saveResults, result);
-      }
-      spinner?.stop();
-      if (globalOptions.json) {
-        writeResult(result, true);
-      } else {
-        writeResult(renderCheckReport(result, globalOptions.color, Boolean(options.verbose)), false);
       }
-      process.exitCode = result.gates.overallPassed ? 0 : 1;
-    } catch (error) {
-      spinner?.stop();
-      writeError(error, globalOptions.json);
+    });
+    if (options.saveResults) {
+      await writeJsonFile(options.saveResults, result);
+    }
+    spinner?.stop();
+    if (options.json) {
+      writeResult(result, true);
+    } else {
+      writeResult(renderCheckReport(result, options.color, options.verbose), false);
+    }
+    process.exitCode = result.gates.overallPassed ? 0 : 1;
+  } catch (error) {
+    spinner?.stop();
+    writeError(error, options.json);
+    process.exitCode = 2;
+  }
+}
+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("--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) => {
+    const globalOptions = getGlobalCliOptions(command);
+    const config = getResolvedConfig(command);
+    const parsedCli = checkCliSchema.safeParse(command.opts());
+    if (!parsedCli.success) {
+      writeError(new Error(parsedCli.error.issues[0]?.message ?? "Invalid check options."), globalOptions.json);
       process.exitCode = 2;
+      return;
     }
+    await handleCheckCommand(
+      targetPath,
+      {
+        ...globalOptions,
+        provider: config.provider,
+        model: config.model,
+        graderModel: parsedCli.data.graderModel,
+        apiKey: parsedCli.data.apiKey,
+        queries: parsedCli.data.queries,
+        numQueries: config.trigger.numQueries,
+        prompts: parsedCli.data.prompts,
+        minF1: config.trigger.threshold,
+        minAssertPassRate: config.eval.threshold,
+        numRuns: config.eval.numRuns,
+        lintFailOn: config.lint.failOn,
+        lintSuppress: config.lint.suppress,
+        triggerSeed: config.trigger.seed,
+        saveResults: parsedCli.data.saveResults,
+        continueOnLintFail: Boolean(parsedCli.data.continueOnLintFail),
+        verbose: Boolean(parsedCli.data.verbose)
+      },
+      command
+    );
   });
 }
 
@@ -2128,27 +2606,49 @@ function registerCheckCommand(program) {
 function resolveVersion() {
   try {
     const currentFilePath = fileURLToPath(import.meta.url);
-    const packageJsonPath = path5.resolve(path5.dirname(currentFilePath), "..", "package.json");
-    const raw = fs5.readFileSync(packageJsonPath, "utf8");
+    const packageJsonPath = path6.resolve(path6.dirname(currentFilePath), "..", "package.json");
+    const raw = fs7.readFileSync(packageJsonPath, "utf8");
     const parsed = JSON.parse(raw);
     return parsed.version ?? "0.0.0";
   } catch {
     return "0.0.0";
   }
 }
+function shouldRenderJson(argv) {
+  return argv.includes("--json");
+}
+function renderTopLevelError(error, asJson) {
+  const message = error instanceof Error ? error.message : String(error);
+  if (asJson) {
+    process.stdout.write(`${JSON.stringify({ error: message }, null, 2)}
+`);
+    return;
+  }
+  process.stderr.write(`Error: ${message}
+`);
+}
 async function run(argv) {
   const program = new Command();
   program.name("skilltest").description("The testing framework for Agent Skills.").version(resolveVersion()).option("--json", "Output results as JSON").option("--no-color", "Disable colored output").showHelpAfterError();
+  program.hook("preAction", async (_program, actionCommand) => {
+    const targetPath = typeof actionCommand.processedArgs[0] === "string" ? actionCommand.processedArgs[0] : void 0;
+    const cliOverrides = extractCliConfigOverrides(actionCommand);
+    const context = await resolveConfigContext(targetPath, cliOverrides);
+    setCommandExecutionContext(actionCommand, context);
+  });
   registerLintCommand(program);
   registerTriggerCommand(program);
   registerEvalCommand(program);
   registerCheckCommand(program);
-  await program.parseAsync(argv);
+  try {
+    await program.parseAsync(argv);
+  } catch (error) {
+    renderTopLevelError(error, shouldRenderJson(argv));
+    process.exitCode = 2;
+  }
 }
 run(process.argv).catch((error) => {
-  const message = error instanceof Error ? error.message : String(error);
-  process.stderr.write(`Error: ${message}
-`);
+  renderTopLevelError(error, shouldRenderJson(process.argv));
   process.exitCode = 2;
 });
 export {