sage-governance 1.0.0

package/README.md

@@ -0,0 +1,319 @@
+# SAGE — Supervisory Agentic Governance Engine
+
+> Open-source governance layer for agentic coding systems.  
+> Intercepts, evaluates, and audits developer prompts - before code is written.
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+[![MCP Compatible](https://img.shields.io/badge/MCP-Compatible-blue.svg)](https://modelcontextprotocol.io)
+[![Works With: OpenCode · Cline · Claude Code · Continue · Cursor](https://img.shields.io/badge/Works%20With-OpenCode%20·%20Cline%20·%20Claude%20Code%20·%20Continue%20·%20Cursor-green.svg)]()
+
+---
+
+## What SAGE Does
+
+Most governance tools audit *after* the fact. SAGE intervenes *before* code is written.
+
+When a developer asks a coding agent to build a recidivism classifier, SAGE intercepts the request, classifies it as **CRITICAL** under EU AI Act Annex III.6.d, detects that `race`, `sex`, and `age` are being used as direct model features, surfaces three concrete fairness tradeoffs (Equalized Odds, Demographic Parity, Predictive Parity) with pros/cons and Fairlearn API calls, blocks the file write until the developer makes an explicit choice, writes a SHA-256 chained audit entry, and generates a model card compliant with Google's Model Cards spec.
+
+No other tool in this demo room holds the pen before it touches the file.
+
+---
+
+## Architecture
+
+```
+Developer prompt
+      │
+      ▼
+Coding Agent (OpenCode / Cline / Claude Code / Continue / Cursor)
+      │  MCP call
+      ▼
+┌─────────────────────────────────────────────────────┐
+│  SAGE MCP Server  (Python / FastMCP / stdio)        │
+│                                                     │
+│  ┌───────────────┐  ┌───────────────┐  ┌─────────┐ │
+│  │  SAGE Agent   │→ │ Coding Agent  │→ │Security │ │
+│  │  intent + EU  │  │ routes only   │  │ Agent   │ │
+│  │  AI Act check │  │ compliant req │  │ P0–P4   │ │
+│  └───────────────┘  └───────────────┘  └─────────┘ │
+│                                                     │
+│  ┌──────────────────┐  ┌────────────────────────┐  │
+│  │  Audit Trail     │  │  Report Generator      │  │
+│  │  decisions.jsonl │  │  model card (markdown) │  │
+│  │  SHA-256 chain   │  │  Mitchell et al. 2019  │  │
+│  └──────────────────┘  └────────────────────────┘  │
+└─────────────────────────────────────────────────────┘
+      │                                    │
+      ▼                                    ▼
+rules/general/               audit-trail/decisions.jsonl
+  UNESCO_AI_Ethics.md        LOGS.md
+  EU_AI_Act_Annex_III.md     reports/governance_report_*.md
+  UN_Human_Rights.md
+  OECD_Principles.md
+```
+
+**Why MCP?** The Model Context Protocol is the universal adapter layer. SAGE is written once and works with every MCP-compatible coding agent — OpenCode, Cline, Claude Code, Continue, Cursor, Zed. Switching from one to another requires zero code changes.
+
+---
+
+## The Three Agents
+
+### SAGE Agent (`sage/sage_agent.py`)
+Classifies developer intent and evaluates ethical/regulatory compliance.
+
+- Reads `rules/general/` policy files at startup (zero per-call latency)
+- Detects protected attributes (`race`, `sex`, `age`, ...) used directly
+- Detects proxy attributes (`zip_code`, `surname`, `priors_count`, ...) via semantic map
+- Maps to EU AI Act Annex III categories (Annex III.6.d for criminal justice, etc.)
+- Maps to UDHR articles (Article 7, 10, 11, 22, 23...)
+- Generates three fairness tradeoff options with Fairlearn API calls
+- Enriches reasoning with LLM (falls back deterministically if unavailable)
+- Returns Pydantic-validated `SageEvaluateResponse` — always parseable, schema-stable
+
+### Coding Agent (`codingagent/`)
+Writes, refactors, or debugs code based on SAGE-approved intent.
+
+- Receives only SAGE-approved or tradeoff-resolved requests
+- Can read `LOGS.md` and `local_memory.md` for session context
+- Generates human-readable charts and reports using Python
+- Designed for compatibility with any underlying LLM provider
+- NOT tied to a single provider or framework — swap via `SAGE_LLM_MODEL` env var
+
+### Code & Infrastructure Security Agent (`sage/security_agent.py`)
+Deterministic (no LLM) full-spectrum code scanner.
+
+| Severity | Category | Examples |
+|----------|----------|---------|
+| P0 | Secret exposure | Hardcoded API keys, Anthropic/OpenAI keys, DB passwords |
+| P0 | Critical PII | SSN, biometrics, medical data, GDPR Article 9 special categories |
+| P1 | Sensitive PII | Geolocation, passport numbers, date of birth |
+| P1 | Protected attribute direct use | `race`, `sex`, `age` as model features |
+| P2 | Proxy discrimination | `zip_code`, `surname`, `priors_count` as indirect proxies |
+| P2 | Compliance gap | Black-box model in high-risk system; no fairness metrics |
+| P3 | Data quality | `LabelEncoder` on demographics; unstratified splits |
+
+---
+
+## The Key Differentiator: `intercept_file_write`
+
+Every governance tool in existence audits after deployment. SAGE blocks before write.
+
+```
+Developer asks coding agent to create classifier.py
+                   │
+                   ▼
+    intercept_file_write called with full code
+                   │
+         ┌─────────┴─────────┐
+         │  Security Scan    │
+         └─────────┬─────────┘
+                   │
+    ┌──────────────┴──────────────┐
+    │                             │
+ No P0/P1 findings          P0/P1 found
+    │                             │
+ auto_approved ✅            BLOCKED ⛔
+ file written                Single highest-risk
+                             finding surfaced
+                                  │
+                         Developer chooses:
+                         • accept_as_is
+                         • apply_suggestion
+                         • reject
+                                  │
+                         audit_write records choice
+                                  │
+                         File written (or not)
+```
+
+---
+
+## Installation
+
+### Quick Start (recommended)
+
+```bash
+npm install -g sage-governance
+```
+
+This installs the `sage` CLI command globally. The Node.js wrapper automatically resolves `python3`, `python`, or `py` in that order.
+
+### Manual / Development
+
+```bash
+git clone https://github.com/[your-org]/sage-governance
+cd sage-governance
+
+# Python dependencies
+pip install mcp anthropic pydantic fairlearn diffprivlib
+
+# Set your LLM provider key
+export ANTHROPIC_API_KEY=sk-ant-...
+
+# Optional: override model
+export SAGE_LLM_MODEL=claude-sonnet-4-6
+```
+
+### Run SAGE as MCP Server
+
+```bash
+# Via CLI (after npm install -g)
+sage
+
+# Directly via Python
+python sage/mcp_server.py
+```
+
+---
+
+## OpenCode Configuration (`opencode.json`)
+
+```json
+{
+  "$schema": "https://opencode.ai/config.schema.json",
+  "mcpServers": {
+    "sage-governance": {
+      "type": "local",
+      "command": "sage",
+      "args": [],
+      "env": {
+        "ANTHROPIC_API_KEY": "${ANTHROPIC_API_KEY}",
+        "SAGE_LLM_MODEL": "claude-sonnet-4-6"
+      }
+    }
+  }
+}
+```
+
+For Cline, Claude Code, or Continue, use the equivalent MCP server configuration for stdio transport.
+
+---
+
+## 5 MCP Tools (API Reference)
+
+| Tool | When to call | Returns |
+|------|-------------|---------|
+| `sage_evaluate` | Before any ML/data request | risk_level, fairness_options, compliance_flags |
+| `security_scan` | On any generated code | P0–P4 findings, passed/blocked verdict |
+| `intercept_file_write` | **Before every file write** | approved true/false, highest-risk finding |
+| `audit_write` | After every developer decision | entry_hash, session_id |
+| `report_generate` | End of session | Full model card markdown |
+
+### Schema Contract (`SageEvaluateResponse`)
+
+```python
+{
+  "risk_level": "LOW" | "MEDIUM" | "HIGH" | "CRITICAL",
+  "eu_ai_act_annex": "Annex III.6.d" | null,
+  "eu_ai_act_category": "description string" | null,
+  "udhr_articles": ["Article 7", "Article 10"],
+  "protected_attributes": ["race", "sex", "age"],
+  "proxy_attributes": ["zip_code", "priors_count"],
+  "detected_domain": "criminal_justice",
+  "intent_summary": "first 300 chars of prompt",
+  "compliance_flags": ["flag 1", "flag 2"],
+  "fairness_options": [{ ... FairnessOption ... }],
+  "immediate_actions": ["action 1", "action 2"],
+  "regulations": ["EU AI Act Annex III.6.d: ..."],
+  "requires_human_review": true,
+  "sage_reasoning": "2-3 sentence explanation",
+  "fairness_impossibility": true,
+  "audit_entry_hash": "sha256hex"
+}
+```
+
+---
+
+## Policy Files (`rules/general/`)
+
+| File | Source | Domains covered |
+|------|--------|----------------|
+| `UNESCO_AI_Ethics.md` | UNESCO 2021 Recommendation | All AI systems |
+| `EU_AI_Act_Annex_III.md` | Regulation (EU) 2024/1689 | High-risk AI systems |
+| `UN_Human_Rights.md` | UDHR 1948 | All domains |
+| `OECD_Principles.md` | OECD 2019 (updated 2024) | All AI systems |
+| `country/` | Per-jurisdiction files | Region-specific |
+
+Policy files are loaded at MCP server startup — zero per-call file I/O.
+
+---
+
+## Audit Trail (`audit-trail/decisions.jsonl`)
+
+Every governance event is written as an append-only JSON line with SHA-256 chaining:
+
+```json
+{
+  "event_type": "file_write_intercepted",
+  "filepath": "classifier.py",
+  "decision": "blocked_pending_developer_action",
+  "highest_risk_finding": {
+    "severity": "P1",
+    "category": "PROTECTED_ATTRIBUTE_DIRECT_USE",
+    "line_number": 47,
+    "description": "Protected attribute 'race' used directly in model code"
+  },
+  "session_id": "20260620_143022",
+  "timestamp": "2026-06-20T14:30:22Z",
+  "entry_hash": "a3f9c2...",
+  "prev_hash": "b7d1e4..."
+}
+```
+
+**Honest limitation:** The chain proves sequential integrity within a session. Local file deletion is not prevented. For immutable audit logging, forward entries to an external append-only service.
+
+---
+
+## Demo Flow (COMPAS, ~4 minutes)
+
+1. Developer types: *"Build a recidivism classifier to predict two_year_recid using race, sex, and age"*
+2. SAGE `sage_evaluate` → **CRITICAL** | EU AI Act Annex III.6.d | Protected: `race`, `sex`, `age`
+3. SAGE presents 3 options: Equalized Odds / Predictive Parity / Demographic Parity
+4. Developer picks **Equalized Odds** → `audit_write` records choice
+5. Coding Agent generates Fairlearn `ExponentiatedGradient` classifier
+6. `intercept_file_write` → **BLOCKED** — `race` on line 47, P1 severity
+7. Developer chooses `apply_suggestion` → ThresholdOptimizer pattern applied
+8. `audit_write` records file decision
+9. `report_generate` → full model card written to `reports/`
+
+Steps 6–7 are the demo money moment. No other team's tool holds the pen.
+
+---
+
+## Fairness Impossibility — Honest About the Math
+
+SAGE never pretends a "correct" answer exists. It makes the conflict explicit.
+
+When base rates differ across groups, Demographic Parity, Equalized Odds, and Predictive Parity **cannot all be satisfied simultaneously** (Chouldechova, 2016). SAGE presents each option with exactly who benefits, what the tradeoff costs, and which metrics it is mathematically incompatible with. The developer makes the values judgment. SAGE records it.
+
+---
+
+## Team
+
+**Team SAGE — SpainGov/AESIA Governance Hackathon**
+
+| Member | Role |
+|--------|------|
+| Olu & Prajwal | Architecture, MCP server, agentic orchestration |
+| Roshan | MCP servers, OpenCode integration, agent wiring |
+| George | Ethics & regulatory policy files, project management |
+| Jeremy | Data science validation, security pipeline, presentation |
+
+**Built with:** FastMCP · Python · Pydantic · Fairlearn · Anthropic API  
+**Built by:** Oluwagbemisola, Prajwal, Roshan, Jeremy, George
+**License:** MIT
+
+---
+
+## References
+
+- EU AI Act — Regulation (EU) 2024/1689
+- UNESCO Recommendation on the Ethics of Artificial Intelligence (2021)
+- OECD AI Principles (2019, updated 2024)
+- Universal Declaration of Human Rights (1948)
+- Mitchell et al. (2019). "Model Cards for Model Reporting." FAccT.
+- Chouldechova, A. (2016). "Fair Prediction with Disparate Impact."
+- ProPublica (2016). "Machine Bias." COMPAS audit.
+- Ali et al. (2019). "Discrimination through Optimization." ACM FAccT.
+- Beunec Technologies Inc Agentic Annotation Protocol - github.com/beunec
+- Anthropic Model Context Protocol — modelcontextprotocol.io

package/bin/sage.js

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+
+/**
+ * bin/sage.js — Node.js wrapper for SAGE MCP Server
+ * ════════════════════════════════════════════════
+ * Automatically resolves the Python executable and spawns the
+ * SAGE MCP server (sage/mcp_server.py).
+ */
+
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+const PROJECT_ROOT = path.resolve(__dirname, '..');
+const MCP_SERVER_PATH = path.join(PROJECT_ROOT, 'sage', 'mcp_server.py');
+
+/**
+ * Resolves the Python executable in order of preference.
+ */
+function getPythonExecutable() {
+    const executables = ['python3', 'python', 'py'];
+    const { execSync } = require('child_process');
+
+    for (const exe of executables) {
+        try {
+            execSync(`${exe} --version`, { stdio: 'ignore' });
+            return exe;
+        } catch (e) {
+            continue;
+        }
+    }
+    return null;
+}
+
+const pythonExe = getPythonExecutable();
+
+if (!pythonExe) {
+    console.error('[SAGE] Error: Python 3 not found in PATH.');
+    console.error('       Please install Python 3 (https://python.org) and try again.');
+    process.exit(1);
+}
+
+const child = spawn(pythonExe, [MCP_SERVER_PATH, ...process.argv.slice(2)], {
+    stdio: 'inherit',
+    env: process.env
+});
+
+child.on('error', (err) => {
+    console.error('[SAGE] Failed to start Python process:', err);
+    process.exit(1);
+});
+
+child.on('exit', (code) => {
+    process.exit(code);
+});

package/claude.json

@@ -0,0 +1,16 @@
+{
+  "_note": "Claude Code MCP configuration. Copy this file to .mcp.json in your project root, OR run: claude mcp add sage sage -- sage",
+  "_docs": "https://docs.anthropic.com/en/docs/claude-code/mcp",
+  "_compatible_with": "Claude Code (claude.ai/code)",
+  "mcpServers": {
+    "sage-governance": {
+      "command": "sage",
+      "args": [],
+      "type": "stdio",
+      "env": {
+        "OPENAI_API_KEY": "${OPENAI_API_KEY}",
+        "SAGE_LLM_MODEL": "gpt-4o-mini"
+      }
+    }
+  }
+}

package/codex.json

@@ -0,0 +1,22 @@
+{
+  "_note": "OpenAI Codex / Codex CLI MCP configuration. Codex CLI reads codex.json for MCP server config.",
+  "_docs": "https://github.com/openai/codex",
+  "_compatible_with": "Codex CLI >= 0.1.0",
+  "provider": "openai",
+  "model": "o4-mini",
+  "mcpServers": {
+    "sage-governance": {
+      "command": "sage",
+      "args": [],
+      "type": "stdio",
+      "env": {
+        "OPENAI_API_KEY": "${OPENAI_API_KEY}",
+        "SAGE_LLM_MODEL": "gpt-4o-mini"
+      },
+      "description": "SAGE governance layer — evaluates ethics, fairness, and regulatory compliance before code generation"
+    }
+  },
+  "instructions": "You are operating inside the SAGE governance runtime. Read AGENTS.md for full operational rules. Always call sage_evaluate before ML tasks. Always call intercept_file_write before writing files. Always call audit_write after developer decisions.",
+  "fullAutoErrorMode": "ask-user",
+  "notify": false
+}

package/cursor.json

@@ -0,0 +1,27 @@
+{
+  "_note": "Cursor project configuration. The MCP server config lives at .cursor/mcp.json. This file documents Cursor-specific rules for SAGE.",
+  "_compatible_with": "Cursor >= 0.43",
+  "_mcp_config_path": ".cursor/mcp.json",
+  "_rules_file": ".cursorrules",
+  "rules": [
+    "Read AGENTS.md before starting any task in this project",
+    "Call sage_evaluate before any machine learning or data science task",
+    "Call intercept_file_write before writing any file — no exceptions",
+    "Call audit_write after every developer decision",
+    "Never use race, sex, age, or religion as direct model features without governance review",
+    "Present ALL three fairness options when sage_evaluate returns HIGH or CRITICAL risk",
+    "Append-only to LOGS.md and local_memory.md — never delete entries",
+    "Run sage --check before starting a new project to verify the environment"
+  ],
+  "mcpServers": {
+    "sage-governance": {
+      "command": "sage",
+      "args": [],
+      "type": "stdio",
+      "env": {
+        "OPENAI_API_KEY": "${OPENAI_API_KEY}",
+        "SAGE_LLM_MODEL": "gpt-4o-mini"
+      }
+    }
+  }
+}

package/docs/architecture.md

@@ -0,0 +1,38 @@
+# SAGE Architecture
+
+SAGE (Supervisory Agentic Governance Engine) is designed as a governance layer that intercepts developer prompts and coding agent actions before they result in code being written.
+
+## Components
+
+### 1. SAGE Agent (`sage/sage_agent.py`)
+Classifies developer intent and evaluates ethical/regulatory compliance.
+- Performs deterministic domain detection and risk scoring.
+- Detects protected and proxy attributes.
+- Maps requests to relevant regulations (EU AI Act, UDHR, etc.).
+- Suggests fairness options using an LLM for reasoning.
+
+### 2. Security Agent (`sage/security_agent.py`)
+A deterministic code scanner that checks for security and compliance issues.
+- Scans for hardcoded secrets and API keys.
+- Detects PII and protected attribute usage.
+- Identifies compliance gaps such as black-box models or missing fairness metrics.
+
+### 3. MCP Server (`sage/mcp_server.py`)
+Exposes SAGE's functionality through the Model Context Protocol (MCP).
+- Provides tools like `sage_evaluate`, `security_scan`, and `intercept_file_write`.
+- The `intercept_file_write` tool is a critical point that blocks insecure file writes.
+
+### 4. Audit Trail (`audit-trail/`)
+Maintains an append-only log of all governance decisions.
+- Uses SHA-256 chaining to ensure the integrity of the session log.
+- Supports generating comprehensive model cards/governance reports.
+
+## Workflow
+
+1. **Prompt Interception:** A developer prompt is sent to `sage_evaluate`.
+2. **Evaluation:** SAGE evaluates the risk and suggests fairness strategies.
+3. **Action:** The coding agent generates code based on the approved intent.
+4. **Pre-Write Scan:** Before writing to disk, `intercept_file_write` is called.
+5. **Enforcement:** If high-risk issues are found, the write is blocked until the developer makes an explicit decision.
+6. **Logging:** Every step and decision is recorded in the Audit Trail.
+7. **Reporting:** A final governance report can be generated at any time.

package/opencode.json

@@ -0,0 +1,24 @@
+{
+  "$schema": "https://opencode.ai/config.schema.json",
+  "model": "anthropic/claude-sonnet-4-6",
+  "mcpServers": {
+    "sage-governance": {
+      "type": "local",
+      "command": "sage",
+      "args": [],
+      "env": {
+        "OPENAI_API_KEY": "${OPENAI_API_KEY}",
+        "SAGE_LLM_MODEL": "gpt-4o-mini"
+      }
+    }
+  },
+  "instructions": "You are operating inside the SAGE governance runtime. Before acting on any prompt involving machine learning, data, or automated decisions: (1) call sage_evaluate, (2) present the risk level and fairness options to the developer, (3) wait for their choice, (4) call audit_write to record it. Before writing ANY file: call intercept_file_write first. Never skip these steps. Read AGENTS.md for full operational rules.",
+  "rules": [
+    "ALWAYS call sage_evaluate before any ML, data science, or automated decision task",
+    "ALWAYS call intercept_file_write before writing any file to disk",
+    "ALWAYS call audit_write after any developer decision (fairness choice or file decision)",
+    "NEVER use protected attributes (race, sex, age, religion) as model features without developer acknowledgement",
+    "NEVER write to audit-trail/decisions.jsonl directly — use the audit_write MCP tool",
+    "NEVER delete or modify LOGS.md or local_memory.md — append only"
+  ]
+}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "sage-governance",
+  "version": "1.0.0",
+  "description": "Supervisory Agentic Governance Engine — Open-source MCP governance layer for agentic coding systems. Intercepts, evaluates, and audits AI coding prompts for EU AI Act, GDPR, and fairness compliance.",
+  "main": "bin/sage.js",
+  "bin": {
+    "sage": "bin/sage.js"
+  },
+  "scripts": {
+    "start": "node bin/sage.js",
+    "_prepublishOnly": "find . -path './.git' -prune -o -name '__pycache__' -type d -print -exec rm -rf {} + 2>/dev/null; echo 'pycache cleaned'",
+    "postinstall": "node -e \"console.log('\\n[SAGE] Python deps required — run: pip install -r requirements.txt\\n')\""
+  },
+  "files": [
+    "bin/",
+    "sage/",
+    "rules/",
+    "docs/",
+    "AGENTS.MD",
+    "README.md",
+    "LICENSE",
+    "requirements.txt",
+    "opencode.json",
+    "claude.json",
+    "cursor.json",
+    "codex.json"
+  ],
+  "keywords": [
+    "mcp",
+    "governance",
+    "ai-safety",
+    "fairness",
+    "eu-ai-act",
+    "gdpr",
+    "ethics",
+    "compliance",
+    "agentic",
+    "llm",
+    "audit",
+    "fairlearn",
+    "responsible-ai",
+    "model-card"
+  ],
+  "author": "SAGE Team <team@olustar.io>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Olustar/supervisory-agentic-governance-engine.git"
+  },
+  "homepage": "https://github.com/Olustar/supervisory-agentic-governance-engine#readme",
+  "bugs": {
+    "url": "https://github.com/Olustar/supervisory-agentic-governance-engine/issues"
+  },
+  "dependencies": {},
+  "engines": {
+    "node": ">=16.0.0"
+  }
+}

package/requirements.txt

@@ -0,0 +1,7 @@
+mcp
+pydantic
+openai
+fairlearn
+diffprivlib
+pandas
+scikit-learn

package/rules/general/EU_AI_Act_Annex_III.md

@@ -0,0 +1,29 @@
+# EU AI Act — Annex III: High-Risk AI Systems
+
+The EU AI Act classifies certain AI systems as "high-risk" if they have a significant impact on people's health, safety, or fundamental rights. These systems are subject to strict obligations before they can be put on the market.
+
+## High-Risk Categories (SAGE Implementation)
+
+### 1. Criminal Justice (Annex III.6.d)
+AI systems for law enforcement assessing risk of offending or re-offending (e.g. COMPAS, recidivism prediction).
+- **Keywords:** recidivism, criminal, parole, sentencing, compas, reoffend, bail, arrest, two_year_recid, risk score, reoffending, criminal justice.
+
+### 2. Employment (Annex III.4.a)
+AI systems for recruitment/selection, including targeted job advertisements, CV filtering, candidate evaluation.
+- **Keywords:** job, recruitment, hiring, resume, cv, employment, advertisement, candidate, fairjob, job ad, click, click-through, ctr.
+
+### 3. Credit Scoring (Annex III.5.b)
+AI systems for creditworthiness evaluation or credit score determination.
+- **Keywords:** credit, loan, default, creditworthiness, mortgage, financial risk, lending, apple card, credit card, credit limit, credit score.
+
+### 4. Education (Annex III.3.a)
+AI systems determining access to educational institutions or evaluating students.
+- **Keywords:** education, school, admission, student, grade, academic, university, college, exam.
+
+### 5. Essential Services (Annex III.5.a)
+AI systems for essential private and public services (healthcare, insurance, housing, social security).
+- **Keywords:** healthcare, insurance, benefit, welfare, housing, social security, medical.
+
+### 6. Children Safety (Annex III context-dependent)
+AI systems impacting children's safety, privacy, or wellbeing; UNICEF 10 Principles apply.
+- **Keywords:** child, minor, children, safeguarding, grooming, bullying, moderation, self-harm, abuse, distress, escalation, chat safety.

package/rules/general/OECD_Principles.md

@@ -0,0 +1,20 @@
+# OECD AI Principles
+
+Adopted in May 2019 and updated in 2024, the OECD AI Principles promote the use of AI that is innovative and trustworthy and that respects human rights and democratic values.
+
+## The Five Principles
+
+1. **Inclusive growth, sustainable development, and well-being:**
+   Stakeholders should proactively engage in responsible stewardship of trustworthy AI in pursuit of beneficial outcomes for people and the planet, such as augmenting human capabilities and enhancing creativity, advancing inclusion of underrepresented populations, reducing economic, social, gender and other inequalities, and protecting natural environments, thus invigorating inclusive growth, sustainable development and well-being.
+
+2. **Human rights and democratic values, including fairness and privacy:**
+   AI actors should respect the rule of law, human rights and democratic values, throughout the AI system lifecycle. These include, freedom, dignity and autonomy, privacy and data protection, non-discrimination and fairness.
+
+3. **Transparency and explainability:**
+   AI Actors should commit to transparency and responsible disclosure regarding AI systems. To this end, they should provide meaningful information, appropriate to the context, and consistent with the state of art.
+
+4. **Robustness, security, and safety:**
+   AI systems should be robust, secure and safe throughout their entire lifecycle so that, in conditions of normal use, foreseeable use or misuse, or other adverse conditions, they function appropriately and do not pose unreasonable safety risk.
+
+5. **Accountability:**
+   AI actors should be accountable for the proper functioning of AI systems and for the respect of the above principles, based on their roles, the context, and consistent with the state of art.