@uinaf/skillcheck 0.1.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 undefined is not a function LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,63 @@
+![skillcheck — lint and eval harness for agent skills.](https://uinaf.dev/og/banner/skillcheck.png)
+
+# @uinaf/skillcheck
+
+lint and eval harness for agent skills. one CLI with two halves: a keyless
+structural lint any repo can run in CI, and a promptfoo-driven eval loop that
+grades what a skill actually makes an agent do.
+
+built for [uinaf](https://uinaf.dev) skill repos. nothing in it is
+uinaf-specific. it ships no opinion about what a skill should say, only about
+where skills sit and how a scenario is scored.
+
+## install
+
+```sh
+pnpm add -D @uinaf/skillcheck
+```
+
+node 24 or newer. the package ships compiled ESM and runs no install scripts,
+so a runner using `--ignore-scripts` is fine. consumers still pinned to the
+pre-npm git tags are covered in [adoption](docs/adoption.md).
+
+## use
+
+```sh
+skillcheck lint                              # structural lint, no credentials
+skillcheck run skills/wat/evals/basic        # one scenario, graded end to end
+skillcheck sweep && skillcheck summarize     # every scenario, then a scorecard
+```
+
+`lint` needs nothing. `run` and `sweep` need model auth, which is why sweeps
+stay operator-run and consumer repos never hold credentials. every command,
+flag, and auth variable is in [usage](docs/usage.md).
+
+## layout contract
+
+frozen, not configurable. every command reads one root: `--root <dir>`, or the
+current directory.
+
+```text
+<root>/skills/<skill>/SKILL.md                       linted
+<root>/skills/<skill>/evals/<scenario>/task.md       the problem + input files
+<root>/skills/<skill>/evals/<scenario>/criteria.json the weighted checklist
+<root>/.skillcheck/                                  results, scratch, scorecards
+```
+
+`cli/*/skills/<skill>/` is scanned too, for repos that keep a skill next to the
+CLI it documents.
+
+## docs
+
+| doc                             | when                                  |
+| ------------------------------- | ------------------------------------- |
+| [usage](docs/usage.md)          | every subcommand, flag, and auth path |
+| [scenarios](docs/scenarios.md)  | writing an eval scenario              |
+| [adoption](docs/adoption.md)    | wiring the lint into another repo     |
+| [releasing](docs/releasing.md)  | the npm pipeline                      |
+| [contributing](CONTRIBUTING.md) | local setup and the verify gate       |
+| [security](SECURITY.md)         | reporting a vulnerability             |
+
+## license
+
+MIT · undefined is not a function LLC

package/dist/cli.js

@@ -0,0 +1,344 @@
+#!/usr/bin/env node
+import { lintSkills } from "./lint.js";
+import { generateRun, runNameFor } from "./scenario.js";
+import { execFileSync, spawnSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+//#region src/cli.ts
+const here = path.dirname(fileURLToPath(import.meta.url));
+const packageDir = path.resolve(here, "..");
+const selfExt = path.extname(fileURLToPath(import.meta.url));
+function toolVersion() {
+	return JSON.parse(fs.readFileSync(path.join(packageDir, "package.json"), "utf8")).version;
+}
+function parseMaxTurns(raw) {
+	const n = Number(raw);
+	if (!Number.isInteger(n) || n <= 0) throw new Error(`--max-turns must be a positive integer, got ${JSON.stringify(raw)}`);
+	return n;
+}
+function fail(msg) {
+	console.error(msg);
+	process.exit(1);
+}
+function parseArgs(argv) {
+	const positional = [];
+	const flags = /* @__PURE__ */ new Map();
+	const takesValue = /* @__PURE__ */ new Set([
+		"--root",
+		"--agent",
+		"--judge",
+		"--harness",
+		"--max-turns"
+	]);
+	for (let i = 0; i < argv.length; i++) {
+		const a = argv[i];
+		if (!a.startsWith("--")) positional.push(a);
+		else if (takesValue.has(a)) {
+			const v = argv[++i];
+			if (v === void 0 || v.startsWith("--")) throw new Error(`${a} needs a value`);
+			flags.set(a, v);
+		} else if (a === "--all" || a === "--allow-mixed") flags.set(a, true);
+		else throw new Error(`unknown flag: ${a}`);
+	}
+	return {
+		positional,
+		flags
+	};
+}
+function resolveRoot(flags) {
+	return path.resolve(flags.get("--root") ?? process.cwd());
+}
+function stateDirs(root) {
+	const base = path.join(root, ".skillcheck");
+	return {
+		results: path.join(base, "results"),
+		scratch: path.join(base, "scratch"),
+		scorecards: path.join(base, "scorecards")
+	};
+}
+function runOptions(flags) {
+	const harness = flags.get("--harness") ?? "claude";
+	if (harness !== "claude" && harness !== "codex") fail(`--harness must be claude or codex, got ${harness}`);
+	return {
+		harness,
+		agentModel: flags.get("--agent"),
+		judgeModel: flags.get("--judge") ?? "claude-opus-5",
+		maxTurns: flags.has("--max-turns") ? parseMaxTurns(flags.get("--max-turns")) : void 0
+	};
+}
+function classifyResult(raw) {
+	const root = raw;
+	const res = root?.results?.results?.[0];
+	if (res === void 0) return { error: "promptfoo output carried no result" };
+	const message = typeof res.error === "string" ? res.error.trim() : "";
+	if (message !== "") return { error: message };
+	const stats = root?.results?.stats;
+	if (stats !== void 0 && (stats.errors ?? 0) > 0 && (stats.successes ?? 0) === 0 && (stats.failures ?? 0) === 0) return { error: "promptfoo reported an errored test with nothing graded" };
+	if (typeof res.score !== "number" || typeof res.success !== "boolean") return { error: "promptfoo result carried no usable score" };
+	return {
+		score: res.score,
+		pass: res.success
+	};
+}
+function gitHead(root) {
+	return execFileSync("git", ["rev-parse", "HEAD"], {
+		cwd: root,
+		encoding: "utf8"
+	}).trim();
+}
+function metaPath(resultPath) {
+	return resultPath.replace(/\.json$/, ".meta.json");
+}
+function runScenario(scenarioDir, opts, root) {
+	const dirs = stateDirs(root);
+	const { name, configPath } = generateRun(path.resolve(scenarioDir), opts, {
+		scratchDir: dirs.scratch,
+		transformPath: path.join(here, `transform${selfExt}`)
+	});
+	fs.mkdirSync(dirs.results, { recursive: true });
+	const resultPath = path.join(dirs.results, `${name}.json`);
+	fs.rmSync(resultPath, { force: true });
+	fs.rmSync(metaPath(resultPath), { force: true });
+	const sha = gitHead(root);
+	const rc = spawnSync("npx", [
+		"promptfoo",
+		"eval",
+		"--no-cache",
+		"--no-progress-bar",
+		"-j",
+		process.env.EVALS_CONCURRENCY ?? "4",
+		"-c",
+		configPath,
+		"-o",
+		resultPath
+	], {
+		cwd: packageDir,
+		stdio: "inherit",
+		env: {
+			...process.env,
+			PROMPTFOO_FAILED_TEST_EXIT_CODE: "0"
+		}
+	}).status ?? 1;
+	const outcome = {
+		name,
+		rc,
+		resultPath
+	};
+	if (rc !== 0) return outcome;
+	let verdict;
+	try {
+		verdict = classifyResult(JSON.parse(fs.readFileSync(resultPath, "utf8")));
+	} catch {
+		verdict = { error: "promptfoo produced no parseable result file" };
+	}
+	outcome.score = verdict.score;
+	outcome.pass = verdict.pass;
+	outcome.error = verdict.error;
+	if (verdict.score !== void 0) fs.writeFileSync(metaPath(resultPath), JSON.stringify({
+		skills_tree_sha: sha,
+		harness: opts.harness,
+		ran_at: (/* @__PURE__ */ new Date()).toISOString(),
+		tool_version: toolVersion()
+	}, null, 2) + "\n");
+	return outcome;
+}
+function discoverScenarios(root) {
+	const roots = [path.join(root, "skills")];
+	const cliDir = path.join(root, "cli");
+	if (fs.existsSync(cliDir)) {
+		for (const e of fs.readdirSync(cliDir, { withFileTypes: true })) if (e.isDirectory()) roots.push(path.join(cliDir, e.name, "skills"));
+	}
+	const found = [];
+	for (const dir of roots) {
+		if (!fs.existsSync(dir)) continue;
+		for (const skill of fs.readdirSync(dir, { withFileTypes: true })) {
+			const evalsDir = path.join(dir, skill.name, "evals");
+			if (!skill.isDirectory() || !fs.existsSync(evalsDir)) continue;
+			for (const sc of fs.readdirSync(evalsDir, { withFileTypes: true })) {
+				const scenarioDir = path.join(evalsDir, sc.name);
+				if (sc.isDirectory() && fs.existsSync(path.join(scenarioDir, "task.md")) && fs.existsSync(path.join(scenarioDir, "criteria.json"))) found.push(scenarioDir);
+			}
+		}
+	}
+	return found.sort();
+}
+function cmdRun(argv) {
+	const { positional, flags } = parseArgs(argv);
+	if (positional.length !== 1) fail("usage: skillcheck run <scenario-dir> [--root DIR] [--agent MODEL] [--judge MODEL] [--harness claude|codex]");
+	const o = runScenario(positional[0], runOptions(flags), resolveRoot(flags));
+	if (o.score === void 0) {
+		console.error(`ERROR ${o.name}: ${o.error ?? "no usable result"} (promptfoo rc=${o.rc})`);
+		process.exit(2);
+	}
+	console.log(`${o.pass ? "PASS" : "FAIL"} ${o.name} score=${o.score.toFixed(4)} (results: ${o.resultPath})`);
+	process.exit(o.pass ? 0 : 1);
+}
+function cmdSweep(argv) {
+	const { positional, flags } = parseArgs(argv);
+	if (positional.length > 0) fail("usage: skillcheck sweep [--root DIR] [--all]");
+	const root = resolveRoot(flags);
+	const opts = runOptions(flags);
+	const all = flags.get("--all") === true;
+	const resultsDir = stateDirs(root).results;
+	let passed = 0, failed = 0, errored = 0, skipped = 0;
+	for (const dir of discoverScenarios(root)) {
+		const name = runNameFor(dir, opts.harness);
+		const resultPath = path.join(resultsDir, `${name}.json`);
+		if (!all && fs.existsSync(resultPath)) {
+			skipped++;
+			console.log(`SKIP  ${name} (results exist; use --all to rerun)`);
+			continue;
+		}
+		const o = runScenario(dir, opts, root);
+		if (o.score === void 0) {
+			errored++;
+			console.log(`ERROR ${o.name} ${o.error ?? "no usable result"} (promptfoo rc=${o.rc})`);
+		} else if (o.pass) {
+			passed++;
+			console.log(`PASS  ${o.name} score=${o.score.toFixed(4)}`);
+		} else {
+			failed++;
+			console.log(`FAIL  ${o.name} score=${o.score.toFixed(4)}`);
+		}
+	}
+	console.log(`\nsweep: ${passed} passed, ${failed} failed, ${errored} errored, ${skipped} skipped`);
+	process.exit(errored > 0 ? 2 : failed > 0 ? 1 : 0);
+}
+function reduceResults(dir, allowMixed) {
+	const entries = [];
+	const skipped = [];
+	const shas = /* @__PURE__ */ new Set();
+	for (const f of fs.readdirSync(dir).filter((f) => f.endsWith(".json") && !f.endsWith(".meta.json")).sort()) {
+		let raw;
+		try {
+			raw = JSON.parse(fs.readFileSync(path.join(dir, f), "utf8"));
+		} catch {
+			raw = void 0;
+		}
+		const res = raw?.results?.results?.[0];
+		if (typeof res?.score !== "number" || typeof res?.success !== "boolean") {
+			console.error(`skipping ${f}: not a promptfoo result`);
+			skipped.push(f);
+			continue;
+		}
+		const provider = raw.config?.providers?.[0];
+		const judge = raw.config?.defaultTest?.options?.provider;
+		const base = f.replace(/\.json$/, "");
+		const harness = base.endsWith("--codex") ? "codex" : "claude";
+		const [skill, ...rest] = base.replace(/--codex$/, "").split("--");
+		let sha = "unattested";
+		try {
+			sha = JSON.parse(fs.readFileSync(path.join(dir, `${base}.meta.json`), "utf8")).skills_tree_sha ?? "unattested";
+		} catch {}
+		shas.add(sha);
+		entries.push({
+			skill,
+			scenario: rest.join("--"),
+			harness,
+			skills_tree_sha: sha,
+			score: res.score,
+			pass: res.success,
+			agent_model: provider?.config?.model ?? "codex-default",
+			judge_model: typeof judge === "string" ? judge.replace(/^anthropic:messages:/, "") : judge?.config?.model ?? "unknown",
+			latency_ms: res.latencyMs,
+			tokens: (res.tokenUsage?.total ?? 0) + (res.tokenUsage?.assertions?.total ?? 0)
+		});
+	}
+	if (shas.size > 1 && !allowMixed) throw new Error(`results span multiple skills-tree revisions (${[...shas].join(", ")}); rerun stale ones or pass --allow-mixed`);
+	return {
+		treeSha: shas.size === 1 ? [...shas][0] : shas.size === 0 ? "none" : "mixed",
+		entries,
+		skipped
+	};
+}
+function entryKey(e) {
+	return [
+		e.skill,
+		e.scenario,
+		e.harness
+	].join("\0");
+}
+function mergeScorecard(existing, fresh) {
+	const byKey = /* @__PURE__ */ new Map();
+	for (const e of existing) byKey.set(entryKey(e), e);
+	let carried = byKey.size;
+	for (const e of fresh) {
+		if (byKey.has(entryKey(e))) carried--;
+		byKey.set(entryKey(e), e);
+	}
+	return {
+		entries: [...byKey.values()].sort((a, b) => entryKey(a) < entryKey(b) ? -1 : entryKey(a) > entryKey(b) ? 1 : 0),
+		carried
+	};
+}
+function treeShaOf(entries) {
+	const shas = new Set(entries.map((e) => e.skills_tree_sha));
+	return shas.size === 1 ? [...shas][0] : shas.size === 0 ? "none" : "mixed";
+}
+function readExistingScorecard(out) {
+	if (!fs.existsSync(out)) return [];
+	let prev;
+	try {
+		prev = JSON.parse(fs.readFileSync(out, "utf8"));
+	} catch {
+		throw new Error(`existing scorecard ${out} is not valid JSON; refusing to overwrite it`);
+	}
+	const scenarios = prev?.scenarios;
+	if (!Array.isArray(scenarios)) throw new Error(`existing scorecard ${out} has no scenarios array; refusing to overwrite it`);
+	return scenarios;
+}
+function cmdSummarize(argv) {
+	const { positional, flags } = parseArgs(argv);
+	if (positional.length > 0) fail("usage: skillcheck summarize [--root DIR] [--allow-mixed]");
+	const dirs = stateDirs(resolveRoot(flags));
+	if (!fs.existsSync(dirs.results)) fail(`no results directory at ${dirs.results} — run some evals first`);
+	const { entries, skipped } = reduceResults(dirs.results, flags.get("--allow-mixed") === true);
+	fs.mkdirSync(dirs.scorecards, { recursive: true });
+	const out = path.join(dirs.scorecards, `${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}.json`);
+	const existing = readExistingScorecard(out);
+	const merged = mergeScorecard(existing, entries);
+	const scorecard = {
+		ran_at: (/* @__PURE__ */ new Date()).toISOString(),
+		skills_tree_sha: treeShaOf(merged.entries),
+		scenarios: merged.entries
+	};
+	fs.writeFileSync(out, JSON.stringify(scorecard, null, 2) + "\n");
+	console.log(`${out}: ${merged.entries.length} scenario(s), ${merged.entries.filter((e) => e.pass).length} passing, ${skipped.length} skipped file(s)`);
+	if (existing.length > 0) console.log(`merged into today's scorecard: ${entries.length} from this run, ${merged.carried} carried over`);
+}
+function cmdLint(argv) {
+	const { positional, flags } = parseArgs(argv);
+	if (positional.length > 1) fail("usage: skillcheck lint [<root>] [--root DIR]");
+	const root = positional.length === 1 ? path.resolve(positional[0]) : resolveRoot(flags);
+	const { errors, count } = lintSkills(root);
+	if (errors.length > 0) {
+		for (const e of errors) console.error(e);
+		console.error(`skill lint: ${errors.length} error(s) across ${count} package(s)`);
+		process.exit(1);
+	}
+	console.log(`skill lint: ${count} package(s) clean`);
+}
+function isMainModule() {
+	const entry = process.argv[1];
+	if (entry === void 0) return false;
+	try {
+		return fs.realpathSync(entry) === fs.realpathSync(fileURLToPath(import.meta.url));
+	} catch {
+		return false;
+	}
+}
+if (isMainModule()) {
+	const [cmd, ...rest] = process.argv.slice(2);
+	try {
+		if (cmd === "run") cmdRun(rest);
+		else if (cmd === "sweep") cmdSweep(rest);
+		else if (cmd === "summarize") cmdSummarize(rest);
+		else if (cmd === "lint") cmdLint(rest);
+		else fail("usage: skillcheck <lint|run|sweep|summarize> ...");
+	} catch (err) {
+		fail(err instanceof Error ? err.message : String(err));
+	}
+}
+//#endregion
+export { classifyResult, mergeScorecard, parseArgs, parseMaxTurns, reduceResults, resolveRoot, stateDirs, toolVersion, treeShaOf };

package/dist/lint.js

@@ -0,0 +1,79 @@
+import fs from "node:fs";
+import path from "node:path";
+//#region src/lint.ts
+const ALLOWED_KEYS = /* @__PURE__ */ new Set([
+	"name",
+	"description",
+	"disable-model-invocation"
+]);
+function lintSkill(dir, root, errors) {
+	const skillMd = path.join(dir, "SKILL.md");
+	const label = path.relative(root, skillMd);
+	if (!fs.existsSync(skillMd)) {
+		errors.push(`${path.relative(root, dir)}: missing SKILL.md`);
+		return;
+	}
+	const lines = fs.readFileSync(skillMd, "utf8").split("\n");
+	if (lines[0] !== "---") {
+		errors.push(`${label}: frontmatter must open with --- on line 1`);
+		return;
+	}
+	const close = lines.indexOf("---", 1);
+	if (close === -1) {
+		errors.push(`${label}: frontmatter never closes`);
+		return;
+	}
+	const fields = /* @__PURE__ */ new Map();
+	for (const line of lines.slice(1, close)) {
+		const m = line.match(/^([a-z-]+):\s*(.*)$/);
+		if (!m) {
+			errors.push(`${label}: unparseable frontmatter line: ${line}`);
+			continue;
+		}
+		const [, key, raw] = m;
+		if (!ALLOWED_KEYS.has(key)) {
+			errors.push(`${label}: unknown frontmatter key: ${key}`);
+			continue;
+		}
+		if (fields.has(key)) {
+			errors.push(`${label}: duplicate frontmatter key: ${key}`);
+			continue;
+		}
+		const value = raw.replace(/^"(.*)"$/s, "$1").replace(/^'(.*)'$/s, "$1").trim();
+		fields.set(key, {
+			raw: raw.trim(),
+			value
+		});
+	}
+	const name = fields.get("name")?.value ?? "";
+	if (name !== path.basename(dir)) errors.push(`${label}: frontmatter name ${JSON.stringify(name)} != directory ${path.basename(dir)}`);
+	if (!fields.get("description")?.value) errors.push(`${label}: description is required and must be non-empty`);
+	const dmi = fields.get("disable-model-invocation");
+	if (dmi !== void 0 && dmi.raw !== "true") errors.push(`${label}: disable-model-invocation must be the literal boolean true, got ${JSON.stringify(dmi.raw)}`);
+	const body = lines.slice(close + 1).join("\n").replace(/^```[\s\S]*?^```/gm, "").replace(/`[^`\n]*`/g, "");
+	for (const link of body.matchAll(/\]\(\s*(<[^>\n]*>|[^)\s]+)(?:\s+"[^"\n]*")?\s*\)/g)) {
+		const target = link[1].replace(/^<(.*)>$/, "$1");
+		if (/^[a-z][a-z+.-]*:/.test(target) || target.startsWith("#") || target === "") continue;
+		const resolved = path.join(dir, target.split("#")[0]);
+		if (!fs.existsSync(resolved)) errors.push(`${label}: link target does not exist: ${target}`);
+	}
+}
+function lintSkills(root) {
+	const roots = ["skills", ...fs.globSync("cli/*/skills", { cwd: root })].map((r) => path.join(root, r));
+	const errors = [];
+	let count = 0;
+	for (const dir of roots) {
+		if (!fs.existsSync(dir)) continue;
+		for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+			if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
+			lintSkill(path.join(dir, entry.name), root, errors);
+			count++;
+		}
+	}
+	return {
+		errors,
+		count
+	};
+}
+//#endregion
+export { lintSkills };

package/dist/scenario.js

@@ -0,0 +1,228 @@
+import { createRequire } from "node:module";
+import fs from "node:fs";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import os from "node:os";
+//#region src/scenario.ts
+function loadScenario(scenarioDir) {
+	const match = scenarioDir.match(/skills\/([^/]+)\/evals\/([^/]+)$/);
+	if (!match) throw new Error(`not a scenario dir (want .../skills/<skill>/evals/<scenario>): ${scenarioDir}`);
+	const [, skill, scenario] = match;
+	const taskMd = fs.readFileSync(path.join(scenarioDir, "task.md"), "utf8");
+	const criteria = JSON.parse(fs.readFileSync(path.join(scenarioDir, "criteria.json"), "utf8"));
+	if (criteria.type !== "weighted_checklist" || !Array.isArray(criteria.checklist) || criteria.checklist.length === 0) throw new Error(`unsupported or empty criteria in ${scenarioDir}`);
+	for (const item of criteria.checklist) if (!(typeof item?.name === "string" && item.name.trim() !== "" && typeof item?.description === "string" && item.description.trim() !== "" && Number.isFinite(item?.max_score) && item.max_score > 0)) throw new Error(`invalid checklist item in ${scenarioDir}: ${JSON.stringify(item)}`);
+	const files = [];
+	let prompt = taskMd.replace(/^=+ FILE: (.+?) =+\n([\s\S]*?)\n=+ END FILE =+$/gm, (_, name, content) => {
+		files.push({
+			name: name.trim(),
+			content: content + "\n"
+		});
+		return `(Input file \`${name.trim()}\` is available in your working directory.)`;
+	});
+	const skillDir = path.resolve(scenarioDir, "../..");
+	if (isHiddenSkill(fs.readFileSync(path.join(skillDir, "SKILL.md"), "utf8"))) prompt = `Use the ${skill} skill for this task.\n\n${prompt}`;
+	return {
+		skill,
+		scenario,
+		name: `${skill}--${scenario}`,
+		skillDir,
+		prompt,
+		files,
+		criteria
+	};
+}
+function runNameFor(scenarioDir, harness) {
+	const m = path.resolve(scenarioDir).match(/skills\/([^/]+)\/evals\/([^/]+)$/);
+	if (!m) throw new Error(`not a scenario dir (want .../skills/<skill>/evals/<scenario>): ${scenarioDir}`);
+	return harness === "codex" ? `${m[1]}--${m[2]}--codex` : `${m[1]}--${m[2]}`;
+}
+function frontmatterRange(text) {
+	const lines = text.split("\n");
+	if (lines[0] !== "---") return null;
+	const close = lines.indexOf("---", 1);
+	return close === -1 ? null : [1, close];
+}
+function isHiddenSkill(skillMd) {
+	const range = frontmatterRange(skillMd);
+	if (!range) return false;
+	return skillMd.split("\n").slice(range[0], range[1]).some((l) => l.startsWith("disable-model-invocation:"));
+}
+function stripHiddenFlag(skillMd) {
+	const range = frontmatterRange(skillMd);
+	if (!range) return skillMd;
+	return skillMd.split("\n").filter((l, i) => !(i >= range[0] && i < range[1] && l.startsWith("disable-model-invocation:"))).join("\n");
+}
+const RESERVED = /* @__PURE__ */ new Set([".claude", ".agents"]);
+function materialize(s, runDir, harness) {
+	const workdir = path.join(runDir, "workdir");
+	fs.rmSync(runDir, {
+		recursive: true,
+		force: true
+	});
+	fs.mkdirSync(workdir, { recursive: true });
+	const seen = /* @__PURE__ */ new Set();
+	const planned = s.files.map((f) => {
+		const dest = path.resolve(workdir, f.name);
+		const rel = path.relative(workdir, dest);
+		if (rel === "" || rel.startsWith("..") || path.isAbsolute(rel)) throw new Error(`embedded file escapes workdir: ${f.name}`);
+		if (RESERVED.has(rel.split(path.sep)[0])) throw new Error(`embedded file targets reserved dir: ${f.name}`);
+		if (seen.has(dest)) throw new Error(`duplicate embedded file: ${f.name}`);
+		seen.add(dest);
+		return {
+			dest,
+			content: f.content
+		};
+	});
+	for (const { dest, content } of planned) {
+		fs.mkdirSync(path.dirname(dest), { recursive: true });
+		fs.writeFileSync(dest, content);
+	}
+	const roots = harness === "codex" ? [".claude", ".agents"] : [".claude"];
+	for (const root of roots) fs.cpSync(s.skillDir, path.join(workdir, root, "skills", s.skill), {
+		recursive: true,
+		filter: (src) => path.basename(src) !== "evals"
+	});
+	for (const root of roots) {
+		const skillMd = path.join(workdir, root, "skills", s.skill, "SKILL.md");
+		const text = fs.readFileSync(skillMd, "utf8");
+		const stripped = stripHiddenFlag(text);
+		if (stripped !== text) fs.writeFileSync(skillMd, stripped);
+	}
+	const manifest = {};
+	const walk = (dir) => {
+		for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+			const p = path.join(dir, e.name);
+			if (e.isDirectory()) {
+				if (e.name !== ".claude") walk(p);
+			} else manifest[path.relative(workdir, p)] = createHash("sha256").update(fs.readFileSync(p)).digest("hex");
+		}
+	};
+	walk(workdir);
+	const manifestPath = path.join(runDir, "manifest.json");
+	fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+	return {
+		workdir,
+		manifestPath
+	};
+}
+function agentProvider(opts, workdir, skill) {
+	if (opts.harness === "codex") return {
+		id: "openai:codex-sdk",
+		config: {
+			...opts.agentModel ? { model: opts.agentModel } : {},
+			working_dir: workdir,
+			skip_git_repo_check: true,
+			enable_streaming: true,
+			sandbox_mode: "workspace-write",
+			cli_env: { CODEX_HOME: process.env.CODEX_HOME ?? path.join(os.homedir(), ".codex") }
+		}
+	};
+	return {
+		id: "anthropic:claude-agent-sdk",
+		config: {
+			model: opts.agentModel ?? "claude-opus-5",
+			apiKeyRequired: false,
+			working_dir: workdir,
+			setting_sources: ["project"],
+			skills: [skill],
+			permission_mode: "acceptEdits",
+			append_allowed_tools: [
+				"Read",
+				"Write",
+				"Edit",
+				"Glob",
+				"Grep"
+			],
+			max_turns: opts.maxTurns ?? 50
+		}
+	};
+}
+function buildConfig(s, workdir, manifestPath, opts, transformPath) {
+	return {
+		description: `${s.skill}/${s.scenario}`,
+		prompts: ["{{task}}"],
+		providers: [agentProvider(opts, workdir, s.skill)],
+		defaultTest: { options: {
+			provider: process.env.ANTHROPIC_API_KEY ? `anthropic:messages:${opts.judgeModel}` : {
+				id: "anthropic:claude-agent-sdk",
+				config: {
+					model: opts.judgeModel,
+					apiKeyRequired: false,
+					max_turns: 3,
+					output_format: {
+						type: "json_schema",
+						schema: {
+							type: "object",
+							additionalProperties: false,
+							required: [
+								"reason",
+								"pass",
+								"score"
+							],
+							properties: {
+								reason: { type: "string" },
+								pass: { type: "boolean" },
+								score: {
+									type: "number",
+									minimum: 0,
+									maximum: 1
+								}
+							}
+						}
+					}
+				}
+			},
+			transform: `file://${transformPath}`
+		} },
+		tests: [{
+			description: s.criteria.context,
+			vars: {
+				task: s.prompt,
+				workdir,
+				manifest: manifestPath
+			},
+			assert: [{
+				type: "assert-set",
+				threshold: .7,
+				assert: s.criteria.checklist.map((item) => ({
+					type: "llm-rubric",
+					value: `${item.name}: ${item.description}`,
+					weight: item.max_score
+				}))
+			}, {
+				type: "skill-used",
+				value: s.skill
+			}]
+		}]
+	};
+}
+const SDK_PACKAGES = ["@anthropic-ai/claude-agent-sdk", "@openai/codex-sdk"];
+function sdkNodeModulesDir() {
+	const require = createRequire(import.meta.url);
+	for (const pkg of SDK_PACKAGES) for (const dir of require.resolve.paths(pkg) ?? []) if (fs.existsSync(path.join(dir, pkg, "package.json"))) return dir;
+}
+function generateRun(scenarioDir, opts, paths) {
+	const s = loadScenario(scenarioDir);
+	const name = runNameFor(scenarioDir, opts.harness);
+	const runDir = path.join(paths.scratchDir, name);
+	const { workdir, manifestPath } = materialize(s, runDir, opts.harness);
+	const sdkDir = sdkNodeModulesDir();
+	if (sdkDir !== void 0) {
+		const link = path.join(runDir, "node_modules");
+		fs.rmSync(link, {
+			recursive: true,
+			force: true
+		});
+		fs.symlinkSync(sdkDir, link, "dir");
+	}
+	const config = buildConfig(s, workdir, manifestPath, opts, paths.transformPath);
+	const configPath = path.join(runDir, "promptfooconfig.json");
+	fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+	return {
+		name,
+		configPath
+	};
+}
+//#endregion
+export { buildConfig, generateRun, isHiddenSkill, loadScenario, materialize, runNameFor, sdkNodeModulesDir, stripHiddenFlag };

package/dist/transform.js

@@ -0,0 +1,67 @@
+import fs from "node:fs";
+import path from "node:path";
+import { createHash } from "node:crypto";
+//#region src/transform.ts
+const PER_FILE_CAP = 4e3;
+const TOTAL_CAP = 24e3;
+function safeSlice(text, end) {
+	let cut = text.slice(0, end);
+	const last = cut.charCodeAt(cut.length - 1);
+	if (last >= 55296 && last <= 56319) cut = cut.slice(0, -1);
+	return cut;
+}
+function capped(rel, text) {
+	if (text.length <= PER_FILE_CAP) return `=== OUTPUT FILE: ${rel} ===\n${text}\n=== END OUTPUT FILE ===`;
+	return `=== OUTPUT FILE: ${rel} (truncated: showing ${PER_FILE_CAP} of ${text.length} chars) ===\n${safeSlice(text, PER_FILE_CAP)}\n=== END OUTPUT FILE ===`;
+}
+function transform(output, context) {
+	const workdir = context.vars.workdir;
+	const manifest = JSON.parse(fs.readFileSync(context.vars.manifest, "utf8"));
+	const sections = [];
+	const visited = /* @__PURE__ */ new Set();
+	const walk = (dir) => {
+		for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+			const p = path.join(dir, e.name);
+			if (e.isDirectory()) {
+				if (e.name !== ".claude") walk(p);
+			} else if (e.isFile()) {
+				const rel = path.relative(workdir, p);
+				visited.add(rel);
+				let body;
+				try {
+					body = fs.readFileSync(p);
+				} catch (err) {
+					const detail = err instanceof Error ? err.message : String(err);
+					sections.push({
+						rel,
+						text: `=== UNREADABLE FILE: ${rel} === (${detail})`
+					});
+					continue;
+				}
+				const hash = createHash("sha256").update(body).digest("hex");
+				if (manifest[rel] !== hash) sections.push({
+					rel,
+					text: capped(rel, body.toString("utf8"))
+				});
+			} else {
+				const nrel = path.relative(workdir, p);
+				sections.push({
+					rel: nrel,
+					text: `=== NON-REGULAR FILE: ${nrel} ===`
+				});
+			}
+		}
+	};
+	walk(workdir);
+	for (const rel of Object.keys(manifest)) if (!visited.has(rel)) sections.push({
+		rel,
+		text: `=== DELETED FILE: ${rel} === (input file removed by the agent)`
+	});
+	if (sections.length === 0) return output;
+	sections.sort((a, b) => a.rel < b.rel ? -1 : a.rel > b.rel ? 1 : 0);
+	let appended = sections.map((s) => s.text).join("\n\n");
+	if (appended.length > TOTAL_CAP) appended = `${safeSlice(appended, TOTAL_CAP)}\n\n=== TRUNCATED: output files exceeded ${TOTAL_CAP} chars total ===`;
+	return `${output}\n\n${appended}`;
+}
+//#endregion
+export { transform as default };

package/docs/adoption.md

@@ -0,0 +1,80 @@
+# adopting it in a repo
+
+two separate decisions: run the lint in CI, and run evals on a machine that has
+model auth. only the first belongs in a consumer repo.
+
+## lint in CI
+
+```sh
+pnpm add -D @uinaf/skillcheck
+```
+
+runners that install with `--ignore-scripts` are fine: the package ships
+compiled ESM and has no install, prepare, or postinstall script.
+
+```json
+{ "scripts": { "skills:lint": "skillcheck lint" } }
+```
+
+```yaml
+jobs:
+  skills:
+    name: skills lint
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          persist-credentials: false
+      - uses: actions/setup-node@249970729cb0ef3589644e2896645e5dc5ba9c38 # v6.5.0
+        with:
+          node-version: "24"
+      - run: pnpm install --frozen-lockfile
+      - run: pnpm run skills:lint
+```
+
+the job needs no secrets and no network beyond the install. node 24 is the
+floor.
+
+run it through the script rather than a bare `npx skillcheck`: the script
+resolves the version the repo pinned, and `npx` would resolve the latest one on
+the registry.
+
+## evals
+
+sweeps need model credentials, so they stay off consumer CI and run from an
+operator machine or a job that already holds gateway auth:
+
+```sh
+skillcheck sweep            # resumes: only scenarios without results
+skillcheck summarize        # writes .skillcheck/scorecards/<UTC-date>.json
+```
+
+commit `.skillcheck/scorecards/`. gitignore the rest:
+
+```gitignore
+.skillcheck/results/
+.skillcheck/scratch/
+```
+
+a scorecard is only comparable against the tree it graded, which is why every
+result carries the root repo's HEAD and `summarize` refuses to mix revisions
+without `--allow-mixed`.
+
+## upgrading
+
+bump the version in `package.json` and rerun the sweep. results carry the
+`tool_version` that produced them, so a scorecard says which harness build it
+came from as well as which skills tree.
+
+## the older install path
+
+before the package was published, consumers installed it from a git tag:
+
+```sh
+npm i -D github:uinaf/skillcheck#v0.1.3
+```
+
+those tags are frozen and still work: they carry a committed `dist/`, and npm
+12 consumers needed `allow-git=root` in `.npmrc` to accept the spec at all. the
+registry install needs none of that. tags from `v0.1.4` on are npm releases and
+carry no `dist/`, so a git spec pointing at one will not run.

package/docs/releasing.md

@@ -0,0 +1,80 @@
+# releasing
+
+## pipeline
+
+a push to `main` runs one workflow, `.github/workflows/release.yml`:
+
+```text
+verify ──┐
+         ├──> release   npm publish, OIDC + uinaf-releaser  (release environment)
+secrets ─┘
+```
+
+`verify` and `secrets` are the shared gate, called from `verify.yml` and
+`secrets.yml`, so one definition serves pull requests, the merge queue, and this
+push. keep it that way: a second copy of the gate on a push-to-`main` workflow
+races this one over the same commit.
+
+the file name `release.yml` is load-bearing. see below.
+
+## npm
+
+`@uinaf/skillcheck` publishes from `.github/workflows/release.yml` via npm
+Trusted Publishing (OIDC) and the `uinaf-releaser` GitHub App. there is no npm
+token in this repository, in its environments, or in the organization.
+
+required on the `release` GitHub Environment:
+
+| name                            | kind   | purpose                                     |
+| ------------------------------- | ------ | ------------------------------------------- |
+| `UINAF_RELEASE_APP_CLIENT_ID`   | var    | GitHub App client id for the releaser bot   |
+| `UINAF_RELEASE_APP_PRIVATE_KEY` | secret | GitHub App private key for the releaser bot |
+
+the trusted publisher on npmjs.com is registered by **file path**, so
+`.github/workflows/release.yml` cannot be renamed or moved without editing that
+registration first. a rename fails the publish with an identity mismatch, and
+nothing earlier in the run reports it. the `release` environment name is bound
+the same way.
+
+deleting the `release` environment deletes both rows above with it, and there is
+no repo-level fallback: `create-github-app-token` then runs with empty inputs
+and the job fails at that step. the private key cannot be read back from
+GitHub; recreating it means generating a new one in the App settings.
+
+## version history
+
+semantic-release owns the version and the tag. `tagFormat` is `v${version}` and
+history continues from `v0.1.3`; `v0.1.0`–`v0.1.3` are the legacy git-install
+tags and are never deleted or moved.
+
+during preparation, `@semantic-release/npm` stages the released `package.json`
+version and `@jno21/semantic-release-github-commit` commits it to `main` through
+GitHub's API as the authenticated App. GitHub signs that commit, and the release
+tag points to it. the `[skip ci]` marker on that commit is what stops a release
+from releasing itself.
+
+check what the next version would be without publishing anything:
+
+```sh
+pnpm dlx semantic-release --dry-run --no-ci
+```
+
+## the artifact
+
+`dist/` is generated and untracked. `prepublishOnly` runs `pnpm run verify`,
+which builds it, so the tarball is always packed from a tree that just passed
+the gate. `files` is `dist`, `docs`, `README.md`, `LICENSE`.
+
+manual publish is emergency recovery only:
+
+```sh
+pnpm run verify
+npm publish --access public
+```
+
+## the old install path
+
+before `@uinaf/skillcheck` existed, consumers installed
+`github:uinaf/skillcheck#v0.1.3`. those tags still resolve and still carry a
+committed `dist/`, so anything pinned to them keeps working untouched. new
+consumers use npm.

package/docs/scenarios.md

@@ -0,0 +1,86 @@
+# writing scenarios
+
+a scenario is two files in a frozen location:
+
+```text
+<root>/skills/<skill>/evals/<scenario>/task.md
+<root>/skills/<skill>/evals/<scenario>/criteria.json
+```
+
+the path is the identity: `<skill>--<scenario>` names the run, the result file,
+and the scorecard entry. on the codex harness the name gains a `--codex` suffix,
+so both harnesses can hold results side by side. a directory missing either file
+is not discovered.
+
+## task.md
+
+the prompt handed to the agent, verbatim, with one piece of syntax. input files
+are embedded inline and materialized into the workdir before the run:
+
+```md
+Fix the failing check in the config below.
+
+======= FILE: config.json =======
+{ "retries": -1 }
+======= END FILE =======
+```
+
+each block is replaced in the prompt with a pointer ("Input file `config.json`
+is available in your working directory.") and written to disk. destinations
+must stay under the workdir, must not collide, and must not target `.claude/` or
+`.agents/`, since a fixture that writes agent config would be configuring its
+own examiner.
+
+write the task the way a user would write it. do not name the skill, describe
+its steps, or hint at the checklist: routing is part of what is being measured.
+
+## criteria.json
+
+```json
+{
+  "type": "weighted_checklist",
+  "context": "one line describing what a good answer looks like",
+  "checklist": [
+    { "name": "short-handle", "description": "what the judge should look for", "max_score": 3 }
+  ]
+}
+```
+
+`type` must be `weighted_checklist` and the checklist must be non-empty. every
+item needs a non-empty `name` and `description` and a positive `max_score`.
+
+each item becomes one `llm-rubric` assertion weighted by `max_score`, inside an
+assert-set with threshold 0.7. a separate `skill-used` assertion sits outside
+that aggregate, so a run that produces good output without ever loading the
+skill still fails. there is no test-level threshold: both must pass.
+
+write descriptions a judge can check against the deliverable: an observable
+property, not a feeling. weight the items that would make a reviewer reject the
+work.
+
+## what the judge sees
+
+the agent's final message, plus every file in the workdir that differs from the
+pre-run manifest. unchanged inputs are omitted; deleted inputs, unreadable
+files, and non-regular files are named rather than read.
+
+sections are sorted by path, each file is capped at 4,000 characters and the
+appended total at 24,000, with truncation stated inline. very large outputs make
+rubric judges return nothing at all, which is why the caps exist. keep fixtures
+small enough that the deliverable fits.
+
+## hidden skills
+
+a skill with `disable-model-invocation: true` is explicit-invoke-only in
+production, which the agent SDK cannot simulate. so the eval copy, never the shipped one,
+has the flag stripped, and the task gains a leading
+`Use the <skill> skill for this task.` the eval then measures
+behavior-when-invoked rather than routing. the flag is only honored inside the
+frontmatter block; body text mentioning the key does not count.
+
+## the workdir
+
+per run, under `<root>/.skillcheck/scratch/<name>/`, rebuilt from scratch each
+time. the skill under test is installed at `.claude/skills/<skill>/` (and also
+`.agents/skills/<skill>/` on the codex harness) with its `evals/` directory
+excluded, so criteria never leak into the agent's context.

package/docs/usage.md

@@ -0,0 +1,125 @@
+# usage
+
+every subcommand resolves one root, `--root <dir>` or the current directory.
+`lint` also takes the root as a positional, because that is the shape CI reaches
+for first.
+
+## lint
+
+```sh
+skillcheck lint            # lints the current repo
+skillcheck lint ../other   # lints another root
+```
+
+checks each `<root>/skills/<skill>/`:
+
+- frontmatter opens with `---` on line 1 and closes
+- keys are `name`, `description`, `disable-model-invocation` and nothing else,
+  each at most once
+- `name` equals the directory name; `description` is non-empty
+- `disable-model-invocation`, when present, is the bare YAML boolean `true`.
+  a quoted `"true"` is an error
+- relative links in the body resolve on disk
+
+code spans and fenced blocks are stripped before links are checked, so example
+links never fail. external schemes and `#anchors` pass. dot-directories under
+`skills/` (`.claude-plugin`) are plugin metadata, not packages, and are skipped.
+
+findings print one per line, relative to the linted root, then a count. exit 0
+clean, 1 with findings.
+
+## run
+
+```sh
+skillcheck run skills/<skill>/evals/<scenario>
+skillcheck run <scenario-dir> --agent MODEL --judge MODEL --harness codex --max-turns 80
+```
+
+materializes the scenario into `<root>/.skillcheck/scratch/<name>/workdir`,
+installs the skill under test into that workdir, drives the agent, and grades
+the files it wrote. exit 0 pass, 1 graded fail, 2 error (promptfoo produced no
+usable result).
+
+a test that errored was never graded, so it exits 2, prints the provider's
+message, and writes no provenance sidecar. it is never reported as
+`FAIL score=0.0000`; only a real judged verdict can fail a run.
+
+defaults: `--harness claude`, agent `claude-opus-5`, judge `claude-opus-5`,
+`--max-turns 50`. on the codex harness, omitting `--agent` leaves the model to
+the Codex CLI's own default.
+
+## sweep
+
+```sh
+skillcheck sweep           # only scenarios without results
+skillcheck sweep --all     # rerun everything
+```
+
+walks `<root>/skills/*/evals/*` and `<root>/cli/*/skills/*/evals/*`, in sorted
+order, sequentially. a scenario needs both `task.md` and `criteria.json` to be
+discovered. exit 2 if anything errored, 1 if anything failed, else 0.
+
+`EVALS_CONCURRENCY` is passed to promptfoo as `-j` (default 4). it parallelizes
+within one scenario, not across them.
+
+one known failure mode: judge calls through a gateway can drop at the transport
+layer ([uinaf/agent-platform#28](https://github.com/uinaf/agent-platform/issues/28)).
+that surfaces as an ERROR with no usable result, not as a graded FAIL, and the
+mitigation is a rerun. `sweep` without `--all` resumes, so a rerun only picks up
+what is missing.
+
+## summarize
+
+```sh
+skillcheck summarize [--allow-mixed]
+```
+
+reduces `<root>/.skillcheck/results/*.json` into
+`<root>/.skillcheck/scorecards/<UTC-date>.json`: one entry per scenario with
+skill, scenario, harness, tree sha, score, pass, both models, latency, tokens.
+
+if a scorecard for today already exists, the two are merged on
+`(skill, scenario, harness)`: entries from this run win, entries it did not
+touch survive, and the merge is reported on stdout. summarizing after rerunning
+six of twenty-nine scenarios therefore leaves twenty-nine rows in the file, not
+six. a same-date file that cannot be parsed stops the write instead of being
+overwritten.
+
+files that are not promptfoo results are skipped with a warning rather than
+failing the reduction.
+
+## provenance
+
+each successful run writes a `<name>.meta.json` sidecar next to its result:
+
+```json
+{
+  "skills_tree_sha": "<root repo HEAD at run time>",
+  "harness": "claude",
+  "ran_at": "<ISO timestamp>",
+  "tool_version": "<skillcheck version>"
+}
+```
+
+`summarize` reads those sidecars and refuses to mix skills-tree revisions in one
+scorecard unless `--allow-mixed`, in which case the top-level `skills_tree_sha`
+becomes `mixed` and per-entry shas remain. a result with no sidecar reduces as
+`unattested`.
+
+## state
+
+`<root>/.skillcheck/` holds `scratch/` and `results/`, both disposable and safe
+to gitignore, and `scorecards/`, which is meant to be committed. nothing is ever
+written inside the installed package.
+
+## auth
+
+| variable                                      | effect                                                            |
+| --------------------------------------------- | ----------------------------------------------------------------- |
+| `ANTHROPIC_BASE_URL` + `ANTHROPIC_AUTH_TOKEN` | claude agent and judge go through a gateway                       |
+| none of the above                             | falls back to the local Claude Code session                       |
+| `ANTHROPIC_API_KEY`                           | judge grades over `anthropic:messages:<model>` instead of the SDK |
+| `CODEX_HOME` (default `~/.codex`)             | where the codex harness finds the local `codex` CLI login         |
+| `OPENAI_API_KEY`                              | codex agent auth when there is no local login                     |
+
+the judge stays on the Anthropic selection regardless of the agent harness.

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@uinaf/skillcheck",
+  "version": "0.1.3",
+  "description": "Lint and eval harness for agent skills",
+  "homepage": "https://github.com/uinaf/skillcheck#readme",
+  "bugs": {
+    "url": "https://github.com/uinaf/skillcheck/issues"
+  },
+  "license": "MIT",
+  "author": "undefined is not a function LLC",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/uinaf/skillcheck.git"
+  },
+  "bin": {
+    "skillcheck": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "docs",
+    "README.md",
+    "LICENSE"
+  ],
+  "type": "module",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "verify": "vp check && vp pack && vp test run",
+    "prepare": "vp config --no-agent",
+    "prepublishOnly": "pnpm run verify"
+  },
+  "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.3.233",
+    "@openai/codex-sdk": "^0.147.0",
+    "promptfoo": "^0.122.0"
+  },
+  "devDependencies": {
+    "@types/node": "^26.2.0",
+    "vite": "catalog:",
+    "vite-plus": "catalog:"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "packageManager": "pnpm@11.22.0"
+}