scene-capability-engine 3.6.37 → 3.6.39

package/lib/commands/scene.js

@@ -158,6 +158,45 @@ function createDoctorTraceId() {
   return `doctor-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
 }
 
+function stringifyJsonForCli(value, indentSize = 2, currentIndent = 0) {
+  if (value === null) {
+    return 'null';
+  }
+
+  if (typeof value === 'number') {
+    return Object.is(value, -0) ? '-0' : JSON.stringify(value);
+  }
+
+  if (typeof value === 'string' || typeof value === 'boolean') {
+    return JSON.stringify(value);
+  }
+
+  if (Array.isArray(value)) {
+    if (value.length === 0) {
+      return '[]';
+    }
+
+    const nextIndent = currentIndent + indentSize;
+    const indent = ' '.repeat(currentIndent);
+    const childIndent = ' '.repeat(nextIndent);
+    const items = value.map((entry) => `${childIndent}${stringifyJsonForCli(entry, indentSize, nextIndent)}`);
+    return `[\n${items.join(',\n')}\n${indent}]`;
+  }
+
+  const keys = Object.keys(value);
+  if (keys.length === 0) {
+    return '{}';
+  }
+
+  const nextIndent = currentIndent + indentSize;
+  const indent = ' '.repeat(currentIndent);
+  const childIndent = ' '.repeat(nextIndent);
+  const entries = keys.map((key) => (
+    `${childIndent}${JSON.stringify(key)}: ${stringifyJsonForCli(value[key], indentSize, nextIndent)}`
+  ));
+  return `{\n${entries.join(',\n')}\n${indent}}`;
+}
+
 function registerSceneCommands(program) {
   const sceneCmd = program
     .command('scene')
@@ -4795,7 +4834,7 @@ function createSceneEvalConfigTemplateByProfile(profile = 'default') {
 }
 
 function normalizeRelativePath(targetPath = '') {
-  return String(targetPath || '').replace(/\\/g, '/').replace(/\/+/g, '/').replace(/^\.\//, '');
+  return String(targetPath || '').trim().replace(/\\/g, '/').replace(/\/+/g, '/').replace(/^\.\//, '');
 }
 
 function collectManifestDiscoveryCandidates(preferredPath = 'custom/scene.yaml') {
@@ -13639,6 +13678,35 @@ async function runSceneVersionCommand(rawOptions = {}, dependencies = {}) {
   }
 }
 
+function isBinaryContent(buffer) {
+  if (!Buffer.isBuffer(buffer)) {
+    return false;
+  }
+
+  for (let index = 0; index < buffer.length; index++) {
+    if (buffer[index] === 0) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+function countChangedLines(fromContent, toContent) {
+  const oldLines = fromContent.toString('utf8').split('\n');
+  const newLines = toContent.toString('utf8').split('\n');
+  const maxLen = Math.max(oldLines.length, newLines.length);
+  let changedLines = 0;
+
+  for (let index = 0; index < maxLen; index++) {
+    if ((oldLines[index] || '') !== (newLines[index] || '')) {
+      changedLines++;
+    }
+  }
+
+  return changedLines;
+}
+
 function buildPackageDiff(fromFiles, toFiles) {
   const fromMap = new Map();
   for (const f of (fromFiles || [])) {
@@ -13662,19 +13730,9 @@ function buildPackageDiff(fromFiles, toFiles) {
       if (Buffer.compare(content, toContent) === 0) {
         unchanged.push(filePath);
       } else {
-        let changedLines = 0;
-        try {
-          const oldLines = content.toString('utf8').split('\n');
-          const newLines = toContent.toString('utf8').split('\n');
-          const maxLen = Math.max(oldLines.length, newLines.length);
-          for (let i = 0; i < maxLen; i++) {
-            if ((oldLines[i] || '') !== (newLines[i] || '')) {
-              changedLines++;
-            }
-          }
-        } catch (_e) {
-          changedLines = -1;
-        }
+        const changedLines = isBinaryContent(content) || isBinaryContent(toContent)
+          ? -1
+          : countChangedLines(content, toContent);
         modified.push({ path: filePath, changedLines });
       }
     }
@@ -13734,7 +13792,9 @@ function printSceneDiffSummary(options, payload, projectRoot = process.cwd()) {
       console.log(chalk.red(`  - ${f}`));
     }
     for (const f of payload.files.modified) {
-      const detail = f.changedLines >= 0 ? ` (${f.changedLines} lines changed)` : ' (binary content differs)';
+      const detail = options.stat
+        ? ''
+        : (f.changedLines >= 0 ? ` (${f.changedLines} lines changed)` : ' (binary content differs)');
       console.log(chalk.yellow(`  ~ ${f.path}${detail}`));
     }
   }
@@ -15248,7 +15308,7 @@ async function runSceneLintCommand(rawOptions = {}, dependencies = {}) {
 
 function printSceneLintSummary(options, payload, projectRoot = process.cwd()) {
   if (options.json) {
-    console.log(JSON.stringify(payload, null, 2));
+    console.log(stringifyJsonForCli(payload));
     return;
   }
 
@@ -15344,7 +15404,7 @@ async function runSceneScoreCommand(rawOptions = {}, dependencies = {}) {
 
 function printSceneScoreSummary(options, payload, projectRoot = process.cwd()) {
   if (options.json) {
-    console.log(JSON.stringify(payload, null, 2));
+    console.log(stringifyJsonForCli(payload));
     return;
   }
 
@@ -15524,7 +15584,7 @@ async function runSceneContributeCommand(rawOptions = {}, dependencies = {}) {
 
 function printSceneContributeSummary(options, payload, projectRoot = process.cwd()) {
   if (options.json) {
-    console.log(JSON.stringify(payload, null, 2));
+    console.log(stringifyJsonForCli(payload));
     return;
   }
 

package/lib/commands/watch.js

@@ -11,6 +11,15 @@ const inquirer = require('inquirer');
 const WatchManager = require('../watch/watch-manager');
 const { listPresets, getPreset, mergePreset, validatePreset } = require('../watch/presets');
 
+function sleep(ms) {
+  return new Promise(resolve => {
+    const timer = setTimeout(resolve, ms);
+    if (typeof timer.unref === 'function') {
+      timer.unref();
+    }
+  });
+}
+
 /**
  * Start watch mode
  * 
@@ -329,7 +338,7 @@ async function followLogStream(logPath, options = {}) {
         break;
       }
 
-      await new Promise(resolve => setTimeout(resolve, pollIntervalMs));
+      await sleep(pollIntervalMs);
     }
   } finally {
     process.removeListener('SIGINT', onSigInt);

package/lib/governance/config-manager.js

@@ -52,6 +52,12 @@ class ConfigManager {
         'CHANGELOG.md',
         'CONTRIBUTING.md'
       ],
+      specAllowedRootFiles: [
+        'requirements.md',
+        'design.md',
+        'tasks.md',
+        'collaboration.json'
+      ],
       specSubdirs: [
         'reports',
         'scripts',
@@ -152,6 +158,10 @@ class ConfigManager {
     if (!config.specSubdirs || !Array.isArray(config.specSubdirs)) {
       errors.push('specSubdirs must be an array');
     }
+
+    if (!config.specAllowedRootFiles || !Array.isArray(config.specAllowedRootFiles)) {
+      errors.push('specAllowedRootFiles must be an array');
+    }
     
     if (!config.temporaryPatterns || !Array.isArray(config.temporaryPatterns)) {
       errors.push('temporaryPatterns must be an array');
@@ -169,6 +179,12 @@ class ConfigManager {
         errors.push('specSubdirs must contain only strings');
       }
     }
+
+    if (config.specAllowedRootFiles && Array.isArray(config.specAllowedRootFiles)) {
+      if (config.specAllowedRootFiles.some(f => typeof f !== 'string')) {
+        errors.push('specAllowedRootFiles must contain only strings');
+      }
+    }
     
     if (config.temporaryPatterns && Array.isArray(config.temporaryPatterns)) {
       if (config.temporaryPatterns.some(p => typeof p !== 'string')) {

package/lib/governance/diagnostic-engine.js

@@ -81,6 +81,7 @@ class DiagnosticEngine {
   async scanSpecDirectory(specPath) {
     const specName = path.basename(specPath);
     const requiredFiles = ['requirements.md', 'design.md', 'tasks.md'];
+    const allowedRootFiles = this.config.specAllowedRootFiles || requiredFiles;
     
     // Check for missing required files
     for (const requiredFile of requiredFiles) {
@@ -124,7 +125,7 @@ class DiagnosticEngine {
       const basename = path.basename(filePath);
       
       // Skip required files
-      if (requiredFiles.includes(basename)) {
+      if (allowedRootFiles.includes(basename)) {
         continue;
       }
       

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,