scene-capability-engine 3.6.64 → 3.6.67

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

@@ -152,6 +152,11 @@ class SceStateStore {
       timeline_snapshots: {},
       scene_session_cycles: {},
       agent_runtime: {},
+      supreme_intent_assessments: {},
+      semantic_observations: {},
+      semantic_lesson_candidates: {},
+      semantic_evaluation_runs: {},
+      semantic_capability_ledgers: {},
       errorbook_entry_index: {},
       errorbook_incident_index: {},
       governance_spec_scene_override: {},
@@ -374,6 +379,176 @@ class SceStateStore {
       CREATE INDEX IF NOT EXISTS idx_agent_runtime_registry_status
         ON agent_runtime_registry(status);
 
+      CREATE TABLE IF NOT EXISTS supreme_intent_assessment_registry (
+        assessment_id TEXT PRIMARY KEY,
+        project_id TEXT,
+        channel_id TEXT,
+        session_id TEXT,
+        scene_id TEXT,
+        spec_id TEXT,
+        job_id TEXT,
+        source_kind TEXT NOT NULL,
+        action TEXT NOT NULL,
+        planning_allowed INTEGER NOT NULL,
+        execution_allowed INTEGER NOT NULL,
+        policy_path TEXT,
+        policy_loaded_from TEXT,
+        original_text TEXT,
+        effective_text TEXT,
+        message TEXT,
+        evidence_path TEXT,
+        worldview_json TEXT NOT NULL,
+        lifeview_json TEXT NOT NULL,
+        values_json TEXT NOT NULL,
+        methodology_json TEXT NOT NULL,
+        matched_rules_json TEXT NOT NULL,
+        clarification_questions_json TEXT NOT NULL,
+        metadata_json TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_supreme_intent_assessment_registry_project_ts
+        ON supreme_intent_assessment_registry(project_id, updated_at DESC);
+
+      CREATE INDEX IF NOT EXISTS idx_supreme_intent_assessment_registry_context
+        ON supreme_intent_assessment_registry(scene_id, spec_id, session_id, updated_at DESC);
+
+      CREATE INDEX IF NOT EXISTS idx_supreme_intent_assessment_registry_action
+        ON supreme_intent_assessment_registry(source_kind, action, updated_at DESC);
+
+      CREATE TABLE IF NOT EXISTS semantic_observation_registry (
+        observation_id TEXT PRIMARY KEY,
+        project_id TEXT,
+        channel_id TEXT,
+        session_id TEXT,
+        scene_id TEXT,
+        spec_id TEXT,
+        task_ref TEXT,
+        source_runtime TEXT NOT NULL,
+        source_kind TEXT,
+        host_session_id TEXT,
+        event_kind TEXT NOT NULL,
+        role TEXT,
+        intent TEXT,
+        summary TEXT,
+        outcome TEXT,
+        quality_signal TEXT,
+        raw_ref TEXT,
+        raw_payload_json TEXT NOT NULL,
+        normalized_payload_json TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_semantic_observation_registry_project_ts
+        ON semantic_observation_registry(project_id, updated_at DESC);
+
+      CREATE INDEX IF NOT EXISTS idx_semantic_observation_registry_context
+        ON semantic_observation_registry(scene_id, spec_id, task_ref, updated_at DESC);
+
+      CREATE INDEX IF NOT EXISTS idx_semantic_observation_registry_runtime
+        ON semantic_observation_registry(source_runtime, event_kind, updated_at DESC);
+
+      CREATE TABLE IF NOT EXISTS semantic_lesson_candidate_registry (
+        lesson_id TEXT PRIMARY KEY,
+        project_id TEXT,
+        scene_id TEXT,
+        spec_id TEXT,
+        source_runtime TEXT,
+        fingerprint TEXT,
+        lesson_type TEXT NOT NULL,
+        title TEXT,
+        summary TEXT,
+        heuristic TEXT,
+        confidence REAL,
+        status TEXT,
+        evidence_json TEXT,
+        metadata_json TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_semantic_lesson_candidate_registry_project_status
+        ON semantic_lesson_candidate_registry(project_id, status, updated_at DESC);
+
+      CREATE INDEX IF NOT EXISTS idx_semantic_lesson_candidate_registry_fingerprint
+        ON semantic_lesson_candidate_registry(fingerprint, updated_at DESC);
+
+      CREATE TABLE IF NOT EXISTS semantic_evaluation_run_registry (
+        evaluation_run_id TEXT PRIMARY KEY,
+        project_id TEXT,
+        channel_id TEXT,
+        session_id TEXT,
+        scene_id TEXT,
+        spec_id TEXT,
+        lesson_id TEXT,
+        source_runtime TEXT,
+        release_gate TEXT,
+        baseline_evaluation_run_id TEXT,
+        candidate_kind TEXT NOT NULL,
+        candidate_label TEXT,
+        candidate_payload_json TEXT NOT NULL,
+        observation_ids_json TEXT NOT NULL,
+        replay_summary_json TEXT NOT NULL,
+        score REAL,
+        threshold REAL,
+        verdict TEXT,
+        regression_detected INTEGER,
+        drift_level TEXT,
+        regression_reasons_json TEXT,
+        evidence_json TEXT,
+        governance_json TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_semantic_evaluation_run_registry_project_ts
+        ON semantic_evaluation_run_registry(project_id, updated_at DESC);
+
+      CREATE INDEX IF NOT EXISTS idx_semantic_evaluation_run_registry_context
+        ON semantic_evaluation_run_registry(scene_id, spec_id, session_id, updated_at DESC);
+
+      CREATE INDEX IF NOT EXISTS idx_semantic_evaluation_run_registry_verdict
+        ON semantic_evaluation_run_registry(verdict, regression_detected, updated_at DESC);
+
+      CREATE TABLE IF NOT EXISTS semantic_capability_ledger_registry (
+        capability_id TEXT PRIMARY KEY,
+        lesson_id TEXT,
+        evaluation_run_id TEXT,
+        project_id TEXT,
+        channel_id TEXT,
+        session_id TEXT,
+        scene_id TEXT,
+        spec_id TEXT,
+        target_library TEXT,
+        capability_status TEXT,
+        publish_state TEXT,
+        activation_count INTEGER,
+        activation_success_count INTEGER,
+        activation_mixed_count INTEGER,
+        activation_negative_count INTEGER,
+        quarantine_count INTEGER,
+        last_activated_at TEXT,
+        last_quality_signal TEXT,
+        last_runtime TEXT,
+        rank_score REAL,
+        lineage_json TEXT NOT NULL,
+        publication_json TEXT NOT NULL,
+        metrics_json TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_semantic_capability_ledger_registry_project_ts
+        ON semantic_capability_ledger_registry(project_id, updated_at DESC);
+
+      CREATE INDEX IF NOT EXISTS idx_semantic_capability_ledger_registry_status
+        ON semantic_capability_ledger_registry(capability_status, publish_state, updated_at DESC);
+
+      CREATE INDEX IF NOT EXISTS idx_semantic_capability_ledger_registry_lesson
+        ON semantic_capability_ledger_registry(lesson_id, updated_at DESC);
+
       CREATE TABLE IF NOT EXISTS state_migration_registry (
         migration_id TEXT PRIMARY KEY,
         component_id TEXT NOT NULL,
@@ -1116,6 +1291,163 @@ class SceStateStore {
     };
   }
 
+  _mapSupremeIntentAssessmentRow(row) {
+    if (!row) {
+      return null;
+    }
+    return {
+      assessment_id: normalizeString(row.assessment_id),
+      project_id: normalizeString(row.project_id) || null,
+      channel_id: normalizeString(row.channel_id) || null,
+      session_id: normalizeString(row.session_id) || null,
+      scene_id: normalizeString(row.scene_id) || null,
+      spec_id: normalizeString(row.spec_id) || null,
+      job_id: normalizeString(row.job_id) || null,
+      source_kind: normalizeString(row.source_kind) || null,
+      action: normalizeString(row.action) || null,
+      planning_allowed: normalizeBooleanValue(row.planning_allowed, false),
+      execution_allowed: normalizeBooleanValue(row.execution_allowed, false),
+      policy_path: normalizeString(row.policy_path) || null,
+      policy_loaded_from: normalizeString(row.policy_loaded_from) || null,
+      original_text: normalizeString(row.original_text) || null,
+      effective_text: normalizeString(row.effective_text) || null,
+      message: normalizeString(row.message) || null,
+      evidence_path: normalizeString(row.evidence_path) || null,
+      worldview: parseJsonSafe(row.worldview_json, {}) || {},
+      lifeview: parseJsonSafe(row.lifeview_json, {}) || {},
+      values: parseJsonSafe(row.values_json, {}) || {},
+      methodology: parseJsonSafe(row.methodology_json, {}) || {},
+      matched_rules: parseJsonSafe(row.matched_rules_json, {}) || {},
+      clarification_questions: normalizeStringArray(parseJsonSafe(row.clarification_questions_json, []), []),
+      metadata: parseJsonSafe(row.metadata_json, {}) || {},
+      created_at: normalizeIsoTimestamp(row.created_at) || null,
+      updated_at: normalizeIsoTimestamp(row.updated_at) || null
+    };
+  }
+
+  _mapSemanticObservationRow(row) {
+    if (!row) {
+      return null;
+    }
+    return {
+      observation_id: normalizeString(row.observation_id),
+      project_id: normalizeString(row.project_id) || null,
+      channel_id: normalizeString(row.channel_id) || null,
+      session_id: normalizeString(row.session_id) || null,
+      scene_id: normalizeString(row.scene_id) || null,
+      spec_id: normalizeString(row.spec_id) || null,
+      task_ref: normalizeString(row.task_ref) || null,
+      source_runtime: normalizeString(row.source_runtime) || null,
+      source_kind: normalizeString(row.source_kind) || null,
+      host_session_id: normalizeString(row.host_session_id) || null,
+      event_kind: normalizeString(row.event_kind) || null,
+      role: normalizeString(row.role) || null,
+      intent: normalizeString(row.intent) || null,
+      summary: normalizeString(row.summary) || null,
+      outcome: normalizeString(row.outcome) || null,
+      quality_signal: normalizeString(row.quality_signal) || null,
+      raw_ref: normalizeString(row.raw_ref) || null,
+      raw_payload: parseJsonSafe(row.raw_payload_json, {}) || {},
+      normalized_payload: parseJsonSafe(row.normalized_payload_json, {}) || {},
+      created_at: normalizeIsoTimestamp(row.created_at) || null,
+      updated_at: normalizeIsoTimestamp(row.updated_at) || null
+    };
+  }
+
+  _mapSemanticLessonCandidateRow(row) {
+    if (!row) {
+      return null;
+    }
+    const confidence = Number(row.confidence);
+    return {
+      lesson_id: normalizeString(row.lesson_id),
+      project_id: normalizeString(row.project_id) || null,
+      scene_id: normalizeString(row.scene_id) || null,
+      spec_id: normalizeString(row.spec_id) || null,
+      source_runtime: normalizeString(row.source_runtime) || null,
+      fingerprint: normalizeString(row.fingerprint) || null,
+      lesson_type: normalizeString(row.lesson_type) || null,
+      title: normalizeString(row.title) || null,
+      summary: normalizeString(row.summary) || null,
+      heuristic: normalizeString(row.heuristic) || null,
+      confidence: Number.isFinite(confidence) ? confidence : null,
+      status: normalizeString(row.status) || null,
+      evidence: parseJsonSafe(row.evidence_json, {}) || {},
+      metadata: parseJsonSafe(row.metadata_json, {}) || {},
+      created_at: normalizeIsoTimestamp(row.created_at) || null,
+      updated_at: normalizeIsoTimestamp(row.updated_at) || null
+    };
+  }
+
+  _mapSemanticEvaluationRunRow(row) {
+    if (!row) {
+      return null;
+    }
+    const score = Number(row.score);
+    const threshold = Number(row.threshold);
+    return {
+      evaluation_run_id: normalizeString(row.evaluation_run_id),
+      project_id: normalizeString(row.project_id) || null,
+      channel_id: normalizeString(row.channel_id) || null,
+      session_id: normalizeString(row.session_id) || null,
+      scene_id: normalizeString(row.scene_id) || null,
+      spec_id: normalizeString(row.spec_id) || null,
+      lesson_id: normalizeString(row.lesson_id) || null,
+      source_runtime: normalizeString(row.source_runtime) || null,
+      release_gate: normalizeString(row.release_gate) || null,
+      baseline_evaluation_run_id: normalizeString(row.baseline_evaluation_run_id) || null,
+      candidate_kind: normalizeString(row.candidate_kind) || null,
+      candidate_label: normalizeString(row.candidate_label) || null,
+      candidate_payload: parseJsonSafe(row.candidate_payload_json, {}) || {},
+      observation_ids: normalizeStringArray(parseJsonSafe(row.observation_ids_json, []), []),
+      replay_summary: parseJsonSafe(row.replay_summary_json, {}) || {},
+      score: Number.isFinite(score) ? Number(score.toFixed(2)) : null,
+      threshold: Number.isFinite(threshold) ? Number(threshold.toFixed(2)) : null,
+      verdict: normalizeString(row.verdict) || null,
+      regression_detected: normalizeBooleanValue(row.regression_detected, false),
+      drift_level: normalizeString(row.drift_level) || null,
+      regression_reasons: normalizeStringArray(parseJsonSafe(row.regression_reasons_json, []), []),
+      evidence: parseJsonSafe(row.evidence_json, {}) || {},
+      governance: parseJsonSafe(row.governance_json, {}) || {},
+      created_at: normalizeIsoTimestamp(row.created_at) || null,
+      updated_at: normalizeIsoTimestamp(row.updated_at) || null
+    };
+  }
+
+  _mapSemanticCapabilityLedgerRow(row) {
+    if (!row) {
+      return null;
+    }
+    const rankScore = Number(row.rank_score);
+    return {
+      capability_id: normalizeString(row.capability_id),
+      lesson_id: normalizeString(row.lesson_id) || null,
+      evaluation_run_id: normalizeString(row.evaluation_run_id) || null,
+      project_id: normalizeString(row.project_id) || null,
+      channel_id: normalizeString(row.channel_id) || null,
+      session_id: normalizeString(row.session_id) || null,
+      scene_id: normalizeString(row.scene_id) || null,
+      spec_id: normalizeString(row.spec_id) || null,
+      target_library: normalizeString(row.target_library) || null,
+      capability_status: normalizeString(row.capability_status) || null,
+      publish_state: normalizeString(row.publish_state) || null,
+      activation_count: normalizeNonNegativeInteger(row.activation_count, 0),
+      activation_success_count: normalizeNonNegativeInteger(row.activation_success_count, 0),
+      activation_mixed_count: normalizeNonNegativeInteger(row.activation_mixed_count, 0),
+      activation_negative_count: normalizeNonNegativeInteger(row.activation_negative_count, 0),
+      quarantine_count: normalizeNonNegativeInteger(row.quarantine_count, 0),
+      last_activated_at: normalizeIsoTimestamp(row.last_activated_at, '') || null,
+      last_quality_signal: normalizeString(row.last_quality_signal) || null,
+      last_runtime: normalizeString(row.last_runtime) || null,
+      rank_score: Number.isFinite(rankScore) ? Number(rankScore.toFixed(2)) : null,
+      lineage: parseJsonSafe(row.lineage_json, {}) || {},
+      publication: parseJsonSafe(row.publication_json, {}) || {},
+      metrics: parseJsonSafe(row.metrics_json, {}) || {},
+      created_at: normalizeIsoTimestamp(row.created_at) || null,
+      updated_at: normalizeIsoTimestamp(row.updated_at) || null
+    };
+  }
+
   _mapStateMigrationRow(row) {
     if (!row) {
       return null;
@@ -2779,6 +3111,1034 @@ class SceStateStore {
       .filter(Boolean);
   }
 
+  async appendSupremeIntentAssessment(record = {}) {
+    const action = normalizeString(record.action);
+    const sourceKind = normalizeString(record.source_kind || record.sourceKind);
+    if (!action || !sourceKind) {
+      return null;
+    }
+
+    const nowIso = this.now();
+    const assessmentId = normalizeString(record.assessment_id || record.assessmentId)
+      || `supreme-${Date.now()}-${crypto.randomBytes(3).toString('hex')}`;
+    const normalized = {
+      assessment_id: assessmentId,
+      project_id: normalizeString(record.project_id || record.projectId) || null,
+      channel_id: normalizeString(record.channel_id || record.channelId) || null,
+      session_id: normalizeString(record.session_id || record.sessionId) || null,
+      scene_id: normalizeString(record.scene_id || record.sceneId) || null,
+      spec_id: normalizeString(record.spec_id || record.specId) || null,
+      job_id: normalizeString(record.job_id || record.jobId) || null,
+      source_kind: sourceKind,
+      action,
+      planning_allowed: normalizeBooleanValue(record.planning_allowed ?? record.planningAllowed, false),
+      execution_allowed: normalizeBooleanValue(record.execution_allowed ?? record.executionAllowed, false),
+      policy_path: normalizeString(record.policy_path || record.policyPath) || null,
+      policy_loaded_from: normalizeString(record.policy_loaded_from || record.policyLoadedFrom) || null,
+      original_text: normalizeString(record.original_text || record.originalText) || null,
+      effective_text: normalizeString(record.effective_text || record.effectiveText) || null,
+      message: normalizeString(record.message) || null,
+      evidence_path: normalizeString(record.evidence_path || record.evidencePath) || null,
+      worldview: record.worldview && typeof record.worldview === 'object' ? record.worldview : {},
+      lifeview: record.lifeview && typeof record.lifeview === 'object' ? record.lifeview : {},
+      values: record.values && typeof record.values === 'object' ? record.values : {},
+      methodology: record.methodology && typeof record.methodology === 'object' ? record.methodology : {},
+      matched_rules: record.matched_rules && typeof record.matched_rules === 'object' ? record.matched_rules : {},
+      clarification_questions: normalizeStringArray(record.clarification_questions || record.clarificationQuestions, []),
+      metadata: record.metadata && typeof record.metadata === 'object' ? record.metadata : {},
+      created_at: normalizeIsoTimestamp(record.created_at || record.createdAt, nowIso) || nowIso,
+      updated_at: normalizeIsoTimestamp(record.updated_at || record.updatedAt, nowIso) || nowIso
+    };
+
+    if (this._useMemoryBackend()) {
+      this._memory.supreme_intent_assessments[normalized.assessment_id] = { ...normalized };
+      return this._mapSupremeIntentAssessmentRow({
+        ...normalized,
+        worldview_json: JSON.stringify(normalized.worldview || {}),
+        lifeview_json: JSON.stringify(normalized.lifeview || {}),
+        values_json: JSON.stringify(normalized.values || {}),
+        methodology_json: JSON.stringify(normalized.methodology || {}),
+        matched_rules_json: JSON.stringify(normalized.matched_rules || {}),
+        clarification_questions_json: JSON.stringify(normalized.clarification_questions || []),
+        metadata_json: JSON.stringify(normalized.metadata || {})
+      });
+    }
+
+    if (!await this.ensureReady()) {
+      return null;
+    }
+
+    this._db
+      .prepare(`
+        INSERT OR REPLACE INTO supreme_intent_assessment_registry(
+          assessment_id, project_id, channel_id, session_id, scene_id, spec_id, job_id,
+          source_kind, action, planning_allowed, execution_allowed, policy_path, policy_loaded_from,
+          original_text, effective_text, message, evidence_path, worldview_json, lifeview_json,
+          values_json, methodology_json, matched_rules_json, clarification_questions_json, metadata_json,
+          created_at, updated_at
+        )
+        VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `)
+      .run(
+        normalized.assessment_id,
+        normalized.project_id,
+        normalized.channel_id,
+        normalized.session_id,
+        normalized.scene_id,
+        normalized.spec_id,
+        normalized.job_id,
+        normalized.source_kind,
+        normalized.action,
+        normalized.planning_allowed ? 1 : 0,
+        normalized.execution_allowed ? 1 : 0,
+        normalized.policy_path,
+        normalized.policy_loaded_from,
+        normalized.original_text,
+        normalized.effective_text,
+        normalized.message,
+        normalized.evidence_path,
+        JSON.stringify(normalized.worldview || {}),
+        JSON.stringify(normalized.lifeview || {}),
+        JSON.stringify(normalized.values || {}),
+        JSON.stringify(normalized.methodology || {}),
+        JSON.stringify(normalized.matched_rules || {}),
+        JSON.stringify(normalized.clarification_questions || []),
+        JSON.stringify(normalized.metadata || {}),
+        normalized.created_at,
+        normalized.updated_at
+      );
+
+    return this.getSupremeIntentAssessment(normalized.assessment_id);
+  }
+
+  async getSupremeIntentAssessment(assessmentId) {
+    const normalizedAssessmentId = normalizeString(assessmentId);
+    if (!normalizedAssessmentId) {
+      return null;
+    }
+
+    if (this._useMemoryBackend()) {
+      const row = this._memory.supreme_intent_assessments[normalizedAssessmentId];
+      if (!row) {
+        return null;
+      }
+      return this._mapSupremeIntentAssessmentRow({
+        ...row,
+        worldview_json: JSON.stringify(row.worldview || {}),
+        lifeview_json: JSON.stringify(row.lifeview || {}),
+        values_json: JSON.stringify(row.values || {}),
+        methodology_json: JSON.stringify(row.methodology || {}),
+        matched_rules_json: JSON.stringify(row.matched_rules || {}),
+        clarification_questions_json: JSON.stringify(row.clarification_questions || []),
+        metadata_json: JSON.stringify(row.metadata || {})
+      });
+    }
+
+    if (!await this.ensureReady()) {
+      return null;
+    }
+
+    const row = this._db
+      .prepare(`
+        SELECT assessment_id, project_id, channel_id, session_id, scene_id, spec_id, job_id,
+               source_kind, action, planning_allowed, execution_allowed, policy_path, policy_loaded_from,
+               original_text, effective_text, message, evidence_path, worldview_json, lifeview_json,
+               values_json, methodology_json, matched_rules_json, clarification_questions_json, metadata_json,
+               created_at, updated_at
+        FROM supreme_intent_assessment_registry
+        WHERE assessment_id = ?
+      `)
+      .get(normalizedAssessmentId);
+    return this._mapSupremeIntentAssessmentRow(row);
+  }
+
+  async listSupremeIntentAssessments(options = {}) {
+    const limit = normalizeInteger(options.limit, 20);
+    const projectId = normalizeString(options.project_id || options.projectId);
+    const channelId = normalizeString(options.channel_id || options.channelId);
+    const sessionId = normalizeString(options.session_id || options.sessionId);
+    const sceneId = normalizeString(options.scene_id || options.sceneId);
+    const specId = normalizeString(options.spec_id || options.specId);
+    const jobId = normalizeString(options.job_id || options.jobId);
+    const sourceKind = normalizeString(options.source_kind || options.sourceKind);
+    const action = normalizeString(options.action);
+
+    if (this._useMemoryBackend()) {
+      let rows = Object.values(this._memory.supreme_intent_assessments || {}).map((item) => ({ ...item }));
+      if (projectId) rows = rows.filter((item) => normalizeString(item.project_id) === projectId);
+      if (channelId) rows = rows.filter((item) => normalizeString(item.channel_id) === channelId);
+      if (sessionId) rows = rows.filter((item) => normalizeString(item.session_id) === sessionId);
+      if (sceneId) rows = rows.filter((item) => normalizeString(item.scene_id) === sceneId);
+      if (specId) rows = rows.filter((item) => normalizeString(item.spec_id) === specId);
+      if (jobId) rows = rows.filter((item) => normalizeString(item.job_id) === jobId);
+      if (sourceKind) rows = rows.filter((item) => normalizeString(item.source_kind) === sourceKind);
+      if (action) rows = rows.filter((item) => normalizeString(item.action) === action);
+      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._mapSupremeIntentAssessmentRow({
+        ...row,
+        worldview_json: JSON.stringify(row.worldview || {}),
+        lifeview_json: JSON.stringify(row.lifeview || {}),
+        values_json: JSON.stringify(row.values || {}),
+        methodology_json: JSON.stringify(row.methodology || {}),
+        matched_rules_json: JSON.stringify(row.matched_rules || {}),
+        clarification_questions_json: JSON.stringify(row.clarification_questions || []),
+        metadata_json: JSON.stringify(row.metadata || {})
+      }));
+    }
+
+    if (!await this.ensureReady()) {
+      return null;
+    }
+
+    let query = `
+      SELECT assessment_id, project_id, channel_id, session_id, scene_id, spec_id, job_id,
+             source_kind, action, planning_allowed, execution_allowed, policy_path, policy_loaded_from,
+             original_text, effective_text, message, evidence_path, worldview_json, lifeview_json,
+             values_json, methodology_json, matched_rules_json, clarification_questions_json, metadata_json,
+             created_at, updated_at
+      FROM supreme_intent_assessment_registry
+    `;
+    const params = [];
+    const filters = [];
+    if (projectId) { filters.push('project_id = ?'); params.push(projectId); }
+    if (channelId) { filters.push('channel_id = ?'); params.push(channelId); }
+    if (sessionId) { filters.push('session_id = ?'); params.push(sessionId); }
+    if (sceneId) { filters.push('scene_id = ?'); params.push(sceneId); }
+    if (specId) { filters.push('spec_id = ?'); params.push(specId); }
+    if (jobId) { filters.push('job_id = ?'); params.push(jobId); }
+    if (sourceKind) { filters.push('source_kind = ?'); params.push(sourceKind); }
+    if (action) { filters.push('action = ?'); params.push(action); }
+    if (filters.length > 0) {
+      query += ` WHERE ${filters.join(' AND ')}`;
+    }
+    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._mapSupremeIntentAssessmentRow(row)).filter(Boolean);
+  }
+
+  async appendSemanticObservation(record = {}) {
+    const sourceRuntime = normalizeString(record.source_runtime || record.sourceRuntime);
+    const eventKind = normalizeString(record.event_kind || record.eventKind);
+    if (!sourceRuntime || !eventKind) {
+      return null;
+    }
+
+    const nowIso = this.now();
+    const observationId = normalizeString(record.observation_id || record.observationId)
+      || `sem-obs-${Date.now()}-${crypto.randomBytes(3).toString('hex')}`;
+    const normalized = {
+      observation_id: observationId,
+      project_id: normalizeString(record.project_id || record.projectId) || null,
+      channel_id: normalizeString(record.channel_id || record.channelId) || null,
+      session_id: normalizeString(record.session_id || record.sessionId) || null,
+      scene_id: normalizeString(record.scene_id || record.sceneId) || null,
+      spec_id: normalizeString(record.spec_id || record.specId) || null,
+      task_ref: normalizeString(record.task_ref || record.taskRef) || null,
+      source_runtime: sourceRuntime,
+      source_kind: normalizeString(record.source_kind || record.sourceKind) || 'embedded-host',
+      host_session_id: normalizeString(record.host_session_id || record.hostSessionId) || null,
+      event_kind: eventKind,
+      role: normalizeString(record.role) || null,
+      intent: normalizeString(record.intent) || null,
+      summary: normalizeString(record.summary) || null,
+      outcome: normalizeString(record.outcome) || null,
+      quality_signal: normalizeString(record.quality_signal || record.qualitySignal) || null,
+      raw_ref: normalizeString(record.raw_ref || record.rawRef) || null,
+      raw_payload: record.raw_payload && typeof record.raw_payload === 'object'
+        ? record.raw_payload
+        : (record.rawPayload && typeof record.rawPayload === 'object' ? record.rawPayload : {}),
+      normalized_payload: record.normalized_payload && typeof record.normalized_payload === 'object'
+        ? record.normalized_payload
+        : (record.normalizedPayload && typeof record.normalizedPayload === 'object' ? record.normalizedPayload : {}),
+      created_at: normalizeIsoTimestamp(record.created_at || record.createdAt, nowIso) || nowIso,
+      updated_at: normalizeIsoTimestamp(record.updated_at || record.updatedAt, nowIso) || nowIso
+    };
+
+    if (this._useMemoryBackend()) {
+      this._memory.semantic_observations[normalized.observation_id] = { ...normalized };
+      return this._mapSemanticObservationRow({
+        ...normalized,
+        raw_payload_json: JSON.stringify(normalized.raw_payload || {}),
+        normalized_payload_json: JSON.stringify(normalized.normalized_payload || {})
+      });
+    }
+
+    if (!await this.ensureReady()) {
+      return null;
+    }
+
+    this._db
+      .prepare(`
+        INSERT OR REPLACE INTO semantic_observation_registry(
+          observation_id, project_id, channel_id, session_id, scene_id, spec_id, task_ref,
+          source_runtime, source_kind, host_session_id, event_kind, role, intent, summary,
+          outcome, quality_signal, raw_ref, raw_payload_json, normalized_payload_json, created_at, updated_at
+        )
+        VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `)
+      .run(
+        normalized.observation_id,
+        normalized.project_id,
+        normalized.channel_id,
+        normalized.session_id,
+        normalized.scene_id,
+        normalized.spec_id,
+        normalized.task_ref,
+        normalized.source_runtime,
+        normalized.source_kind,
+        normalized.host_session_id,
+        normalized.event_kind,
+        normalized.role,
+        normalized.intent,
+        normalized.summary,
+        normalized.outcome,
+        normalized.quality_signal,
+        normalized.raw_ref,
+        JSON.stringify(normalized.raw_payload || {}),
+        JSON.stringify(normalized.normalized_payload || {}),
+        normalized.created_at,
+        normalized.updated_at
+      );
+
+    return this.getSemanticObservation(normalized.observation_id);
+  }
+
+  async getSemanticObservation(observationId) {
+    const normalizedObservationId = normalizeString(observationId);
+    if (!normalizedObservationId) {
+      return null;
+    }
+
+    if (this._useMemoryBackend()) {
+      const row = this._memory.semantic_observations[normalizedObservationId];
+      if (!row) {
+        return null;
+      }
+      return this._mapSemanticObservationRow({
+        ...row,
+        raw_payload_json: JSON.stringify(row.raw_payload || {}),
+        normalized_payload_json: JSON.stringify(row.normalized_payload || {})
+      });
+    }
+
+    if (!await this.ensureReady()) {
+      return null;
+    }
+
+    const row = this._db
+      .prepare(`
+        SELECT observation_id, project_id, channel_id, session_id, scene_id, spec_id, task_ref,
+               source_runtime, source_kind, host_session_id, event_kind, role, intent, summary,
+               outcome, quality_signal, raw_ref, raw_payload_json, normalized_payload_json, created_at, updated_at
+        FROM semantic_observation_registry
+        WHERE observation_id = ?
+      `)
+      .get(normalizedObservationId);
+    return this._mapSemanticObservationRow(row);
+  }
+
+  async listSemanticObservations(options = {}) {
+    const limit = normalizeInteger(options.limit, 20);
+    const projectId = normalizeString(options.project_id || options.projectId);
+    const sourceRuntime = normalizeString(options.source_runtime || options.sourceRuntime);
+    const sessionId = normalizeString(options.session_id || options.sessionId);
+
+    if (this._useMemoryBackend()) {
+      let rows = Object.values(this._memory.semantic_observations || {}).map((item) => ({ ...item }));
+      if (projectId) {
+        rows = rows.filter((item) => normalizeString(item.project_id) === projectId);
+      }
+      if (sourceRuntime) {
+        rows = rows.filter((item) => normalizeString(item.source_runtime) === sourceRuntime);
+      }
+      if (sessionId) {
+        rows = rows.filter((item) => normalizeString(item.session_id) === sessionId);
+      }
+      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._mapSemanticObservationRow({
+        ...row,
+        raw_payload_json: JSON.stringify(row.raw_payload || {}),
+        normalized_payload_json: JSON.stringify(row.normalized_payload || {})
+      }));
+    }
+
+    if (!await this.ensureReady()) {
+      return null;
+    }
+
+    let query = `
+      SELECT observation_id, project_id, channel_id, session_id, scene_id, spec_id, task_ref,
+             source_runtime, source_kind, host_session_id, event_kind, role, intent, summary,
+             outcome, quality_signal, raw_ref, raw_payload_json, normalized_payload_json, created_at, updated_at
+      FROM semantic_observation_registry
+    `;
+    const params = [];
+    const filters = [];
+    if (projectId) {
+      filters.push('project_id = ?');
+      params.push(projectId);
+    }
+    if (sourceRuntime) {
+      filters.push('source_runtime = ?');
+      params.push(sourceRuntime);
+    }
+    if (sessionId) {
+      filters.push('session_id = ?');
+      params.push(sessionId);
+    }
+    if (filters.length > 0) {
+      query += ` WHERE ${filters.join(' AND ')}`;
+    }
+    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._mapSemanticObservationRow(row)).filter(Boolean);
+  }
+
+  async upsertSemanticLessonCandidate(record = {}) {
+    const lessonType = normalizeString(record.lesson_type || record.lessonType);
+    if (!lessonType) {
+      return null;
+    }
+    const nowIso = this.now();
+    const lessonId = normalizeString(record.lesson_id || record.lessonId)
+      || `sem-lesson-${Date.now()}-${crypto.randomBytes(3).toString('hex')}`;
+    const confidenceValue = Number(record.confidence);
+    const normalized = {
+      lesson_id: lessonId,
+      project_id: normalizeString(record.project_id || record.projectId) || null,
+      scene_id: normalizeString(record.scene_id || record.sceneId) || null,
+      spec_id: normalizeString(record.spec_id || record.specId) || null,
+      source_runtime: normalizeString(record.source_runtime || record.sourceRuntime) || null,
+      fingerprint: normalizeString(record.fingerprint) || null,
+      lesson_type: lessonType,
+      title: normalizeString(record.title) || null,
+      summary: normalizeString(record.summary) || null,
+      heuristic: normalizeString(record.heuristic) || null,
+      confidence: Number.isFinite(confidenceValue) ? confidenceValue : null,
+      status: normalizeString(record.status) || 'candidate',
+      evidence: record.evidence && typeof record.evidence === 'object' ? record.evidence : {},
+      metadata: record.metadata && typeof record.metadata === 'object' ? record.metadata : {},
+      created_at: normalizeIsoTimestamp(record.created_at || record.createdAt, nowIso) || nowIso,
+      updated_at: normalizeIsoTimestamp(record.updated_at || record.updatedAt, nowIso) || nowIso
+    };
+
+    if (this._useMemoryBackend()) {
+      this._memory.semantic_lesson_candidates[normalized.lesson_id] = { ...normalized };
+      return this._mapSemanticLessonCandidateRow({
+        ...normalized,
+        evidence_json: JSON.stringify(normalized.evidence || {}),
+        metadata_json: JSON.stringify(normalized.metadata || {})
+      });
+    }
+
+    if (!await this.ensureReady()) {
+      return null;
+    }
+
+    this._db
+      .prepare(`
+        INSERT OR REPLACE INTO semantic_lesson_candidate_registry(
+          lesson_id, project_id, scene_id, spec_id, source_runtime, fingerprint, lesson_type,
+          title, summary, heuristic, confidence, status, evidence_json, metadata_json, created_at, updated_at
+        )
+        VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `)
+      .run(
+        normalized.lesson_id,
+        normalized.project_id,
+        normalized.scene_id,
+        normalized.spec_id,
+        normalized.source_runtime,
+        normalized.fingerprint,
+        normalized.lesson_type,
+        normalized.title,
+        normalized.summary,
+        normalized.heuristic,
+        normalized.confidence,
+        normalized.status,
+        JSON.stringify(normalized.evidence || {}),
+        JSON.stringify(normalized.metadata || {}),
+        normalized.created_at,
+        normalized.updated_at
+      );
+
+    return this.getSemanticLessonCandidate(normalized.lesson_id);
+  }
+
+  async getSemanticLessonCandidate(lessonId) {
+    const normalizedLessonId = normalizeString(lessonId);
+    if (!normalizedLessonId) {
+      return null;
+    }
+
+    if (this._useMemoryBackend()) {
+      const row = this._memory.semantic_lesson_candidates[normalizedLessonId];
+      if (!row) {
+        return null;
+      }
+      return this._mapSemanticLessonCandidateRow({
+        ...row,
+        evidence_json: JSON.stringify(row.evidence || {}),
+        metadata_json: JSON.stringify(row.metadata || {})
+      });
+    }
+
+    if (!await this.ensureReady()) {
+      return null;
+    }
+
+    const row = this._db
+      .prepare(`
+        SELECT lesson_id, project_id, scene_id, spec_id, source_runtime, fingerprint, lesson_type,
+               title, summary, heuristic, confidence, status, evidence_json, metadata_json, created_at, updated_at
+        FROM semantic_lesson_candidate_registry
+        WHERE lesson_id = ?
+      `)
+      .get(normalizedLessonId);
+    return this._mapSemanticLessonCandidateRow(row);
+  }
+
+  async listSemanticLessonCandidates(options = {}) {
+    const limit = normalizeInteger(options.limit, 20);
+    const projectId = normalizeString(options.project_id || options.projectId);
+    const status = normalizeString(options.status);
+
+    if (this._useMemoryBackend()) {
+      let rows = Object.values(this._memory.semantic_lesson_candidates || {}).map((item) => ({ ...item }));
+      if (projectId) {
+        rows = rows.filter((item) => normalizeString(item.project_id) === projectId);
+      }
+      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._mapSemanticLessonCandidateRow({
+        ...row,
+        evidence_json: JSON.stringify(row.evidence || {}),
+        metadata_json: JSON.stringify(row.metadata || {})
+      }));
+    }
+
+    if (!await this.ensureReady()) {
+      return null;
+    }
+
+    let query = `
+      SELECT lesson_id, project_id, scene_id, spec_id, source_runtime, fingerprint, lesson_type,
+             title, summary, heuristic, confidence, status, evidence_json, metadata_json, created_at, updated_at
+      FROM semantic_lesson_candidate_registry
+    `;
+    const params = [];
+    const filters = [];
+    if (projectId) {
+      filters.push('project_id = ?');
+      params.push(projectId);
+    }
+    if (status) {
+      filters.push('status = ?');
+      params.push(status);
+    }
+    if (filters.length > 0) {
+      query += ` WHERE ${filters.join(' AND ')}`;
+    }
+    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._mapSemanticLessonCandidateRow(row)).filter(Boolean);
+  }
+
+  async appendSemanticEvaluationRun(record = {}) {
+    const candidateKind = normalizeString(record.candidate_kind || record.candidateKind);
+    if (!candidateKind) {
+      return null;
+    }
+
+    const nowIso = this.now();
+    const evaluationRunId = normalizeString(record.evaluation_run_id || record.evaluationRunId)
+      || `sem-eval-${Date.now()}-${crypto.randomBytes(3).toString('hex')}`;
+    const scoreValue = Number(record.score);
+    const thresholdValue = Number(record.threshold);
+    const normalized = {
+      evaluation_run_id: evaluationRunId,
+      project_id: normalizeString(record.project_id || record.projectId) || null,
+      channel_id: normalizeString(record.channel_id || record.channelId) || null,
+      session_id: normalizeString(record.session_id || record.sessionId) || null,
+      scene_id: normalizeString(record.scene_id || record.sceneId) || null,
+      spec_id: normalizeString(record.spec_id || record.specId) || null,
+      lesson_id: normalizeString(record.lesson_id || record.lessonId) || null,
+      source_runtime: normalizeString(record.source_runtime || record.sourceRuntime) || null,
+      release_gate: normalizeString(record.release_gate || record.releaseGate) || null,
+      baseline_evaluation_run_id: normalizeString(record.baseline_evaluation_run_id || record.baselineEvaluationRunId) || null,
+      candidate_kind: candidateKind,
+      candidate_label: normalizeString(record.candidate_label || record.candidateLabel) || null,
+      candidate_payload: record.candidate_payload && typeof record.candidate_payload === 'object'
+        ? record.candidate_payload
+        : (record.candidatePayload && typeof record.candidatePayload === 'object' ? record.candidatePayload : {}),
+      observation_ids: normalizeStringArray(record.observation_ids || record.observationIds, []),
+      replay_summary: record.replay_summary && typeof record.replay_summary === 'object'
+        ? record.replay_summary
+        : (record.replaySummary && typeof record.replaySummary === 'object' ? record.replaySummary : {}),
+      score: Number.isFinite(scoreValue) ? Number(scoreValue.toFixed(2)) : null,
+      threshold: Number.isFinite(thresholdValue) ? Number(thresholdValue.toFixed(2)) : null,
+      verdict: normalizeString(record.verdict) || null,
+      regression_detected: normalizeBooleanValue(record.regression_detected || record.regressionDetected, false),
+      drift_level: normalizeString(record.drift_level || record.driftLevel) || null,
+      regression_reasons: normalizeStringArray(record.regression_reasons || record.regressionReasons, []),
+      evidence: record.evidence && typeof record.evidence === 'object' ? record.evidence : {},
+      governance: record.governance && typeof record.governance === 'object' ? record.governance : {},
+      created_at: normalizeIsoTimestamp(record.created_at || record.createdAt, nowIso) || nowIso,
+      updated_at: normalizeIsoTimestamp(record.updated_at || record.updatedAt, nowIso) || nowIso
+    };
+
+    if (this._useMemoryBackend()) {
+      this._memory.semantic_evaluation_runs[normalized.evaluation_run_id] = { ...normalized };
+      return this._mapSemanticEvaluationRunRow({
+        ...normalized,
+        candidate_payload_json: JSON.stringify(normalized.candidate_payload || {}),
+        observation_ids_json: JSON.stringify(normalized.observation_ids || []),
+        replay_summary_json: JSON.stringify(normalized.replay_summary || {}),
+        regression_reasons_json: JSON.stringify(normalized.regression_reasons || []),
+        evidence_json: JSON.stringify(normalized.evidence || {}),
+        governance_json: JSON.stringify(normalized.governance || {})
+      });
+    }
+
+    if (!await this.ensureReady()) {
+      return null;
+    }
+
+    this._db
+      .prepare(`
+        INSERT OR REPLACE INTO semantic_evaluation_run_registry(
+          evaluation_run_id, project_id, channel_id, session_id, scene_id, spec_id, lesson_id,
+          source_runtime, release_gate, baseline_evaluation_run_id, candidate_kind, candidate_label,
+          candidate_payload_json, observation_ids_json, replay_summary_json, score, threshold, verdict,
+          regression_detected, drift_level, regression_reasons_json, evidence_json, governance_json,
+          created_at, updated_at
+        )
+        VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `)
+      .run(
+        normalized.evaluation_run_id,
+        normalized.project_id,
+        normalized.channel_id,
+        normalized.session_id,
+        normalized.scene_id,
+        normalized.spec_id,
+        normalized.lesson_id,
+        normalized.source_runtime,
+        normalized.release_gate,
+        normalized.baseline_evaluation_run_id,
+        normalized.candidate_kind,
+        normalized.candidate_label,
+        JSON.stringify(normalized.candidate_payload || {}),
+        JSON.stringify(normalized.observation_ids || []),
+        JSON.stringify(normalized.replay_summary || {}),
+        normalized.score,
+        normalized.threshold,
+        normalized.verdict,
+        normalized.regression_detected ? 1 : 0,
+        normalized.drift_level,
+        JSON.stringify(normalized.regression_reasons || []),
+        JSON.stringify(normalized.evidence || {}),
+        JSON.stringify(normalized.governance || {}),
+        normalized.created_at,
+        normalized.updated_at
+      );
+
+    return this.getSemanticEvaluationRun(normalized.evaluation_run_id);
+  }
+
+  async getSemanticEvaluationRun(evaluationRunId) {
+    const normalizedEvaluationRunId = normalizeString(evaluationRunId);
+    if (!normalizedEvaluationRunId) {
+      return null;
+    }
+
+    if (this._useMemoryBackend()) {
+      const row = this._memory.semantic_evaluation_runs[normalizedEvaluationRunId];
+      if (!row) {
+        return null;
+      }
+      return this._mapSemanticEvaluationRunRow({
+        ...row,
+        candidate_payload_json: JSON.stringify(row.candidate_payload || {}),
+        observation_ids_json: JSON.stringify(row.observation_ids || []),
+        replay_summary_json: JSON.stringify(row.replay_summary || {}),
+        regression_reasons_json: JSON.stringify(row.regression_reasons || []),
+        evidence_json: JSON.stringify(row.evidence || {}),
+        governance_json: JSON.stringify(row.governance || {})
+      });
+    }
+
+    if (!await this.ensureReady()) {
+      return null;
+    }
+
+    const row = this._db
+      .prepare(`
+        SELECT evaluation_run_id, project_id, channel_id, session_id, scene_id, spec_id, lesson_id,
+               source_runtime, release_gate, baseline_evaluation_run_id, candidate_kind, candidate_label,
+               candidate_payload_json, observation_ids_json, replay_summary_json, score, threshold, verdict,
+               regression_detected, drift_level, regression_reasons_json, evidence_json, governance_json,
+               created_at, updated_at
+        FROM semantic_evaluation_run_registry
+        WHERE evaluation_run_id = ?
+      `)
+      .get(normalizedEvaluationRunId);
+    return this._mapSemanticEvaluationRunRow(row);
+  }
+
+  async listSemanticEvaluationRuns(options = {}) {
+    const limit = normalizeInteger(options.limit, 20);
+    const projectId = normalizeString(options.project_id || options.projectId);
+    const sessionId = normalizeString(options.session_id || options.sessionId);
+    const specId = normalizeString(options.spec_id || options.specId);
+    const verdict = normalizeString(options.verdict);
+
+    if (this._useMemoryBackend()) {
+      let rows = Object.values(this._memory.semantic_evaluation_runs || {}).map((item) => ({ ...item }));
+      if (projectId) {
+        rows = rows.filter((item) => normalizeString(item.project_id) === projectId);
+      }
+      if (sessionId) {
+        rows = rows.filter((item) => normalizeString(item.session_id) === sessionId);
+      }
+      if (specId) {
+        rows = rows.filter((item) => normalizeString(item.spec_id) === specId);
+      }
+      if (verdict) {
+        rows = rows.filter((item) => normalizeString(item.verdict) === verdict);
+      }
+      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._mapSemanticEvaluationRunRow({
+        ...row,
+        candidate_payload_json: JSON.stringify(row.candidate_payload || {}),
+        observation_ids_json: JSON.stringify(row.observation_ids || []),
+        replay_summary_json: JSON.stringify(row.replay_summary || {}),
+        regression_reasons_json: JSON.stringify(row.regression_reasons || []),
+        evidence_json: JSON.stringify(row.evidence || {}),
+        governance_json: JSON.stringify(row.governance || {})
+      }));
+    }
+
+    if (!await this.ensureReady()) {
+      return null;
+    }
+
+    let query = `
+      SELECT evaluation_run_id, project_id, channel_id, session_id, scene_id, spec_id, lesson_id,
+             source_runtime, release_gate, baseline_evaluation_run_id, candidate_kind, candidate_label,
+             candidate_payload_json, observation_ids_json, replay_summary_json, score, threshold, verdict,
+             regression_detected, drift_level, regression_reasons_json, evidence_json, governance_json,
+             created_at, updated_at
+      FROM semantic_evaluation_run_registry
+    `;
+    const params = [];
+    const filters = [];
+    if (projectId) {
+      filters.push('project_id = ?');
+      params.push(projectId);
+    }
+    if (sessionId) {
+      filters.push('session_id = ?');
+      params.push(sessionId);
+    }
+    if (specId) {
+      filters.push('spec_id = ?');
+      params.push(specId);
+    }
+    if (verdict) {
+      filters.push('verdict = ?');
+      params.push(verdict);
+    }
+    if (filters.length > 0) {
+      query += ` WHERE ${filters.join(' AND ')}`;
+    }
+    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._mapSemanticEvaluationRunRow(row)).filter(Boolean);
+  }
+
+  async upsertSemanticCapabilityLedger(record = {}) {
+    const capabilityId = normalizeString(record.capability_id || record.capabilityId);
+    if (!capabilityId) {
+      return null;
+    }
+
+    const nowIso = this.now();
+    const metrics = record.metrics && typeof record.metrics === 'object' ? record.metrics : {};
+    const lineage = record.lineage && typeof record.lineage === 'object' ? record.lineage : {};
+    const publication = record.publication && typeof record.publication === 'object' ? record.publication : {};
+    const rankScoreValue = Number(record.rank_score ?? record.rankScore ?? metrics.rank_score);
+
+    const normalized = {
+      capability_id: capabilityId,
+      lesson_id: normalizeString(record.lesson_id || record.lessonId) || null,
+      evaluation_run_id: normalizeString(record.evaluation_run_id || record.evaluationRunId) || null,
+      project_id: normalizeString(record.project_id || record.projectId) || null,
+      channel_id: normalizeString(record.channel_id || record.channelId) || null,
+      session_id: normalizeString(record.session_id || record.sessionId) || null,
+      scene_id: normalizeString(record.scene_id || record.sceneId) || null,
+      spec_id: normalizeString(record.spec_id || record.specId) || null,
+      target_library: normalizeString(record.target_library || record.targetLibrary) || null,
+      capability_status: normalizeString(record.capability_status || record.capabilityStatus) || 'candidate',
+      publish_state: normalizeString(record.publish_state || record.publishState || publication.publish_state) || 'pending',
+      activation_count: normalizeNonNegativeInteger(
+        record.activation_count ?? record.activationCount ?? metrics.activation_count,
+        0
+      ),
+      activation_success_count: normalizeNonNegativeInteger(
+        record.activation_success_count ?? record.activationSuccessCount ?? metrics.activation_success_count,
+        0
+      ),
+      activation_mixed_count: normalizeNonNegativeInteger(
+        record.activation_mixed_count ?? record.activationMixedCount ?? metrics.activation_mixed_count,
+        0
+      ),
+      activation_negative_count: normalizeNonNegativeInteger(
+        record.activation_negative_count ?? record.activationNegativeCount ?? metrics.activation_negative_count,
+        0
+      ),
+      quarantine_count: normalizeNonNegativeInteger(
+        record.quarantine_count ?? record.quarantineCount ?? metrics.quarantine_count,
+        0
+      ),
+      last_activated_at: normalizeIsoTimestamp(record.last_activated_at || record.lastActivatedAt, '') || null,
+      last_quality_signal: normalizeString(record.last_quality_signal || record.lastQualitySignal || metrics.last_quality_signal) || null,
+      last_runtime: normalizeString(record.last_runtime || record.lastRuntime || metrics.last_runtime) || null,
+      rank_score: Number.isFinite(rankScoreValue) ? Number(rankScoreValue.toFixed(2)) : null,
+      lineage,
+      publication,
+      metrics,
+      created_at: normalizeIsoTimestamp(record.created_at || record.createdAt, nowIso) || nowIso,
+      updated_at: normalizeIsoTimestamp(record.updated_at || record.updatedAt, nowIso) || nowIso
+    };
+
+    if (this._useMemoryBackend()) {
+      this._memory.semantic_capability_ledgers[normalized.capability_id] = { ...normalized };
+      return this._mapSemanticCapabilityLedgerRow({
+        ...normalized,
+        lineage_json: JSON.stringify(normalized.lineage || {}),
+        publication_json: JSON.stringify(normalized.publication || {}),
+        metrics_json: JSON.stringify(normalized.metrics || {})
+      });
+    }
+
+    if (!await this.ensureReady()) {
+      return null;
+    }
+
+    this._db
+      .prepare(`
+        INSERT OR REPLACE INTO semantic_capability_ledger_registry(
+          capability_id, lesson_id, evaluation_run_id, project_id, channel_id, session_id, scene_id, spec_id,
+          target_library, capability_status, publish_state, activation_count, activation_success_count,
+          activation_mixed_count, activation_negative_count, quarantine_count, last_activated_at,
+          last_quality_signal, last_runtime, rank_score, lineage_json, publication_json, metrics_json,
+          created_at, updated_at
+        )
+        VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `)
+      .run(
+        normalized.capability_id,
+        normalized.lesson_id,
+        normalized.evaluation_run_id,
+        normalized.project_id,
+        normalized.channel_id,
+        normalized.session_id,
+        normalized.scene_id,
+        normalized.spec_id,
+        normalized.target_library,
+        normalized.capability_status,
+        normalized.publish_state,
+        normalized.activation_count,
+        normalized.activation_success_count,
+        normalized.activation_mixed_count,
+        normalized.activation_negative_count,
+        normalized.quarantine_count,
+        normalized.last_activated_at,
+        normalized.last_quality_signal,
+        normalized.last_runtime,
+        normalized.rank_score,
+        JSON.stringify(normalized.lineage || {}),
+        JSON.stringify(normalized.publication || {}),
+        JSON.stringify(normalized.metrics || {}),
+        normalized.created_at,
+        normalized.updated_at
+      );
+
+    return this.getSemanticCapabilityLedger(normalized.capability_id);
+  }
+
+  async getSemanticCapabilityLedger(capabilityId) {
+    const normalizedCapabilityId = normalizeString(capabilityId);
+    if (!normalizedCapabilityId) {
+      return null;
+    }
+
+    if (this._useMemoryBackend()) {
+      const row = this._memory.semantic_capability_ledgers[normalizedCapabilityId];
+      if (!row) {
+        return null;
+      }
+      return this._mapSemanticCapabilityLedgerRow({
+        ...row,
+        lineage_json: JSON.stringify(row.lineage || {}),
+        publication_json: JSON.stringify(row.publication || {}),
+        metrics_json: JSON.stringify(row.metrics || {})
+      });
+    }
+
+    if (!await this.ensureReady()) {
+      return null;
+    }
+
+    const row = this._db
+      .prepare(`
+        SELECT capability_id, lesson_id, evaluation_run_id, project_id, channel_id, session_id, scene_id, spec_id,
+               target_library, capability_status, publish_state, activation_count, activation_success_count,
+               activation_mixed_count, activation_negative_count, quarantine_count, last_activated_at,
+               last_quality_signal, last_runtime, rank_score, lineage_json, publication_json, metrics_json,
+               created_at, updated_at
+        FROM semantic_capability_ledger_registry
+        WHERE capability_id = ?
+      `)
+      .get(normalizedCapabilityId);
+    return this._mapSemanticCapabilityLedgerRow(row);
+  }
+
+  async listSemanticCapabilityLedgers(options = {}) {
+    const limit = normalizeInteger(options.limit, 20);
+    const projectId = normalizeString(options.project_id || options.projectId);
+    const lessonId = normalizeString(options.lesson_id || options.lessonId);
+    const sceneId = normalizeString(options.scene_id || options.sceneId);
+    const specId = normalizeString(options.spec_id || options.specId);
+    const targetLibrary = normalizeString(options.target_library || options.targetLibrary);
+    const capabilityStatus = normalizeString(options.capability_status || options.capabilityStatus);
+    const publishState = normalizeString(options.publish_state || options.publishState);
+
+    if (this._useMemoryBackend()) {
+      let rows = Object.values(this._memory.semantic_capability_ledgers || {}).map((item) => ({ ...item }));
+      if (projectId) {
+        rows = rows.filter((item) => normalizeString(item.project_id) === projectId);
+      }
+      if (lessonId) {
+        rows = rows.filter((item) => normalizeString(item.lesson_id) === lessonId);
+      }
+      if (sceneId) {
+        rows = rows.filter((item) => normalizeString(item.scene_id) === sceneId);
+      }
+      if (specId) {
+        rows = rows.filter((item) => normalizeString(item.spec_id) === specId);
+      }
+      if (targetLibrary) {
+        rows = rows.filter((item) => normalizeString(item.target_library) === targetLibrary);
+      }
+      if (capabilityStatus) {
+        rows = rows.filter((item) => normalizeString(item.capability_status) === capabilityStatus);
+      }
+      if (publishState) {
+        rows = rows.filter((item) => normalizeString(item.publish_state) === publishState);
+      }
+      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._mapSemanticCapabilityLedgerRow({
+        ...row,
+        lineage_json: JSON.stringify(row.lineage || {}),
+        publication_json: JSON.stringify(row.publication || {}),
+        metrics_json: JSON.stringify(row.metrics || {})
+      }));
+    }
+
+    if (!await this.ensureReady()) {
+      return null;
+    }
+
+    let query = `
+      SELECT capability_id, lesson_id, evaluation_run_id, project_id, channel_id, session_id, scene_id, spec_id,
+             target_library, capability_status, publish_state, activation_count, activation_success_count,
+             activation_mixed_count, activation_negative_count, quarantine_count, last_activated_at,
+             last_quality_signal, last_runtime, rank_score, lineage_json, publication_json, metrics_json,
+             created_at, updated_at
+      FROM semantic_capability_ledger_registry
+    `;
+    const params = [];
+    const filters = [];
+    if (projectId) {
+      filters.push('project_id = ?');
+      params.push(projectId);
+    }
+    if (lessonId) {
+      filters.push('lesson_id = ?');
+      params.push(lessonId);
+    }
+    if (sceneId) {
+      filters.push('scene_id = ?');
+      params.push(sceneId);
+    }
+    if (specId) {
+      filters.push('spec_id = ?');
+      params.push(specId);
+    }
+    if (targetLibrary) {
+      filters.push('target_library = ?');
+      params.push(targetLibrary);
+    }
+    if (capabilityStatus) {
+      filters.push('capability_status = ?');
+      params.push(capabilityStatus);
+    }
+    if (publishState) {
+      filters.push('publish_state = ?');
+      params.push(publishState);
+    }
+    if (filters.length > 0) {
+      query += ` WHERE ${filters.join(' AND ')}`;
+    }
+    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._mapSemanticCapabilityLedgerRow(row)).filter(Boolean);
+  }
+
   async appendStateMigrationRecord(record = {}) {
     const componentId = normalizeString(record.component_id || record.componentId);
     if (!componentId) {