2sagaco48 1.0.0

package/src/lib/overrides/vite-native-doctor-plane.ts

@@ -0,0 +1,208 @@
+/**
+ * vite-native-doctor-plane.ts — L4: Aggregated Health & Remediation
+ * Dynamically imports all planes to avoid circular dependencies.
+ * Zero-dependency: node:* only.
+ */
+async function optionalImport(specifier: string): Promise<{ ok: boolean; mod?: any; error?: string }> {
+  try {
+    const mod = await import(specifier);
+    return { ok: true, mod };
+  } catch (e: any) {
+    return { ok: false, error: e?.message ?? 'Import failed' };
+  }
+}
+
+export type HealthStatus = 'green' | 'yellow' | 'red';
+
+export interface DoctorSection {
+  available: boolean;
+  error?: string;
+  data?: Record<string, unknown>;
+}
+
+export interface DoctorReport {
+  status: HealthStatus;
+  ts: number;
+  pressure: string;
+  criticalFailed: number;
+  highFailed: number;
+  indexConsistent: boolean;
+  recommendations: string[];
+  sections: {
+    runtime: DoctorSection;
+    policy: DoctorSection;
+    knowledge: DoctorSection;
+    contract: DoctorSection;
+    snapshot: DoctorSection;
+    selftest?: DoctorSection;
+  };
+}
+
+function pickStatus(opts: {
+  criticalFailed: number;
+  pressure: string;
+  indexConsistent: boolean;
+  highFailed: number;
+}): HealthStatus {
+  if (opts.criticalFailed > 0 || opts.pressure === 'hot') return 'red';
+  if (!opts.indexConsistent || opts.highFailed > 0 || opts.pressure === 'warm') return 'yellow';
+  return 'green';
+}
+
+export async function buildDoctorReport(opts: { deep?: boolean } = {}): Promise<DoctorReport> {
+  const ts = Date.now();
+  const recommendations: string[] = [];
+  let criticalFailed = 0;
+  let highFailed = 0;
+  let pressure = 'ok';
+  let indexConsistent = true;
+
+  // ── Runtime section ────────────────────────────────────────────────────
+  // Hand-trace: if getRuntimeStats() throws an Error:
+  //   sections.runtime = { available: true, error: 'Error message string', data: {} }
+  //   criticalFailed is NOT incremented (runtime errors are not critical failures)
+  const runtimeSection: DoctorSection = { available: true };
+  const runtimeImport = await optionalImport('./vite-native-runtime-plane.js');
+  if (!runtimeImport.ok) {
+    runtimeSection.available = true;
+    runtimeSection.error = runtimeImport.error;
+    criticalFailed++;
+  } else {
+    try {
+      const stats = runtimeImport.mod.getRuntimeStats();
+      pressure = stats.pressure;
+      runtimeSection.data = stats;
+    } catch (e: any) {
+      runtimeSection.error = e?.message ?? 'getRuntimeStats failed';
+      runtimeSection.data = {};
+    }
+  }
+
+  // ── Policy section ─────────────────────────────────────────────────────
+  const policySection: DoctorSection = { available: true };
+  const policyImport = await optionalImport('./vite-native-policy-plane.js');
+  if (!policyImport.ok) {
+    policySection.available = true;
+    policySection.error = policyImport.error;
+    criticalFailed++;
+  } else {
+    try {
+      const policy = policyImport.mod.evaluatePolicy({ pressure });
+      policySection.data = policy;
+    } catch (e: any) {
+      policySection.error = e?.message ?? 'evaluatePolicy failed';
+      highFailed++;
+    }
+  }
+
+  // ── Knowledge section ──────────────────────────────────────────────────
+  const knowledgeSection: DoctorSection = { available: true };
+  const knowledgeImport = await optionalImport('./vite-native-knowledge-store.js');
+  if (!knowledgeImport.ok) {
+    knowledgeSection.available = true;
+    knowledgeSection.error = knowledgeImport.error;
+    criticalFailed++;
+  } else {
+    try {
+      const stats = knowledgeImport.mod.getKnowledgeStats();
+      knowledgeSection.data = stats;
+      // Check FTS index consistency
+      if (stats.totalRecords > 0 && !stats.available) {
+        indexConsistent = false;
+        recommendations.push('Run /api/native-knowledge/repair-index to heal FTS drift.');
+      }
+    } catch (e: any) {
+      knowledgeSection.error = e?.message ?? 'getKnowledgeStats failed';
+      highFailed++;
+    }
+  }
+
+  // ── Contract section ───────────────────────────────────────────────────
+  const contractSection: DoctorSection = { available: true };
+  const contractImport = await optionalImport('./vite-native-contract-plane.js');
+  if (!contractImport.ok) {
+    contractSection.available = true;
+    contractSection.error = contractImport.error;
+    highFailed++;
+  } else {
+    try {
+      const result = contractImport.mod.contractSelfTest();
+      contractSection.data = result;
+      if (!result.passed) highFailed++;
+    } catch (e: any) {
+      contractSection.error = e?.message ?? 'contractSelfTest failed';
+      highFailed++;
+    }
+  }
+
+  // ── Snapshot section ───────────────────────────────────────────────────
+  const snapshotSection: DoctorSection = { available: true };
+  const snapshotImport = await optionalImport('./vite-native-snapshot-plane.js');
+  if (!snapshotImport.ok) {
+    snapshotSection.available = true;
+    snapshotSection.error = snapshotImport.error;
+  } else {
+    try {
+      const manifest = await snapshotImport.mod.getSnapshotManifest();
+      snapshotSection.data = manifest;
+      // Maintenance recommendation: >32MB reclaimable space
+      if (manifest.sizeBytes > 32 * 1024 * 1024) {
+        recommendations.push('Run /api/native-maintenance/run to reclaim SQLite space.');
+      }
+    } catch (e: any) {
+      snapshotSection.error = e?.message ?? 'getSnapshotManifest failed';
+    }
+  }
+
+  // ── Optional deep self-test ────────────────────────────────────────────
+  let selftestSection: DoctorSection | undefined;
+  if (opts.deep) {
+    selftestSection = { available: true };
+    const stImport = await optionalImport('./vite-native-selftest.js');
+    if (!stImport.ok) {
+      selftestSection.available = true;
+      selftestSection.error = stImport.error;
+      criticalFailed++;
+    } else {
+      try {
+        const result = stImport.mod.runStaticSelfTest();
+        selftestSection.data = result;
+        if (!result.passed) {
+          highFailed += result.failures?.length ?? 1;
+          // Trigger policy remediation for known failures
+          if (policyImport.ok) {
+            policyImport.mod.applySelfTestRemediation(result);
+          }
+        }
+      } catch (e: any) {
+        selftestSection.error = e?.message ?? 'Static self-test failed';
+        criticalFailed++;
+      }
+    }
+  }
+
+  // Add index inconsistency recommendation
+  if (!indexConsistent) {
+    recommendations.push('Run /api/native-knowledge/repair-index to heal FTS drift.');
+  }
+
+  const status = pickStatus({ criticalFailed, pressure, indexConsistent, highFailed });
+
+  return {
+    status,
+    ts,
+    pressure,
+    criticalFailed,
+    highFailed,
+    indexConsistent,
+    recommendations: [...new Set(recommendations)],
+    sections: {
+      runtime: runtimeSection,
+      policy: policySection,
+      knowledge: knowledgeSection,
+      contract: contractSection,
+      snapshot: snapshotSection,
+      ...(selftestSection && { selftest: selftestSection }),
+    },
+  };
+}

package/src/lib/overrides/vite-native-knowledge-store.ts

@@ -0,0 +1,267 @@
+/**
+ * vite-native-knowledge-store.ts — L1: Persistence & Vector/Lexical Math
+ * Zero-dependency SQLite storage for scraped content, RAG chunks, and Merkle-lite audit logs.
+ * All imports are from node:* only.
+ */
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// ── Ghost Load Pattern: avoids Rollup static analysis crash ──────────────
+let DatabaseSync: any = null;
+let dbAvailable = false;
+try {
+  const anyProc: any = globalThis.process as any;
+  if (anyProc && typeof anyProc.getBuiltinModule === 'function') {
+    const mod = anyProc.getBuiltinModule('node:sqlite');
+    if (mod?.DatabaseSync) { DatabaseSync = mod.DatabaseSync; dbAvailable = true; }
+  }
+} catch {}
+if (!dbAvailable) {
+  try {
+    const req = createRequire(import.meta.url);
+    ({ DatabaseSync } = req('node:sqlite'));
+    dbAvailable = !!DatabaseSync;
+  } catch { dbAvailable = false; }
+}
+
+const AUDIT_DIR = join(__dirname, '..', '..', '..', 'src', 'audit');
+const DB_PATH = join(AUDIT_DIR, 'knowledge.db');
+
+let db: any = null;
+
+function ensureDb(): boolean {
+  if (db) return true;
+  if (!dbAvailable) return false;
+  try {
+    if (!existsSync(AUDIT_DIR)) mkdirSync(AUDIT_DIR, { recursive: true });
+    db = new DatabaseSync(DB_PATH);
+    // Exact pragmas — MUST execute immediately after open
+    db.exec('PRAGMA journal_mode = WAL;');
+    db.exec('PRAGMA synchronous = NORMAL;');
+    db.exec('PRAGMA busy_timeout = 3000;');
+    initSchema();
+    return true;
+  } catch (e: any) {
+    console.warn('[knowledge-store] DB init failed:', e?.message);
+    return false;
+  }
+}
+
+function initSchema(): void {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS knowledge (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      kind TEXT NOT NULL,
+      ref TEXT NOT NULL,
+      summary TEXT NOT NULL,
+      ts INTEGER NOT NULL,
+      refHash TEXT NOT NULL,
+      simHash TEXT NOT NULL
+    );
+    CREATE VIRTUAL TABLE IF NOT EXISTS knowledge_fts
+      USING fts5(summary, content='knowledge', content_rowid='id');
+  `);
+  // Exact FTS5 triggers — must NOT deviate
+  db.exec(`
+    CREATE TRIGGER IF NOT EXISTS tbl_ai AFTER INSERT ON knowledge BEGIN
+      INSERT INTO knowledge_fts(rowid, summary) VALUES (new.id, new.summary);
+    END;
+    CREATE TRIGGER IF NOT EXISTS tbl_ad AFTER DELETE ON knowledge BEGIN
+      INSERT INTO knowledge_fts(knowledge_fts, rowid, summary) VALUES('delete', old.id, old.summary);
+    END;
+    CREATE TRIGGER IF NOT EXISTS tbl_au AFTER UPDATE ON knowledge BEGIN
+      INSERT INTO knowledge_fts(knowledge_fts, rowid, summary) VALUES('delete', old.id, old.summary);
+      INSERT INTO knowledge_fts(rowid, summary) VALUES (new.id, new.summary);
+    END;
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS audit_log (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      kind TEXT NOT NULL,
+      ref TEXT NOT NULL,
+      merkleHash TEXT NOT NULL,
+      ts INTEGER NOT NULL
+    );
+  `);
+}
+
+// ── 64-bit SimHash using BigInt — NO Number bitwise ops allowed ──────────
+// Hand-trace: "hello world"
+// toks = ["hello","world"]
+// For "hello": sha256 -> 32 bytes; use first 8 bytes as BigInt
+// bits = byte[0]<<56 | byte[1]<<48 | ... | byte[7]<<0  (using BigInt shifts)
+// For each bit position b in 0..63: v[b] += ((bits >> BigInt(b)) & 1n) === 1n ? 1 : -1
+// After all tokens, fp: for b in 0..63 if v[b]>0 then fp |= 1n<<BigInt(b)
+// Return fp.toString(16).padStart(16,'0')
+export function computeSimHash64(text: string): string {
+  const toks = text.toLowerCase().match(/[a-z0-9]+/g) || [];
+  const v = new Array(64).fill(0);
+  for (const tok of toks) {
+    const hashBuffer = createHash('sha256').update(tok, 'utf8').digest();
+    // Construct 64-bit BigInt from first 8 bytes — strictly BigInt arithmetic
+    let bits = 0n;
+    for (let i = 0; i < 8; i++) bits = (bits << 8n) | BigInt(hashBuffer[i]);
+    // Project onto 64-dimensional vector
+    for (let b = 0; b < 64; b++) v[b] += ((bits >> BigInt(b)) & 1n) === 1n ? 1 : -1;
+  }
+  // Collapse vector to fingerprint — MUST use BigInt, not Number bitwise
+  let fp = 0n;
+  for (let b = 0; b < 64; b++) if (v[b] > 0) fp |= (1n << BigInt(b));
+  return fp.toString(16).padStart(16, '0');
+}
+
+export function hammingDistance64(a: string, b: string): number {
+  let diff = BigInt(`0x${a}`) ^ BigInt(`0x${b}`);
+  let dist = 0;
+  while (diff > 0n) { dist += Number(diff & 1n); diff >>= 1n; }
+  return dist;
+}
+
+// ── Secret redaction before any data hits disk ───────────────────────────
+export function redactSecrets(text: string): string {
+  // AWS keys
+  let r = text.replace(/AKIA[0-9A-Z]{16}/g, '[REDACTED_AWS_KEY]');
+  // GitHub PATs
+  r = r.replace(/ghp_[A-Za-z0-9]{36}/g, '[REDACTED_GH_PAT]');
+  r = r.replace(/github_pat_[A-Za-z0-9_]{82}/g, '[REDACTED_GH_PAT]');
+  // Generic secrets — bearer tokens, API keys in headers
+  r = r.replace(/Bearer\s+[A-Za-z0-9._\-]{20,}/gi, 'Bearer [REDACTED]');
+  r = r.replace(/api[_-]?key["\s:=]+[A-Za-z0-9_\-]{20,}/gi, 'api_key=[REDACTED]');
+  return r;
+}
+
+// ── Prompt injection scanner ──────────────────────────────────────────────
+export function scanForInjection(text: string): boolean {
+  const lower = text.toLowerCase();
+  const injectionPatterns = [
+    'ignore previous instructions',
+    'ignore all instructions',
+    'system prompt:',
+    'new instruction:',
+    'prompt injection',
+    '</system>',
+    '<|im_start|>',
+    'jailbreak',
+    'dan mode',
+  ];
+  return injectionPatterns.some(p => lower.includes(p));
+}
+
+// ── Core storage API ─────────────────────────────────────────────────────
+export interface KnowledgeRecord {
+  id?: number;
+  kind: string;
+  ref: string;
+  summary: string;
+  ts: number;
+  refHash: string;
+  simHash: string;
+}
+
+export function recordKnowledge(kind: string, ref: string, rawSummary: string): { id: number } | null {
+  if (!ensureDb()) return null;
+  // Redact secrets before writing
+  const summary = redactSecrets(rawSummary).slice(0, 4000);
+  // Block injection attempts
+  if (scanForInjection(summary)) {
+    console.warn('[knowledge-store] Injection attempt detected in summary, blocking.');
+    return null;
+  }
+  const ts = Date.now();
+  const refHash = createHash('sha256').update(ref, 'utf8').digest('hex');
+  const simHash = computeSimHash64(summary);
+  try {
+    const stmt = db.prepare(`
+      INSERT INTO knowledge (kind, ref, summary, ts, refHash, simHash)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `);
+    const result = stmt.run(kind, ref, summary, ts, refHash, simHash);
+    return { id: Number(result.lastInsertRowid) };
+  } catch (e: any) {
+    console.warn('[knowledge-store] recordKnowledge failed:', e?.message);
+    return null;
+  }
+}
+
+export function searchKnowledge(query: string, limit = 10): KnowledgeRecord[] {
+  if (!ensureDb()) return [];
+  try {
+    const stmt = db.prepare(`
+      SELECT k.* FROM knowledge k
+      JOIN knowledge_fts f ON f.rowid = k.id
+      WHERE knowledge_fts MATCH ?
+      ORDER BY rank
+      LIMIT ?
+    `);
+    return stmt.all(query, limit) as KnowledgeRecord[];
+  } catch {
+    // Fallback to LIKE if FTS fails
+    try {
+      const stmt = db.prepare(`SELECT * FROM knowledge WHERE summary LIKE ? LIMIT ?`);
+      return stmt.all(`%${query}%`, limit) as KnowledgeRecord[];
+    } catch { return []; }
+  }
+}
+
+export function getKnowledgeById(id: number): KnowledgeRecord | null {
+  if (!ensureDb()) return null;
+  try {
+    const stmt = db.prepare(`SELECT * FROM knowledge WHERE id = ?`);
+    return (stmt.get(id) as KnowledgeRecord) || null;
+  } catch { return null; }
+}
+
+export function deleteKnowledge(id: number): boolean {
+  if (!ensureDb()) return false;
+  try {
+    const stmt = db.prepare(`DELETE FROM knowledge WHERE id = ?`);
+    stmt.run(id);
+    return true;
+  } catch { return false; }
+}
+
+export function repairKnowledgeFts(): boolean {
+  if (!ensureDb()) return false;
+  try {
+    db.exec(`INSERT INTO knowledge_fts(knowledge_fts) VALUES('rebuild')`);
+    return true;
+  } catch { return false; }
+}
+
+// ── Autophagy: purge ghost files (refs no longer on disk) ────────────────
+export function purgeGhostFiles(): number {
+  if (!ensureDb()) return 0;
+  try {
+    const rows = db.prepare(`SELECT id, ref FROM knowledge WHERE kind = 'file'`).all() as Array<{id:number, ref:string}>;
+    let purged = 0;
+    for (const row of rows) {
+      if (!existsSync(row.ref)) {
+        db.prepare(`DELETE FROM knowledge WHERE id = ?`).run(row.id);
+        purged++;
+      }
+    }
+    return purged;
+  } catch { return 0; }
+}
+
+// ── Stats ─────────────────────────────────────────────────────────────────
+export function getKnowledgeStats(): { totalRecords: number; kinds: Record<string, number>; dbPath: string; available: boolean } {
+  if (!ensureDb()) return { totalRecords: 0, kinds: {}, dbPath: DB_PATH, available: false };
+  try {
+    const total = (db.prepare(`SELECT COUNT(*) as c FROM knowledge`).get() as any)?.c ?? 0;
+    const kindRows = db.prepare(`SELECT kind, COUNT(*) as c FROM knowledge GROUP BY kind`).all() as Array<{kind:string,c:number}>;
+    const kinds: Record<string, number> = {};
+    for (const r of kindRows) kinds[r.kind] = r.c;
+    return { totalRecords: total, kinds, dbPath: DB_PATH, available: true };
+  } catch { return { totalRecords: 0, kinds: {}, dbPath: DB_PATH, available: false }; }
+}
+
+export function getDb(): any { ensureDb(); return db; }
+export function getDbPath(): string { return DB_PATH; }
+export function isDbAvailable(): boolean { return dbAvailable && !!db; }

package/src/lib/overrides/vite-native-policy-plane.ts

@@ -0,0 +1,190 @@
+/**
+ * vite-native-policy-plane.ts — L2: Dynamic Feature Flags & Overrides
+ * Dynamic feature flagging backed by SQLite, allowing runtime degradation.
+ * Zero-dependency: node:* only.
+ */
+import { createRequire } from 'node:module';
+import { existsSync, mkdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Ghost load for SQLite
+let DatabaseSync: any = null;
+let dbAvailable = false;
+try {
+  const anyProc: any = globalThis.process as any;
+  if (anyProc && typeof anyProc.getBuiltinModule === 'function') {
+    const mod = anyProc.getBuiltinModule('node:sqlite');
+    if (mod?.DatabaseSync) { DatabaseSync = mod.DatabaseSync; dbAvailable = true; }
+  }
+} catch {}
+if (!dbAvailable) {
+  try {
+    const req = createRequire(import.meta.url);
+    ({ DatabaseSync } = req('node:sqlite'));
+    dbAvailable = !!DatabaseSync;
+  } catch { dbAvailable = false; }
+}
+
+const AUDIT_DIR = join(__dirname, '..', '..', '..', 'src', 'audit');
+const DB_PATH = join(AUDIT_DIR, 'knowledge.db');
+
+let db: any = null;
+
+function ensureDb(): boolean {
+  if (db) return true;
+  if (!dbAvailable) return false;
+  try {
+    if (!existsSync(AUDIT_DIR)) mkdirSync(AUDIT_DIR, { recursive: true });
+    db = new DatabaseSync(DB_PATH);
+    db.exec('PRAGMA journal_mode = WAL;');
+    db.exec('PRAGMA synchronous = NORMAL;');
+    db.exec('PRAGMA busy_timeout = 3000;');
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS policy_flags (
+        name TEXT PRIMARY KEY,
+        valueJson TEXT NOT NULL,
+        ts INTEGER NOT NULL
+      );
+    `);
+    return true;
+  } catch (e: any) {
+    console.warn('[policy-plane] DB init failed:', e?.message);
+    return false;
+  }
+}
+
+export interface PolicyState {
+  useDdg: boolean;
+  useBing: boolean;
+  useYahoo: boolean;
+  useMojeek: boolean;
+  enableSSE: boolean;
+  enablePrefetch: boolean;
+  enableAutoRag: boolean;
+  enableRateLimit: boolean;
+  enableCircuitBreaker: boolean;
+  maxResultsPerEngine: number;
+  searchTimeoutMs: number;
+}
+
+export const DEFAULT_POLICY: PolicyState = {
+  useDdg: true,
+  useBing: true,
+  useYahoo: true,
+  useMojeek: true,
+  enableSSE: true,
+  enablePrefetch: true,
+  enableAutoRag: true,
+  enableRateLimit: true,
+  enableCircuitBreaker: true,
+  maxResultsPerEngine: 5,
+  searchTimeoutMs: 8000,
+};
+
+export function getPolicyOverrides(): Partial<PolicyState> {
+  if (!ensureDb()) return {};
+  try {
+    const rows = db.prepare(`SELECT name, valueJson FROM policy_flags`).all() as Array<{name: string; valueJson: string}>;
+    const result: Partial<PolicyState> = {};
+    for (const row of rows) {
+      try {
+        // Wrap JSON.parse — corrupted rows must be ignored, not thrown
+        const val = JSON.parse(row.valueJson);
+        (result as any)[row.name] = val;
+      } catch {
+        // Silently ignore corrupted DB rows
+      }
+    }
+    return result;
+  } catch { return {}; }
+}
+
+// UPSERT implementation for SQLite
+export function setPolicyOverride(name: keyof PolicyState | string, value: unknown): boolean {
+  if (!ensureDb()) return false;
+  try {
+    // Hand-trace: calling twice with same name — second call hits ON CONFLICT
+    // First: INSERT succeeds, row created with name, valueJson, ts
+    // Second: INSERT fails ON CONFLICT(name), DO UPDATE SET fires instead
+    // Both calls result in the same row with updated valueJson and ts
+    const stmt = db.prepare(`
+      INSERT INTO policy_flags (name, valueJson, ts)
+      VALUES (?, ?, ?)
+      ON CONFLICT(name) DO UPDATE SET valueJson = excluded.valueJson, ts = excluded.ts
+    `);
+    stmt.run(name, JSON.stringify(value), Date.now());
+    return true;
+  } catch { return false; }
+}
+
+export function deletePolicyOverride(name: string): boolean {
+  if (!ensureDb()) return false;
+  try {
+    db.prepare(`DELETE FROM policy_flags WHERE name = ?`).run(name);
+    return true;
+  } catch { return false; }
+}
+
+// ── Policy Evaluation ─────────────────────────────────────────────────────
+// Hand-trace: DB override sets enablePrefetch = true, but ctx.pressure = 'hot'
+// Step 1: merged = {...DEFAULT_POLICY, ...overrides} => enablePrefetch = true
+// Step 2: pressure === 'hot' => forcefully set enablePrefetch = false, enableSSE = false, enableAutoRag = false
+// Final value of enablePrefetch = FALSE (hot pressure wins, ignores DB override)
+export function evaluatePolicy(ctx: { pressure: 'ok' | 'warm' | 'hot' }): PolicyState {
+  const overrides = getPolicyOverrides();
+  const merged: PolicyState = { ...DEFAULT_POLICY, ...overrides };
+
+  // Hot pressure: force shed non-critical features — DB overrides are IGNORED
+  if (ctx.pressure === 'hot') {
+    merged.enablePrefetch = false;
+    merged.enableSSE = false;
+    merged.enableAutoRag = false;
+  }
+
+  // Total engine blackout prevention: force useDdg if all four engines disabled
+  if (!merged.useDdg && !merged.useBing && !merged.useYahoo && !merged.useMojeek) {
+    merged.useDdg = true;
+  }
+
+  return merged;
+}
+
+// ── Self-test remediation ─────────────────────────────────────────────────
+export interface SelfTestResult {
+  passed: boolean;
+  failures: string[];
+}
+
+export function applySelfTestRemediation(result: SelfTestResult): void {
+  for (const failure of result.failures) {
+    if (failure.includes('parser.bing.href.capture')) {
+      console.warn('[policy-plane] Bing parser failure detected — disabling Bing engine');
+      setPolicyOverride('useBing', false);
+    }
+    if (failure.includes('parser.ddg.href.capture')) {
+      console.warn('[policy-plane] DDG parser failure detected — disabling DDG engine');
+      setPolicyOverride('useDdg', false);
+    }
+    if (failure.includes('parser.yahoo.href.capture')) {
+      setPolicyOverride('useYahoo', false);
+    }
+    if (failure.includes('parser.mojeek.href.capture')) {
+      setPolicyOverride('useMojeek', false);
+    }
+  }
+}
+
+export function getAllPolicyFlags(): Array<{ name: string; value: unknown; ts: number }> {
+  if (!ensureDb()) return [];
+  try {
+    const rows = db.prepare(`SELECT name, valueJson, ts FROM policy_flags ORDER BY name`).all() as Array<{name:string;valueJson:string;ts:number}>;
+    return rows.map(r => {
+      try { return { name: r.name, value: JSON.parse(r.valueJson), ts: r.ts }; }
+      catch { return { name: r.name, value: null, ts: r.ts }; }
+    });
+  } catch { return []; }
+}