scene-capability-engine 3.6.38 → 3.6.39

package/lib/governance/validation-engine.js

@@ -84,6 +84,8 @@ class ValidationEngine {
    */
   async validateSpec(specName) {
     const specPath = this.scanner.getSpecDirectory(specName);
+    const requiredFiles = ['requirements.md', 'design.md', 'tasks.md'];
+    const allowedRootFiles = this.config.specAllowedRootFiles || requiredFiles;
     
     // Check if Spec directory exists
     if (!await this.scanner.exists(specPath)) {
@@ -97,7 +99,6 @@ class ValidationEngine {
     }
     
     // Check required files
-    const requiredFiles = ['requirements.md', 'design.md', 'tasks.md'];
     for (const file of requiredFiles) {
       const filePath = path.join(specPath, file);
       if (!await this.scanner.exists(filePath)) {
@@ -118,7 +119,7 @@ class ValidationEngine {
       const basename = path.basename(filePath);
       
       // Skip required files
-      if (requiredFiles.includes(basename)) {
+      if (allowedRootFiles.includes(basename)) {
         continue;
       }
       

package/lib/runtime/session-store.js

@@ -568,26 +568,34 @@ class SessionStore {
 
     const fileCount = fileRecords.length;
     const sqliteCount = Array.isArray(sqliteRecords) ? sqliteRecords.length : null;
+    let readSource = 'file';
 
     let status = 'file-only';
     if (sqliteCount === null) {
       status = 'sqlite-unavailable';
     } else if (fileCount === 0 && sqliteCount === 0) {
       status = 'empty';
+      readSource = 'empty';
     } else if (fileCount === 0 && sqliteCount > 0) {
       status = 'sqlite-only';
+      readSource = 'sqlite';
     } else if (fileCount > 0 && sqliteCount === 0) {
       status = 'file-only';
+      readSource = 'file';
     } else if (fileCount === sqliteCount) {
       status = 'aligned';
+      readSource = this._preferSqliteSceneReads ? 'sqlite' : 'file';
     } else if (sqliteCount < fileCount) {
       status = 'pending-sync';
+      readSource = 'file';
     } else if (sqliteCount > fileCount) {
       status = 'sqlite-ahead';
+      readSource = 'sqlite';
     }
 
     return {
       read_preference: this._preferSqliteSceneReads ? 'sqlite' : 'file',
+      read_source: readSource,
       file_scene_count: fileCount,
       sqlite_scene_count: sqliteCount,
       status

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

@@ -162,6 +162,7 @@ class SceStateStore {
       migration_records: {},
       auth_leases: {},
       auth_events: [],
+      interactive_approval_events: {},
       sequences: {
         scene_next: 1,
         spec_next_by_scene: {},
@@ -294,6 +295,34 @@ class SceStateStore {
       CREATE INDEX IF NOT EXISTS idx_auth_event_stream_ts
         ON auth_event_stream(event_timestamp);
 
+      CREATE TABLE IF NOT EXISTS interactive_approval_event_projection (
+        event_id TEXT PRIMARY KEY,
+        workflow_id TEXT,
+        event_timestamp TEXT NOT NULL,
+        event_type TEXT NOT NULL,
+        action TEXT,
+        actor TEXT,
+        actor_role TEXT,
+        from_status TEXT,
+        to_status TEXT,
+        blocked INTEGER,
+        reason TEXT,
+        audit_file TEXT,
+        line_no INTEGER,
+        raw_json TEXT NOT NULL,
+        source TEXT,
+        indexed_at TEXT NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_interactive_approval_event_projection_workflow_ts
+        ON interactive_approval_event_projection(workflow_id, event_timestamp DESC);
+
+      CREATE INDEX IF NOT EXISTS idx_interactive_approval_event_projection_actor_action_ts
+        ON interactive_approval_event_projection(actor, action, event_timestamp DESC);
+
+      CREATE INDEX IF NOT EXISTS idx_interactive_approval_event_projection_blocked_ts
+        ON interactive_approval_event_projection(blocked, event_timestamp DESC);
+
       CREATE TABLE IF NOT EXISTS timeline_snapshot_registry (
         snapshot_id TEXT PRIMARY KEY,
         created_at TEXT NOT NULL,
@@ -1007,6 +1036,30 @@ class SceStateStore {
     };
   }
 
+  _mapInteractiveApprovalEventProjectionRow(row) {
+    if (!row) {
+      return null;
+    }
+    return {
+      event_id: normalizeString(row.event_id),
+      workflow_id: normalizeString(row.workflow_id) || null,
+      event_timestamp: normalizeIsoTimestamp(row.event_timestamp) || null,
+      event_type: normalizeString(row.event_type),
+      action: normalizeString(row.action) || null,
+      actor: normalizeString(row.actor) || null,
+      actor_role: normalizeString(row.actor_role) || null,
+      from_status: normalizeString(row.from_status) || null,
+      to_status: normalizeString(row.to_status) || null,
+      blocked: normalizeBooleanValue(row.blocked, false),
+      reason: normalizeString(row.reason) || null,
+      audit_file: normalizeString(row.audit_file) || null,
+      line_no: normalizeNonNegativeInteger(row.line_no, 0),
+      raw: parseJsonSafe(row.raw_json, null),
+      source: normalizeString(row.source) || null,
+      indexed_at: normalizeIsoTimestamp(row.indexed_at) || null
+    };
+  }
+
   _mapTimelineSnapshotRow(row) {
     if (!row) {
       return null;
@@ -2151,6 +2204,218 @@ class SceStateStore {
       .filter(Boolean);
   }
 
+  async clearInteractiveApprovalEventProjection(options = {}) {
+    const auditFileFilter = normalizeString(options.auditFile || options.audit_file);
+
+    if (this._useMemoryBackend()) {
+      if (!auditFileFilter) {
+        this._memory.interactive_approval_events = {};
+        return { success: true, removed: 0 };
+      }
+      let removed = 0;
+      for (const [eventId, item] of Object.entries(this._memory.interactive_approval_events || {})) {
+        if (normalizeString(item.audit_file) === auditFileFilter) {
+          delete this._memory.interactive_approval_events[eventId];
+          removed += 1;
+        }
+      }
+      return { success: true, removed };
+    }
+
+    if (!await this.ensureReady()) {
+      return null;
+    }
+
+    if (auditFileFilter) {
+      const info = this._db
+        .prepare('DELETE FROM interactive_approval_event_projection WHERE audit_file = ?')
+        .run(auditFileFilter);
+      return {
+        success: true,
+        removed: normalizeNonNegativeInteger(info && info.changes, 0)
+      };
+    }
+
+    const info = this._db
+      .prepare('DELETE FROM interactive_approval_event_projection')
+      .run();
+    return {
+      success: true,
+      removed: normalizeNonNegativeInteger(info && info.changes, 0)
+    };
+  }
+
+  async upsertInteractiveApprovalEventProjection(records = [], options = {}) {
+    const source = normalizeString(options.source) || 'jsonl.interactive-approval-events';
+    const auditFile = normalizeString(options.auditFile || options.audit_file) || null;
+    const nowIso = this.now();
+    const normalizedRecords = Array.isArray(records)
+      ? records.map((item, index) => ({
+        event_id: normalizeString(item && item.event_id),
+        workflow_id: normalizeString(item && item.workflow_id) || null,
+        event_timestamp: normalizeIsoTimestamp(item && (item.event_timestamp || item.timestamp), nowIso) || nowIso,
+        event_type: normalizeString(item && item.event_type),
+        action: normalizeString(item && item.action) || null,
+        actor: normalizeString(item && item.actor) || null,
+        actor_role: normalizeString(item && item.actor_role) || null,
+        from_status: normalizeString(item && item.from_status) || null,
+        to_status: normalizeString(item && item.to_status) || null,
+        blocked: normalizeBooleanValue(item && item.blocked, false),
+        reason: normalizeString(item && item.reason) || null,
+        audit_file: normalizeString(item && (item.audit_file || item.auditFile)) || auditFile,
+        line_no: normalizeNonNegativeInteger(item && (item.line_no || item.lineNo), index + 1),
+        raw_json: JSON.stringify(item && typeof item === 'object' ? item : {}),
+        source,
+        indexed_at: nowIso
+      }))
+        .filter((item) => item.event_id && item.event_type)
+      : [];
+
+    if (this._useMemoryBackend()) {
+      for (const item of normalizedRecords) {
+        this._memory.interactive_approval_events[item.event_id] = { ...item };
+      }
+      return {
+        success: true,
+        written: normalizedRecords.length,
+        total: Object.keys(this._memory.interactive_approval_events || {}).length
+      };
+    }
+
+    if (!await this.ensureReady()) {
+      return null;
+    }
+
+    const statement = this._db.prepare(`
+      INSERT OR REPLACE INTO interactive_approval_event_projection(
+        event_id, workflow_id, event_timestamp, event_type, action, actor, actor_role,
+        from_status, to_status, blocked, reason, audit_file, line_no, raw_json, source, indexed_at
+      )
+      VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+
+    this._withTransaction(() => {
+      for (const item of normalizedRecords) {
+        statement.run(
+          item.event_id,
+          item.workflow_id,
+          item.event_timestamp,
+          item.event_type,
+          item.action,
+          item.actor,
+          item.actor_role,
+          item.from_status,
+          item.to_status,
+          item.blocked ? 1 : 0,
+          item.reason,
+          item.audit_file,
+          item.line_no,
+          item.raw_json,
+          item.source,
+          item.indexed_at
+        );
+      }
+    });
+
+    const totalRow = this._db
+      .prepare('SELECT COUNT(*) AS total FROM interactive_approval_event_projection')
+      .get();
+
+    return {
+      success: true,
+      written: normalizedRecords.length,
+      total: normalizeNonNegativeInteger(totalRow && totalRow.total, 0)
+    };
+  }
+
+  async listInteractiveApprovalEventProjection(options = {}) {
+    const limit = normalizeInteger(options.limit, 100);
+    const workflowId = normalizeString(options.workflowId || options.workflow_id);
+    const actor = normalizeString(options.actor);
+    const action = normalizeString(options.action);
+    const eventType = normalizeString(options.eventType || options.event_type);
+    const auditFile = normalizeString(options.auditFile || options.audit_file);
+    const blockedFilter = options.blocked === undefined || options.blocked === null
+      ? null
+      : normalizeBooleanValue(options.blocked, false);
+
+    if (this._useMemoryBackend()) {
+      let rows = Object.values(this._memory.interactive_approval_events || {}).map((item) => ({ ...item }));
+      if (workflowId) {
+        rows = rows.filter((item) => normalizeString(item.workflow_id) === workflowId);
+      }
+      if (actor) {
+        rows = rows.filter((item) => normalizeString(item.actor) === actor);
+      }
+      if (action) {
+        rows = rows.filter((item) => normalizeString(item.action) === action);
+      }
+      if (eventType) {
+        rows = rows.filter((item) => normalizeString(item.event_type) === eventType);
+      }
+      if (auditFile) {
+        rows = rows.filter((item) => normalizeString(item.audit_file) === auditFile);
+      }
+      if (blockedFilter !== null) {
+        rows = rows.filter((item) => normalizeBooleanValue(item.blocked, false) === blockedFilter);
+      }
+      rows.sort((left, right) => (Date.parse(right.event_timestamp || '') || 0) - (Date.parse(left.event_timestamp || '') || 0));
+      if (limit > 0) {
+        rows = rows.slice(0, limit);
+      }
+      return rows.map((row) => this._mapInteractiveApprovalEventProjectionRow(row)).filter(Boolean);
+    }
+
+    if (!await this.ensureReady()) {
+      return null;
+    }
+
+    let query = `
+      SELECT event_id, workflow_id, event_timestamp, event_type, action, actor, actor_role,
+             from_status, to_status, blocked, reason, audit_file, line_no, raw_json, source, indexed_at
+      FROM interactive_approval_event_projection
+    `;
+    const clauses = [];
+    const params = [];
+    if (workflowId) {
+      clauses.push('workflow_id = ?');
+      params.push(workflowId);
+    }
+    if (actor) {
+      clauses.push('actor = ?');
+      params.push(actor);
+    }
+    if (action) {
+      clauses.push('action = ?');
+      params.push(action);
+    }
+    if (eventType) {
+      clauses.push('event_type = ?');
+      params.push(eventType);
+    }
+    if (auditFile) {
+      clauses.push('audit_file = ?');
+      params.push(auditFile);
+    }
+    if (blockedFilter !== null) {
+      clauses.push('blocked = ?');
+      params.push(blockedFilter ? 1 : 0);
+    }
+    if (clauses.length > 0) {
+      query += ` WHERE ${clauses.join(' AND ')}`;
+    }
+    query += ' ORDER BY event_timestamp DESC, line_no DESC';
+    if (limit > 0) {
+      query += ' LIMIT ?';
+      params.push(limit);
+    }
+
+    const rows = this._db.prepare(query).all(...params);
+    return rows
+      .map((row) => this._mapInteractiveApprovalEventProjectionRow(row))
+      .filter(Boolean);
+  }
+
   async upsertTimelineSnapshotIndex(records = [], options = {}) {
     const source = normalizeString(options.source) || 'file.timeline.index';
     const nowIso = this.now();

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

@@ -723,8 +723,12 @@ async function runStateDoctor(options = {}, dependencies = {}) {
       syncStatus = 'source-parse-error';
     } else if (sourceCount === 0 && targetCount === 0) {
       syncStatus = 'empty';
+    } else if (sourceCount === 0 && targetCount > 0) {
+      syncStatus = 'sqlite-only';
     } else if (targetCount < sourceCount) {
       syncStatus = 'pending-migration';
+    } else if (targetCount > sourceCount) {
+      syncStatus = 'sqlite-ahead';
     }
     return {
       id: component.id,
@@ -750,22 +754,37 @@ async function runStateDoctor(options = {}, dependencies = {}) {
   if (checks.some((item) => item.sync_status === 'source-parse-error')) {
     blocking.push('source-parse-error');
   }
+  if (checks.some((item) => item.sync_status === 'sqlite-ahead')) {
+    blocking.push('sqlite-ahead');
+  }
+  if (checks.some((item) => item.sync_status === 'sqlite-only')) {
+    blocking.push('sqlite-only');
+  }
 
   const alerts = checks
     .filter((item) => item.sync_status === 'pending-migration')
     .map((item) => `pending migration: ${item.id}`);
+  alerts.push(...checks
+    .filter((item) => item.sync_status === 'missing-source')
+    .map((item) => `missing source: ${item.id}`));
 
   if (runtime.timeline && runtime.timeline.consistency && runtime.timeline.consistency.status === 'pending-sync') {
     alerts.push('runtime timeline index pending-sync');
   }
   if (runtime.timeline && runtime.timeline.consistency && runtime.timeline.consistency.status === 'sqlite-ahead') {
-    alerts.push('runtime timeline index sqlite-ahead');
+    blocking.push('runtime timeline index sqlite-ahead');
+  }
+  if (runtime.timeline && runtime.timeline.consistency && runtime.timeline.consistency.status === 'sqlite-only') {
+    blocking.push('runtime timeline index sqlite-only');
   }
   if (runtime.scene_session && runtime.scene_session.consistency && runtime.scene_session.consistency.status === 'pending-sync') {
     alerts.push('runtime scene-session index pending-sync');
   }
   if (runtime.scene_session && runtime.scene_session.consistency && runtime.scene_session.consistency.status === 'sqlite-ahead') {
-    alerts.push('runtime scene-session index sqlite-ahead');
+    blocking.push('runtime scene-session index sqlite-ahead');
+  }
+  if (runtime.scene_session && runtime.scene_session.consistency && runtime.scene_session.consistency.status === 'sqlite-only') {
+    blocking.push('runtime scene-session index sqlite-only');
   }
 
   const summary = summarizeDoctorChecks(checks, alerts, blocking);
@@ -792,7 +811,9 @@ function summarizeDoctorChecks(checks = [], alerts = [], blocking = []) {
   const pendingComponents = normalizedChecks.filter((item) => item.sync_status === 'pending-migration').length;
   const syncedComponents = normalizedChecks.filter((item) => item.sync_status === 'synced').length;
   const sqliteOnlyComponents = normalizedChecks.filter((item) => item.sync_status === 'sqlite-only').length;
+  const sqliteAheadComponents = normalizedChecks.filter((item) => item.sync_status === 'sqlite-ahead').length;
   const missingSourceComponents = normalizedChecks.filter((item) => item.sync_status === 'missing-source').length;
+  const parseErrorComponents = normalizedChecks.filter((item) => item.sync_status === 'source-parse-error').length;
   const driftRecords = normalizedChecks.reduce((sum, item) => {
     const source = normalizeCount(item.source_record_count);
     const target = normalizeCount(item.sqlite_record_count);
@@ -804,7 +825,9 @@ function summarizeDoctorChecks(checks = [], alerts = [], blocking = []) {
     synced_components: syncedComponents,
     pending_components: pendingComponents,
     sqlite_only_components: sqliteOnlyComponents,
+    sqlite_ahead_components: sqliteAheadComponents,
     missing_source_components: missingSourceComponents,
+    source_parse_error_components: parseErrorComponents,
     total_source_records: sourceRecords,
     total_sqlite_records: sqliteRecords,
     total_record_drift: driftRecords,
@@ -878,6 +901,7 @@ async function collectRuntimeDiagnostics(dependencies = {}) {
     const sceneIndex = await sessionStore.getSceneIndexDiagnostics();
     runtime.scene_session = {
       read_preference: normalizeString(sceneIndex.read_preference) || 'file',
+      read_source: normalizeString(sceneIndex.read_source) || 'file',
       consistency: {
         status: normalizeString(sceneIndex.status) || 'unknown',
         file_index_count: normalizeCount(sceneIndex.file_scene_count),
@@ -889,6 +913,7 @@ async function collectRuntimeDiagnostics(dependencies = {}) {
   } catch (_error) {
     runtime.scene_session = {
       read_preference: 'file',
+      read_source: 'unavailable',
       consistency: {
         status: 'unavailable',
         file_index_count: 0,

package/lib/state/state-storage-policy.js

@@ -0,0 +1,179 @@
+'use strict';
+
+const DEFAULT_STATE_STORAGE_POLICY = Object.freeze({
+  schema_version: '1.0',
+  strategy: 'selective-sqlite-advancement',
+  tiers: {
+    'file-source': {
+      description: 'Canonical file-backed storage for low-cardinality config, raw evidence, audit streams, and recovery-oriented payloads.'
+    },
+    'sqlite-index': {
+      description: 'SQLite index/registry layer for file-backed resources that need high-frequency filtering, sorting, and cross-run aggregation.'
+    },
+    'derived-sqlite-projection': {
+      description: 'Disposable SQLite projection rebuilt from canonical files for append-only streams with query pressure.'
+    }
+  },
+  admission: {
+    required_signals: [
+      'cross-run or cross-session query pressure is proven',
+      'file scans are materially weaker than indexed filtering/sorting',
+      'sqlite content remains rebuildable from a canonical source',
+      'operator diagnostics and reconcile path are defined before rollout'
+    ],
+    deny_if_any: [
+      'resource is the only copy of raw audit or evidence payload',
+      'resource is low-cardinality personal workspace or preference state',
+      'human-readable diff and manual recovery are more valuable than query speed',
+      'migration would introduce silent source-of-truth cutover'
+    ],
+    future_candidate_checklist: [
+      'identify canonical source path or stream',
+      'document expected query patterns and consumers',
+      'define rebuild and reconcile semantics',
+      'define release gate or audit behavior for drift states',
+      'document why existing file-only storage is insufficient'
+    ]
+  },
+  component_scope: [
+    {
+      component_id: 'collab.agent-registry',
+      tier: 'sqlite-index',
+      canonical_source: 'file',
+      source_path: '.sce/config/agent-registry.json',
+      sqlite_tables: ['agent_runtime_registry'],
+      rationale: 'Registry-style lookup with repeated status and capability queries.'
+    },
+    {
+      component_id: 'runtime.timeline-index',
+      tier: 'sqlite-index',
+      canonical_source: 'file',
+      source_path: '.sce/timeline/index.json',
+      sqlite_tables: ['timeline_snapshot_registry'],
+      rationale: 'Timeline index benefits from filtered and cross-session reads while file snapshots remain recoverable source artifacts.'
+    },
+    {
+      component_id: 'runtime.scene-session-index',
+      tier: 'sqlite-index',
+      canonical_source: 'file',
+      source_path: '.sce/session-governance/scene-index.json',
+      sqlite_tables: ['scene_session_cycle_registry'],
+      rationale: 'Scene/session lookups have query pressure and consistency checks but still rely on file session payloads.'
+    },
+    {
+      component_id: 'errorbook.entry-index',
+      tier: 'sqlite-index',
+      canonical_source: 'file',
+      source_path: '.sce/errorbook/index.json',
+      sqlite_tables: ['errorbook_entry_index_registry'],
+      rationale: 'Promoted errorbook registry queries benefit from indexed status and quality filtering.'
+    },
+    {
+      component_id: 'errorbook.incident-index',
+      tier: 'sqlite-index',
+      canonical_source: 'file',
+      source_path: '.sce/errorbook/staging/index.json',
+      sqlite_tables: ['errorbook_incident_index_registry'],
+      rationale: 'Incident staging state requires queryable triage views without replacing raw incident artifacts.'
+    },
+    {
+      component_id: 'governance.spec-scene-overrides',
+      tier: 'sqlite-index',
+      canonical_source: 'file',
+      source_path: '.sce/spec-governance/spec-scene-overrides.json',
+      sqlite_tables: ['governance_spec_scene_override_registry'],
+      rationale: 'Override lookups are registry-like and join naturally with other governance indexes.'
+    },
+    {
+      component_id: 'governance.scene-index',
+      tier: 'sqlite-index',
+      canonical_source: 'file',
+      source_path: '.sce/spec-governance/scene-index.json',
+      sqlite_tables: ['governance_scene_index_registry'],
+      rationale: 'Scene governance summaries are better served by indexed counts and status filters.'
+    },
+    {
+      component_id: 'release.evidence-runs-index',
+      tier: 'sqlite-index',
+      canonical_source: 'file',
+      source_path: '.sce/reports/release-evidence/handoff-runs.json',
+      sqlite_tables: ['release_evidence_run_registry'],
+      rationale: 'Release evidence run summaries need fast historical querying while release assets remain file-backed.'
+    },
+    {
+      component_id: 'release.gate-history-index',
+      tier: 'sqlite-index',
+      canonical_source: 'file',
+      source_path: '.sce/reports/release-evidence/release-gate-history.json',
+      sqlite_tables: ['release_gate_history_registry'],
+      rationale: 'Gate history is registry-shaped and queried by tag, pass/fail, and drift metrics.'
+    }
+  ],
+  resource_rules: [
+    {
+      rule_id: 'workspace-personal-state',
+      tier: 'file-source',
+      explicit_paths: ['~/.sce/workspace-state.json'],
+      derived_projection_allowed: false,
+      source_replacement_allowed: false,
+      rationale: 'Personal workspace selection and preferences are low-cardinality, atomic, and not worth migrating into SQLite.'
+    },
+    {
+      rule_id: 'append-only-report-streams',
+      tier: 'file-source',
+      path_patterns: ['.sce/reports/**/*.jsonl'],
+      derived_projection_allowed: true,
+      source_replacement_allowed: false,
+      rationale: 'Raw governance and evidence streams must stay append-only files; projection is allowed only for query acceleration.'
+    },
+    {
+      rule_id: 'append-only-audit-streams',
+      tier: 'file-source',
+      path_patterns: ['.sce/audit/**/*.jsonl'],
+      derived_projection_allowed: true,
+      source_replacement_allowed: false,
+      rationale: 'Audit streams remain canonical evidence and should never become SQLite-only write paths.'
+    },
+    {
+      rule_id: 'timeline-snapshot-payloads',
+      tier: 'file-source',
+      path_patterns: ['.sce/timeline/snapshots/**'],
+      derived_projection_allowed: false,
+      source_replacement_allowed: false,
+      rationale: 'Timeline snapshots are recovery-oriented payload artifacts, not registry data.'
+    },
+    {
+      rule_id: 'session-payload-artifacts',
+      tier: 'file-source',
+      path_patterns: ['.sce/session-governance/sessions/**'],
+      derived_projection_allowed: false,
+      source_replacement_allowed: false,
+      rationale: 'Session payloads must stay file-backed for recovery, archive, and manual debugging.'
+    },
+    {
+      rule_id: 'release-evidence-assets',
+      tier: 'file-source',
+      path_patterns: [
+        '.sce/reports/release-evidence/**/*.json',
+        '.sce/reports/release-evidence/**/*.md',
+        '.sce/reports/release-evidence/**/*.jsonl',
+        '.sce/reports/release-evidence/**/*.lines'
+      ],
+      derived_projection_allowed: true,
+      source_replacement_allowed: false,
+      rationale: 'Release evidence assets remain portable files even when selected summary indexes are mirrored into SQLite.'
+    }
+  ]
+});
+
+const REQUIRED_COMPONENT_IDS = Object.freeze(DEFAULT_STATE_STORAGE_POLICY.component_scope.map((item) => item.component_id));
+
+function cloneStateStoragePolicyDefaults() {
+  return JSON.parse(JSON.stringify(DEFAULT_STATE_STORAGE_POLICY));
+}
+
+module.exports = {
+  DEFAULT_STATE_STORAGE_POLICY,
+  REQUIRED_COMPONENT_IDS,
+  cloneStateStoragePolicyDefaults
+};

package/lib/watch/action-executor.js

@@ -4,6 +4,15 @@ const { promisify } = require('util');
 
 const execAsync = promisify(exec);
 
+function sleep(ms) {
+  return new Promise(resolve => {
+    const timer = setTimeout(resolve, ms);
+    if (typeof timer.unref === 'function') {
+      timer.unref();
+    }
+  });
+}
+
 /**
  * ActionExecutor - 动作执行器
  * 
@@ -203,7 +212,7 @@ class ActionExecutor extends EventEmitter {
       });
 
       // 等待
-      await new Promise(resolve => setTimeout(resolve, delay));
+      await sleep(delay);
 
       try {
         // 重新执行

package/lib/watch/event-debouncer.js

@@ -71,6 +71,9 @@ class EventDebouncer extends EventEmitter {
         this.emit('error', { error, key, type: 'debounce' });
       }
     }, actualDelay);
+    if (typeof timer.unref === 'function') {
+      timer.unref();
+    }
 
     this.debounceTimers.set(key, timer);
   }