scene-capability-engine 3.6.4 → 3.6.5

package/CHANGELOG.md

@@ -7,6 +7,30 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [3.6.5] - 2026-03-05
+
+### Added
+- Stage-2 SQLite migration components for Errorbook indexes:
+  - `errorbook.entry-index` (`.sce/errorbook/index.json`)
+  - `errorbook.incident-index` (`.sce/errorbook/staging/index.json`)
+- Stage-3 SQLite migration components for spec governance indexes:
+  - `governance.spec-scene-overrides` (`.sce/spec-governance/spec-scene-overrides.json`)
+  - `governance.scene-index` (`.sce/spec-governance/scene-index.json`)
+- New SQLite index tables in state store:
+  - `errorbook_entry_index_registry`
+  - `errorbook_incident_index_registry`
+  - `governance_spec_scene_override_registry`
+  - `governance_scene_index_registry`
+- New `SceStateStore` APIs:
+  - `upsert/listErrorbookEntryIndexRecords`
+  - `upsert/listErrorbookIncidentIndexRecords`
+  - `upsert/listGovernanceSpecSceneOverrideRecords`
+  - `upsert/listGovernanceSceneIndexRecords`
+
+### Changed
+- `sce state plan/doctor/migrate/export` now include spec-governance index components in migration scope and parity summaries.
+- State export payload now includes spec-governance index tables for audit/debug snapshots.
+
 ## [3.6.4] - 2026-03-05
 
 ### Added

package/README.md

@@ -153,6 +153,7 @@ Studio task-stream output contract (default):
   - reconciliation gate: `npm run gate:state-migration-reconciliation`
   - runtime reads now prefer sqlite indexes for timeline/scene-session views when indexed data exists
   - `state doctor` now emits `summary` and runtime diagnostics (`runtime.timeline`, `runtime.scene_session`) with read-source and consistency status
+  - migratable components now include errorbook + spec-governance indexes (`errorbook.entry-index`, `errorbook.incident-index`, `governance.spec-scene-overrides`, `governance.scene-index`) in addition to runtime registries
 - Write authorization lease model (SQLite-backed):
   - policy file: `.sce/config/authorization-policy.json`
   - grant lease: `sce auth grant --scope studio:* --reason "<reason>" --auth-password <password> --json`

package/README.zh.md

@@ -153,6 +153,7 @@ Studio 任务流输出契约（默认）：
   - 对账门禁：`npm run gate:state-migration-reconciliation`
   - 运行时读取在存在索引数据时优先使用 SQLite（timeline/scene-session 视图）
   - `state doctor` 新增 `summary` 与运行时诊断（`runtime.timeline`、`runtime.scene_session`），可直接读取读源与一致性状态
+  - 可迁移组件扩展到 errorbook + spec-governance 索引（`errorbook.entry-index`、`errorbook.incident-index`、`governance.spec-scene-overrides`、`governance.scene-index`）
 - 写入授权租约模型（SQLite 持久化）：
   - 策略文件：`.sce/config/authorization-policy.json`
   - 申请租约：`sce auth grant --scope studio:* --reason "<原因>" --auth-password <密码> --json`

package/docs/command-reference.md

@@ -734,11 +734,19 @@ Current migratable components:
 - `collab.agent-registry` (`.sce/config/agent-registry.json`)
 - `runtime.timeline-index` (`.sce/timeline/index.json`)
 - `runtime.scene-session-index` (`.sce/session-governance/scene-index.json`)
+- `errorbook.entry-index` (`.sce/errorbook/index.json`)
+- `errorbook.incident-index` (`.sce/errorbook/staging/index.json`)
+- `governance.spec-scene-overrides` (`.sce/spec-governance/spec-scene-overrides.json`)
+- `governance.scene-index` (`.sce/spec-governance/scene-index.json`)
 
 SQLite index tables introduced for gradual migration:
 - `agent_runtime_registry`
 - `timeline_snapshot_registry`
 - `scene_session_cycle_registry`
+- `errorbook_entry_index_registry`
+- `errorbook_incident_index_registry`
+- `governance_spec_scene_override_registry`
+- `governance_scene_index_registry`
 - `state_migration_registry`
 
 Runtime read preference:

package/lib/gitignore/gitignore-detector.js

@@ -43,7 +43,8 @@ class GitignoreDetector {
       '.sce/environments.json',
       '.sce/backups/',
       '.sce/logs/',
-      '.sce/reports/'
+      '.sce/reports/',
+      '.sce/state/'
     ];
   }
 

package/lib/gitignore/layered-rules-template.js

@@ -25,6 +25,7 @@ const LAYERED_RULES_TEMPLATE = `# ========================================
 .sce/backups/
 .sce/logs/
 .sce/reports/
+.sce/state/
 
 # Spec artifacts (COMMIT - but exclude temporary files)
 .sce/specs/**/SESSION-*.md

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,10 @@ class SceStateStore {
       timeline_snapshots: {},
       scene_session_cycles: {},
       agent_runtime: {},
+      errorbook_entry_index: {},
+      errorbook_incident_index: {},
+      governance_spec_scene_override: {},
+      governance_scene_index: {},
       migration_records: {},
       auth_leases: {},
       auth_events: [],
@@ -317,6 +338,75 @@ 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);
     `);
   }
 
@@ -511,6 +601,83 @@ 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
+    };
+  }
+
   async resolveOrCreateTaskRef(options = {}) {
     const sceneId = normalizeString(options.sceneId);
     const specId = normalizeString(options.specId);
@@ -1514,6 +1681,490 @@ 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);
+  }
+
   _resolveOrCreateTaskRefInMemory(options = {}) {
     const sceneId = normalizeString(options.sceneId);
     const specId = normalizeString(options.specId);

package/lib/state/state-migration-manager.js

@@ -7,6 +7,10 @@ const { SessionStore } = require('../runtime/session-store');
 const COMPONENT_AGENT_REGISTRY = 'collab.agent-registry';
 const COMPONENT_TIMELINE_INDEX = 'runtime.timeline-index';
 const COMPONENT_SCENE_SESSION_INDEX = 'runtime.scene-session-index';
+const COMPONENT_ERRORBOOK_ENTRY_INDEX = 'errorbook.entry-index';
+const COMPONENT_ERRORBOOK_INCIDENT_INDEX = 'errorbook.incident-index';
+const COMPONENT_SPEC_SCENE_OVERRIDES = 'governance.spec-scene-overrides';
+const COMPONENT_SPEC_SCENE_INDEX = 'governance.scene-index';
 const DEFAULT_STATE_EXPORT_PATH = '.sce/reports/state-migration/state-export.latest.json';
 
 const COMPONENT_DEFINITIONS = Object.freeze([
@@ -21,6 +25,22 @@ const COMPONENT_DEFINITIONS = Object.freeze([
   {
     id: COMPONENT_SCENE_SESSION_INDEX,
     source_path: '.sce/session-governance/scene-index.json'
+  },
+  {
+    id: COMPONENT_ERRORBOOK_ENTRY_INDEX,
+    source_path: '.sce/errorbook/index.json'
+  },
+  {
+    id: COMPONENT_ERRORBOOK_INCIDENT_INDEX,
+    source_path: '.sce/errorbook/staging/index.json'
+  },
+  {
+    id: COMPONENT_SPEC_SCENE_OVERRIDES,
+    source_path: '.sce/spec-governance/spec-scene-overrides.json'
+  },
+  {
+    id: COMPONENT_SPEC_SCENE_INDEX,
+    source_path: '.sce/spec-governance/scene-index.json'
   }
 ]);
 
@@ -159,6 +179,107 @@ function mapSceneSessionIndexPayload(payload = {}) {
   return records;
 }
 
+function mapErrorbookEntryIndexPayload(payload = {}) {
+  if (!payload || typeof payload !== 'object' || !Array.isArray(payload.entries)) {
+    return [];
+  }
+  return payload.entries
+    .map((item) => ({
+      entry_id: normalizeString(item && (item.id || item.entry_id)),
+      fingerprint: normalizeString(item && item.fingerprint),
+      title: normalizeString(item && item.title),
+      status: normalizeString(item && item.status),
+      quality_score: normalizeInteger(item && item.quality_score, 0),
+      tags: Array.isArray(item && item.tags)
+        ? item.tags.map((token) => normalizeString(token)).filter(Boolean)
+        : [],
+      ontology_tags: Array.isArray(item && item.ontology_tags)
+        ? item.ontology_tags.map((token) => normalizeString(token)).filter(Boolean)
+        : [],
+      temporary_mitigation_active: item && item.temporary_mitigation_active === true,
+      temporary_mitigation_deadline_at: normalizeString(item && item.temporary_mitigation_deadline_at),
+      occurrences: normalizeInteger(item && item.occurrences, 0),
+      created_at: normalizeString(item && item.created_at),
+      updated_at: normalizeString(item && item.updated_at)
+    }))
+    .filter((item) => item.entry_id);
+}
+
+function mapErrorbookIncidentIndexPayload(payload = {}) {
+  if (!payload || typeof payload !== 'object' || !Array.isArray(payload.incidents)) {
+    return [];
+  }
+  return payload.incidents
+    .map((item) => ({
+      incident_id: normalizeString(item && (item.id || item.incident_id)),
+      fingerprint: normalizeString(item && item.fingerprint),
+      title: normalizeString(item && item.title),
+      symptom: normalizeString(item && item.symptom),
+      state: normalizeString(item && item.state),
+      attempt_count: normalizeInteger(item && item.attempt_count, 0),
+      created_at: normalizeString(item && item.created_at),
+      updated_at: normalizeString(item && item.updated_at),
+      last_attempt_at: normalizeString(item && item.last_attempt_at),
+      resolved_at: normalizeString(item && item.resolved_at),
+      linked_entry_id: normalizeString(item && item.linked_entry_id)
+    }))
+    .filter((item) => item.incident_id);
+}
+
+function mapSpecSceneOverridesPayload(payload = {}) {
+  if (!payload || typeof payload !== 'object' || !payload.mappings || typeof payload.mappings !== 'object') {
+    return [];
+  }
+  return Object.entries(payload.mappings)
+    .map(([specId, mapping]) => {
+      if (typeof mapping === 'string') {
+        return {
+          spec_id: normalizeString(specId),
+          scene_id: normalizeString(mapping),
+          source: 'override',
+          rule_id: '',
+          updated_at: normalizeString(payload && payload.updated_at)
+        };
+      }
+      return {
+        spec_id: normalizeString(specId),
+        scene_id: normalizeString(mapping && mapping.scene_id),
+        source: normalizeString(mapping && mapping.source) || 'override',
+        rule_id: normalizeString(mapping && mapping.rule_id),
+        updated_at: normalizeString(mapping && mapping.updated_at) || normalizeString(payload && payload.updated_at)
+      };
+    })
+    .filter((item) => item.spec_id && item.scene_id);
+}
+
+function mapSpecSceneIndexPayload(payload = {}) {
+  if (!payload || typeof payload !== 'object' || !payload.scenes || typeof payload.scenes !== 'object') {
+    return [];
+  }
+  const generatedAt = normalizeString(payload.generated_at) || normalizeString(payload.updated_at);
+  const sceneFilter = normalizeString(payload.scene_filter);
+  return Object.entries(payload.scenes)
+    .map(([sceneId, scene]) => ({
+      scene_id: normalizeString(sceneId),
+      total_specs: normalizeInteger(scene && scene.total_specs, 0),
+      active_specs: normalizeInteger(scene && scene.active_specs, 0),
+      completed_specs: normalizeInteger(scene && scene.completed_specs, 0),
+      stale_specs: normalizeInteger(scene && scene.stale_specs, 0),
+      spec_ids: Array.isArray(scene && scene.spec_ids)
+        ? scene.spec_ids.map((token) => normalizeString(token)).filter(Boolean)
+        : [],
+      active_spec_ids: Array.isArray(scene && scene.active_spec_ids)
+        ? scene.active_spec_ids.map((token) => normalizeString(token)).filter(Boolean)
+        : [],
+      stale_spec_ids: Array.isArray(scene && scene.stale_spec_ids)
+        ? scene.stale_spec_ids.map((token) => normalizeString(token)).filter(Boolean)
+        : [],
+      generated_at: generatedAt,
+      scene_filter: sceneFilter
+    }))
+    .filter((item) => item.scene_id);
+}
+
 async function readJsonSource(absolutePath, fileSystem = fs) {
   if (!await fileSystem.pathExists(absolutePath)) {
     return {
@@ -196,6 +317,14 @@ async function readComponentSnapshot(component = {}, projectPath = process.cwd()
       records = mapTimelineIndexPayload(source.payload);
     } else if (component.id === COMPONENT_SCENE_SESSION_INDEX) {
       records = mapSceneSessionIndexPayload(source.payload);
+    } else if (component.id === COMPONENT_ERRORBOOK_ENTRY_INDEX) {
+      records = mapErrorbookEntryIndexPayload(source.payload);
+    } else if (component.id === COMPONENT_ERRORBOOK_INCIDENT_INDEX) {
+      records = mapErrorbookIncidentIndexPayload(source.payload);
+    } else if (component.id === COMPONENT_SPEC_SCENE_OVERRIDES) {
+      records = mapSpecSceneOverridesPayload(source.payload);
+    } else if (component.id === COMPONENT_SPEC_SCENE_INDEX) {
+      records = mapSpecSceneIndexPayload(source.payload);
     }
   }
 
@@ -285,6 +414,26 @@ async function writeComponentToStateStore(componentSnapshot = {}, stateStore, co
       source: componentId
     });
   }
+  if (componentId === COMPONENT_ERRORBOOK_ENTRY_INDEX) {
+    return stateStore.upsertErrorbookEntryIndexRecords(componentSnapshot.records, {
+      source: componentId
+    });
+  }
+  if (componentId === COMPONENT_ERRORBOOK_INCIDENT_INDEX) {
+    return stateStore.upsertErrorbookIncidentIndexRecords(componentSnapshot.records, {
+      source: componentId
+    });
+  }
+  if (componentId === COMPONENT_SPEC_SCENE_OVERRIDES) {
+    return stateStore.upsertGovernanceSpecSceneOverrideRecords(componentSnapshot.records, {
+      source: componentId
+    });
+  }
+  if (componentId === COMPONENT_SPEC_SCENE_INDEX) {
+    return stateStore.upsertGovernanceSceneIndexRecords(componentSnapshot.records, {
+      source: componentId
+    });
+  }
   return null;
 }
 
@@ -404,17 +553,34 @@ async function runStateDoctor(options = {}, dependencies = {}) {
   const stateStore = dependencies.stateStore || getSceStateStore(projectPath, { fileSystem, env });
   const plan = await buildStateMigrationPlan({}, { projectPath, fileSystem, env, stateStore });
 
-  const [agentRows, timelineRows, sessionRows, migrations] = await Promise.all([
+  const [
+    agentRows,
+    timelineRows,
+    sessionRows,
+    errorbookEntryRows,
+    errorbookIncidentRows,
+    governanceOverrideRows,
+    governanceSceneRows,
+    migrations
+  ] = await Promise.all([
     stateStore.listAgentRuntimeRecords({ limit: 0 }),
     stateStore.listTimelineSnapshotIndex({ limit: 0 }),
     stateStore.listSceneSessionCycles({ limit: 0 }),
+    stateStore.listErrorbookEntryIndexRecords({ limit: 0 }),
+    stateStore.listErrorbookIncidentIndexRecords({ limit: 0 }),
+    stateStore.listGovernanceSpecSceneOverrideRecords({ limit: 0 }),
+    stateStore.listGovernanceSceneIndexRecords({ limit: 0 }),
     stateStore.listStateMigrations({ limit: 20 })
   ]);
 
   const targetCounts = new Map([
     [COMPONENT_AGENT_REGISTRY, Array.isArray(agentRows) ? agentRows.length : 0],
     [COMPONENT_TIMELINE_INDEX, Array.isArray(timelineRows) ? timelineRows.length : 0],
-    [COMPONENT_SCENE_SESSION_INDEX, Array.isArray(sessionRows) ? sessionRows.length : 0]
+    [COMPONENT_SCENE_SESSION_INDEX, Array.isArray(sessionRows) ? sessionRows.length : 0],
+    [COMPONENT_ERRORBOOK_ENTRY_INDEX, Array.isArray(errorbookEntryRows) ? errorbookEntryRows.length : 0],
+    [COMPONENT_ERRORBOOK_INCIDENT_INDEX, Array.isArray(errorbookIncidentRows) ? errorbookIncidentRows.length : 0],
+    [COMPONENT_SPEC_SCENE_OVERRIDES, Array.isArray(governanceOverrideRows) ? governanceOverrideRows.length : 0],
+    [COMPONENT_SPEC_SCENE_INDEX, Array.isArray(governanceSceneRows) ? governanceSceneRows.length : 0]
   ]);
 
   const checks = plan.components.map((component) => {
@@ -614,10 +780,23 @@ async function runStateExport(options = {}, dependencies = {}) {
     : path.join(projectPath, outPathRaw);
   const stateStore = dependencies.stateStore || getSceStateStore(projectPath, { fileSystem, env });
 
-  const [agentRows, timelineRows, sessionRows, migrations] = await Promise.all([
+  const [
+    agentRows,
+    timelineRows,
+    sessionRows,
+    errorbookEntryRows,
+    errorbookIncidentRows,
+    governanceOverrideRows,
+    governanceSceneRows,
+    migrations
+  ] = await Promise.all([
     stateStore.listAgentRuntimeRecords({ limit: 0 }),
     stateStore.listTimelineSnapshotIndex({ limit: 0 }),
     stateStore.listSceneSessionCycles({ limit: 0 }),
+    stateStore.listErrorbookEntryIndexRecords({ limit: 0 }),
+    stateStore.listErrorbookIncidentIndexRecords({ limit: 0 }),
+    stateStore.listGovernanceSpecSceneOverrideRecords({ limit: 0 }),
+    stateStore.listGovernanceSceneIndexRecords({ limit: 0 }),
     stateStore.listStateMigrations({ limit: 0 })
   ]);
 
@@ -630,12 +809,20 @@ async function runStateExport(options = {}, dependencies = {}) {
       agent_runtime_registry: Array.isArray(agentRows) ? agentRows : [],
       timeline_snapshot_registry: Array.isArray(timelineRows) ? timelineRows : [],
       scene_session_cycle_registry: Array.isArray(sessionRows) ? sessionRows : [],
+      errorbook_entry_index_registry: Array.isArray(errorbookEntryRows) ? errorbookEntryRows : [],
+      errorbook_incident_index_registry: Array.isArray(errorbookIncidentRows) ? errorbookIncidentRows : [],
+      governance_spec_scene_override_registry: Array.isArray(governanceOverrideRows) ? governanceOverrideRows : [],
+      governance_scene_index_registry: Array.isArray(governanceSceneRows) ? governanceSceneRows : [],
       state_migration_registry: Array.isArray(migrations) ? migrations : []
     },
     summary: {
       agent_runtime_registry: Array.isArray(agentRows) ? agentRows.length : 0,
       timeline_snapshot_registry: Array.isArray(timelineRows) ? timelineRows.length : 0,
       scene_session_cycle_registry: Array.isArray(sessionRows) ? sessionRows.length : 0,
+      errorbook_entry_index_registry: Array.isArray(errorbookEntryRows) ? errorbookEntryRows.length : 0,
+      errorbook_incident_index_registry: Array.isArray(errorbookIncidentRows) ? errorbookIncidentRows.length : 0,
+      governance_spec_scene_override_registry: Array.isArray(governanceOverrideRows) ? governanceOverrideRows.length : 0,
+      governance_scene_index_registry: Array.isArray(governanceSceneRows) ? governanceSceneRows.length : 0,
       state_migration_registry: Array.isArray(migrations) ? migrations.length : 0
     },
     out_file: path.relative(projectPath, outPath).replace(/\\/g, '/')
@@ -650,6 +837,10 @@ module.exports = {
   COMPONENT_AGENT_REGISTRY,
   COMPONENT_TIMELINE_INDEX,
   COMPONENT_SCENE_SESSION_INDEX,
+  COMPONENT_ERRORBOOK_ENTRY_INDEX,
+  COMPONENT_ERRORBOOK_INCIDENT_INDEX,
+  COMPONENT_SPEC_SCENE_OVERRIDES,
+  COMPONENT_SPEC_SCENE_INDEX,
   COMPONENT_DEFINITIONS,
   DEFAULT_STATE_EXPORT_PATH,
   buildStateMigrationPlan,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scene-capability-engine",
-  "version": "3.6.4",
+  "version": "3.6.5",
   "description": "SCE (Scene Capability Engine) - A CLI tool and npm package for spec-driven development with AI coding assistants.",
   "main": "index.js",
   "bin": {