@blamejs/exceptd-skills 0.9.1

package/scripts/builders/jurisdiction-clocks.js

@@ -0,0 +1,126 @@
+"use strict";
+/**
+ * scripts/builders/jurisdiction-clocks.js
+ *
+ * Builds `data/_indexes/jurisdiction-clocks.json` — the normalized
+ * jurisdiction × obligation × clock matrix. Today consumers asking
+ * "what's the breach-notification clock in jurisdiction X?" have to
+ * scan `data/global-frameworks.json` and pull `notification_sla` off
+ * specific framework entries. This index flattens the dimension.
+ *
+ * Obligation types covered:
+ *   - breach_notification (hours from awareness)
+ *   - patch_sla            (hours from disclosure for Critical/High)
+ *   - incident_reporting   (regulator + clock + trigger)
+ *
+ * Per-jurisdiction shape:
+ *   {
+ *     jurisdiction_name:
+ *     frameworks: {
+ *       <fwName>: {
+ *         authority,
+ *         breach_notification: { hours, trigger, stages?, source }
+ *         patch_sla: { hours, note?, source }
+ *         incident_reporting: { hours, trigger, source }
+ *       }
+ *     }
+ *     fastest_breach_notification: { hours, framework }   // null when none specified
+ *     fastest_patch_sla:           { hours, framework }
+ *   }
+ */
+
+function buildJurisdictionClocks({ globalFrameworks }) {
+  const out = {};
+  const jurisdictionCodes = Object.keys(globalFrameworks).filter(
+    (k) => !k.startsWith("_") && k !== "GLOBAL"
+  );
+
+  for (const code of jurisdictionCodes) {
+    const j = globalFrameworks[code];
+    const frameworks = j.frameworks || {};
+    const flat = {};
+    let fastestNotif = null;
+    let fastestPatch = null;
+
+    for (const [fwName, fw] of Object.entries(frameworks)) {
+      const entry = {};
+      if (typeof fw.notification_sla === "number" || fw.notification_trigger) {
+        entry.breach_notification = {
+          hours: typeof fw.notification_sla === "number" ? fw.notification_sla : null,
+          trigger: fw.notification_trigger || null,
+          stages: fw.notification_stages || null,
+          source: fw.source || null,
+          authority: fw.authority || null,
+        };
+        if (typeof fw.notification_sla === "number") {
+          if (!fastestNotif || fw.notification_sla < fastestNotif.hours) {
+            fastestNotif = { hours: fw.notification_sla, framework: fwName };
+          }
+        }
+      }
+      if (typeof fw.patch_sla === "number") {
+        entry.patch_sla = {
+          hours: fw.patch_sla,
+          note: fw.patch_sla_note || null,
+          source: fw.source || null,
+          authority: fw.authority || null,
+        };
+        if (!fastestPatch || fw.patch_sla < fastestPatch.hours) {
+          fastestPatch = { hours: fw.patch_sla, framework: fwName };
+        }
+      }
+      if (Object.keys(entry).length > 0) {
+        entry.authority = fw.authority || null;
+        flat[fwName] = entry;
+      }
+    }
+
+    if (Object.keys(flat).length === 0) continue;
+
+    out[code] = {
+      jurisdiction_name: j.jurisdiction || code,
+      frameworks: flat,
+      fastest_breach_notification: fastestNotif,
+      fastest_patch_sla: fastestPatch,
+    };
+  }
+
+  // Cross-jurisdiction summary slices for quick consumer lookups.
+  const allNotifs = [];
+  const allPatch = [];
+  for (const [code, j] of Object.entries(out)) {
+    for (const [fwName, fw] of Object.entries(j.frameworks)) {
+      if (fw.breach_notification?.hours != null) {
+        allNotifs.push({
+          jurisdiction: code,
+          framework: fwName,
+          hours: fw.breach_notification.hours,
+          trigger: fw.breach_notification.trigger,
+        });
+      }
+      if (fw.patch_sla?.hours != null) {
+        allPatch.push({
+          jurisdiction: code,
+          framework: fwName,
+          hours: fw.patch_sla.hours,
+          note: fw.patch_sla.note,
+        });
+      }
+    }
+  }
+  allNotifs.sort((a, b) => a.hours - b.hours);
+  allPatch.sort((a, b) => a.hours - b.hours);
+
+  return {
+    _meta: {
+      schema_version: "1.0.0",
+      note: "Normalized obligation matrix derived from data/global-frameworks.json. All times in hours. breach_notification.hours is null for jurisdictions that require notification only on a discretionary trigger.",
+      jurisdiction_count: Object.keys(out).length,
+    },
+    by_jurisdiction: out,
+    sorted_by_breach_notification_hours: allNotifs,
+    sorted_by_patch_sla_hours: allPatch,
+  };
+}
+
+module.exports = { buildJurisdictionClocks };

package/scripts/builders/recipes.js

@@ -0,0 +1,159 @@
+"use strict";
+/**
+ * scripts/builders/recipes.js
+ *
+ * Builds `data/_indexes/recipes.json` — curated skill sequences for the
+ * most common operator use cases. Each recipe is a vetted chain of skills
+ * to invoke, in order, with a brief rationale per step. Saves the
+ * researcher skill from re-deriving these on every request.
+ *
+ * Recipes are content (not derived), so this builder is mostly a
+ * declarative table. The build step validates that every referenced
+ * skill exists in the manifest, so a renamed/deleted skill surfaces as a
+ * build error.
+ */
+
+const RECIPES = [
+  {
+    id: "ai-red-team-prep",
+    name: "AI Red Team Engagement Prep",
+    description: "Stand up the AI security baseline before red-teaming a model or AI feature. Covers attack surface, MCP plugin trust, prompt-injection class, agentic actions, RAG provenance.",
+    when_to_use: "Before scoping or executing a red-team engagement against a model, agentic system, or AI feature.",
+    typical_jurisdictions: ["US", "EU", "UK", "GLOBAL"],
+    steps: [
+      { skill: "ai-attack-surface", why: "Comprehensive attack-surface inventory mapped to ATLAS v5.1.0 with gap flags." },
+      { skill: "ai-c2-detection", why: "Detection coverage for AI-as-C2 (PROMPTFLUX / SesameOp / AI-API egress) before testing." },
+      { skill: "mcp-agent-trust", why: "MCP server trust boundary for the engineering toolchain side of the surface." },
+      { skill: "rag-pipeline-security", why: "RAG ingestion provenance + prompt-injection chain coverage." },
+      { skill: "threat-modeling-methodology", why: "Frame the engagement scope using a current methodology (PASTA/LINDDUN-AI variant)." },
+    ],
+  },
+  {
+    id: "pci-dss-4-audit-defense",
+    name: "PCI DSS 4.0 Audit Defense",
+    description: "Show real coverage of PCI 4.0 sections that auditors most commonly mis-read as 'compliant'. Focus on 6.3.3, 11.4, 12.10.",
+    when_to_use: "Mock audit, ROC drafting, or QSA pre-engagement review.",
+    typical_jurisdictions: ["US", "EU", "UK", "AU", "SG", "GLOBAL"],
+    steps: [
+      { skill: "compliance-theater", why: "Detect the 7 documented theater patterns that pass PCI but leave exposure." },
+      { skill: "framework-gap-analysis", why: "Pre-analyzed PCI control gaps and what to substitute as compensating controls." },
+      { skill: "incident-response-playbook", why: "PCI 12.10 incident-response coverage that maps to ATT&CK + AI-class incidents." },
+      { skill: "supply-chain-integrity", why: "PCI 6.4 covers SDLC; supply-chain integrity covers what 6.4 omits (MCP / coding assistants)." },
+    ],
+  },
+  {
+    id: "federal-incident-response",
+    name: "Federal Incident Response (FISMA + CISA + FedRAMP)",
+    description: "Coordinate an incident affecting a federal system. Layered SLAs: CISA 8h, OMB M-22-09 access-control breach, FedRAMP continuous-monitoring obligations.",
+    when_to_use: "Active or suspected incident on a federal-system boundary, FedRAMP CSP, or DoD/CMMC scope.",
+    typical_jurisdictions: ["US"],
+    steps: [
+      { skill: "incident-response-playbook", why: "PICERL + cross-jurisdiction notification clocks (CISA 8h initial, OMB, FedRAMP)." },
+      { skill: "sector-federal-government", why: "Federal-specific framework obligations (NIST 800-53, FedRAMP, CMMC, OMB memos)." },
+      { skill: "coordinated-vuln-disclosure", why: "If a vulnerability triggered the incident, CVD coordination via CISA's process." },
+      { skill: "policy-exception-gen", why: "Time-bound exceptions for any control bypassed under emergency response." },
+    ],
+  },
+  {
+    id: "dora-tlpt-scoping",
+    name: "DORA TLPT Scoping (EU Financial Services)",
+    description: "Scope a Threat-Led Penetration Test under DORA Art. 26-27 for an in-scope EU financial entity.",
+    when_to_use: "Annual or triennial DORA TLPT scoping cycle, or after a critical-third-party change.",
+    typical_jurisdictions: ["EU"],
+    steps: [
+      { skill: "sector-financial", why: "DORA-specific scoping requirements (Art. 26-27) and critical-function inventory." },
+      { skill: "attack-surface-pentest", why: "Pen-test methodology aligned to ATT&CK Enterprise + financial-services adversary profile." },
+      { skill: "threat-modeling-methodology", why: "Threat-led methodology (ATT&CK + ATLAS variants), red-team rules of engagement." },
+      { skill: "supply-chain-integrity", why: "ICT third-party scope (DORA Art. 28-30) — TLPT must cover critical ICT third parties." },
+      { skill: "incident-response-playbook", why: "Findings → DORA Art. 19 major-incident reporting (4h / 24h / 30d) if a real incident is uncovered." },
+    ],
+  },
+  {
+    id: "k12-edtech-privacy-review",
+    name: "K-12 EdTech Privacy & Safety Review",
+    description: "Review an EdTech product or pilot for a K-12 deployment. COPPA, FERPA, UK Children's Code, EU AI Act Annex III, AU eSafety, age-appropriate design.",
+    when_to_use: "Procurement review for an EdTech vendor, K-12 board approval cycle, or post-deployment audit.",
+    typical_jurisdictions: ["US", "UK", "EU", "AU"],
+    steps: [
+      { skill: "age-gates-child-safety", why: "Age-appropriate design code, age estimation/assurance, dark-pattern audit, AI Act Annex III." },
+      { skill: "dlp-gap-analysis", why: "Student record / PII flow audit; FERPA + state student-privacy laws (CA SOPIPA, NY Ed Law 2-D)." },
+      { skill: "identity-assurance", why: "Auth posture for child accounts — NIST 800-63B IAL2/AAL2 mismatch for age-restricted UIs." },
+      { skill: "compliance-theater", why: "K-12 vendor attestations are a known theater hotspot; surface the gaps." },
+      { skill: "rag-pipeline-security", why: "If the EdTech includes any AI/LLM features (the common case), RAG + prompt-injection class." },
+    ],
+  },
+  {
+    id: "ransomware-tabletop",
+    name: "Ransomware Tabletop Exercise",
+    description: "Run a tabletop covering modern ransomware: double-extortion, data exfiltration before encryption, OT impact, AI-assisted negotiation messages, multi-jurisdictional notification.",
+    when_to_use: "Annual tabletop, post-incident replay, or executive-team readiness review.",
+    typical_jurisdictions: ["US", "EU", "UK", "AU", "CA", "SG", "JP", "GLOBAL"],
+    steps: [
+      { skill: "incident-response-playbook", why: "PICERL + cross-jurisdiction breach notification (GDPR 72h, NIS2 24h/72h, US state laws, NYDFS 72h)." },
+      { skill: "sector-financial", why: "If financial-sector entity: ransom-payment disclosure (NYDFS 24h), DORA Art. 19, SAMA, MAS TRM." },
+      { skill: "ot-ics-security", why: "If OT/critical infrastructure exposure: CIRCIA 24h, NERC CIP, IEC 62443, recovery without paying." },
+      { skill: "email-security-anti-phishing", why: "Initial access vector typical of ransomware; AI-generated phishing baseline." },
+      { skill: "defensive-countermeasure-mapping", why: "Map exercise findings to D3FEND countermeasures with verifiable telemetry." },
+    ],
+  },
+  {
+    id: "new-cve-drop-triage",
+    name: "New CVE Drop Triage",
+    description: "Standardized first 30 minutes after a high-impact CVE drop. RWEP score, KEV check, evidence chain, dispatched to the right specialized skill.",
+    when_to_use: "Operator receives a CVE number from an advisory, news item, or vendor notice and needs to know what to do.",
+    typical_jurisdictions: ["GLOBAL"],
+    steps: [
+      { skill: "researcher", why: "Entry-point dispatcher: anchors the CVE in the catalog, computes RWEP, routes to the right specialist." },
+      { skill: "exploit-scoring", why: "RWEP score + factor breakdown, KEV + EPSS posture, weaponization timeline estimate." },
+      { skill: "framework-gap-analysis", why: "Pre-analyzed control gaps that auditor-track frameworks have for this CVE class." },
+      { skill: "incident-response-playbook", why: "If active exploitation suspected: notification clocks + PICERL kickoff." },
+    ],
+  },
+  {
+    id: "open-source-dep-triage",
+    name: "Open-Source Dependency Triage",
+    description: "Triage a new advisory in a transitive npm/PyPI/Maven dependency: scope, SBOM, exploit-availability, action.",
+    when_to_use: "Dependabot or Renovate fires a critical/high finding, or a public advisory mentions a dependency you ship.",
+    typical_jurisdictions: ["GLOBAL"],
+    steps: [
+      { skill: "supply-chain-integrity", why: "SBOM scoping, transitive-dep evaluation, build-system trust, signed-attestation check." },
+      { skill: "exploit-scoring", why: "RWEP + EPSS + KEV decide whether this is a 'drop everything' or 'normal cycle' patch." },
+      { skill: "coordinated-vuln-disclosure", why: "If the advisory is pre-coordination, hold the disclosure until the upstream window closes." },
+      { skill: "fuzz-testing-strategy", why: "If you maintain a fork or critical patch: prioritized fuzz target the bug class." },
+    ],
+  },
+];
+
+function buildRecipes({ skills }) {
+  const skillNames = new Set(skills.map((s) => s.name));
+  const errors = [];
+  for (const r of RECIPES) {
+    for (const step of r.steps) {
+      if (!skillNames.has(step.skill)) {
+        errors.push(`recipe ${r.id}: references unknown skill "${step.skill}"`);
+      }
+    }
+  }
+  if (errors.length) {
+    throw new Error("recipes.js: " + errors.join("; "));
+  }
+
+  // Add token-budget hints once we have them — token-budget builder may run
+  // after this one, so we just emit the per-step list and let consumers
+  // join to token-budget.json. The skill_count is cheap to include here.
+  const out = {
+    _meta: {
+      schema_version: "1.0.0",
+      note: "Curated skill sequences for common operator use cases. Each step is a vetted skill plus the reason it belongs in the chain. Cross-reference token-budget.json to estimate context cost.",
+      recipe_count: RECIPES.length,
+    },
+    recipes: RECIPES.map((r) => ({
+      ...r,
+      skill_count: r.steps.length,
+      skill_chain: r.steps.map((s) => s.skill),
+    })),
+  };
+  return out;
+}
+
+module.exports = { buildRecipes };

package/scripts/builders/section-offsets.js

@@ -0,0 +1,162 @@
+"use strict";
+/**
+ * scripts/builders/section-offsets.js
+ *
+ * Builds `data/_indexes/section-offsets.json` — for each skill, the byte
+ * + line offsets of every H2 section header in the body. AI consumers can
+ * slice a single section (e.g. "Compliance Theater Check") from disk
+ * without parsing the full skill file.
+ *
+ * Per-skill shape:
+ *   {
+ *     path:           "skills/<name>/skill.md",
+ *     total_bytes:    n,
+ *     total_lines:    n,
+ *     frontmatter:    { byte_start, byte_end, line_start, line_end },
+ *     sections: [
+ *       {
+ *         name:            raw H2 text (e.g. "Threat Context (mid-2026)")
+ *         normalized_name: collapsed for lookup ("threat-context")
+ *         line:            1-based line number of the "## …" header
+ *         byte_start:      byte offset of the "## " character
+ *         byte_end:        byte offset where the next H2 begins (or EOF)
+ *         bytes:           byte_end - byte_start
+ *         h3_count:        number of "### " headers contained
+ *       },
+ *       ...
+ *     ]
+ *   }
+ *
+ * The normalized_name strips parenthetical qualifiers and common phrasings
+ * so consumers can request a canonical section name without caring about
+ * formatting drift.
+ */
+
+const fs = require("fs");
+const path = require("path");
+
+// Recognized canonical section anchors. Multiple raw H2 phrasings map to one
+// normalized name — see grep survey of skills/* for the variant phrasings.
+const NORMALIZERS = [
+  [/threat\s*context/i,                     "threat-context"],
+  [/framework\s*lag\s*declaration/i,        "framework-lag-declaration"],
+  [/ttp\s*mapping/i,                        "ttp-mapping"],
+  [/exploit\s*availability\s*matrix/i,      "exploit-availability-matrix"],
+  [/compliance\s*theater\s*check/i,         "compliance-theater-check"],
+  [/analysis\s*procedure/i,                 "analysis-procedure"],
+  [/defensive\s*countermeasure\s*mapping/i, "defensive-countermeasure-mapping"],
+  [/output\s*format/i,                      "output-format"],
+  [/hand-?off/i,                            "hand-off"],
+  [/detection\s*rules?/i,                   "detection-rules"],
+  [/exposure\s*assessment/i,                "exposure-assessment"],
+];
+
+function normalize(headerText) {
+  const stripped = headerText.replace(/^##\s+/, "").trim();
+  for (const [re, canonical] of NORMALIZERS) {
+    if (re.test(stripped)) return canonical;
+  }
+  // Fall back: slug.
+  return stripped
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-|-$/g, "");
+}
+
+function buildOne(absPath, relPath) {
+  const buf = fs.readFileSync(absPath);
+  const totalBytes = buf.length;
+  const text = buf.toString("utf8");
+  const lines = text.split(/\r?\n/);
+  const lineByteOffsets = [];
+  let cursor = 0;
+  for (const line of lines) {
+    lineByteOffsets.push(cursor);
+    // +1 for the newline. Counts as one byte for LF; CRLF would skew slightly
+    // but the file is written via the project's tooling which is LF-uniform.
+    cursor += Buffer.byteLength(line, "utf8") + 1;
+  }
+
+  // Frontmatter: lines between the first "---" and the second "---".
+  let fmLineStart = -1, fmLineEnd = -1;
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].trim() === "---") {
+      if (fmLineStart === -1) fmLineStart = i;
+      else if (fmLineEnd === -1) {
+        fmLineEnd = i;
+        break;
+      }
+    }
+  }
+  const frontmatter = fmLineStart >= 0 && fmLineEnd > fmLineStart
+    ? {
+        line_start: fmLineStart + 1,
+        line_end: fmLineEnd + 1,
+        byte_start: lineByteOffsets[fmLineStart],
+        byte_end: lineByteOffsets[Math.min(fmLineEnd + 1, lineByteOffsets.length - 1)] || totalBytes,
+      }
+    : null;
+
+  // H2 headers — only those outside fenced code blocks. Skill bodies often
+  // contain "## Foo" lines inside ```...``` blocks as output templates; those
+  // are not real sections.
+  const h2 = [];
+  let inFence = false;
+  for (let i = 0; i < lines.length; i++) {
+    if (/^```/.test(lines[i])) {
+      inFence = !inFence;
+      continue;
+    }
+    if (!inFence && /^## /.test(lines[i])) {
+      h2.push({ line: i + 1, idx: i, raw: lines[i].trim() });
+    }
+  }
+
+  const sections = [];
+  for (let j = 0; j < h2.length; j++) {
+    const cur = h2[j];
+    const next = h2[j + 1];
+    const startByte = lineByteOffsets[cur.idx];
+    const endByte = next ? lineByteOffsets[next.idx] : totalBytes;
+    // Count H3 within this section.
+    const endIdx = next ? next.idx : lines.length;
+    let h3Count = 0;
+    for (let k = cur.idx + 1; k < endIdx; k++) {
+      if (/^### /.test(lines[k])) h3Count++;
+    }
+    sections.push({
+      name: cur.raw.replace(/^##\s+/, ""),
+      normalized_name: normalize(cur.raw),
+      line: cur.line,
+      byte_start: startByte,
+      byte_end: endByte,
+      bytes: endByte - startByte,
+      h3_count: h3Count,
+    });
+  }
+
+  return {
+    path: relPath,
+    total_bytes: totalBytes,
+    total_lines: lines.length,
+    frontmatter,
+    sections,
+  };
+}
+
+function buildSectionOffsets({ root, skills }) {
+  const out = {};
+  for (const s of skills) {
+    out[s.name] = buildOne(path.join(root, s.path), s.path);
+  }
+  return {
+    _meta: {
+      schema_version: "1.0.0",
+      note: "Per-skill byte/line offsets of every H2 section. Use byte_start/byte_end to slice a specific section. normalized_name collapses phrasing variants (e.g. 'Threat Context (mid-2026)' → 'threat-context').",
+      canonical_section_names: NORMALIZERS.map(([, name]) => name),
+    },
+    skills: out,
+  };
+}
+
+module.exports = { buildSectionOffsets };

package/scripts/builders/stale-content.js

@@ -0,0 +1,171 @@
+"use strict";
+/**
+ * scripts/builders/stale-content.js
+ *
+ * Builds `data/_indexes/stale-content.json` — surfaces stale or
+ * drifted references the audit-cross-skill script catches at run time,
+ * persisted as a JSON artifact so CI / dashboards / downstream tools can
+ * read the same view without invoking the script.
+ *
+ * Checks performed here (subset of audit-cross-skill that's relevant to
+ * the index layer, deterministic across reruns):
+ *
+ *   - Skill bodies referencing renamed-skill tokens (e.g. age-gates-minor-*)
+ *   - README badge counts vs. live counts
+ *   - "Researcher routes to N skills" claim vs. live count
+ *   - Skills with last_threat_review older than 180 days from
+ *     manifest.threat_review_date (gives a stale-content snapshot)
+ *   - Catalog _meta.last_verified entries older than freshness_policy.stale_after_days
+ *   - Forward_watch items mentioning dates that have already passed
+ *
+ * Each finding is { severity, category, artifact, detail }.
+ */
+
+const fs = require("fs");
+const path = require("path");
+
+const RENAMED_SKILL_TOKENS = [
+  // Historical names that should no longer appear in the corpus. Update on
+  // each rename — paired with audit-cross-skill.js stale-renamed-skill check.
+  "age-gates-minor-safeguarding",
+  "age-gates-minor",
+];
+
+function findInBody(body, needle) {
+  // Find occurrences with surrounding context. Returns up to first 3 line refs.
+  const lines = body.split(/\r?\n/);
+  const refs = [];
+  for (let i = 0; i < lines.length && refs.length < 3; i++) {
+    if (lines[i].includes(needle)) refs.push({ line: i + 1, content: lines[i].trim().slice(0, 120) });
+  }
+  return refs;
+}
+
+function buildStaleContent({ root, manifest, skills, catalogFiles }) {
+  const findings = [];
+  const refDate = new Date((manifest.threat_review_date || "2026-05-01") + "T00:00:00Z");
+
+  // 1. Stale-renamed-skill tokens
+  for (const s of skills) {
+    const body = fs.readFileSync(path.join(root, s.path), "utf8");
+    for (const tok of RENAMED_SKILL_TOKENS) {
+      const refs = findInBody(body, tok);
+      if (refs.length > 0) {
+        findings.push({
+          severity: "high",
+          category: "stale_renamed_skill",
+          artifact: s.path,
+          detail: `references retired skill token "${tok}"`,
+          refs,
+        });
+      }
+    }
+  }
+
+  // 2. README badge counts vs. live counts
+  const readmePath = path.join(root, "README.md");
+  if (fs.existsSync(readmePath)) {
+    const readme = fs.readFileSync(readmePath, "utf8");
+    const skillsBadge = readme.match(/skills-(\d+)-/);
+    const jurisdictionsBadge = readme.match(/jurisdictions?-(\d+)-/i);
+    const liveJurisdictions = (() => {
+      try {
+        const gf = JSON.parse(fs.readFileSync(path.join(root, "data/global-frameworks.json"), "utf8"));
+        return Object.keys(gf).filter((k) => !k.startsWith("_") && k !== "GLOBAL").length;
+      } catch {
+        return null;
+      }
+    })();
+    if (skillsBadge && Number(skillsBadge[1]) !== skills.length) {
+      findings.push({
+        severity: "medium",
+        category: "badge_drift",
+        artifact: "README.md",
+        detail: `skills badge shows ${skillsBadge[1]}, manifest has ${skills.length}`,
+      });
+    }
+    if (jurisdictionsBadge && liveJurisdictions && Number(jurisdictionsBadge[1]) !== liveJurisdictions) {
+      findings.push({
+        severity: "medium",
+        category: "badge_drift",
+        artifact: "README.md",
+        detail: `jurisdictions badge shows ${jurisdictionsBadge[1]}, live count is ${liveJurisdictions}`,
+      });
+    }
+  }
+
+  // 3. Researcher dispatch count claim
+  const researcherPath = path.join(root, "skills/researcher/skill.md");
+  if (fs.existsSync(researcherPath)) {
+    const r = fs.readFileSync(researcherPath, "utf8");
+    const claimMatch = r.match(/inventory of (\d+) specialized/);
+    if (claimMatch) {
+      const claimed = Number(claimMatch[1]);
+      const live = skills.length - 1; // researcher excluded from its own dispatch table
+      if (claimed !== live) {
+        findings.push({
+          severity: "medium",
+          category: "researcher_claim_drift",
+          artifact: "skills/researcher/skill.md",
+          detail: `claims ${claimed} specialized skills downstream; live count is ${live}`,
+        });
+      }
+    }
+  }
+
+  // 4. Skills with > 180 days since review (against reference date)
+  for (const s of skills) {
+    if (!s.last_threat_review) continue;
+    const ageDays = Math.floor(
+      (refDate - new Date(s.last_threat_review + "T00:00:00Z")) / 86400000
+    );
+    if (ageDays > 180) {
+      findings.push({
+        severity: "low",
+        category: "skill_review_stale",
+        artifact: s.path,
+        detail: `last_threat_review ${s.last_threat_review} is ${ageDays} days before manifest.threat_review_date`,
+      });
+    }
+  }
+
+  // 5. Catalog last_verified entries older than freshness_policy.stale_after_days
+  for (const rel of catalogFiles) {
+    const abs = path.join(root, rel);
+    try {
+      const j = JSON.parse(fs.readFileSync(abs, "utf8"));
+      const meta = j._meta || {};
+      const policy = meta.freshness_policy || null;
+      if (!policy?.stale_after_days) continue;
+      const last = meta.last_updated || meta.last_verified;
+      if (!last) continue;
+      const ageDays = Math.floor((refDate - new Date(last + "T00:00:00Z")) / 86400000);
+      if (ageDays > policy.stale_after_days) {
+        findings.push({
+          severity: "medium",
+          category: "catalog_stale",
+          artifact: rel,
+          detail: `last_updated ${last} is ${ageDays} days old; freshness_policy.stale_after_days is ${policy.stale_after_days}`,
+        });
+      }
+    } catch {
+      // ignore parse errors — caught elsewhere
+    }
+  }
+
+  const bySeverity = { high: 0, medium: 0, low: 0 };
+  for (const f of findings) bySeverity[f.severity] = (bySeverity[f.severity] || 0) + 1;
+
+  return {
+    _meta: {
+      schema_version: "1.0.0",
+      reference_date: manifest.threat_review_date || null,
+      note: "Stale-content snapshot derived from audit-cross-skill checks. Re-runs of build-indexes against the same inputs produce byte-identical output (reference_date is manifest.threat_review_date, not 'now'). audit-cross-skill.js remains the canonical interactive audit.",
+      finding_count: findings.length,
+      by_severity: bySeverity,
+    },
+    findings,
+  };
+}
+
+module.exports = { buildStaleContent };