@clear-capabilities/agentic-security-scanner 0.86.0 → 0.118.2

package/src/ir/.agentic-security/threat-model.json

@@ -0,0 +1,143 @@
+{
+  "entities": [],
+  "boundaries": [],
+  "assets": [],
+  "threats": [
+    {
+      "stride": "T",
+      "strideLabel": "Tampering",
+      "cwe": "CWE-915",
+      "family": "mass-assignment",
+      "severity": "high",
+      "file": "parser-cs.js",
+      "vuln": "Mass Assignment (req.body Direct to Model)",
+      "finding_id": "struct:parser-cs.js:208:Mass_Assignment_(req.body_Direct_to_Model)",
+      "affectsAsset": null,
+      "atEntity": null
+    },
+    {
+      "stride": "T",
+      "strideLabel": "Tampering",
+      "cwe": "CWE-915",
+      "family": "mass-assignment",
+      "severity": "high",
+      "file": "parser-go.js",
+      "vuln": "Mass Assignment (req.body Direct to Model)",
+      "finding_id": "struct:parser-go.js:253:Mass_Assignment_(req.body_Direct_to_Model)",
+      "affectsAsset": null,
+      "atEntity": null
+    },
+    {
+      "stride": "T",
+      "strideLabel": "Tampering",
+      "cwe": "CWE-915",
+      "family": "mass-assignment",
+      "severity": "high",
+      "file": "parser-kt.js",
+      "vuln": "Mass Assignment (req.body Direct to Model)",
+      "finding_id": "struct:parser-kt.js:207:Mass_Assignment_(req.body_Direct_to_Model)",
+      "affectsAsset": null,
+      "atEntity": null
+    },
+    {
+      "stride": "T",
+      "strideLabel": "Tampering",
+      "cwe": "CWE-915",
+      "family": "mass-assignment",
+      "severity": "high",
+      "file": "parser-php.js",
+      "vuln": "Mass Assignment (req.body Direct to Model)",
+      "finding_id": "struct:parser-php.js:209:Mass_Assignment_(req.body_Direct_to_Model)",
+      "affectsAsset": null,
+      "atEntity": null
+    },
+    {
+      "stride": "T",
+      "strideLabel": "Tampering",
+      "cwe": "CWE-915",
+      "family": "mass-assignment",
+      "severity": "high",
+      "file": "parser-rb.js",
+      "vuln": "Mass Assignment (req.body Direct to Model)",
+      "finding_id": "struct:parser-rb.js:201:Mass_Assignment_(req.body_Direct_to_Model)",
+      "affectsAsset": null,
+      "atEntity": null
+    },
+    {
+      "stride": "T",
+      "strideLabel": "Tampering",
+      "cwe": "CWE-400",
+      "family": "dos-sync-io",
+      "severity": "medium",
+      "file": "cpp-preprocessor.js",
+      "vuln": "Synchronous Blocking I/O (DoS Risk in Server Context)",
+      "finding_id": "struct:cpp-preprocessor.js:94:Synchronous_Blocking_I/O_(DoS_Risk_in_Server_Context)",
+      "affectsAsset": null,
+      "atEntity": null
+    },
+    {
+      "stride": "T",
+      "strideLabel": "Tampering",
+      "cwe": "CWE-400",
+      "family": "dos-sync-io",
+      "severity": "medium",
+      "file": "type-stubs.js",
+      "vuln": "Synchronous Blocking I/O (DoS Risk in Server Context)",
+      "finding_id": "struct:type-stubs.js:48:Synchronous_Blocking_I/O_(DoS_Risk_in_Server_Context)",
+      "affectsAsset": null,
+      "atEntity": null
+    },
+    {
+      "stride": "T",
+      "strideLabel": "Tampering",
+      "cwe": "CWE-400",
+      "family": "dos-sync-io",
+      "severity": "medium",
+      "file": "parser-py-cst.js",
+      "vuln": "Synchronous Blocking I/O (DoS Risk in Server Context)",
+      "finding_id": "struct:parser-py-cst.js:91:Synchronous_Blocking_I/O_(DoS_Risk_in_Server_Context)",
+      "affectsAsset": null,
+      "atEntity": null
+    },
+    {
+      "stride": "I",
+      "strideLabel": "Information Disclosure",
+      "cwe": "CWE-327",
+      "family": "crypto-weak-hash",
+      "severity": "medium",
+      "file": "parser-py.helper.py",
+      "line": 68,
+      "vuln": "Weak hash algorithm (MD5 / SHA-1 / MD2 / MD4) used",
+      "finding_id": "crypto-weak-hash:parser-py.helper.py:68",
+      "affectsAsset": null,
+      "atEntity": null
+    },
+    {
+      "stride": "T",
+      "strideLabel": "Tampering",
+      "cwe": "CWE-367",
+      "family": "toctou-file-existence-permission-check-b",
+      "severity": "medium",
+      "file": "type-stubs.js",
+      "line": 48,
+      "vuln": "TOCTOU: file existence/permission check before open",
+      "finding_id": "toctou-fs:type-stubs.js:48",
+      "affectsAsset": null,
+      "atEntity": null
+    },
+    {
+      "stride": "T",
+      "strideLabel": "Tampering",
+      "cwe": "CWE-176",
+      "family": "path-normalization",
+      "severity": "medium",
+      "file": "universal-ir.js",
+      "line": 93,
+      "vuln": "Path Normalization Gap — extension extraction without null-byte/traversal sanitization",
+      "finding_id": "path-norm:universal-ir.js:93",
+      "affectsAsset": null,
+      "atEntity": null
+    }
+  ],
+  "attackTrees": []
+}

package/src/ir/.agentic-security/threat-model.md

@@ -0,0 +1,39 @@
+# Threat Model (auto-generated)
+
+Generated by agentic-security on 2026-05-31.
+
+This threat model is derived from static analysis of the current codebase and is regenerated on every scan. It is intended as a working artifact, not a finished compliance document.
+
+## Entities + boundaries
+
+```mermaid
+flowchart TB
+  subgraph External
+  end
+  subgraph Application
+  end
+```
+
+## Assets
+
+
+## STRIDE threats
+
+### Tampering (10)
+
+- [high] **mass-assignment** (CWE-915) at `parser-cs.js:undefined` — Mass Assignment (req.body Direct to Model)
+- [high] **mass-assignment** (CWE-915) at `parser-go.js:undefined` — Mass Assignment (req.body Direct to Model)
+- [high] **mass-assignment** (CWE-915) at `parser-kt.js:undefined` — Mass Assignment (req.body Direct to Model)
+- [high] **mass-assignment** (CWE-915) at `parser-php.js:undefined` — Mass Assignment (req.body Direct to Model)
+- [high] **mass-assignment** (CWE-915) at `parser-rb.js:undefined` — Mass Assignment (req.body Direct to Model)
+- [medium] **dos-sync-io** (CWE-400) at `cpp-preprocessor.js:undefined` — Synchronous Blocking I/O (DoS Risk in Server Context)
+- [medium] **dos-sync-io** (CWE-400) at `type-stubs.js:undefined` — Synchronous Blocking I/O (DoS Risk in Server Context)
+- [medium] **dos-sync-io** (CWE-400) at `parser-py-cst.js:undefined` — Synchronous Blocking I/O (DoS Risk in Server Context)
+- [medium] **toctou-file-existence-permission-check-b** (CWE-367) at `type-stubs.js:48` — TOCTOU: file existence/permission check before open
+- [medium] **path-normalization** (CWE-176) at `universal-ir.js:93` — Path Normalization Gap — extension extraction without null-byte/traversal sanitization
+
+### Information Disclosure (1)
+
+- [medium] **crypto-weak-hash** (CWE-327) at `parser-py.helper.py:68` — Weak hash algorithm (MD5 / SHA-1 / MD2 / MD4) used
+
+## Attack trees

package/src/ir/CLAUDE.md

@@ -11,6 +11,7 @@ consumed by `scanner/src/dataflow/` for taint analysis.
 | Python   | `parser-py-cst.js`    | Python 3.8+ stdlib `ast` via subprocess (default when available) |
 | Python   | `parser-py.js`        | Hand-rolled regex parser (fallback when python3 missing) |
 | Java     | `parser-java.js`      | `java-parser` npm package (async)                |
+| Long-tail (rust/solidity/cpp/c/go/swift/dart) | `tree-sitter-loader.js` | **Optional** `web-tree-sitter` + `tree-sitter-wasms` (ABI-pinned 0.20.8 ↔ 0.1.13), lazy + degrades when absent. Powers `sast/tree-sitter-sinks.js` (opt-in via `AGENTIC_SECURITY_TREE_SITTER=1`). Marked `--external` in the build so the committed bundle never embeds WASM. |
 
 ## Python parser — dual-path with auto fallback
 

package/src/ir/callgraph.js

@@ -67,8 +67,19 @@ export function buildCallGraph(perFileIR, fileContents) {
   // the call graph for the callee's qid at the assign-from-call site.
   // Same precedence as the edge resolution above (same-file ident wins,
   // ClassName.method falls back).
-  function resolve(name) {
+  function resolve(name, callerFile) {
     if (!name || typeof name !== 'string') return null;
+    // Roadmap #3: same-file preference. A bare name (`handler`, `save`,
+    // `query`) defined in several files would otherwise resolve to whichever
+    // file Map is iterated first, mis-targeting interprocedural taint to a
+    // same-named function in an unrelated file. When the caller's own file
+    // defines the name, that is overwhelmingly the intended callee — prefer
+    // it. Backward-compatible: with no callerFile (or no local match) the
+    // original resolution order is unchanged, so no edge is ever dropped.
+    if (callerFile) {
+      const local = byNameInFile.get(callerFile);
+      if (local && local.has(name)) return local.get(name);
+    }
     for (const m of byNameInFile.values()) {
       if (m.has(name)) return m.get(name);
     }

package/src/ir/tree-sitter-loader.js

@@ -0,0 +1,108 @@
+// Tree-sitter parser loader (roadmap #8) — OPTIONAL, runtime-lazy, degrades.
+//
+// web-tree-sitter + tree-sitter-wasms are OPTIONAL dependencies (pinned to an
+// ABI-matched pair: web-tree-sitter 0.20.8 ↔ tree-sitter-wasms 0.1.13). They
+// are NOT bundled into dist (the build marks them `--external`), so the
+// committed bundle stays self-contained and small; this loader requires them
+// lazily at runtime and returns null when they're absent. That keeps the
+// scanner fully bootable offline / without the optional deps — long-tail
+// languages simply fall back to the existing pattern detectors.
+//
+// Long-tail languages this unlocks (no first-class IR parser today):
+// rust, solidity, cpp, c, go, swift, dart. (js/ts/py/java/etc. already have
+// dedicated IR parsers and don't need this.)
+
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+
+// language → prebuilt grammar wasm shipped by tree-sitter-wasms.
+const GRAMMAR_WASM = {
+  rust: 'tree-sitter-rust.wasm',
+  solidity: 'tree-sitter-solidity.wasm',
+  cpp: 'tree-sitter-cpp.wasm',
+  c: 'tree-sitter-c.wasm',
+  go: 'tree-sitter-go.wasm',
+  swift: 'tree-sitter-swift.wasm',
+  dart: 'tree-sitter-dart.wasm',
+};
+
+const EXT_TO_LANG = {
+  rs: 'rust', sol: 'solidity', cpp: 'cpp', cc: 'cpp', cxx: 'cpp', hpp: 'cpp',
+  c: 'c', h: 'c', go: 'go', swift: 'swift', dart: 'dart',
+};
+
+export function treeSitterLangOf(file) {
+  if (typeof file !== 'string') return null;
+  const ext = file.split('.').pop().toLowerCase();
+  return EXT_TO_LANG[ext] || null;
+}
+
+let _Parser; // undefined = not tried, null = unavailable, fn = the class
+let _initPromise = null;
+const _langCache = new Map(); // language → Language | null
+const _parserCache = new Map(); // language → Parser | null
+
+async function _ensureRuntime() {
+  if (_Parser === null) return null;
+  if (_Parser) return _Parser;
+  try {
+    // 0.20 API: the module's default export IS the Parser class.
+    const mod = require('web-tree-sitter');
+    _Parser = mod && (mod.Parser || mod.default || mod);
+    if (!_initPromise) _initPromise = _Parser.init();
+    await _initPromise;
+    return _Parser;
+  } catch {
+    _Parser = null; // optional dep absent or failed to init → degrade.
+    return null;
+  }
+}
+
+function _grammarPath(language) {
+  const file = GRAMMAR_WASM[language];
+  if (!file) return null;
+  try { return require.resolve('tree-sitter-wasms/out/' + file); } catch { return null; }
+}
+
+// Returns a ready-to-use Parser for `language`, or null if tree-sitter or the
+// grammar isn't available. Cached per language. `parser.parse(src)` is then
+// synchronous, so callers can parse inside a sync loop after awaiting this.
+export async function getParserFor(language) {
+  if (_parserCache.has(language)) return _parserCache.get(language);
+  const Parser = await _ensureRuntime();
+  if (!Parser) { _parserCache.set(language, null); return null; }
+  try {
+    let Lang = _langCache.get(language);
+    if (Lang === undefined) {
+      const wasm = _grammarPath(language);
+      Lang = wasm ? await Parser.Language.load(wasm) : null;
+      _langCache.set(language, Lang);
+    }
+    if (!Lang) { _parserCache.set(language, null); return null; }
+    const p = new Parser();
+    p.setLanguage(Lang);
+    _parserCache.set(language, p);
+    return p;
+  } catch {
+    _parserCache.set(language, null);
+    return null;
+  }
+}
+
+export async function isTreeSitterAvailable() {
+  return (await _ensureRuntime()) != null;
+}
+
+// Walk every named node, invoking cb(node). Iterative to avoid deep recursion.
+export function walkNamed(root, cb) {
+  if (!root) return;
+  const stack = [root];
+  while (stack.length) {
+    const n = stack.pop();
+    cb(n);
+    for (let i = n.namedChildCount - 1; i >= 0; i--) stack.push(n.namedChild(i));
+  }
+}
+
+export const _internals = { GRAMMAR_WASM, EXT_TO_LANG, _grammarPath };

package/src/posture/.agentic-security/dpia.md

@@ -1,6 +1,6 @@
 # Data Protection Impact Assessment (DPIA)
 
-Generated by agentic-security scanner on 2026-05-30.
+Generated by agentic-security scanner on 2026-05-31.
 
 This is an automated DPIA scaffold derived from static analysis.
 It must be reviewed and completed by a privacy officer before use.

package/src/posture/.agentic-security/pqc-migration-plan.json

@@ -1,5 +1,5 @@
 {
-  "generatedAt": "2026-05-30T05:08:00.813Z",
+  "generatedAt": "2026-05-31T14:14:14.017Z",
   "summary": {
     "total": 1,
     "hndlCritical": 0,

package/src/posture/.agentic-security/pqc-migration-plan.md

@@ -1,6 +1,6 @@
 # Post-quantum cryptography migration plan
 
-Generated 2026-05-30.
+Generated 2026-05-31.
 
 **1** pre-quantum primitive sites across **1** files.  
 HNDL-critical: **0** | Standard: **1**

package/src/posture/.agentic-security/sbom-history/0724c133d2943c87555695b5b2adcfcfc3373a2d.json

@@ -0,0 +1,6 @@
+{
+  "sha": "0724c133d2943c87555695b5b2adcfcfc3373a2d",
+  "ts": "2026-05-30T17:55:31.746Z",
+  "componentCount": 0,
+  "components": []
+}

package/src/posture/.agentic-security/sbom-history/99c372cdc33ecc9dde92960b4ffadf7775860e61.json

@@ -0,0 +1,6 @@
+{
+  "sha": "99c372cdc33ecc9dde92960b4ffadf7775860e61",
+  "ts": "2026-05-31T14:14:14.016Z",
+  "componentCount": 0,
+  "components": []
+}

package/src/posture/.agentic-security/sbom-history/b7ac2dada4a9216ccfe8969fc57f988c83f46975.json

@@ -0,0 +1,6 @@
+{
+  "sha": "b7ac2dada4a9216ccfe8969fc57f988c83f46975",
+  "ts": "2026-05-31T05:25:45.025Z",
+  "componentCount": 0,
+  "components": []
+}

package/src/posture/.agentic-security/threat-model.json

@@ -396,7 +396,7 @@
       "severity": "low",
       "file": "holdout-eval.js",
       "vuln": "Synchronous Blocking I/O (DoS Risk in Server Context)",
-      "finding_id": "struct:holdout-eval.js:53:Synchronous_Blocking_I/O_(DoS_Risk_in_Server_Context)",
+      "finding_id": "struct:holdout-eval.js:73:Synchronous_Blocking_I/O_(DoS_Risk_in_Server_Context)",
       "affectsAsset": null,
       "atEntity": null
     },
@@ -1559,9 +1559,9 @@
       "family": "toctou-file-existence-permission-check-b",
       "severity": "low",
       "file": "holdout-eval.js",
-      "line": 53,
+      "line": 73,
       "vuln": "TOCTOU: file existence/permission check before open",
-      "finding_id": "toctou-fs:holdout-eval.js:53",
+      "finding_id": "toctou-fs:holdout-eval.js:73",
       "affectsAsset": null,
       "atEntity": null
     },

package/src/posture/.agentic-security/threat-model.md

@@ -1,6 +1,6 @@
 # Threat Model (auto-generated)
 
-Generated by agentic-security on 2026-05-30.
+Generated by agentic-security on 2026-05-31.
 
 This threat model is derived from static analysis of the current codebase and is regenerated on every scan. It is intended as a working artifact, not a finished compliance document.
 

package/src/posture/corpus-status.js

@@ -0,0 +1,74 @@
+// Corpus coverage / gap reporter (roadmap #10).
+//
+// "Scale the ground-truth corpus" is a data-acquisition effort, not a code one
+// — but you can't prioritize what you can't see. This turns the CVE-replay
+// corpus into an actionable coverage map: progress toward the target size, and
+// exactly which CWE×language cells have zero ground-truth entries. It measures
+// the existing corpus only; it never invents entries.
+
+// The corpus's declared target families/languages (mirrors bench manifest).
+export const TARGET_CWES = [
+  'CWE-22', 'CWE-78', 'CWE-79', 'CWE-89', 'CWE-90', 'CWE-94', 'CWE-113',
+  'CWE-327', 'CWE-329', 'CWE-338', 'CWE-352', 'CWE-502', 'CWE-601', 'CWE-611',
+  'CWE-643', 'CWE-798', 'CWE-916', 'CWE-918', 'CWE-1321', 'CWE-1333',
+];
+export const TARGET_LANGUAGES = [
+  'javascript', 'python', 'java', 'go', 'ruby', 'php', 'csharp', 'kotlin',
+];
+
+// Pure analyzer. `entries` = [{ cwe, language, family, cve, tier? }, …].
+export function analyzeCorpus(entries, opts = {}) {
+  const target = opts.target || 500;
+  const cwes = opts.cweFamilies || TARGET_CWES;
+  const langs = opts.languages || TARGET_LANGUAGES;
+  const list = Array.isArray(entries) ? entries : [];
+
+  const byLanguage = {}, byCwe = {}, matrix = {};
+  for (const e of list) {
+    const lang = (e && e.language) || 'unknown';
+    const cwe = (e && e.cwe) || 'unknown';
+    byLanguage[lang] = (byLanguage[lang] || 0) + 1;
+    byCwe[cwe] = (byCwe[cwe] || 0) + 1;
+    (matrix[cwe] || (matrix[cwe] = {}))[lang] = (matrix[cwe][lang] || 0) + 1;
+  }
+
+  // Empty cells in the target CWE×language matrix = prioritized gaps.
+  const gaps = [];
+  for (const cwe of cwes) {
+    for (const lang of langs) {
+      if (!(matrix[cwe] && matrix[cwe][lang])) gaps.push({ cwe, language: lang });
+    }
+  }
+  const cellsTotal = cwes.length * langs.length;
+  return {
+    total: list.length,
+    target,
+    progressPct: Math.round((list.length / target) * 100),
+    remainingToTarget: Math.max(0, target - list.length),
+    byLanguage,
+    byCwe,
+    matrix,
+    cellsTotal,
+    cellsCovered: cellsTotal - gaps.length,
+    gapCount: gaps.length,
+    gaps,
+  };
+}
+
+export function summarizeCorpusStatus(r) {
+  if (!r) return 'corpus: (no data)';
+  const lines = [
+    `corpus: ${r.total}/${r.target} entries (${r.progressPct}%, ${r.remainingToTarget} to target)`,
+    `matrix: ${r.cellsCovered}/${r.cellsTotal} CWE×language cells covered (${r.gapCount} gaps)`,
+  ];
+  // Top under-covered languages (fewest entries among target languages).
+  const langCounts = Object.entries(r.byLanguage).sort((a, b) => a[1] - b[1]);
+  if (langCounts.length) {
+    lines.push('thinnest languages: ' + langCounts.slice(0, 3).map(([l, n]) => `${l}=${n}`).join(', '));
+  }
+  // A few example gaps to act on first.
+  if (r.gaps.length) {
+    lines.push('example gaps: ' + r.gaps.slice(0, 6).map(g => `${g.cwe}/${g.language}`).join(', '));
+  }
+  return lines.join('\n');
+}

package/src/posture/coverage-report.js

@@ -0,0 +1,113 @@
+// Analysis-coverage honesty report (roadmap #5 + #6).
+//
+// A "perfect" SAST scanner must publish its blind spots, not hide them. This
+// module turns three things the engine already knows internally into an
+// explicit, user-facing coverage summary:
+//
+//   1. Per-language ANALYSIS TIER — which languages in this scan got the full
+//      IR + taint engine vs. only pattern (regex) detectors. The taint engine
+//      is wired for js/ts/py/java/cs/kt/go/php/rb; everything else
+//      (c/c++/rust/swift/solidity/dart/…) is pattern-only today.
+//   2. Files SKIPPED and why (too large, too dense, timed out).
+//   3. UNMODELED-SINK candidates (#5) — calls that match a dangerous shape but
+//      have NO finding at their line, i.e. likely recall blind spots to verify.
+//
+// All of this is informational; it never changes a finding's severity.
+
+// Languages that flow through the Layer-1 IR + Layer-2 taint engine.
+export const IR_TAINT_LANGS = new Set(['js', 'ts', 'py', 'java', 'cs', 'kt', 'go', 'php', 'rb']);
+
+const EXT_TO_LANG = {
+  js: 'js', jsx: 'js', mjs: 'js', cjs: 'js', ts: 'ts', tsx: 'ts',
+  py: 'py', pyw: 'py', java: 'java', go: 'go', rb: 'rb', php: 'php',
+  cs: 'cs', kt: 'kt', kts: 'kt', swift: 'swift', rs: 'rs',
+  c: 'c', h: 'c', cpp: 'cpp', cc: 'cpp', cxx: 'cpp', hpp: 'cpp',
+  sol: 'sol', dart: 'dart', scala: 'scala', m: 'objc',
+};
+
+export function langOfFile(file) {
+  if (typeof file !== 'string') return null;
+  const ext = file.split('.').pop().toLowerCase();
+  return EXT_TO_LANG[ext] || null;
+}
+
+// Given the list of scanned files, report which languages got IR-taint vs.
+// pattern-only analysis, with a per-language file count.
+export function computeAnalysisTiers(fileList) {
+  const counts = {};
+  for (const f of fileList || []) {
+    const l = langOfFile(f);
+    if (!l) continue;
+    counts[l] = (counts[l] || 0) + 1;
+  }
+  const irTaint = {}, patternOnly = {};
+  for (const [lang, n] of Object.entries(counts)) {
+    (IR_TAINT_LANGS.has(lang) ? irTaint : patternOnly)[lang] = n;
+  }
+  return {
+    irTaint,        // { js: 12, py: 4 }
+    patternOnly,    // { rs: 3, sol: 1 }  → flow analysis NOT applied
+    languages: Object.keys(counts).sort(),
+  };
+}
+
+// Dangerous-call shapes worth surfacing when no finding lands on their line.
+// Deliberately conservative + cross-language; this is a "did we miss a sink?"
+// prompt for the user, emitted at info level only.
+const DANGER_TOKENS = [
+  [/\beval\s*\(/, 'eval'],
+  [/\bnew\s+Function\s*\(/, 'Function-constructor'],
+  [/\bvm\.\s*runIn\w+\s*\(/, 'vm.runIn*'],
+  [/\bchild_process\b|\bexecSync?\s*\(|\bspawnSync?\s*\(/, 'child_process'],
+  [/\bdeserialize\s*\(|readObject\s*\(|ObjectInputStream\b/, 'deserialize'],
+  [/\byaml\.\s*load\s*\(|\bsafe_load\b/, 'yaml.load'],
+  [/\bpickle\.\s*loads?\s*\(/, 'pickle.load'],
+  [/\bMarshal\.\s*load\b|\bunserialize\s*\(/, 'unserialize'],
+  [/\bRuntime\b[\s\S]{0,40}\.exec\s*\(|\bProcessBuilder\b/, 'Runtime.exec/ProcessBuilder'],
+  [/\bos\.\s*system\s*\(|\bsubprocess\.\s*(?:call|run|Popen)\s*\(/, 'os.system/subprocess'],
+  [/\.innerHTML\s*=|\bdangerouslySetInnerHTML\b/, 'innerHTML'],
+];
+
+// Scan file contents for danger tokens that have NO finding on their line.
+// findings: array with {file,line}. fc: { path: content }. Returns a capped
+// example list + total count. Lines are 1-based to match finding lines.
+export function countUnmodeledSinkCandidates(fc, findings, opts = {}) {
+  const cap = opts.cap || 12;
+  const covered = new Set();
+  for (const f of findings || []) {
+    if (f && f.file && typeof f.line === 'number') covered.add(`${f.file}:${f.line}`);
+  }
+  const examples = [];
+  let count = 0;
+  for (const [file, content] of Object.entries(fc || {})) {
+    if (typeof content !== 'string') continue;
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+      for (const [re, token] of DANGER_TOKENS) {
+        if (!re.test(lines[i])) continue;
+        if (covered.has(`${file}:${i + 1}`)) continue; // already flagged → modelled
+        count++;
+        if (examples.length < cap) examples.push({ file, line: i + 1, token });
+        break; // one token per line is enough
+      }
+    }
+  }
+  return { count, examples };
+}
+
+// One-line CLI summary of an analysis-coverage object.
+export function summarizeCoverage(meta) {
+  if (!meta) return 'coverage: (none)';
+  const t = meta.analysisTier || {};
+  const irLangs = Object.keys(t.irTaint || {});
+  const patLangs = Object.keys(t.patternOnly || {});
+  const parts = [
+    `scanned=${meta.filesScanned ?? '?'}`,
+    `skipped=${(meta.filesSkipped || 0) + (meta.filesDenseSkipped || 0)}`,
+    `timedOut=${meta.filesTimedOut || 0}`,
+    `ir-taint=[${irLangs.join(',')}]`,
+  ];
+  if (patLangs.length) parts.push(`pattern-only=[${patLangs.join(',')}]`);
+  if (meta.unmodeledSinkCandidates?.count) parts.push(`unmodeled-sink-candidates=${meta.unmodeledSinkCandidates.count}`);
+  return parts.join(' · ');
+}