praxis-sec 1.0.0

package/cli/utils/security-memory.js

@@ -0,0 +1,296 @@
+/**
+ * Security Memory
+ * ================
+ *
+ * Hermes-inspired persistent memory for false-positive learning.
+ *
+ * After deep analysis confirms a finding is a false-positive, the verdict is
+ * written to `.praxis/memory.json`. On the next scan, the SecurityMemory
+ * filter runs before scoring and suppresses any finding whose (rule + file +
+ * matched-snippet hash) appears in memory — avoiding the same LLM call twice.
+ *
+ * Memory entries are per-repo (stored in `.praxis/` inside the project
+ * root), so suppressions don't bleed across unrelated projects.
+ *
+ * USAGE:
+ *   import { SecurityMemory } from '../utils/security-memory.js';
+ *
+ *   const memory = new SecurityMemory(rootPath);
+ *
+ *   // After deep analysis — auto-learn false positives
+ *   memory.learnFromAnalysis(findings);
+ *
+ *   // Filter findings against memory before scoring
+ *   const { kept, suppressed } = memory.filter(findings);
+ *
+ *   // Manual suppression (from `praxis memory add`)
+ *   memory.suppress(finding, 'Not reachable from user input');
+ *
+ *   // CLI commands
+ *   memory.list()   → all suppressed entries
+ *   memory.forget(id) → remove one entry
+ *   memory.clear()  → wipe all entries
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { createHash } from 'crypto';
+
+const MEMORY_DIR  = '.praxis';
+const MEMORY_FILE = 'memory.json';
+
+/** How many chars of the matched snippet to hash (stable across reformatting) */
+const SNIPPET_HASH_LEN = 120;
+
+export class SecurityMemory {
+  constructor(rootPath) {
+    this.rootPath   = rootPath;
+    this.memoryDir  = path.join(rootPath, MEMORY_DIR);
+    this.memoryPath = path.join(this.memoryDir, MEMORY_FILE);
+    this._data      = null; // lazy-loaded
+  }
+
+  // ===========================================================================
+  // PERSISTENCE
+  // ===========================================================================
+
+  _load() {
+    if (this._data) return this._data;
+
+    try {
+      if (fs.existsSync(this.memoryPath)) {
+        this._data = JSON.parse(fs.readFileSync(this.memoryPath, 'utf-8'));
+      }
+    } catch { /* corrupt file — start fresh */ }
+
+    if (!this._data || typeof this._data !== 'object') {
+      this._data = { version: 1, entries: [] };
+    }
+    if (!Array.isArray(this._data.entries)) {
+      this._data.entries = [];
+    }
+
+    return this._data;
+  }
+
+  _save() {
+    try {
+      if (!fs.existsSync(this.memoryDir)) {
+        fs.mkdirSync(this.memoryDir, { recursive: true });
+      }
+      fs.writeFileSync(this.memoryPath, JSON.stringify(this._data, null, 2), 'utf-8');
+    } catch { /* non-fatal */ }
+  }
+
+  // ===========================================================================
+  // KEY GENERATION
+  // ===========================================================================
+
+  /**
+   * Generate a stable key for a finding.
+   * Key = SHA-256(rule + file-basename + first N chars of matched).
+   * Deliberately excludes line number so the suppression survives minor refactors.
+   */
+  static keyOf(finding) {
+    const rule     = finding.rule    || '';
+    const file     = finding.file    ? path.basename(finding.file) : '';
+    const snippet  = (finding.matched || finding.title || '').slice(0, SNIPPET_HASH_LEN);
+    return createHash('sha256').update(`${rule}::${file}::${snippet}`).digest('hex').slice(0, 16);
+  }
+
+  // ===========================================================================
+  // CORE API
+  // ===========================================================================
+
+  /**
+   * Learn from deep analysis results.
+   * Any finding with exploitability === 'false_positive' is auto-added to memory.
+   *
+   * @param {object[]} findings — findings array (with deepAnalysis attached)
+   * @returns {number} — count of new entries added
+   */
+  learnFromAnalysis(findings) {
+    const data = this._load();
+    const existingKeys = new Set(data.entries.map(e => e.key));
+    let added = 0;
+
+    for (const f of findings) {
+      if (f.deepAnalysis?.exploitability !== 'false_positive') continue;
+
+      const key = SecurityMemory.keyOf(f);
+      if (existingKeys.has(key)) continue;
+
+      data.entries.push({
+        key,
+        rule:          f.rule,
+        file:          f.file ? path.basename(f.file) : '',
+        title:         f.title,
+        severity:      f.severity,
+        reason:        f.deepAnalysis.reasoning || 'Auto-detected false positive by deep analysis',
+        source:        'deep-analysis',
+        suppressedAt:  new Date().toISOString(),
+      });
+
+      existingKeys.add(key);
+      added++;
+    }
+
+    if (added > 0) this._save();
+    return added;
+  }
+
+  /**
+   * Manually suppress a finding with a reason.
+   *
+   * @param {object} finding
+   * @param {string} reason
+   * @returns {string} — the key added
+   */
+  suppress(finding, reason = '') {
+    const data = this._load();
+    const key  = SecurityMemory.keyOf(finding);
+
+    if (data.entries.some(e => e.key === key)) {
+      return key; // already suppressed
+    }
+
+    data.entries.push({
+      key,
+      rule:         finding.rule,
+      file:         finding.file ? path.basename(finding.file) : '',
+      title:        finding.title,
+      severity:     finding.severity,
+      reason:       reason || 'Manually suppressed',
+      source:       'manual',
+      suppressedAt: new Date().toISOString(),
+    });
+
+    this._save();
+    return key;
+  }
+
+  /**
+   * Filter findings against memory.
+   * Returns { kept, suppressed } — suppressed findings get a .memorySuppressed flag.
+   *
+   * @param {object[]} findings
+   * @returns {{ kept: object[], suppressed: object[], suppressedCount: number }}
+   */
+  filter(findings) {
+    const data  = this._load();
+    if (data.entries.length === 0) {
+      return { kept: findings, suppressed: [], suppressedCount: 0 };
+    }
+
+    const keySet = new Set(data.entries.map(e => e.key));
+    const kept       = [];
+    const suppressed = [];
+
+    for (const f of findings) {
+      const key    = SecurityMemory.keyOf(f);
+      const entry  = data.entries.find(e => e.key === key);
+      if (entry) {
+        suppressed.push({ ...f, memorySuppressed: true, suppressionReason: entry.reason });
+      } else {
+        kept.push(f);
+      }
+    }
+
+    return { kept, suppressed, suppressedCount: suppressed.length };
+  }
+
+  /**
+   * Remove a single entry by key.
+   */
+  forget(key) {
+    const data = this._load();
+    const before = data.entries.length;
+    data.entries = data.entries.filter(e => e.key !== key);
+    const removed = before - data.entries.length;
+    if (removed > 0) this._save();
+    return removed;
+  }
+
+  /**
+   * Wipe all memory entries.
+   */
+  clear() {
+    this._data = { version: 1, entries: [] };
+    this._save();
+  }
+
+  /**
+   * Return all entries.
+   */
+  list() {
+    return this._load().entries;
+  }
+
+  /**
+   * Count of suppressed entries.
+   */
+  get size() {
+    return this._load().entries.length;
+  }
+}
+
+// =============================================================================
+// CLI COMMAND  (praxis memory)
+// =============================================================================
+
+import chalk from 'chalk';
+import * as output from './output.js';
+
+export async function memoryCommand(subcommand, args = [], options = {}) {
+  const rootPath = path.resolve(options.path || '.');
+  const memory   = new SecurityMemory(rootPath);
+
+  switch (subcommand) {
+    case 'list':
+    case undefined: {
+      const entries = memory.list();
+      if (entries.length === 0) {
+        console.log('\n  No suppressed findings in memory.\n');
+        return;
+      }
+      console.log(`\n  ${chalk.cyan.bold('Security Memory')} — ${entries.length} suppressed finding(s)\n`);
+      for (const e of entries) {
+        const sev = e.severity === 'critical' ? chalk.red.bold(e.severity)
+          : e.severity === 'high'     ? chalk.yellow(e.severity)
+          : chalk.gray(e.severity);
+        console.log(`  ${chalk.gray(e.key)}  ${sev}  ${chalk.white(e.rule)}`);
+        console.log(`    ${chalk.gray('File:')} ${e.file}  ${chalk.gray('Source:')} ${e.source}  ${chalk.gray('Date:')} ${e.suppressedAt.slice(0, 10)}`);
+        console.log(`    ${chalk.gray('Reason:')} ${e.reason}`);
+        console.log();
+      }
+      break;
+    }
+
+    case 'forget': {
+      const key = args[0];
+      if (!key) {
+        output.error('Usage: praxis memory forget <key>');
+        process.exit(1);
+      }
+      const removed = memory.forget(key);
+      if (removed) {
+        console.log(chalk.green(`  Removed memory entry: ${key}`));
+      } else {
+        console.log(chalk.yellow(`  Key not found in memory: ${key}`));
+      }
+      break;
+    }
+
+    case 'clear': {
+      const before = memory.size;
+      memory.clear();
+      console.log(chalk.green(`  Cleared ${before} memory entry/entries.`));
+      break;
+    }
+
+    default:
+      output.error(`Unknown memory subcommand: ${subcommand}`);
+      console.log('  Usage: praxis memory [list|forget <key>|clear]');
+      process.exit(1);
+  }
+}

package/cli/utils/standards/atlas-knowledge.js

@@ -0,0 +1,87 @@
+/**
+ * MITRE ATLAS knowledge lookup — vendored enrichment data.
+ *
+ * Loads cli/data/atlas-knowledge.json (Apache-2.0, The MITRE Corporation,
+ * snapshot 2026-04). Provides hydrated technique details for reports:
+ * technique name/description/URL, parent tactics, mitigations (with
+ * parent-technique fallback), and real-world case studies.
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const DATA_PATH = path.join(__dirname, '..', '..', 'data', 'atlas-knowledge.json');
+
+let _cache = null;
+
+function load() {
+  if (_cache) return _cache;
+  try {
+    _cache = JSON.parse(fs.readFileSync(DATA_PATH, 'utf-8'));
+  } catch {
+    _cache = { entities: {}, snapshot: 'unknown' };
+  }
+  return _cache;
+}
+
+export function atlasSnapshot() {
+  return load().snapshot || 'unknown';
+}
+
+export function atlasAttribution() {
+  return load()._attribution || null;
+}
+
+export function isKnownTechnique(id) {
+  const e = load().entities[id];
+  return Boolean(e && e.entity === 'technique');
+}
+
+/**
+ * Hydrate a technique with readable references. Mitigations fall back to the
+ * parent technique when the (sub-)technique itself carries none.
+ */
+export function getTechniqueDetails(id) {
+  const data = load();
+  const entity = data.entities[id];
+  if (!entity) return null;
+
+  const out = {
+    id,
+    name: entity.name,
+    description: entity.description,
+    url: entity.url || `https://atlas.mitre.org/techniques/${id}`,
+    tactics: [],
+    mitigations: [],
+    caseStudies: [],
+  };
+
+  for (const t of entity.parentTactics || []) {
+    const tactic = data.entities[t];
+    if (tactic) out.tactics.push({ id: t, name: tactic.name, url: tactic.url });
+  }
+
+  let mitigationIds = entity.parentMitigations || [];
+  if (mitigationIds.length === 0 && (entity.parentTechniques || []).length > 0) {
+    const parent = data.entities[entity.parentTechniques[0]];
+    mitigationIds = parent?.parentMitigations || [];
+  }
+  for (const m of mitigationIds) {
+    const mit = data.entities[m];
+    if (mit) out.mitigations.push({ id: m, name: mit.name, url: mit.url });
+  }
+
+  for (const c of entity.parentCaseStudies || []) {
+    const cs = data.entities[c];
+    if (cs) out.caseStudies.push({ id: c, name: cs.name, url: cs.url });
+  }
+
+  return out;
+}
+
+export function listTechniques() {
+  const data = load();
+  return Object.values(data.entities).filter(e => e.entity === 'technique');
+}

package/cli/utils/standards/index.js

@@ -0,0 +1,127 @@
+/**
+ * Standards registry.
+ *
+ * Each standard is a self-contained ESM module exporting:
+ *   name, version, title, description, url, controls, mapFinding(finding)
+ *
+ * `mapFindingToStandards(finding)` returns:
+ *   { 'owasp-llm': ['LLM01'], 'mitre-atlas': ['AML.T0051'], ... }
+ *
+ * Adding a standard: drop a file under ./sources, register in ALL_STANDARDS.
+ */
+
+import * as owaspLlm from './sources/owasp-llm.js';
+import * as mitreAtlas from './sources/mitre-atlas.js';
+import * as nistAi6001 from './sources/nist-ai-600-1.js';
+import * as avid from './sources/avid.js';
+import * as owaspMl from './sources/owasp-ml.js';
+import * as euAiAct from './sources/eu-ai-act.js';
+import * as iso42001 from './sources/iso-42001.js';
+import * as googleSaif from './sources/google-saif.js';
+
+export const ALL_STANDARDS = [
+  owaspLlm,
+  mitreAtlas,
+  nistAi6001,
+  avid,
+  owaspMl,
+  euAiAct,
+  iso42001,
+  googleSaif,
+];
+
+export function listStandards() {
+  return ALL_STANDARDS.map(s => ({
+    name: s.name,
+    version: s.version,
+    title: s.title,
+    description: s.description,
+    url: s.url,
+    controlCount: (s.controls || []).length,
+  }));
+}
+
+export function getStandard(name) {
+  return ALL_STANDARDS.find(s => s.name === name) || null;
+}
+
+/**
+ * Tag a single finding with all standard control IDs it maps to.
+ * @returns {Object<string, string[]>} keyed by standard name; empty arrays omitted.
+ */
+export function mapFindingToStandards(finding) {
+  const out = {};
+  for (const s of ALL_STANDARDS) {
+    let ids;
+    try {
+      ids = s.mapFinding(finding) || [];
+    } catch {
+      ids = [];
+    }
+    if (ids.length > 0) out[s.name] = ids;
+  }
+  return out;
+}
+
+/**
+ * Aggregate coverage across a finding set.
+ * Returns:
+ *   {
+ *     [standardName]: {
+ *       title, version, totalControls, flaggedControls, coverage,
+ *       controls: [{ id, title, findingCount, status }]
+ *     }
+ *   }
+ */
+export function getStandardsSummary(findings = []) {
+  const summary = {};
+
+  for (const s of ALL_STANDARDS) {
+    summary[s.name] = {
+      name: s.name,
+      title: s.title,
+      version: s.version,
+      url: s.url,
+      totalControls: (s.controls || []).length,
+      flaggedControls: 0,
+      coverage: `0/${(s.controls || []).length}`,
+      controls: (s.controls || []).map(c => ({ ...c, findingCount: 0, status: 'clear' })),
+    };
+  }
+
+  for (const f of findings) {
+    const tagged = mapFindingToStandards(f);
+    for (const [stdName, ids] of Object.entries(tagged)) {
+      const std = summary[stdName];
+      if (!std) continue;
+      for (const id of ids) {
+        const ctrl = std.controls.find(c => c.id === id);
+        if (ctrl) {
+          ctrl.findingCount += 1;
+          ctrl.status = 'flagged';
+        }
+      }
+    }
+  }
+
+  for (const std of Object.values(summary)) {
+    std.flaggedControls = std.controls.filter(c => c.findingCount > 0).length;
+    std.coverage = `${std.flaggedControls}/${std.totalControls}`;
+  }
+
+  return summary;
+}
+
+/**
+ * Filter a finding list to only those tagged with a given standard (and
+ * optionally a specific control within that standard).
+ */
+export function filterFindingsByStandard(findings, standardName, controlId = null) {
+  return findings.filter(f => {
+    const tagged = f.standards || mapFindingToStandards(f);
+    const ids = tagged[standardName];
+    if (!ids || ids.length === 0) return false;
+    if (controlId) return ids.includes(controlId);
+    return true;
+  });
+}

package/cli/utils/standards/sources/avid.js

@@ -0,0 +1,45 @@
+/**
+ * AVID — AI Vulnerability Database taxonomy.
+ * https://avidml.org/
+ *
+ * AVID classifies vulnerabilities under three top-level categories:
+ *   S — Security    P — Performance    E — Ethics
+ */
+
+export const name = 'avid';
+export const version = '2024';
+export const title = 'AI Vulnerability Database (AVID) Taxonomy';
+export const description = 'Open taxonomy for AI failure modes across security, performance, and ethics.';
+export const url = 'https://avidml.org/';
+
+export const controls = [
+  { id: 'S0100', title: 'Software Vulnerability',          description: 'Classical software flaws in AI systems (injection, IDOR, etc.).' },
+  { id: 'S0200', title: 'Supply Chain Compromise',         description: 'Tampered model, dataset, or upstream package.' },
+  { id: 'S0301', title: 'Information Leakage',             description: 'Model leaks training data, secrets, or system prompts.' },
+  { id: 'S0400', title: 'Model Bypass / Evasion',          description: 'Crafted inputs bypass model safety or filters.' },
+  { id: 'S0500', title: 'Exfiltration via Model Outputs',  description: 'Adversary uses model channel to exfiltrate data.' },
+  { id: 'P0201', title: 'Robustness — Adversarial',        description: 'Model degrades under adversarial / OOD inputs.' },
+  { id: 'P0204', title: 'Data Drift',                      description: 'Inputs diverge from training distribution.' },
+  { id: 'P0301', title: 'Hallucination / Confabulation',   description: 'Confidently incorrect outputs.' },
+  { id: 'E0101', title: 'Group Fairness',                  description: 'Outputs disadvantage protected groups.' },
+];
+
+export function mapFinding(finding) {
+  const ids = new Set();
+  const cwe = finding.cwe || '';
+  const owasp = finding.owasp || '';
+  const cat = finding.category || '';
+  const rule = (finding.rule || '').toLowerCase();
+  const title = (finding.title || '').toLowerCase();
+
+  if (cat === 'injection' || cat === 'auth' || cat === 'config' || /^CWE-/.test(cwe)) ids.add('S0100');
+  if (cat === 'supply-chain' || cat === 'deps' || owasp === 'ASI04') ids.add('S0200');
+  if (cat === 'secrets' || cat === 'git-history' || cwe === 'CWE-200' || cwe === 'CWE-312' || owasp === 'ASI06') ids.add('S0301');
+  if (/jailbreak|prompt.?inject|bypass/.test(rule + title) || owasp === 'ASI01') ids.add('S0400');
+  if (owasp === 'ASI05' || /poison|tamper|memory/.test(rule + title)) ids.add('P0201');
+  if (/retrieval|vector.?store|rag\b|embedding/.test(rule + title)) ids.add('S0500');
+  if (/halluc|confabul|misinform/.test(rule + title) || owasp === 'ASI10') ids.add('P0301');
+  if (/bias|fairness|discriminat/.test(rule + title)) ids.add('E0101');
+
+  return [...ids];
+}

package/cli/utils/standards/sources/eu-ai-act.js

@@ -0,0 +1,89 @@
+/**
+ * EU AI Act (Regulation (EU) 2024/1689).
+ * https://eur-lex.europa.eu/eli/reg/2024/1689/oj
+ *
+ * Control text authored by Praxis from the public text of the Regulation
+ * (EUR-Lex). For static analysis we tag findings against the cybersecurity,
+ * transparency, data-governance, oversight, and post-market monitoring
+ * obligations most relevant to code-level signals.
+ */
+
+export const name = 'eu-ai-act';
+export const version = '2024/1689';
+export const title = 'EU AI Act';
+export const description = 'Regulation laying down harmonised rules on artificial intelligence in the EU.';
+export const url = 'https://eur-lex.europa.eu/eli/reg/2024/1689/oj';
+
+export const controls = [
+  { id: 'Art.5',   title: 'Prohibited AI practices',                  description: 'Subliminal/manipulative techniques, exploitative, social scoring, and similar prohibited uses (Art. 5(1)(a)-(h)).' },
+  { id: 'Art.9',   title: 'Risk management system',                   description: 'Continuous risk management for high-risk systems covering identification, analysis, mitigation, and testing (Art. 9).' },
+  { id: 'Art.10',  title: 'Data and data governance',                 description: 'Training/validation data must meet quality, integrity, and relevance criteria; governance for bias and gaps (Art. 10).' },
+  { id: 'Art.11',  title: 'Technical documentation',                  description: 'Documentation demonstrating compliance with high-risk requirements before and during market placement (Art. 11, Annex IV).' },
+  { id: 'Art.12',  title: 'Record keeping / logging',                 description: 'Automatic logging of system events sufficient for post-market traceability and oversight (Art. 12).' },
+  { id: 'Art.13',  title: 'Transparency to deployers',                description: 'High-risk AI must be designed for transparent operation; instructions for use (Art. 13).' },
+  { id: 'Art.14',  title: 'Human oversight',                          description: 'Effective oversight by natural persons during AI use; intervention and override capability (Art. 14).' },
+  { id: 'Art.15',  title: 'Accuracy, robustness and cybersecurity',   description: 'AI systems must be resilient against errors, faults, and adversarial manipulation (Art. 15).' },
+  { id: 'Art.17',  title: 'Quality management system',                description: 'Provider QMS covering design control, verification, data management, and post-market monitoring (Art. 17).' },
+  { id: 'Art.25',  title: 'Responsibilities along the value chain',   description: 'Obligations distributed among providers, deployers, importers, and distributors (Art. 25).' },
+  { id: 'Art.26',  title: 'Obligations of deployers', detectable: false,                 description: 'Deployers must use high-risk systems per instructions, ensure input relevance, and monitor operation (Art. 26).' },
+  { id: 'Art.27',  title: 'Fundamental rights impact assessment', detectable: false,     description: 'Deployers of high-risk systems assess impact on fundamental rights before deployment (Art. 27).' },
+  { id: 'Art.49',  title: 'Registration', detectable: false,                             description: 'High-risk systems registered in the EU database before market placement (Art. 49).' },
+  { id: 'Art.50',  title: 'Transparency for GenAI / chatbots',        description: 'Disclose AI interaction; mark synthetic and deepfake content (Art. 50).' },
+  { id: 'Art.53',  title: 'GPAI provider obligations',                description: 'General-purpose AI model documentation, copyright policy, training-data summary (Art. 53).' },
+  { id: 'Art.55',  title: 'GPAI systemic-risk obligations',           description: 'Adversarial testing, incident reporting, and cybersecurity for systemic-risk models (Art. 55).' },
+  { id: 'Art.72',  title: 'Post-market monitoring',                   description: 'Continuous monitoring of deployed AI for new risks; corrective action and incident reporting (Art. 72).' },
+  { id: 'Art.73',  title: 'Reporting of serious incidents',           description: 'Serious incidents reported to market surveillance authorities, with investigations (Art. 73).' },
+];
+
+export function mapFinding(finding) {
+  const ids = new Set();
+  const cwe = finding.cwe || '';
+  const owasp = finding.owasp || '';
+  const cat = finding.category || '';
+  const rule = (finding.rule || '').toLowerCase();
+  const title = (finding.title || '').toLowerCase();
+  const text = rule + title;
+
+  // Art. 5 — prohibited-practice adjacent signals (deception, manipulation, social scoring)
+  if (/social.?scor|subliminal|manipulat|deceptiv|emotion.?recogn/.test(text)) ids.add('Art.5');
+
+  // Art. 9/10 — data governance, model/data/context poisoning, RAG content
+  if (/poison|embedding|rag\b|retrieval|memory/.test(text)) {
+    ids.add('Art.9'); ids.add('Art.10');
+  }
+
+  // Art. 11/17 — technical documentation / QMS evidence gaps
+  if (/no.?model.?card|missing.?documentation|no.?readme/.test(text)) ids.add('Art.11');
+  if (/unpinned|attestation|unsigned|integrity.?hash/.test(text)) ids.add('Art.17');
+
+  // Art. 12 — logging / record keeping
+  if (/no.?logging|no.?observability|telemetry|no.?audit.?log/.test(text)) ids.add('Art.12');
+
+  // Art. 13 — transparency / opaqueness / system prompt leakage
+  if (/system.?prompt.?leak|opaqu|disclos|transparen/.test(text)) ids.add('Art.13');
+
+  // Art. 14 — human oversight / auto-approval / excessive agency
+  if (owasp === 'ASI08' || /human.?oversight|auto.?accept|yolo|excessive.?agency|no.?approval|permissionless/.test(text)) ids.add('Art.14');
+
+  // Art. 15 — accuracy/robustness/cybersecurity (all technical vuln classes)
+  if (cat === 'injection' || cat === 'supply-chain' || cat === 'auth' || cat === 'config'
+      || /prompt.?inject|jailbreak/.test(text) || owasp === 'ASI01' || owasp === 'ASI04'
+      || cwe === 'CWE-94' || cwe === 'CWE-78' || cwe === 'CWE-502') ids.add('Art.15');
+
+  // Art. 25/26 — value chain, third-party components, deployer obligations
+  if (/third.?party|supplier|vendor|deployer/.test(text) && (cat === 'supply-chain' || /mcp/.test(text))) ids.add('Art.25');
+
+  // Art. 50 — GenAI/chatbot disclosure, synthetic content
+  if (/chatbot|user.?facing|disclos|synthetic|deepfake/.test(text)) ids.add('Art.50');
+
+  // Art. 53/55 — GPAI obligations, model provenance, systemic risk
+  if (cat === 'supply-chain' && /(model|dataset|gpai|foundation|training.?data)/.test(text)) ids.add('Art.53');
+  if (owasp === 'ASI10' || /systemic.?risk|capabilit|frontier/.test(text)) ids.add('Art.55');
+
+  // Art. 72/73 — post-market monitoring / incident reporting / MCP runtime risk
+  if (/mcp|tool.?poison/.test(text) || owasp === 'ASI06' || /post.?market|incident.?report|no.?monitoring/.test(text)) {
+    ids.add('Art.72'); ids.add('Art.73');
+  }
+
+  return [...ids];
+}

package/cli/utils/standards/sources/google-saif.js

@@ -0,0 +1,39 @@
+/**
+ * Google Secure AI Framework (SAIF).
+ * https://safety.google/cybersecurity-advancements/saif/
+ *
+ * Six core elements for securing AI systems end-to-end.
+ */
+
+export const name = 'google-saif';
+export const version = '1.0';
+export const title = 'Google Secure AI Framework (SAIF)';
+export const description = 'Conceptual framework for securing AI systems across foundations, detection, defense, controls, adaptation, and context.';
+export const url = 'https://safety.google/cybersecurity-advancements/saif/';
+
+export const controls = [
+  { id: 'SAIF-1', title: 'Expand strong security foundations to the AI ecosystem', description: 'Apply secure-by-default infra and IAM to AI workloads.' },
+  { id: 'SAIF-2', title: 'Extend detection and response to AI threats',            description: 'Bring AI into the SOC: monitor model I/O, prompt anomalies.' },
+  { id: 'SAIF-3', title: 'Automate defenses to keep pace with new threats',        description: 'Automate scanning, patching, and adversarial testing.' },
+  { id: 'SAIF-4', title: 'Harmonize platform-level controls across AI systems',    description: 'Consistent controls across model serving, RAG, and agents.' },
+  { id: 'SAIF-5', title: 'Adapt controls and create faster feedback loops',        description: 'Continuously tune mitigations using deployment signals.' },
+  { id: 'SAIF-6', title: 'Contextualize AI risks in surrounding business processes', description: 'Tie AI risk to actual use case, data, and business impact.' },
+];
+
+export function mapFinding(finding) {
+  const ids = new Set();
+  const cwe = finding.cwe || '';
+  const owasp = finding.owasp || '';
+  const cat = finding.category || '';
+  const rule = (finding.rule || '').toLowerCase();
+  const title = (finding.title || '').toLowerCase();
+
+  if (cat === 'auth' || cat === 'config' || cat === 'secrets' || /^CWE-(287|306|269|250|798|312)$/.test(cwe)) ids.add('SAIF-1');
+  if (/log.?inject|missing.?logg|silent|hide.?output/.test(rule + title) || owasp === 'ASI06') ids.add('SAIF-2');
+  if (cat === 'supply-chain' || cat === 'deps' || cat === 'git-history' || owasp === 'ASI04') ids.add('SAIF-3');
+  if (/mcp|tool.?poison|rag\b|retrieval|vector.?store|agent.?config|\.cursorrules|CLAUDE\.md/.test(rule + title) || cat === 'agentic') ids.add('SAIF-4');
+  if (owasp === 'ASI05' || owasp === 'ASI10' || /poison|tamper|memory/.test(rule + title)) ids.add('SAIF-5');
+  if (owasp === 'ASI08' || cat === 'llm') ids.add('SAIF-6');
+
+  return [...ids];
+}