@blamejs/exceptd-skills 0.9.1

package/agents/skill-updater.md

@@ -0,0 +1,102 @@
+# Agent: Skill Updater
+
+## Role
+
+Apply validated intelligence packages (approved by source-validator) to skill files and data files. The only agent authorized to write to `data/` and `skills/` directories.
+
+## When to spawn
+
+- source-validator produces an "approved" or "approved with corrections" verdict
+- A forward_watch item has been resolved and needs to be applied to the affected skill
+- skill-update-loop identifies a skill with currency below 70%
+
+## Pre-write Checklist
+
+Before writing to any file:
+1. Confirm the source-validator verdict is "approved" or "approved with corrections"
+2. If "approved with corrections": verify all corrections have been applied to the intelligence package
+3. Identify every file that needs to change (data files + skill files + manifest)
+4. Plan the change set as an atomic unit — all related changes together, not piecemeal
+
+## Write Protocol
+
+### Updating data/cve-catalog.json
+
+1. Check if CVE ID already exists in the catalog
+2. If new entry: add with all required fields. Use `lib/scoring.js` schema as the field checklist.
+3. If updating existing entry: preserve the existing entry, change only the fields that have new verified data
+4. Add `source_verified` date and `verification_sources` list
+5. Recalculate RWEP score if any input factors changed
+
+### Updating data/exploit-availability.json
+
+1. Add or update the entry for the CVE
+2. Include `last_verified` date
+3. Note if PoC status changed (private → public is a high-urgency update)
+
+### Updating data/zeroday-lessons.json
+
+1. Run the zero-day learning loop (zeroday-gap-learn skill) against the new CVE
+2. Generate the full lesson entry: attack vector, defense chain analysis, framework coverage, new control requirements
+3. Add to zeroday-lessons.json
+
+### Updating data/rfc-references.json
+
+Per AGENTS.md hard rule #12, the RFC catalog is a tracked external-data surface. Triggered when:
+
+- `npm run validate-rfcs --live` reports drift (status change, errata count delta, replaced-by populated).
+- A draft cited in `rfc_refs` advances to a numbered RFC: change the catalog key from `DRAFT-...` to `RFC-NNNN`, populate `number`, `published`, `replaces`, and bump `last_verified`.
+- A new RFC newly applies to a covered domain: add a new entry with status, errata count, tracker URL, the cross-reference to which skills will cite it, and `last_verified`.
+
+Atomic update unit when an RFC status changes:
+1. Update the entry in `data/rfc-references.json`.
+2. Audit every skill whose `rfc_refs` lists the affected key. Update each skill's `rfc_refs` (frontmatter + manifest entry) and bump `last_threat_review`.
+3. Refresh `manifest-snapshot.json` (`node scripts/refresh-manifest-snapshot.js`) — a renamed key counts as a public-surface change.
+4. Re-sign the affected skills: `node lib/sign.js sign-all`.
+
+### Updating skill files
+
+For each affected skill:
+1. Identify the specific section that needs updating (Threat Context, Exploit Availability Matrix, etc.)
+2. Apply the minimum change required — do not refactor surrounding content
+3. Update `last_threat_review` in the frontmatter
+4. If a pre-calculated RWEP score changed: update all occurrences in the skill body
+
+### Updating manifest.json
+
+1. Update `threat_review_date` if this is a general review
+2. Update `last_threat_review` for each skill that was changed
+
+## Handoff Package (Output)
+
+```json
+{
+  "agent": "skill-updater",
+  "run_id": "[matches source-validator run_id]",
+  "timestamp": "[ISO 8601]",
+  "changes_made": [
+    {
+      "file": "data/cve-catalog.json",
+      "action": "add | update",
+      "cve_id": "...",
+      "fields_changed": ["cisa_kev", "rwep_score"]
+    },
+    {
+      "file": "skills/kernel-lpe-triage/skill.md",
+      "action": "update",
+      "section": "Exploit Availability Matrix",
+      "description": "Updated RWEP score for CVE-XXXX from 75 to 96 (CISA KEV confirmed)"
+    }
+  ],
+  "forward_watch_resolved": ["..."],
+  "next_agent": "report-generator | none"
+}
+```
+
+## Quality Rules
+
+- Never write to data files without a source-validator approval
+- Never modify the interpretation of a framework control without a framework-analyst package
+- Never delete entries from zeroday-lessons.json or framework-control-gaps.json — mark as superseded, not deleted
+- Always update `last_threat_review` in skill frontmatter after changes
+- If a RWEP score changes by more than 15 points: flag for review rather than auto-applying

package/agents/source-validator.md

@@ -0,0 +1,119 @@
+# Agent: Source Validator
+
+## Role
+
+Cross-check all claims in a threat-researcher or framework-analyst handoff package against primary sources. Flag unverifiable claims. Produce a verification report that the skill-updater uses to decide what to accept.
+
+This agent is the quality gate. It prevents bad data from entering the skill catalog.
+
+## When to spawn
+
+- After threat-researcher produces an intelligence package
+- After framework-analyst produces a gap update
+- On-demand audit of existing data/cve-catalog.json entries
+- Before any new skill that contains specific CVE or TTP claims is merged
+
+## Verification Checklist
+
+### For CVE data
+
+| Claim | Verification Method | Primary Source |
+|---|---|---|
+| CVSS score | Query NVD API, compare | nvd.nist.gov |
+| CVSS vector | Query NVD API, verify vector string | nvd.nist.gov |
+| CISA KEV status | Query CISA KEV JSON feed, check for CVE ID | cisa.gov/known-exploited-vulnerabilities-catalog |
+| CISA KEV date | CISA KEV JSON feed `dateAdded` field | cisa.gov |
+| Active exploitation | CISA KEV (authoritative) or named threat intel report | CISA KEV or specific named report |
+| PoC available | NVD references check; researcher advisory | NVD references |
+| AI-discovered | Researcher disclosure statement | Named researcher/paper |
+| Affected versions | Vendor security advisory | Vendor advisory URL |
+| Patched versions | Vendor security advisory | Vendor advisory URL |
+| Live patch support | kpatch.com / ubuntu.com/livepatch / suse.com | Vendor livepatch pages |
+
+### For ATLAS TTP references
+
+| Claim | Verification Method |
+|---|---|
+| TTP ID validity | atlas.mitre.org/techniques/{ID} returns a page |
+| TTP name accuracy | Matches atlas.mitre.org name exactly |
+| ATLAS version | TTP exists in the version cited in the skill |
+
+### For framework controls
+
+| Claim | Verification Method |
+|---|---|
+| Control ID format | Matches the framework's official ID format |
+| Control name | Cross-check against authoritative source |
+| Control text interpretation | Does the gap analysis accurately represent what the control requires? |
+
+## Verification Report Format
+
+```json
+{
+  "agent": "source-validator",
+  "run_id": "[matches threat-researcher run_id]",
+  "timestamp": "[ISO 8601]",
+  "input_from": "threat-researcher | framework-analyst",
+  "verification_results": {
+    "passed": [
+      {
+        "claim": "CVE-2026-31431 CVSS 7.8",
+        "verified_against": "NVD API",
+        "source_url": "https://nvd.nist.gov/vuln/detail/CVE-2026-31431",
+        "verified_at": "2026-05-01T12:05:00Z"
+      }
+    ],
+    "failed": [
+      {
+        "claim": "CVE-2026-31431 affects kernel < 4.14",
+        "issue": "NVD states affected version range as >= 4.14 (not <4.14). Direction is reversed.",
+        "action_required": "Correct to: affects kernel >= 4.14 AND < [patched version]"
+      }
+    ],
+    "unverifiable": [
+      {
+        "claim": "PoC is 732 bytes",
+        "reason": "Specific byte count not in NVD or any linked advisory. Source is secondary reporting.",
+        "recommendation": "Accept with caveat: cite as 'reported' not 'confirmed'. Or remove specific byte count."
+      }
+    ],
+    "source_single_point": [
+      {
+        "claim": "Active exploitation confirmed",
+        "only_source": "Threat intelligence vendor X",
+        "recommendation": "Downgrade to 'suspected' until CISA KEV confirmation"
+      }
+    ]
+  },
+  "overall_verdict": "approved | approved_with_corrections | rejected",
+  "corrections_required": ["..."],
+  "approved_for_skill_update": true
+}
+```
+
+## Verdict Definitions
+
+**Approved:** All claims verified against primary sources. Skill-updater may proceed.
+
+**Approved with corrections:** Most claims verified. Specific corrections required before skill-updater writes to data files. Corrections documented in `corrections_required`.
+
+**Rejected:** Critical claims unverifiable or incorrect. Return to threat-researcher with specific issues. Do not write to data files.
+
+## Handling Unverifiable Claims
+
+Some claims are inherently difficult to verify from public sources:
+- "PoC is 732 bytes" — specific technical detail from secondary reporting
+- "AI discovered in ~1 hour" — from researcher disclosure without formal citation
+- "150M+ affected downloads" — aggregate statistic without a single authoritative source
+
+For these, the validator applies a severity filter:
+- **High precision claim** (specific number, version, date): require primary source or downgrade to approximate language
+- **Directional claim** (AI-assisted, wide blast radius): accept if consistent across multiple credible sources
+- **Attribution claim** (this was AI-discovered, this campaign is attributed to X): require researcher disclosure or credible attribution report; otherwise "reported as" language
+
+## What This Agent Does NOT Do
+
+- Does not research new threat intel — that is the threat-researcher's job
+- Does not make security recommendations — that is the skill-updater's job
+- Does not modify skill files — that is the skill-updater's job
+- Does not block reasonable claims on technicalities — the goal is data quality, not paralysis

package/agents/threat-researcher.md

@@ -0,0 +1,149 @@
+# Agent: Threat Researcher
+
+## Role
+
+Research and validate new threat intelligence — CVEs, attack campaigns, new ATLAS TTPs, exploit availability changes. Produce a validated, source-cited intelligence package for handoff to the source-validator agent.
+
+## When to spawn
+
+- A new CVE is published in a domain covered by an existing skill (kernel, AI/ML, MCP, supply chain, cryptography)
+- A new CISA KEV entry is added
+- A new threat campaign is documented in credible sources
+- MITRE ATLAS publishes a new version
+- A researcher discloses a new vulnerability class
+- A user invokes `/zeroday-gap-learn` with a CVE that isn't in the catalog
+
+## Inputs
+
+```json
+{
+  "trigger_type": "new_cve | kev_addition | atlas_update | campaign | researcher_disclosure",
+  "trigger_id": "CVE-YYYY-NNNNN | ATLAS-vX.X | [campaign name]",
+  "scope": "what is known so far"
+}
+```
+
+## Research Protocol
+
+### For a new CVE
+
+1. **Query NVD** — `https://services.nvd.nist.gov/rest/json/cves/2.0?cveId={CVE_ID}`
+   - Extract: CVSS score, CVSS vector, description, affected versions, references
+   - Flag any field where NVD data is incomplete or not yet analyzed
+
+2. **Query CISA KEV** — `https://www.cisa.gov/sites/default/files/feeds/known_exploited_vulnerabilities.json`
+   - Is the CVE listed? If yes: extract KEV date and due date
+   - If not yet listed: note as "not listed as of [date]"
+
+3. **Check vendor advisories**
+   - For kernel CVEs: check Red Hat, Ubuntu, Debian, SUSE, Amazon Linux security advisories
+   - For AI tool CVEs: check GitHub Security Advisories, vendor security pages
+   - Extract: affected version ranges, patched versions, workarounds, live-patch availability
+
+4. **Assess PoC availability**
+   - Check NVD references for links to researcher disclosures, proof-of-concept code
+   - Check GitHub for CVE-tagged repositories
+   - DO NOT include direct exploit links in output. Document: "PoC exists — [brief description of technique]"
+   - Flag: was this CVE AI-discovered? Was it AI-assisted weaponization?
+
+5. **Assess active exploitation**
+   - CISA KEV is the authoritative source for confirmed exploitation
+   - Threat intelligence reports (when available from credible sources)
+   - Distinguish: "CISA KEV confirmed" vs. "suspected" vs. "no evidence"
+
+6. **Map to ATLAS/ATT&CK**
+   - Identify which ATLAS v5.1.0 TTPs are relevant to this CVE's attack vector
+   - Identify which ATT&CK techniques are relevant
+   - Flag any ATLAS gaps (attack pattern not in ATLAS v5.1.0)
+
+7. **Identify affected skills**
+   - Which skills cover the CVE's technology domain?
+   - Which skills have pre-calculated RWEP scores that need updating?
+   - Which `forward_watch` items in any skill does this CVE resolve?
+
+### For an ATLAS version update
+
+1. **Download changelog** — `https://atlas.mitre.org/resources/changelog`
+2. **Identify changes:**
+   - New TTPs added → check all skills for domains covered by new TTPs
+   - TTPs modified (ID changed, description changed) → check all skills with that TTP in `atlas_refs`
+   - TTPs removed → flag affected skills
+3. **Map new TTPs to skills** — does any new TTP warrant adding to an existing skill's coverage?
+4. **Identify new TTPs that need new skills** — document as a skill gap
+
+### For a framework amendment
+
+1. **Obtain the amendment text** from the authoritative source (sources/index.json)
+2. **Identify changed controls** — what control IDs changed? What did the text change?
+3. **Cross-reference with data/framework-control-gaps.json** — does the change close any open gaps?
+4. **Assess adequacy** — if a gap is nominally closed, does the new control text actually address the TTP?
+5. **Produce gap status update** — "closed", "partially addressed", or "still open with new evidence"
+
+## Output Format
+
+```json
+{
+  "agent": "threat-researcher",
+  "run_id": "[YYYY-MM-DD]-[trigger_id]",
+  "timestamp": "[ISO 8601]",
+  "trigger": {
+    "type": "[trigger_type]",
+    "id": "[trigger_id]"
+  },
+  "research_findings": {
+    "cve_data": {
+      "cve_id": "...",
+      "cvss_score": 0.0,
+      "cvss_vector": "...",
+      "cisa_kev": false,
+      "poc_available": false,
+      "poc_description": "...",
+      "ai_discovered": false,
+      "active_exploitation": "none | suspected | confirmed",
+      "affected_versions": ["..."],
+      "patch_available": false,
+      "live_patch_available": false,
+      "reboot_required": true,
+      "atlas_refs": ["..."],
+      "attack_refs": ["..."]
+    },
+    "sources_used": [
+      {"source": "NVD", "url": "...", "accessed": "...", "data_extracted": ["cvss_score", "cvss_vector"]},
+      {"source": "CISA KEV", "url": "...", "accessed": "...", "data_extracted": ["kev_status"]}
+    ],
+    "unverified_claims": ["..."],
+    "affected_skills": ["..."],
+    "proposed_skill_updates": {
+      "skill_name": {
+        "section": "Exploit Availability Matrix",
+        "change": "Add CVE-XXXX row with RWEP [score]"
+      }
+    },
+    "proposed_data_updates": {
+      "cve-catalog.json": {"action": "add | update", "entry": {...}},
+      "exploit-availability.json": {"action": "add | update", "entry": {...}}
+    },
+    "forward_watch_resolutions": ["..."]
+  },
+  "verification_required": true,
+  "next_agent": "source-validator",
+  "confidence": "high | medium | low",
+  "confidence_notes": "..."
+}
+```
+
+## Quality Standards
+
+- Every claim must have a `sources_used` entry
+- Claims from a single source must be flagged in `unverified_claims`
+- Confidence is "high" only if 2+ independent sources confirm
+- Confidence is "low" if only a researcher's pre-publication disclosure exists (before NVD analysis)
+- Never assert active exploitation without CISA KEV confirmation or equivalent
+- Never assert PoC availability without verifying at least one credible reference
+
+## What This Agent Does NOT Do
+
+- Does not write directly to data files — that is the skill-updater's job after source-validator approval
+- Does not include direct exploit links in output
+- Does not make compliance recommendations — that is the framework-analyst's job
+- Does not score risk — RWEP calculation is in lib/scoring.js

package/bin/exceptd.js

@@ -0,0 +1,183 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * bin/exceptd.js
+ *
+ * Single executable entry point for the published `@blamejs/exceptd-skills`
+ * package. Routes subcommands to the right internal script so consumers
+ * who installed via npm / npx don't need to know the on-disk layout.
+ *
+ * Subcommands (use `exceptd help` for the full list):
+ *
+ *   path                  Print absolute path to the installed package
+ *                         (so AI assistants can be pointed at AGENTS.md
+ *                         + skills/ + data/_indexes/).
+ *   prefetch [args]       Warm a local cache of upstream artifacts.
+ *   refresh  [args]       Cache-aware external-data refresh.
+ *   build-indexes [args]  Rebuild data/_indexes/ derived files.
+ *   scan                  Scan environment for findings.
+ *   dispatch              Scan then route findings to skills.
+ *   skill <name>          Show context for a specific skill.
+ *   currency              Skill currency report.
+ *   report [format]       Compliance / executive / technical report.
+ *   validate-cves [args]  Cross-check CVE catalog against NVD/KEV/EPSS.
+ *   validate-rfcs [args]  Cross-check RFC catalog against Datatracker.
+ *   watchlist [args]      Forward-watch aggregator.
+ *   verify                Verify every skill's Ed25519 signature.
+ *   help, --help, -h      This help.
+ *   version, --version,
+ *     -v                  Print the package version.
+ *
+ * All subcommand args after the subcommand name are forwarded verbatim
+ * to the underlying script.
+ *
+ * The dispatcher resolves the internal package root at runtime, so
+ * `npx @blamejs/exceptd-skills <cmd>` (which downloads + runs from a temp
+ * dir) and a normal local `node bin/exceptd.js <cmd>` invocation behave
+ * identically.
+ */
+
+const fs = require("fs");
+const path = require("path");
+const { spawnSync } = require("child_process");
+
+// Package root = the directory containing this bin script's parent
+// (e.g. <somewhere>/node_modules/@blamejs/exceptd-skills).
+const PKG_ROOT = path.resolve(__dirname, "..");
+
+// Subcommand → resolved script path. Lazy-resolved per call so a missing
+// optional component (e.g. orchestrator/) just fails that one command
+// instead of crashing dispatcher init.
+const COMMANDS = {
+  path:            null,                                                       // built-in
+  version:         null,                                                       // built-in
+  help:            null,                                                       // built-in
+  "--version":     null,
+  "-v":            null,
+  "--help":        null,
+  "-h":            null,
+  prefetch:        () => path.join(PKG_ROOT, "lib", "prefetch.js"),
+  refresh:         () => path.join(PKG_ROOT, "lib", "refresh-external.js"),
+  "build-indexes": () => path.join(PKG_ROOT, "scripts", "build-indexes.js"),
+  verify:          () => path.join(PKG_ROOT, "lib", "verify.js"),
+  scan:            () => path.join(PKG_ROOT, "orchestrator", "index.js"),
+  dispatch:        () => path.join(PKG_ROOT, "orchestrator", "index.js"),
+  skill:           () => path.join(PKG_ROOT, "orchestrator", "index.js"),
+  currency:        () => path.join(PKG_ROOT, "orchestrator", "index.js"),
+  report:          () => path.join(PKG_ROOT, "orchestrator", "index.js"),
+  "validate-cves": () => path.join(PKG_ROOT, "orchestrator", "index.js"),
+  "validate-rfcs": () => path.join(PKG_ROOT, "orchestrator", "index.js"),
+  watchlist:       () => path.join(PKG_ROOT, "orchestrator", "index.js"),
+};
+
+const ORCHESTRATOR_PASSTHROUGH = new Set([
+  "scan", "dispatch", "skill", "currency", "report",
+  "validate-cves", "validate-rfcs", "watchlist",
+]);
+
+function readPkgVersion() {
+  try {
+    return JSON.parse(fs.readFileSync(path.join(PKG_ROOT, "package.json"), "utf8")).version;
+  } catch {
+    return "unknown";
+  }
+}
+
+function printHelp() {
+  console.log(`exceptd — @blamejs/exceptd-skills v${readPkgVersion()}
+
+Usage: exceptd <command> [args]
+       npx @blamejs/exceptd-skills <command> [args]
+
+Discovery:
+  path                       Print absolute path to the installed package.
+                             Point your AI assistant here:
+                               $(exceptd path)/AGENTS.md
+                               $(exceptd path)/data/_indexes/summary-cards.json
+
+External data:
+  prefetch [args]            Warm local cache of upstream artifacts
+                             (KEV / NVD / EPSS / IETF / GitHub releases).
+                             Try: exceptd prefetch --no-network --quiet
+  refresh [args]             Refresh against cache + apply upserts.
+                             Try: exceptd refresh --from-cache --swarm
+
+Build / verify:
+  build-indexes [args]       Regenerate data/_indexes/*.json.
+                             Try: exceptd build-indexes --changed
+  verify                     Verify every skill's Ed25519 signature.
+
+Analyst:
+  scan                       Scan environment for findings.
+  dispatch                   Scan then route findings to skills.
+  skill <name>               Show context for a specific skill.
+  currency                   Skill currency report.
+  report [format]            Compliance / executive / technical report.
+  validate-cves [args]       Cross-check CVE catalog vs NVD/KEV/EPSS.
+                             Add --from-cache to read from prefetch cache.
+  validate-rfcs [args]       Cross-check RFC catalog vs IETF Datatracker.
+  watchlist [args]           Forward-watch aggregator across skills.
+
+Common:
+  help                       This help.
+  version                    Package version.
+
+Examples:
+  npx @blamejs/exceptd-skills path
+  npx @blamejs/exceptd-skills prefetch
+  npx @blamejs/exceptd-skills validate-cves --from-cache --no-fail
+  npx @blamejs/exceptd-skills skill kernel-lpe-triage
+
+Full documentation: ${PKG_ROOT}/README.md
+Project rules:      ${PKG_ROOT}/AGENTS.md
+`);
+}
+
+function main() {
+  const argv = process.argv.slice(2);
+  if (argv.length === 0) {
+    printHelp();
+    process.exit(0);
+  }
+  const cmd = argv[0];
+  const rest = argv.slice(1);
+
+  if (cmd === "help" || cmd === "--help" || cmd === "-h") {
+    printHelp();
+    process.exit(0);
+  }
+  if (cmd === "version" || cmd === "--version" || cmd === "-v") {
+    process.stdout.write(readPkgVersion() + "\n");
+    process.exit(0);
+  }
+  if (cmd === "path") {
+    process.stdout.write(PKG_ROOT + "\n");
+    process.exit(0);
+  }
+
+  const resolver = COMMANDS[cmd];
+  if (typeof resolver !== "function") {
+    process.stderr.write(`exceptd: unknown command "${cmd}". Run \`exceptd help\` for the list.\n`);
+    process.exit(2);
+  }
+
+  const script = resolver();
+  if (!fs.existsSync(script)) {
+    process.stderr.write(`exceptd: command "${cmd}" not available — expected ${path.relative(PKG_ROOT, script)} in the installed package.\n`);
+    process.exit(2);
+  }
+
+  // Orchestrator subcommands need the subcommand name preserved as argv[0]
+  // for orchestrator/index.js's switch statement.
+  const finalArgs = ORCHESTRATOR_PASSTHROUGH.has(cmd) ? [script, cmd, ...rest] : [script, ...rest];
+  const res = spawnSync(process.execPath, finalArgs, { stdio: "inherit", cwd: PKG_ROOT });
+  if (res.error) {
+    process.stderr.write(`exceptd: failed to run ${cmd}: ${res.error.message}\n`);
+    process.exit(2);
+  }
+  process.exit(typeof res.status === "number" ? res.status : 1);
+}
+
+if (require.main === module) main();
+
+module.exports = { COMMANDS, PKG_ROOT };

package/data/_indexes/_meta.json

@@ -0,0 +1,88 @@
+{
+  "schema_version": "1.1.0",
+  "generated_at": "2026-05-11T23:30:53.944Z",
+  "generator": "scripts/build-indexes.js",
+  "source_count": 49,
+  "source_hashes": {
+    "manifest.json": "c4569222d4863d33008f65256fc2081364ed3fe6f69ec019a2a79b9d6ec2496b",
+    "data/atlas-ttps.json": "1500b5830dab070c4252496964a8c0948e1052a656e2c7c6e1efaf0350645e13",
+    "data/cve-catalog.json": "a81d3e4b491b27ccc084596b063a6108ff10c9eb01d7776922fc393980b534fe",
+    "data/cwe-catalog.json": "c3367d469b4b3d31e4c56397dd7a8305a0be338ecd85afa27804c0c9ce12157b",
+    "data/d3fend-catalog.json": "b5cd14669e2a931d0df81bb8402f3c8ac08b0d2613e595eaecd8cc4631a57587",
+    "data/dlp-controls.json": "8ea8d907aea0a2cfd772b048a62122a322ba3284a5c36a272ad5e9d392564cb5",
+    "data/exploit-availability.json": "7dad52f459c324c40aa4df7cd9157f6a19f670fdfb9d8f687d777c9d99798668",
+    "data/framework-control-gaps.json": "25db4d0cc9e6242e1143494178393ae8eab3384672ca0d685bd55c537f028c83",
+    "data/global-frameworks.json": "84fd19061f052e4ccf66308a7b8d3fd38e00325e97e9e5e19e4d9b302c128957",
+    "data/rfc-references.json": "23ffeb970af5403e9a733844dcea9b45cbae689623085f030dec826c492682e3",
+    "data/zeroday-lessons.json": "56d63821686403c6894c93b9ff9ef318ca8e08d7027e8517131068811d529beb",
+    "skills/kernel-lpe-triage/skill.md": "c00e0a77e8b7b1a1ebcb7267dd728b39ec2671d1260bf4f6a4842f10101a69b0",
+    "skills/ai-attack-surface/skill.md": "3f5c59f1823f1552efe8a5cb32656d34d6407609ddaa1eed254c263864563453",
+    "skills/mcp-agent-trust/skill.md": "716d0d65499f8be21e0389a06a1fcaf6abd1cd2e90f068cab54471dd67127f74",
+    "skills/framework-gap-analysis/skill.md": "86c86761b91d04bcd1ec684fb3d65cf5c2881fde59b03d33fa59baddbbf64d31",
+    "skills/compliance-theater/skill.md": "dda149e69fcd92d913f3f6be4aa1aba8fe85a2b408b88c052c71174b2e0e918c",
+    "skills/exploit-scoring/skill.md": "993dbd4417018e5d20edb31ff2296b92b65fff42d2acde722c05e0be7994ddbe",
+    "skills/rag-pipeline-security/skill.md": "6274bbac1fbd164123f4d57a49c5cc7429846b7452ea476095e9dc846fdc2c42",
+    "skills/ai-c2-detection/skill.md": "afe4258fa03e3fd81ca4bb7b348cb483585eb129ebae811457810b5290080793",
+    "skills/policy-exception-gen/skill.md": "6a18b1ecd342dd792e03fcadaed3aa846192f2408c21c79d98eadd431e1619e1",
+    "skills/threat-model-currency/skill.md": "afa24a1d04202a384374598ea2d924cdaa52e264b9552bae1ace88fd39d6c0e8",
+    "skills/global-grc/skill.md": "a9f4477368e260609793b77275e65e255b5c8067b7ae777047a70f3edb373e50",
+    "skills/zeroday-gap-learn/skill.md": "b101815b1c55e95706d72d31eb88153a92f41a748a86e111ad1ac06b9c676548",
+    "skills/pqc-first/skill.md": "5b4300d71890c16b1de31d380859babaa3631729cedb0c0a397a1ff097524773",
+    "skills/skill-update-loop/skill.md": "c8bfea03c60403fb26e3ab7e07406660ef148bece9e12f9149b5171033cf5e22",
+    "skills/security-maturity-tiers/skill.md": "931d6144048308124930e8036d8e74931ca176f7315e110d33fb30880d2f5367",
+    "skills/researcher/skill.md": "40de9c281ea82e92b21856b5dde15609f187d8cddc7e4116886ac0fff9d0e269",
+    "skills/attack-surface-pentest/skill.md": "f639b6d9c19def5908eddbbb79f0514e168e74661c0894b737d7c76cbb550841",
+    "skills/fuzz-testing-strategy/skill.md": "83b1929a0d1e09a58908b91125ebc91ff14323ab9acc9bab6c4b04903b69b837",
+    "skills/dlp-gap-analysis/skill.md": "041c4c6a5299057383b1d6bd4328c1ef578f8c5c6bade8750d339c7b51020027",
+    "skills/supply-chain-integrity/skill.md": "b7fbb5bfcce53d774c51be3fe2231c5f371850a5bdb8d7edfced3342dd99dbb8",
+    "skills/defensive-countermeasure-mapping/skill.md": "634f0805597a0ab417248a7413eed39b08afbc820e7c6bd257eebaa663d8990d",
+    "skills/identity-assurance/skill.md": "e8f3958ef8dd89f9276f2a62a0a1b418a206a3312bb8ff228729c8f358603dc7",
+    "skills/ot-ics-security/skill.md": "7c6eb389e7ace5b2c6e092f8dfcf4795ce1b0aefaa2738c6e383cb0fef4d6287",
+    "skills/coordinated-vuln-disclosure/skill.md": "22ba9ee01252274b1e4aa1238468415c6f564eca319c601de588fbcdd1bea3bb",
+    "skills/threat-modeling-methodology/skill.md": "9e1ee084a56f837074a41b7a7929b1deb5619bb483485aa066b0c26990fe70db",
+    "skills/webapp-security/skill.md": "10a17ab8d3f0e9b1107f7bed5ff2881f59234592b57f2a52c8c397d711604ffb",
+    "skills/ai-risk-management/skill.md": "6062be4e748606ca7536bba3d87e25716795d5690a0063f188325e8e68291cb6",
+    "skills/sector-healthcare/skill.md": "01dd58ed20b3f97dc240e1b77a522f780bd9428294ac9ac78d51817150b55476",
+    "skills/sector-financial/skill.md": "52bdf30cece82381ea8a4023838aa61a2b9026f315a1356aabb638e49bf7b6d9",
+    "skills/sector-federal-government/skill.md": "e1443a3f788050fd5d63d001a3aafbd3244280399ccdec595d7807de547614d4",
+    "skills/sector-energy/skill.md": "068996fa85cc9d8d7f890b185a38619602cb3bab89704d3bfc85c99cbddaafb8",
+    "skills/api-security/skill.md": "131de2913341f794585091b72522b0e0b8d7dd42eca4faf8ea7315d27b5a5c6f",
+    "skills/cloud-security/skill.md": "26e533f5fa4876cb611cfa026fb7e6417927dd4c2e04f50e42fc08016c40274b",
+    "skills/container-runtime-security/skill.md": "7c62132c189edfe0e803c1cc2a688cef7b6ddd2d3be8c5d74a807293f14e0790",
+    "skills/mlops-security/skill.md": "78bb564f841f2c60ea48790ba686ba1e3f628afd402c96847177cc7e05fba4de",
+    "skills/incident-response-playbook/skill.md": "ede731be2bd673d65a8b7509ca3e2eb9af800186780a99c0369e15b2459d7cb6",
+    "skills/email-security-anti-phishing/skill.md": "9dfc1ca36f3059bb8f1cbc566d1358d1c797bb8f51d7bd62a70df8505563ab23",
+    "skills/age-gates-child-safety/skill.md": "f477320c9727986a44f38dc470e61a2c50bf9eef0a6a4c4ab1f14462dfa94f73"
+  },
+  "skill_count": 38,
+  "catalog_count": 10,
+  "index_stats": {
+    "xref_entries": {
+      "cwe_refs": 34,
+      "d3fend_refs": 20,
+      "framework_gaps": 49,
+      "atlas_refs": 9,
+      "attack_refs": 30,
+      "rfc_refs": 19,
+      "dlp_refs": 0
+    },
+    "trigger_table_entries": 453,
+    "chains_cve_entries": 5,
+    "chains_cwe_entries": 34,
+    "jurisdictions_indexed": 29,
+    "handoff_dag_nodes": 38,
+    "summary_cards": 38,
+    "section_offsets_skills": 38,
+    "token_budget_total_approx": 334394,
+    "recipes": 8,
+    "jurisdiction_clocks": 29,
+    "did_ladders": 8,
+    "theater_fingerprints": 7,
+    "currency_action_required": 8,
+    "frequency_fields": 7,
+    "activity_feed_events": 49,
+    "catalog_summaries": 10,
+    "stale_content_findings": 0
+  },
+  "invalidation_note": "If any source file in source_hashes has a different SHA-256 than recorded here, the indexes are stale. Re-run `npm run build-indexes`."
+}