nubos-pilot 1.2.0 → 1.2.2

package/lib/migrate.test.cjs

@@ -0,0 +1,91 @@
+'use strict';
+
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+
+const { runMigrators, MAX_HOPS } = require('./migrate.cjs');
+const { NubosPilotError } = require('./core.cjs');
+
+test('MIG-1: object already at target version is returned unchanged', () => {
+  const obj = { version: 2, payload: 'x' };
+  const out = runMigrators(obj, { targetVersion: 2, migrators: {} });
+  assert.equal(out, obj);
+});
+
+test('MIG-2: single hop runs the matching migrator', () => {
+  const out = runMigrators({ version: 1, n: 1 }, {
+    targetVersion: 2,
+    migrators: { 1: (v) => ({ version: 2, n: v.n + 1 }) },
+  });
+  assert.deepEqual(out, { version: 2, n: 2 });
+});
+
+test('MIG-3: multi-hop chain runs each hop until target', () => {
+  const out = runMigrators({ version: 0, steps: [] }, {
+    targetVersion: 3,
+    migrators: {
+      0: (v) => ({ version: 1, steps: [...v.steps, 'a'] }),
+      1: (v) => ({ version: 2, steps: [...v.steps, 'b'] }),
+      2: (v) => ({ version: 3, steps: [...v.steps, 'c'] }),
+    },
+  });
+  assert.deepEqual(out.steps, ['a', 'b', 'c']);
+});
+
+test('MIG-4: missing migrator for a version returns null', () => {
+  const out = runMigrators({ version: 99 }, { targetVersion: 1, migrators: {} });
+  assert.equal(out, null);
+});
+
+test('MIG-5: migrator returning a non-object returns null', () => {
+  const out = runMigrators({ version: 0 }, { targetVersion: 1, migrators: { 0: () => null } });
+  assert.equal(out, null);
+});
+
+test('MIG-6: hop cap prevents an infinite migrator cycle', () => {
+  const out = runMigrators({ version: 0 }, {
+    targetVersion: 999,
+    migrators: { 0: () => ({ version: 0 }) },
+  });
+  assert.equal(out, null);
+});
+
+test('MIG-7: pure function — input object is not mutated', () => {
+  const input = { version: 0, n: 1 };
+  runMigrators(input, { targetVersion: 1, migrators: { 0: (v) => ({ version: 1, n: v.n + 1 }) } });
+  assert.deepEqual(input, { version: 0, n: 1 });
+});
+
+test('MIG-8: migrated shape is validated against the given schema', () => {
+  assert.throws(
+    () => runMigrators({ version: 0, learnings: [] }, {
+      targetVersion: 1,
+      migrators: { 0: () => ({ version: 1, learnings: [{ fingerprint: 'NOTHEX', occurrence: 1 }] }) },
+      schema: 'learnings.v1',
+      code: 'learnings-store-corrupt',
+      details: { path: '<test>' },
+    }),
+    (err) => err instanceof NubosPilotError && err.code === 'learnings-store-corrupt',
+  );
+});
+
+test('MIG-9: custom versionField is honoured', () => {
+  const out = runMigrators({ schema_version: 1, ok: true }, {
+    versionField: 'schema_version',
+    targetVersion: 1,
+    migrators: {},
+  });
+  assert.deepEqual(out, { schema_version: 1, ok: true });
+});
+
+test('MIG-10: MAX_HOPS is a finite positive cap', () => {
+  assert.ok(Number.isInteger(MAX_HOPS) && MAX_HOPS > 0);
+});
+
+test('MIG-11: a version matching an Object.prototype member returns null, not a raw throw', () => {
+  for (const poison of ['valueOf', 'hasOwnProperty', 'toString', 'constructor', '__proto__']) {
+    let out;
+    assert.doesNotThrow(() => { out = runMigrators({ version: poison }, { targetVersion: 1, migrators: {} }); });
+    assert.equal(out, null);
+  }
+});

package/lib/schemas/data/checkpoint.v1.json

@@ -0,0 +1,13 @@
+{
+  "$id": "checkpoint.v1",
+  "title": "Task checkpoint (checkpoints/<task_id>.json)",
+  "type": "object",
+  "required": ["schema_version"],
+  "properties": {
+    "schema_version": { "type": "integer", "minimum": 1 },
+    "task_id": { "type": "string" },
+    "status": { "type": "string" },
+    "files_touched": { "type": "array" },
+    "nubosloop": { "type": "object" }
+  }
+}

package/lib/schemas/data/codebase-manifest.v1.json

@@ -0,0 +1,22 @@
+{
+  "$id": "codebase-manifest.v1",
+  "title": "Codebase hash manifest (codebase/.hashes.json)",
+  "type": "object",
+  "required": ["schema_version"],
+  "properties": {
+    "schema_version": { "type": "integer", "minimum": 1 },
+    "generated_at": { "type": ["string", "null"] },
+    "files": {
+      "type": "object",
+      "additionalProperties": {
+        "type": "object",
+        "required": ["sha256"],
+        "properties": {
+          "sha256": { "type": "string" },
+          "size": { "type": "integer", "minimum": 0 },
+          "ext": { "type": "string" }
+        }
+      }
+    }
+  }
+}

package/lib/schemas/data/learnings.v1.json

@@ -0,0 +1,28 @@
+{
+  "$id": "learnings.v1",
+  "title": "Learnings store (knowledge/learnings.json)",
+  "type": "object",
+  "required": ["version", "learnings"],
+  "properties": {
+    "version": { "type": "integer", "minimum": 1 },
+    "learnings": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["fingerprint", "pattern", "outcome", "occurrence", "first_seen", "last_seen"],
+        "properties": {
+          "fingerprint": { "type": "string", "pattern": "^[a-f0-9]{16}$" },
+          "pattern": { "type": "string", "maxBytes": 4096 },
+          "outcome": { "type": "string", "maxBytes": 4096 },
+          "occurrence": { "type": "integer", "minimum": 1 },
+          "first_seen": { "type": "string" },
+          "last_seen": { "type": "string" },
+          "tokens": { "type": "array", "items": { "type": "string" } },
+          "task_ids": { "type": "array", "items": { "type": "string" } },
+          "milestone_ids": { "type": "array", "items": { "type": "string" } },
+          "outcome_history": { "type": "array" }
+        }
+      }
+    }
+  }
+}

package/lib/schemas/data/memory-manifest.v1.json

@@ -0,0 +1,14 @@
+{
+  "$id": "memory-manifest.v1",
+  "title": "Memory manifest (memory/manifest.json)",
+  "type": "object",
+  "required": ["schema_version", "model", "dim"],
+  "properties": {
+    "schema_version": { "type": "integer", "minimum": 1 },
+    "model": { "type": "string", "minLength": 1 },
+    "dim": { "type": "integer", "minimum": 1 },
+    "alpha": { "type": "number" },
+    "created_at": { "type": "string" },
+    "rebuilt_at": { "type": "string" }
+  }
+}

package/lib/schemas/data/memory-record.v1.json

@@ -0,0 +1,16 @@
+{
+  "$id": "memory-record.v1",
+  "title": "Memory record (memory/records.jsonl line)",
+  "type": "object",
+  "required": ["type", "title", "body"],
+  "properties": {
+    "type": { "enum": ["learning", "handoff", "critic", "research"] },
+    "title": { "type": "string", "minLength": 1 },
+    "body": { "type": "string" },
+    "tags": { "type": ["array", "null"] },
+    "provenance": { "enum": ["VERIFIED", "CITED", "ASSUMED", "CACHED", null] },
+    "id": { "type": ["string", "null"] },
+    "phase": { "type": ["string", "null"] },
+    "created_at": { "type": ["string", "null"] }
+  }
+}

package/lib/schemas/data/message.v1.json

@@ -0,0 +1,19 @@
+{
+  "$id": "message.v1",
+  "title": "Inter-agent message (messages/inbox/<agent>/<id>.json)",
+  "type": "object",
+  "required": ["id", "from", "to", "phase", "kind", "subject", "body", "created_at"],
+  "properties": {
+    "id": { "type": "string", "pattern": "^\\d+-[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$" },
+    "from": { "type": "string", "pattern": "^[a-zA-Z0-9_-]+$" },
+    "to": { "type": "string", "pattern": "^[a-zA-Z0-9_-]+$" },
+    "phase": { "type": "string", "minLength": 1 },
+    "round": { "type": ["integer", "null"], "minimum": 0 },
+    "kind": { "enum": ["request", "response", "notify"] },
+    "subject": { "type": "string", "minLength": 1 },
+    "body": { "type": "string", "maxBytes": 262144 },
+    "expects_reply": { "type": "boolean" },
+    "in_reply_to": { "type": ["string", "null"] },
+    "created_at": { "type": "string" }
+  }
+}

package/lib/schemas/data/metrics-record.v1.json

@@ -0,0 +1,11 @@
+{
+  "$id": "metrics-record.v1",
+  "title": "Metrics record (metrics/phase-<phase>.jsonl, meta.jsonl line)",
+  "type": "object",
+  "properties": {
+    "duration_ms": { "type": ["number", "null"], "minimum": 0 },
+    "tokens_in": { "type": ["number", "null"] },
+    "tokens_out": { "type": ["number", "null"] },
+    "retry_count": { "type": ["number", "null"], "minimum": 0 }
+  }
+}

package/lib/security/ledger.cjs

@@ -0,0 +1,203 @@
+'use strict';
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const { withFileLock, atomicWriteFileSync } = require('../core.cjs');
+
+const LEDGER_VERSION = 1;
+const RISK_SEVERITIES = new Set(['risk', 'high', 'critical', 'fail']);
+
+function sanitizeSid(sid) {
+  return String(sid || '').replace(/[^a-zA-Z0-9._-]/g, '_');
+}
+
+function ledgerPath(sid) {
+  return path.join(os.tmpdir(), 'claude-sec-' + sanitizeSid(sid) + '.json');
+}
+
+function _skeleton(sid) {
+  return {
+    session_id: String(sid || ''),
+    version: LEDGER_VERSION,
+    created_at: Date.now(),
+    baseline: null,
+    seen_scan: {},
+    findings: [],
+    review_in_flight: null,
+    stop_streak: 0,
+    commit_review_times: [],
+  };
+}
+
+function _read(sid) {
+  const p = ledgerPath(sid);
+  let raw;
+  try { raw = fs.readFileSync(p, 'utf-8'); }
+  catch { return _skeleton(sid); }
+  if (!raw || raw.trim() === '') return _skeleton(sid);
+  let parsed;
+  try { parsed = JSON.parse(raw); }
+  catch { return _skeleton(sid); }
+  if (!parsed || typeof parsed !== 'object') return _skeleton(sid);
+  return Object.assign(_skeleton(sid), parsed);
+}
+
+function _isPidAlive(pid) {
+  if (!Number.isInteger(pid)) return false;
+  try { process.kill(pid, 0); return true; }
+  catch (err) { return !!(err && err.code === 'EPERM'); }
+}
+
+function withLedger(sid, fn) {
+  const p = ledgerPath(sid);
+  return withFileLock(p, () => {
+    const ledger = _read(sid);
+    const result = fn(ledger);
+    atomicWriteFileSync(p, JSON.stringify(ledger), 'utf-8', 0o600);
+    return result;
+  });
+}
+
+function readLedger(sid) {
+  return _read(sid);
+}
+
+function initSession(sid) {
+  return withLedger(sid, (l) => { l.created_at = l.created_at || Date.now(); return { session_id: l.session_id }; });
+}
+
+function setBaseline(sid, baseline) {
+  return withLedger(sid, (l) => {
+    l.baseline = Object.assign({ captured_at: Date.now() }, baseline || {});
+    return l.baseline;
+  });
+}
+
+function _scanKey(f) {
+  return String(f.file) + '::' + String(f.rule_name);
+}
+
+function markScanReported(sid, findings) {
+  const list = Array.isArray(findings) ? findings : [];
+  return withLedger(sid, (l) => {
+    const fresh = [];
+    for (const f of list) {
+      const key = _scanKey(f);
+      if (l.seen_scan[key]) continue;
+      l.seen_scan[key] = true;
+      fresh.push(f);
+    }
+    return fresh;
+  });
+}
+
+function _fingerprint(f) {
+  return [
+    String(f.file || ''),
+    String(f.line == null ? '' : f.line),
+    String(f.category || ''),
+    String(f.rule_name || f.title || ''),
+  ].join('|');
+}
+
+function addReviewFindings(sid, findings, layer) {
+  const list = Array.isArray(findings) ? findings : [];
+  return withLedger(sid, (l) => {
+    const existing = new Set(l.findings.map((f) => f.fp));
+    let added = 0;
+    for (const f of list) {
+      const fp = _fingerprint(f);
+      if (existing.has(fp)) continue;
+      existing.add(fp);
+      l.findings.push({
+        fp,
+        file: f.file || null,
+        line: f.line == null ? null : f.line,
+        category: f.category || null,
+        severity: f.severity || 'risk',
+        title: f.title || f.rule_name || null,
+        mitigation_hint: f.mitigation_hint || f.reminder || null,
+        layer: layer || null,
+        surfaced: false,
+        addressed: false,
+        created_at: Date.now(),
+      });
+      added++;
+    }
+    return { added };
+  });
+}
+
+function takeUnsurfacedRisks(sid, opts) {
+  const maxStreak = opts && Number.isFinite(opts.maxStreak) ? opts.maxStreak : 3;
+  return withLedger(sid, (l) => {
+    const unsurfaced = l.findings.filter((f) => !f.surfaced && RISK_SEVERITIES.has(String(f.severity)));
+    if (unsurfaced.length === 0) {
+      l.stop_streak = 0;
+      return { findings: [], yielded: false };
+    }
+    if (l.stop_streak >= maxStreak) {
+      for (const f of unsurfaced) f.surfaced = true;
+      l.stop_streak = 0;
+      return { findings: [], yielded: true };
+    }
+    for (const f of unsurfaced) f.surfaced = true;
+    l.stop_streak += 1;
+    return { findings: unsurfaced.map((f) => ({ ...f })), yielded: false };
+  });
+}
+
+function tryBeginReview(sid, opts) {
+  const staleMs = opts && Number.isFinite(opts.staleMs) ? opts.staleMs : 5 * 60 * 1000;
+  return withLedger(sid, (l) => {
+    const cur = l.review_in_flight;
+    if (cur && typeof cur === 'object') {
+      const age = Date.now() - Number(cur.started_at || 0);
+      const stale = age > staleMs || !_isPidAlive(Number(cur.pid));
+      if (!stale) return { began: false, reason: 'in-flight' };
+    }
+    l.review_in_flight = { pid: process.pid, started_at: Date.now() };
+    return { began: true };
+  });
+}
+
+function endReview(sid) {
+  return withLedger(sid, (l) => { l.review_in_flight = null; return { ok: true }; });
+}
+
+function tryRecordCommitReview(sid, opts) {
+  const maxPerHour = opts && Number.isFinite(opts.maxPerHour) ? opts.maxPerHour : 20;
+  const windowMs = 60 * 60 * 1000;
+  return withLedger(sid, (l) => {
+    const now = Date.now();
+    l.commit_review_times = (l.commit_review_times || []).filter((t) => now - t < windowMs);
+    if (l.commit_review_times.length >= maxPerHour) return { allowed: false, count: l.commit_review_times.length };
+    l.commit_review_times.push(now);
+    return { allowed: true, count: l.commit_review_times.length };
+  });
+}
+
+function removeLedger(sid) {
+  try { fs.unlinkSync(ledgerPath(sid)); } catch {}
+}
+
+module.exports = {
+  LEDGER_VERSION,
+  RISK_SEVERITIES,
+  sanitizeSid,
+  ledgerPath,
+  withLedger,
+  readLedger,
+  initSession,
+  setBaseline,
+  markScanReported,
+  addReviewFindings,
+  takeUnsurfacedRisks,
+  tryBeginReview,
+  endReview,
+  tryRecordCommitReview,
+  removeLedger,
+  _fingerprint,
+};

package/lib/security/ledger.test.cjs

@@ -0,0 +1,139 @@
+'use strict';
+
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+
+const ledger = require('./ledger.cjs');
+
+let _sidCounter = 0;
+function freshSid() {
+  _sidCounter += 1;
+  return 'test-sec-' + process.pid + '-' + _sidCounter;
+}
+function cleanup(sid) {
+  ledger.removeLedger(sid);
+  try { fs.unlinkSync(ledger.ledgerPath(sid) + '.lock'); } catch {}
+}
+
+test('LED-1 scan report-once: same pattern+file reported only once per session', () => {
+  const sid = freshSid();
+  try {
+    const f = [{ file: 'a.js', rule_name: 'eval_call' }];
+    const first = ledger.markScanReported(sid, f);
+    const second = ledger.markScanReported(sid, f);
+    assert.equal(first.length, 1);
+    assert.equal(second.length, 0);
+  } finally { cleanup(sid); }
+});
+
+test('LED-2 scan dedup is per-file: same rule on a different file is fresh', () => {
+  const sid = freshSid();
+  try {
+    ledger.markScanReported(sid, [{ file: 'a.js', rule_name: 'eval_call' }]);
+    const other = ledger.markScanReported(sid, [{ file: 'b.js', rule_name: 'eval_call' }]);
+    assert.equal(other.length, 1);
+  } finally { cleanup(sid); }
+});
+
+test('LED-3 review findings dedup by fingerprint (cross-layer)', () => {
+  const sid = freshSid();
+  try {
+    const finding = { file: 'x.js', line: 10, category: 'injection', severity: 'risk', title: 'SQLi' };
+    const a = ledger.addReviewFindings(sid, [finding], 'stop');
+    const b = ledger.addReviewFindings(sid, [finding], 'commit');
+    assert.equal(a.added, 1);
+    assert.equal(b.added, 0);
+  } finally { cleanup(sid); }
+});
+
+test('LED-4 takeUnsurfacedRisks surfaces once, then nothing', () => {
+  const sid = freshSid();
+  try {
+    ledger.addReviewFindings(sid, [{ file: 'x.js', line: 1, category: 'authz', severity: 'risk', title: 'bypass' }], 'stop');
+    const first = ledger.takeUnsurfacedRisks(sid, { maxStreak: 3 });
+    const second = ledger.takeUnsurfacedRisks(sid, { maxStreak: 3 });
+    assert.equal(first.findings.length, 1);
+    assert.equal(second.findings.length, 0);
+  } finally { cleanup(sid); }
+});
+
+test('LED-5 only risk-class severities surface; warn does not block', () => {
+  const sid = freshSid();
+  try {
+    ledger.addReviewFindings(sid, [{ file: 'x.js', line: 2, category: 'style', severity: 'warn', title: 'nit' }], 'stop');
+    const r = ledger.takeUnsurfacedRisks(sid, {});
+    assert.equal(r.findings.length, 0);
+  } finally { cleanup(sid); }
+});
+
+test('LED-6 a single surfacing drains all currently-unsurfaced risks at once', () => {
+  const sid = freshSid();
+  try {
+    for (let i = 0; i < 5; i++) {
+      ledger.addReviewFindings(sid, [{ file: 'f' + i + '.js', line: i, category: 'injection', severity: 'risk', title: 't' + i }], 'stop');
+    }
+    const r1 = ledger.takeUnsurfacedRisks(sid, { maxStreak: 3 });
+    const r2 = ledger.takeUnsurfacedRisks(sid, { maxStreak: 3 });
+    assert.equal(r1.findings.length, 5);
+    assert.equal(r2.findings.length, 0);
+  } finally { cleanup(sid); }
+});
+
+test('LED-6b once streak hits max with leftovers, it yields back to the user', () => {
+  const sid = freshSid();
+  try {
+    let streak = 0;
+    let yielded = false;
+    for (let turn = 0; turn < 10; turn++) {
+      ledger.addReviewFindings(sid, [{ file: 'g' + turn + '.js', line: turn, category: 'injection', severity: 'risk', title: 'g' + turn }], 'stop');
+      const r = ledger.takeUnsurfacedRisks(sid, { maxStreak: 3 });
+      if (r.yielded) { yielded = true; break; }
+      streak++;
+    }
+    assert.ok(yielded, 'should yield within a few turns');
+    assert.ok(streak <= 3, 'never more than maxStreak consecutive blocks');
+  } finally { cleanup(sid); }
+});
+
+test('LED-7 concurrency guard: second begin while in-flight is rejected', () => {
+  const sid = freshSid();
+  try {
+    const a = ledger.tryBeginReview(sid, {});
+    const b = ledger.tryBeginReview(sid, {});
+    assert.equal(a.began, true);
+    assert.equal(b.began, false);
+    ledger.endReview(sid);
+    const c = ledger.tryBeginReview(sid, {});
+    assert.equal(c.began, true);
+  } finally { cleanup(sid); }
+});
+
+test('LED-7b stale in-flight (old timestamp) is reclaimed', () => {
+  const sid = freshSid();
+  try {
+    ledger.tryBeginReview(sid, {});
+    ledger.withLedger(sid, (l) => { l.review_in_flight.started_at = Date.now() - 10 * 60 * 1000; });
+    const c = ledger.tryBeginReview(sid, { staleMs: 5 * 60 * 1000 });
+    assert.equal(c.began, true);
+  } finally { cleanup(sid); }
+});
+
+test('LED-8 commit rolling-hour cap enforced', () => {
+  const sid = freshSid();
+  try {
+    let lastAllowed = true;
+    for (let i = 0; i < 20; i++) lastAllowed = ledger.tryRecordCommitReview(sid, { maxPerHour: 20 }).allowed;
+    assert.equal(lastAllowed, true);
+    const over = ledger.tryRecordCommitReview(sid, { maxPerHour: 20 });
+    assert.equal(over.allowed, false);
+  } finally { cleanup(sid); }
+});
+
+test('LED-9 baseline round-trips', () => {
+  const sid = freshSid();
+  try {
+    ledger.setBaseline(sid, { head: 'abc123' });
+    assert.equal(ledger.readLedger(sid).baseline.head, 'abc123');
+  } finally { cleanup(sid); }
+});

package/lib/security/patterns.cjs

@@ -0,0 +1,119 @@
+'use strict';
+
+const BUILTIN_PATTERNS = Object.freeze([
+  {
+    rule_name: 'eval_call',
+    category: 'dynamic-exec',
+    severity: 'risk',
+    regex: '\\beval\\s*\\(',
+    reminder: 'Dynamic code execution via eval(). Avoid evaluating runtime strings; parse data explicitly.',
+  },
+  {
+    rule_name: 'new_function',
+    category: 'dynamic-exec',
+    severity: 'risk',
+    regex: 'new\\s+Function\\s*\\(',
+    reminder: 'new Function() evaluates strings as code. Replace with explicit logic or a safe parser.',
+  },
+  {
+    rule_name: 'node_child_process_exec',
+    category: 'dynamic-exec',
+    severity: 'risk',
+    regex: 'child_process\\.(exec|execSync)\\s*\\(',
+    reminder: 'Shell exec of a string is injection-prone. Prefer execFile/spawn with an argv array.',
+  },
+  {
+    rule_name: 'python_os_system',
+    category: 'dynamic-exec',
+    severity: 'risk',
+    regex: '\\bos\\.system\\s*\\(',
+    reminder: 'os.system runs a shell command string. Use subprocess.run([...]) with a list, shell=False.',
+  },
+  {
+    rule_name: 'python_subprocess_shell',
+    category: 'dynamic-exec',
+    severity: 'risk',
+    regex: 'subprocess\\.(call|run|Popen|check_output)\\s*\\([^)]*shell\\s*=\\s*True',
+    reminder: 'subprocess with shell=True is injection-prone. Pass an argument list and shell=False.',
+  },
+  {
+    rule_name: 'python_pickle_load',
+    category: 'unsafe-deserialization',
+    severity: 'risk',
+    regex: '\\bpickle\\.loads?\\s*\\(',
+    reminder: 'pickle deserialization executes arbitrary code on untrusted input. Use json or a safe format.',
+  },
+  {
+    rule_name: 'yaml_unsafe_load',
+    category: 'unsafe-deserialization',
+    severity: 'risk',
+    regex: 'yaml\\.load\\s*\\((?![^)]*Safe)',
+    reminder: 'yaml.load without SafeLoader can instantiate arbitrary objects. Use yaml.safe_load.',
+  },
+  {
+    rule_name: 'php_unserialize',
+    category: 'unsafe-deserialization',
+    severity: 'risk',
+    regex: '\\bunserialize\\s*\\(',
+    reminder: 'unserialize() on untrusted input enables object injection. Use json_decode for data.',
+  },
+  {
+    rule_name: 'react_dangerously_set_inner_html',
+    category: 'dom-injection',
+    severity: 'risk',
+    substrings: ['dangerouslySetInnerHTML'],
+    reminder: 'dangerouslySetInnerHTML can introduce XSS. Sanitize input or render as text.',
+  },
+  {
+    rule_name: 'dom_inner_html_assignment',
+    category: 'dom-injection',
+    severity: 'risk',
+    regex: '\\.innerHTML\\s*=',
+    reminder: 'Assigning to .innerHTML with untrusted data is an XSS vector. Use textContent or sanitize.',
+  },
+  {
+    rule_name: 'dom_document_write',
+    category: 'dom-injection',
+    severity: 'risk',
+    regex: 'document\\.write\\s*\\(',
+    reminder: 'document.write with dynamic input enables XSS. Build DOM nodes explicitly instead.',
+  },
+  {
+    rule_name: 'github_workflow_edit',
+    category: 'workflow-file',
+    severity: 'warn',
+    path_only: true,
+    paths: ['**/.github/workflows/**'],
+    reminder: 'Workflow files can grant repository-level permissions. Review trigger and permission scope.',
+  },
+  {
+    rule_name: 'private_key_block',
+    category: 'hardcoded-secret',
+    severity: 'risk',
+    regex: '-----BEGIN (?:RSA |EC |OPENSSH |DSA |PGP )?PRIVATE KEY-----',
+    reminder: 'Hardcoded private key material. Load keys from a secret manager, never from source.',
+  },
+  {
+    rule_name: 'aws_access_key_id',
+    category: 'hardcoded-secret',
+    severity: 'risk',
+    regex: '\\b(?:AKIA|ASIA)[0-9A-Z]{16}\\b',
+    reminder: 'Hardcoded AWS access key id. Move credentials to the secret manager / environment.',
+  },
+  {
+    rule_name: 'stripe_live_secret',
+    category: 'hardcoded-secret',
+    severity: 'risk',
+    substrings: ['sk_live_'],
+    reminder: 'Hardcoded live Stripe secret key prefix. Load credentials from the secret manager.',
+  },
+  {
+    rule_name: 'generic_secret_assignment',
+    category: 'hardcoded-secret',
+    severity: 'warn',
+    regex: '(?:password|passwd|secret|api[_-]?key|access[_-]?token|auth[_-]?token)\\s*[:=]\\s*[\'"][^\'"\\s]{8,}[\'"]',
+    reminder: 'Looks like a hardcoded credential. Load it from configuration / a secret manager instead.',
+  },
+]);
+
+module.exports = { BUILTIN_PATTERNS };