@noir-ai/skills 1.9.3 → 1.9.4-beta.2

package/builtin/noir-writing-skills/SKILL.md

@@ -0,0 +1,42 @@
+---
+name: noir-writing-skills
+description: Use when authoring or revising a Noir skill — ensure it is valid, WHEN+WHAT-described, structurally complete, and genuinely useful when invoked. Use when the user says "write a skill" or "update a skill". Do NOT use for general documentation.
+metadata:
+  category: meta
+  version: 1.0.0
+license: MIT
+compatibility: claude · agents-md · gemini · cursor · opencode
+---
+
+# noir-writing-skills
+
+The pack's authoring manual. Every skill must be: valid (passes `validateSkill`), structural (required sections), and genuinely useful (has concrete guidance the model doesn't already know). The meta-gate: `noir skills lint` reports pass/fail per skill.
+
+## When to use
+
+## Procedure
+1. **Follow the guidance** in the notes and verification.
+
+- Creating a new `noir-*` skill.
+- Revising an existing skill's body, description, or metadata.
+- The user says "write a skill", "update the skill", "add a skill for X."
+- Verifying the pack — `noir skills lint`.
+
+## Skill writing rules
+
+1. **Frontmatter.** `name` = dir name (`noir-<kebab>`); `description` = WHAT+WHEN, ≤1024 chars, trigger-first, keyword-rich, with boundary ("Do NOT use for..."). Add `metadata.{category,version}`, `license`, `compatibility`. For args-taking skills, add `argument-hint`.
+2. **Body.** Overview → When to use → Procedure (numbered) → Verification (`- [ ]` checklist) → Notes → "When done → next skill" footer.
+3. **Quality gate.** `noir skills lint` checks: metadata presence, required sections, line budget (<500), one-level references, WHAT clause, thin-body warnings, no-example warnings. A skill that fails `validateSkill` cannot be emitted.
+4. **Test it.** Every skill's directives must survive a real prompt. Write `evals/<skill>/evals.json` with offline assertions.
+5. **No assumptions.** A skill that says "the user knows the project layout" is a broken skill. State the path, name the tool, give the command.
+
+## Verification
+
+- [ ] `validateSkill` passes (frontmatter + sections + budget).
+- [ ] `noir skills lint` reports zero errors.
+- [ ] The "When to use" and boundary are mutually-exclusive with sibling skills.
+- [ ] The skill has a "When done → next skill" footer.
+
+## When done → next skill
+
+→ `noir skills lint` to verify the pack. Or continue authoring.

package/dist/index.d.ts

@@ -4,6 +4,14 @@ interface SkillFrontmatter {
     name: string;
     description: string;
     references?: string[];
+    /** C3 enhancement — canonical agentskills.io optional fields. `metadata` is a
+     *  string→string map convention; we type the two keys the registry reads. */
+    metadata?: {
+        category?: string;
+        version?: string;
+    };
+    license?: string;
+    compatibility?: string;
     [k: string]: unknown;
 }
 interface BuiltinReference {
@@ -57,6 +65,9 @@ interface IntegrationSkill extends BuiltinSkill {
 interface ValidationResult {
     ok: boolean;
     errors: string[];
+    /** C3 soft-quality warnings (lint-level): thin body, no example, first-person
+     *  narration, voodoo constants, time-sensitive pins. Present only when >0. */
+    warnings?: string[];
 }
 interface EmittedFile {
     path: string[];
@@ -125,7 +136,7 @@ type SkillConflictResolution = 'replace' | 'preserve' | 'rename' | 'duplicate' |
  * regenerate conflicts.
  */
 interface SkillConflictContext {
-    /** Path relative to the skills target dir (e.g. `noir-brainstorm/SKILL.md`). */
+    /** Path relative to the skills target dir (e.g. `noir-brainstorming/SKILL.md`). */
     relPath: string;
     /** The skill file's current on-disk bytes. */
     existing: string;
@@ -214,13 +225,63 @@ declare function discoverAll(opts?: {
     integrations: IntegrationSkill[];
 };
 
+/** The max body length the canon recommends (Anthropic: "under 500 lines").
+ *  SKILL.md is a navigator, not a repository — split to references/ past this. */
+declare const MAX_BODY_LINES = 500;
+/** The floor for a full (non-stub) playbook body. Stubs were ~13 lines; a real
+ *  playbook needs at least this much substance to be loadable as guidance. */
+declare const MIN_FULL_BODY_LINES = 20;
+/**
+ * Which required sections are missing from a skill body. Returns a list of
+ * human-readable section names, e.g. `['## When to use', '## Verification']`.
+ * Empty array = the body carries the canonical playbook shape.
+ */
+declare function missingSections(body: string): string[];
+/** True when the body is within the canon line budget. */
+declare function withinLineBudget(body: string, max?: number): boolean;
+/** Reference files that point at another reference file (chained — forbidden).
+ *  Returns the offending reference names. */
+declare function chainedReferences(skill: BuiltinSkill): string[];
+/**
+ * True when the description carries BOTH a WHEN trigger lead AND a WHAT clause.
+ * The C3 rule: `description` MUST lead with a WHEN cue (existing compiler rule)
+ * AND contain a compact WHAT clause naming what the skill does.
+ *
+ * Two canonical shapes both pass:
+ *   "Use when turning an idea into a spec — draft the spec."   (WHEN → WHAT)
+ *   "Use when a task writes back to ClickUp: update its status."  (WHEN → WHAT)
+ * The description MUST lead with a cue (the WHEN-only and WHAT-only schools are
+ * both rejected). The WHAT clause is the part after the trigger phrase — split
+ * on an em/en dash or a period that ends the trigger phrase. A real WHAT clause
+ * has ≥3 words naming the action, so a bare "Use when…" fails.
+ */
+declare function isWhatWhenDescription(description: string): boolean;
+/** True when the description leads with a WHEN cue (the existing rule, kept
+ *  here so validate + lint + hygiene share one implementation). */
+declare function looksLikeWhenDescription(description: string): boolean;
+/**
+ * Soft-quality warnings for `lintSkill`. Each returns a short rule id + message.
+ * These are advisory — a skill can pass `validateSkill` and still carry lint
+ * warnings that the author should resolve. Rules are drawn from the researched
+ * anti-pattern list (no examples, thin body, first/second person narration,
+ * voodoo constants, time-sensitive version pins).
+ */
+declare function lintWarnings(skill: BuiltinSkill): string[];
+
 declare function parseFrontmatter(md: string): SkillFrontmatter;
 declare function bodyOf(md: string): string;
-/** A WHEN description leads with its trigger. Requiring a leading cue — rather
- *  than a loose "contains when/before/after anywhere" — avoids false positives
- *  ("A tool that decides when to run tests") and accepts valid leads ("Upon…"). */
-declare function looksLikeWhenDescription(desc: string): boolean;
 declare function validateSkill(skill: BuiltinSkill): ValidationResult;
+/**
+ * `lintSkill` — the C3 soft quality gate. Errors = `validateSkill` errors (a
+ * skill that fails validation is broken); warnings = `quality.ts` style rules
+ * (thin body, no examples, first-person narration, …). A skill can validate
+ * clean yet still carry lint warnings the author should resolve.
+ */
+declare function lintSkill(skill: BuiltinSkill): {
+    name: string;
+    errors: string[];
+    warnings: string[];
+};
 /**
  * Compile a builtin skill into the host-shaped `CompiledSkill`. The validator
  * runs for every target (a malformed skill is malformed in any format).
@@ -286,6 +347,57 @@ declare function emitSkillsToDir(targetDir: string, opts?: {
     interactive?: boolean;
 }): Promise<EmitSummary>;
 
+/** A single offline assertion on the produced output. */
+type EvalAssertion = {
+    type: 'contains';
+    value: string;
+} | {
+    type: 'not-contains';
+    value: string;
+} | {
+    type: 'regex';
+    value: string;
+} | {
+    type: 'length-gte';
+    value: number;
+};
+/** One eval case: a prompt + the expected directive the skill must produce. */
+interface SkillEval {
+    id: string;
+    prompt: string;
+    expected_output: string;
+    assertions?: EvalAssertion[];
+}
+/** A suite = one skill's evals (the `evals.json` shape). */
+interface EvalSuite {
+    skill_name: string;
+    evals: SkillEval[];
+}
+/** Parse + validate a raw `evals.json` payload. Throws on malformed shape. */
+declare function parseEvalSuite(raw: unknown): EvalSuite;
+/** Run a list of assertions against `output`. Returns pass + per-assertion failures. */
+declare function runAssertions(output: string, assertions: EvalAssertion[]): {
+    pass: boolean;
+    failures: string[];
+};
+declare const EVALS_DIR: string;
+/**
+ * Load every eval suite under `dir` (default the shipped `evals/` dir — each
+ * subdir carries an `evals.json`). Skips non-`.json` files and missing dirs
+ * (no evals = no-op). Fail-fast on a malformed suite (a broken evals.json is a
+ * bug, not a skip).
+ */
+declare function loadEvalSuites(dir?: string): EvalSuite[];
+/** Evaluate one suite: for each eval, check its assertions against
+ *  `expected_output` (the directive the skill should produce). Returns pass/fail
+ *  per eval with the assertion failures. This is the offline core the vitest
+ *  runner drives. */
+declare function evaluateSuite(suite: EvalSuite): Array<{
+    id: string;
+    pass: boolean;
+    failures: string[];
+}>;
+
 /** Auth shape. Locked: `env-var` only until keychain lands (Q4b — refuse OAuth,
  *  never silently lower the security bar). `fallback:'manual-paste'` keeps the
  *  no-token path honest (the playbook tells the user to paste a value); `'none'`
@@ -300,9 +412,10 @@ declare const IntegrationAuthSchema: z.ZodObject<{
     }>>;
 }, z.core.$strip>;
 /** SDD two-way binding. `intakeFrom` declares the external artifact kind the
- *  `noir-intake` skill pulls from; `writeBack` enumerates the fields
- *  `noir-wrap`/`noir-document` push back at session end. Strings (not enums)
- *  for `writeBack` so a per-integration vocabulary stays expressible without
+ *  `noir-brainstorming` skill pulls from (absorbed noir-intake in C3);
+ *  `writeBack` enumerates the fields `noir-wrap` pushes back at session end
+ *  (absorbed noir-document in C3). Strings (not enums) for `writeBack` so a
+ *  per-integration vocabulary stays expressible without
  *  churning the schema. */
 declare const IntegrationSddSchema: z.ZodDefault<z.ZodObject<{
     intakeFrom: z.ZodOptional<z.ZodEnum<{
@@ -382,6 +495,43 @@ declare function validateIntegration(obj: unknown): {
  *  existing `noir mcp serve --stdio` entry so no NEW server entry is emitted. */
 declare function runtimeEmitsHostMcp(runtime: IntegrationDeclaration['runtime']): boolean;
 
+/** The pack-wide `noir-` namespace a registry entry always belongs to. */
+declare const NOIR_NAMESPACE = "noir-";
+/** One row in the derived registry. */
+interface SkillRegistryEntry {
+    /** Canonical `noir-<kebab>` id (== dir name). */
+    name: string;
+    /** `builtin` for the shipped pack; `integration` for an `integrations/<name>/`. */
+    kind: 'builtin' | 'integration';
+    /** Category from `metadata.category`; falls back to the `noir-`-stripped name
+     *  (a newly-authored skill still gets a sensible cell). */
+    category: string;
+    /** Per-skill version from `metadata.version`; defaults to `0.0.0` when absent
+     *  (the pack-level version in package.json is the authoritative release). */
+    version: string;
+    /** `full` when the body has no `> **Stub:**` marker; `stub` otherwise. */
+    status: 'full' | 'stub';
+    /** Lifecycle stage of the skill. `active` = currently shipped and usable;
+     *  `deprecated` = superseded (a renamed/merged predecessor). C3 spec §8.
+     *  The curated pack has no deprecated members today. */
+    lifecycle: 'active' | 'deprecated';
+    /** The WHAT+WHEN description (the trigger the host sees). */
+    description: string;
+    /** Number of `references/*.md` files. */
+    referenceCount: number;
+    /** Total SKILL.md line count (frontmatter + body). */
+    lines: number;
+}
+/**
+ * Build the full registry from `discoverAll()` — builtins + integrations in
+ * one list, sorted by name. Pure (no I/O beyond discovery); never throws for
+ * a malformed skill (a discovery failure surfaces upstream, the same as the
+ * compiler's fail-fast).
+ */
+declare function buildRegistry(): SkillRegistryEntry[];
+/** Convenience: registry filtered to a single category (CLI grouping). */
+declare function registryByCategory(category: string): SkillRegistryEntry[];
+
 declare const FORBIDDEN_RESIDUE: readonly string[];
 
-export { BUILTIN_DIR, type BuiltinReference, type BuiltinSkill, type CompileTarget, type CompiledIntegration, type CompiledSkill, type EmitSummary, type EmittedFile, FORBIDDEN_RESIDUE, INTEGRATIONS_DIR, IntegrationAuthSchema, type IntegrationDeclaration$1 as IntegrationDeclaration, IntegrationDeclarationSchema, IntegrationMcpSchema, IntegrationSddSchema, type IntegrationSkill, type SkillFrontmatter, type ValidationResult, bodyOf, compileIntegration, compileSkill, discoverAll, discoverBuiltin, discoverIntegrations, emitSkillsToDir, looksLikeWhenDescription, parseFrontmatter, parseIntegration, runtimeEmitsHostMcp, validateIntegration, validateSkill };
+export { BUILTIN_DIR, type BuiltinReference, type BuiltinSkill, type CompileTarget, type CompiledIntegration, type CompiledSkill, EVALS_DIR, type EmitSummary, type EmittedFile, type EvalAssertion, type EvalSuite, FORBIDDEN_RESIDUE, INTEGRATIONS_DIR, IntegrationAuthSchema, type IntegrationDeclaration$1 as IntegrationDeclaration, IntegrationDeclarationSchema, IntegrationMcpSchema, IntegrationSddSchema, type IntegrationSkill, MAX_BODY_LINES, MIN_FULL_BODY_LINES, NOIR_NAMESPACE, type SkillEval, type SkillFrontmatter, type SkillRegistryEntry, type ValidationResult, bodyOf, buildRegistry, chainedReferences, compileIntegration, compileSkill, discoverAll, discoverBuiltin, discoverIntegrations, emitSkillsToDir, evaluateSuite, isWhatWhenDescription, lintSkill, lintWarnings, loadEvalSuites, looksLikeWhenDescription, missingSections, parseEvalSuite, parseFrontmatter, parseIntegration, registryByCategory, runAssertions, runtimeEmitsHostMcp, validateIntegration, validateSkill, withinLineBudget };

package/dist/index.js

@@ -106,10 +106,67 @@ function discoverAll(opts = {}) {
   };
 }
 
+// src/quality.ts
+var MAX_BODY_LINES = 500;
+var MIN_FULL_BODY_LINES = 20;
+var WHEN_SECTION = /^## When to use$/im;
+var PROCEDURE_SECTION = /^## (Procedure|Steps)$/im;
+var CLOSING_SECTION = /^## (Verification|Notes|Fallbacks|Troubleshooting|Why order matters)$/im;
+var WHEN_CUE = /^(use|using|used|whenever|when|before|after|while|starting|encountering|completing|creating|about to|upon|during|to|for|on)\b/i;
+var CHAINED_REF_RE = /\]\((\/?\.?\.?\/)?(references\/|\.\.\/references\/)/i;
+function missingSections(body) {
+  const missing = [];
+  if (!WHEN_SECTION.test(body)) missing.push("## When to use");
+  if (!PROCEDURE_SECTION.test(body)) missing.push("## Procedure (or ## Steps)");
+  if (!CLOSING_SECTION.test(body)) {
+    missing.push("one of ## Verification / ## Notes / ## Fallbacks / ## Troubleshooting");
+  }
+  return missing;
+}
+function withinLineBudget(body, max = MAX_BODY_LINES) {
+  return body.split("\n").length <= max;
+}
+function chainedReferences(skill) {
+  return skill.references.filter((r) => CHAINED_REF_RE.test(r.content)).map((r) => r.name);
+}
+function isWhatWhenDescription(description) {
+  const trimmed = description.trim();
+  if (!trimmed) return false;
+  if (!WHEN_CUE.test(trimmed)) return false;
+  const whatPart = trimmed.split(/[—–]|(?<=\.) /).slice(1).join(" ").trim();
+  return whatPart.split(/\s+/).filter(Boolean).length >= 3;
+}
+function looksLikeWhenDescription(description) {
+  return WHEN_CUE.test(description.trim());
+}
+function lintWarnings(skill) {
+  const warnings = [];
+  const body = skill.skillMd;
+  const bodyLines = body.split("\n").length;
+  if (bodyLines < MIN_FULL_BODY_LINES + 6) {
+    warnings.push("thin-body: full playbook body is under 20 lines");
+  }
+  const hasExample = /```/.test(body) || /\bexample:?\b/i.test(body) || /\be\.g\.\b/i.test(body);
+  if (!hasExample) {
+    warnings.push("no-example: no concrete code fence or worked example in the body");
+  }
+  if (/\b(I|we|you)\s+(will|should|can|need|must|do|write|create|implement|run|build)\b/i.test(body)) {
+    warnings.push("first-person: narration addresses the reader instead of imperative steps");
+  }
+  if (/\b(?:wait|sleep|retry|backoff|limit|cap)\s+[a-z]*\s*(\d{1,4})\b/i.test(body) && !/because|to (avoid|prevent|give|let)/i.test(body)) {
+    warnings.push("voodoo-constant: numeric threshold without a stated reason");
+  }
+  const hasVersionPin = /as of \d{4}|\bversion \d+\.\d+\.\d+\b|"v\d+\.\d+"/i.test(body);
+  const hasLegacySection = /^## Legacy|^## Old patterns/i.test(body);
+  if (hasVersionPin && !hasLegacySection) {
+    warnings.push("time-sensitive: version/date pin outside a Legacy section");
+  }
+  return warnings;
+}
+
 // src/compiler.ts
 var FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
 var NAME_RE = /^noir-[a-z0-9]+(?:-[a-z0-9]+)*$/;
-var WHEN_START = /^(use|using|used|whenever|when|before|after|while|starting|encountering|completing|creating|about to|upon|during|to|for|on)\b/i;
 var MAX_DESC = 1024;
 function parseFrontmatter(md) {
   const m = md.match(FRONTMATTER_RE);
@@ -125,12 +182,10 @@ function parseFrontmatter(md) {
 function bodyOf(md) {
   return md.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/, "");
 }
-function looksLikeWhenDescription(desc) {
-  return WHEN_START.test(desc.trim());
-}
 function validateSkill(skill) {
   const errors = [];
-  const { name, description } = skill.frontmatter;
+  const warnings = [];
+  const { name, description, metadata } = skill.frontmatter;
   if (!name) errors.push("missing `name`");
   else if (!NAME_RE.test(name)) errors.push(`name "${name}" must match noir-<kebab>`);
   if (basename(skill.dir) !== name) {
@@ -140,12 +195,30 @@ function validateSkill(skill) {
   else if (description.length > MAX_DESC) errors.push(`description exceeds ${MAX_DESC} chars`);
   else if (!looksLikeWhenDescription(description)) {
     errors.push('description must state WHEN to trigger (e.g. "Use when\u2026"), not WHAT it does');
+  } else if (!isWhatWhenDescription(description)) {
+    errors.push("description must be WHAT+WHEN \u2014 a WHAT clause after the trigger phrase");
   }
+  if (!metadata?.category?.trim()) errors.push("missing `metadata.category`");
+  if (!metadata?.version?.trim()) errors.push("missing `metadata.version`");
+  const body = bodyOf(skill.skillMd);
+  const missing = missingSections(body);
+  for (const sec of missing) errors.push(`missing required section: ${sec}`);
+  if (!withinLineBudget(body)) {
+    errors.push(`body exceeds ${MAX_BODY_LINES}-line budget (${body.split("\n").length} lines)`);
+  }
+  const chained = chainedReferences(skill);
+  for (const r of chained)
+    errors.push(`reference "${r}" chains to another reference (must be one level deep)`);
   for (const r of skill.references) {
     if (!/^[a-z0-9-]+\.md$/i.test(r.name)) errors.push(`reference "${r.name}" must be <kebab>.md`);
     if (!r.content.trim()) errors.push(`reference "${r.name}" is empty`);
   }
-  return { ok: errors.length === 0, errors };
+  warnings.push(...lintWarnings(skill));
+  return { ok: errors.length === 0, errors, warnings: warnings.length > 0 ? warnings : void 0 };
+}
+function lintSkill(skill) {
+  const res = validateSkill(skill);
+  return { name: skill.name, errors: res.errors, warnings: res.warnings ?? [] };
 }
 function compileSkill(skill, target = "claude") {
   const res = validateSkill(skill);
@@ -425,6 +498,150 @@ async function uniqueAsideAbs(abs, suffix) {
   return candidate;
 }
 
+// src/evals.ts
+import { readdirSync as readdirSync2, readFileSync as readFileSync2 } from "fs";
+import { dirname as dirname3, join as join3 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+function parseAssertion(a) {
+  if (typeof a !== "object" || a === null) throw new Error("assertion must be an object");
+  const { type, value } = a;
+  switch (type) {
+    case "contains":
+    case "not-contains":
+    case "regex":
+      if (typeof value !== "string" || value.length === 0) {
+        throw new Error(`assertion '${String(type)}' requires a non-empty string value`);
+      }
+      return { type, value };
+    case "length-gte":
+      if (typeof value !== "number" || !Number.isFinite(value)) {
+        throw new Error("assertion 'length-gte' requires a finite number value");
+      }
+      return { type, value };
+    default:
+      throw new Error(`unknown assertion type '${String(type)}'`);
+  }
+}
+function parseEvalSuite(raw) {
+  if (typeof raw !== "object" || raw === null) throw new Error("evals.json must be an object");
+  const { skill_name, evals } = raw;
+  if (typeof skill_name !== "string" || skill_name.length === 0) {
+    throw new Error("evals.json requires a non-empty string `skill_name`");
+  }
+  if (!Array.isArray(evals) || evals.length === 0) {
+    throw new Error(`evals.json for ${skill_name} requires a non-empty 'evals' array`);
+  }
+  const parsed = evals.map((e, i) => {
+    if (typeof e !== "object" || e === null) throw new Error(`eval[${i}] must be an object`);
+    const { id, prompt, expected_output, assertions } = e;
+    if (typeof id !== "string" || id.length === 0)
+      throw new Error(`eval[${i}] requires a string id`);
+    if (typeof prompt !== "string" || prompt.length === 0) {
+      throw new Error(`eval ${id} requires a string prompt`);
+    }
+    if (typeof expected_output !== "string") {
+      throw new Error(`eval ${id} requires a string expected_output`);
+    }
+    return {
+      id,
+      prompt,
+      expected_output,
+      assertions: Array.isArray(assertions) ? assertions.map(parseAssertion) : void 0
+    };
+  });
+  return { skill_name, evals: parsed };
+}
+function runAssertions(output, assertions) {
+  const failures = [];
+  for (const a of assertions) {
+    switch (a.type) {
+      case "contains":
+        if (!output.includes(a.value)) failures.push(`expected to contain "${a.value}"`);
+        break;
+      case "not-contains":
+        if (output.includes(a.value)) failures.push(`expected NOT to contain "${a.value}"`);
+        break;
+      case "regex":
+        if (!new RegExp(a.value, "i").test(output)) failures.push(`expected to match /${a.value}/`);
+        break;
+      case "length-gte":
+        if (output.length < a.value)
+          failures.push(`expected length >= ${a.value} (got ${output.length})`);
+        break;
+    }
+  }
+  return { pass: failures.length === 0, failures };
+}
+var HERE2 = dirname3(fileURLToPath2(import.meta.url));
+var PKG_ROOT2 = dirname3(HERE2);
+var EVALS_DIR = join3(PKG_ROOT2, "evals");
+function loadEvalSuites(dir = EVALS_DIR) {
+  let entries;
+  try {
+    entries = readdirSync2(dir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name).sort();
+  } catch {
+    return [];
+  }
+  const suites = [];
+  for (const name of entries) {
+    const file = join3(dir, name, "evals.json");
+    try {
+      const raw = JSON.parse(readFileSync2(file, "utf8"));
+      suites.push(parseEvalSuite(raw));
+    } catch (err) {
+      try {
+        readFileSync2(file, "utf8");
+        throw err;
+      } catch (re) {
+        if (re === err) throw err;
+      }
+    }
+  }
+  return suites;
+}
+function evaluateSuite(suite) {
+  return suite.evals.map((e) => ({
+    id: e.id,
+    pass: e.assertions ? runAssertions(e.expected_output, e.assertions).pass : true,
+    failures: e.assertions ? runAssertions(e.expected_output, e.assertions).failures : []
+  }));
+}
+
+// src/registry.ts
+var NOIR_NAMESPACE = "noir-";
+function fallbackCategory(name) {
+  return name.replace(/^noir-/, "") || "general";
+}
+function toEntry(s, kind) {
+  const category = s.frontmatter.metadata?.category?.trim() || fallbackCategory(s.name);
+  const version = s.frontmatter.metadata?.version?.trim() || "0.0.0";
+  const status = s.skillMd.includes("> **Stub:**") ? "stub" : "full";
+  const lines = s.skillMd.split("\n").length;
+  return {
+    name: s.name,
+    kind,
+    category,
+    version,
+    status,
+    // Every shipped skill is active; `deprecated` is reserved for a future
+    // superseded member (C3 spec §8).
+    lifecycle: "active",
+    description: typeof s.frontmatter.description === "string" ? s.frontmatter.description : "",
+    referenceCount: s.references.length,
+    lines
+  };
+}
+function buildRegistry() {
+  const { builtins, integrations } = discoverAll();
+  return [
+    ...builtins.map((b) => toEntry(b, "builtin")),
+    ...integrations.map((i) => toEntry(i, "integration"))
+  ].sort((a, b) => a.name.localeCompare(b.name));
+}
+function registryByCategory(category) {
+  return buildRegistry().filter((e) => e.category === category);
+}
+
 // src/residue.ts
 var FORBIDDEN_RESIDUE = [
   "workflow/<task",
@@ -448,24 +665,40 @@ var FORBIDDEN_RESIDUE = [
 ];
 export {
   BUILTIN_DIR,
+  EVALS_DIR,
   FORBIDDEN_RESIDUE,
   INTEGRATIONS_DIR,
   IntegrationAuthSchema,
   IntegrationDeclarationSchema,
   IntegrationMcpSchema,
   IntegrationSddSchema,
+  MAX_BODY_LINES,
+  MIN_FULL_BODY_LINES,
+  NOIR_NAMESPACE,
   bodyOf,
+  buildRegistry,
+  chainedReferences,
   compileIntegration,
   compileSkill,
   discoverAll,
   discoverBuiltin,
   discoverIntegrations,
   emitSkillsToDir,
+  evaluateSuite,
+  isWhatWhenDescription,
+  lintSkill,
+  lintWarnings,
+  loadEvalSuites,
   looksLikeWhenDescription,
+  missingSections,
+  parseEvalSuite,
   parseFrontmatter,
   parseIntegration,
+  registryByCategory,
+  runAssertions,
   runtimeEmitsHostMcp,
   validateIntegration,
-  validateSkill
+  validateSkill,
+  withinLineBudget
 };
 //# sourceMappingURL=index.js.map