scene-capability-engine 3.6.4 → 3.6.7

package/lib/state/sce-state-store.js

@@ -21,6 +21,23 @@ function normalizeInteger(value, fallback = 0) {
   return parsed;
 }
 
+function normalizeBooleanValue(value, fallback = false) {
+  if (typeof value === 'boolean') {
+    return value;
+  }
+  const normalized = normalizeString(`${value || ''}`).toLowerCase();
+  if (!normalized) {
+    return fallback;
+  }
+  if (['1', 'true', 'yes', 'y', 'on'].includes(normalized)) {
+    return true;
+  }
+  if (['0', 'false', 'no', 'n', 'off'].includes(normalized)) {
+    return false;
+  }
+  return fallback;
+}
+
 function normalizeNonNegativeInteger(value, fallback = 0) {
   const parsed = Number.parseInt(`${value}`, 10);
   if (!Number.isFinite(parsed) || parsed < 0) {
@@ -116,6 +133,12 @@ class SceStateStore {
       timeline_snapshots: {},
       scene_session_cycles: {},
       agent_runtime: {},
+      errorbook_entry_index: {},
+      errorbook_incident_index: {},
+      governance_spec_scene_override: {},
+      governance_scene_index: {},
+      release_evidence_run: {},
+      release_gate_history: {},
       migration_records: {},
       auth_leases: {},
       auth_events: [],
@@ -317,6 +340,123 @@ class SceStateStore {
 
       CREATE INDEX IF NOT EXISTS idx_state_migration_registry_component_started
         ON state_migration_registry(component_id, started_at DESC);
+
+      CREATE TABLE IF NOT EXISTS errorbook_entry_index_registry (
+        entry_id TEXT PRIMARY KEY,
+        fingerprint TEXT,
+        title TEXT,
+        status TEXT,
+        quality_score INTEGER,
+        tags_json TEXT,
+        ontology_tags_json TEXT,
+        temporary_mitigation_active INTEGER,
+        temporary_mitigation_deadline_at TEXT,
+        occurrences INTEGER,
+        created_at TEXT,
+        updated_at TEXT,
+        source TEXT,
+        indexed_at TEXT NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_errorbook_entry_index_registry_status_updated
+        ON errorbook_entry_index_registry(status, updated_at DESC);
+
+      CREATE TABLE IF NOT EXISTS errorbook_incident_index_registry (
+        incident_id TEXT PRIMARY KEY,
+        fingerprint TEXT,
+        title TEXT,
+        symptom TEXT,
+        state TEXT,
+        attempt_count INTEGER,
+        created_at TEXT,
+        updated_at TEXT,
+        last_attempt_at TEXT,
+        resolved_at TEXT,
+        linked_entry_id TEXT,
+        source TEXT,
+        indexed_at TEXT NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_errorbook_incident_index_registry_state_updated
+        ON errorbook_incident_index_registry(state, updated_at DESC);
+
+      CREATE TABLE IF NOT EXISTS governance_spec_scene_override_registry (
+        spec_id TEXT PRIMARY KEY,
+        scene_id TEXT NOT NULL,
+        source TEXT,
+        rule_id TEXT,
+        updated_at TEXT,
+        indexed_at TEXT NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_governance_spec_scene_override_registry_scene
+        ON governance_spec_scene_override_registry(scene_id, updated_at DESC);
+
+      CREATE TABLE IF NOT EXISTS governance_scene_index_registry (
+        scene_id TEXT PRIMARY KEY,
+        total_specs INTEGER,
+        active_specs INTEGER,
+        completed_specs INTEGER,
+        stale_specs INTEGER,
+        spec_ids_json TEXT,
+        active_spec_ids_json TEXT,
+        stale_spec_ids_json TEXT,
+        generated_at TEXT,
+        scene_filter TEXT,
+        source TEXT,
+        indexed_at TEXT NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_governance_scene_index_registry_counts
+        ON governance_scene_index_registry(total_specs DESC, active_specs DESC);
+
+      CREATE TABLE IF NOT EXISTS release_evidence_run_registry (
+        session_id TEXT PRIMARY KEY,
+        merged_at TEXT,
+        status TEXT,
+        gate_passed INTEGER,
+        spec_success_rate_percent REAL,
+        risk_level TEXT,
+        ontology_quality_score REAL,
+        capability_coverage_percent REAL,
+        capability_coverage_passed INTEGER,
+        scene_package_batch_passed INTEGER,
+        scene_package_batch_failure_count INTEGER,
+        failed_goals INTEGER,
+        release_gate_preflight_available INTEGER,
+        release_gate_preflight_blocked INTEGER,
+        source_updated_at TEXT,
+        source TEXT,
+        indexed_at TEXT NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_release_evidence_run_registry_status_merged
+        ON release_evidence_run_registry(status, merged_at DESC);
+
+      CREATE TABLE IF NOT EXISTS release_gate_history_registry (
+        tag TEXT PRIMARY KEY,
+        evaluated_at TEXT,
+        gate_passed INTEGER,
+        enforce INTEGER,
+        risk_level TEXT,
+        spec_success_rate_percent REAL,
+        scene_package_batch_passed INTEGER,
+        scene_package_batch_failure_count INTEGER,
+        capability_expected_unknown_count INTEGER,
+        capability_provided_unknown_count INTEGER,
+        release_gate_preflight_available INTEGER,
+        release_gate_preflight_blocked INTEGER,
+        require_release_gate_preflight INTEGER,
+        drift_alert_count INTEGER,
+        drift_blocked INTEGER,
+        weekly_ops_blocked INTEGER,
+        source_updated_at TEXT,
+        source TEXT,
+        indexed_at TEXT NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_release_gate_history_registry_eval
+        ON release_gate_history_registry(evaluated_at DESC);
     `);
   }
 
@@ -511,6 +651,143 @@ class SceStateStore {
     };
   }
 
+  _mapErrorbookEntryIndexRow(row) {
+    if (!row) {
+      return null;
+    }
+    return {
+      entry_id: normalizeString(row.entry_id),
+      fingerprint: normalizeString(row.fingerprint) || null,
+      title: normalizeString(row.title) || null,
+      status: normalizeString(row.status) || null,
+      quality_score: normalizeNonNegativeInteger(row.quality_score, 0),
+      tags: normalizeStringArray(parseJsonSafe(row.tags_json, []), []),
+      ontology_tags: normalizeStringArray(parseJsonSafe(row.ontology_tags_json, []), []),
+      temporary_mitigation_active: Number(row.temporary_mitigation_active) === 1,
+      temporary_mitigation_deadline_at: normalizeIsoTimestamp(row.temporary_mitigation_deadline_at, '') || null,
+      occurrences: normalizeNonNegativeInteger(row.occurrences, 0),
+      created_at: normalizeIsoTimestamp(row.created_at, '') || null,
+      updated_at: normalizeIsoTimestamp(row.updated_at, '') || null,
+      source: normalizeString(row.source) || null,
+      indexed_at: normalizeIsoTimestamp(row.indexed_at, '') || null
+    };
+  }
+
+  _mapErrorbookIncidentIndexRow(row) {
+    if (!row) {
+      return null;
+    }
+    return {
+      incident_id: normalizeString(row.incident_id),
+      fingerprint: normalizeString(row.fingerprint) || null,
+      title: normalizeString(row.title) || null,
+      symptom: normalizeString(row.symptom) || null,
+      state: normalizeString(row.state) || null,
+      attempt_count: normalizeNonNegativeInteger(row.attempt_count, 0),
+      created_at: normalizeIsoTimestamp(row.created_at, '') || null,
+      updated_at: normalizeIsoTimestamp(row.updated_at, '') || null,
+      last_attempt_at: normalizeIsoTimestamp(row.last_attempt_at, '') || null,
+      resolved_at: normalizeIsoTimestamp(row.resolved_at, '') || null,
+      linked_entry_id: normalizeString(row.linked_entry_id) || null,
+      source: normalizeString(row.source) || null,
+      indexed_at: normalizeIsoTimestamp(row.indexed_at, '') || null
+    };
+  }
+
+  _mapGovernanceSpecSceneOverrideRow(row) {
+    if (!row) {
+      return null;
+    }
+    return {
+      spec_id: normalizeString(row.spec_id),
+      scene_id: normalizeString(row.scene_id),
+      source: normalizeString(row.source) || null,
+      rule_id: normalizeString(row.rule_id) || null,
+      updated_at: normalizeIsoTimestamp(row.updated_at, '') || null,
+      indexed_at: normalizeIsoTimestamp(row.indexed_at, '') || null
+    };
+  }
+
+  _mapGovernanceSceneIndexRow(row) {
+    if (!row) {
+      return null;
+    }
+    return {
+      scene_id: normalizeString(row.scene_id),
+      total_specs: normalizeNonNegativeInteger(row.total_specs, 0),
+      active_specs: normalizeNonNegativeInteger(row.active_specs, 0),
+      completed_specs: normalizeNonNegativeInteger(row.completed_specs, 0),
+      stale_specs: normalizeNonNegativeInteger(row.stale_specs, 0),
+      spec_ids: normalizeStringArray(parseJsonSafe(row.spec_ids_json, []), []),
+      active_spec_ids: normalizeStringArray(parseJsonSafe(row.active_spec_ids_json, []), []),
+      stale_spec_ids: normalizeStringArray(parseJsonSafe(row.stale_spec_ids_json, []), []),
+      generated_at: normalizeIsoTimestamp(row.generated_at, '') || null,
+      scene_filter: normalizeString(row.scene_filter) || null,
+      source: normalizeString(row.source) || null,
+      indexed_at: normalizeIsoTimestamp(row.indexed_at, '') || null
+    };
+  }
+
+  _mapReleaseEvidenceRunRow(row) {
+    if (!row) {
+      return null;
+    }
+    return {
+      session_id: normalizeString(row.session_id),
+      merged_at: normalizeIsoTimestamp(row.merged_at, '') || null,
+      status: normalizeString(row.status) || null,
+      gate_passed: normalizeBooleanValue(row.gate_passed, false),
+      spec_success_rate_percent: Number.isFinite(Number(row.spec_success_rate_percent))
+        ? Number(row.spec_success_rate_percent)
+        : null,
+      risk_level: normalizeString(row.risk_level) || null,
+      ontology_quality_score: Number.isFinite(Number(row.ontology_quality_score))
+        ? Number(row.ontology_quality_score)
+        : null,
+      capability_coverage_percent: Number.isFinite(Number(row.capability_coverage_percent))
+        ? Number(row.capability_coverage_percent)
+        : null,
+      capability_coverage_passed: normalizeBooleanValue(row.capability_coverage_passed, false),
+      scene_package_batch_passed: normalizeBooleanValue(row.scene_package_batch_passed, false),
+      scene_package_batch_failure_count: normalizeNonNegativeInteger(row.scene_package_batch_failure_count, 0),
+      failed_goals: normalizeNonNegativeInteger(row.failed_goals, 0),
+      release_gate_preflight_available: normalizeBooleanValue(row.release_gate_preflight_available, false),
+      release_gate_preflight_blocked: normalizeBooleanValue(row.release_gate_preflight_blocked, false),
+      source_updated_at: normalizeIsoTimestamp(row.source_updated_at, '') || null,
+      source: normalizeString(row.source) || null,
+      indexed_at: normalizeIsoTimestamp(row.indexed_at, '') || null
+    };
+  }
+
+  _mapReleaseGateHistoryRow(row) {
+    if (!row) {
+      return null;
+    }
+    return {
+      tag: normalizeString(row.tag),
+      evaluated_at: normalizeIsoTimestamp(row.evaluated_at, '') || null,
+      gate_passed: normalizeBooleanValue(row.gate_passed, false),
+      enforce: normalizeBooleanValue(row.enforce, false),
+      risk_level: normalizeString(row.risk_level) || null,
+      spec_success_rate_percent: Number.isFinite(Number(row.spec_success_rate_percent))
+        ? Number(row.spec_success_rate_percent)
+        : null,
+      scene_package_batch_passed: normalizeBooleanValue(row.scene_package_batch_passed, false),
+      scene_package_batch_failure_count: normalizeNonNegativeInteger(row.scene_package_batch_failure_count, 0),
+      capability_expected_unknown_count: normalizeNonNegativeInteger(row.capability_expected_unknown_count, 0),
+      capability_provided_unknown_count: normalizeNonNegativeInteger(row.capability_provided_unknown_count, 0),
+      release_gate_preflight_available: normalizeBooleanValue(row.release_gate_preflight_available, false),
+      release_gate_preflight_blocked: normalizeBooleanValue(row.release_gate_preflight_blocked, false),
+      require_release_gate_preflight: normalizeBooleanValue(row.require_release_gate_preflight, false),
+      drift_alert_count: normalizeNonNegativeInteger(row.drift_alert_count, 0),
+      drift_blocked: normalizeBooleanValue(row.drift_blocked, false),
+      weekly_ops_blocked: normalizeBooleanValue(row.weekly_ops_blocked, false),
+      source_updated_at: normalizeIsoTimestamp(row.source_updated_at, '') || null,
+      source: normalizeString(row.source) || null,
+      indexed_at: normalizeIsoTimestamp(row.indexed_at, '') || null
+    };
+  }
+
   async resolveOrCreateTaskRef(options = {}) {
     const sceneId = normalizeString(options.sceneId);
     const specId = normalizeString(options.specId);
@@ -1514,6 +1791,806 @@ class SceStateStore {
       .filter(Boolean);
   }
 
+  async upsertErrorbookEntryIndexRecords(records = [], options = {}) {
+    const source = normalizeString(options.source) || 'file.errorbook.index';
+    const nowIso = this.now();
+    const normalizedRecords = Array.isArray(records)
+      ? records.map((item) => ({
+        entry_id: normalizeString(item && (item.entry_id || item.id)),
+        fingerprint: normalizeString(item && item.fingerprint) || null,
+        title: normalizeString(item && item.title) || null,
+        status: normalizeString(item && item.status) || null,
+        quality_score: normalizeNonNegativeInteger(item && item.quality_score, 0),
+        tags: normalizeStringArray(item && item.tags, []),
+        ontology_tags: normalizeStringArray(item && item.ontology_tags, []),
+        temporary_mitigation_active: normalizeBooleanValue(item && item.temporary_mitigation_active, false),
+        temporary_mitigation_deadline_at: normalizeIsoTimestamp(item && item.temporary_mitigation_deadline_at, '') || null,
+        occurrences: normalizeNonNegativeInteger(item && item.occurrences, 0),
+        created_at: normalizeIsoTimestamp(item && item.created_at, '') || null,
+        updated_at: normalizeIsoTimestamp(item && item.updated_at, nowIso) || nowIso,
+        source,
+        indexed_at: nowIso
+      }))
+        .filter((item) => item.entry_id)
+      : [];
+
+    if (this._useMemoryBackend()) {
+      for (const item of normalizedRecords) {
+        this._memory.errorbook_entry_index[item.entry_id] = { ...item };
+      }
+      return {
+        success: true,
+        written: normalizedRecords.length,
+        total: Object.keys(this._memory.errorbook_entry_index || {}).length
+      };
+    }
+
+    if (!await this.ensureReady()) {
+      return null;
+    }
+
+    const statement = this._db.prepare(`
+      INSERT OR REPLACE INTO errorbook_entry_index_registry(
+        entry_id, fingerprint, title, status, quality_score, tags_json, ontology_tags_json,
+        temporary_mitigation_active, temporary_mitigation_deadline_at, occurrences, created_at, updated_at, source, indexed_at
+      )
+      VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+
+    this._withTransaction(() => {
+      for (const item of normalizedRecords) {
+        statement.run(
+          item.entry_id,
+          item.fingerprint,
+          item.title,
+          item.status,
+          item.quality_score,
+          JSON.stringify(item.tags || []),
+          JSON.stringify(item.ontology_tags || []),
+          item.temporary_mitigation_active ? 1 : 0,
+          item.temporary_mitigation_deadline_at,
+          item.occurrences,
+          item.created_at,
+          item.updated_at,
+          item.source,
+          item.indexed_at
+        );
+      }
+    });
+
+    const totalRow = this._db
+      .prepare('SELECT COUNT(*) AS total FROM errorbook_entry_index_registry')
+      .get();
+
+    return {
+      success: true,
+      written: normalizedRecords.length,
+      total: normalizeNonNegativeInteger(totalRow && totalRow.total, 0)
+    };
+  }
+
+  async listErrorbookEntryIndexRecords(options = {}) {
+    const limit = normalizeInteger(options.limit, 100);
+    const status = normalizeString(options.status);
+
+    if (this._useMemoryBackend()) {
+      let rows = Object.values(this._memory.errorbook_entry_index || {}).map((item) => ({ ...item }));
+      if (status) {
+        rows = rows.filter((item) => normalizeString(item.status) === status);
+      }
+      rows.sort((left, right) => (Date.parse(right.updated_at || '') || 0) - (Date.parse(left.updated_at || '') || 0));
+      if (limit > 0) {
+        rows = rows.slice(0, limit);
+      }
+      return rows.map((row) => this._mapErrorbookEntryIndexRow({
+        ...row,
+        tags_json: JSON.stringify(row.tags || []),
+        ontology_tags_json: JSON.stringify(row.ontology_tags || [])
+      }));
+    }
+
+    if (!await this.ensureReady()) {
+      return null;
+    }
+
+    let query = `
+      SELECT entry_id, fingerprint, title, status, quality_score, tags_json, ontology_tags_json,
+             temporary_mitigation_active, temporary_mitigation_deadline_at, occurrences, created_at, updated_at, source, indexed_at
+      FROM errorbook_entry_index_registry
+    `;
+    const params = [];
+    if (status) {
+      query += ' WHERE status = ?';
+      params.push(status);
+    }
+    query += ' ORDER BY updated_at DESC';
+    if (limit > 0) {
+      query += ' LIMIT ?';
+      params.push(limit);
+    }
+
+    const rows = this._db.prepare(query).all(...params);
+    return rows
+      .map((row) => this._mapErrorbookEntryIndexRow(row))
+      .filter(Boolean);
+  }
+
+  async upsertErrorbookIncidentIndexRecords(records = [], options = {}) {
+    const source = normalizeString(options.source) || 'file.errorbook.incident-index';
+    const nowIso = this.now();
+    const normalizedRecords = Array.isArray(records)
+      ? records.map((item) => ({
+        incident_id: normalizeString(item && (item.incident_id || item.id)),
+        fingerprint: normalizeString(item && item.fingerprint) || null,
+        title: normalizeString(item && item.title) || null,
+        symptom: normalizeString(item && item.symptom) || null,
+        state: normalizeString(item && item.state) || null,
+        attempt_count: normalizeNonNegativeInteger(item && item.attempt_count, 0),
+        created_at: normalizeIsoTimestamp(item && item.created_at, '') || null,
+        updated_at: normalizeIsoTimestamp(item && item.updated_at, nowIso) || nowIso,
+        last_attempt_at: normalizeIsoTimestamp(item && item.last_attempt_at, '') || null,
+        resolved_at: normalizeIsoTimestamp(item && item.resolved_at, '') || null,
+        linked_entry_id: normalizeString(item && item.linked_entry_id) || null,
+        source,
+        indexed_at: nowIso
+      }))
+        .filter((item) => item.incident_id)
+      : [];
+
+    if (this._useMemoryBackend()) {
+      for (const item of normalizedRecords) {
+        this._memory.errorbook_incident_index[item.incident_id] = { ...item };
+      }
+      return {
+        success: true,
+        written: normalizedRecords.length,
+        total: Object.keys(this._memory.errorbook_incident_index || {}).length
+      };
+    }
+
+    if (!await this.ensureReady()) {
+      return null;
+    }
+
+    const statement = this._db.prepare(`
+      INSERT OR REPLACE INTO errorbook_incident_index_registry(
+        incident_id, fingerprint, title, symptom, state, attempt_count,
+        created_at, updated_at, last_attempt_at, resolved_at, linked_entry_id, source, indexed_at
+      )
+      VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+
+    this._withTransaction(() => {
+      for (const item of normalizedRecords) {
+        statement.run(
+          item.incident_id,
+          item.fingerprint,
+          item.title,
+          item.symptom,
+          item.state,
+          item.attempt_count,
+          item.created_at,
+          item.updated_at,
+          item.last_attempt_at,
+          item.resolved_at,
+          item.linked_entry_id,
+          item.source,
+          item.indexed_at
+        );
+      }
+    });
+
+    const totalRow = this._db
+      .prepare('SELECT COUNT(*) AS total FROM errorbook_incident_index_registry')
+      .get();
+
+    return {
+      success: true,
+      written: normalizedRecords.length,
+      total: normalizeNonNegativeInteger(totalRow && totalRow.total, 0)
+    };
+  }
+
+  async listErrorbookIncidentIndexRecords(options = {}) {
+    const limit = normalizeInteger(options.limit, 100);
+    const state = normalizeString(options.state);
+
+    if (this._useMemoryBackend()) {
+      let rows = Object.values(this._memory.errorbook_incident_index || {}).map((item) => ({ ...item }));
+      if (state) {
+        rows = rows.filter((item) => normalizeString(item.state) === state);
+      }
+      rows.sort((left, right) => (Date.parse(right.updated_at || '') || 0) - (Date.parse(left.updated_at || '') || 0));
+      if (limit > 0) {
+        rows = rows.slice(0, limit);
+      }
+      return rows.map((row) => this._mapErrorbookIncidentIndexRow(row));
+    }
+
+    if (!await this.ensureReady()) {
+      return null;
+    }
+
+    let query = `
+      SELECT incident_id, fingerprint, title, symptom, state, attempt_count,
+             created_at, updated_at, last_attempt_at, resolved_at, linked_entry_id, source, indexed_at
+      FROM errorbook_incident_index_registry
+    `;
+    const params = [];
+    if (state) {
+      query += ' WHERE state = ?';
+      params.push(state);
+    }
+    query += ' ORDER BY updated_at DESC';
+    if (limit > 0) {
+      query += ' LIMIT ?';
+      params.push(limit);
+    }
+
+    const rows = this._db.prepare(query).all(...params);
+    return rows
+      .map((row) => this._mapErrorbookIncidentIndexRow(row))
+      .filter(Boolean);
+  }
+
+  async upsertGovernanceSpecSceneOverrideRecords(records = [], options = {}) {
+    const source = normalizeString(options.source) || 'file.spec-governance.spec-scene-overrides';
+    const nowIso = this.now();
+    const normalizedRecords = Array.isArray(records)
+      ? records.map((item) => ({
+        spec_id: normalizeString(item && item.spec_id),
+        scene_id: normalizeString(item && item.scene_id),
+        source: normalizeString(item && item.source) || source,
+        rule_id: normalizeString(item && item.rule_id) || null,
+        updated_at: normalizeIsoTimestamp(item && item.updated_at, nowIso) || nowIso,
+        indexed_at: nowIso
+      }))
+        .filter((item) => item.spec_id && item.scene_id)
+      : [];
+
+    if (this._useMemoryBackend()) {
+      for (const item of normalizedRecords) {
+        this._memory.governance_spec_scene_override[item.spec_id] = { ...item };
+      }
+      return {
+        success: true,
+        written: normalizedRecords.length,
+        total: Object.keys(this._memory.governance_spec_scene_override || {}).length
+      };
+    }
+
+    if (!await this.ensureReady()) {
+      return null;
+    }
+
+    const statement = this._db.prepare(`
+      INSERT OR REPLACE INTO governance_spec_scene_override_registry(
+        spec_id, scene_id, source, rule_id, updated_at, indexed_at
+      )
+      VALUES(?, ?, ?, ?, ?, ?)
+    `);
+
+    this._withTransaction(() => {
+      for (const item of normalizedRecords) {
+        statement.run(
+          item.spec_id,
+          item.scene_id,
+          item.source,
+          item.rule_id,
+          item.updated_at,
+          item.indexed_at
+        );
+      }
+    });
+
+    const totalRow = this._db
+      .prepare('SELECT COUNT(*) AS total FROM governance_spec_scene_override_registry')
+      .get();
+
+    return {
+      success: true,
+      written: normalizedRecords.length,
+      total: normalizeNonNegativeInteger(totalRow && totalRow.total, 0)
+    };
+  }
+
+  async listGovernanceSpecSceneOverrideRecords(options = {}) {
+    const limit = normalizeInteger(options.limit, 100);
+    const sceneId = normalizeString(options.sceneId);
+    const specId = normalizeString(options.specId);
+
+    if (this._useMemoryBackend()) {
+      let rows = Object.values(this._memory.governance_spec_scene_override || {}).map((item) => ({ ...item }));
+      if (sceneId) {
+        rows = rows.filter((item) => normalizeString(item.scene_id) === sceneId);
+      }
+      if (specId) {
+        rows = rows.filter((item) => normalizeString(item.spec_id) === specId);
+      }
+      rows.sort((left, right) => (Date.parse(right.updated_at || '') || 0) - (Date.parse(left.updated_at || '') || 0));
+      if (limit > 0) {
+        rows = rows.slice(0, limit);
+      }
+      return rows.map((row) => this._mapGovernanceSpecSceneOverrideRow(row));
+    }
+
+    if (!await this.ensureReady()) {
+      return null;
+    }
+
+    let query = `
+      SELECT spec_id, scene_id, source, rule_id, updated_at, indexed_at
+      FROM governance_spec_scene_override_registry
+    `;
+    const clauses = [];
+    const params = [];
+    if (sceneId) {
+      clauses.push('scene_id = ?');
+      params.push(sceneId);
+    }
+    if (specId) {
+      clauses.push('spec_id = ?');
+      params.push(specId);
+    }
+    if (clauses.length > 0) {
+      query += ` WHERE ${clauses.join(' AND ')}`;
+    }
+    query += ' ORDER BY updated_at DESC, spec_id ASC';
+    if (limit > 0) {
+      query += ' LIMIT ?';
+      params.push(limit);
+    }
+
+    const rows = this._db.prepare(query).all(...params);
+    return rows
+      .map((row) => this._mapGovernanceSpecSceneOverrideRow(row))
+      .filter(Boolean);
+  }
+
+  async upsertGovernanceSceneIndexRecords(records = [], options = {}) {
+    const source = normalizeString(options.source) || 'file.spec-governance.scene-index';
+    const nowIso = this.now();
+    const normalizedRecords = Array.isArray(records)
+      ? records.map((item) => ({
+        scene_id: normalizeString(item && item.scene_id),
+        total_specs: normalizeNonNegativeInteger(item && item.total_specs, 0),
+        active_specs: normalizeNonNegativeInteger(item && item.active_specs, 0),
+        completed_specs: normalizeNonNegativeInteger(item && item.completed_specs, 0),
+        stale_specs: normalizeNonNegativeInteger(item && item.stale_specs, 0),
+        spec_ids: normalizeStringArray(item && item.spec_ids, []),
+        active_spec_ids: normalizeStringArray(item && item.active_spec_ids, []),
+        stale_spec_ids: normalizeStringArray(item && item.stale_spec_ids, []),
+        generated_at: normalizeIsoTimestamp(item && item.generated_at, nowIso) || nowIso,
+        scene_filter: normalizeString(item && item.scene_filter) || null,
+        source: normalizeString(item && item.source) || source,
+        indexed_at: nowIso
+      }))
+        .filter((item) => item.scene_id)
+      : [];
+
+    if (this._useMemoryBackend()) {
+      for (const item of normalizedRecords) {
+        this._memory.governance_scene_index[item.scene_id] = { ...item };
+      }
+      return {
+        success: true,
+        written: normalizedRecords.length,
+        total: Object.keys(this._memory.governance_scene_index || {}).length
+      };
+    }
+
+    if (!await this.ensureReady()) {
+      return null;
+    }
+
+    const statement = this._db.prepare(`
+      INSERT OR REPLACE INTO governance_scene_index_registry(
+        scene_id, total_specs, active_specs, completed_specs, stale_specs,
+        spec_ids_json, active_spec_ids_json, stale_spec_ids_json, generated_at,
+        scene_filter, source, indexed_at
+      )
+      VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+
+    this._withTransaction(() => {
+      for (const item of normalizedRecords) {
+        statement.run(
+          item.scene_id,
+          item.total_specs,
+          item.active_specs,
+          item.completed_specs,
+          item.stale_specs,
+          JSON.stringify(item.spec_ids || []),
+          JSON.stringify(item.active_spec_ids || []),
+          JSON.stringify(item.stale_spec_ids || []),
+          item.generated_at,
+          item.scene_filter,
+          item.source,
+          item.indexed_at
+        );
+      }
+    });
+
+    const totalRow = this._db
+      .prepare('SELECT COUNT(*) AS total FROM governance_scene_index_registry')
+      .get();
+
+    return {
+      success: true,
+      written: normalizedRecords.length,
+      total: normalizeNonNegativeInteger(totalRow && totalRow.total, 0)
+    };
+  }
+
+  async listGovernanceSceneIndexRecords(options = {}) {
+    const limit = normalizeInteger(options.limit, 100);
+    const sceneId = normalizeString(options.sceneId);
+
+    if (this._useMemoryBackend()) {
+      let rows = Object.values(this._memory.governance_scene_index || {}).map((item) => ({ ...item }));
+      if (sceneId) {
+        rows = rows.filter((item) => normalizeString(item.scene_id) === sceneId);
+      }
+      rows.sort((left, right) => {
+        if (right.total_specs !== left.total_specs) {
+          return right.total_specs - left.total_specs;
+        }
+        return `${left.scene_id}`.localeCompare(`${right.scene_id}`);
+      });
+      if (limit > 0) {
+        rows = rows.slice(0, limit);
+      }
+      return rows.map((row) => this._mapGovernanceSceneIndexRow({
+        ...row,
+        spec_ids_json: JSON.stringify(row.spec_ids || []),
+        active_spec_ids_json: JSON.stringify(row.active_spec_ids || []),
+        stale_spec_ids_json: JSON.stringify(row.stale_spec_ids || [])
+      }));
+    }
+
+    if (!await this.ensureReady()) {
+      return null;
+    }
+
+    let query = `
+      SELECT scene_id, total_specs, active_specs, completed_specs, stale_specs,
+             spec_ids_json, active_spec_ids_json, stale_spec_ids_json, generated_at,
+             scene_filter, source, indexed_at
+      FROM governance_scene_index_registry
+    `;
+    const params = [];
+    if (sceneId) {
+      query += ' WHERE scene_id = ?';
+      params.push(sceneId);
+    }
+    query += ' ORDER BY total_specs DESC, active_specs DESC, scene_id ASC';
+    if (limit > 0) {
+      query += ' LIMIT ?';
+      params.push(limit);
+    }
+
+    const rows = this._db.prepare(query).all(...params);
+    return rows
+      .map((row) => this._mapGovernanceSceneIndexRow(row))
+      .filter(Boolean);
+  }
+
+  async upsertReleaseEvidenceRunRecords(records = [], options = {}) {
+    const source = normalizeString(options.source) || 'file.release-evidence.handoff-runs';
+    const nowIso = this.now();
+    const normalizedRecords = Array.isArray(records)
+      ? records.map((item) => ({
+        session_id: normalizeString(item && item.session_id),
+        merged_at: normalizeIsoTimestamp(item && item.merged_at, '') || null,
+        status: normalizeString(item && item.status) || null,
+        gate_passed: normalizeBooleanValue(item && item.gate_passed, false),
+        spec_success_rate_percent: Number.isFinite(Number(item && item.spec_success_rate_percent))
+          ? Number(item.spec_success_rate_percent)
+          : null,
+        risk_level: normalizeString(item && item.risk_level) || null,
+        ontology_quality_score: Number.isFinite(Number(item && item.ontology_quality_score))
+          ? Number(item.ontology_quality_score)
+          : null,
+        capability_coverage_percent: Number.isFinite(Number(item && item.capability_coverage_percent))
+          ? Number(item.capability_coverage_percent)
+          : null,
+        capability_coverage_passed: normalizeBooleanValue(item && item.capability_coverage_passed, false),
+        scene_package_batch_passed: normalizeBooleanValue(item && item.scene_package_batch_passed, false),
+        scene_package_batch_failure_count: normalizeNonNegativeInteger(item && item.scene_package_batch_failure_count, 0),
+        failed_goals: normalizeNonNegativeInteger(item && item.failed_goals, 0),
+        release_gate_preflight_available: normalizeBooleanValue(item && item.release_gate_preflight_available, false),
+        release_gate_preflight_blocked: normalizeBooleanValue(item && item.release_gate_preflight_blocked, false),
+        source_updated_at: normalizeIsoTimestamp(item && item.source_updated_at, '') || null,
+        source: normalizeString(item && item.source) || source,
+        indexed_at: nowIso
+      }))
+        .filter((item) => item.session_id)
+      : [];
+
+    if (this._useMemoryBackend()) {
+      for (const item of normalizedRecords) {
+        this._memory.release_evidence_run[item.session_id] = { ...item };
+      }
+      return {
+        success: true,
+        written: normalizedRecords.length,
+        total: Object.keys(this._memory.release_evidence_run || {}).length
+      };
+    }
+
+    if (!await this.ensureReady()) {
+      return null;
+    }
+
+    const statement = this._db.prepare(`
+      INSERT OR REPLACE INTO release_evidence_run_registry(
+        session_id, merged_at, status, gate_passed, spec_success_rate_percent, risk_level,
+        ontology_quality_score, capability_coverage_percent, capability_coverage_passed,
+        scene_package_batch_passed, scene_package_batch_failure_count, failed_goals,
+        release_gate_preflight_available, release_gate_preflight_blocked,
+        source_updated_at, source, indexed_at
+      )
+      VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+
+    this._withTransaction(() => {
+      for (const item of normalizedRecords) {
+        statement.run(
+          item.session_id,
+          item.merged_at,
+          item.status,
+          item.gate_passed ? 1 : 0,
+          item.spec_success_rate_percent,
+          item.risk_level,
+          item.ontology_quality_score,
+          item.capability_coverage_percent,
+          item.capability_coverage_passed ? 1 : 0,
+          item.scene_package_batch_passed ? 1 : 0,
+          item.scene_package_batch_failure_count,
+          item.failed_goals,
+          item.release_gate_preflight_available ? 1 : 0,
+          item.release_gate_preflight_blocked ? 1 : 0,
+          item.source_updated_at,
+          item.source,
+          item.indexed_at
+        );
+      }
+    });
+
+    const totalRow = this._db
+      .prepare('SELECT COUNT(*) AS total FROM release_evidence_run_registry')
+      .get();
+
+    return {
+      success: true,
+      written: normalizedRecords.length,
+      total: normalizeNonNegativeInteger(totalRow && totalRow.total, 0)
+    };
+  }
+
+  async listReleaseEvidenceRunRecords(options = {}) {
+    const limit = normalizeInteger(options.limit, 100);
+    const status = normalizeString(options.status);
+    const riskLevel = normalizeString(options.riskLevel || options.risk_level);
+
+    if (this._useMemoryBackend()) {
+      let rows = Object.values(this._memory.release_evidence_run || {}).map((item) => ({ ...item }));
+      if (status) {
+        rows = rows.filter((item) => normalizeString(item.status) === status);
+      }
+      if (riskLevel) {
+        rows = rows.filter((item) => normalizeString(item.risk_level) === riskLevel);
+      }
+      rows.sort((left, right) => {
+        const leftTs = Date.parse(left.merged_at || '') || 0;
+        const rightTs = Date.parse(right.merged_at || '') || 0;
+        if (rightTs !== leftTs) {
+          return rightTs - leftTs;
+        }
+        return `${right.session_id}`.localeCompare(`${left.session_id}`);
+      });
+      if (limit > 0) {
+        rows = rows.slice(0, limit);
+      }
+      return rows.map((row) => this._mapReleaseEvidenceRunRow(row));
+    }
+
+    if (!await this.ensureReady()) {
+      return null;
+    }
+
+    let query = `
+      SELECT session_id, merged_at, status, gate_passed, spec_success_rate_percent, risk_level,
+             ontology_quality_score, capability_coverage_percent, capability_coverage_passed,
+             scene_package_batch_passed, scene_package_batch_failure_count, failed_goals,
+             release_gate_preflight_available, release_gate_preflight_blocked, source_updated_at,
+             source, indexed_at
+      FROM release_evidence_run_registry
+    `;
+    const clauses = [];
+    const params = [];
+    if (status) {
+      clauses.push('status = ?');
+      params.push(status);
+    }
+    if (riskLevel) {
+      clauses.push('risk_level = ?');
+      params.push(riskLevel);
+    }
+    if (clauses.length > 0) {
+      query += ` WHERE ${clauses.join(' AND ')}`;
+    }
+    query += ' ORDER BY merged_at DESC, session_id DESC';
+    if (limit > 0) {
+      query += ' LIMIT ?';
+      params.push(limit);
+    }
+
+    const rows = this._db.prepare(query).all(...params);
+    return rows
+      .map((row) => this._mapReleaseEvidenceRunRow(row))
+      .filter(Boolean);
+  }
+
+  async upsertReleaseGateHistoryRecords(records = [], options = {}) {
+    const source = normalizeString(options.source) || 'file.release-evidence.gate-history';
+    const nowIso = this.now();
+    const normalizedRecords = Array.isArray(records)
+      ? records.map((item) => ({
+        tag: normalizeString(item && item.tag),
+        evaluated_at: normalizeIsoTimestamp(item && item.evaluated_at, '') || null,
+        gate_passed: normalizeBooleanValue(item && item.gate_passed, false),
+        enforce: normalizeBooleanValue(item && item.enforce, false),
+        risk_level: normalizeString(item && item.risk_level) || null,
+        spec_success_rate_percent: Number.isFinite(Number(item && item.spec_success_rate_percent))
+          ? Number(item.spec_success_rate_percent)
+          : null,
+        scene_package_batch_passed: normalizeBooleanValue(item && item.scene_package_batch_passed, false),
+        scene_package_batch_failure_count: normalizeNonNegativeInteger(item && item.scene_package_batch_failure_count, 0),
+        capability_expected_unknown_count: normalizeNonNegativeInteger(item && item.capability_expected_unknown_count, 0),
+        capability_provided_unknown_count: normalizeNonNegativeInteger(item && item.capability_provided_unknown_count, 0),
+        release_gate_preflight_available: normalizeBooleanValue(item && item.release_gate_preflight_available, false),
+        release_gate_preflight_blocked: normalizeBooleanValue(item && item.release_gate_preflight_blocked, false),
+        require_release_gate_preflight: normalizeBooleanValue(item && item.require_release_gate_preflight, false),
+        drift_alert_count: normalizeNonNegativeInteger(item && item.drift_alert_count, 0),
+        drift_blocked: normalizeBooleanValue(item && item.drift_blocked, false),
+        weekly_ops_blocked: normalizeBooleanValue(item && item.weekly_ops_blocked, false),
+        source_updated_at: normalizeIsoTimestamp(item && item.source_updated_at, '') || null,
+        source: normalizeString(item && item.source) || source,
+        indexed_at: nowIso
+      }))
+        .filter((item) => item.tag)
+      : [];
+
+    if (this._useMemoryBackend()) {
+      for (const item of normalizedRecords) {
+        this._memory.release_gate_history[item.tag] = { ...item };
+      }
+      return {
+        success: true,
+        written: normalizedRecords.length,
+        total: Object.keys(this._memory.release_gate_history || {}).length
+      };
+    }
+
+    if (!await this.ensureReady()) {
+      return null;
+    }
+
+    const statement = this._db.prepare(`
+      INSERT OR REPLACE INTO release_gate_history_registry(
+        tag, evaluated_at, gate_passed, enforce, risk_level, spec_success_rate_percent,
+        scene_package_batch_passed, scene_package_batch_failure_count,
+        capability_expected_unknown_count, capability_provided_unknown_count,
+        release_gate_preflight_available, release_gate_preflight_blocked,
+        require_release_gate_preflight, drift_alert_count, drift_blocked,
+        weekly_ops_blocked, source_updated_at, source, indexed_at
+      )
+      VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+
+    this._withTransaction(() => {
+      for (const item of normalizedRecords) {
+        statement.run(
+          item.tag,
+          item.evaluated_at,
+          item.gate_passed ? 1 : 0,
+          item.enforce ? 1 : 0,
+          item.risk_level,
+          item.spec_success_rate_percent,
+          item.scene_package_batch_passed ? 1 : 0,
+          item.scene_package_batch_failure_count,
+          item.capability_expected_unknown_count,
+          item.capability_provided_unknown_count,
+          item.release_gate_preflight_available ? 1 : 0,
+          item.release_gate_preflight_blocked ? 1 : 0,
+          item.require_release_gate_preflight ? 1 : 0,
+          item.drift_alert_count,
+          item.drift_blocked ? 1 : 0,
+          item.weekly_ops_blocked ? 1 : 0,
+          item.source_updated_at,
+          item.source,
+          item.indexed_at
+        );
+      }
+    });
+
+    const totalRow = this._db
+      .prepare('SELECT COUNT(*) AS total FROM release_gate_history_registry')
+      .get();
+
+    return {
+      success: true,
+      written: normalizedRecords.length,
+      total: normalizeNonNegativeInteger(totalRow && totalRow.total, 0)
+    };
+  }
+
+  async listReleaseGateHistoryRecords(options = {}) {
+    const limit = normalizeInteger(options.limit, 100);
+    const tag = normalizeString(options.tag);
+    const riskLevel = normalizeString(options.riskLevel || options.risk_level);
+
+    if (this._useMemoryBackend()) {
+      let rows = Object.values(this._memory.release_gate_history || {}).map((item) => ({ ...item }));
+      if (tag) {
+        rows = rows.filter((item) => normalizeString(item.tag) === tag);
+      }
+      if (riskLevel) {
+        rows = rows.filter((item) => normalizeString(item.risk_level) === riskLevel);
+      }
+      rows.sort((left, right) => {
+        const leftTs = Date.parse(left.evaluated_at || '') || 0;
+        const rightTs = Date.parse(right.evaluated_at || '') || 0;
+        if (rightTs !== leftTs) {
+          return rightTs - leftTs;
+        }
+        return `${right.tag}`.localeCompare(`${left.tag}`);
+      });
+      if (limit > 0) {
+        rows = rows.slice(0, limit);
+      }
+      return rows.map((row) => this._mapReleaseGateHistoryRow(row));
+    }
+
+    if (!await this.ensureReady()) {
+      return null;
+    }
+
+    let query = `
+      SELECT tag, evaluated_at, gate_passed, enforce, risk_level, spec_success_rate_percent,
+             scene_package_batch_passed, scene_package_batch_failure_count,
+             capability_expected_unknown_count, capability_provided_unknown_count,
+             release_gate_preflight_available, release_gate_preflight_blocked,
+             require_release_gate_preflight, drift_alert_count, drift_blocked,
+             weekly_ops_blocked, source_updated_at, source, indexed_at
+      FROM release_gate_history_registry
+    `;
+    const clauses = [];
+    const params = [];
+    if (tag) {
+      clauses.push('tag = ?');
+      params.push(tag);
+    }
+    if (riskLevel) {
+      clauses.push('risk_level = ?');
+      params.push(riskLevel);
+    }
+    if (clauses.length > 0) {
+      query += ` WHERE ${clauses.join(' AND ')}`;
+    }
+    query += ' ORDER BY evaluated_at DESC, tag DESC';
+    if (limit > 0) {
+      query += ' LIMIT ?';
+      params.push(limit);
+    }
+
+    const rows = this._db.prepare(query).all(...params);
+    return rows
+      .map((row) => this._mapReleaseGateHistoryRow(row))
+      .filter(Boolean);
+  }
+
   _resolveOrCreateTaskRefInMemory(options = {}) {
     const sceneId = normalizeString(options.sceneId);
     const specId = normalizeString(options.specId);