skilldrop-cli 0.8.4 → 0.9.1

package/README.md

@@ -14,6 +14,8 @@ npx skilldrop-cli list                               #     sre-oncall, stakehold
 
 Originally scoped to solution architects, now broadly useful to PMs, founders, consultants, engineering leaders, exec assistants — anyone who turns ideas into stakeholder-ready artifacts.
 
+Every skill is a plain `SKILL.md` folder — the [**Agent Skills open standard**](https://agentskills.io) Anthropic ratified — so the same folder runs unchanged in Claude.ai, Claude Code, the Claude Agent SDK, Cursor, Kiro, Codex, Copilot, Antigravity, and anything else that reads the format. Portable by construction: no runtime, no platform, no lock-in.
+
 **Why skilldrop over heavier agent platforms:** every skill is a plain folder (`SKILL.md` + `manifest.json` + supporting files) and installs by *copy, never transformation* — what runs in your IDE is byte-identical to what's reviewed in this repo. The flat layout doubles as an open catalog contract: [any repo shaped like this one](#third-party-catalogs--publish-your-own-skills-through-the-same-cli) is installable through the same CLI. Skills are *opinionated* — each ships a quality bar, anti-patterns, and acceptance evals, so the output is an artifact, not a vibe.
 
 ## How skilldrop works
@@ -259,8 +261,10 @@ npx skilldrop-cli install --pack sre-oncall --ide kiro  # .kiro/skills — Kiro
 npx skilldrop-cli install adr-generator --dest .agents/skills   # Codex + Copilot CLI (see below)
 npx skilldrop-cli agents                                # the reviewer subagents
 npx skilldrop-cli install --agent devils-advocate       # -> ~/.claude/agents/ (RFC-0012)
+npx skilldrop-cli install --panel review                # the whole review fleet: 3 subagents + the pre-merge-review orchestrator (RFC-0020)
 npx skilldrop-cli outdated && npx skilldrop-cli update  # skills improve; cp -R never tells you
 npx skilldrop-cli list | skilldrop info <skill> | skilldrop packs | skilldrop uninstall <skill>
+npx skilldrop-cli list --json                            # machine-readable: list/info/packs/agents/outdated (RFC-0021)
 ```
 
 `--with-related` also pulls each skill's companions. From a clone (or before the package is published): `node bin/skilldrop.js <same args>`. Scope and design: [RFC-0002](docs/rfcs/0002-skilldrop-cli.md), full command surface in [`docs/designs/skilldrop-cli-design.md`](docs/designs/skilldrop-cli-design.md).

package/agents/README.md

@@ -26,6 +26,28 @@ npx skilldrop-cli install --agent devils-advocate --ide kiro   # .kiro/agents/*.
 
 They are deliberately **split, not merged.** A single "review my code" agent dilutes all three — bug-hunting, craft, and exploitability pull in different directions. Run them as separate passes; together they are the reviewer panel [`feature-implement-loop`](../skills/feature-implement-loop/SKILL.md) drives after each generation round. `devils-advocate` here is the subagent form of the [`devils-advocate` skill](../skills/devils-advocate/SKILL.md); same persona, packaged for a tool's native agent slot instead of on-demand skill invocation.
 
+## Fire them as a panel
+
+The three reviewers are meant to run **together** on a change. Install the whole fleet in one command:
+
+```bash
+npx skilldrop-cli install --panel review            # 3 subagents + the pre-merge-review orchestrator -> ~/.claude/
+npx skilldrop-cli install --panel review --project  # .claude/ (shared with the repo)
+```
+
+The [`pre-merge-review`](../skills/pre-merge-review/SKILL.md) skill is the **portable orchestrator** — it dispatches the three as **parallel subagents** where the tool has a native subagent runner, and sweeps the lenses inline otherwise. The orchestration lives in the *skill* (portable); the reviewers are *native subagents* (per-tool):
+
+| Tool | How the panel fires in parallel |
+|---|---|
+| **Claude Code** | Native parallel subagents — `pre-merge-review` fires all three at once. `--panel review` installs both halves. |
+| **Kiro** | Native subagents — `--panel review --ide kiro` installs both halves. |
+| **Codex** | Multi-agent runner — install the agents (`--agent … --ide codex`) + the skill; Codex runs the fleet in parallel (confirm the invocation against your Codex version). |
+| **Antigravity** | Lead → specialist delegation — install the agents (`--agent … --ide antigravity`) + the skill; the lead agent delegates to the three, each in its own context. |
+| **Copilot** | Agents install (`--agent … --ide copilot`); the skill drives them — sequentially unless your Copilot build exposes parallel subagents. |
+| **Cursor** | No agent format — `pre-merge-review` sweeps the three lenses inline (no subagents). |
+
+Designing your own fleet? Use [`subagent-design`](../skills/subagent-design/SKILL.md) — the reviewer panel is its "judge panel" topology.
+
 ## Installing an agent into your tool
 
 ### Claude Code (native subagents)

package/bin/skilldrop.js

@@ -20,6 +20,16 @@ const BUNDLED = "bundled";
 // Neutral hook vocabulary (RFC-0006). Kept in sync with validate.py's HOOK_EVENTS.
 const HOOK_EVENTS = ["session-start", "pre-commit-review", "on-demand"];
 
+// Panels (RFC-0020): a named bundle of reviewer subagents + the orchestrator skill that fires
+// them in parallel. `install --panel <name>` installs the whole fleet in one command.
+const PANELS = {
+  review: {
+    agents: ["devils-advocate", "security-reviewer", "code-quality"],
+    skill: "pre-merge-review",
+    blurb: "correctness + security + craft reviewers, fired in parallel by pre-merge-review",
+  },
+};
+
 const HELP = `skilldrop — portable AI-agent skills for Claude Code, Cursor, Kiro, and more
 
 Usage:
@@ -31,11 +41,16 @@ Usage:
   skilldrop install --pack <name>         install a whole pack
   skilldrop install --all                 install every skill in the catalog
   skilldrop install --agent <name...>     install reviewer subagents (RFC-0012)
+  skilldrop install --panel review        install the review panel — the 3 reviewer subagents +
+                                          the pre-merge-review orchestrator that fires them (RFC-0020)
   skilldrop update                        re-copy installed skills whose version changed
   skilldrop outdated                      show installed vs current versions, change nothing
   skilldrop uninstall <skill...>          remove skills (and wiring files this tool wrote)
   skilldrop uninstall --agent <name...>   remove subagents
   skilldrop validate [--from <src>]       structural check of a catalog (for catalog authors)
+  skilldrop scan [<skill...>] [--from <src>]  supply-chain scan — flag network/exec/credential
+                                          patterns in scripts and injection-shaped instructions
+                                          in SKILL.md before you trust a catalog (RFC-0022)
 
 Catalogs:
   (default)          the catalog bundled with this package
@@ -60,6 +75,8 @@ Options:
                        --ide antigravity  ~/.gemini/config/agents  markdown, subagent: true
                        --dest <dir>   any directory         copied as-is
                      Cursor has no agent format — use a custom mode (agents/README.md).
+  --json             machine-readable output for list | info | packs | agents | outdated —
+                     one JSON object on stdout, nothing else (for agents, scripts, CI)
   --with-related     also install each skill's related companions (one level)
   --with-hooks       also wire any hooks a skill declares (RFC-0006) — git pre-commit
                      reminders and Claude Code session-start context; degrades where the
@@ -70,11 +87,16 @@ Options:
 function die(msg) { console.error("error: " + msg); process.exit(1); }
 function readJSON(p) { return JSON.parse(fs.readFileSync(p, "utf8")); }
 
+/* --json (RFC-0021): the read commands emit one machine-readable object on stdout and nothing
+   else, so an agent or script can consume them without scraping aligned columns. Human output is
+   unchanged by default — this is additive. Errors still go to stderr and exit non-zero. */
+function emitJSON(obj) { console.log(JSON.stringify(obj, null, 2)); }
+
 function parseArgs(argv) {
   const out = { _: [], flags: {} };
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
-    if (a === "--pack" || a === "--ide" || a === "--dest" || a === "--from") out.flags[a.slice(2)] = argv[++i];
+    if (a === "--pack" || a === "--ide" || a === "--dest" || a === "--from" || a === "--panel") out.flags[a.slice(2)] = argv[++i];
     else if (a.startsWith("--")) out.flags[a.slice(2)] = true;
     else out._.push(a);
   }
@@ -264,6 +286,117 @@ function gate(cat, names) {
   if (bad) die(`${bad} skill(s) failed the structural check — nothing was installed`);
 }
 
+/* ---------- supply-chain scan (RFC-0022) ----------
+   A skill is instruction prose an agent will obey, and its scripts are code that runs on the
+   user's machine — so installing a third-party catalog is a supply-chain event. Anthropic's own
+   Skills guidance says to audit a skill's files for "unexpected network calls, file access
+   patterns, or operations that don't match the Skill's stated purpose"; this automates that first
+   pass. It is a HEURISTIC that reports — it never blocks and never replaces reading the skill.
+
+   Two rule sets, deliberately different:
+   - SCRIPT_RULES run over executable files (real code): network, exec, credential, obfuscation.
+   - PROSE_RULES run over SKILL.md and only match *instructions to misbehave* — not security
+     vocabulary, so a skill that legitimately discusses injection (threat-model) isn't flagged. */
+
+const SCRIPT_EXT = new Set([".py", ".js", ".mjs", ".cjs", ".sh", ".bash", ".zsh", ".rb", ".pl", ".ps1"]);
+
+const SCRIPT_RULES = [
+  { id: "exec-remote", sev: "🟥", why: "downloads and executes remote content — the classic supply-chain payload",
+    re: /(curl|wget)[^\n|]*\|\s*(sudo\s+)?(ba|z|)sh|eval\s*\(\s*(requests|urllib|fetch)|base64\s+(-d|--decode)[^\n|]*\|\s*(ba|z|)sh/i },
+  { id: "shell-exec", sev: "🟧", why: "executes shell commands",
+    re: /\b(os\.system|subprocess\.(run|call|Popen|check_output)|child_process|execSync|spawnSync|shell_exec|`[^`\n]*\$\()/ },
+  { id: "network", sev: "🟧", why: "makes outbound network calls",
+    re: /\b(requests\.(get|post|put)|urllib\.request|httpx\.|axios\.|node-fetch|\bfetch\s*\(\s*["'`]https?:|curl\s+https?:|wget\s+https?:)/i },
+  { id: "credentials", sev: "🟧", why: "reads credentials or secret material",
+    re: /\b(os\.environ|process\.env)\b[^\n]{0,40}(TOKEN|KEY|SECRET|PASSWORD|CREDENTIAL)|~\/\.(aws|ssh|npmrc|netrc)|\.env\b|id_rsa/i },
+  { id: "broad-fs", sev: "🟨", why: "writes outside the skill's own directory",
+    re: /\b(shutil\.rmtree|rm\s+-rf\s+[~/]|open\s*\(\s*["'`]\/(etc|usr|bin)|fs\.(unlink|rmSync)\s*\([^)]*\.\.\/)/ },
+];
+
+const PROSE_RULES = [
+  { id: "instruction-override", sev: "🟥", why: "tells the agent to ignore its prior instructions",
+    re: /ignore\s+(all\s+)?(previous|prior|earlier|above|preceding)\s+(instructions|prompts|rules)/i },
+  { id: "conceal-from-user", sev: "🟥", why: "tells the agent to hide actions from the user",
+    re: /(do\s*n[o']?t|never|without)\s+(tell|telling|inform|informing|notify|notifying|mention|mentioning)\s+(the\s+)?(user|human)/i },
+  { id: "memory-overwrite", sev: "🟥", why: "instructs the agent to rewrite its own persistent memory/identity",
+    re: /(update|overwrite|append\s+to|modify)\s+your\s+(own\s+)?(SOUL|MEMORY|CLAUDE|AGENTS)\.md/i },
+  { id: "prose-exfil", sev: "🟧", why: "instructs the agent to send data to an external endpoint",
+    re: /\b(POST|send|upload|transmit)\b[^\n.]{0,60}\bto\s+https?:\/\//i },
+];
+
+function walkFiles(dir, out = []) {
+  for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+    const p = path.join(dir, e.name);
+    if (e.isDirectory()) walkFiles(p, out);
+    else out.push(p);
+  }
+  return out;
+}
+
+/* Scan one skill. Returns [{sev, id, why, file, line, text}] — worst first. */
+function scanSkill(cat, s) {
+  const dir = skillDir(cat, s);
+  const findings = [];
+  if (!dir || !fs.existsSync(dir)) return findings;
+  for (const file of walkFiles(dir)) {
+    const rel = path.relative(dir, file);
+    const ext = path.extname(file).toLowerCase();
+    const isScript = SCRIPT_EXT.has(ext);
+    const isProse = path.basename(file) === "SKILL.md";
+    if (!isScript && !isProse) continue;
+    let body = "";
+    try { body = fs.readFileSync(file, "utf8"); } catch (e) { continue; }
+    const rules = isScript ? SCRIPT_RULES : PROSE_RULES;
+    body.split(/\r?\n/).forEach((line, i) => {
+      if (line.length > 400) return; // minified/data line — not reviewable prose or code
+      for (const r of rules) {
+        if (r.re.test(line))
+          findings.push({ sev: r.sev, id: r.id, why: r.why, file: rel, line: i + 1, text: line.trim().slice(0, 120) });
+      }
+    });
+  }
+  const order = { "🟥": 0, "🟧": 1, "🟨": 2, "⚪": 3 };
+  return findings.sort((a, b) => order[a.sev] - order[b.sev]);
+}
+
+function printScan(cat, names, { compact = false } = {}) {
+  let total = 0, worst = null;
+  for (const s of names) {
+    const f = scanSkill(cat, s);
+    if (!f.length) continue;
+    total += f.length;
+    if (!worst || f[0].sev === "🟥") worst = worst === "🟥" ? worst : f[0].sev;
+    console.log(`\n${s}`);
+    for (const x of (compact ? f.slice(0, 3) : f))
+      console.log(`  ${x.sev} ${x.id} — ${x.why}\n     ${x.file}:${x.line}  ${x.text}`);
+    if (compact && f.length > 3) console.log(`     … ${f.length - 3} more (skilldrop scan ${s} --from ${cat.source})`);
+  }
+  return { total, worst };
+}
+
+function scan(args) {
+  const cat = resolveCatalog(args.flags.from);
+  const names = args._.length ? args._.slice() : skillsIn(cat);
+  for (const s of names) if (!skillExists(cat, s)) die(`unknown skill '${s}' in catalog '${cat.source}'`);
+
+  if (args.flags.json) {
+    const out = names.map((s) => ({ skill: s, findings: scanSkill(cat, s) })).filter((r) => r.findings.length);
+    return emitJSON({
+      catalog: cat.source, scanned: names.length,
+      flagged: out.length, findingCount: out.reduce((n, r) => n + r.findings.length, 0), skills: out,
+    });
+  }
+  console.log(`Scanning ${names.length} skill(s) in catalog '${cat.source}' for supply-chain patterns…`);
+  const { total } = printScan(cat, names);
+  if (!total) {
+    console.log("\nNo flagged patterns found.");
+  } else {
+    console.log(`\n${total} flagged pattern(s). These are HEURISTICS, not verdicts — a match can be` +
+                ` entirely legitimate (a skill that is *about* security, or a script that genuinely needs the network).`);
+    console.log("Read the cited lines before installing. Nothing here is executed by skilldrop; installs copy files only.");
+  }
+}
+
 /* ---------- install targets & ledger ---------- */
 
 function target(flags) {
@@ -567,7 +700,33 @@ function copyOne(cat, s, dest, ide, l, notes) {
   return m;
 }
 
+/* Install a whole review panel — the reviewer subagents + the orchestrator skill — in one
+   command (RFC-0020). Needs a target with BOTH a subagent and a skill format, so it accepts
+   the default (Claude Code), --project, --ide kiro, or --dest; other IDEs install the halves
+   separately. Delegates to installAgents + install so every existing safety/craft gate applies. */
+function installPanel(args) {
+  const name = args.flags.panel;
+  const p = PANELS[name];
+  if (!p) die(`unknown panel '${name}' — available: ${Object.keys(PANELS).join(", ")}`);
+  const ide = args.flags.ide;
+  if (ide && ide !== "kiro" && !args.flags.dest)
+    die(`--panel installs subagents + the orchestrator skill together, so it needs a target with both formats:\n` +
+        `       (default | --project) Claude Code, --ide kiro, or --dest <dir>.\n` +
+        `       For ${ide}: install the agents (skilldrop install --agent ${p.agents.join(" ")} --ide ${ide}) ` +
+        `and the skill (skilldrop install ${p.skill} --ide ${ide}) separately.`);
+  const flags = Object.assign({}, args.flags);
+  delete flags.panel;
+  console.log(`Installing the '${name}' panel — ${p.agents.length} reviewer subagents + the ${p.skill} orchestrator skill.\n`);
+  installAgents({ _: p.agents.slice(), flags: Object.assign({}, flags, { agent: true }) });
+  console.log("");
+  install({ _: [p.skill], flags });
+  console.log(`\nPanel installed. Fire it with the ${p.skill} skill — e.g. "run a pre-merge review on this change".`);
+  console.log(`It dispatches the three subagents in parallel where your tool has native subagents (Claude Code today;`);
+  console.log(`Codex / Antigravity multi-agent runners), and sweeps the lenses inline otherwise. Per-tool: agents/README.md.`);
+}
+
 function install(args) {
+  if (args.flags.panel) return installPanel(args);
   if (args.flags.agent) return installAgents(args);
   const cat = resolveCatalog(args.flags.from);
   let names = expandNames(args, cat);
@@ -605,8 +764,15 @@ function install(args) {
     console.log(`\n${withHooks.join(", ")} declare hooks — re-run with --with-hooks to wire them (git pre-commit reminders / session-start context).`);
   }
 
-  if (cat.source !== BUNDLED)
+  if (cat.source !== BUNDLED) {
     console.log(`\nWARNING: third-party catalog '${cat.source}'. Skills are instructions your AI agent will follow — review each installed SKILL.md under ${dest} before first use. Install copied files only; nothing was executed.`);
+    // Supply-chain scan (RFC-0022): surface risky patterns at the moment of trust. Reports only —
+    // the files are already copied, and a match is a prompt to read, not a verdict.
+    const { total } = printScan(cat, names, { compact: true });
+    console.log(total
+      ? `\n${total} pattern(s) worth reading before you trust these skills. Full detail: skilldrop scan --from ${cat.source}`
+      : "\nSupply-chain scan: no flagged patterns.");
+  }
   if (ide === "generic")
     console.log("wiring: attach each skill's SKILL.md to your agent (Continue/Cline: @file, Aider: /add, Codex: reference it from AGENTS.md) — see the repo README's per-IDE steps.");
   for (const s of pipDeps)
@@ -649,8 +815,18 @@ function update(args) {
 
 function outdated(args) {
   const { dest, rows } = installedRows(args.flags);
-  if (!rows.length) return console.log(`nothing installed at ${dest}`);
   const stale = rows.filter((r) => r.current && r.current !== r.installed);
+  if (args.flags.json)
+    return emitJSON({
+      dest,
+      count: rows.length,
+      outdatedCount: stale.length,
+      skills: rows.map((r) => ({
+        name: r.s, installed: r.installed, current: r.current,
+        source: r.src, outdated: !!(r.current && r.current !== r.installed),
+      })),
+    });
+  if (!rows.length) return console.log(`nothing installed at ${dest}`);
   for (const r of stale) console.log(`${r.s}: installed ${r.installed}, current ${r.current} (${r.src})`);
   console.log(stale.length ? `\n${stale.length} outdated — run: skilldrop update` : "everything up to date.");
 }
@@ -674,6 +850,15 @@ function uninstall(args) {
 function listAgents(args) {
   const cat = resolveCatalog(args.flags.from);
   const names = agentsIn(cat);
+  if (args.flags.json)
+    return emitJSON({
+      catalog: cat.source,
+      count: names.length,
+      agents: names.map((a) => {
+        const m = agentMeta(cat, a);
+        return { name: a, description: m.description || null, tools: m.tools || null, model: m.model || null };
+      }),
+    });
   if (!names.length) return console.log(`catalog '${cat.source}' ships no agents.`);
   const w = Math.max(...names.map((n) => n.length));
   for (const a of names) {
@@ -741,6 +926,12 @@ function list(args) {
     try { const m = manifestOf(cat, s); return [s, m.version || "?", (m.model && m.model.tier) || "?"]; }
     catch (e) { return [s, "?", "?"]; }
   });
+  if (args.flags.json)
+    return emitJSON({
+      catalog: cat.source,
+      count: rows.length,
+      skills: rows.map(([name, version, tier]) => ({ name, version, tier })),
+    });
   const w = Math.max(...rows.map((r) => r[0].length));
   for (const [s, v, t] of rows) console.log(`${s.padEnd(w)}  ${v}  ${t}`);
   console.log(`\n${rows.length} skills in catalog '${cat.source}'. Details: skilldrop info <skill>`);
@@ -753,6 +944,21 @@ function info(args) {
   const m = manifestOf(cat, s);
   const ps = packsOf(cat) || {};
   const inPacks = Object.entries(ps).filter(([, p]) => p.skills.includes(s)).map(([n]) => n);
+  const needsPip = ((m.deps || {}).pip || []).length > 0 || fs.existsSync(path.join(skillDir(cat, s), "requirements.txt"));
+  if (args.flags.json)
+    return emitJSON({
+      catalog: cat.source,
+      name: m.name,
+      version: m.version || null,
+      description: m.description || null,
+      tier: (m.model && m.model.tier) || null,
+      packs: inPacks,
+      related: m.related || [],
+      tags: m.tags || [],
+      deps: { pip: (m.deps || {}).pip || [], npm: (m.deps || {}).npm || [], requirementsTxt: needsPip },
+      env: { required: (m.env || {}).required || [], optional: (m.env || {}).optional || [] },
+      hooks: m.hooks || [],
+    });
   console.log(`${m.name}@${m.version}  (tier: ${(m.model && m.model.tier) || "n/a"})\n\n${m.description}\n`);
   console.log(`catalog: ${cat.source}`);
   console.log(`packs:   ${inPacks.join(", ") || "-"}`);
@@ -765,6 +971,14 @@ function info(args) {
 function listPacks(args) {
   const cat = resolveCatalog(args.flags.from);
   const ps = packsOf(cat);
+  if (args.flags.json)
+    return emitJSON({
+      catalog: cat.source,
+      count: ps ? Object.keys(ps).length : 0,
+      packs: Object.entries(ps || {}).map(([name, p]) => ({
+        name, description: p.description || null, skills: p.skills || [],
+      })),
+    });
   if (!ps) return console.log(`catalog '${cat.source}' defines no packs.`);
   const w = Math.max(...Object.keys(ps).map((n) => n.length));
   for (const [n, p] of Object.entries(ps))
@@ -792,7 +1006,7 @@ function validateCmd(args) {
 
 const args = parseArgs(process.argv.slice(2));
 const cmd = args._.shift();
-const commands = { list, info, packs: listPacks, agents: listAgents, install, update, outdated, uninstall, validate: validateCmd };
+const commands = { list, info, packs: listPacks, agents: listAgents, install, update, outdated, uninstall, validate: validateCmd, scan };
 if (!cmd || cmd === "help" || args.flags.help) console.log(HELP);
 else if (commands[cmd]) commands[cmd](args);
 else die(`unknown command '${cmd}' — run: skilldrop help`);

package/model-routing.json

@@ -21,8 +21,8 @@
       "label": "Claude Code (Anthropic)",
       "models": {
         "light": "claude-haiku-4-5-20251001",
-        "standard": "claude-sonnet-4-6",
-        "heavy": "claude-opus-4-8"
+        "standard": "claude-sonnet-5",
+        "heavy": "claude-opus-5"
       },
       "select_via": "`/model <model-id>` in the session, or hand the skill to the model-router agent for automatic dispatch.",
       "automation": ".claude/agents/model-router.md"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skilldrop-cli",
-  "version": "0.8.4",
+  "version": "0.9.1",
   "description": "Portable AI-agent skills for the deliverables knowledge workers ship \u2014 diagrams, ADRs, PRDs, runbooks, decks, reviews \u2014 installable into Claude Code, Cursor, Kiro, and any IDE that takes custom instructions. One command per skill or per role-based pack.",
   "author": {
     "name": "Sanjay Ananthanarayan",

package/skills/adr-generator/evals/eval_queries.json

@@ -0,0 +1,34 @@
+[
+  {
+    "query": "Write an ADR for this decision",
+    "should_trigger": true
+  },
+  {
+    "query": "Document the 'we decided X because Y' moment as an architecture decision record",
+    "should_trigger": true
+  },
+  {
+    "query": "Capture this architectural decision in MADR format",
+    "should_trigger": true
+  },
+  {
+    "query": "We picked Postgres over Dynamo — record the decision properly",
+    "should_trigger": true
+  },
+  {
+    "query": "Extract the decisions and owners from these meeting notes",
+    "should_trigger": false
+  },
+  {
+    "query": "Write a full engineering design doc for this feature",
+    "should_trigger": false
+  },
+  {
+    "query": "Critique the ADR I already wrote",
+    "should_trigger": false
+  },
+  {
+    "query": "Convene a council to decide which database we should use",
+    "should_trigger": false
+  }
+]

package/skills/adr-generator/evals/evals.json

@@ -0,0 +1,17 @@
+{
+  "skill_name": "adr-generator",
+  "evals": [
+    {
+      "id": 1,
+      "prompt": "Write an ADR: we decided to use Postgres as our primary datastore instead of DynamoDB, because our access patterns are relational and the team already operates Postgres.",
+      "assertions": [
+        "Status is one of Proposed / Accepted / Deprecated / Superseded by ADR-NNNN, defaulting to Proposed unless the user says it was agreed",
+        "Title is a noun phrase naming the decision, not a verb phrase naming the activity",
+        "Consequences include real trade-offs and downsides, not only upsides",
+        "The alternatives considered each carry a why-not, not just a description",
+        "The chosen format is MADR by default; Nygard only when explicitly requested",
+        "No invented context — facts not supplied by the user are marked rather than fabricated"
+      ]
+    }
+  ]
+}

package/skills/api-contract-draft/evals/eval_queries.json

@@ -0,0 +1,34 @@
+[
+  {
+    "query": "Draft the OpenAPI spec for this API",
+    "should_trigger": true
+  },
+  {
+    "query": "Write the REST contract for these endpoints",
+    "should_trigger": true
+  },
+  {
+    "query": "I need an API contract with a proper error catalog and pagination decided",
+    "should_trigger": true
+  },
+  {
+    "query": "Turn this user story into an OpenAPI 3.1 definition",
+    "should_trigger": true
+  },
+  {
+    "query": "Define the contract for this Kafka topic our team publishes",
+    "should_trigger": false
+  },
+  {
+    "query": "Design the Postgres schema and indexes for this feature",
+    "should_trigger": false
+  },
+  {
+    "query": "What latency and availability targets should this service have?",
+    "should_trigger": false
+  },
+  {
+    "query": "Review this API implementation for security bugs",
+    "should_trigger": false
+  }
+]

package/skills/api-contract-draft/evals/evals.json

@@ -0,0 +1,18 @@
+{
+  "skill_name": "api-contract-draft",
+  "evals": [
+    {
+      "id": 1,
+      "prompt": "Draft the OpenAPI contract for our orders API — clients need to create an order, fetch one, and list a customer's orders.",
+      "assertions": [
+        "The emitted YAML is parseable OpenAPI 3.1 and every $ref resolves",
+        "Paths are resource-oriented rather than RPC-style verbs in the URL",
+        "Every operation enumerates its 4xx set with stable machine-switchable code values — not a bare '400: Bad Request'",
+        "Errors follow RFC 9457 problem-details shape",
+        "Pagination, idempotency, and versioning are each decided explicitly rather than deferred",
+        "Every operation carries at least one example",
+        "Each decision in the log has a rationale, and any deviation from the skill's conventions is logged rather than made silently"
+      ]
+    }
+  ]
+}

package/skills/architecture-diagrams/evals/eval_queries.json

@@ -0,0 +1,34 @@
+[
+  {
+    "query": "Draw an architecture diagram for this system",
+    "should_trigger": true
+  },
+  {
+    "query": "Generate a Mermaid diagram of these services",
+    "should_trigger": true
+  },
+  {
+    "query": "Create a C4 container diagram from this description",
+    "should_trigger": true
+  },
+  {
+    "query": "Diagram the sequence flow I just described",
+    "should_trigger": true
+  },
+  {
+    "query": "Reverse-engineer the architecture from our Terraform and repo",
+    "should_trigger": false
+  },
+  {
+    "query": "Read the frames in our Figma file",
+    "should_trigger": false
+  },
+  {
+    "query": "Threat model this design",
+    "should_trigger": false
+  },
+  {
+    "query": "Write the design doc for this system",
+    "should_trigger": false
+  }
+]

package/skills/architecture-diagrams/evals/evals.json

@@ -0,0 +1,16 @@
+{
+  "skill_name": "architecture-diagrams",
+  "evals": [
+    {
+      "id": 1,
+      "prompt": "Draw the architecture for a checkout service: an API gateway, an orders service, a payments service calling Stripe, and a Postgres primary with a read replica.",
+      "assertions": [
+        "The diagram fits on one screen; beyond roughly 15 nodes it is split into separate Context and Container diagrams rather than crammed",
+        "Arrows show direction of data flow, not undirected connections",
+        "Every arrow crossing a trust boundary is labelled",
+        "The diagram is generated from the written description provided — no components are invented beyond it",
+        "A named format is produced (Mermaid, PlantUML, or C4) and renders as valid syntax"
+      ]
+    }
+  ]
+}

package/skills/audience-profile/evals/eval_queries.json

@@ -0,0 +1,34 @@
+[
+  {
+    "query": "Who is my audience and what rules should the deck follow?",
+    "should_trigger": true
+  },
+  {
+    "query": "What are the structural rules for presenting to a board versus engineers?",
+    "should_trigger": true
+  },
+  {
+    "query": "Profile this audience so I know how technical to go",
+    "should_trigger": true
+  },
+  {
+    "query": "We have a mixed exec and technical room — how should I pitch it?",
+    "should_trigger": true
+  },
+  {
+    "query": "Build the PowerPoint for the board meeting",
+    "should_trigger": false
+  },
+  {
+    "query": "Outline the slides for this deck",
+    "should_trigger": false
+  },
+  {
+    "query": "Write the one-page executive summary",
+    "should_trigger": false
+  },
+  {
+    "query": "Map the customer's journey through our product",
+    "should_trigger": false
+  }
+]

package/skills/audience-profile/evals/evals.json

@@ -0,0 +1,15 @@
+{
+  "skill_name": "audience-profile",
+  "evals": [
+    {
+      "id": 1,
+      "prompt": "We're presenting our platform strategy to a mixed room — the board plus two engineering leads. What audience rules should we design to?",
+      "assertions": [
+        "Output is concrete and structural (slide count ranges, density, tone, must-have sections, things to avoid) rather than advice like 'keep it short'",
+        "A mixed audience resolves to the least-technical archetype, with the more-technical material moved to an appendix",
+        "No new archetype is invented for a one-off case — the closest existing one is chosen and the divergence noted",
+        "The profile is reusable across deliverables rather than being a deck or summary itself"
+      ]
+    }
+  ]
+}

package/skills/brief-intake/evals/eval_queries.json

@@ -0,0 +1,34 @@
+[
+  {
+    "query": "Turn this Slack thread into a structured brief",
+    "should_trigger": true
+  },
+  {
+    "query": "I have a messy transcript — get it into shape for the design-doc skill",
+    "should_trigger": true
+  },
+  {
+    "query": "Structure this raw context into a brief before I run the next skill",
+    "should_trigger": true
+  },
+  {
+    "query": "Take this half-written Notion page and extract a clean brief",
+    "should_trigger": true
+  },
+  {
+    "query": "Extract the decisions, owners, and due dates from this discussion",
+    "should_trigger": false
+  },
+  {
+    "query": "Write the ADR itself from this context",
+    "should_trigger": false
+  },
+  {
+    "query": "Critique this brief's quality",
+    "should_trigger": false
+  },
+  {
+    "query": "Summarize this thread for the executive team",
+    "should_trigger": false
+  }
+]

package/skills/brief-intake/evals/evals.json

@@ -0,0 +1,16 @@
+{
+  "skill_name": "brief-intake",
+  "evals": [
+    {
+      "id": 1,
+      "prompt": "Here's a messy Slack thread about our caching problem — turn it into a brief I can hand to design-doc.",
+      "assertions": [
+        "Extracted fields marked [explicit] or [implied] carry a short verbatim snippet from the source so nothing is hallucinated",
+        "Relative dates are converted to absolute YYYY-MM-DD, marked implied where computed",
+        "Gaps are named as missing rather than filled in with plausible invention",
+        "The output names the downstream skill the brief is shaped for",
+        "The brief is structured into the fields that downstream skill needs, not a summary"
+      ]
+    }
+  ]
+}