@rosetears/aili-pi 0.1.0

package/skills/rose-memory/references/schema.sql

@@ -0,0 +1,315 @@
+
+CREATE TABLE IF NOT EXISTS schema_migration (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  version INTEGER NOT NULL,
+  name TEXT NOT NULL,
+  checksum TEXT NOT NULL,
+  applied_at TEXT NOT NULL,
+  UNIQUE(version)
+);
+
+CREATE TABLE IF NOT EXISTS memory_receipt (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  receipt_key TEXT NOT NULL UNIQUE,
+  operation TEXT NOT NULL,
+  status TEXT NOT NULL CHECK (status IN ('ok','error')),
+  payload_json TEXT NOT NULL DEFAULT '{}',
+  created_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS session (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  session_key TEXT NOT NULL UNIQUE,
+  project TEXT NOT NULL,
+  agent TEXT NOT NULL,
+  started_at TEXT NOT NULL,
+  ended_at TEXT,
+  metadata_json TEXT NOT NULL DEFAULT '{}'
+);
+
+CREATE TABLE IF NOT EXISTS task (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  task_key TEXT NOT NULL UNIQUE,
+  session_id INTEGER REFERENCES session(id) ON DELETE SET NULL,
+  project TEXT NOT NULL,
+  agent TEXT NOT NULL,
+  title TEXT NOT NULL,
+  scope_text TEXT NOT NULL DEFAULT '',
+  status TEXT NOT NULL CHECK (status IN ('active','blocked','completed','cancelled')),
+  started_at TEXT NOT NULL,
+  completed_at TEXT,
+  outcome TEXT,
+  metadata_json TEXT NOT NULL DEFAULT '{}'
+);
+
+CREATE TABLE IF NOT EXISTS memory_event (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  session_id INTEGER REFERENCES session(id) ON DELETE SET NULL,
+  task_id INTEGER REFERENCES task(id) ON DELETE SET NULL,
+  event_type TEXT NOT NULL,
+  state TEXT,
+  summary TEXT NOT NULL DEFAULT '',
+  payload_json TEXT NOT NULL DEFAULT '{}',
+  created_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS memory_fact (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  session_id INTEGER REFERENCES session(id) ON DELETE SET NULL,
+  project TEXT NOT NULL,
+  agent TEXT NOT NULL,
+  fact_key TEXT NOT NULL,
+  fact_text TEXT NOT NULL,
+  category TEXT NOT NULL,
+  confidence TEXT NOT NULL DEFAULT 'medium'
+    CHECK (confidence IN ('low','medium','high')),
+  status TEXT NOT NULL DEFAULT 'active'
+    CHECK (status IN ('active','superseded','rejected','expired')),
+  sensitive INTEGER NOT NULL DEFAULT 0 CHECK (sensitive IN (0,1)),
+  indexable INTEGER NOT NULL DEFAULT 1 CHECK (indexable IN (0,1)),
+  first_seen_at TEXT NOT NULL,
+  last_seen_at TEXT NOT NULL,
+  superseded_by INTEGER REFERENCES memory_fact(id),
+  metadata_json TEXT NOT NULL DEFAULT '{}',
+  UNIQUE(project, agent, fact_key)
+);
+
+CREATE TABLE IF NOT EXISTS claim (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  session_id INTEGER REFERENCES session(id) ON DELETE SET NULL,
+  task_id INTEGER REFERENCES task(id) ON DELETE SET NULL,
+  project TEXT NOT NULL,
+  agent TEXT NOT NULL,
+  claim_key TEXT NOT NULL,
+  claim_text TEXT NOT NULL,
+  verification_status TEXT NOT NULL
+    CHECK (verification_status IN ('unverified','verified','disputed','superseded')),
+  evidence_summary TEXT NOT NULL DEFAULT '',
+  sensitive INTEGER NOT NULL DEFAULT 0 CHECK (sensitive IN (0,1)),
+  indexable INTEGER NOT NULL DEFAULT 1 CHECK (indexable IN (0,1)),
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  metadata_json TEXT NOT NULL DEFAULT '{}',
+  UNIQUE(project, agent, claim_key)
+);
+
+CREATE TABLE IF NOT EXISTS finding (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  session_id INTEGER REFERENCES session(id) ON DELETE SET NULL,
+  task_id INTEGER REFERENCES task(id) ON DELETE SET NULL,
+  project TEXT NOT NULL,
+  agent TEXT NOT NULL,
+  kind TEXT NOT NULL
+    CHECK (kind IN ('correction','failure','review_rejection','preference','risk','observation')),
+  category TEXT NOT NULL,
+  severity TEXT NOT NULL DEFAULT 'normal'
+    CHECK (severity IN ('low','normal','high','critical')),
+  wrong_behavior TEXT NOT NULL DEFAULT '',
+  correct_behavior TEXT NOT NULL DEFAULT '',
+  summary TEXT NOT NULL,
+  raw_ref TEXT NOT NULL DEFAULT '',
+  sensitive INTEGER NOT NULL DEFAULT 0 CHECK (sensitive IN (0,1)),
+  indexable INTEGER NOT NULL DEFAULT 1 CHECK (indexable IN (0,1)),
+  created_at TEXT NOT NULL,
+  metadata_json TEXT NOT NULL DEFAULT '{}'
+);
+
+CREATE TABLE IF NOT EXISTS evidence (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  session_id INTEGER REFERENCES session(id) ON DELETE SET NULL,
+  task_id INTEGER REFERENCES task(id) ON DELETE SET NULL,
+  project TEXT NOT NULL,
+  agent TEXT NOT NULL,
+  source_type TEXT NOT NULL
+    CHECK (source_type IN ('finding','claim','memory_event','task','file','diff','test','user_confirmation')),
+  source_id INTEGER,
+  evidence_key TEXT NOT NULL,
+  evidence_text TEXT NOT NULL,
+  evidence_hash TEXT NOT NULL,
+  weight INTEGER NOT NULL DEFAULT 1 CHECK (weight >= 0),
+  sensitive INTEGER NOT NULL DEFAULT 0 CHECK (sensitive IN (0,1)),
+  indexable INTEGER NOT NULL DEFAULT 1 CHECK (indexable IN (0,1)),
+  created_at TEXT NOT NULL,
+  metadata_json TEXT NOT NULL DEFAULT '{}',
+  UNIQUE(project, agent, evidence_key)
+);
+
+CREATE TABLE IF NOT EXISTS rule_candidate (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  project TEXT NOT NULL,
+  agent TEXT NOT NULL,
+  rule_key TEXT NOT NULL,
+  normalized_rule_hash TEXT NOT NULL,
+  rule_text TEXT NOT NULL,
+  category TEXT NOT NULL,
+  severity TEXT NOT NULL DEFAULT 'normal'
+    CHECK (severity IN ('low','normal','high','critical')),
+  status TEXT NOT NULL DEFAULT 'memory'
+    CHECK (status IN (
+      'memory',
+      'candidate',
+      'needs_reconciliation',
+      'approved',
+      'promoted',
+      'rejected',
+      'superseded',
+      'expired'
+    )),
+  score INTEGER NOT NULL DEFAULT 0 CHECK (score >= 0),
+  mention_count INTEGER NOT NULL DEFAULT 0 CHECK (mention_count >= 0),
+  session_count INTEGER NOT NULL DEFAULT 0 CHECK (session_count >= 0),
+  evidence_count INTEGER NOT NULL DEFAULT 0 CHECK (evidence_count >= 0),
+  promotion_target TEXT NOT NULL DEFAULT 'AGENTS.md',
+  target_scope TEXT NOT NULL DEFAULT 'project_root_agents'
+    CHECK (target_scope IN ('project_root_agents')),
+  conflicts_json TEXT NOT NULL DEFAULT '[]',
+  requires_user_approval INTEGER NOT NULL DEFAULT 1 CHECK (requires_user_approval IN (0,1)),
+  first_seen_at TEXT NOT NULL,
+  last_seen_at TEXT NOT NULL,
+  approved_at TEXT,
+  promoted_at TEXT,
+  superseded_by INTEGER REFERENCES rule_candidate(id),
+  metadata_json TEXT NOT NULL DEFAULT '{}',
+  UNIQUE(project, agent, rule_key)
+);
+
+CREATE TABLE IF NOT EXISTS rule_candidate_evidence (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  rule_id INTEGER NOT NULL REFERENCES rule_candidate(id) ON DELETE CASCADE,
+  evidence_id INTEGER NOT NULL REFERENCES evidence(id) ON DELETE RESTRICT,
+  signal_type TEXT NOT NULL
+    CHECK (signal_type IN (
+      'long_term_instruction',
+      'correction_after_drift',
+      'review_rejection',
+      'ordinary_preference',
+      'evidence_backed_failure',
+      'risk_signal',
+      'user_confirmation'
+    )),
+  weight INTEGER NOT NULL CHECK (weight >= 0),
+  created_at TEXT NOT NULL,
+  UNIQUE(rule_id, evidence_id)
+);
+
+CREATE TABLE IF NOT EXISTS instruction_snapshot (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  target_path TEXT NOT NULL,
+  target_scope TEXT NOT NULL
+    CHECK (target_scope IN ('project_root_agents')),
+  hash_algorithm TEXT NOT NULL DEFAULT 'sha256',
+  content_hash TEXT NOT NULL,
+  summary TEXT NOT NULL DEFAULT '',
+  captured_at TEXT NOT NULL,
+  metadata_json TEXT NOT NULL DEFAULT '{}'
+);
+
+CREATE TABLE IF NOT EXISTS rule_patch (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  rule_id INTEGER NOT NULL REFERENCES rule_candidate(id) ON DELETE CASCADE,
+  target_path TEXT NOT NULL DEFAULT 'AGENTS.md',
+  target_scope TEXT NOT NULL DEFAULT 'project_root_agents'
+    CHECK (target_scope IN ('project_root_agents')),
+  base_snapshot_id INTEGER NOT NULL REFERENCES instruction_snapshot(id),
+  base_hash TEXT NOT NULL,
+  patch_hash TEXT NOT NULL,
+  proposed_rule_hash TEXT NOT NULL,
+  patch_text TEXT NOT NULL,
+  status TEXT NOT NULL DEFAULT 'proposed'
+    CHECK (status IN ('proposed','approved','rejected','applied','stale','failed')),
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  metadata_json TEXT NOT NULL DEFAULT '{}'
+);
+
+CREATE TABLE IF NOT EXISTS rule_decision (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  rule_id INTEGER NOT NULL REFERENCES rule_candidate(id) ON DELETE CASCADE,
+  patch_id INTEGER NOT NULL REFERENCES rule_patch(id) ON DELETE CASCADE,
+  decision TEXT NOT NULL
+    CHECK (decision IN ('approved','rejected','superseded','needs_reconciliation')),
+  approved_rule_hash TEXT,
+  approved_patch_hash TEXT,
+  actor TEXT NOT NULL,
+  reason TEXT NOT NULL DEFAULT '',
+  decided_at TEXT NOT NULL,
+  metadata_json TEXT NOT NULL DEFAULT '{}'
+);
+
+CREATE TABLE IF NOT EXISTS rule_promotion (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  rule_id INTEGER NOT NULL REFERENCES rule_candidate(id) ON DELETE CASCADE,
+  patch_id INTEGER NOT NULL REFERENCES rule_patch(id) ON DELETE CASCADE,
+  decision_id INTEGER NOT NULL REFERENCES rule_decision(id) ON DELETE RESTRICT,
+  mode TEXT NOT NULL CHECK (mode IN ('apply','record_applied')),
+  target_path TEXT NOT NULL,
+  old_target_hash TEXT NOT NULL,
+  new_target_hash TEXT NOT NULL,
+  applied_by TEXT NOT NULL,
+  applied_at TEXT NOT NULL,
+  metadata_json TEXT NOT NULL DEFAULT '{}',
+  UNIQUE(patch_id)
+);
+
+CREATE TABLE IF NOT EXISTS audit_run (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  audit_key TEXT NOT NULL UNIQUE,
+  operation TEXT NOT NULL,
+  status TEXT NOT NULL CHECK (status IN ('ok','error')),
+  checks_json TEXT NOT NULL DEFAULT '{}',
+  created_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS search_doc (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  project TEXT NOT NULL,
+  agent TEXT NOT NULL,
+  doc_type TEXT NOT NULL,
+  source_table TEXT,
+  source_id INTEGER,
+  title TEXT NOT NULL DEFAULT '',
+  body TEXT NOT NULL,
+  summary TEXT NOT NULL DEFAULT '',
+  sensitive INTEGER NOT NULL DEFAULT 0 CHECK (sensitive IN (0,1)),
+  indexable INTEGER NOT NULL DEFAULT 1 CHECK (indexable IN (0,1)),
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  metadata_json TEXT NOT NULL DEFAULT '{}'
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS idx_search_doc_source
+ON search_doc(project, agent, source_table, source_id)
+WHERE source_table IS NOT NULL AND source_id IS NOT NULL;
+
+CREATE VIRTUAL TABLE IF NOT EXISTS search_fts USING fts5(
+  title,
+  body,
+  summary,
+  content='search_doc',
+  content_rowid='id'
+);
+
+CREATE TRIGGER IF NOT EXISTS search_doc_ai AFTER INSERT ON search_doc
+WHEN new.sensitive = 0 AND new.indexable = 1
+BEGIN
+  INSERT INTO search_fts(rowid, title, body, summary)
+  VALUES (new.id, new.title, new.body, new.summary);
+END;
+
+CREATE TRIGGER IF NOT EXISTS search_doc_ad AFTER DELETE ON search_doc
+WHEN old.sensitive = 0 AND old.indexable = 1
+BEGIN
+  INSERT INTO search_fts(search_fts, rowid, title, body, summary)
+  VALUES ('delete', old.id, old.title, old.body, old.summary);
+END;
+
+CREATE TRIGGER IF NOT EXISTS search_doc_au AFTER UPDATE ON search_doc
+BEGIN
+  INSERT INTO search_fts(search_fts, rowid, title, body, summary)
+  SELECT 'delete', old.id, old.title, old.body, old.summary
+  WHERE old.sensitive = 0 AND old.indexable = 1;
+
+  INSERT INTO search_fts(rowid, title, body, summary)
+  SELECT new.id, new.title, new.body, new.summary
+  WHERE new.sensitive = 0 AND new.indexable = 1;
+END;

package/skills/security-and-hardening/SKILL.md

@@ -0,0 +1,369 @@
+---
+name: security-and-hardening
+description: Perform a bounded security design/hardening pass for explicit security or threat-model intent, or a concrete auth/authorization/secret/untrusted-input/file-upload/sensitive-data risk; do not trigger for every input, data store, third-party call, implementation, review, or release.
+---
+
+# Security and Hardening
+
+## Overview
+
+Security-first development practices for web applications. Treat every external input as hostile, every secret as sacred, and every authorization check as mandatory. Security isn't a phase — it's a constraint on every line of code that touches user data, authentication, or external systems.
+
+## When to Use
+
+- The user explicitly asks for security review, hardening, or threat modeling.
+- The accepted scope changes authentication, authorization, sessions, secrets, permissions, sensitive/PII/payment data, uploads, or another named trust boundary.
+- A concrete untrusted-input or external-callback path has a material vulnerability question the primary owner cannot resolve inline.
+
+Near misses: ordinary validated form work, a routine API call, generic data storage, release preparation, or code review without a named security gap does not select this skill automatically.
+
+ROSE/`aili-delivery-flow` owns lifecycle state, material decisions, exact security-sensitive operation approvals, and verification. This skill performs one bounded security loop and returns `complete`, `need-user`, `need-evidence`, `material-delta`, `blocked`, or `Unverified`. It does not invoke review, audit, testing, source research, release, or another process skill. Exact auth/security/dependency/external/secret gates and canonical claim-matched verification override generic checklist breadth below.
+
+## The Three-Tier Boundary System
+
+### Always Do (No Exceptions)
+
+- **Validate all external input** at the system boundary (API routes, form handlers)
+- **Parameterize all database queries** — never concatenate user input into SQL
+- **Encode output** to prevent XSS (use framework auto-escaping, don't bypass it)
+- **Use HTTPS** for all external communication
+- **Hash passwords** with bcrypt/scrypt/argon2 (never store plaintext)
+- **Set security headers** (CSP, HSTS, X-Frame-Options, X-Content-Type-Options)
+- **Use httpOnly, secure, sameSite cookies** for sessions
+- **Use current dependency-advisory evidence** when the selected release/security claim needs it; never run a network-capable audit automatically
+
+### Ask First (Requires Human Approval)
+
+- Adding new authentication flows or changing auth logic
+- Storing new categories of sensitive data (PII, payment info)
+- Adding new external service integrations
+- Changing CORS configuration
+- Adding file upload handlers
+- Modifying rate limiting or throttling
+- Granting elevated permissions or roles
+
+🔴 **CHECKPOINT — High-risk security decisions:** stop for explicit approval before changing authentication/session behavior, storing or exposing new PII, relaxing CORS, adding uploads, changing authorization roles, or weakening rate limits/security headers. State the threat, data affected, and rollback path before editing.
+
+### Never Do
+
+- **Never commit secrets** to version control (API keys, passwords, tokens)
+- **Never log sensitive data** (passwords, tokens, full credit card numbers)
+- **Never trust client-side validation** as a security boundary
+- **Never disable security headers** for convenience
+- **Never use `eval()` or `innerHTML`** with user-provided data
+- **Never store sessions in client-accessible storage** (localStorage for auth tokens)
+- **Never expose stack traces** or internal error details to users
+
+## Security Decision Gates
+
+| Area | Stop before | Required evidence before implementation |
+|---|---|---|
+| Auth/session | New login flow, token storage change, OAuth provider, password reset | Current auth model, token lifetime/storage, revocation/error path |
+| PII/payment | New field, logging, analytics, export, third-party sharing | Data classification, minimization plan, encryption/redaction rule |
+| CORS | Adding wildcard, credentials, new origins, proxy bypass | Exact allowed origins, credential need, environment-specific config |
+| Uploads | New file type, larger size, public storage, direct-to-cloud flow | MIME + magic-byte check, max size, storage ACL, malware/quarantine plan |
+
+If the evidence is missing, return a clarification request instead of implementing a permissive default.
+
+## OWASP Top 10 Prevention
+
+### 1. Injection (SQL, NoSQL, OS Command)
+
+```typescript
+// BAD: SQL injection via string concatenation
+const query = `SELECT * FROM users WHERE id = '${userId}'`;
+
+// GOOD: Parameterized query
+const user = await db.query('SELECT * FROM users WHERE id = $1', [userId]);
+
+// GOOD: ORM with parameterized input
+const user = await prisma.user.findUnique({ where: { id: userId } });
+```
+
+### 2. Broken Authentication
+
+```typescript
+// Password hashing
+import { hash, compare } from 'bcrypt';
+
+const SALT_ROUNDS = 12;
+const hashedPassword = await hash(plaintext, SALT_ROUNDS);
+const isValid = await compare(plaintext, hashedPassword);
+
+// Session management
+app.use(session({
+  secret: process.env.SESSION_SECRET,  // From environment, not code
+  resave: false,
+  saveUninitialized: false,
+  cookie: {
+    httpOnly: true,     // Not accessible via JavaScript
+    secure: true,       // HTTPS only
+    sameSite: 'lax',    // CSRF protection
+    maxAge: 24 * 60 * 60 * 1000,  // 24 hours
+  },
+}));
+```
+
+### 3. Cross-Site Scripting (XSS)
+
+```typescript
+// BAD: Rendering user input as HTML
+element.innerHTML = userInput;
+
+// GOOD: Use framework auto-escaping (React does this by default)
+return <div>{userInput}</div>;
+
+// If you MUST render HTML, sanitize first
+import DOMPurify from 'dompurify';
+const clean = DOMPurify.sanitize(userInput);
+```
+
+### 4. Broken Access Control
+
+```typescript
+// Always check authorization, not just authentication
+app.patch('/api/tasks/:id', authenticate, async (req, res) => {
+  const task = await taskService.findById(req.params.id);
+
+  // Check that the authenticated user owns this resource
+  if (task.ownerId !== req.user.id) {
+    return res.status(403).json({
+      error: { code: 'FORBIDDEN', message: 'Not authorized to modify this task' }
+    });
+  }
+
+  // Proceed with update
+  const updated = await taskService.update(req.params.id, req.body);
+  return res.json(updated);
+});
+```
+
+### 5. Security Misconfiguration
+
+```typescript
+// Security headers (use helmet for Express)
+import helmet from 'helmet';
+app.use(helmet());
+
+// Content Security Policy
+app.use(helmet.contentSecurityPolicy({
+  directives: {
+    defaultSrc: ["'self'"],
+    scriptSrc: ["'self'"],
+    styleSrc: ["'self'", "'unsafe-inline'"],  // Tighten if possible
+    imgSrc: ["'self'", 'data:', 'https:'],
+    connectSrc: ["'self'"],
+  },
+}));
+
+// CORS — restrict to known origins
+app.use(cors({
+  origin: process.env.ALLOWED_ORIGINS?.split(',') || 'http://localhost:3000',
+  credentials: true,
+}));
+```
+
+### 6. Sensitive Data Exposure
+
+```typescript
+// Never return sensitive fields in API responses
+function sanitizeUser(user: UserRecord): PublicUser {
+  const { passwordHash, resetToken, ...publicFields } = user;
+  return publicFields;
+}
+
+// Use environment variables for secrets
+const API_KEY = process.env.STRIPE_API_KEY;
+if (!API_KEY) throw new Error('STRIPE_API_KEY not configured');
+```
+
+## Input Validation Patterns
+
+### Schema Validation at Boundaries
+
+```typescript
+import { z } from 'zod';
+
+const CreateTaskSchema = z.object({
+  title: z.string().min(1).max(200).trim(),
+  description: z.string().max(2000).optional(),
+  priority: z.enum(['low', 'medium', 'high']).default('medium'),
+  dueDate: z.string().datetime().optional(),
+});
+
+// Validate at the route handler
+app.post('/api/tasks', async (req, res) => {
+  const result = CreateTaskSchema.safeParse(req.body);
+  if (!result.success) {
+    return res.status(422).json({
+      error: {
+        code: 'VALIDATION_ERROR',
+        message: 'Invalid input',
+        details: result.error.flatten(),
+      },
+    });
+  }
+  // result.data is now typed and validated
+  const task = await taskService.create(result.data);
+  return res.status(201).json(task);
+});
+```
+
+### File Upload Safety
+
+```typescript
+// Restrict file types and sizes
+const ALLOWED_TYPES = ['image/jpeg', 'image/png', 'image/webp'];
+const MAX_SIZE = 5 * 1024 * 1024; // 5MB
+
+function validateUpload(file: UploadedFile) {
+  if (!ALLOWED_TYPES.includes(file.mimetype)) {
+    throw new ValidationError('File type not allowed');
+  }
+  if (file.size > MAX_SIZE) {
+    throw new ValidationError('File too large (max 5MB)');
+  }
+  // Don't trust the file extension — check magic bytes if critical
+}
+```
+
+## Triaging npm audit Results
+
+Not all audit findings require immediate action. Use this decision tree:
+
+```
+npm audit reports a vulnerability
+├── Severity: critical or high
+│   ├── Is the vulnerable code reachable in your app?
+│   │   ├── YES --> Fix immediately (update, patch, or replace the dependency)
+│   │   └── NO (dev-only dep, unused code path) --> Fix soon, but not a blocker
+│   └── Is a fix available?
+│       ├── YES --> Update to the patched version
+│       └── NO --> Check for workarounds, consider replacing the dependency, or add to allowlist with a review date
+├── Severity: moderate
+│   ├── Reachable in production? --> Fix in the next release cycle
+│   └── Dev-only? --> Fix when convenient, track in backlog
+└── Severity: low
+    └── Track and fix during regular dependency updates
+```
+
+**Key questions:**
+- Is the vulnerable function actually called in your code path?
+- Is the dependency a runtime dependency or dev-only?
+- Is the vulnerability exploitable given your deployment context (e.g., a server-side vulnerability in a client-only app)?
+
+When you defer a fix, document the reason and set a review date.
+
+## Rate Limiting
+
+```typescript
+import rateLimit from 'express-rate-limit';
+
+// General API rate limit
+app.use('/api/', rateLimit({
+  windowMs: 15 * 60 * 1000, // 15 minutes
+  max: 100,                   // 100 requests per window
+  standardHeaders: true,
+  legacyHeaders: false,
+}));
+
+// Stricter limit for auth endpoints
+app.use('/api/auth/', rateLimit({
+  windowMs: 15 * 60 * 1000,
+  max: 10,  // 10 attempts per 15 minutes
+}));
+```
+
+## Secrets Management
+
+```
+.env files:
+  ├── .env.example  → Committed (template with placeholder values)
+  ├── .env          → NOT committed (contains real secrets)
+  └── .env.local    → NOT committed (local overrides)
+
+.gitignore must include:
+  .env
+  .env.local
+  .env.*.local
+  *.pem
+  *.key
+```
+
+**Always check before committing:**
+```bash
+# Check for accidentally staged secrets
+git diff --cached | grep -i "password\|secret\|api_key\|token"
+```
+
+## Security Review Checklist
+
+```markdown
+### Authentication
+- [ ] Passwords hashed with bcrypt/scrypt/argon2 (salt rounds ≥ 12)
+- [ ] Session tokens are httpOnly, secure, sameSite
+- [ ] Login has rate limiting
+- [ ] Password reset tokens expire
+
+### Authorization
+- [ ] Every endpoint checks user permissions
+- [ ] Users can only access their own resources
+- [ ] Admin actions require admin role verification
+
+### Input
+- [ ] All user input validated at the boundary
+- [ ] SQL queries are parameterized
+- [ ] HTML output is encoded/escaped
+
+### Data
+- [ ] No secrets in code or version control
+- [ ] Sensitive fields excluded from API responses
+- [ ] PII encrypted at rest (if applicable)
+
+### Infrastructure
+- [ ] Security headers configured (CSP, HSTS, etc.)
+- [ ] CORS restricted to known origins
+- [ ] Dependencies audited for vulnerabilities
+- [ ] Error messages don't expose internals
+```
+
+## Failure Handling
+
+| Trigger | First response | If unresolved |
+|---|---|---|
+| Security requirement conflicts with product request | Name the conflict and preserve the safer default | Return the exact product/security decision to ROSE; do not silently weaken controls |
+| Audit finding has no patch | Check reachability and documented workaround | Return allowlist-versus-dependency-change disposition to ROSE; do not mutate dependencies here |
+| Secret appears in diff/log | Stop, remove it from output, and tell the user rotation may be required | Do not commit or print more context; request incident handling guidance |
+| Upload/CORS/auth behavior cannot be verified | Report the unverified gate and keep restrictive behavior | Do not claim hardened/secure until evidence exists |
+
+## Common Rationalizations
+
+| Rationalization | Reality |
+|---|---|
+| "This is an internal tool, security doesn't matter" | Internal tools get compromised. Attackers target the weakest link. |
+| "We'll add security later" | Security retrofitting is 10x harder than building it in. Add it now. |
+| "No one would try to exploit this" | Automated scanners will find it. Security by obscurity is not security. |
+| "The framework handles security" | Frameworks provide tools, not guarantees. You still need to use them correctly. |
+| "It's just a prototype" | Prototypes become production. Security habits from day one. |
+
+## Red Flags
+
+- User input passed directly to database queries, shell commands, or HTML rendering
+- Secrets in source code or commit history
+- API endpoints without authentication or authorization checks
+- Missing CORS configuration or wildcard (`*`) origins
+- No rate limiting on authentication endpoints
+- Stack traces or internal errors exposed to users
+- Dependencies with known critical vulnerabilities
+
+## Verification
+
+For the selected affected security claim, use only applicable checks chosen by the canonical verification owner:
+
+- [ ] Dependency audit evidence is present only when dependency/release risk makes it relevant
+- [ ] No secrets in source code or git history
+- [ ] All user input validated at system boundaries
+- [ ] Authentication and authorization checked on every protected endpoint
+- [ ] Security headers present in response (check with browser DevTools)
+- [ ] Error responses don't expose internal details
+- [ ] Rate limiting active on auth endpoints