skanvil 1.0.0 → 1.1.0

package/dist/{chunk-TYO4LLN5.js → chunk-WXEWECJP.js}

@@ -200,18 +200,192 @@ ${this.body}`;
   }
 };
 
+// src/core/params.ts
+import fs from "fs/promises";
+import path2 from "path";
+import { z } from "zod";
+var PARAMS_FILE = "params.json";
+var ParamSchema = z.union([
+  z.object({
+    type: z.literal("enum"),
+    values: z.array(z.string()).min(1),
+    default: z.string(),
+    description: z.string().optional()
+  }).strict(),
+  z.object({ type: z.literal("string"), default: z.string(), description: z.string().optional() }).strict(),
+  z.object({ type: z.literal("boolean"), default: z.boolean(), description: z.string().optional() }).strict()
+]);
+var ParamsFileSchema = z.record(
+  z.string().regex(/^[a-zA-Z][a-zA-Z0-9]*$/, "parameter names must be camelCase letters and digits"),
+  ParamSchema
+);
+function parseParams(text) {
+  let json;
+  try {
+    json = JSON.parse(text);
+  } catch (error) {
+    throw new Error(`${PARAMS_FILE} is not valid JSON: ${error.message}`);
+  }
+  if (json && typeof json === "object" && !Array.isArray(json)) {
+    const invalid = Object.keys(json).filter((key) => !/^[a-zA-Z][a-zA-Z0-9]*$/.test(key));
+    if (invalid.length > 0) {
+      throw new Error(
+        `invalid ${PARAMS_FILE}: parameter names must be camelCase letters and digits (${invalid.join(", ")})`
+      );
+    }
+  }
+  const parsed = ParamsFileSchema.safeParse(json);
+  if (!parsed.success) {
+    const issues = parsed.error.issues.map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`);
+    throw new Error(`invalid ${PARAMS_FILE}: ${issues.slice(0, 3).join("; ")}`);
+  }
+  for (const [name, definition] of Object.entries(parsed.data)) {
+    if (definition.type === "enum" && !definition.values.includes(definition.default)) {
+      throw new Error(`invalid ${PARAMS_FILE}: ${name}.default must be one of ${definition.values.join(", ")}`);
+    }
+  }
+  return parsed.data;
+}
+async function readParams(skillDir) {
+  let text;
+  try {
+    text = await fs.readFile(path2.join(skillDir, PARAMS_FILE), "utf8");
+  } catch {
+    return null;
+  }
+  return parseParams(text);
+}
+function resolveParamValues(definitions, given = {}, skill = "skill", ignoreUnknown = false) {
+  const values = {};
+  for (const key of Object.keys(given)) {
+    if (!Object.prototype.hasOwnProperty.call(definitions, key) && !ignoreUnknown) {
+      const known = Object.keys(definitions);
+      throw new Error(
+        `${skill} has no parameter '${key}'` + (known.length ? ` (parameters: ${known.join(", ")})` : " (it has no parameters)")
+      );
+    }
+  }
+  for (const [name, definition] of Object.entries(definitions)) {
+    const raw = Object.prototype.hasOwnProperty.call(given, name) && given[name] !== void 0 ? given[name] : definition.default;
+    if (definition.type === "boolean") {
+      if (raw === true || raw === "true") values[name] = true;
+      else if (raw === false || raw === "false") values[name] = false;
+      else throw new Error(`${skill}: parameter '${name}' must be true or false, got ${JSON.stringify(raw)}`);
+    } else if (typeof raw !== "string") {
+      throw new Error(`${skill}: parameter '${name}' must be a string, got ${JSON.stringify(raw)}`);
+    } else if (definition.type === "enum" && !definition.values.includes(raw)) {
+      throw new Error(`${skill}: parameter '${name}' must be one of ${definition.values.join(", ")}, got "${raw}"`);
+    } else {
+      values[name] = raw;
+    }
+  }
+  return values;
+}
+function renderTemplate(text, values) {
+  const tagPattern = /\{\{\s*(#if\s+[^}]*?|else|\/if|[A-Za-z][A-Za-z0-9]*)\s*\}\}/g;
+  const tokens = [];
+  let cursor = 0;
+  let match;
+  while ((match = tagPattern.exec(text)) !== null) {
+    const body = match[1];
+    const isBlock = body.startsWith("#if") || body === "else" || body === "/if";
+    let start = match.index;
+    let end = match.index + match[0].length;
+    if (isBlock) {
+      const lineStart = text.lastIndexOf("\n", start - 1) + 1;
+      const newline = text.indexOf("\n", end);
+      const lineEnd = newline === -1 ? text.length : newline;
+      const before = text.slice(lineStart, start);
+      const after = text.slice(end, lineEnd);
+      if (before.trim() === "" && after.trim() === "" && lineStart >= cursor) {
+        start = lineStart;
+        end = newline === -1 ? text.length : newline + 1;
+      }
+    }
+    if (start > cursor) tokens.push({ kind: "text", value: text.slice(cursor, start) });
+    if (body.startsWith("#if")) tokens.push({ kind: "if", expr: body.slice(3).trim() });
+    else if (body === "else") tokens.push({ kind: "else" });
+    else if (body === "/if") tokens.push({ kind: "end" });
+    else tokens.push({ kind: "var", name: body, raw: match[0] });
+    cursor = end;
+    tagPattern.lastIndex = end;
+  }
+  if (cursor < text.length) tokens.push({ kind: "text", value: text.slice(cursor) });
+  const has = (name) => Object.prototype.hasOwnProperty.call(values, name);
+  const evaluate = (expr) => {
+    const comparison = expr.match(/^([A-Za-z][A-Za-z0-9]*)\s*(==|!=)\s*(?:"([^"]*)"|'([^']*)')$/);
+    if (comparison) {
+      const [, name, operator, double, single] = comparison;
+      if (!has(name)) throw new Error(`{{#if ${expr}}} uses unknown parameter '${name}'`);
+      const equal = String(values[name]) === (double !== void 0 ? double : single);
+      return operator === "==" ? equal : !equal;
+    }
+    const truthy = expr.match(/^(!?)([A-Za-z][A-Za-z0-9]*)$/);
+    if (truthy) {
+      const [, negate, name] = truthy;
+      if (!has(name)) throw new Error(`{{#if ${expr}}} uses unknown parameter '${name}'`);
+      const value = values[name];
+      const result = value !== false && value !== "" && value !== "false";
+      return negate ? !result : result;
+    }
+    throw new Error(`invalid condition {{#if ${expr}}}: use name, !name, name == "value" or name != "value"`);
+  };
+  const stack = [];
+  let output = "";
+  let active = true;
+  for (const token of tokens) {
+    if (token.kind === "if") {
+      const condition = active ? evaluate(token.expr) : false;
+      stack.push({ active: condition, parentActive: active, sawElse: false });
+      active = active && condition;
+    } else if (token.kind === "else") {
+      const frame = stack[stack.length - 1];
+      if (!frame || frame.sawElse) throw new Error("{{else}} without a matching {{#if}}");
+      frame.sawElse = true;
+      active = frame.parentActive && !frame.active;
+    } else if (token.kind === "end") {
+      const frame = stack.pop();
+      if (!frame) throw new Error("{{/if}} without a matching {{#if}}");
+      active = frame.parentActive;
+    } else if (active) {
+      output += token.kind === "text" ? token.value : has(token.name) ? String(values[token.name]) : token.raw;
+    }
+  }
+  if (stack.length > 0) throw new Error(`${stack.length} {{#if}} block(s) are not closed with {{/if}}`);
+  return output;
+}
+function findUndeclaredParams(text, definitions) {
+  const names = /* @__PURE__ */ new Set();
+  for (const match of text.matchAll(/\{\{\s*([A-Za-z][A-Za-z0-9]*)\s*\}\}/g)) {
+    if (match[1] !== "else" && !Object.prototype.hasOwnProperty.call(definitions, match[1])) names.add(match[1]);
+  }
+  return [...names];
+}
+function parseParamPairs(pairs) {
+  const values = {};
+  for (const pair of pairs) {
+    const index = pair.indexOf("=");
+    const key = index === -1 ? "" : pair.slice(0, index).trim();
+    if (!/^[a-zA-Z][a-zA-Z0-9]*$/.test(key)) {
+      throw new Error(`Invalid --param '${pair}'. Use name=value, e.g. --param ticketTracker=jira`);
+    }
+    values[key] = pair.slice(index + 1);
+  }
+  return values;
+}
+
 // src/core/templates.ts
-import fs2 from "fs/promises";
-import path3 from "path";
+import fs3 from "fs/promises";
+import path4 from "path";
 import { stringify } from "yaml";
 
 // src/util/fs.ts
-import fs from "fs/promises";
+import fs2 from "fs/promises";
 import { createHash } from "crypto";
-import path2 from "path";
+import path3 from "path";
 async function exists(target) {
   try {
-    await fs.access(target);
+    await fs2.access(target);
     return true;
   } catch {
     return false;
@@ -219,14 +393,14 @@ async function exists(target) {
 }
 async function isEmptyOrMissing(dir) {
   try {
-    return (await fs.readdir(dir)).length === 0;
+    return (await fs2.readdir(dir)).length === 0;
   } catch {
     return true;
   }
 }
 async function listFiles(dir, relative = "") {
   const out = [];
-  for (const entry of await fs.readdir(path2.join(dir, relative), { withFileTypes: true })) {
+  for (const entry of await fs2.readdir(path3.join(dir, relative), { withFileTypes: true })) {
     const rel = relative ? `${relative}/${entry.name}` : entry.name;
     if (entry.isDirectory()) {
       out.push(...await listFiles(dir, rel));
@@ -241,7 +415,7 @@ async function hashDirectory(dir) {
   for (const file of await listFiles(dir)) {
     hash.update(file);
     hash.update("\0");
-    hash.update(await fs.readFile(path2.join(dir, file)));
+    hash.update(await fs2.readFile(path3.join(dir, file)));
     hash.update("\0");
   }
   return hash.digest("hex").slice(0, 16);
@@ -286,8 +460,8 @@ function renderSkillMarkdown(text, variables) {
 }
 async function copyTemplateDir(source, destination, options = {}, relative = "") {
   const { variables = {}, skip = () => false, render: shouldRender = true } = options;
-  await fs2.mkdir(path3.join(destination, relative), { recursive: true });
-  for (const entry of await fs2.readdir(path3.join(source, relative), { withFileTypes: true })) {
+  await fs3.mkdir(path4.join(destination, relative), { recursive: true });
+  for (const entry of await fs3.readdir(path4.join(source, relative), { withFileTypes: true })) {
     const relativePath = relative ? `${relative}/${entry.name}` : entry.name;
     if (skip(relativePath)) continue;
     if (entry.isDirectory()) {
@@ -295,45 +469,45 @@ async function copyTemplateDir(source, destination, options = {}, relative = "")
       continue;
     }
     const targetName = shouldRender ? FILE_ALIASES[entry.name] || entry.name : entry.name;
-    const from = path3.join(source, relative, entry.name);
-    const target = path3.join(destination, relative, targetName);
-    if (shouldRender && TEXT_EXTENSIONS.has(path3.extname(entry.name))) {
-      const text = await fs2.readFile(from, "utf8");
+    const from = path4.join(source, relative, entry.name);
+    const target = path4.join(destination, relative, targetName);
+    if (shouldRender && TEXT_EXTENSIONS.has(path4.extname(entry.name))) {
+      const text = await fs3.readFile(from, "utf8");
       const rendered = entry.name === "SKILL.md" ? renderSkillMarkdown(text, variables) : render(text, variables);
-      await fs2.writeFile(target, rendered, "utf8");
+      await fs3.writeFile(target, rendered, "utf8");
     } else {
-      await fs2.copyFile(from, target);
+      await fs3.copyFile(from, target);
     }
   }
 }
 function builtinTemplate(name) {
-  return path3.join(TEMPLATES_ROOT, name);
+  return path4.join(TEMPLATES_ROOT, name);
 }
 async function resolveSkillTemplate(library, categoryId, explicit) {
-  const localRoot = path3.join(library.root, library.config.templates.dir);
+  const localRoot = path4.join(library.root, library.config.templates.dir);
   if (explicit) {
-    const candidate = path3.join(localRoot, explicit);
+    const candidate = path4.join(localRoot, explicit);
     if (await exists(candidate)) return candidate;
     throw new Error(`Template '${explicit}' not found in ${localRoot}.`);
   }
-  for (const candidate of [path3.join(localRoot, `skill-${categoryId}`), path3.join(localRoot, "skill")]) {
+  for (const candidate of [path4.join(localRoot, `skill-${categoryId}`), path4.join(localRoot, "skill")]) {
     if (await exists(candidate)) return candidate;
   }
   return builtinTemplate("skill");
 }
 async function ejectSkillTemplate(library, categoryId, force = false) {
   const folder = categoryId ? `skill-${library.categories.resolve(categoryId).id}` : "skill";
-  const target = path3.join(library.root, library.config.templates.dir, folder);
+  const target = path4.join(library.root, library.config.templates.dir, folder);
   if (await exists(target) && !force) {
     throw new Error(`Template folder already exists: ${target} (use --force to overwrite).`);
   }
-  await fs2.rm(target, { recursive: true, force: true });
+  await fs3.rm(target, { recursive: true, force: true });
   await copyTemplateDir(builtinTemplate("skill"), target, { render: false });
   return target;
 }
 
 // src/core/validate.ts
-import path4 from "path";
+import path5 from "path";
 import { isMap as isMap2, isScalar as isScalar2 } from "yaml";
 
 // src/core/naming.ts
@@ -400,6 +574,14 @@ var RULES = {
     severity: "warn",
     description: "The body no longer contains the generic text of the built-in skill template."
   },
+  "params-file": {
+    severity: "error",
+    description: "params.json, when present, is valid: camelCase names, a type, and a default (in its values for enums)."
+  },
+  "params-template": {
+    severity: "error",
+    description: "{{placeholders}} and {{#if}} blocks use declared parameters and are balanced."
+  },
   "readme-missing": { severity: "error", description: "Every indexed skill is listed in the README.", fixable: true },
   "readme-orphan": { severity: "error", description: "README does not reference missing skills.", fixable: true },
   "readme-section": {
@@ -557,7 +739,7 @@ function findBrokenReferences(body, files) {
       continue;
     const clean = safeDecode(raw.split(/[?#]/)[0]);
     if (!clean) continue;
-    const resolved = path4.posix.normalize(clean).replace(/\/+$/, "");
+    const resolved = path5.posix.normalize(clean).replace(/\/+$/, "");
     if (resolved === "." || resolved === "") continue;
     if (resolved === ".." || resolved.startsWith("../")) {
       problems.push(`reference '${raw}' points outside the skill folder`);
@@ -567,6 +749,31 @@ function findBrokenReferences(body, files) {
   }
   return problems;
 }
+async function renderForValidation(library, folder, raw, collector) {
+  let params;
+  try {
+    params = await library.readSkillParams(folder);
+  } catch (error) {
+    collector.add("params-file", error.message, folder);
+    return null;
+  }
+  if (!params) return null;
+  const source = raw.toLfString();
+  const undeclared = findUndeclaredParams(source, params);
+  if (undeclared.length > 0) {
+    collector.add(
+      "params-template",
+      `uses undeclared parameter(s) ${undeclared.map((name) => `{{${name}}}`).join(", ")}; declare them in ${PARAMS_FILE}`,
+      folder
+    );
+  }
+  try {
+    return SkillFile.parse(renderTemplate(source, resolveParamValues(params, {}, folder)));
+  } catch (error) {
+    collector.add("params-template", error.message, folder);
+    return null;
+  }
+}
 async function validateLibrary(library, options = {}) {
   const collector = new Collector(library.config.validation.rules);
   const folders = await library.listSkillFolders();
@@ -581,6 +788,8 @@ async function validateLibrary(library, options = {}) {
       collector.add("skill-file", "missing SKILL.md", folder);
       continue;
     }
+    const rendered = await renderForValidation(library, folder, skill, collector);
+    if (rendered) skill = rendered;
     const files = new Set(await listFiles(library.skillPath(folder)));
     const allowUnderscore = library.categories.fromFolder(folder).prefix === "_";
     const name = validateSkillFile(collector, folder, skill, ruleOptions, allowUnderscore, files);
@@ -636,9 +845,10 @@ function formatDiagnostic(diagnostic) {
 }
 
 // src/core/sync.ts
-import fs3 from "fs/promises";
+import fs4 from "fs/promises";
 import os from "os";
-import path5 from "path";
+import path6 from "path";
+import { createHash as createHash2 } from "crypto";
 var TARGET_PRESETS = {
   claude: ".claude/skills",
   // Claude Code
@@ -663,51 +873,72 @@ function resolveTarget(dest, target, options = {}) {
         `Global installs only accept presets (${Object.keys(USER_TARGET_PRESETS).join(", ")}), got '${target}'.`
       );
     }
-    return path5.join(options.homeDir ?? os.homedir(), preset);
+    return path6.join(options.homeDir ?? os.homedir(), preset);
   }
-  const root = path5.resolve(dest);
-  if (TARGET_PRESETS[target]) return path5.resolve(root, TARGET_PRESETS[target]);
-  const resolved = path5.resolve(root, target);
-  const relative = path5.relative(root, resolved);
-  if (!relative || relative.startsWith("..") || path5.isAbsolute(relative)) {
+  const root = path6.resolve(dest);
+  if (TARGET_PRESETS[target]) return path6.resolve(root, TARGET_PRESETS[target]);
+  const resolved = path6.resolve(root, target);
+  const relative = path6.relative(root, resolved);
+  if (!relative || relative.startsWith("..") || path6.isAbsolute(relative)) {
     throw new Error(`Target '${target}' must be a folder inside ${root}.`);
   }
   return resolved;
 }
 async function readManifest(dir) {
   try {
-    const parsed = JSON.parse(await fs3.readFile(path5.join(dir, MANIFEST_FILE), "utf8"));
+    const parsed = JSON.parse(await fs4.readFile(path6.join(dir, MANIFEST_FILE), "utf8"));
     return parsed && parsed.tool === "skanvil" && parsed.skills ? parsed : null;
   } catch {
     return null;
   }
 }
 async function resolveSource(from, dest) {
-  const direct = path5.resolve(dest, from);
+  const direct = path6.resolve(dest, from);
   if (await exists(direct)) return direct;
-  let dir = path5.resolve(dest);
+  let dir = path6.resolve(dest);
   for (; ; ) {
-    const candidate = path5.join(dir, "node_modules", from);
+    const candidate = path6.join(dir, "node_modules", from);
     if (await exists(candidate)) return candidate;
-    const parent = path5.dirname(dir);
+    const parent = path6.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
   throw new Error(`Cannot find skills source '${from}' (not a folder, nor an installed npm package).`);
 }
-async function place(source, target, mode, warnings) {
-  await fs3.rm(target, { recursive: true, force: true });
-  if (mode === "link") {
+async function place(source, target, mode, warnings, rendered) {
+  await fs4.rm(target, { recursive: true, force: true });
+  if (mode === "link" && rendered !== null) {
+    warnings.push(`${path6.basename(target)} has parameters, so it was copied rendered instead of linked`);
+  } else if (mode === "link") {
     try {
-      await fs3.symlink(source, target, process.platform === "win32" ? "junction" : "dir");
+      await fs4.symlink(source, target, process.platform === "win32" ? "junction" : "dir");
       return "link";
     } catch (error) {
-      warnings.push(`could not link ${path5.basename(target)} (${error.message}); copied instead`);
+      warnings.push(`could not link ${path6.basename(target)} (${error.message}); copied instead`);
     }
   }
-  await fs3.cp(source, target, { recursive: true });
+  await fs4.cp(source, target, { recursive: true });
+  if (rendered !== null) {
+    await fs4.writeFile(path6.join(target, "SKILL.md"), rendered, "utf8");
+    await fs4.rm(path6.join(target, PARAMS_FILE), { force: true });
+  }
   return "copy";
 }
+async function materialize(library, name, definitions, values) {
+  const dir = library.skillPath(name);
+  if (!definitions) return { hash: await hashDirectory(dir), rendered: null };
+  const raw = await fs4.readFile(path6.join(dir, "SKILL.md"), "utf8");
+  const rendered = renderTemplate(raw, resolveParamValues(definitions, values, name, true));
+  const hash = createHash2("sha256");
+  for (const file of await listFiles(dir)) {
+    if (file === PARAMS_FILE) continue;
+    hash.update(file);
+    hash.update("\0");
+    hash.update(file === "SKILL.md" ? Buffer.from(rendered, "utf8") : await fs4.readFile(path6.join(dir, file)));
+    hash.update("\0");
+  }
+  return { hash: hash.digest("hex").slice(0, 16), rendered };
+}
 async function syncSkills(library, options) {
   const mode = options.mode ?? library.config.sync.mode;
   const filtered = Boolean(options.categories?.length || options.skills?.length);
@@ -739,15 +970,34 @@ async function syncSkills(library, options) {
       }
     }
   }
-  const hashes = /* @__PURE__ */ new Map();
-  for (const name of candidates) hashes.set(name, await hashDirectory(library.skillPath(name)));
-  const dirs = options.targets.map(
-    (target) => resolveTarget(options.dest, target, { scope: options.scope, homeDir: options.homeDir })
-  );
-  const results = [];
-  for (const [index, target] of options.targets.entries()) {
-    const dir = dirs[index];
+  const definitions = /* @__PURE__ */ new Map();
+  for (const name of candidates) definitions.set(name, await library.readSkillParams(name));
+  const declared = new Set([...definitions.values()].flatMap((defs) => Object.keys(defs ?? {})));
+  if (options.params) {
+    const unknown = Object.keys(options.params).filter((key) => !declared.has(key));
+    if (unknown.length > 0) {
+      throw new Error(
+        `Unknown parameter(s) ${unknown.join(", ")}: no synced skill declares them` + (declared.size ? ` (declared: ${[...declared].join(", ")})` : " (no synced skill has parameters)")
+      );
+    }
+  }
+  const cache = /* @__PURE__ */ new Map();
+  const plans = [];
+  for (const target of options.targets) {
+    const dir = resolveTarget(options.dest, target, { scope: options.scope, homeDir: options.homeDir });
     const manifest = await readManifest(dir) ?? { tool: "skanvil", version: "", source: "", skills: {} };
+    const remembered = Object.fromEntries(Object.entries(manifest.params ?? {}).filter(([key]) => declared.has(key)));
+    const values = options.params ?? remembered;
+    const items = /* @__PURE__ */ new Map();
+    for (const name of candidates) {
+      const key = `${name}\0${JSON.stringify(values)}`;
+      if (!cache.has(key)) cache.set(key, await materialize(library, name, definitions.get(name) ?? null, values));
+      items.set(name, cache.get(key));
+    }
+    plans.push({ target, dir, manifest, values, items });
+  }
+  const results = [];
+  for (const { target, dir, manifest, values, items } of plans) {
     const result = {
       target,
       path: dir,
@@ -756,21 +1006,23 @@ async function syncSkills(library, options) {
       unchanged: [],
       removed: [],
       skipped: [...skipped],
-      warnings: []
+      warnings: [],
+      params: declared.size ? values : {}
     };
     const next = {
       tool: "skanvil",
       version: packageVersion(),
       // Relative, so a committed manifest does not change from machine to machine.
-      source: path5.relative(dir, library.root).split(path5.sep).join("/"),
-      skills: filtered ? { ...manifest.skills } : {}
+      source: path6.relative(dir, library.root).split(path6.sep).join("/"),
+      skills: filtered ? { ...manifest.skills } : {},
+      ...declared.size && Object.keys(values).length ? { params: values } : {}
     };
-    if (!options.dryRun) await fs3.mkdir(dir, { recursive: true });
+    if (!options.dryRun) await fs4.mkdir(dir, { recursive: true });
     for (const name of candidates) {
-      const destination = path5.join(dir, name);
+      const destination = path6.join(dir, name);
       const previous = manifest.skills[name];
       const present = await exists(destination);
-      const hash = hashes.get(name);
+      const { hash, rendered } = items.get(name);
       if (present && !previous) {
         result.skipped.push({ skill: name, reason: `${destination} exists and is not managed by skanvil` });
         continue;
@@ -781,7 +1033,7 @@ async function syncSkills(library, options) {
         continue;
       }
       (present ? result.updated : result.added).push(name);
-      const actualMode = options.dryRun ? mode : await place(library.skillPath(name), destination, mode, result.warnings);
+      const actualMode = options.dryRun ? mode : await place(library.skillPath(name), destination, mode, result.warnings, rendered);
       next.skills[name] = { hash, mode: actualMode };
     }
     if (!filtered) {
@@ -792,11 +1044,11 @@ async function syncSkills(library, options) {
           continue;
         }
         result.removed.push(name);
-        if (!options.dryRun) await fs3.rm(path5.join(dir, name), { recursive: true, force: true });
+        if (!options.dryRun) await fs4.rm(path6.join(dir, name), { recursive: true, force: true });
       }
     }
     if (!options.dryRun) {
-      await fs3.writeFile(path5.join(dir, MANIFEST_FILE), `${JSON.stringify(next, null, 2)}
+      await fs4.writeFile(path6.join(dir, MANIFEST_FILE), `${JSON.stringify(next, null, 2)}
 `, "utf8");
     }
     results.push(result);
@@ -805,16 +1057,16 @@ async function syncSkills(library, options) {
 }
 
 // src/core/agent-skill.ts
-import fs4 from "fs/promises";
-import path6 from "path";
+import fs5 from "fs/promises";
+import path7 from "path";
 var AGENT_SKILL_NAME = "skanvil";
 var AGENT_SKILL_VERSION_KEY = "skanvil-version";
 function agentSkillSource() {
-  return path6.join(PACKAGE_ROOT, "agent-skill", AGENT_SKILL_NAME);
+  return path7.join(PACKAGE_ROOT, "agent-skill", AGENT_SKILL_NAME);
 }
 async function installedVersion(dir) {
   try {
-    const skill = SkillFile.parse(await fs4.readFile(path6.join(dir, "SKILL.md"), "utf8"));
+    const skill = SkillFile.parse(await fs5.readFile(path7.join(dir, "SKILL.md"), "utf8"));
     return skill.getString("metadata", AGENT_SKILL_VERSION_KEY) || null;
   } catch {
     return null;
@@ -824,7 +1076,7 @@ async function installAgentSkill(options) {
   const version = packageVersion();
   const results = [];
   const destinations = options.targets.map(
-    (target) => path6.join(resolveTarget(options.dest, target, { scope: options.scope, homeDir: options.homeDir }), AGENT_SKILL_NAME)
+    (target) => path7.join(resolveTarget(options.dest, target, { scope: options.scope, homeDir: options.homeDir }), AGENT_SKILL_NAME)
   );
   for (const [index, target] of options.targets.entries()) {
     const destination = destinations[index];
@@ -843,18 +1095,255 @@ async function installAgentSkill(options) {
       results.push({ target, path: destination, status: "unchanged" });
       continue;
     }
-    await fs4.rm(destination, { recursive: true, force: true });
-    await fs4.mkdir(path6.dirname(destination), { recursive: true });
-    await fs4.cp(agentSkillSource(), destination, { recursive: true });
-    const skillPath = path6.join(destination, "SKILL.md");
-    const skill = SkillFile.parse(await fs4.readFile(skillPath, "utf8"));
+    await fs5.rm(destination, { recursive: true, force: true });
+    await fs5.mkdir(path7.dirname(destination), { recursive: true });
+    await fs5.cp(agentSkillSource(), destination, { recursive: true });
+    const skillPath = path7.join(destination, "SKILL.md");
+    const skill = SkillFile.parse(await fs5.readFile(skillPath, "utf8"));
     skill.set(["metadata", AGENT_SKILL_VERSION_KEY], version);
-    await fs4.writeFile(skillPath, skill.toString(), "utf8");
+    await fs5.writeFile(skillPath, skill.toString(), "utf8");
     results.push({ target, path: destination, status: present ? "updated" : "installed" });
   }
   return results;
 }
 
+// src/core/build.ts
+import fs6 from "fs/promises";
+import path8 from "path";
+var RESERVED = new Set(
+  "break case catch class const continue debugger default delete do else enum export extends false finally for function if import in instanceof new null return super switch this throw true try typeof var void while with yield let static implements interface package private protected public await arguments eval skills getSkill renderTemplate resolveParamValues".split(" ")
+);
+function camelCase(value) {
+  return value.split(/[^a-zA-Z0-9]+/).filter(Boolean).map((part, index) => index === 0 ? part.toLowerCase() : part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+function capitalize(identifier) {
+  return identifier.charAt(0).toUpperCase() + identifier.slice(1);
+}
+function exportNames(library, names) {
+  const fix = (name) => /^[a-z]/.test(name) && !RESERVED.has(name) ? name : `skill${capitalize(name)}`;
+  const short = new Map(names.map((name) => [name, fix(camelCase(library.categories.stripPrefix(name)))]));
+  const counts = /* @__PURE__ */ new Map();
+  for (const value of short.values()) counts.set(value, (counts.get(value) ?? 0) + 1);
+  const result = /* @__PURE__ */ new Map();
+  for (const name of names) {
+    const candidate = short.get(name);
+    result.set(name, counts.get(candidate) > 1 ? fix(camelCase(name)) : candidate);
+  }
+  return result;
+}
+function isText(buffer) {
+  return !buffer.includes(0) && Buffer.from(buffer.toString("utf8"), "utf8").equals(buffer);
+}
+function docComment(lines, indent = "") {
+  const body = lines.flatMap((line) => line.split("\n")).map((line) => `${indent} * ${line.replace(/\*\//g, "*\\/")}`.trimEnd());
+  return `${indent}/**
+${body.join("\n")}
+${indent} */
+`;
+}
+function paramsType(definitions) {
+  const entries = Object.entries(definitions).map(([name, definition]) => {
+    const type = definition.type === "enum" ? definition.values.map((value) => JSON.stringify(value)).join(" | ") : definition.type === "boolean" ? "boolean" : "string";
+    const doc = docComment(
+      [
+        ...definition.description ? [definition.description] : [],
+        `@defaultValue ${JSON.stringify(definition.default)}`
+      ],
+      "  "
+    );
+    return `${doc}  ${name}?: ${type};`;
+  });
+  return entries.length ? `{
+${entries.join("\n")}
+}` : "Record<string, never>";
+}
+function runtimeSource(skills) {
+  const data = skills.map((skill) => ({
+    name: skill.name,
+    category: skill.category,
+    title: skill.title,
+    description: skill.description,
+    params: skill.params,
+    template: skill.template,
+    files: skill.files
+  }));
+  return `const renderTemplate = ${renderTemplate.toString()};
+
+const resolveParamValues = ${resolveParamValues.toString()};
+
+const definitions = ${JSON.stringify(data, null, 2)};
+
+function createSkill(definition) {
+  const render = (params) =>
+    renderTemplate(definition.template, resolveParamValues(definition.params, params || {}, definition.name));
+  return Object.freeze({
+    name: definition.name,
+    category: definition.category,
+    title: definition.title,
+    description: definition.description,
+    params: definition.params,
+    render,
+    files: (params) => Object.assign({ "SKILL.md": { encoding: "utf8", content: render(params) } }, definition.files)
+  });
+}
+
+const skills = Object.freeze(definitions.map(createSkill));
+
+function getSkill(name) {
+  const skill = skills.find((candidate) => candidate.name === name);
+  if (!skill) throw new Error("Unknown skill '" + name + "'. Available: " + skills.map((s) => s.name).join(", "));
+  return skill;
+}
+`;
+}
+function declarationSource(skills, packageName) {
+  const header = `// Generated by skanvil build. Do not edit.
+
+/** Definition of a skill parameter (from its params.json). */
+export interface SkillParamDefinition {
+  type: "enum" | "string" | "boolean";
+  /** Allowed values of an enum parameter. */
+  values?: string[];
+  default: string | boolean;
+  description?: string;
+}
+
+/** A file of a skill. Text files are UTF-8, binary files base64. */
+export interface SkillFileContent {
+  encoding: "utf8" | "base64";
+  content: string;
+}
+
+/** A skill of ${packageName}. */
+export interface Skill<P = Record<string, unknown>> {
+  /** Folder and frontmatter name, e.g. "front-api-review". */
+  readonly name: string;
+  /** Category id. */
+  readonly category: string;
+  /** Display title. */
+  readonly title: string;
+  /** Frontmatter description (rendered with default parameters). */
+  readonly description: string;
+  /** Declared parameters. */
+  readonly params: Readonly<Record<string, SkillParamDefinition>>;
+  /** Returns SKILL.md rendered with the given parameters (defaults for the rest). Throws on invalid values. */
+  render(params?: P): string;
+  /** Every file of the skill folder, keyed by relative path, with SKILL.md rendered. Write them to e.g. .claude/skills/<name>/. */
+  files(params?: P): Record<string, SkillFileContent>;
+}
+
+/** Every skill of the package, in folder order. */
+export declare const skills: readonly Skill[];
+
+/** Finds a skill by folder name. Throws when it does not exist. */
+export declare function getSkill(name: SkillName): Skill;
+
+/** Folder names of the skills in this package. */
+export type SkillName = ${skills.map((skill) => JSON.stringify(skill.name)).join(" | ") || "never"};
+`;
+  const perSkill = skills.map((skill) => {
+    const typeName = `${capitalize(skill.exportName)}Params`;
+    return `
+${docComment([`Parameters of the \`${skill.name}\` skill.`])}export type ${typeName} = ${paramsType(skill.params)};
+
+` + docComment([
+      `${skill.title}: ${skill.description}`,
+      "",
+      `@returns The \`${skill.name}\` SKILL.md${Object.keys(skill.params).length ? ", rendered with the given parameters" : ""}.`
+    ]) + `export declare function ${skill.exportName}(params?: ${typeName}): string;
+`;
+  });
+  return header + perSkill.join("");
+}
+async function buildLibrary(library, options = {}) {
+  if (!options.force) {
+    const validation = await validateLibrary(library);
+    if (validation.errors > 0) {
+      throw new Error(
+        `Validation found ${validation.errors} error(s); run 'skanvil validate' (or build with --force).`
+      );
+    }
+  }
+  const folders = [];
+  for (const folder of await library.listSkillFolders()) {
+    if (library.categories.fromFolder(folder).validated && await library.hasSkill(folder)) folders.push(folder);
+  }
+  const names = exportNames(library, folders);
+  const skills = [];
+  for (const folder of folders) {
+    const dir = library.skillPath(folder);
+    const params = await library.readSkillParams(folder) ?? {};
+    const template = (await fs6.readFile(path8.join(dir, "SKILL.md"), "utf8")).replace(/\r\n/g, "\n");
+    const rendered = await library.readSkillRendered(folder);
+    const files = {};
+    for (const file of await listFiles(dir)) {
+      if (file === "SKILL.md" || file === PARAMS_FILE) continue;
+      const buffer = await fs6.readFile(path8.join(dir, file));
+      files[file] = isText(buffer) ? { encoding: "utf8", content: buffer.toString("utf8") } : { encoding: "base64", content: buffer.toString("base64") };
+    }
+    skills.push({
+      name: folder,
+      exportName: names.get(folder),
+      category: library.categories.fromFolder(folder).id,
+      title: rendered.title || folder,
+      description: rendered.getString("description"),
+      params,
+      template,
+      files
+    });
+  }
+  let packageName = library.config.name ?? path8.basename(library.root);
+  try {
+    packageName = JSON.parse(await fs6.readFile(path8.join(library.root, "package.json"), "utf8")).name ?? packageName;
+  } catch {
+  }
+  const outDir = path8.resolve(library.root, options.outDir ?? "dist");
+  await fs6.mkdir(outDir, { recursive: true });
+  const runtime = runtimeSource(skills);
+  const exportsList = skills.map((skill) => `  ${skill.exportName}`);
+  const functions = skills.map((skill, index) => `const ${skill.exportName} = (params) => skills[${index}].render(params);`).join("\n");
+  const banner = "// Generated by skanvil build. Do not edit.\n";
+  const esm = `${banner}${runtime}
+${functions}
+
+export {
+  skills,
+  getSkill${exportsList.length ? ",\n" + exportsList.join(",\n") : ""}
+};
+`;
+  const cjs = `${banner}"use strict";
+${runtime}
+${functions}
+
+module.exports = {
+  skills,
+  getSkill${exportsList.length ? ",\n" + exportsList.join(",\n") : ""}
+};
+`;
+  const dts = declarationSource(skills, packageName);
+  const written = {
+    "index.mjs": esm,
+    "index.cjs": cjs,
+    "index.d.mts": dts,
+    "index.d.cts": dts
+  };
+  for (const [file, content] of Object.entries(written)) {
+    await fs6.writeFile(path8.join(outDir, file), content, "utf8");
+  }
+  return {
+    outDir,
+    files: Object.keys(written).map(
+      (file) => path8.relative(library.root, path8.join(outDir, file)).split(path8.sep).join("/")
+    ),
+    skills: skills.map((skill) => ({
+      name: skill.name,
+      exportName: skill.exportName,
+      category: skill.category,
+      params: Object.keys(skill.params)
+    }))
+  };
+}
+
 // src/core/readme-index.ts
 var SUMMARY_PATTERN = /<summary><strong>(.+?)<\/strong><\/summary>/;
 function folderPattern(skillsDir) {
@@ -1260,46 +1749,46 @@ var Categories = class {
 };
 
 // src/core/config.ts
-import fs5 from "fs/promises";
-import path7 from "path";
-import { z } from "zod";
+import fs7 from "fs/promises";
+import path9 from "path";
+import { z as z2 } from "zod";
 var CONFIG_FILE = ".skanvilrc.json";
 var SEVERITIES = ["error", "warn", "off"];
 var PREFIX_PATTERN = /^(|_|[a-z0-9]+(?:-[a-z0-9]+)*-)$/;
-var CategorySchema = z.object({
-  id: z.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "category id must be kebab-case").describe("Category identifier used by `--type` (kebab-case)."),
-  prefix: z.string().regex(PREFIX_PATTERN, "prefix must be empty, '_' or kebab-case ending in '-'").optional().describe(
+var CategorySchema = z2.object({
+  id: z2.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "category id must be kebab-case").describe("Category identifier used by `--type` (kebab-case)."),
+  prefix: z2.string().regex(PREFIX_PATTERN, "prefix must be empty, '_' or kebab-case ending in '-'").optional().describe(
     "Folder-name prefix of the category's skills, e.g. `front-` or `_`. Only the default category may be empty."
   ),
-  title: z.string().min(1).optional().describe("README section title. Defaults to the title-cased id."),
-  aliases: z.array(z.string()).optional().describe("Alternative names accepted by `--type` (case-insensitive)."),
-  default: z.boolean().optional().describe(
+  title: z2.string().min(1).optional().describe("README section title. Defaults to the title-cased id."),
+  aliases: z2.array(z2.string()).optional().describe("Alternative names accepted by `--type` (case-insensitive)."),
+  default: z2.boolean().optional().describe(
     "Marks the fallback category for folders without a known prefix. Exactly one category must be the default."
   ),
-  indexed: z.boolean().optional().describe("List the category's skills in the README index. Default: true."),
-  validated: z.boolean().optional().describe("Validate the category's skills against the spec and allow syncing them. Default: true."),
-  metadata: z.record(z.string(), z.string()).optional().describe("Key/value pairs written to the `metadata` frontmatter map of new or retyped skills."),
-  compatibility: z.string().max(500).optional().describe("Value written to the `compatibility` frontmatter field of new or retyped skills (max 500 chars).")
+  indexed: z2.boolean().optional().describe("List the category's skills in the README index. Default: true."),
+  validated: z2.boolean().optional().describe("Validate the category's skills against the spec and allow syncing them. Default: true."),
+  metadata: z2.record(z2.string(), z2.string()).optional().describe("Key/value pairs written to the `metadata` frontmatter map of new or retyped skills."),
+  compatibility: z2.string().max(500).optional().describe("Value written to the `compatibility` frontmatter field of new or retyped skills (max 500 chars).")
 }).strict().describe("A skill category: folder prefix, README section and frontmatter defaults.");
-var ConfigSchema = z.object({
-  $schema: z.string().optional().describe("JSON Schema reference for editor support."),
-  name: z.string().optional().describe("Library name (informational)."),
-  scope: z.string().optional().describe("npm scope without '@' (informational)."),
-  skillsDir: z.string().min(1).optional().describe("Folder holding the skills, relative to the library root. Default: skills."),
-  readme: z.string().min(1).optional().describe("README file holding the skills index. Default: README.md."),
-  categories: z.array(CategorySchema).min(1).optional().describe("Skill categories. Replaces the default preset (front, back, transversal, internal) when set."),
-  validation: z.object({
-    requiredSections: z.array(z.string()).optional().describe("Level-2 headings (`## Name`) every SKILL.md must contain, compared case-insensitively."),
-    placeholders: z.array(z.string()).optional().describe("Forbidden placeholder strings. ALL-CAPS entries (TODO) match case-sensitively as words."),
-    maxLines: z.number().int().positive().optional().describe("Line count reported by the `max-lines` rule. Default: 500."),
-    rules: z.record(z.string(), z.enum(SEVERITIES)).optional().describe('Per-rule severity overrides, e.g. { "max-lines": "off" }. See `skanvil validate --help`.')
+var ConfigSchema = z2.object({
+  $schema: z2.string().optional().describe("JSON Schema reference for editor support."),
+  name: z2.string().optional().describe("Library name (informational)."),
+  scope: z2.string().optional().describe("npm scope without '@' (informational)."),
+  skillsDir: z2.string().min(1).optional().describe("Folder holding the skills, relative to the library root. Default: skills."),
+  readme: z2.string().min(1).optional().describe("README file holding the skills index. Default: README.md."),
+  categories: z2.array(CategorySchema).min(1).optional().describe("Skill categories. Replaces the default preset (front, back, transversal, internal) when set."),
+  validation: z2.object({
+    requiredSections: z2.array(z2.string()).optional().describe("Level-2 headings (`## Name`) every SKILL.md must contain, compared case-insensitively."),
+    placeholders: z2.array(z2.string()).optional().describe("Forbidden placeholder strings. ALL-CAPS entries (TODO) match case-sensitively as words."),
+    maxLines: z2.number().int().positive().optional().describe("Line count reported by the `max-lines` rule. Default: 500."),
+    rules: z2.record(z2.string(), z2.enum(SEVERITIES)).optional().describe('Per-rule severity overrides, e.g. { "max-lines": "off" }. See `skanvil validate --help`.')
   }).strict().optional().describe("Validation settings."),
-  templates: z.object({
-    dir: z.string().min(1).optional().describe("Folder with custom templates, relative to the library root. Default: .skanvil/templates.")
+  templates: z2.object({
+    dir: z2.string().min(1).optional().describe("Folder with custom templates, relative to the library root. Default: .skanvil/templates.")
   }).strict().optional().describe("Custom template settings."),
-  sync: z.object({
-    targets: z.array(z.string()).optional().describe("Default `skanvil sync` targets: presets (claude, copilot, agents, codex) or paths."),
-    mode: z.enum(["copy", "link"]).optional().describe("Default sync mode. Default: copy.")
+  sync: z2.object({
+    targets: z2.array(z2.string()).optional().describe("Default `skanvil sync` targets: presets (claude, copilot, agents, codex) or paths."),
+    mode: z2.enum(["copy", "link"]).optional().describe("Default sync mode. Default: copy.")
   }).strict().optional().describe("Defaults for `skanvil sync`.")
 }).strict().describe("skanvil library configuration.");
 var DEFAULT_CATEGORIES = [
@@ -1434,7 +1923,7 @@ function resolveConfig(raw = {}) {
 async function readRawConfig(root) {
   let text;
   try {
-    text = await fs5.readFile(path7.join(root, CONFIG_FILE), "utf8");
+    text = await fs7.readFile(path9.join(root, CONFIG_FILE), "utf8");
   } catch {
     return {};
   }
@@ -1448,12 +1937,12 @@ async function loadConfig(root) {
   return resolveConfig(await readRawConfig(root));
 }
 function configJsonSchema() {
-  return z.toJSONSchema(ConfigSchema, { target: "draft-7" });
+  return z2.toJSONSchema(ConfigSchema, { target: "draft-7" });
 }
 
 // src/core/library.ts
-import fs6 from "fs/promises";
-import path8 from "path";
+import fs8 from "fs/promises";
+import path10 from "path";
 var Library = class _Library {
   /** Absolute library root. */
   root;
@@ -1468,7 +1957,7 @@ var Library = class _Library {
    * @param config - Resolved configuration. @defaultValue the default preset
    */
   constructor(root, config = resolveConfig()) {
-    this.root = path8.resolve(root);
+    this.root = path10.resolve(root);
     this.config = config;
     this.categories = new Categories(config.categories);
   }
@@ -1480,7 +1969,7 @@ var Library = class _Library {
    * @throws Error when the config is invalid or the skills folder is missing.
    */
   static async open(root) {
-    const library = new _Library(root, await loadConfig(path8.resolve(root)));
+    const library = new _Library(root, await loadConfig(path10.resolve(root)));
     if (!await exists(library.skillsDir)) {
       throw new Error(
         `No ${library.config.skillsDir}/ folder found in ${library.root}. Run 'skanvil init' first or use --cwd.`
@@ -1490,29 +1979,29 @@ var Library = class _Library {
   }
   /** Absolute path of the skills folder. */
   get skillsDir() {
-    return path8.join(this.root, this.config.skillsDir);
+    return path10.join(this.root, this.config.skillsDir);
   }
   /** Skills folder as written in README entries (posix separators), e.g. `skills`. */
   get skillsDirRef() {
-    return this.config.skillsDir.split(path8.sep).join("/");
+    return this.config.skillsDir.split(path10.sep).join("/");
   }
   /** Absolute path of the README holding the index. */
   get readmePath() {
-    return path8.join(this.root, this.config.readme);
+    return path10.join(this.root, this.config.readme);
   }
   /**
    * @param name - Skill folder name.
    * @returns Absolute path of the skill folder (it may not exist).
    */
   skillPath(name) {
-    return path8.join(this.skillsDir, name);
+    return path10.join(this.skillsDir, name);
   }
   /**
    * @param name - Skill folder name.
    * @returns Absolute path of the skill's `SKILL.md` (it may not exist).
    */
   skillFilePath(name) {
-    return path8.join(this.skillPath(name), "SKILL.md");
+    return path10.join(this.skillPath(name), "SKILL.md");
   }
   /**
    * Lists the skill folders. Hidden folders (starting with `.`) are ignored.
@@ -1520,7 +2009,7 @@ var Library = class _Library {
    * @returns Folder names sorted with `localeCompare`.
    */
   async listSkillFolders() {
-    const entries = await fs6.readdir(this.skillsDir, { withFileTypes: true });
+    const entries = await fs8.readdir(this.skillsDir, { withFileTypes: true });
     return entries.filter((entry) => entry.isDirectory() && !entry.name.startsWith(".")).map((entry) => entry.name).sort((a, b) => a.localeCompare(b));
   }
   /**
@@ -1549,7 +2038,33 @@ var Library = class _Library {
    * @throws The file system error when the file cannot be read.
    */
   async readSkill(name) {
-    return SkillFile.parse(await fs6.readFile(this.skillFilePath(name), "utf8"));
+    return SkillFile.parse(await fs8.readFile(this.skillFilePath(name), "utf8"));
+  }
+  /**
+   * Reads a skill's parameter definitions (`params.json`).
+   *
+   * @param name - Skill folder name.
+   * @returns The definitions, or `null` when the skill has none.
+   * @throws Error when `params.json` exists but is invalid.
+   */
+  async readSkillParams(name) {
+    return readParams(this.skillPath(name));
+  }
+  /**
+   * Reads a skill's `SKILL.md` rendered with parameter values. Skills without `params.json` are
+   * returned as they are.
+   *
+   * @param name - Skill folder name.
+   * @param values - Parameter values; missing ones take their defaults. @defaultValue `{}`
+   * @returns The rendered file.
+   * @throws Error when the file cannot be read, `params.json` is invalid, a value is invalid, or
+   *   the template is malformed.
+   */
+  async readSkillRendered(name, values = {}) {
+    const text = await fs8.readFile(this.skillFilePath(name), "utf8");
+    const params = await this.readSkillParams(name);
+    if (!params) return SkillFile.parse(text);
+    return SkillFile.parse(renderTemplate(text, resolveParamValues(params, values, name)));
   }
   /**
    * Writes a skill's `SKILL.md`, keeping the line ending it was read with.
@@ -1558,7 +2073,7 @@ var Library = class _Library {
    * @param skill - File content to write.
    */
   async writeSkill(name, skill) {
-    await fs6.writeFile(this.skillFilePath(name), skill.toString(), "utf8");
+    await fs8.writeFile(this.skillFilePath(name), skill.toString(), "utf8");
   }
   /**
    * Reads the README.
@@ -1568,7 +2083,7 @@ var Library = class _Library {
    */
   async readReadme() {
     try {
-      return splitEol(await fs6.readFile(this.readmePath, "utf8"));
+      return splitEol(await fs8.readFile(this.readmePath, "utf8"));
     } catch {
       throw new Error(`Cannot read ${this.config.readme} in ${this.root}.`);
     }
@@ -1591,7 +2106,7 @@ var Library = class _Library {
    * @param readme - Content and line ending, usually from {@link Library.readReadme}.
    */
   async writeReadme(readme) {
-    await fs6.writeFile(this.readmePath, fromLf(readme.text, readme.eol), "utf8");
+    await fs8.writeFile(this.readmePath, fromLf(readme.text, readme.eol), "utf8");
   }
   /**
    * Lists the skills documented in each README section of the indexed categories.
@@ -1629,7 +2144,7 @@ var Library = class _Library {
     let title = "";
     let description = "";
     try {
-      const skill = await this.readSkill(name);
+      const skill = await this.readSkillRendered(name).catch(() => this.readSkill(name));
       title = skill.title;
       description = skill.getString("description");
     } catch {
@@ -1646,8 +2161,8 @@ var Library = class _Library {
 
 // src/core/init.ts
 import { spawnSync } from "child_process";
-import fs7 from "fs/promises";
-import path9 from "path";
+import fs9 from "fs/promises";
+import path11 from "path";
 var defaultCategories = new Categories(resolveConfig().categories);
 function parseProfile(value) {
   const indexed = defaultCategories.indexed.map((category) => category.id);
@@ -1668,11 +2183,11 @@ function parseProfile(value) {
   return [...new Set(ids)];
 }
 async function createLibrary(target, options = {}) {
-  target = path9.resolve(target);
+  target = path11.resolve(target);
   if (!await isEmptyOrMissing(target)) {
     throw new Error(`Target folder is not empty: ${target}`);
   }
-  const name = toKebabCase(options.name || path9.basename(target));
+  const name = toKebabCase(options.name || path11.basename(target));
   if (!name) {
     throw new Error("Library name is required.");
   }
@@ -1700,7 +2215,8 @@ async function createLibrary(target, options = {}) {
       packageName: scope ? `@${scope}/${name}` : name,
       title,
       description,
-      sections: buildSections(sectionTitles)
+      sections: buildSections(sectionTitles),
+      skanvilRange: `^${packageVersion()}`
     }
   });
   const rc = {
@@ -1718,7 +2234,7 @@ async function createLibrary(target, options = {}) {
     sync: { targets: syncTargets, mode: "copy" }
   };
   resolveConfig(rc);
-  await fs7.writeFile(path9.join(target, CONFIG_FILE), `${JSON.stringify(rc, null, 2)}
+  await fs9.writeFile(path11.join(target, CONFIG_FILE), `${JSON.stringify(rc, null, 2)}
 `, "utf8");
   if (options.ejectTemplates) {
     await ejectSkillTemplate(new Library(target, resolveConfig(rc)));
@@ -1733,7 +2249,7 @@ async function createLibrary(target, options = {}) {
 }
 
 // src/commands/shared.ts
-import path10 from "path";
+import path12 from "path";
 
 // src/util/output.ts
 import pc from "picocolors";
@@ -1776,7 +2292,7 @@ var Output = class {
 
 // src/commands/shared.ts
 function resolveRoot(options) {
-  return path10.resolve(options.cwd || process.cwd());
+  return path12.resolve(options.cwd || process.cwd());
 }
 function openLibrary(options) {
   return Library.open(resolveRoot(options));
@@ -1805,7 +2321,7 @@ async function validateAfter(library, label, skip) {
 }
 
 // src/core/skills.ts
-import fs8 from "fs/promises";
+import fs10 from "fs/promises";
 async function toLibrary(ref) {
   return typeof ref === "string" ? Library.open(ref) : ref;
 }
@@ -1875,7 +2391,7 @@ async function scaffoldSkill(ref, options) {
       await library.writeReadme(readme);
     }
   } catch (error) {
-    await fs8.rm(target, { recursive: true, force: true });
+    await fs10.rm(target, { recursive: true, force: true });
     throw error;
   }
   return { skillName, title, type: category.id, target, template };
@@ -1895,7 +2411,7 @@ async function editSkill(ref, skillName, options) {
     throw new Error(`Skill folder already exists: ${library.skillPath(newName)}`);
   }
   const skillFile = library.skillFilePath(skillName);
-  const originalSkill = await fs8.readFile(skillFile, "utf8");
+  const originalSkill = await fs10.readFile(skillFile, "utf8");
   const skill = await library.readSkill(skillName);
   skill.set(["name"], newName);
   if (description) skill.set(["description"], description);
@@ -1921,13 +2437,13 @@ async function editSkill(ref, skillName, options) {
     readme.text = insertEntry(removeEntry(readme.text, skillName, dir), newCategory.title, entry);
   }
   try {
-    await fs8.writeFile(skillFile, skill.toString(), "utf8");
+    await fs10.writeFile(skillFile, skill.toString(), "utf8");
     await library.writeReadme(readme);
     if (newName !== skillName) {
-      await fs8.rename(library.skillPath(skillName), library.skillPath(newName));
+      await fs10.rename(library.skillPath(skillName), library.skillPath(newName));
     }
   } catch (error) {
-    await fs8.writeFile(skillFile, originalSkill, "utf8").catch(() => void 0);
+    await fs10.writeFile(skillFile, originalSkill, "utf8").catch(() => void 0);
     await library.writeReadme(originalReadme).catch(() => void 0);
     throw new Error(`Edit failed and was rolled back: ${error.message}`);
   }
@@ -1937,7 +2453,7 @@ async function removeSkill(ref, skillName) {
   const library = await toLibrary(ref);
   await library.requireSkill(skillName);
   const readme = await library.readReadmeOrEmpty();
-  await fs8.rm(library.skillPath(skillName), { recursive: true, force: true });
+  await fs10.rm(library.skillPath(skillName), { recursive: true, force: true });
   if (readme.text) {
     readme.text = removeEntry(readme.text, skillName, library.skillsDirRef);
     await library.writeReadme(readme);
@@ -2068,6 +2584,13 @@ export {
   packageVersion,
   displayPath,
   SkillFile,
+  PARAMS_FILE,
+  parseParams,
+  readParams,
+  resolveParamValues,
+  renderTemplate,
+  findUndeclaredParams,
+  parseParamPairs,
   toKebabCase,
   toTitleCase,
   resolveSkillTemplate,
@@ -2084,6 +2607,8 @@ export {
   AGENT_SKILL_NAME,
   agentSkillSource,
   installAgentSkill,
+  exportNames,
+  buildLibrary,
   rebuildIndex,
   reconcileIndex,
   doctor,