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

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

@@ -0,0 +1,73 @@
+# 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
+    route_GET__api_users_2["http-route: GET /api/users/2"]
+    route_GET__api_admin_users["http-route: GET /api/admin/users"]
+    route_GET__api_health["http-route: GET /api/health"]
+  end
+  subgraph Application
+  end
+  External --> route_GET__api_users_2
+  External --> route_GET__api_admin_users
+  External --> route_GET__api_health
+```
+
+## Assets
+
+
+## STRIDE threats
+
+### Tampering (148)
+
+- [medium] **dos-sync-io** (CWE-400) at `deploy-platform.js:undefined` — Synchronous Blocking I/O (DoS Risk in Server Context)
+- [low] **mass-assignment** (CWE-915) at `integrity.js:undefined` — Mass Assignment (req.body Direct to Model)
+- [low] **dos-sync-io** (CWE-400) at `agents-memory.js:undefined` — Synchronous Blocking I/O (DoS Risk in Server Context)
+- [low] **dos-sync-io** (CWE-400) at `api-contract.js:undefined` — Synchronous Blocking I/O (DoS Risk in Server Context)
+- [low] **dos-sync-io** (CWE-400) at `auditor-walkthrough.js:undefined` — Synchronous Blocking I/O (DoS Risk in Server Context)
+- [low] **dos-sync-io** (CWE-400) at `auth-posture-import.js:undefined` — Synchronous Blocking I/O (DoS Risk in Server Context)
+- [low] **dos-sync-io** (CWE-400) at `blast-radius.js:undefined` — Synchronous Blocking I/O (DoS Risk in Server Context)
+- [low] **dos-sync-io** (CWE-400) at `calibration-drift.js:undefined` — Synchronous Blocking I/O (DoS Risk in Server Context)
+- [low] **dos-sync-io** (CWE-400) at `calibration.js:undefined` — Synchronous Blocking I/O (DoS Risk in Server Context)
+- [low] **dos-sync-io** (CWE-400) at `compliance-policy.js:undefined` — Synchronous Blocking I/O (DoS Risk in Server Context)
+- [low] **dos-sync-io** (CWE-400) at `cross-repo-memory.js:undefined` — Synchronous Blocking I/O (DoS Risk in Server Context)
+- [low] **dos-sync-io** (CWE-400) at `custom-rules.js:undefined` — Synchronous Blocking I/O (DoS Risk in Server Context)
+- [low] **dos-sync-io** (CWE-400) at `cve-alert-daemon.js:undefined` — Synchronous Blocking I/O (DoS Risk in Server Context)
+- [low] **dos-sync-io** (CWE-400) at `cve-lookup.js:undefined` — Synchronous Blocking I/O (DoS Risk in Server Context)
+- [low] **dos-sync-io** (CWE-400) at `dep-add-guard.js:undefined` — Synchronous Blocking I/O (DoS Risk in Server Context)
+- [low] **dos-sync-io** (CWE-400) at `deterministic.js:undefined` — Synchronous Blocking I/O (DoS Risk in Server Context)
+- [low] **dos-sync-io** (CWE-400) at `epss.js:undefined` — Synchronous Blocking I/O (DoS Risk in Server Context)
+- [low] **dos-sync-io** (CWE-400) at `exploitability-probability.js:undefined` — Synchronous Blocking I/O (DoS Risk in Server Context)
+- [low] **dos-sync-io** (CWE-400) at `feature-flags.js:undefined` — Synchronous Blocking I/O (DoS Risk in Server Context)
+- [low] **dos-sync-io** (CWE-400) at `federated-learning.js:undefined` — Synchronous Blocking I/O (DoS Risk in Server Context)
+- [low] **dos-sync-io** (CWE-400) at `findings-memory.js:undefined` — Synchronous Blocking I/O (DoS Risk in Server Context)
+- [low] **dos-sync-io** (CWE-400) at `fix-history.js:undefined` — Synchronous Blocking I/O (DoS Risk in Server Context)
+- [low] **dos-sync-io** (CWE-400) at `fix-plan.js:undefined` — Synchronous Blocking I/O (DoS Risk in Server Context)
+- [low] **dos-sync-io** (CWE-400) at `fix-style-mirror.js:undefined` — Synchronous Blocking I/O (DoS Risk in Server Context)
+- [low] **dos-sync-io** (CWE-400) at `fix-verify-loop.js:undefined` — Synchronous Blocking I/O (DoS Risk in Server Context)
+- … and 123 more
+
+### Information Disclosure (5)
+
+- [low] **ssrf** (CWE-918) at `attack-playbooks.js:72` — SSRF: explicit reference to cloud instance-metadata endpoint
+- [low] **ssrf** (CWE-918) at `defender-agent.js:41` — SSRF: explicit reference to cloud instance-metadata endpoint
+- [low] **ssrf** (CWE-918) at `flow-narration.js:24` — SSRF: explicit reference to cloud instance-metadata endpoint
+- [low] **pqc-migration** (CWE-327) at `rule-pack-signing.js:187` — Pre-quantum ED25519 (ed25519) — replace with ML-DSA-65 before CRQC arrives
+- [low] **ssrf** (CWE-918) at `verifier.js:55` — SSRF: explicit reference to cloud instance-metadata endpoint
+
+### Elevation of Privilege (5)
+
+- [low] **ssrf** (CWE-918) at `attack-playbooks.js:72` — SSRF: explicit reference to cloud instance-metadata endpoint
+- [low] **prototype-pollution** (CWE-1321) at `adversarial-self-test.js:60` — Prototype Pollution: Direct write to __proto__ / constructor.prototype
+- [low] **ssrf** (CWE-918) at `defender-agent.js:41` — SSRF: explicit reference to cloud instance-metadata endpoint
+- [low] **ssrf** (CWE-918) at `flow-narration.js:24` — SSRF: explicit reference to cloud instance-metadata endpoint
+- [low] **ssrf** (CWE-918) at `verifier.js:55` — SSRF: explicit reference to cloud instance-metadata endpoint
+
+## Attack trees

package/src/posture/auditor-walkthrough.js

@@ -230,7 +230,7 @@ export function renderWalkthrough(fw, evaluation, opts = {}) {
       lines.push('');
     }
     if (ev.status === 'absent' || ev.status === 'partial') {
-      lines.push(`**Remediation:** address the bullet(s) above, then re-run \`/auditor-walkthrough ${fw.id}\` to update this report.`);
+      lines.push(`**Remediation:** address the bullet(s) above, then re-run \`/compliance --walkthrough ${fw.id}\` to update this report.`);
       lines.push('');
     }
   }

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(' · ');
+}

package/src/posture/holdout-eval.js

@@ -23,6 +23,25 @@ import { brierScore, computeBrierOnHeldOut, wilsonInterval } from './calibration
 
 const ECE_BINS_DEFAULT = 10;
 
+// Map a labeled sample to a source language. Prefer an explicit `language`
+// field; otherwise derive it from the `file` extension. Keeps per-language
+// metrics meaningful even for older corpora that only carry a file path.
+const EXT_TO_LANG = {
+  js: 'js', jsx: 'js', mjs: 'js', cjs: 'js', ts: 'ts', tsx: 'ts',
+  py: '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',
+};
+export function languageOf(o) {
+  if (o && typeof o.language === 'string' && o.language) return o.language;
+  if (o && typeof o.file === 'string') {
+    const ext = o.file.split('.').pop().toLowerCase();
+    if (EXT_TO_LANG[ext]) return EXT_TO_LANG[ext];
+  }
+  return 'unknown';
+}
+
 export function parseLabeledJsonl(text) {
   if (typeof text !== 'string' || !text.length) return [];
   const out = [];
@@ -39,6 +58,7 @@ export function parseLabeledJsonl(text) {
       if (p === null || a === null) continue;
       out.push({
         family: typeof o.family === 'string' ? o.family : 'unknown',
+        language: languageOf(o),
         stableId: typeof o.stableId === 'string' ? o.stableId : null,
         predicted: Math.max(0, Math.min(1, p)),
         actual: a,
@@ -98,6 +118,27 @@ export function perFamily(samples) {
   return fams;
 }
 
+// Per-language precision/recall breakdown (roadmap #9). The "perfect
+// multi-language SAST" claim is only defensible with per-language ground
+// truth — a corpus that's 90% JS can hide poor Ruby precision behind a
+// healthy aggregate. Mirrors perFamily, keyed by sample.language, and adds
+// a per-language precision so a regression in one language is visible.
+export function perLanguage(samples) {
+  const langs = {};
+  for (const s of samples) {
+    const l = s.language || 'unknown';
+    if (!langs[l]) langs[l] = { tp: 0, fp: 0, n: 0, precision: 0 };
+    langs[l].n++;
+    if (s.actual === 1) langs[l].tp++;
+    else if (s.actual === 0) langs[l].fp++;
+  }
+  for (const l of Object.keys(langs)) {
+    const { tp, fp } = langs[l];
+    langs[l].precision = (tp + fp) > 0 ? Number((tp / (tp + fp)).toFixed(4)) : 0;
+  }
+  return langs;
+}
+
 // One-shot evaluation: Brier + ECE + per-family TP/FP + overall precision.
 // Returns null only when there's truly no data; never returns a tautological
 // zero.
@@ -124,14 +165,30 @@ export function evaluateHeldOut(samples) {
     precision,
     precisionCi95: ci,
     perFamily: fams,
+    perLanguage: perLanguage(samples),
     notes: [
       ...(samples.length < 100 ? ['n<100: Brier and ECE have wide confidence; treat as directional, not decision-grade.'] : []),
       ...(brierR.brier !== null && brierR.brier > 0.10 ? [`brier=${brierR.brier.toFixed(3)} exceeds PRD target 0.10`] : []),
       ...(ece && ece.ece > 0.05 ? [`ece=${ece.ece.toFixed(3)} exceeds 0.05 calibration target`] : []),
+      // Per-language regression surfacing: a language with enough samples
+      // whose precision trails the aggregate by >0.15 is the failure the
+      // aggregate would otherwise mask.
+      ...Object.entries(perLanguage(samples))
+        .filter(([, m]) => m.n >= 20 && precision - m.precision > 0.15)
+        .map(([lang, m]) => `language '${lang}' precision=${m.precision.toFixed(3)} (n=${m.n}) trails aggregate ${precision.toFixed(3)}`),
     ],
   };
 }
 
+// Per-language dashboard line: one row per language, sorted by sample count.
+export function summarizePerLanguage(result) {
+  if (!result || !result.ok || !result.perLanguage) return 'per-language: no data';
+  return Object.entries(result.perLanguage)
+    .sort((a, b) => b[1].n - a[1].n)
+    .map(([lang, m]) => `${lang}: precision=${m.precision.toFixed(3)} (tp=${m.tp} fp=${m.fp} n=${m.n})`)
+    .join('\n');
+}
+
 // CLI-friendly summary line.
 export function summarize(result) {
   if (!result || !result.ok) return `held-out: ${result?.reason || 'unknown error'}`;

package/src/posture/pr-augment.js

@@ -141,7 +141,7 @@ export function augmentPrBody(scanRoot, opts = {}) {
   lines.push('');
 
   if (!baseline) {
-    lines.push(`> Baseline against \`${baselineRef}\` not found — showing the full current scan as added. Run \`/pr-augment --persist-baseline ${baselineRef}\` from \`${baselineRef}\` to enable diff mode.`);
+    lines.push(`> Baseline against \`${baselineRef}\` not found — showing the full current scan as added. Run \`/compliance --pr --persist-baseline ${baselineRef}\` from \`${baselineRef}\` to enable diff mode.`);
     lines.push('');
   }
 

package/src/posture/router.js

@@ -7,8 +7,8 @@
 // Decision tree (cheap, no scan):
 //   - No prior scan?              → run /scan first
 //   - Prior scan, criticals open? → run /fix --all --critical
-//   - Prior scan, highs open?     → /fix --all --high  OR  /show-findings
-//   - Prior scan, only mediums?   → /report-card
+//   - Prior scan, highs open?     → /fix --all --high  OR  /triage --show
+//   - Prior scan, only mediums?   → /posture --report-card
 //   - All clean?                  → /security-badge   (celebrate + share)
 //   - Pre-deploy intent (--launch flag, or no scan in 7 days)? → /launch-check
 //
@@ -27,7 +27,34 @@ function ageHours(fp) {
   return (Date.now() - fs.statSync(fp).mtimeMs) / 3_600_000;
 }
 
-export function decide({ scanRoot, intent }) {
+// Compare the two most-recent scan-history entries to tell the user whether
+// they're trending safer or more exposed. Returns {} when there isn't enough
+// history to say anything honest. (premortem: never invent a trend from one
+// data point.)
+export function computeScanTrend(scanRoot) {
+  const hist = readJson(path.join(scanRoot, '.agentic-security', 'scan-history.json'));
+  if (!Array.isArray(hist) || hist.length < 2) return {};
+  const cur = hist[hist.length - 1];
+  const prev = hist[hist.length - 2];
+  const sevOf = (e) => (e?.critical || 0) + (e?.high || 0);
+  const delta = sevOf(cur) - sevOf(prev);
+  let trend = 'flat';
+  if (delta < 0) trend = 'improving';
+  else if (delta > 0) trend = 'regressing';
+  const n = Math.abs(delta);
+  const whatChanged =
+    trend === 'improving' ? `${n} fewer critical+high than last scan — keep going.`
+    : trend === 'regressing' ? `${n} more critical+high than last scan — new risk crept in.`
+    : 'No change in critical+high since last scan.';
+  return { trend, whatChanged };
+}
+
+export function decide(opts) {
+  const base = baseDecision(opts);
+  return { ...base, ...computeScanTrend(opts.scanRoot) };
+}
+
+function baseDecision({ scanRoot, intent }) {
   const stateDir = path.join(scanRoot, '.agentic-security');
   const lastScan = readJson(path.join(stateDir, 'last-scan.json'));
   const scanAge = ageHours(path.join(stateDir, 'last-scan.json'));
@@ -71,7 +98,7 @@ export function decide({ scanRoot, intent }) {
   if (sev.high > 0) {
     return {
       action: 'review-high',
-      command: 'claude /show-findings',
+      command: 'claude /triage --show',
       reason: `${sev.high} high finding(s). Review and triage before fixing.`,
     };
   }
@@ -85,7 +112,7 @@ export function decide({ scanRoot, intent }) {
   if (sev.medium > 0) {
     return {
       action: 'report-card',
-      command: 'claude /report-card',
+      command: 'claude /posture --report-card',
       reason: `Only mediums remain. Get a letter-grade snapshot and pick what's worth fixing.`,
     };
   }
@@ -102,8 +129,11 @@ export function explain(decision) {
     ``,
     `  Action:  ${decision.action}`,
     `  Why:     ${decision.reason}`,
-    `  Run:     ${decision.command}`,
-    ``,
   ];
+  if (decision.trend) {
+    const arrow = decision.trend === 'improving' ? '↓' : decision.trend === 'regressing' ? '↑' : '→';
+    lines.push(`  Trend:   ${arrow} ${decision.whatChanged}`);
+  }
+  lines.push(`  Run:     ${decision.command}`, ``);
   return lines.join('\n');
 }

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

@@ -0,0 +1,26 @@
+# Data Protection Impact Assessment (DPIA)
+
+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.
+
+## Data classes identified
+
+## Privacy-related findings
+
+| Severity | File:Line | Class → Sink | Description |
+|---|---|---|---|
+
+## Regulatory framework mapping
+
+- **GDPR Art. 35** — DPIA required when processing is likely to result in high risk to data subjects.
+- **CCPA §1798.130** — Notice + access rights for collected personal information.
+
+## Reviewer checklist
+
+- [ ] Confirm each PII field's collection has a documented lawful basis
+- [ ] Confirm retention period for each class is documented
+- [ ] Confirm DSAR (data subject access request) workflow exists
+- [ ] Confirm encryption at rest + in transit for each class
+- [ ] Confirm logging of PII access for audit (where applicable)

package/src/report/.agentic-security/sbom-history/7d45b5e03804aac084b4a2b4dc8c6f10107d2005.json

@@ -0,0 +1,6 @@
+{
+  "sha": "7d45b5e03804aac084b4a2b4dc8c6f10107d2005",
+  "ts": "2026-05-30T05:08:01.641Z",
+  "componentCount": 0,
+  "components": []
+}

package/src/report/.agentic-security/sbom-history/f94be839aa6a1011f53da016416a561698b8f338.json

@@ -0,0 +1,6 @@
+{
+  "sha": "f94be839aa6a1011f53da016416a561698b8f338",
+  "ts": "2026-05-31T16:06:10.902Z",
+  "componentCount": 0,
+  "components": []
+}

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

@@ -0,0 +1,7 @@
+{
+  "entities": [],
+  "boundaries": [],
+  "assets": [],
+  "threats": [],
+  "attackTrees": []
+}

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

@@ -0,0 +1,22 @@
+# 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
+
+## Attack trees

package/src/report/index.js

@@ -973,7 +973,7 @@ export function toShipVerdict(scan, options = {}) {
   // CONFIRMED: surface validator-confirmed criticals as a trust signal —
   // distinguishes "tool said so" from "tool built a PoC and it ran."
   if (confirmedCount > 0) {
-    lines.push(c(`  ✓  ${confirmedCount} CONFIRMED (PoC built by /validate-findings)`, '\x1b[1;32m'));
+    lines.push(c(`  ✓  ${confirmedCount} CONFIRMED (PoC built by /triage --validate)`, '\x1b[1;32m'));
   }
   lines.push('');
 
@@ -1001,6 +1001,23 @@ export function toShipVerdict(scan, options = {}) {
   } else if (advisoryCount > 0) {
     lines.push(c(`  ${advisoryCount} advisory item${advisoryCount === 1 ? '' : 's'} — run /security-scan-all --firehose to see them.`, DIM));
   }
+  // Coverage-honesty line (#5/#6): show the scan's blind spots — which
+  // languages got flow analysis vs pattern-only, what was skipped, and how
+  // many dangerous-looking calls had no finding. One concise line, not bloat.
+  const _covMeta = scan._scanMeta;
+  if (_covMeta && _covMeta.analysisTier) {
+    const t = _covMeta.analysisTier;
+    const pat = Object.keys(t.patternOnly || {});
+    const segs = [`${_covMeta.filesScanned ?? '?'} files`];
+    const ir = Object.keys(t.irTaint || {});
+    if (ir.length) segs.push(`flow=[${ir.join(',')}]`);
+    if (pat.length) segs.push(`pattern-only=[${pat.join(',')}]`);
+    const skipped = (_covMeta.filesSkipped || 0) + (_covMeta.filesDenseSkipped || 0);
+    if (skipped) segs.push(`${skipped} skipped`);
+    if (_covMeta.unmodeledSinkCandidates?.count) segs.push(`${_covMeta.unmodeledSinkCandidates.count} unmodeled-sink candidate${_covMeta.unmodeledSinkCandidates.count === 1 ? '' : 's'}`);
+    lines.push('');
+    lines.push(c('  Coverage: ' + segs.join(' · '), DIM));
+  }
   lines.push('');
   lines.push(c('  🛡  agentic-security · created by ClearCapabilities.Com', DIM));
   return lines.join('\n');

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

@@ -0,0 +1,26 @@
+# Data Protection Impact Assessment (DPIA)
+
+Generated by agentic-security scanner on 2026-06-01.
+
+This is an automated DPIA scaffold derived from static analysis.
+It must be reviewed and completed by a privacy officer before use.
+
+## Data classes identified
+
+## Privacy-related findings
+
+| Severity | File:Line | Class → Sink | Description |
+|---|---|---|---|
+
+## Regulatory framework mapping
+
+- **GDPR Art. 35** — DPIA required when processing is likely to result in high risk to data subjects.
+- **CCPA §1798.130** — Notice + access rights for collected personal information.
+
+## Reviewer checklist
+
+- [ ] Confirm each PII field's collection has a documented lawful basis
+- [ ] Confirm retention period for each class is documented
+- [ ] Confirm DSAR (data subject access request) workflow exists
+- [ ] Confirm encryption at rest + in transit for each class
+- [ ] Confirm logging of PII access for audit (where applicable)

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

@@ -0,0 +1,65 @@
+{
+  "generatedAt": "2026-06-01T03:15:31.819Z",
+  "summary": {
+    "total": 1,
+    "hndlCritical": 1,
+    "standard": 0,
+    "filesAffected": 1,
+    "primitivesNeeded": [
+      "ML-KEM-768"
+    ]
+  },
+  "milestones": [
+    {
+      "id": "M1",
+      "title": "Inventory & policy",
+      "target": "90 days",
+      "owner": "security",
+      "items": [
+        "Confirm scanner findings against design docs",
+        "Adopt PQC migration policy (CNSA 2.0 / NIST IR 8547 alignment)",
+        "Establish KMS support for hybrid keys"
+      ]
+    },
+    {
+      "id": "M2",
+      "title": "HNDL-critical paths to PQ-hybrid",
+      "target": "180 days",
+      "owner": "platform",
+      "items": [
+        {
+          "finding": "pqc-rsa-encrypt:post-quantum-crypto.js:136",
+          "file": "post-quantum-crypto.js",
+          "line": 136,
+          "replacement": "X25519+ML-KEM-768 (CNSA 2.0 transitional)"
+        }
+      ]
+    },
+    {
+      "id": "M3",
+      "title": "Standard signing/KEX migration",
+      "target": "12 months",
+      "owner": "platform",
+      "items": []
+    },
+    {
+      "id": "M4",
+      "title": "Deprecate classical primitives",
+      "target": "24 months",
+      "owner": "security",
+      "items": [
+        "Remove dual-stack libraries once peers are PQ-capable",
+        "Rotate root CA / long-lived signing keys to ML-DSA"
+      ]
+    }
+  ],
+  "perFile": {
+    "post-quantum-crypto.js": {
+      "count": 1,
+      "subfamilies": [
+        "pqc-rsa-encrypt"
+      ],
+      "hndlCritical": true
+    }
+  }
+}