nubos-pilot 1.2.0 → 1.2.2

package/bin/np-tools/security.cjs

@@ -0,0 +1,177 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const child_process = require('node:child_process');
+
+const { tryReadConfigPath } = require('../../lib/config.cjs');
+const scan = require('../../lib/security/scan.cjs');
+const ledger = require('../../lib/security/ledger.cjs');
+const review = require('../../lib/security/review.cjs');
+const args = require('./_args.cjs');
+
+const COMMIT_RE = /\bgit\b[\s\S]*\b(commit|push)\b/;
+
+function _readStdin() {
+  return new Promise((resolve) => {
+    if (process.stdin.isTTY) return resolve('');
+    let buf = '';
+    process.stdin.setEncoding('utf-8');
+    const timer = setTimeout(() => { try { process.stdin.removeAllListeners(); } catch {} resolve(buf); }, 800);
+    process.stdin.on('data', (c) => { buf += c; });
+    process.stdin.on('end', () => { clearTimeout(timer); resolve(buf); });
+    process.stdin.on('error', () => { clearTimeout(timer); resolve(buf); });
+  });
+}
+
+function _safeParse(s) { try { return s ? JSON.parse(s) : {}; } catch { return {}; }}
+
+async function _payload(argv) {
+  const inline = args.getFlag(argv, '--payload', { allowDashValues: true });
+  if (inline !== undefined) return _safeParse(inline);
+  if (argv.includes('--stdin')) return _safeParse(await _readStdin());
+  return {};
+}
+
+function _cfg(cwd) {
+  return {
+    enabled: tryReadConfigPath(cwd, 'security.enabled', true) !== false,
+    scan_on_write: tryReadConfigPath(cwd, 'security.scan_on_write', true) !== false,
+    review_on_stop: tryReadConfigPath(cwd, 'security.review_on_stop', true) !== false,
+    review_on_commit: tryReadConfigPath(cwd, 'security.review_on_commit', true) !== false,
+    custom_rules_path: tryReadConfigPath(cwd, 'security.custom_rules_path', null),
+    guidance_path: tryReadConfigPath(cwd, 'security.guidance_path', null),
+    review_timeout_ms: Number(tryReadConfigPath(cwd, 'security.review_timeout_ms', 180000)) || 180000,
+    max_stop_reviews_in_a_row: Number(tryReadConfigPath(cwd, 'security.max_stop_reviews_in_a_row', 3)) || 3,
+    max_commit_reviews_per_hour: Number(tryReadConfigPath(cwd, 'security.max_commit_reviews_per_hour', 20)) || 20,
+    max_files_per_review: Number(tryReadConfigPath(cwd, 'security.max_files_per_review', 30)) || 30,
+  };
+}
+
+function _resolveRel(cwd, p) {
+  if (!p) return null;
+  return path.isAbsolute(p) ? p : path.join(cwd, p);
+}
+
+function _editedContent(toolInput) {
+  if (!toolInput || typeof toolInput !== 'object') return '';
+  if (typeof toolInput.content === 'string') return toolInput.content;
+  if (typeof toolInput.new_string === 'string') return toolInput.new_string;
+  if (typeof toolInput.new_source === 'string') return toolInput.new_source;
+  if (Array.isArray(toolInput.edits)) {
+    return toolInput.edits.map((e) => (e && typeof e.new_string === 'string' ? e.new_string : '')).join('\n');
+  }
+  return '';
+}
+
+function _editedPath(cwd, toolInput) {
+  if (!toolInput || typeof toolInput !== 'object') return '';
+  const raw = toolInput.file_path || toolInput.notebook_path || '';
+  if (!raw) return '';
+  return path.isAbsolute(raw) ? path.relative(cwd, raw) : raw;
+}
+
+function _spawnWorker(cwd, sid, mode) {
+  const npTools = path.join(__dirname, '..', '..', 'np-tools.cjs');
+  try {
+    const child = child_process.spawn(
+      process.execPath,
+      [npTools, 'security', 'run-review', '--session', sid, '--mode', mode],
+      { cwd, detached: true, stdio: 'ignore' },
+    );
+    child.unref();
+    return true;
+  } catch { return false; }
+}
+
+function _emit(stdout, obj) { stdout.write(JSON.stringify(obj)); }
+
+async function run(argv, ctx) {
+  const context = ctx || {};
+  const cwd = context.cwd || process.cwd();
+  const stdout = context.stdout || process.stdout;
+  const list = Array.isArray(argv) ? argv : [];
+  const verb = list[0];
+
+  const cfg = _cfg(cwd);
+  if (!cfg.enabled && verb !== 'run-review') return 0;
+
+  const payload = await _payload(list);
+  const sid = payload.session_id || args.getFlag(list, '--session') || '';
+
+  if (verb === 'session-start') {
+    if (sid) { try { ledger.initSession(sid); } catch {} }
+    return 0;
+  }
+
+  if (verb === 'baseline') {
+    if (sid) {
+      try { ledger.setBaseline(sid, { head: review.headSha(cwd) }); } catch {}
+    }
+    return 0;
+  }
+
+  if (verb === 'scan') {
+    if (!cfg.scan_on_write || !sid) return 0;
+    const filePath = _editedPath(cwd, payload.tool_input);
+    const content = _editedContent(payload.tool_input);
+    if (!filePath || !content) return 0;
+    let result;
+    try {
+      result = scan.scanContent({ filePath, content, customRulesPath: _resolveRel(cwd, cfg.custom_rules_path) });
+    } catch { return 0; }
+    let fresh;
+    try { fresh = ledger.markScanReported(sid, result.findings); } catch { fresh = result.findings; }
+    if (!fresh.length) return 0;
+    const lines = fresh.map((f) => '- [' + f.category + '] ' + path.basename(f.file) + ':' + f.line + ' — ' + f.reminder);
+    _emit(stdout, {
+      hookSpecificOutput: {
+        hookEventName: 'PostToolUse',
+        additionalContext: '[nubos-pilot security] potential issue(s) in just-written code:\n' + lines.join('\n')
+          + '\nConsider addressing before proceeding (non-blocking).',
+      },
+    });
+    return 0;
+  }
+
+  if (verb === 'review') {
+    if (!cfg.review_on_stop || !sid) return 0;
+    let harvest = { findings: [] };
+    try { harvest = ledger.takeUnsurfacedRisks(sid, { maxStreak: cfg.max_stop_reviews_in_a_row }); } catch {}
+    if (harvest.findings && harvest.findings.length) {
+      const lines = harvest.findings.map((f) => '- [' + (f.category || 'security') + '] '
+        + (f.file ? path.basename(String(f.file)) + (f.line ? ':' + f.line : '') + ' — ' : '')
+        + (f.title || 'security finding') + (f.mitigation_hint ? ' (' + f.mitigation_hint + ')' : ''));
+      _emit(stdout, {
+        decision: 'block',
+        reason: '[nubos-pilot security] An independent review of this turn\'s changes found '
+          + harvest.findings.length + ' security issue(s). Address them now as a follow-up, then continue:\n'
+          + lines.join('\n'),
+      });
+      return 0;
+    }
+    _spawnWorker(cwd, sid, 'stop');
+    return 0;
+  }
+
+  if (verb === 'commit') {
+    if (!cfg.review_on_commit || !sid) return 0;
+    const cmd = payload.tool_input && typeof payload.tool_input.command === 'string' ? payload.tool_input.command : '';
+    if (!cmd || !COMMIT_RE.test(cmd)) return 0;
+    let allowed = { allowed: false };
+    try { allowed = ledger.tryRecordCommitReview(sid, { maxPerHour: cfg.max_commit_reviews_per_hour }); } catch {}
+    if (allowed.allowed) _spawnWorker(cwd, sid, 'commit');
+    return 0;
+  }
+
+  if (verb === 'run-review') {
+    if (!cfg.enabled || !sid) return 0;
+    const mode = args.getFlag(list, '--mode') === 'commit' ? 'commit' : 'stop';
+    try { review.runReview({ cwd, sid, mode, config: { ...cfg, guidance_path: _resolveRel(cwd, cfg.guidance_path) } }); } catch {}
+    return 0;
+  }
+
+  return 0;
+}
+
+module.exports = { run, COMMIT_RE, _editedContent, _editedPath };

package/bin/np-tools/security.test.cjs

@@ -0,0 +1,82 @@
+'use strict';
+
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const security = require('./security.cjs');
+const ledger = require('../../lib/security/ledger.cjs');
+
+let _c = 0;
+function freshSid() { _c += 1; return 'cmd-sec-' + process.pid + '-' + _c; }
+function cleanup(sid) { ledger.removeLedger(sid); try { fs.unlinkSync(ledger.ledgerPath(sid) + '.lock'); } catch {} }
+
+function collector() {
+  const chunks = [];
+  return { stdout: { write: (s) => chunks.push(s) }, text: () => chunks.join('') };
+}
+
+async function runVerb(verb, payload, cwd, extra) {
+  const c = collector();
+  const argv = [verb, '--payload', JSON.stringify(payload), ...(extra || [])];
+  await security.run(argv, { cwd: cwd || process.cwd(), stdout: c.stdout });
+  return c.text();
+}
+
+test('SECCMD-1 scan emits additionalContext on first hit, silent on repeat (report-once)', async () => {
+  const sid = freshSid();
+  try {
+    const payload = { session_id: sid, tool_name: 'Write', tool_input: { file_path: 'x.js', content: 'const r = eval(q)' } };
+    const first = await runVerb('scan', payload);
+    const second = await runVerb('scan', payload);
+    assert.match(first, /hookSpecificOutput/);
+    assert.match(first, /nubos-pilot security/);
+    assert.equal(second, '');
+  } finally { cleanup(sid); }
+});
+
+test('SECCMD-2 review harvests unsurfaced risks and emits a non-blocking Stop block decision', async () => {
+  const sid = freshSid();
+  try {
+    ledger.addReviewFindings(sid, [{ file: 'a.js', line: 5, category: 'injection', severity: 'risk', title: 'SQLi', mitigation_hint: 'parameterize' }], 'stop');
+    const out = await runVerb('review', { session_id: sid });
+    const parsed = JSON.parse(out);
+    assert.equal(parsed.decision, 'block');
+    assert.match(parsed.reason, /nubos-pilot security/);
+    assert.match(parsed.reason, /SQLi/);
+  } finally { cleanup(sid); }
+});
+
+test('SECCMD-3 commit verb ignores non-git Bash commands', async () => {
+  const sid = freshSid();
+  try {
+    const out = await runVerb('commit', { session_id: sid, tool_name: 'Bash', tool_input: { command: 'ls -la' } });
+    assert.equal(out, '');
+    assert.equal(ledger.readLedger(sid).commit_review_times.length, 0);
+  } finally { cleanup(sid); }
+});
+
+test('SECCMD-4 master toggle off makes every hook verb a silent no-op', async () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'np-sec-proj-'));
+  fs.mkdirSync(path.join(root, '.nubos-pilot'), { recursive: true });
+  fs.writeFileSync(path.join(root, '.nubos-pilot', 'config.json'), JSON.stringify({ security: { enabled: false } }));
+  const sid = freshSid();
+  try {
+    const scanOut = await runVerb('scan', { session_id: sid, tool_name: 'Write', tool_input: { file_path: 'x.js', content: 'eval(q)' } }, root);
+    ledger.addReviewFindings(sid, [{ file: 'a.js', line: 1, category: 'x', severity: 'risk', title: 't' }], 'stop');
+    const reviewOut = await runVerb('review', { session_id: sid }, root);
+    assert.equal(scanOut, '');
+    assert.equal(reviewOut, '');
+  } finally { cleanup(sid); fs.rmSync(root, { recursive: true, force: true }); }
+});
+
+test('SECCMD-5 session-start and baseline are safe no-throw no-ops without a repo', async () => {
+  const sid = freshSid();
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'np-sec-nr-'));
+  try {
+    assert.equal(await runVerb('session-start', { session_id: sid }, root), '');
+    assert.equal(await runVerb('baseline', { session_id: sid }, root), '');
+  } finally { cleanup(sid); fs.rmSync(root, { recursive: true, force: true }); }
+});

package/lib/checkpoint.cjs

@@ -10,8 +10,10 @@ const {
 } = require('./core.cjs');
 const { parseState, serializeState } = require('./state.cjs');
 const { TASK_ID_RE } = require('./ids.cjs');
+const { assertValid } = require('./validate.cjs');
 
 const CHECKPOINT_SCHEMA_VERSION = 1;
+const STORE_SCHEMA = 'checkpoint.v1';
 
 function _assertSafeTaskId(taskId) {
   if (typeof taskId !== 'string' || !TASK_ID_RE.test(taskId)) {
@@ -78,6 +80,7 @@ function _assertCompatibleSchema(existing, cpPath) {
       },
     );
   }
+  assertValid(existing, STORE_SCHEMA, 'checkpoint-corrupt', { path: cpPath });
 }
 
 function _sliceFromTaskId(taskId) {

package/lib/codebase-graph.test.cjs

@@ -0,0 +1,174 @@
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+
+const g = require('./codebase-graph.cjs');
+
+function fact(id, directory, files, extra) {
+  const source_paths = files.map((f) => f.path);
+  return Object.assign({
+    id,
+    name: directory || 'root',
+    directory: directory || '',
+    primary_language: 'javascript',
+    language_distribution: { javascript: files.length },
+    file_count: files.length,
+    source_paths,
+    symbols: [],
+    internal_deps: [],
+    external_deps: [],
+    files,
+  }, extra || {});
+}
+
+test('CG-1: buildModuleGraph creates a node per fact', () => {
+  const facts = [
+    fact('src-auth', 'src/auth', [{ path: 'src/auth/login.js', language: 'javascript', symbols: [], deps: [] }]),
+    fact('src-db', 'src/db', [{ path: 'src/db/index.js', language: 'javascript', symbols: [], deps: [] }]),
+  ];
+  const graph = g.buildModuleGraph(facts);
+  assert.equal(graph.module_count, 2);
+  assert.deepEqual(graph.nodes.map((n) => n.id), ['src-auth', 'src-db']);
+});
+
+test('CG-2: relative import resolves to a cross-module edge', () => {
+  const facts = [
+    fact('src-auth', 'src/auth', [
+      { path: 'src/auth/login.js', language: 'javascript', symbols: [], deps: ['../db', 'bcrypt'] },
+    ]),
+    fact('src-db', 'src/db', [
+      { path: 'src/db/index.js', language: 'javascript', symbols: [], deps: [] },
+    ]),
+  ];
+  const graph = g.buildModuleGraph(facts);
+  assert.equal(graph.edge_count, 1);
+  assert.deepEqual(graph.edges[0], { from: 'src-auth', to: 'src-db', weight: 1 });
+});
+
+test('CG-3: external (non-relative) deps never become edges', () => {
+  const facts = [
+    fact('src-auth', 'src/auth', [
+      { path: 'src/auth/login.js', language: 'javascript', symbols: [], deps: ['bcrypt', 'node:fs'] },
+    ]),
+  ];
+  const graph = g.buildModuleGraph(facts);
+  assert.equal(graph.edge_count, 0);
+});
+
+test('CG-4: same-module relative import is not a self-edge', () => {
+  const facts = [
+    fact('src-auth', 'src/auth', [
+      { path: 'src/auth/login.js', language: 'javascript', symbols: [], deps: ['./session'] },
+      { path: 'src/auth/session.js', language: 'javascript', symbols: [], deps: [] },
+    ]),
+  ];
+  const graph = g.buildModuleGraph(facts);
+  assert.equal(graph.edge_count, 0);
+});
+
+test('CG-5: repeated imports raise edge weight', () => {
+  const facts = [
+    fact('a', 'a', [
+      { path: 'a/one.js', language: 'javascript', symbols: [], deps: ['../b'] },
+      { path: 'a/two.js', language: 'javascript', symbols: [], deps: ['../b/helper'] },
+    ]),
+    fact('b', 'b', [
+      { path: 'b/index.js', language: 'javascript', symbols: [], deps: [] },
+      { path: 'b/helper.js', language: 'javascript', symbols: [], deps: [] },
+    ]),
+  ];
+  const graph = g.buildModuleGraph(facts);
+  assert.equal(graph.edges.length, 1);
+  assert.equal(graph.edges[0].weight, 2);
+});
+
+test('CG-6: unresolved internal-looking deps are counted, not edged', () => {
+  const facts = [
+    fact('a', 'a', [
+      { path: 'a/one.js', language: 'javascript', symbols: [], deps: ['../nonexistent'] },
+    ]),
+  ];
+  const graph = g.buildModuleGraph(facts);
+  assert.equal(graph.edge_count, 0);
+  assert.equal(graph.metrics.unresolved_internal_deps, 1);
+});
+
+test('CG-7: Tarjan detects a 2-module cycle', () => {
+  const facts = [
+    fact('a', 'a', [{ path: 'a/x.js', language: 'javascript', symbols: [], deps: ['../b'] }]),
+    fact('b', 'b', [{ path: 'b/index.js', language: 'javascript', symbols: [], deps: ['../a'] }]),
+  ];
+  const graph = g.buildModuleGraph(facts);
+  assert.equal(graph.cycles.length, 1);
+  assert.deepEqual(graph.cycles[0], ['a', 'b']);
+});
+
+test('CG-8: acyclic graph reports no cycles', () => {
+  const facts = [
+    fact('a', 'a', [{ path: 'a/x.js', language: 'javascript', symbols: [], deps: ['../b'] }]),
+    fact('b', 'b', [{ path: 'b/index.js', language: 'javascript', symbols: [], deps: ['../c'] }]),
+    fact('c', 'c', [{ path: 'c/index.js', language: 'javascript', symbols: [], deps: [] }]),
+  ];
+  const graph = g.buildModuleGraph(facts);
+  assert.equal(graph.cycles.length, 0);
+});
+
+test('CG-9: transitive dependents (impact) walk the reverse graph', () => {
+  const facts = [
+    fact('a', 'a', [{ path: 'a/x.js', language: 'javascript', symbols: [], deps: ['../b'] }]),
+    fact('b', 'b', [{ path: 'b/index.js', language: 'javascript', symbols: [], deps: ['../c'] }]),
+    fact('c', 'c', [{ path: 'c/index.js', language: 'javascript', symbols: [], deps: [] }]),
+  ];
+  const graph = g.buildModuleGraph(facts);
+  assert.deepEqual(g.transitiveDependents(graph, 'c'), ['a', 'b']);
+  assert.deepEqual(g.directDependents(graph, 'c'), ['b']);
+  assert.deepEqual(g.transitiveDependencies(graph, 'a'), ['b', 'c']);
+  assert.deepEqual(g.directDependencies(graph, 'a'), ['b']);
+});
+
+test('CG-10: deterministic clustering groups a connected component together', () => {
+  const facts = [
+    fact('a', 'a', [{ path: 'a/x.js', language: 'javascript', symbols: [], deps: ['../b'] }]),
+    fact('b', 'b', [{ path: 'b/index.js', language: 'javascript', symbols: [], deps: ['../a'] }]),
+    fact('lonely', 'lonely', [{ path: 'lonely/z.js', language: 'javascript', symbols: [], deps: [] }]),
+  ];
+  const graph = g.buildModuleGraph(facts);
+  const first = g.buildModuleGraph(facts);
+  assert.deepEqual(graph.clusters, first.clusters);
+  const clusterAB = graph.clusters.find((c) => c.members.includes('a'));
+  assert.ok(clusterAB.members.includes('b'));
+  assert.ok(!clusterAB.members.includes('lonely'));
+});
+
+test('CG-11: cycleFor and clusterOf locate a module', () => {
+  const facts = [
+    fact('a', 'a', [{ path: 'a/x.js', language: 'javascript', symbols: [], deps: ['../b'] }]),
+    fact('b', 'b', [{ path: 'b/index.js', language: 'javascript', symbols: [], deps: ['../a'] }]),
+  ];
+  const graph = g.buildModuleGraph(facts);
+  assert.deepEqual(g.cycleFor(graph, 'a'), ['a', 'b']);
+  assert.equal(typeof g.clusterOf(graph, 'a'), 'number');
+  assert.equal(g.cycleFor(graph, 'missing'), null);
+  assert.equal(g.clusterOf(graph, 'missing'), null);
+});
+
+test('CG-12: root-relative (/-prefixed) deps resolve from project root', () => {
+  const facts = [
+    fact('src-auth', 'src/auth', [
+      { path: 'src/auth/login.js', language: 'javascript', symbols: [], deps: ['/src/db'] },
+    ]),
+    fact('src-db', 'src/db', [
+      { path: 'src/db/index.js', language: 'javascript', symbols: [], deps: [] },
+    ]),
+  ];
+  const graph = g.buildModuleGraph(facts);
+  assert.equal(graph.edge_count, 1);
+  assert.deepEqual(graph.edges[0], { from: 'src-auth', to: 'src-db', weight: 1 });
+});
+
+test('CG-13: empty facts yield an empty graph', () => {
+  const graph = g.buildModuleGraph([]);
+  assert.equal(graph.module_count, 0);
+  assert.equal(graph.edge_count, 0);
+  assert.deepEqual(graph.cycles, []);
+  assert.deepEqual(graph.clusters, []);
+});

package/lib/codebase-manifest.cjs

@@ -3,8 +3,10 @@
 const fs = require('node:fs');
 const path = require('node:path');
 const { atomicWriteFileSync, NubosPilotError } = require('./core.cjs');
+const { assertValid } = require('./validate.cjs');
 
 const SCHEMA_VERSION = 1;
+const STORE_SCHEMA = 'codebase-manifest.v1';
 const CODEBASE_DIR_NAME = 'codebase';
 const MANIFEST_FILENAME = '.hashes.json';
 
@@ -63,6 +65,7 @@ function readManifest(projectRoot) {
     );
   }
   if (!parsed.files || typeof parsed.files !== 'object') parsed.files = {};
+  assertValid(parsed, STORE_SCHEMA, 'manifest-invalid-shape', { path: p });
   return parsed;
 }
 

package/lib/config-defaults.cjs

@@ -41,6 +41,23 @@ const DEFAULT_SWARM = Object.freeze({
   knowledge_adapter: 'local',
 });
 
+const DEFAULT_SECURITY = Object.freeze({
+  enabled: true,
+  scan_on_write: true,
+  review_on_stop: true,
+  review_on_commit: true,
+  custom_rules_path: null,
+  guidance_path: null,
+  review_timeout_ms: 180000,
+  max_stop_reviews_in_a_row: 3,
+  max_commit_reviews_per_hour: 20,
+  max_files_per_review: 30,
+});
+
+const DEFAULT_CONFORMANCE = Object.freeze({
+  inject_criteria: true,
+});
+
 const DEFAULT_AUTO_LOG_LEARNING = true;
 
 const DEFAULT_SPAWN_HEADLESS = Object.freeze({
@@ -67,6 +84,8 @@ const DEFAULT_CONFIG_TREE = Object.freeze({
   loop: DEFAULT_LOOP,
   swarm: DEFAULT_SWARM,
   spawn: DEFAULT_SPAWN,
+  security: DEFAULT_SECURITY,
+  conformance: DEFAULT_CONFORMANCE,
   auto_log_learning: DEFAULT_AUTO_LOG_LEARNING,
 });
 
@@ -98,6 +117,8 @@ function buildInstallConfig(answers) {
         fallback_on_error: DEFAULT_SPAWN_HEADLESS.fallback_on_error,
       },
     },
+    security: { ...DEFAULT_SECURITY },
+    conformance: { ...DEFAULT_CONFORMANCE },
     auto_log_learning: DEFAULT_AUTO_LOG_LEARNING,
   };
 }
@@ -112,6 +133,8 @@ module.exports = {
   DEFAULT_SWARM_CRITIC,
   DEFAULT_SPAWN,
   DEFAULT_SPAWN_HEADLESS,
+  DEFAULT_SECURITY,
+  DEFAULT_CONFORMANCE,
   DEFAULT_AUTO_LOG_LEARNING,
   DEFAULT_MODEL_PROFILE,
   DEFAULT_SCOPE,

package/lib/config-defaults.test.cjs

@@ -69,3 +69,18 @@ test('CFD-7: end-to-end — user answers "true" via askUser → commit_artifacts
     try { fs.rmSync(root, { recursive: true, force: true }); } catch {}
   }
 });
+
+test('CFD-SEC-1: buildInstallConfig writes always-on security defaults', () => {
+  const cfg = buildInstallConfig({ runtime: 'claude' });
+  assert.equal(cfg.security.enabled, true);
+  assert.equal(cfg.security.scan_on_write, true);
+  assert.equal(cfg.security.review_on_stop, true);
+  assert.equal(cfg.security.review_on_commit, true);
+  assert.equal(cfg.security.custom_rules_path, null);
+  assert.equal(cfg.security.max_files_per_review, 30);
+});
+
+test('CFD-CONF-1: buildInstallConfig writes conformance.inject_criteria default', () => {
+  const cfg = buildInstallConfig({ runtime: 'claude' });
+  assert.equal(cfg.conformance.inject_criteria, true);
+});

package/lib/config-schema.cjs

@@ -67,6 +67,25 @@ const SCHEMA = Object.freeze({
       },
     },
   },
+  security: {
+    type: 'object', optional: true, shape: {
+      enabled:                    { type: 'boolean', optional: true },
+      scan_on_write:              { type: 'boolean', optional: true },
+      review_on_stop:             { type: 'boolean', optional: true },
+      review_on_commit:           { type: 'boolean', optional: true },
+      custom_rules_path:          { type: 'any', optional: true },  // string | null
+      guidance_path:              { type: 'any', optional: true },  // string | null
+      review_timeout_ms:          { type: 'number', optional: true },
+      max_stop_reviews_in_a_row:  { type: 'number', optional: true },
+      max_commit_reviews_per_hour:{ type: 'number', optional: true },
+      max_files_per_review:       { type: 'number', optional: true },
+    },
+  },
+  conformance: {
+    type: 'object', optional: true, shape: {
+      inject_criteria: { type: 'boolean', optional: true },
+    },
+  },
 });
 
 function _typeOf(v) {

package/lib/config-schema.test.cjs

@@ -146,3 +146,61 @@ test('SCHEMA-SYNC-1 every top-level key in DEFAULT_CONFIG_TREE has a SCHEMA entr
       'SCHEMA.' + key + ' is neither in DEFAULT_CONFIG_TREE nor SCHEMA_ONLY_KEYS — drift');
   }
 });
+
+test('SEC-CFG-1 valid security block produces zero warnings', () => {
+  const w = validateConfig({
+    security: {
+      enabled: true,
+      scan_on_write: true,
+      review_on_stop: false,
+      review_on_commit: true,
+      custom_rules_path: '.nubos-pilot/security-rules.json',
+      guidance_path: null,
+      review_timeout_ms: 120000,
+      max_stop_reviews_in_a_row: 3,
+      max_commit_reviews_per_hour: 20,
+      max_files_per_review: 30,
+    },
+  });
+  assert.deepEqual(w, []);
+});
+
+test('SEC-CFG-2 wrong type in security flags is flagged', () => {
+  const w = validateConfig({ security: { enabled: 'yes', max_files_per_review: 'lots' } });
+  assert.equal(w.length, 2);
+  assert.ok(w.every((x) => x.kind === 'invalid-type'));
+});
+
+test('SEC-CFG-3 unknown security sub-key is flagged', () => {
+  const w = validateConfig({ security: { scan_everywhere: true } });
+  assert.equal(w.length, 1);
+  assert.equal(w[0].kind, 'unknown-key');
+  assert.equal(w[0].path, 'security.scan_everywhere');
+});
+
+test('SEC-CFG-4 default security tree validates clean', () => {
+  const defaults = require('./config-defaults.cjs');
+  assert.deepEqual(validateConfig({ security: defaults.DEFAULT_SECURITY }), []);
+});
+
+test('CONF-CFG-1 valid conformance block produces zero warnings', () => {
+  assert.deepEqual(validateConfig({ conformance: { inject_criteria: true } }), []);
+});
+
+test('CONF-CFG-2 wrong type in conformance.inject_criteria is flagged', () => {
+  const w = validateConfig({ conformance: { inject_criteria: 'yes' } });
+  assert.equal(w.length, 1);
+  assert.equal(w[0].kind, 'invalid-type');
+  assert.equal(w[0].path, 'conformance.inject_criteria');
+});
+
+test('CONF-CFG-3 unknown conformance sub-key is flagged', () => {
+  const w = validateConfig({ conformance: { review_on_executor_stop: true } });
+  assert.equal(w.length, 1);
+  assert.equal(w[0].kind, 'unknown-key');
+});
+
+test('CONF-CFG-4 default conformance tree validates clean', () => {
+  const defaults = require('./config-defaults.cjs');
+  assert.deepEqual(validateConfig({ conformance: defaults.DEFAULT_CONFORMANCE }), []);
+});