skilldrop-cli 0.9.0 → 0.9.1

package/README.md

@@ -264,6 +264,7 @@ npx skilldrop-cli install --agent devils-advocate       # -> ~/.claude/agents/ (
 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/bin/skilldrop.js

@@ -48,6 +48,9 @@ Usage:
   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
@@ -72,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
@@ -82,6 +87,11 @@ 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++) {
@@ -276,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) {
@@ -643,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)
@@ -687,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.");
 }
@@ -712,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) {
@@ -779,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>`);
@@ -791,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(", ") || "-"}`);
@@ -803,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))
@@ -830,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skilldrop-cli",
-  "version": "0.9.0",
+  "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"
+      ]
+    }
+  ]
+}

package/skills/council-review/evals/eval_queries.json

@@ -0,0 +1,38 @@
+[
+  {
+    "query": "Convene the council on this architecture decision",
+    "should_trigger": true
+  },
+  {
+    "query": "I want multiple senior perspectives to deliberate this change",
+    "should_trigger": true
+  },
+  {
+    "query": "Get an architect, security, and SRE view on this before we commit",
+    "should_trigger": true
+  },
+  {
+    "query": "Run a pre-mortem style multi-perspective review of this RFC",
+    "should_trigger": true
+  },
+  {
+    "query": "This is risky and load-bearing — I need more than one reviewer's lens",
+    "should_trigger": true
+  },
+  {
+    "query": "Review this code for edge cases the first pass missed",
+    "should_trigger": false
+  },
+  {
+    "query": "Critique this document against its quality bar",
+    "should_trigger": false
+  },
+  {
+    "query": "Score Postgres vs DynamoDB on weighted criteria",
+    "should_trigger": false
+  },
+  {
+    "query": "Write the ADR recording the decision we already made",
+    "should_trigger": false
+  }
+]

package/skills/council-review/evals/evals.json

@@ -0,0 +1,18 @@
+{
+  "skill_name": "council-review",
+  "evals": [
+    {
+      "id": 1,
+      "prompt": "We're considering moving our monolith's checkout flow onto a separate service before Black Friday. Convene the council and give me a verdict.",
+      "assertions": [
+        "Each of the five standing seats takes an independent stance (support / conditions / oppose / abstain) before any cross-talk",
+        "Every seat point is concrete and attached to evidence — file:line for code, or the named assumption for a decision",
+        "Genuine disagreements are surfaced as named cruxes; agreement is reported honestly as unanimous rather than manufactured into conflict",
+        "A Chair issues a single reconciled verdict (PROCEED / WITH CONDITIONS / REVISE / RECONSIDER / SPLIT)",
+        "The verdict names the tradeoff chosen, records dissent, and states what would change the decision",
+        "Bench seats are added only when the change warrants them, and benching is stated explicitly",
+        "No persona cosplay — the persona is used as a lens, not costume prose"
+      ]
+    }
+  ]
+}

package/skills/data-contract/evals/eval_queries.json

@@ -0,0 +1,34 @@
+[
+  {
+    "query": "Write a data contract for this table",
+    "should_trigger": true
+  },
+  {
+    "query": "We have downstream consumers of this dataset — define the contract and its SLAs",
+    "should_trigger": true
+  },
+  {
+    "query": "Define the schema and quality guarantees for this event stream",
+    "should_trigger": true
+  },
+  {
+    "query": "What should our producers promise consumers about this data?",
+    "should_trigger": true
+  },
+  {
+    "query": "Draft the OpenAPI spec for our REST API",
+    "should_trigger": false
+  },
+  {
+    "query": "Design the database schema and indexes from our access patterns",
+    "should_trigger": false
+  },
+  {
+    "query": "Write the product requirements document",
+    "should_trigger": false
+  },
+  {
+    "query": "Plan our observability and alerting",
+    "should_trigger": false
+  }
+]

package/skills/data-contract/evals/evals.json

@@ -0,0 +1,16 @@
+{
+  "skill_name": "data-contract",
+  "evals": [
+    {
+      "id": 1,
+      "prompt": "We publish an `orders_daily` table that three downstream teams consume. Write the data contract.",
+      "assertions": [
+        "Every field carries a meaning plus a unit or allowed-values, not merely a type — the cents-vs-dollars class of bug is designed out",
+        "Every quality SLA states a threshold, a check, and a breach action; 'high quality' is rejected as an SLA",
+        "The evolution policy explicitly names meaning-change-under-a-stable-name as a breaking change",
+        "The contract names the owner and the consumers it is a promise to",
+        "Freshness, completeness, validity, and distribution are each addressed or explicitly marked not-applicable"
+      ]
+    }
+  ]
+}