scene-capability-engine 3.6.5 → 3.6.8

package/CHANGELOG.md

@@ -7,6 +7,44 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [3.6.8] - 2026-03-05
+
+### Added
+- New one-shot state command:
+  - `sce state reconcile --all --apply --json`
+  - runs `doctor -> migrate -> doctor` with before/after drift summary in one payload
+- Release workflow now runs state reconcile before reconciliation gate and uploads:
+  - `state-reconcile-<tag>.json`
+
+### Changed
+- Release workflow state reconciliation gate is now enforce-by-default (`KSE_RELEASE_STATE_MIGRATION_ENFORCE` defaults to `true`).
+- Release workflow Node runtime updated to `22.x` so sqlite-backed reconciliation can run in release pipeline.
+
+## [3.6.7] - 2026-03-05
+
+### Fixed
+- `state-migration-reconciliation-gate` now treats `blocking` checks as advisory by default and only fails when `--fail-on-blocking` is explicitly set.
+- Release workflow reconciliation step now adds `--fail-on-blocking` only in enforce mode, preventing advisory mode from failing npm publish.
+
+## [3.6.6] - 2026-03-05
+
+### Added
+- Stage-4 SQLite migration components for release evidence indexes:
+  - `release.evidence-runs-index` (`.sce/reports/release-evidence/handoff-runs.json`)
+  - `release.gate-history-index` (`.sce/reports/release-evidence/release-gate-history.json`)
+- New SQLite index tables in state store:
+  - `release_evidence_run_registry`
+  - `release_gate_history_registry`
+- New `SceStateStore` APIs:
+  - `upsert/listReleaseEvidenceRunRecords`
+  - `upsert/listReleaseGateHistoryRecords`
+- Release workflow gate integration:
+  - new step `state_migration_reconciliation`
+  - new release asset `.sce/reports/release-evidence/state-migration-reconciliation-<tag>.json`
+
+### Changed
+- `sce state plan/doctor/migrate/export` now includes release-evidence components in migration scope and parity summaries.
+
 ## [3.6.5] - 2026-03-05
 
 ### Added

package/README.md

@@ -149,11 +149,13 @@ Studio task-stream output contract (default):
   - `sce state plan --json`
   - `sce state doctor --json`
   - `sce state migrate --all --apply --json`
+  - `sce state reconcile --all --apply --json` (doctor -> migrate -> doctor one-shot)
   - `sce state export --out .sce/reports/state-migration/state-export.latest.json --json`
   - reconciliation gate: `npm run gate:state-migration-reconciliation`
+  - release workflow defaults to enforce mode for state reconciliation gate and runs reconcile before publish
   - 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
+  - migratable components now include runtime + errorbook + spec-governance + release evidence indexes (`errorbook.entry-index`, `errorbook.incident-index`, `governance.spec-scene-overrides`, `governance.scene-index`, `release.evidence-runs-index`, `release.gate-history-index`)
 - 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

@@ -149,11 +149,13 @@ Studio 任务流输出契约（默认）：
   - `sce state plan --json`
   - `sce state doctor --json`
   - `sce state migrate --all --apply --json`
+  - `sce state reconcile --all --apply --json`（一键执行 doctor -> migrate -> doctor）
   - `sce state export --out .sce/reports/state-migration/state-export.latest.json --json`
   - 对账门禁：`npm run gate:state-migration-reconciliation`
+  - 发布工作流默认对 state reconciliation 启用 enforce，并在发布前执行 reconcile
   - 运行时读取在存在索引数据时优先使用 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`）
+  - 可迁移组件扩展到 runtime + errorbook + spec-governance + release evidence 索引（`errorbook.entry-index`、`errorbook.incident-index`、`governance.spec-scene-overrides`、`governance.scene-index`、`release.evidence-runs-index`、`release.gate-history-index`）
 - 写入授权租约模型（SQLite 持久化）：
   - 策略文件：`.sce/config/authorization-policy.json`
   - 申请租约：`sce auth grant --scope studio:* --reason "<原因>" --auth-password <密码> --json`

package/docs/command-reference.md

@@ -719,6 +719,9 @@ sce state migrate --all --json
 # apply migration writes into sqlite index tables
 sce state migrate --all --apply --json
 
+# reconcile in one flow (doctor -> migrate -> doctor)
+sce state reconcile --all --apply --json
+
 # migrate specific components
 sce state migrate --component collab.agent-registry --component runtime.timeline-index --apply --json
 
@@ -727,7 +730,7 @@ sce state export --out .sce/reports/state-migration/state-export.latest.json --j
 
 # reconciliation gate (non-blocking by default; choose strict flags as needed)
 npm run gate:state-migration-reconciliation
-node scripts/state-migration-reconciliation-gate.js --fail-on-alert --fail-on-pending --json
+node scripts/state-migration-reconciliation-gate.js --fail-on-blocking --fail-on-alert --fail-on-pending --json
 ```
 
 Current migratable components:
@@ -738,6 +741,8 @@ Current migratable components:
 - `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`)
+- `release.evidence-runs-index` (`.sce/reports/release-evidence/handoff-runs.json`)
+- `release.gate-history-index` (`.sce/reports/release-evidence/release-gate-history.json`)
 
 SQLite index tables introduced for gradual migration:
 - `agent_runtime_registry`
@@ -747,11 +752,14 @@ SQLite index tables introduced for gradual migration:
 - `errorbook_incident_index_registry`
 - `governance_spec_scene_override_registry`
 - `governance_scene_index_registry`
+- `release_evidence_run_registry`
+- `release_gate_history_registry`
 - `state_migration_registry`
 
 Runtime read preference:
 - timeline/session runtime views now prefer SQLite indexes when indexed rows exist.
 - file artifacts remain source-of-truth for content payload and recovery operations.
+- release workflow runs `state reconcile --all --apply` before reconciliation gate.
 - `sce state doctor --json` now includes:
   - `summary` aggregate (`pending_components`, `total_record_drift`, `blocking_count`, `alert_count`)
   - runtime read diagnostics (`runtime.timeline`, `runtime.scene_session`) with read-source/read-preference and consistency status

package/lib/commands/state.js

@@ -8,6 +8,7 @@ const {
   runStateDoctor,
   runStateExport
 } = require('../state/state-migration-manager');
+const { getSceStateStore } = require('../state/sce-state-store');
 
 function normalizeString(value) {
   if (typeof value !== 'string') {
@@ -147,6 +148,85 @@ async function runStateExportCommand(options = {}, dependencies = {}) {
   return payload;
 }
 
+async function runStateReconcileCommand(options = {}, dependencies = {}) {
+  const projectPath = dependencies.projectPath || process.cwd();
+  const fileSystem = dependencies.fileSystem || fs;
+  const env = dependencies.env || process.env;
+  const components = normalizeComponentInput(options.component);
+  const componentIds = options.all === true ? [] : components;
+  const apply = options.apply === true;
+  const stateStore = dependencies.stateStore || getSceStateStore(projectPath, {
+    fileSystem,
+    env
+  });
+
+  const before = await runStateDoctor({}, {
+    projectPath,
+    fileSystem,
+    env,
+    stateStore
+  });
+
+  const migration = await runStateMigration({
+    apply,
+    all: options.all === true,
+    componentIds
+  }, {
+    projectPath,
+    fileSystem,
+    env,
+    stateStore
+  });
+
+  const after = await runStateDoctor({}, {
+    projectPath,
+    fileSystem,
+    env,
+    stateStore
+  });
+
+  const beforePending = Number(before && before.summary && before.summary.pending_components) || 0;
+  const afterPending = Number(after && after.summary && after.summary.pending_components) || 0;
+  const beforeBlocking = Number(before && before.summary && before.summary.blocking_count) || 0;
+  const afterBlocking = Number(after && after.summary && after.summary.blocking_count) || 0;
+  const pendingReduced = Math.max(0, beforePending - afterPending);
+  const blockingReduced = Math.max(0, beforeBlocking - afterBlocking);
+
+  const payload = {
+    mode: 'state-reconcile',
+    success: Boolean(migration && migration.success) && afterBlocking === 0,
+    apply,
+    generated_at: new Date().toISOString(),
+    store_path: after && after.store_path ? after.store_path : null,
+    sqlite: after && after.sqlite ? after.sqlite : null,
+    migration,
+    before: {
+      summary: before && before.summary ? before.summary : null,
+      blocking: Array.isArray(before && before.blocking) ? before.blocking : [],
+      alerts: Array.isArray(before && before.alerts) ? before.alerts : []
+    },
+    after: {
+      summary: after && after.summary ? after.summary : null,
+      blocking: Array.isArray(after && after.blocking) ? after.blocking : [],
+      alerts: Array.isArray(after && after.alerts) ? after.alerts : []
+    },
+    summary: {
+      apply,
+      migrated_components: Number(migration && migration.summary && migration.summary.migrated_components) || 0,
+      migrated_records: Number(migration && migration.summary && migration.summary.migrated_records) || 0,
+      before_pending_components: beforePending,
+      after_pending_components: afterPending,
+      pending_components_reduced: pendingReduced,
+      before_blocking_count: beforeBlocking,
+      after_blocking_count: afterBlocking,
+      blocking_reduced: blockingReduced
+    }
+  };
+
+  printPayload(payload, options, 'State Reconcile');
+  return payload;
+}
+
 async function safeRun(handler, options = {}, dependencies = {}, title = 'state command') {
   try {
     await handler(options, dependencies);
@@ -199,6 +279,15 @@ function registerStateCommands(program) {
     .option('--out <path>', 'Output file path', '.sce/reports/state-migration/state-export.latest.json')
     .option('--json', 'Print machine-readable JSON output')
     .action(async (options) => safeRun(runStateExportCommand, options, {}, 'state export'));
+
+  state
+    .command('reconcile')
+    .description('Run doctor + migrate + doctor in one flow (dry-run by default)')
+    .option('--component <id>', `Component id (repeatable): ${knownIds}`, collectOptionValue, [])
+    .option('--all', 'Reconcile all known components')
+    .option('--apply', 'Apply migration writes (default is dry-run)')
+    .option('--json', 'Print machine-readable JSON output')
+    .action(async (options) => safeRun(runStateReconcileCommand, options, {}, 'state reconcile'));
 }
 
 module.exports = {
@@ -206,5 +295,6 @@ module.exports = {
   runStateDoctorCommand,
   runStateMigrateCommand,
   runStateExportCommand,
+  runStateReconcileCommand,
   registerStateCommands
 };

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

@@ -137,6 +137,8 @@ class SceStateStore {
       errorbook_incident_index: {},
       governance_spec_scene_override: {},
       governance_scene_index: {},
+      release_evidence_run: {},
+      release_gate_history: {},
       migration_records: {},
       auth_leases: {},
       auth_events: [],
@@ -407,6 +409,54 @@ class SceStateStore {
 
       CREATE INDEX IF NOT EXISTS idx_governance_scene_index_registry_counts
         ON governance_scene_index_registry(total_specs DESC, active_specs DESC);
+
+      CREATE TABLE IF NOT EXISTS release_evidence_run_registry (
+        session_id TEXT PRIMARY KEY,
+        merged_at TEXT,
+        status TEXT,
+        gate_passed INTEGER,
+        spec_success_rate_percent REAL,
+        risk_level TEXT,
+        ontology_quality_score REAL,
+        capability_coverage_percent REAL,
+        capability_coverage_passed INTEGER,
+        scene_package_batch_passed INTEGER,
+        scene_package_batch_failure_count INTEGER,
+        failed_goals INTEGER,
+        release_gate_preflight_available INTEGER,
+        release_gate_preflight_blocked INTEGER,
+        source_updated_at TEXT,
+        source TEXT,
+        indexed_at TEXT NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_release_evidence_run_registry_status_merged
+        ON release_evidence_run_registry(status, merged_at DESC);
+
+      CREATE TABLE IF NOT EXISTS release_gate_history_registry (
+        tag TEXT PRIMARY KEY,
+        evaluated_at TEXT,
+        gate_passed INTEGER,
+        enforce INTEGER,
+        risk_level TEXT,
+        spec_success_rate_percent REAL,
+        scene_package_batch_passed INTEGER,
+        scene_package_batch_failure_count INTEGER,
+        capability_expected_unknown_count INTEGER,
+        capability_provided_unknown_count INTEGER,
+        release_gate_preflight_available INTEGER,
+        release_gate_preflight_blocked INTEGER,
+        require_release_gate_preflight INTEGER,
+        drift_alert_count INTEGER,
+        drift_blocked INTEGER,
+        weekly_ops_blocked INTEGER,
+        source_updated_at TEXT,
+        source TEXT,
+        indexed_at TEXT NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_release_gate_history_registry_eval
+        ON release_gate_history_registry(evaluated_at DESC);
     `);
   }
 
@@ -678,6 +728,66 @@ class SceStateStore {
     };
   }
 
+  _mapReleaseEvidenceRunRow(row) {
+    if (!row) {
+      return null;
+    }
+    return {
+      session_id: normalizeString(row.session_id),
+      merged_at: normalizeIsoTimestamp(row.merged_at, '') || null,
+      status: normalizeString(row.status) || null,
+      gate_passed: normalizeBooleanValue(row.gate_passed, false),
+      spec_success_rate_percent: Number.isFinite(Number(row.spec_success_rate_percent))
+        ? Number(row.spec_success_rate_percent)
+        : null,
+      risk_level: normalizeString(row.risk_level) || null,
+      ontology_quality_score: Number.isFinite(Number(row.ontology_quality_score))
+        ? Number(row.ontology_quality_score)
+        : null,
+      capability_coverage_percent: Number.isFinite(Number(row.capability_coverage_percent))
+        ? Number(row.capability_coverage_percent)
+        : null,
+      capability_coverage_passed: normalizeBooleanValue(row.capability_coverage_passed, false),
+      scene_package_batch_passed: normalizeBooleanValue(row.scene_package_batch_passed, false),
+      scene_package_batch_failure_count: normalizeNonNegativeInteger(row.scene_package_batch_failure_count, 0),
+      failed_goals: normalizeNonNegativeInteger(row.failed_goals, 0),
+      release_gate_preflight_available: normalizeBooleanValue(row.release_gate_preflight_available, false),
+      release_gate_preflight_blocked: normalizeBooleanValue(row.release_gate_preflight_blocked, false),
+      source_updated_at: normalizeIsoTimestamp(row.source_updated_at, '') || null,
+      source: normalizeString(row.source) || null,
+      indexed_at: normalizeIsoTimestamp(row.indexed_at, '') || null
+    };
+  }
+
+  _mapReleaseGateHistoryRow(row) {
+    if (!row) {
+      return null;
+    }
+    return {
+      tag: normalizeString(row.tag),
+      evaluated_at: normalizeIsoTimestamp(row.evaluated_at, '') || null,
+      gate_passed: normalizeBooleanValue(row.gate_passed, false),
+      enforce: normalizeBooleanValue(row.enforce, false),
+      risk_level: normalizeString(row.risk_level) || null,
+      spec_success_rate_percent: Number.isFinite(Number(row.spec_success_rate_percent))
+        ? Number(row.spec_success_rate_percent)
+        : null,
+      scene_package_batch_passed: normalizeBooleanValue(row.scene_package_batch_passed, false),
+      scene_package_batch_failure_count: normalizeNonNegativeInteger(row.scene_package_batch_failure_count, 0),
+      capability_expected_unknown_count: normalizeNonNegativeInteger(row.capability_expected_unknown_count, 0),
+      capability_provided_unknown_count: normalizeNonNegativeInteger(row.capability_provided_unknown_count, 0),
+      release_gate_preflight_available: normalizeBooleanValue(row.release_gate_preflight_available, false),
+      release_gate_preflight_blocked: normalizeBooleanValue(row.release_gate_preflight_blocked, false),
+      require_release_gate_preflight: normalizeBooleanValue(row.require_release_gate_preflight, false),
+      drift_alert_count: normalizeNonNegativeInteger(row.drift_alert_count, 0),
+      drift_blocked: normalizeBooleanValue(row.drift_blocked, false),
+      weekly_ops_blocked: normalizeBooleanValue(row.weekly_ops_blocked, false),
+      source_updated_at: normalizeIsoTimestamp(row.source_updated_at, '') || null,
+      source: normalizeString(row.source) || null,
+      indexed_at: normalizeIsoTimestamp(row.indexed_at, '') || null
+    };
+  }
+
   async resolveOrCreateTaskRef(options = {}) {
     const sceneId = normalizeString(options.sceneId);
     const specId = normalizeString(options.specId);
@@ -2165,6 +2275,322 @@ class SceStateStore {
       .filter(Boolean);
   }
 
+  async upsertReleaseEvidenceRunRecords(records = [], options = {}) {
+    const source = normalizeString(options.source) || 'file.release-evidence.handoff-runs';
+    const nowIso = this.now();
+    const normalizedRecords = Array.isArray(records)
+      ? records.map((item) => ({
+        session_id: normalizeString(item && item.session_id),
+        merged_at: normalizeIsoTimestamp(item && item.merged_at, '') || null,
+        status: normalizeString(item && item.status) || null,
+        gate_passed: normalizeBooleanValue(item && item.gate_passed, false),
+        spec_success_rate_percent: Number.isFinite(Number(item && item.spec_success_rate_percent))
+          ? Number(item.spec_success_rate_percent)
+          : null,
+        risk_level: normalizeString(item && item.risk_level) || null,
+        ontology_quality_score: Number.isFinite(Number(item && item.ontology_quality_score))
+          ? Number(item.ontology_quality_score)
+          : null,
+        capability_coverage_percent: Number.isFinite(Number(item && item.capability_coverage_percent))
+          ? Number(item.capability_coverage_percent)
+          : null,
+        capability_coverage_passed: normalizeBooleanValue(item && item.capability_coverage_passed, false),
+        scene_package_batch_passed: normalizeBooleanValue(item && item.scene_package_batch_passed, false),
+        scene_package_batch_failure_count: normalizeNonNegativeInteger(item && item.scene_package_batch_failure_count, 0),
+        failed_goals: normalizeNonNegativeInteger(item && item.failed_goals, 0),
+        release_gate_preflight_available: normalizeBooleanValue(item && item.release_gate_preflight_available, false),
+        release_gate_preflight_blocked: normalizeBooleanValue(item && item.release_gate_preflight_blocked, false),
+        source_updated_at: normalizeIsoTimestamp(item && item.source_updated_at, '') || null,
+        source: normalizeString(item && item.source) || source,
+        indexed_at: nowIso
+      }))
+        .filter((item) => item.session_id)
+      : [];
+
+    if (this._useMemoryBackend()) {
+      for (const item of normalizedRecords) {
+        this._memory.release_evidence_run[item.session_id] = { ...item };
+      }
+      return {
+        success: true,
+        written: normalizedRecords.length,
+        total: Object.keys(this._memory.release_evidence_run || {}).length
+      };
+    }
+
+    if (!await this.ensureReady()) {
+      return null;
+    }
+
+    const statement = this._db.prepare(`
+      INSERT OR REPLACE INTO release_evidence_run_registry(
+        session_id, merged_at, status, gate_passed, spec_success_rate_percent, risk_level,
+        ontology_quality_score, capability_coverage_percent, capability_coverage_passed,
+        scene_package_batch_passed, scene_package_batch_failure_count, failed_goals,
+        release_gate_preflight_available, release_gate_preflight_blocked,
+        source_updated_at, source, indexed_at
+      )
+      VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+
+    this._withTransaction(() => {
+      for (const item of normalizedRecords) {
+        statement.run(
+          item.session_id,
+          item.merged_at,
+          item.status,
+          item.gate_passed ? 1 : 0,
+          item.spec_success_rate_percent,
+          item.risk_level,
+          item.ontology_quality_score,
+          item.capability_coverage_percent,
+          item.capability_coverage_passed ? 1 : 0,
+          item.scene_package_batch_passed ? 1 : 0,
+          item.scene_package_batch_failure_count,
+          item.failed_goals,
+          item.release_gate_preflight_available ? 1 : 0,
+          item.release_gate_preflight_blocked ? 1 : 0,
+          item.source_updated_at,
+          item.source,
+          item.indexed_at
+        );
+      }
+    });
+
+    const totalRow = this._db
+      .prepare('SELECT COUNT(*) AS total FROM release_evidence_run_registry')
+      .get();
+
+    return {
+      success: true,
+      written: normalizedRecords.length,
+      total: normalizeNonNegativeInteger(totalRow && totalRow.total, 0)
+    };
+  }
+
+  async listReleaseEvidenceRunRecords(options = {}) {
+    const limit = normalizeInteger(options.limit, 100);
+    const status = normalizeString(options.status);
+    const riskLevel = normalizeString(options.riskLevel || options.risk_level);
+
+    if (this._useMemoryBackend()) {
+      let rows = Object.values(this._memory.release_evidence_run || {}).map((item) => ({ ...item }));
+      if (status) {
+        rows = rows.filter((item) => normalizeString(item.status) === status);
+      }
+      if (riskLevel) {
+        rows = rows.filter((item) => normalizeString(item.risk_level) === riskLevel);
+      }
+      rows.sort((left, right) => {
+        const leftTs = Date.parse(left.merged_at || '') || 0;
+        const rightTs = Date.parse(right.merged_at || '') || 0;
+        if (rightTs !== leftTs) {
+          return rightTs - leftTs;
+        }
+        return `${right.session_id}`.localeCompare(`${left.session_id}`);
+      });
+      if (limit > 0) {
+        rows = rows.slice(0, limit);
+      }
+      return rows.map((row) => this._mapReleaseEvidenceRunRow(row));
+    }
+
+    if (!await this.ensureReady()) {
+      return null;
+    }
+
+    let query = `
+      SELECT session_id, merged_at, status, gate_passed, spec_success_rate_percent, risk_level,
+             ontology_quality_score, capability_coverage_percent, capability_coverage_passed,
+             scene_package_batch_passed, scene_package_batch_failure_count, failed_goals,
+             release_gate_preflight_available, release_gate_preflight_blocked, source_updated_at,
+             source, indexed_at
+      FROM release_evidence_run_registry
+    `;
+    const clauses = [];
+    const params = [];
+    if (status) {
+      clauses.push('status = ?');
+      params.push(status);
+    }
+    if (riskLevel) {
+      clauses.push('risk_level = ?');
+      params.push(riskLevel);
+    }
+    if (clauses.length > 0) {
+      query += ` WHERE ${clauses.join(' AND ')}`;
+    }
+    query += ' ORDER BY merged_at DESC, session_id DESC';
+    if (limit > 0) {
+      query += ' LIMIT ?';
+      params.push(limit);
+    }
+
+    const rows = this._db.prepare(query).all(...params);
+    return rows
+      .map((row) => this._mapReleaseEvidenceRunRow(row))
+      .filter(Boolean);
+  }
+
+  async upsertReleaseGateHistoryRecords(records = [], options = {}) {
+    const source = normalizeString(options.source) || 'file.release-evidence.gate-history';
+    const nowIso = this.now();
+    const normalizedRecords = Array.isArray(records)
+      ? records.map((item) => ({
+        tag: normalizeString(item && item.tag),
+        evaluated_at: normalizeIsoTimestamp(item && item.evaluated_at, '') || null,
+        gate_passed: normalizeBooleanValue(item && item.gate_passed, false),
+        enforce: normalizeBooleanValue(item && item.enforce, false),
+        risk_level: normalizeString(item && item.risk_level) || null,
+        spec_success_rate_percent: Number.isFinite(Number(item && item.spec_success_rate_percent))
+          ? Number(item.spec_success_rate_percent)
+          : null,
+        scene_package_batch_passed: normalizeBooleanValue(item && item.scene_package_batch_passed, false),
+        scene_package_batch_failure_count: normalizeNonNegativeInteger(item && item.scene_package_batch_failure_count, 0),
+        capability_expected_unknown_count: normalizeNonNegativeInteger(item && item.capability_expected_unknown_count, 0),
+        capability_provided_unknown_count: normalizeNonNegativeInteger(item && item.capability_provided_unknown_count, 0),
+        release_gate_preflight_available: normalizeBooleanValue(item && item.release_gate_preflight_available, false),
+        release_gate_preflight_blocked: normalizeBooleanValue(item && item.release_gate_preflight_blocked, false),
+        require_release_gate_preflight: normalizeBooleanValue(item && item.require_release_gate_preflight, false),
+        drift_alert_count: normalizeNonNegativeInteger(item && item.drift_alert_count, 0),
+        drift_blocked: normalizeBooleanValue(item && item.drift_blocked, false),
+        weekly_ops_blocked: normalizeBooleanValue(item && item.weekly_ops_blocked, false),
+        source_updated_at: normalizeIsoTimestamp(item && item.source_updated_at, '') || null,
+        source: normalizeString(item && item.source) || source,
+        indexed_at: nowIso
+      }))
+        .filter((item) => item.tag)
+      : [];
+
+    if (this._useMemoryBackend()) {
+      for (const item of normalizedRecords) {
+        this._memory.release_gate_history[item.tag] = { ...item };
+      }
+      return {
+        success: true,
+        written: normalizedRecords.length,
+        total: Object.keys(this._memory.release_gate_history || {}).length
+      };
+    }
+
+    if (!await this.ensureReady()) {
+      return null;
+    }
+
+    const statement = this._db.prepare(`
+      INSERT OR REPLACE INTO release_gate_history_registry(
+        tag, evaluated_at, gate_passed, enforce, risk_level, spec_success_rate_percent,
+        scene_package_batch_passed, scene_package_batch_failure_count,
+        capability_expected_unknown_count, capability_provided_unknown_count,
+        release_gate_preflight_available, release_gate_preflight_blocked,
+        require_release_gate_preflight, drift_alert_count, drift_blocked,
+        weekly_ops_blocked, source_updated_at, source, indexed_at
+      )
+      VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+
+    this._withTransaction(() => {
+      for (const item of normalizedRecords) {
+        statement.run(
+          item.tag,
+          item.evaluated_at,
+          item.gate_passed ? 1 : 0,
+          item.enforce ? 1 : 0,
+          item.risk_level,
+          item.spec_success_rate_percent,
+          item.scene_package_batch_passed ? 1 : 0,
+          item.scene_package_batch_failure_count,
+          item.capability_expected_unknown_count,
+          item.capability_provided_unknown_count,
+          item.release_gate_preflight_available ? 1 : 0,
+          item.release_gate_preflight_blocked ? 1 : 0,
+          item.require_release_gate_preflight ? 1 : 0,
+          item.drift_alert_count,
+          item.drift_blocked ? 1 : 0,
+          item.weekly_ops_blocked ? 1 : 0,
+          item.source_updated_at,
+          item.source,
+          item.indexed_at
+        );
+      }
+    });
+
+    const totalRow = this._db
+      .prepare('SELECT COUNT(*) AS total FROM release_gate_history_registry')
+      .get();
+
+    return {
+      success: true,
+      written: normalizedRecords.length,
+      total: normalizeNonNegativeInteger(totalRow && totalRow.total, 0)
+    };
+  }
+
+  async listReleaseGateHistoryRecords(options = {}) {
+    const limit = normalizeInteger(options.limit, 100);
+    const tag = normalizeString(options.tag);
+    const riskLevel = normalizeString(options.riskLevel || options.risk_level);
+
+    if (this._useMemoryBackend()) {
+      let rows = Object.values(this._memory.release_gate_history || {}).map((item) => ({ ...item }));
+      if (tag) {
+        rows = rows.filter((item) => normalizeString(item.tag) === tag);
+      }
+      if (riskLevel) {
+        rows = rows.filter((item) => normalizeString(item.risk_level) === riskLevel);
+      }
+      rows.sort((left, right) => {
+        const leftTs = Date.parse(left.evaluated_at || '') || 0;
+        const rightTs = Date.parse(right.evaluated_at || '') || 0;
+        if (rightTs !== leftTs) {
+          return rightTs - leftTs;
+        }
+        return `${right.tag}`.localeCompare(`${left.tag}`);
+      });
+      if (limit > 0) {
+        rows = rows.slice(0, limit);
+      }
+      return rows.map((row) => this._mapReleaseGateHistoryRow(row));
+    }
+
+    if (!await this.ensureReady()) {
+      return null;
+    }
+
+    let query = `
+      SELECT tag, evaluated_at, gate_passed, enforce, risk_level, spec_success_rate_percent,
+             scene_package_batch_passed, scene_package_batch_failure_count,
+             capability_expected_unknown_count, capability_provided_unknown_count,
+             release_gate_preflight_available, release_gate_preflight_blocked,
+             require_release_gate_preflight, drift_alert_count, drift_blocked,
+             weekly_ops_blocked, source_updated_at, source, indexed_at
+      FROM release_gate_history_registry
+    `;
+    const clauses = [];
+    const params = [];
+    if (tag) {
+      clauses.push('tag = ?');
+      params.push(tag);
+    }
+    if (riskLevel) {
+      clauses.push('risk_level = ?');
+      params.push(riskLevel);
+    }
+    if (clauses.length > 0) {
+      query += ` WHERE ${clauses.join(' AND ')}`;
+    }
+    query += ' ORDER BY evaluated_at DESC, tag DESC';
+    if (limit > 0) {
+      query += ' LIMIT ?';
+      params.push(limit);
+    }
+
+    const rows = this._db.prepare(query).all(...params);
+    return rows
+      .map((row) => this._mapReleaseGateHistoryRow(row))
+      .filter(Boolean);
+  }
+
   _resolveOrCreateTaskRefInMemory(options = {}) {
     const sceneId = normalizeString(options.sceneId);
     const specId = normalizeString(options.specId);

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

@@ -11,6 +11,8 @@ 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 COMPONENT_RELEASE_EVIDENCE_RUNS = 'release.evidence-runs-index';
+const COMPONENT_RELEASE_GATE_HISTORY = 'release.gate-history-index';
 const DEFAULT_STATE_EXPORT_PATH = '.sce/reports/state-migration/state-export.latest.json';
 
 const COMPONENT_DEFINITIONS = Object.freeze([
@@ -41,6 +43,14 @@ const COMPONENT_DEFINITIONS = Object.freeze([
   {
     id: COMPONENT_SPEC_SCENE_INDEX,
     source_path: '.sce/spec-governance/scene-index.json'
+  },
+  {
+    id: COMPONENT_RELEASE_EVIDENCE_RUNS,
+    source_path: '.sce/reports/release-evidence/handoff-runs.json'
+  },
+  {
+    id: COMPONENT_RELEASE_GATE_HISTORY,
+    source_path: '.sce/reports/release-evidence/release-gate-history.json'
   }
 ]);
 
@@ -280,6 +290,106 @@ function mapSpecSceneIndexPayload(payload = {}) {
     .filter((item) => item.scene_id);
 }
 
+function mapReleaseEvidenceRunsPayload(payload = {}) {
+  if (!payload || typeof payload !== 'object' || !Array.isArray(payload.sessions)) {
+    return [];
+  }
+  const sourceUpdatedAt = normalizeString(payload.updated_at) || normalizeString(payload.generated_at);
+  return payload.sessions
+    .map((session) => {
+      const gate = session && session.gate && typeof session.gate === 'object' ? session.gate : {};
+      const gateActual = gate && gate.actual && typeof gate.actual === 'object' ? gate.actual : {};
+      const coverage = session && session.capability_coverage && typeof session.capability_coverage === 'object'
+        ? session.capability_coverage
+        : {};
+      const coverageSummary = coverage && coverage.summary && typeof coverage.summary === 'object'
+        ? coverage.summary
+        : {};
+      const scenePackageBatch = session && session.scene_package_batch && typeof session.scene_package_batch === 'object'
+        ? session.scene_package_batch
+        : {};
+      const scenePackageBatchSummary = scenePackageBatch && scenePackageBatch.summary && typeof scenePackageBatch.summary === 'object'
+        ? scenePackageBatch.summary
+        : {};
+      const batchSummary = session && session.batch_summary && typeof session.batch_summary === 'object'
+        ? session.batch_summary
+        : {};
+      const preflight = session && session.release_gate_preflight && typeof session.release_gate_preflight === 'object'
+        ? session.release_gate_preflight
+        : {};
+      return {
+        session_id: normalizeString(session && session.session_id),
+        merged_at: normalizeString(session && session.merged_at) || normalizeString(session && session.generated_at),
+        status: normalizeString(session && session.status),
+        gate_passed: gate && gate.passed === true,
+        spec_success_rate_percent: Number.isFinite(Number(gateActual.spec_success_rate_percent))
+          ? Number(gateActual.spec_success_rate_percent)
+          : null,
+        risk_level: normalizeString(gateActual.risk_level),
+        ontology_quality_score: Number.isFinite(Number(gateActual.ontology_quality_score))
+          ? Number(gateActual.ontology_quality_score)
+          : null,
+        capability_coverage_percent: Number.isFinite(Number(coverageSummary.coverage_percent))
+          ? Number(coverageSummary.coverage_percent)
+          : null,
+        capability_coverage_passed: coverageSummary.passed === true,
+        scene_package_batch_passed: scenePackageBatchSummary.batch_gate_passed === true,
+        scene_package_batch_failure_count: Number.isFinite(Number(scenePackageBatchSummary.batch_gate_failure_count))
+          ? Number.parseInt(`${scenePackageBatchSummary.batch_gate_failure_count}`, 10)
+          : (
+            Number.isFinite(Number(scenePackageBatchSummary.failed))
+              ? Number.parseInt(`${scenePackageBatchSummary.failed}`, 10)
+              : 0
+          ),
+        failed_goals: Number.isFinite(Number(batchSummary.failed_goals))
+          ? Number.parseInt(`${batchSummary.failed_goals}`, 10)
+          : 0,
+        release_gate_preflight_available: preflight && preflight.available === true,
+        release_gate_preflight_blocked: preflight && preflight.blocked === true,
+        source_updated_at: sourceUpdatedAt
+      };
+    })
+    .filter((item) => item.session_id);
+}
+
+function mapReleaseGateHistoryPayload(payload = {}) {
+  if (!payload || typeof payload !== 'object' || !Array.isArray(payload.entries)) {
+    return [];
+  }
+  const sourceUpdatedAt = normalizeString(payload.updated_at) || normalizeString(payload.generated_at);
+  return payload.entries
+    .map((entry) => ({
+      tag: normalizeString(entry && entry.tag),
+      evaluated_at: normalizeString(entry && entry.evaluated_at),
+      gate_passed: entry && entry.gate_passed === true,
+      enforce: entry && entry.enforce === true,
+      risk_level: normalizeString(entry && entry.risk_level),
+      spec_success_rate_percent: Number.isFinite(Number(entry && entry.spec_success_rate_percent))
+        ? Number(entry.spec_success_rate_percent)
+        : null,
+      scene_package_batch_passed: entry && entry.scene_package_batch_passed === true,
+      scene_package_batch_failure_count: Number.isFinite(Number(entry && entry.scene_package_batch_failure_count))
+        ? Number.parseInt(`${entry.scene_package_batch_failure_count}`, 10)
+        : 0,
+      capability_expected_unknown_count: Number.isFinite(Number(entry && entry.capability_expected_unknown_count))
+        ? Number.parseInt(`${entry.capability_expected_unknown_count}`, 10)
+        : 0,
+      capability_provided_unknown_count: Number.isFinite(Number(entry && entry.capability_provided_unknown_count))
+        ? Number.parseInt(`${entry.capability_provided_unknown_count}`, 10)
+        : 0,
+      release_gate_preflight_available: entry && entry.release_gate_preflight_available === true,
+      release_gate_preflight_blocked: entry && entry.release_gate_preflight_blocked === true,
+      require_release_gate_preflight: entry && entry.require_release_gate_preflight === true,
+      drift_alert_count: Number.isFinite(Number(entry && entry.drift_alert_count))
+        ? Number.parseInt(`${entry.drift_alert_count}`, 10)
+        : 0,
+      drift_blocked: entry && entry.drift_blocked === true,
+      weekly_ops_blocked: entry && entry.weekly_ops_blocked === true,
+      source_updated_at: sourceUpdatedAt
+    }))
+    .filter((item) => item.tag);
+}
+
 async function readJsonSource(absolutePath, fileSystem = fs) {
   if (!await fileSystem.pathExists(absolutePath)) {
     return {
@@ -325,6 +435,10 @@ async function readComponentSnapshot(component = {}, projectPath = process.cwd()
       records = mapSpecSceneOverridesPayload(source.payload);
     } else if (component.id === COMPONENT_SPEC_SCENE_INDEX) {
       records = mapSpecSceneIndexPayload(source.payload);
+    } else if (component.id === COMPONENT_RELEASE_EVIDENCE_RUNS) {
+      records = mapReleaseEvidenceRunsPayload(source.payload);
+    } else if (component.id === COMPONENT_RELEASE_GATE_HISTORY) {
+      records = mapReleaseGateHistoryPayload(source.payload);
     }
   }
 
@@ -434,6 +548,16 @@ async function writeComponentToStateStore(componentSnapshot = {}, stateStore, co
       source: componentId
     });
   }
+  if (componentId === COMPONENT_RELEASE_EVIDENCE_RUNS) {
+    return stateStore.upsertReleaseEvidenceRunRecords(componentSnapshot.records, {
+      source: componentId
+    });
+  }
+  if (componentId === COMPONENT_RELEASE_GATE_HISTORY) {
+    return stateStore.upsertReleaseGateHistoryRecords(componentSnapshot.records, {
+      source: componentId
+    });
+  }
   return null;
 }
 
@@ -561,6 +685,8 @@ async function runStateDoctor(options = {}, dependencies = {}) {
     errorbookIncidentRows,
     governanceOverrideRows,
     governanceSceneRows,
+    releaseEvidenceRows,
+    releaseGateHistoryRows,
     migrations
   ] = await Promise.all([
     stateStore.listAgentRuntimeRecords({ limit: 0 }),
@@ -570,6 +696,8 @@ async function runStateDoctor(options = {}, dependencies = {}) {
     stateStore.listErrorbookIncidentIndexRecords({ limit: 0 }),
     stateStore.listGovernanceSpecSceneOverrideRecords({ limit: 0 }),
     stateStore.listGovernanceSceneIndexRecords({ limit: 0 }),
+    stateStore.listReleaseEvidenceRunRecords({ limit: 0 }),
+    stateStore.listReleaseGateHistoryRecords({ limit: 0 }),
     stateStore.listStateMigrations({ limit: 20 })
   ]);
 
@@ -580,7 +708,9 @@ async function runStateDoctor(options = {}, dependencies = {}) {
     [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]
+    [COMPONENT_SPEC_SCENE_INDEX, Array.isArray(governanceSceneRows) ? governanceSceneRows.length : 0],
+    [COMPONENT_RELEASE_EVIDENCE_RUNS, Array.isArray(releaseEvidenceRows) ? releaseEvidenceRows.length : 0],
+    [COMPONENT_RELEASE_GATE_HISTORY, Array.isArray(releaseGateHistoryRows) ? releaseGateHistoryRows.length : 0]
   ]);
 
   const checks = plan.components.map((component) => {
@@ -788,6 +918,8 @@ async function runStateExport(options = {}, dependencies = {}) {
     errorbookIncidentRows,
     governanceOverrideRows,
     governanceSceneRows,
+    releaseEvidenceRows,
+    releaseGateHistoryRows,
     migrations
   ] = await Promise.all([
     stateStore.listAgentRuntimeRecords({ limit: 0 }),
@@ -797,6 +929,8 @@ async function runStateExport(options = {}, dependencies = {}) {
     stateStore.listErrorbookIncidentIndexRecords({ limit: 0 }),
     stateStore.listGovernanceSpecSceneOverrideRecords({ limit: 0 }),
     stateStore.listGovernanceSceneIndexRecords({ limit: 0 }),
+    stateStore.listReleaseEvidenceRunRecords({ limit: 0 }),
+    stateStore.listReleaseGateHistoryRecords({ limit: 0 }),
     stateStore.listStateMigrations({ limit: 0 })
   ]);
 
@@ -813,6 +947,8 @@ async function runStateExport(options = {}, dependencies = {}) {
       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 : [],
+      release_evidence_run_registry: Array.isArray(releaseEvidenceRows) ? releaseEvidenceRows : [],
+      release_gate_history_registry: Array.isArray(releaseGateHistoryRows) ? releaseGateHistoryRows : [],
       state_migration_registry: Array.isArray(migrations) ? migrations : []
     },
     summary: {
@@ -823,6 +959,8 @@ async function runStateExport(options = {}, dependencies = {}) {
       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,
+      release_evidence_run_registry: Array.isArray(releaseEvidenceRows) ? releaseEvidenceRows.length : 0,
+      release_gate_history_registry: Array.isArray(releaseGateHistoryRows) ? releaseGateHistoryRows.length : 0,
       state_migration_registry: Array.isArray(migrations) ? migrations.length : 0
     },
     out_file: path.relative(projectPath, outPath).replace(/\\/g, '/')
@@ -841,6 +979,8 @@ module.exports = {
   COMPONENT_ERRORBOOK_INCIDENT_INDEX,
   COMPONENT_SPEC_SCENE_OVERRIDES,
   COMPONENT_SPEC_SCENE_INDEX,
+  COMPONENT_RELEASE_EVIDENCE_RUNS,
+  COMPONENT_RELEASE_GATE_HISTORY,
   COMPONENT_DEFINITIONS,
   DEFAULT_STATE_EXPORT_PATH,
   buildStateMigrationPlan,

package/package.json

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