@blamejs/exceptd-skills 0.13.35 → 0.13.37

package/AGENTS.md

@@ -372,7 +372,7 @@ This split costs every consumer the same translation work on every invocation. C
 exceptd collect secrets | exceptd run secrets --evidence -
 ```
 
-The collector library is small and grows as playbooks are touched. Three reference collectors ship today (`lib/collectors/secrets.js`, `lib/collectors/kernel.js`, `lib/collectors/sbom.js`); the rest are written when each playbook needs them. Until a playbook has a collector, the AI/operator owns evidence collection as before.
+The collector library is small and grows as playbooks are touched. Six reference collectors ship today (`lib/collectors/secrets.js`, `lib/collectors/kernel.js`, `lib/collectors/sbom.js`, `lib/collectors/containers.js`, `lib/collectors/library-author.js`, `lib/collectors/crypto-codebase.js`); the rest are written when each playbook needs them. Until a playbook has a collector, the AI/operator owns evidence collection as before.
 
 ### Precision target for new `look.artifacts[].source` strings
 

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## 0.13.37 — 2026-05-20
+
+Sixth reference collector.
+
+### Features
+
+- **`lib/collectors/crypto-codebase.js`** — audits a consumer repo for cryptographic-primitive misuse. Walks source files (JS/TS/Python/Go/Rust/Java/Ruby/PHP/C/C++/C#/Swift/Obj-C) and flips eight deterministic indicators from the `crypto-codebase` playbook: `weak-hash-import` (MD5 / SHA-1 with same-file flow into auth / integrity / token variables), `weak-cipher-mode` (AES-ECB, DES / 3DES, RC4), `rsa-1024-anywhere` (`modulusLength: 1024` and variants), `math-random-in-security-path` (`Math.random` / `random.random` / `mt_rand` / `rand()` within 200 chars of a `token` / `secret` / `key` / `salt` / `nonce` / `iv` / `seed` / `state` / `jwt` / `csrf` / `session` variable assignment), `pbkdf2-under-iterated` (OWASP 2023 thresholds — SHA256 < 600,000 / SHA512 < 210,000 / SHA1 < 1,300,000), `bcrypt-cost-low` (< 12), `hardcoded-key-material` (PEM markers outside test / spec / fixture / example / sample / demo / doc paths), `tls-old-protocol` (TLSv1.0 / TLSv1.1 / SSLv3 / SSLv23 in `secureProtocol` / `minVersion` / `ssl_version`). Three indicators flip conditionally: `ecdsa-without-pqc-roadmap` fires when classical signature use is observed AND no PQC sig impl AND no hybrid-migration roadmap in README / SECURITY.md; `no-ml-kem-implementation` fires when the library claims PQC-ready in README / SECURITY.md AND no ML-KEM / Kyber / liboqs / noble-post-quantum / oqsprovider call site exists; `fips-claim-without-runtime-activation` fires when the library claims FIPS validation AND no `crypto.setFips(true)` / `OSSL_PROVIDER_load(*, "fips", *)` / `Provider::load(*, "fips")` call site exists. `vendored-pqc-no-provenance` fires when a `vendor/` / `third_party/` subdirectory contains a Kyber / Dilithium / SLH-DSA / SPHINCS+ / Falcon source file AND no `_PROVENANCE.json` / `UPSTREAM` / `ORIGIN` / `.upstream-commit` / `PROVENANCE.md` marker exists at any ancestor up to the vendor root. `no-crypto-agility-abstraction` (behavioral / interface-shape) is left unflipped so the runner returns inconclusive — that one requires operator review of the public API surface.
+
+## 0.13.36 — 2026-05-20
+
+Fifth reference collector.
+
+### Features
+
+- **`lib/collectors/library-author.js`** — audits a publisher-side repository for supply-chain posture markers. Flips 11 deterministic indicators: `publish-workflow-uses-static-token`, `publish-workflow-no-id-token-write`, `publish-workflow-action-refs-mutable` (any `uses: <action>@<ref>` where ref isn't a 40-char SHA), `release-workflow-non-frozen-install` (`npm install` vs `npm ci`, cargo without `--locked`), `publish-workflow-runs-on-self-hosted`, `package-json-provenance-missing` (no `publishConfig.provenance: true`), `lockfile-missing-integrity`, `sbom-absent-or-unsigned`, `no-security-md`, `no-security-txt`, `vendored-no-provenance`. Indicators that require GitHub API / sigstore lookup / GPG identity inspection (`tag-protection-absent`, `private-vuln-reporting-disabled`, `no-rekor-entry-for-latest-release`, etc.) are left unflipped — operator-supplied evidence remains the path for those.
+
 ## 0.13.35 — 2026-05-20
 
 Fourth reference collector + a sbom-collector indicator-pattern correction.

package/data/_indexes/_meta.json

@@ -1,10 +1,10 @@
 {
   "schema_version": "1.1.0",
-  "generated_at": "2026-05-21T00:30:25.921Z",
+  "generated_at": "2026-05-21T03:49:45.015Z",
   "generator": "scripts/build-indexes.js",
   "source_count": 54,
   "source_hashes": {
-    "manifest.json": "61181a50546ab0616fcaffabaf0316c4276705f5d25c03fe9248916416b404f6",
+    "manifest.json": "5eeb28b7edf5ebf368b201b1988d0b6ccbb7ca838ee7fe45e63a878e7d3650f9",
     "data/atlas-ttps.json": "d296c1d3e71807c9279b731f047e57796e85137f186586743a8cdad214b408f9",
     "data/attack-techniques.json": "49b6010b317edd219def135171ea8f3b1bbf1e00e9c5a08bf7237215ff54e2c3",
     "data/cve-catalog.json": "a09c83af3f9679a7ea73935726a1ff9de2cab94b4ab6321fc017fc147747d7c3",

package/lib/collectors/crypto-codebase.js

@@ -0,0 +1,438 @@
+"use strict";
+
+/**
+ * lib/collectors/crypto-codebase.js
+ *
+ * Companion collector for the `crypto-codebase` playbook. Walks the
+ * cwd tree, grepping source files for hash / cipher / KEX / signature
+ * / KDF / RNG / TLS / PQC / FIPS call sites. Flips signal_overrides
+ * only for indicators whose verdict can be determined deterministically
+ * from the codebase scan; behavioral indicators that require operator
+ * judgement (e.g. crypto-agility abstraction shape) are left unflipped
+ * so the runner returns inconclusive rather than a forced miss.
+ *
+ * Interface: see lib/collectors/README.md
+ */
+
+const fs = require("node:fs");
+const path = require("node:path");
+
+const COLLECTOR_ID = "crypto-codebase";
+
+const DEFAULT_MAX_DEPTH = 6;
+const DEFAULT_EXCLUDES = new Set([
+  "node_modules", ".git", "dist", "build", "out",
+  ".venv", "venv", "__pycache__", ".pytest_cache",
+  "target", ".idea", ".vscode",
+]);
+
+const SOURCE_EXTS = new Set([
+  ".js", ".mjs", ".cjs", ".jsx", ".ts", ".tsx", ".mts", ".cts",
+  ".py", ".pyi",
+  ".go",
+  ".rs",
+  ".java", ".kt", ".kts", ".scala",
+  ".rb",
+  ".php",
+  ".c", ".h", ".cc", ".cpp", ".hpp", ".cxx",
+  ".cs",
+  ".swift",
+  ".m", ".mm",
+]);
+
+const TEST_PATH_SEGMENTS = [
+  "/test/", "/tests/", "/spec/", "/specs/", "/__tests__/",
+  "/fixtures/", "/fixture/", "/examples/", "/example/",
+  "/docs/", "/doc/", "/sample/", "/samples/", "/demo/", "/demos/",
+  "/benchmarks/", "/benchmark/", "/bench/",
+  // Files whose purpose is grepping for these patterns — their source
+  // literally contains the patterns, so production-scope scans would
+  // match the scanner itself. The crypto-codebase playbook's intent
+  // is the consumer's source, not the scanner's regex catalogue.
+  "/lib/collectors/", "/scripts/check-version-tags",
+];
+
+const MAX_FILE_BYTES = 1024 * 1024;
+
+function isTestPath(rel) {
+  const norm = "/" + rel.replace(/\\/g, "/").toLowerCase() + "/";
+  for (const seg of TEST_PATH_SEGMENTS) {
+    if (norm.includes(seg)) return true;
+  }
+  if (/\.(test|spec)\.[a-z]+$/i.test(rel)) return true;
+  return false;
+}
+
+function walkTree(root, opts = {}) {
+  const maxDepth = opts.maxDepth ?? DEFAULT_MAX_DEPTH;
+  const excludes = opts.excludes ?? DEFAULT_EXCLUDES;
+  const out = [];
+  const seen = new Set();
+
+  function walk(dir, depth) {
+    if (depth > maxDepth) return;
+    let entries;
+    try { entries = fs.readdirSync(dir, { withFileTypes: true }); }
+    catch { return; }
+    for (const entry of entries) {
+      if (excludes.has(entry.name)) continue;
+      const full = path.join(dir, entry.name);
+      let real;
+      try { real = fs.realpathSync(full); } catch { continue; }
+      if (seen.has(real)) continue;
+      seen.add(real);
+      if (entry.isDirectory()) {
+        walk(full, depth + 1);
+      } else if (entry.isFile()) {
+        out.push({ full, rel: path.relative(root, full), name: entry.name });
+      }
+    }
+  }
+  walk(root, 0);
+  return out;
+}
+
+function readSafe(full) {
+  try {
+    const s = fs.statSync(full);
+    if (s.size > MAX_FILE_BYTES) return null;
+    return fs.readFileSync(full, "utf8");
+  } catch { return null; }
+}
+
+const WEAK_HASH_RE = /(?:crypto\.createHash\(\s*['"](?:md5|sha1|sha-1)['"]|hashlib\.(?:md5|sha1)\s*\(|MessageDigest\.getInstance\(\s*['"](?:MD5|SHA-1|SHA1)['"]|crypto\/(?:md5|sha1)\b|Digest::(?:MD5|SHA1)\b)/i;
+const WEAK_HASH_VAR_FLOW_RE = /(hash|hmac|sign|signature|integrity|token|jwt|verify|password)/i;
+
+const WEAK_CIPHER_ECB_RE = /(?:aes-\d+-ecb|AES\/ECB\/|Cipher\.getInstance\(\s*['"]AES['"]\s*\))/i;
+const WEAK_CIPHER_DES_RE = /(?:des-cbc|des-ede3|\bDES\/|\bDESede\/|["']3des["']|["']des["']|\bDES_(?:set|encrypt|decrypt|cbc))/i;
+const WEAK_CIPHER_RC4_RE = /(?:["']rc4["']|\barc4\b|\bARCFOUR\b)/i;
+
+const RSA_1024_RE = /(?:modulusLength\s*:\s*1024|key_size\s*=\s*1024|["']rsa["']\s*,\s*1024|RSA(?:KeyPair)?Generator[^]{0,80}?1024|Generate\w+Key\([^)]*1024)/;
+
+const MATH_RANDOM_GLOBAL_RE = /\b(?:Math\.random\(|random\.random\(|random\.randint\(|random\.choice\(|mt_rand\(|srand\(|rand\(\s*\))/g;
+const SECURITY_VAR_RE = /\b(?:token|secret|key|salt|nonce|iv|seed|state|jwt|jti|csrf|session)\w*\s*[:=]/i;
+
+const PBKDF2_BLOCK_GLOBAL_RE = /\b(?:pbkdf2(?:Sync)?|hashlib\.pbkdf2_hmac)\s*\([^)]{0,400}/g;
+
+const BCRYPT_BLOCK_GLOBAL_RE = /\b(?:bcrypt\.(?:hash|hashSync|gen_salt|genSalt|genSaltSync)|BCrypt::Password\.create)\s*\([^)]{0,200}/g;
+// Captures either named-arg form (`cost: 12` / `rounds=12`) or the
+// positional-arg trailing-integer form. Match against the block
+// captured by BCRYPT_BLOCK_GLOBAL_RE — which truncates at the first
+// `)`, so the trailing-int branch must match `, <digits>` followed
+// by either end-of-block or whitespace, not a closing paren.
+const BCRYPT_COST_RE = /(?:cost|rounds)\s*[:=]\s*(\d+)|,\s*(\d+)\s*$/;
+
+const PEM_RE = /-----BEGIN (?:RSA |EC |DSA |OPENSSH |ENCRYPTED )?(?:PRIVATE|PUBLIC) KEY-----|-----BEGIN CERTIFICATE-----/;
+
+const TLS_OLD_PROTO_RE = /(?:secureProtocol\s*:\s*['"](?:TLSv1_method|TLSv1_1_method|SSLv23_method|SSLv3_method)['"]|minVersion\s*:\s*['"]TLSv1(?:\.0|\.1)?['"]|ssl_version\s*=\s*ssl\.PROTOCOL_TLSv1(?:_1)?|MinTlsVersion::TLSv1\b)/i;
+
+const FIPS_ACTIVATION_RE = /(?:OSSL_PROVIDER_load\([^)]*\bfips\b|crypto\.setFips\s*\(\s*true|Provider::load[^,]*,\s*["']fips["']|set_fips_mode\s*\()/i;
+const FIPS_CLAIM_RE = /\bfips(?:[- _]?(?:validated|compliance|compliant|140-?[23]|mode))\b/i;
+
+const ML_KEM_IMPL_RE = /(?:ml[-_]?kem|kyber|noble-post-quantum|liboqs|oqsprovider|EVP_KEM_|OQS_KEM_|pqcrypto::|aws-lc-rs::pqc|circl\/kem\/kyber)/i;
+const PQC_CLAIM_RE = /\b(?:pqc(?:[- _]?ready)?|post[- _]?quantum)\b/i;
+
+const CLASSICAL_SIG_RE = /\b(?:ECDSA|secp(?:256k1|256r1|384r1|521r1)|Ed25519|Ed448|RSA-?PSS|RSA-?PKCS1)\b/i;
+const PQC_SIG_IMPL_RE = /\b(?:ml[-_]?dsa|dilithium|slh[-_]?dsa|sphincs)\b/i;
+const HYBRID_ROADMAP_RE = /\b(?:hybrid[- _](?:signature|pqc)|(?:pqc|post[- _]?quantum)[- _](?:migration|roadmap|timeline))\b/i;
+
+const VENDORED_PQC_NAMES_RE = /(?:kyber|dilithium|sphincs|ml[-_]?kem|ml[-_]?dsa|slh[-_]?dsa|falcon)/i;
+
+function scanWeakHash(content) {
+  if (!WEAK_HASH_RE.test(content)) return false;
+  return WEAK_HASH_VAR_FLOW_RE.test(content);
+}
+
+function scanMathRandom(content) {
+  const matches = [];
+  for (const m of content.matchAll(MATH_RANDOM_GLOBAL_RE)) {
+    const start = Math.max(0, m.index - 200);
+    const end = Math.min(content.length, m.index + 200);
+    const window = content.slice(start, end);
+    if (SECURITY_VAR_RE.test(window)) {
+      matches.push({ offset: m.index, snippet: m[0] });
+    }
+  }
+  return matches;
+}
+
+function scanPbkdf2(content) {
+  const hits = [];
+  for (const m of content.matchAll(PBKDF2_BLOCK_GLOBAL_RE)) {
+    const block = m[0];
+    let threshold = 210000;
+    if (/sha[-_]?256/i.test(block)) threshold = 600000;
+    else if (/sha1\b/i.test(block) || /sha-1\b/i.test(block)) threshold = 1300000;
+    // Take the max 4+ digit literal as the iteration count. Don't
+    // pre-filter common key-bit-size values (256/384/512/1024) — a
+    // call like `pbkdf2Sync(pw, salt, 1024, 32, 'sha256')` IS under-
+    // iterated at 1024 and must hit. The max() picks iteration over
+    // keylen in the typical positional shape (iter, keylen, algo).
+    const nums = [];
+    for (const nm of block.matchAll(/\b(\d{4,8})\b/g)) {
+      nums.push(Number(nm[1]));
+    }
+    if (nums.length === 0) continue;
+    const iter = Math.max(...nums);
+    if (iter < threshold) {
+      hits.push({ offset: m.index, threshold, iter });
+    }
+  }
+  return hits;
+}
+
+function scanBcrypt(content) {
+  const hits = [];
+  for (const m of content.matchAll(BCRYPT_BLOCK_GLOBAL_RE)) {
+    const block = m[0];
+    const cm = block.match(BCRYPT_COST_RE);
+    if (!cm) continue;
+    const cost = Number(cm[1] || cm[2]);
+    if (!Number.isFinite(cost) || cost === 0) continue;
+    if (cost < 12) hits.push({ offset: m.index, cost });
+  }
+  return hits;
+}
+
+function isVendored(rel) {
+  const norm = "/" + rel.replace(/\\/g, "/").toLowerCase() + "/";
+  return /\/(?:vendor|third_party|3rdparty|external|deps)\//.test(norm);
+}
+
+function collect({ cwd = process.cwd(), env = process.env, args = {} } = {}) {
+  const errors = [];
+  const startTime = Date.now();
+  const root = path.resolve(cwd);
+
+  let files;
+  try {
+    files = walkTree(root);
+  } catch (e) {
+    errors.push({ kind: "walk_failed", reason: e.message });
+    files = [];
+  }
+  if (files.length > 50000) {
+    errors.push({
+      kind: "file_count_capped",
+      reason: `walked ${files.length} files; capping content scan at 50000.`,
+    });
+    files = files.slice(0, 50000);
+  }
+
+  const sourceFiles = files.filter(f => SOURCE_EXTS.has(path.extname(f.name).toLowerCase()));
+
+  const hits = {
+    "weak-hash-import": [],
+    "weak-cipher-mode": [],
+    "rsa-1024-anywhere": [],
+    "math-random-in-security-path": [],
+    "pbkdf2-under-iterated": [],
+    "bcrypt-cost-low": [],
+    "hardcoded-key-material": [],
+    "tls-old-protocol": [],
+  };
+
+  let sawClassicalSig = false;
+  let sawPqcSigImpl = false;
+  let sawHybridRoadmap = false;
+  let sawPqcClaim = false;
+  let sawMlKemImpl = false;
+  let sawFipsClaim = false;
+  let sawFipsActivation = false;
+
+  for (const f of sourceFiles) {
+    const content = readSafe(f.full);
+    if (content == null) {
+      errors.push({ artifact_id: "source-files", kind: "read_failed", reason: f.rel });
+      continue;
+    }
+    const isTest = isTestPath(f.rel);
+
+    if (!isTest) {
+      if (scanWeakHash(content)) {
+        hits["weak-hash-import"].push({ file: f.rel });
+      }
+      if (WEAK_CIPHER_ECB_RE.test(content) || WEAK_CIPHER_DES_RE.test(content) || WEAK_CIPHER_RC4_RE.test(content)) {
+        hits["weak-cipher-mode"].push({ file: f.rel });
+      }
+      if (RSA_1024_RE.test(content)) {
+        hits["rsa-1024-anywhere"].push({ file: f.rel });
+      }
+      const mrHits = scanMathRandom(content);
+      for (const h of mrHits) hits["math-random-in-security-path"].push({ file: f.rel, offset: h.offset });
+
+      const pHits = scanPbkdf2(content);
+      for (const h of pHits) hits["pbkdf2-under-iterated"].push({ file: f.rel, iter: h.iter, threshold: h.threshold });
+
+      const bHits = scanBcrypt(content);
+      for (const h of bHits) hits["bcrypt-cost-low"].push({ file: f.rel, cost: h.cost });
+
+      if (PEM_RE.test(content)) {
+        hits["hardcoded-key-material"].push({ file: f.rel });
+      }
+      if (TLS_OLD_PROTO_RE.test(content)) {
+        hits["tls-old-protocol"].push({ file: f.rel });
+      }
+    }
+
+    // Cross-file evidence for the conditional indicators (ecdsa-
+    // without-pqc-roadmap, no-ml-kem-implementation, fips-claim-
+    // without-runtime-activation). Production-context only — a
+    // PQC / FIPS reference inside `tests/` / `fixtures/` / `examples/`
+    // doesn't count as evidence the library SHIPS that capability.
+    if (!isTest) {
+      if (CLASSICAL_SIG_RE.test(content)) sawClassicalSig = true;
+      if (PQC_SIG_IMPL_RE.test(content)) sawPqcSigImpl = true;
+      if (ML_KEM_IMPL_RE.test(content)) sawMlKemImpl = true;
+      if (FIPS_ACTIVATION_RE.test(content)) sawFipsActivation = true;
+    }
+  }
+
+  const docFiles = files.filter(f =>
+    /^README(\.md|\.rst|\.txt)?$/i.test(f.name) ||
+    /^SECURITY\.md$/i.test(f.name) ||
+    /^package\.json$/i.test(f.name) ||
+    /^Cargo\.toml$/i.test(f.name) ||
+    /^pyproject\.toml$/i.test(f.name)
+  );
+  for (const f of docFiles) {
+    const content = readSafe(f.full);
+    if (content == null) continue;
+    if (PQC_CLAIM_RE.test(content)) sawPqcClaim = true;
+    if (HYBRID_ROADMAP_RE.test(content)) sawHybridRoadmap = true;
+    if (FIPS_CLAIM_RE.test(content)) sawFipsClaim = true;
+  }
+
+  const vendoredPqcFiles = files.filter(f => isVendored(f.rel) && VENDORED_PQC_NAMES_RE.test(f.rel));
+  let vendoredPqcNoProvenance = "miss";
+  if (vendoredPqcFiles.length > 0) {
+    const provenanceMarkers = new Set(["_PROVENANCE.json", "UPSTREAM", "ORIGIN", ".upstream-commit", "PROVENANCE.md"]);
+    // Walk from the file's directory up to the repo root, checking
+    // each ancestor for a provenance marker. The marker can live at
+    // the immediate sibling (`vendor/kyber/_PROVENANCE.json`), at
+    // the vendor root (`vendor/_PROVENANCE.json`), or anywhere in
+    // between for deeply-nested vendor trees. Stop at the repo root
+    // (cwd) so we don't escape into the parent filesystem.
+    let anyMissing = false;
+    for (const f of vendoredPqcFiles) {
+      let dir = path.dirname(f.full);
+      let found = false;
+      while (true) {
+        let entries;
+        try { entries = fs.readdirSync(dir); } catch { break; }
+        if (entries.some(e => provenanceMarkers.has(e))) { found = true; break; }
+        if (path.resolve(dir) === root) break;
+        const parent = path.dirname(dir);
+        if (parent === dir) break;
+        // Guard against escaping the repo root via symlinks.
+        if (path.relative(root, parent).startsWith("..")) break;
+        dir = parent;
+      }
+      if (!found) { anyMissing = true; break; }
+    }
+    vendoredPqcNoProvenance = anyMissing ? "hit" : "miss";
+  }
+
+  let ecdsaWithoutRoadmap;
+  if (sawClassicalSig) {
+    ecdsaWithoutRoadmap = (!sawPqcSigImpl && !sawHybridRoadmap) ? "hit" : "miss";
+  }
+
+  let noMlKemImpl;
+  if (sawPqcClaim) {
+    noMlKemImpl = sawMlKemImpl ? "miss" : "hit";
+  }
+
+  let fipsTheater;
+  if (sawFipsClaim) {
+    fipsTheater = sawFipsActivation ? "miss" : "hit";
+  }
+
+  const signal_overrides = {};
+  for (const id of Object.keys(hits)) {
+    signal_overrides[id] = hits[id].length > 0 ? "hit" : "miss";
+  }
+  signal_overrides["vendored-pqc-no-provenance"] = vendoredPqcNoProvenance;
+  if (ecdsaWithoutRoadmap !== undefined) signal_overrides["ecdsa-without-pqc-roadmap"] = ecdsaWithoutRoadmap;
+  if (noMlKemImpl !== undefined) signal_overrides["no-ml-kem-implementation"] = noMlKemImpl;
+  if (fipsTheater !== undefined) signal_overrides["fips-claim-without-runtime-activation"] = fipsTheater;
+
+  const summarize = (id) => {
+    const list = hits[id];
+    if (list.length === 0) return "0 hits";
+    const head = list.slice(0, 5).map(h => h.file + (h.iter ? ` (iter=${h.iter}<${h.threshold})` : "") + (h.cost ? ` (cost=${h.cost})` : "")).join("; ");
+    return `${list.length} hit(s): ${head}` + (list.length > 5 ? "; …" : "");
+  };
+
+  const artifacts = {
+    "package-manifests": {
+      value: docFiles.filter(f => /(package\.json|Cargo\.toml|pyproject\.toml)/i.test(f.name)).map(f => f.rel).join(", ") || "no manifest found at root",
+      captured: true,
+    },
+    "hash-primitive-call-sites": {
+      value: summarize("weak-hash-import"),
+      captured: true,
+    },
+    "cipher-and-kex-call-sites": {
+      value: summarize("weak-cipher-mode"),
+      captured: true,
+    },
+    "signature-call-sites": {
+      value: sawClassicalSig
+        ? `classical signature use observed; pqc_sig_impl=${sawPqcSigImpl}; hybrid_roadmap=${sawHybridRoadmap}`
+        : "no signature call sites detected",
+      captured: true,
+    },
+    "kdf-call-sites": {
+      value: `pbkdf2 under-iterated: ${summarize("pbkdf2-under-iterated")}; bcrypt low: ${summarize("bcrypt-cost-low")}`,
+      captured: true,
+    },
+    "rng-call-sites": {
+      value: summarize("math-random-in-security-path"),
+      captured: true,
+    },
+    "hardcoded-key-material": {
+      value: summarize("hardcoded-key-material"),
+      captured: true,
+    },
+    "tls-config-construction": {
+      value: summarize("tls-old-protocol"),
+      captured: true,
+    },
+    "pqc-adoption-signals": {
+      value: `pqc_claim=${sawPqcClaim}; ml_kem_impl=${sawMlKemImpl}; pqc_sig_impl=${sawPqcSigImpl}; hybrid_roadmap=${sawHybridRoadmap}`,
+      captured: true,
+    },
+    "fips-provider-activation": {
+      value: `fips_claim=${sawFipsClaim}; fips_activation_in_source=${sawFipsActivation}`,
+      captured: true,
+    },
+    "vendored-crypto-tree": {
+      value: vendoredPqcFiles.length
+        ? vendoredPqcFiles.slice(0, 5).map(f => f.rel).join("; ") + (vendoredPqcFiles.length > 5 ? "; …" : "")
+        : "no vendored PQC primitives detected",
+      captured: true,
+    },
+  };
+
+  return {
+    precondition_checks: {
+      "repo-context": sourceFiles.length > 0,
+    },
+    artifacts,
+    signal_overrides,
+    collector_meta: {
+      collector_id: COLLECTOR_ID,
+      collector_version: "2026-05-20",
+      platform: process.platform,
+      captured_at: new Date().toISOString(),
+      cwd: root,
+      duration_ms: Date.now() - startTime,
+      files_walked: files.length,
+      source_files_scanned: sourceFiles.length,
+    },
+    collector_errors: errors,
+  };
+}
+
+module.exports = { playbook_id: COLLECTOR_ID, collect };