skilltrigger 0.0.0-stage → 0.0.2

package/bin/lib/skill.mjs

@@ -0,0 +1,87 @@
+// The two inputs: a skill's SKILL.md (its name and description) and an eval set in
+// skill-creator's format — a JSON array of { query, should_trigger }, any other field
+// carried through untouched.
+import { existsSync, readFileSync, statSync } from 'node:fs'
+import { join } from 'node:path'
+
+// Enough YAML for skill frontmatter: top-level `key: value`, single- and double-quoted
+// scalars, and `|` / `>` block scalars (with their -/+ chomping indicators accepted).
+// Anything nested is skipped — skilltrigger needs two keys.
+export function parseFrontmatter(text) {
+  const m = String(text).match(/^---\r?\n([\s\S]*?)\r?\n---\s*(?:\r?\n|$)/)
+  if (!m) return null
+  const lines = m[1].split(/\r?\n/)
+  const out = {}
+  for (let i = 0; i < lines.length; i++) {
+    const kv = lines[i].match(/^([A-Za-z_][\w-]*):\s*(.*)$/)
+    if (!kv) continue
+    const [, key, rest] = kv
+    const block = rest.match(/^([|>])[-+]?\s*$/)
+    if (block) {
+      const body = []
+      while (i + 1 < lines.length && (/^\s/.test(lines[i + 1]) || lines[i + 1] === '')) body.push(lines[++i])
+      const indent = Math.min(...body.filter((l) => l.trim()).map((l) => l.match(/^\s*/)[0].length))
+      const stripped = body.map((l) => l.slice(indent))
+      out[key] = block[1] === '|' ? stripped.join('\n').trim() : fold(stripped)
+      continue
+    }
+    out[key] = scalar(rest.trim())
+  }
+  return out
+}
+
+// Folded: lines join with a space, a blank line becomes a newline.
+function fold(lines) {
+  const paras = []
+  let cur = []
+  for (const l of lines) {
+    if (l.trim() === '') {
+      if (cur.length) paras.push(cur.join(' '))
+      cur = []
+    } else cur.push(l.trim())
+  }
+  if (cur.length) paras.push(cur.join(' '))
+  return paras.join('\n')
+}
+
+function scalar(s) {
+  if (s.startsWith('"') && s.endsWith('"') && s.length >= 2) return JSON.parse(s.replace(/\\'/g, "'"))
+  if (s.startsWith("'") && s.endsWith("'") && s.length >= 2) return s.slice(1, -1).replace(/''/g, "'")
+  return s
+}
+
+export function loadSkill(path) {
+  const file = existsSync(path) && statSync(path).isDirectory() ? join(path, 'SKILL.md') : path
+  if (!existsSync(file)) throw new Error(`no SKILL.md at ${path}`)
+  const fm = parseFrontmatter(readFileSync(file, 'utf8'))
+  if (!fm) throw new Error(`${file} has no frontmatter`)
+  if (!fm.name) throw new Error(`${file} has no name in its frontmatter`)
+  if (!/^[A-Za-z0-9][\w.-]*$/.test(fm.name)) throw new Error(`${file}: the name "${fm.name}" is not a plain skill name`)
+  if (!fm.description) throw new Error(`${file} has no description in its frontmatter`)
+  return { name: fm.name, description: fm.description }
+}
+
+export function parseEvalSet(text) {
+  let data
+  try {
+    data = JSON.parse(text)
+  } catch (e) {
+    throw new Error(`the eval set is not valid JSON: ${e.message}`)
+  }
+  if (!Array.isArray(data)) throw new Error('the eval set must be a JSON array of { "query": string, "should_trigger": boolean }')
+  if (!data.length) throw new Error('the eval set is empty')
+  const seen = new Set()
+  data.forEach((it, i) => {
+    if (!it || typeof it !== 'object') throw new Error(`item ${i}: not an object`)
+    if (typeof it.query !== 'string' || !it.query.trim()) throw new Error(`item ${i}: query must be a non-empty string`)
+    if (typeof it.should_trigger !== 'boolean') throw new Error(`item ${i}: should_trigger must be true or false`)
+    if (seen.has(it.query)) throw new Error(`item ${i}: duplicate query — compare matches reports by query text`)
+    seen.add(it.query)
+  })
+  return data
+}
+
+export function loadEvalSet(file) {
+  if (!existsSync(file)) throw new Error(`no eval set at ${file}`)
+  return parseEvalSet(readFileSync(file, 'utf8'))
+}

package/bin/lib/stream.mjs

@@ -0,0 +1,150 @@
+// Reading one run's stream. `claude -p --output-format stream-json --verbose
+// --include-partial-messages` prints one JSON event per line: a `system`/`init` event
+// with the roster, `stream_event`s wrapping the API's own streaming events, complete
+// `assistant` and `user` messages, and a final `result`.
+//
+// The definition of a trigger, which the README states in the same words: the stub is
+// loaded when the model's FIRST decisive message carries a tool call that names it —
+// `Skill` or `SlashCommand` with the stub's name in its input, or `Read` of the stub
+// file. A first message that only fetches tool schemas (`ToolSearch`) is not decisive;
+// the next one is. Anything else in the first decisive message — a text answer,
+// another tool, another skill — is `not-triggered`. That is skill-creator's rule too,
+// minus its one shortcut: it stopped at the first tool of any other kind, so a Bash
+// call listed before the Skill call in the same message counted as a miss.
+//
+// An authentication failure or an API error is an `error`, never `not-triggered`:
+// that confusion is how an expired login used to read as a clean 0/40.
+
+const LOADERS = new Set(['Skill', 'SlashCommand', 'Read'])
+const NEUTRAL = new Set(['ToolSearch'])
+const ERROR_TEXT = /^\s*(?:Failed to authenticate|API Error\b|Invalid API key|OAuth token has expired|Please run \/login|Credit balance is too low)/i
+
+export function createDetector({ stubName, stubPath }) {
+  const names = (tool, input) => {
+    if (!LOADERS.has(tool)) return false
+    const s = typeof input === 'string' ? input : JSON.stringify(input ?? {})
+    if (tool === 'Read') return s.includes(stubPath) || s.includes(`${stubName}.md`)
+    return s.includes(stubName)
+  }
+  const state = {
+    init: null,
+    // Per message: the tool calls seen so far, and whether any of them was decisive.
+    blocks: new Map(),
+    decisive: false,
+    resultSeen: false,
+  }
+  const done = (outcome, reason) => ({ outcome, reason })
+
+  const endOfMessage = () => {
+    // Only a message that did something decides: neutral tools alone keep listening.
+    const decisive = state.decisive
+    state.blocks.clear()
+    state.decisive = false
+    return decisive ? done('not-triggered', 'the first decisive message did not load the stub') : null
+  }
+
+  function feed(ev) {
+    if (!ev || typeof ev !== 'object') return null
+    if (ev.type === 'system' && ev.subtype === 'init') {
+      state.init = ev
+      if (Array.isArray(ev.slash_commands) && !ev.slash_commands.some((c) => String(c).replace(/^\//, '').split(':').pop() === stubName)) {
+        return done('error', `the stub ${stubName} is not in the roster the init event lists — the model never saw it`)
+      }
+      return null
+    }
+    if (ev.type === 'stream_event') {
+      const se = ev.event ?? {}
+      if (se.type === 'content_block_start') {
+        const cb = se.content_block ?? {}
+        if (cb.type === 'tool_use') {
+          state.blocks.set(se.index ?? 0, { tool: cb.name, json: '' })
+          if (!NEUTRAL.has(cb.name)) state.decisive = true
+        } else if (cb.type === 'text') state.decisive = true
+      } else if (se.type === 'content_block_delta') {
+        const b = state.blocks.get(se.index ?? 0)
+        if (b && se.delta?.type === 'input_json_delta') {
+          b.json += se.delta.partial_json ?? ''
+          if (names(b.tool, b.json)) return done('triggered', `${b.tool} named the stub`)
+        }
+      } else if (se.type === 'content_block_stop') {
+        const b = state.blocks.get(se.index ?? 0)
+        if (b && names(b.tool, b.json)) return done('triggered', `${b.tool} named the stub`)
+      } else if (se.type === 'message_stop') {
+        return endOfMessage()
+      }
+      return null
+    }
+    if (ev.type === 'assistant') {
+      const msg = ev.message ?? {}
+      const content = Array.isArray(msg.content) ? msg.content : []
+      const text = content.filter((c) => c.type === 'text').map((c) => c.text ?? '').join('\n')
+      if (ev.error || msg.model === '<synthetic>' || ERROR_TEXT.test(text)) return done('error', firstLine(text) || `assistant error: ${ev.error}`)
+      for (const c of content) {
+        if (c.type !== 'tool_use') continue
+        if (names(c.name, c.input)) return done('triggered', `${c.name} named the stub`)
+        if (!NEUTRAL.has(c.name)) state.decisive = true
+      }
+      if (text) state.decisive = true
+      return null
+    }
+    if (ev.type === 'user') {
+      // A tool result means the message that asked for it is over, whether or not a
+      // message_stop was streamed for it.
+      return endOfMessage()
+    }
+    if (ev.type === 'result') {
+      state.resultSeen = true
+      const text = typeof ev.result === 'string' ? ev.result : ''
+      if (ev.is_error || (ev.subtype && ev.subtype !== 'success') || ERROR_TEXT.test(text)) return done('error', firstLine(text) || `result: ${ev.subtype}`)
+      return done('not-triggered', 'the session ended without loading the stub')
+    }
+    return null
+  }
+
+  function end({ code, stderr = '' } = {}) {
+    const why = firstLine(stderr)
+    return done('error', `the stream ended without a decision (exit ${code ?? '?'})${why ? `: ${why}` : ''}`)
+  }
+
+  return {
+    feed,
+    end,
+    get init() {
+      return state.init
+    },
+  }
+}
+
+const firstLine = (s) => String(s ?? '').trim().split('\n')[0].slice(0, 200)
+
+// Newline-delimited JSON from a byte stream: chunks arrive split anywhere, and a line
+// that is not JSON (a warning the CLI prints to stdout) is skipped, not fatal.
+export function lineSplitter(onEvent) {
+  let buf = ''
+  const emit = (line) => {
+    const t = line.trim()
+    if (!t) return
+    let ev
+    try {
+      ev = JSON.parse(t)
+    } catch {
+      return
+    }
+    onEvent(ev)
+  }
+  return {
+    push(chunk) {
+      buf += chunk
+      let i
+      while ((i = buf.indexOf('\n')) >= 0) {
+        const line = buf.slice(0, i)
+        buf = buf.slice(i + 1)
+        emit(line)
+      }
+    },
+    end() {
+      if (buf) emit(buf)
+      buf = ''
+    },
+  }
+}

package/bin/lib/toggles.mjs

@@ -0,0 +1,62 @@
+// The re-enable reminder. The conflict gate prints `claude plugin disable` and `enable`
+// and runs neither; once the user disables the plugin it is no longer a conflict, so
+// nothing would mention it again (ST-21). The toggles the gate printed are remembered in
+// one small file under the run's --out directory — never under ~/.claude — and the
+// enable command is printed by every preflight that sees the plugin still disabled and at
+// the end of every run, until a preflight sees it enabled again or no longer installed.
+//
+// The file holds plugin ids, scopes and the two commands; it is not a report and none of
+// it enters one.
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { toggleCommands } from './plugins.mjs'
+
+export const TOGGLES_FILE = '.skilltrigger-toggles'
+
+export function readToggles(outDir) {
+  try {
+    const list = JSON.parse(readFileSync(join(outDir, TOGGLES_FILE), 'utf8'))?.plugins
+    return Array.isArray(list) ? list.filter((t) => typeof t?.id === 'string' && typeof t.enable === 'string') : []
+  } catch {
+    return []
+  }
+}
+
+export function writeToggles(outDir, list) {
+  const file = join(outDir, TOGGLES_FILE)
+  if (!list.length) return rmSync(file, { force: true })
+  mkdirSync(outDir, { recursive: true })
+  writeFileSync(file, JSON.stringify({ plugins: list }, null, 2) + '\n')
+}
+
+// remembered: what the file holds; conflicts: what the gate found now (ids may be null);
+// plugins: the parsed plugin list, or null when it was not read.
+// → { keep, reminders } — reminders are the kept entries whose plugin is disabled now.
+export function reconcile({ remembered, conflicts = [], plugins = null, date }) {
+  const byId = new Map(remembered.map((t) => [t.id, t]))
+  for (const c of conflicts.filter((x) => x.id)) {
+    const { disable, enable } = toggleCommands([c])
+    byId.set(c.id, { id: c.id, scope: c.scope ?? null, disable: disable[0], enable: enable[0], since: byId.get(c.id)?.since ?? date })
+  }
+  if (!plugins) return { keep: [...byId.values()], reminders: [] }
+  const now = new Map(plugins.map((p) => [p.id, p]))
+  const conflicting = new Set(conflicts.map((c) => c.id).filter(Boolean))
+  const keep = []
+  const reminders = []
+  for (const t of byId.values()) {
+    const p = now.get(t.id)
+    if (!p) continue // uninstalled: nothing to re-enable
+    if (p.enabled && !conflicting.has(t.id)) continue // enabled again: done
+    keep.push(t)
+    if (!p.enabled) reminders.push(t)
+  }
+  return { keep, reminders }
+}
+
+export function formatReminders(reminders, { after = false } = {}) {
+  if (!reminders.length) return null
+  const head = after
+    ? 're-enable what the conflict gate asked you to disable, once the measurements are done:'
+    : `reminder: ${reminders.map((t) => t.id).join(', ')} ${reminders.length === 1 ? 'is' : 'are'} disabled, as the conflict gate asked — re-enable after the measurement:`
+  return [head, ...reminders.map((t) => `  ${t.enable}`)].join('\n')
+}

package/bin/lib/traps.mjs

@@ -0,0 +1,12 @@
+// The six ways the old measurement returned a clean-looking zero that meant nothing,
+// each with the phrase the README must use for it (`check` holds it to that) and what
+// skilltrigger does about it. The first five were hit in practice between 2026-09-09
+// and 2026-09-18; the sixth is the drift note — the roster changing the number.
+export const TRAPS = [
+  { id: 'parallel', phrase: 'Parallel workers', handled: 'strictly serial runner; no workers option' },
+  { id: 'shadowing', phrase: 'An installed plugin shadowing the stub', handled: 'conflict gate: refuses, prints disable/enable commands' },
+  { id: 'outdated', phrase: 'An outdated CLI', handled: 'round-trip gate with the chosen model; version recorded' },
+  { id: 'login', phrase: 'An expired login', handled: 'auth gate, round-trip gate, auth errors are errors' },
+  { id: 'sleep', phrase: 'A machine that sleeps', handled: 'sleep gate: caffeinate on macOS, warning elsewhere; timeouts counted apart' },
+  { id: 'roster', phrase: 'The skill roster', handled: 'roster gate records it; compare warns when it differs' },
+]

package/bin/skilltrigger.mjs

@@ -0,0 +1,196 @@
+#!/usr/bin/env node
+// skilltrigger — how often a Claude Code skill's description makes the model load it,
+// measured behind gates that refuse to report a number they cannot trust.
+//
+//   skilltrigger preflight [--model M] [--skill <dir>] [--out <dir>] [--allow-conflict]
+//   skilltrigger run --skill <dir> --eval <file> [--runs 2] [--model M] [--timeout 30]
+//                    [--description "<override>"] [--out <dir>] [--allow-conflict]
+//   skilltrigger compare <a.json> <b.json>
+//   skilltrigger check
+//
+// Exit codes: 0 done · 1 usage or input error · 2 a gate failed · 3 no verdict.
+import { readFileSync } from 'node:fs'
+import { dirname, join, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { UsageError, number, parseArgs } from './lib/args.mjs'
+import { checkRepo } from './lib/check.mjs'
+import { compare } from './lib/compare.mjs'
+import { formatGates, preflight } from './lib/gates.mjs'
+import { NO_VERDICT_SHARE, headline, localDate, partialLine, summarise, writeReport } from './lib/report.mjs'
+import { runAll } from './lib/runner.mjs'
+import { loadEvalSet, loadSkill } from './lib/skill.mjs'
+import { formatReminders, readToggles, reconcile, writeToggles } from './lib/toggles.mjs'
+
+const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..')
+const pkg = JSON.parse(readFileSync(join(ROOT, 'package.json'), 'utf8'))
+
+const HELP = readFileSync(fileURLToPath(import.meta.url), 'utf8')
+  .split('\n')
+  .slice(1, 12)
+  .map((l) => l.replace(/^\/\/ ?/, ''))
+  .join('\n')
+
+const DEFAULT_OUT = 'skilltrigger-results'
+
+// The gates, then the re-enable reminder: the toggles the conflict gate printed are kept
+// under --out, and any of those plugins still disabled is named with its enable command.
+async function gates({ model, skillName, allowConflict, outDir }) {
+  console.log(`skilltrigger ${pkg.version} — preflight`)
+  const pf = await preflight({ model, skillName, allowConflict })
+  console.log(formatGates(pf.gates))
+  const conflict = pf.gates.find((x) => x.id === 'conflict')
+  const { keep, reminders } = reconcile({ remembered: readToggles(outDir), conflicts: conflict?.conflicts ?? [], plugins: conflict?.plugins ?? null, date: localDate() })
+  writeToggles(outDir, keep)
+  const note = formatReminders(reminders)
+  if (note) console.log(`\n${note}`)
+  return { ...pf, reminders }
+}
+
+async function cmdPreflight(argv) {
+  const { opts, positional } = parseArgs(argv, { model: 'string', skill: 'string', out: 'string', 'allow-conflict': 'boolean' })
+  if (positional.length) throw new UsageError(`unexpected argument: ${positional[0]}`)
+  const skillName = opts.skill ? loadSkill(opts.skill).name : null
+  const pf = await gates({ model: opts.model ?? null, skillName, allowConflict: Boolean(opts['allow-conflict']), outDir: resolve(opts.out ?? DEFAULT_OUT) })
+  if (!pf.ok) {
+    console.log('\npreflight failed — a run now would measure the failure, not the description')
+    return 2
+  }
+  console.log('\npreflight ok')
+  return 0
+}
+
+async function cmdRun(argv) {
+  const { opts, positional } = parseArgs(argv, {
+    skill: 'string',
+    eval: 'string',
+    runs: 'string',
+    model: 'string',
+    timeout: 'string',
+    description: 'string',
+    out: 'string',
+    'allow-conflict': 'boolean',
+  })
+  if (positional.length) throw new UsageError(`unexpected argument: ${positional[0]}`)
+  if (!opts.skill) throw new UsageError('run needs --skill <dir>')
+  if (!opts.eval) throw new UsageError('run needs --eval <file>')
+  const runs = number(opts, 'runs', { fallback: 2, min: 1, integer: true })
+  const timeout = number(opts, 'timeout', { fallback: 30, min: 0.1 })
+  const skill = loadSkill(opts.skill)
+  const items = loadEvalSet(opts.eval)
+  const overridden = opts.description !== undefined
+  const description = overridden ? opts.description : skill.description
+  if (!description.trim()) throw new UsageError('--description is empty')
+  const outDir = resolve(opts.out ?? DEFAULT_OUT)
+  const model = opts.model ?? null
+
+  const pf = await gates({ model, skillName: skill.name, allowConflict: Boolean(opts['allow-conflict']), outDir })
+  if (!pf.ok) {
+    console.log('\nrefusing to run: a failed gate makes the number meaningless. Fix it and run again.')
+    return 2
+  }
+
+  const planned = items.length * runs
+  console.log(`\n${skill.name}: ${items.length} queries × ${runs} runs = ${planned}, serial, ${timeout} s timeout each`)
+  const width = String(planned).length
+  const mark = { triggered: '+', 'not-triggered': '.', timeout: 'T', error: 'E' }
+  const res = await runAll({
+    items,
+    runs,
+    skillName: skill.name,
+    description,
+    model,
+    timeoutMs: timeout * 1000,
+    env: process.env,
+    noVerdictShare: NO_VERDICT_SHARE,
+    onRun: ({ item, done, outcome, reason, ms }) => {
+      const q = item.query.length > 70 ? `${item.query.slice(0, 69)}…` : item.query
+      const why = outcome === 'timeout' || outcome === 'error' ? `  — ${reason}` : ''
+      console.log(`  [${String(done).padStart(width)}/${planned}] ${mark[outcome]} ${outcome.padEnd(13)} ${(ms / 1000).toFixed(1).padStart(5)} s  ${item.should_trigger ? 'pos' : 'neg'}  ${q}${why}`)
+    },
+  })
+  if (res.aborted) console.log(`  stopped: more than ${NO_VERDICT_SHARE * 100}% of the planned runs timed out or failed — no verdict is possible`)
+
+  const rep = summarise({
+    items,
+    outcomes: res.outcomes,
+    models: res.models,
+    skillName: skill.name,
+    description,
+    overridden,
+    facts: pf.facts,
+    runsPerQuery: runs,
+    timeoutSeconds: timeout,
+    planned,
+    aborted: res.aborted,
+    toolVersion: pkg.version,
+  })
+  const files = writeReport(rep, outDir)
+  console.log(`\n${headline(rep)}`)
+  if (partialLine(rep)) console.log(partialLine(rep))
+  if (rep.verdict === 'ok') console.log(`per query: ${rep.totals.passed}/${rep.totals.queries} pass at a trigger rate threshold of ${rep.triggerThreshold}; no-verdict threshold ${rep.noVerdictThreshold * 100}% of runs`)
+  console.log(`report: ${files.json}\n        ${files.md}`)
+  const after = formatReminders(pf.reminders, { after: true })
+  if (after) console.log(`\n${after}`)
+  return rep.verdict === 'ok' ? 0 : 3
+}
+
+function cmdCompare(argv) {
+  const { positional } = parseArgs(argv, {})
+  if (positional.length !== 2) throw new UsageError('compare needs two report files: compare <a.json> <b.json>')
+  const [a, b] = positional.map((f) => {
+    let r
+    try {
+      r = JSON.parse(readFileSync(f, 'utf8'))
+    } catch (e) {
+      throw new UsageError(`${f}: not a readable report (${e.message})`)
+    }
+    if (r?.tool !== 'skilltrigger' || !Array.isArray(r.queries)) throw new UsageError(`${f}: not a skilltrigger report`)
+    return r
+  })
+  console.log(compare(a, b).text)
+  return 0
+}
+
+function cmdCheck() {
+  const errors = checkRepo(ROOT)
+  for (const e of errors) console.error(`check: ${e}`)
+  if (errors.length) return 1
+  console.log(`ok — skilltrigger ${pkg.version}: CHANGELOG, README traps, no dependencies, no private strings`)
+  return 0
+}
+
+async function main() {
+  const [cmd, ...rest] = process.argv.slice(2)
+  try {
+    switch (cmd) {
+      case 'preflight':
+        return await cmdPreflight(rest)
+      case 'run':
+        return await cmdRun(rest)
+      case 'compare':
+        return cmdCompare(rest)
+      case 'check':
+        return cmdCheck()
+      case '--version':
+      case '-v':
+        console.log(pkg.version)
+        return 0
+      case undefined:
+      case 'help':
+      case '--help':
+      case '-h':
+        console.log(HELP)
+        return 0
+      default:
+        throw new UsageError(`unknown command: ${cmd}`)
+    }
+  } catch (e) {
+    // A bad skill directory or eval file is the user's input, not a crash: one line.
+    console.error(`skilltrigger: ${e.message}`)
+    if (e instanceof UsageError) console.error('run `skilltrigger help` for usage')
+    if (process.env.SKILLTRIGGER_DEBUG) console.error(e.stack)
+    return 1
+  }
+}
+
+process.exitCode = await main()

package/package.json

@@ -1,6 +1,86 @@
 {
   "name": "skilltrigger",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.0.2",
+  "description": "How often a Claude Code skill's description makes the model load it, on prompts that should trigger it and near-misses that should not, measured behind gates that refuse to report a number they cannot trust.",
+  "type": "module",
+  "bin": {
+    "skilltrigger": "bin/skilltrigger.mjs"
+  },
+  "files": [
+    "bin",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "test": "node bin/skilltrigger.mjs check && node --test",
+    "backlog": "npx --yes https://codeload.github.com/Allan-Nava/backlogsync/tar.gz/974f2bd96a7030af8f30eab093b05b7b46482ede check",
+    "build:site": "node site/build.mjs",
+    "roadmap": "npx --yes https://codeload.github.com/Allan-Nava/backlogsync/tar.gz/974f2bd96a7030af8f30eab093b05b7b46482ede roadmap"
+  },
+  "backlogsync": {
+    "prefix": "ST",
+    "name": "skilltrigger",
+    "regenerate": "npm run roadmap",
+    "labels": {
+      "gates": [
+        "3b4bb8",
+        "Preflight gates: CLI, auth, round trip, conflict, sleep, roster"
+      ],
+      "runner": [
+        "0e8a16",
+        "The serial runner and the stream detector"
+      ],
+      "report": [
+        "fbca04",
+        "Reports, verdict rule, compare"
+      ],
+      "release": [
+        "5319e7",
+        "Publishing and versioning"
+      ],
+      "docs": [
+        "0075ca",
+        "README, CONTRIBUTING, site"
+      ],
+      "project": [
+        "6a737d",
+        "Backlog, roadmap, repo hygiene"
+      ],
+      "tests": [
+        "d4c5f9",
+        "Test coverage and the fake claude"
+      ],
+      "enhancement": [
+        "a2eeef",
+        "New capability"
+      ],
+      "prio-med": [
+        "e4b429",
+        "Medium priority in BACKLOG.md"
+      ]
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Allan-Nava/skilltrigger"
+  },
+  "homepage": "https://allan-nava.github.io/skilltrigger/",
+  "bugs": "https://github.com/Allan-Nava/skilltrigger/issues",
+  "keywords": [
+    "claude-code",
+    "skills",
+    "evals",
+    "trigger-rate",
+    "skill-description",
+    "measurement"
+  ],
+  "author": "Allan Nava (https://github.com/Allan-Nava)",
+  "license": "MIT",
+  "devDependencies": {
+    "marked": "^17.0.0"
+  }
+}