scene-capability-engine 3.6.38 → 3.6.44

package/lib/backup/backup-system.js

@@ -40,7 +40,7 @@ class BackupSystem {
    * @param {string} projectPath - Absolute path to project root
    * @returns {string} - Absolute path to .sce directory
    */
-  getKiroDir(projectPath) {
+  getSceDir(projectPath) {
     return path.join(projectPath, '.sce');
   }
 
@@ -74,11 +74,11 @@ class BackupSystem {
     const { type = 'manual' } = options;
     
     try {
-      const kiroDir = this.getKiroDir(projectPath);
+      const sceDir = this.getSceDir(projectPath);
       
       // Check if .sce/ exists
-      const kiroExists = await pathExists(kiroDir);
-      if (!kiroExists) {
+      const sceExists = await pathExists(sceDir);
+      if (!sceExists) {
         throw new Error('.sce/ directory does not exist');
       }
       
@@ -100,7 +100,7 @@ class BackupSystem {
       await ensureDirectory(backupPath);
       
       // Copy .sce/ contents to backup (excluding backups/ itself)
-      const items = await listFiles(kiroDir);
+      const items = await listFiles(sceDir);
       
       for (const item of items) {
         // Skip the backups directory itself
@@ -108,7 +108,7 @@ class BackupSystem {
           continue;
         }
         
-        const sourcePath = path.join(kiroDir, item);
+        const sourcePath = path.join(sceDir, item);
         const destPath = path.join(backupPath, item);
         
         await copyDirectory(sourcePath, destPath, { overwrite: false });
@@ -243,20 +243,20 @@ class BackupSystem {
         throw new Error(`Backup validation failed: ${backupId}`);
       }
       
-      const kiroDir = this.getKiroDir(projectPath);
+      const sceDir = this.getSceDir(projectPath);
       
       // Get list of items to restore (excluding metadata.json)
       const items = await listFiles(backupPath);
       const itemsToRestore = items.filter(item => item !== 'metadata.json');
       
       // Remove existing .sce/ contents (except backups/)
-      const existingItems = await listFiles(kiroDir);
+      const existingItems = await listFiles(sceDir);
       for (const item of existingItems) {
         if (item === this.backupDirName) {
           continue;
         }
         
-        const itemPath = path.join(kiroDir, item);
+        const itemPath = path.join(sceDir, item);
         await remove(itemPath);
       }
       
@@ -264,7 +264,7 @@ class BackupSystem {
       const restoredFiles = [];
       for (const item of itemsToRestore) {
         const sourcePath = path.join(backupPath, item);
-        const destPath = path.join(kiroDir, item);
+        const destPath = path.join(sceDir, item);
         
         await copyDirectory(sourcePath, destPath, { overwrite: true });
         restoredFiles.push(item);

package/lib/collab/collab-manager.js

@@ -125,10 +125,10 @@ class CollaborationManager {
   /**
    * Assign a spec to a SCE instance
    * @param {string} specName - Name of the spec
-   * @param {string} kiroInstance - SCE instance identifier
+   * @param {string} sceInstance - SCE instance identifier
    * @returns {Promise<Object>} Assignment result
    */
-  async assignSpec(specName, kiroInstance) {
+  async assignSpec(specName, sceInstance) {
     const metadata = await this.metadataManager.readMetadata(specName);
     
     if (!metadata) {
@@ -149,17 +149,20 @@ class CollaborationManager {
     // Update assignment
     const updated = await this.metadataManager.atomicUpdate(specName, (meta) => {
       meta.assignment = {
-        kiroInstance,
+        sceInstance,
         assignedAt: new Date().toISOString()
       };
+      if (meta.assignment && Object.prototype.hasOwnProperty.call(meta.assignment, 'kiroInstance')) {
+        delete meta.assignment.kiroInstance;
+      }
       return meta;
     });
 
     return {
       success: true,
       spec: specName,
-      kiroInstance,
-      message: `Assigned '${specName}' to '${kiroInstance}'`
+      sceInstance,
+      message: `Assigned '${specName}' to '${sceInstance}'`
     };
   }
 

package/lib/collab/dependency-manager.js

@@ -25,7 +25,7 @@ class DependencyManager {
       nodes.push({
         id: name,
         status: metadata.status?.current || 'not-started',
-        kiroInstance: metadata.assignment?.sceInstance || null,
+        sceInstance: metadata.assignment?.sceInstance || metadata.assignment?.kiroInstance || null,
         type: metadata.type
       });
 

package/lib/commands/adopt.js

@@ -220,7 +220,7 @@ async function adoptInteractive(projectPath, options) {
       console.log('    - Preserve existing specs/ and steering/');
       console.log('    - Add missing components');
       console.log('    - Create/update version.json');
-      if (detection.hasKiroDir) {
+      if (detection.hasSceDir) {
         console.log('    - Create backup before changes');
       }
     } else if (strategy === 'full') {
@@ -487,7 +487,7 @@ async function adoptInteractive(projectPath, options) {
     
     // 9. Create backup if needed (for non-conflict scenarios)
     let backupId = null;
-    if (detection.hasKiroDir && (strategy === 'partial' || strategy === 'full')) {
+    if (detection.hasSceDir && (strategy === 'partial' || strategy === 'full')) {
       console.log(chalk.blue('📦 Creating backup...'));
       const backupSystem = new BackupSystem();
       

package/lib/commands/auto.js

@@ -60,6 +60,7 @@ const fs = require('fs-extra');
 const path = require('path');
 const chalk = require('chalk');
 const { spawnSync } = require('child_process');
+const { auditSpecDeliverySync } = require('../workspace/spec-delivery-audit');
 
 const AUTO_ARCHIVE_SCHEMA_VERSION = '1.0';
 const AUTO_ARCHIVE_SCHEMA_SUPPORTED_VERSIONS = new Set([AUTO_ARCHIVE_SCHEMA_VERSION]);
@@ -95,6 +96,7 @@ const AUTO_HANDOFF_POLICY_PROFILE_PRESETS = {
     require_capability_coverage: true,
     require_capability_semantic: true,
     require_capability_lexicon: true,
+    require_spec_delivery_sync: true,
     require_release_gate_preflight: true,
     dependency_batching: true,
     release_evidence_window: 5
@@ -114,6 +116,7 @@ const AUTO_HANDOFF_POLICY_PROFILE_PRESETS = {
     require_capability_coverage: true,
     require_capability_semantic: true,
     require_capability_lexicon: true,
+    require_spec_delivery_sync: true,
     require_release_gate_preflight: true,
     dependency_batching: true,
     release_evidence_window: 5
@@ -133,6 +136,7 @@ const AUTO_HANDOFF_POLICY_PROFILE_PRESETS = {
     require_capability_coverage: true,
     require_capability_semantic: true,
     require_capability_lexicon: true,
+    require_spec_delivery_sync: true,
     require_release_gate_preflight: true,
     dependency_batching: true,
     release_evidence_window: 10
@@ -1983,6 +1987,8 @@ function registerAutoCommands(program) {
     .description('Evaluate release-gate preflight readiness from gate-history signals')
     .option('--profile <profile>', 'Handoff policy profile: default|moqui|enterprise (default: default)', 'default')
     .option('--history-file <path>', `Release gate history file (default: ${AUTO_HANDOFF_RELEASE_GATE_HISTORY_FILE})`)
+    .option('--require-spec-delivery-sync', 'Gate: require declared spec deliverables to be tracked, committed, and upstream-synced when manifests exist (default: enabled)')
+    .option('--no-require-spec-delivery-sync', 'Gate: disable spec delivery sync hard requirement (not recommended)')
     .option('--require-release-gate-preflight', 'Gate: require release-gate preflight signal to be available and unblocked (default: enabled)')
     .option('--no-require-release-gate-preflight', 'Gate: disable release-gate preflight hard requirement (not recommended)')
     .option('--release-evidence-window <n>', 'Release evidence trend window size (2-50, default from profile)', parseInt)
@@ -1997,10 +2003,15 @@ function registerAutoCommands(program) {
           console.log(chalk.blue('Auto handoff preflight check:'));
           console.log(chalk.gray(`  Status: ${result.status}`));
           console.log(chalk.gray(`  Profile: ${result.policy.profile}`));
+          console.log(chalk.gray(`  Spec delivery sync: ${result.policy.require_spec_delivery_sync ? 'enabled' : 'advisory'}`));
           console.log(chalk.gray(`  Hard-gate preflight: ${result.policy.require_release_gate_preflight ? 'enabled' : 'advisory'}`));
           console.log(chalk.gray(`  History file: ${result.release_gate_preflight.file || 'n/a'}`));
           console.log(chalk.gray(`  Preflight available: ${result.release_gate_preflight.available === true ? 'yes' : 'no'}`));
           console.log(chalk.gray(`  Preflight blocked: ${result.release_gate_preflight.blocked === true ? 'yes' : 'no'}`));
+          if (result.spec_delivery_sync) {
+            console.log(chalk.gray(`  Delivery manifests: ${result.spec_delivery_sync.summary.manifest_count}`));
+            console.log(chalk.gray(`  Delivery sync passed: ${result.spec_delivery_sync.passed === true ? 'yes' : 'no'}`));
+          }
           if (result.release_gate_preflight.latest_tag) {
             console.log(chalk.gray(`  Latest tag: ${result.release_gate_preflight.latest_tag}`));
           }
@@ -2088,6 +2099,8 @@ function registerAutoCommands(program) {
     .option('--no-require-capability-coverage', 'Gate: disable capability coverage requirement (not recommended)')
     .option('--require-capability-lexicon', 'Gate: require capability lexicon normalization (unknown expected/provided aliases not allowed, default: enabled)')
     .option('--no-require-capability-lexicon', 'Gate: disable capability lexicon normalization requirement (not recommended)')
+    .option('--require-spec-delivery-sync', 'Gate: require declared spec deliverables to be tracked, committed, and upstream-synced when manifests exist (default: enabled)')
+    .option('--no-require-spec-delivery-sync', 'Gate: disable spec delivery sync hard requirement (not recommended)')
     .option('--require-release-gate-preflight', 'Gate: require release-gate preflight signal to be available and unblocked (default: enabled)')
     .option('--no-require-release-gate-preflight', 'Gate: disable release-gate preflight hard requirement (not recommended)')
     .option('--release-evidence-window <n>', 'Release evidence trend window size (2-50, default: 5)', parseInt)
@@ -2108,6 +2121,10 @@ function registerAutoCommands(program) {
           if (result.template_diff) {
             console.log(chalk.gray(`  Template compatibility: ${result.template_diff.compatibility}`));
           }
+          if (result.spec_delivery_sync) {
+            console.log(chalk.gray(`  Delivery manifests: ${result.spec_delivery_sync.summary.manifest_count}`));
+            console.log(chalk.gray(`  Delivery sync passed: ${result.spec_delivery_sync.passed === true ? 'yes' : 'no'}`));
+          }
           if (result.dependency_execution && Array.isArray(result.dependency_execution.batches)) {
             console.log(chalk.gray(`  Execution batches: ${result.dependency_execution.batches.length}`));
           }
@@ -7326,6 +7343,10 @@ function buildAutoHandoffRunPolicy(options = {}) {
       options.requireCapabilityLexicon,
       preset.require_capability_lexicon
     ),
+    require_spec_delivery_sync: resolveAutoHandoffPolicyOptionBoolean(
+      options.requireSpecDeliverySync,
+      preset.require_spec_delivery_sync
+    ),
     require_release_gate_preflight: resolveAutoHandoffPolicyOptionBoolean(
       options.requireReleaseGatePreflight,
       preset.require_release_gate_preflight
@@ -7899,6 +7920,34 @@ function evaluateAutoHandoffReleaseGatePreflightGateReasons(policy = {}, preflig
   return reasons;
 }
 
+function evaluateAutoHandoffSpecDeliveryGateReasons(policy = {}, deliveryAudit = null) {
+  const reasons = [];
+  if (policy.require_spec_delivery_sync !== true) {
+    return reasons;
+  }
+
+  const snapshot = deliveryAudit && typeof deliveryAudit === 'object' && !Array.isArray(deliveryAudit)
+    ? deliveryAudit
+    : null;
+  if (!snapshot) {
+    reasons.push('spec delivery audit snapshot missing');
+    return reasons;
+  }
+  if (snapshot.reason === 'no-manifests') {
+    return reasons;
+  }
+  if (snapshot.passed !== true) {
+    const violations = Array.isArray(snapshot.violations) ? snapshot.violations : [];
+    if (violations.length > 0) {
+      reasons.push(...violations);
+    } else {
+      reasons.push('spec delivery sync audit reported violations');
+    }
+  }
+
+  return reasons;
+}
+
 function buildAutoHandoffReleaseGatePreflight(signals = null) {
   const source = signals && typeof signals === 'object' && !Array.isArray(signals)
     ? signals
@@ -7969,6 +8018,9 @@ function buildAutoHandoffPreflightCheckRecommendations(projectPath, result = {})
   const preflight = result && result.release_gate_preflight && typeof result.release_gate_preflight === 'object'
     ? result.release_gate_preflight
     : {};
+  const deliveryAudit = result && result.spec_delivery_sync && typeof result.spec_delivery_sync === 'object'
+    ? result.spec_delivery_sync
+    : {};
   const reasons = Array.isArray(result.reasons) ? result.reasons : [];
   const windowSize = Number.isInteger(policy.release_evidence_window)
     ? policy.release_evidence_window
@@ -7984,6 +8036,16 @@ function buildAutoHandoffPreflightCheckRecommendations(projectPath, result = {})
   if (result.status !== 'pass' || preflight.blocked === true) {
     push(`sce auto handoff evidence --window ${windowSize} --json`);
   }
+  if (
+    deliveryAudit.reason === 'missing-manifest' ||
+    deliveryAudit.reason === 'violations'
+  ) {
+    push('sce workspace delivery-audit --json --strict');
+  }
+  if (Number.isFinite(Number(deliveryAudit.git && deliveryAudit.git.ahead)) && Number(deliveryAudit.git.ahead) > 0) {
+    const branch = normalizeHandoffText(deliveryAudit.git && deliveryAudit.git.branch) || '<branch>';
+    push(`git push origin ${branch}`);
+  }
 
   if (preflight.blocked === true) {
     const governanceRecommendations = buildGovernanceCloseLoopRecommendations(
@@ -8014,23 +8076,41 @@ function buildAutoHandoffPreflightCheckRecommendations(projectPath, result = {})
       'Ensure release workflow publishes `release-gate-history.json` and rerun preflight check.'
     );
   }
+  if (reasons.some(item => `${item}`.includes('spec delivery'))) {
+    push(
+      'Declare feature deliverables in `.sce/specs/<spec>/deliverables.json`, commit tracked files, and push upstream before handoff.'
+    );
+  }
 
   return recommendations;
 }
 
 async function buildAutoHandoffPreflightCheck(projectPath, options = {}) {
   const policy = buildAutoHandoffRunPolicy(options);
+  const specDeliverySync = await auditSpecDeliverySync(projectPath, {
+    requireManifest: false
+  });
   const releaseGateSignals = await loadGovernanceReleaseGateSignals(projectPath, {
     historyFile: options.historyFile
   });
   const releaseGatePreflight = buildAutoHandoffReleaseGatePreflight(releaseGateSignals);
-  const hardGateReasons = evaluateAutoHandoffReleaseGatePreflightGateReasons(
-    policy,
-    releaseGatePreflight
-  );
+  const hardGateReasons = [
+    ...evaluateAutoHandoffSpecDeliveryGateReasons(policy, specDeliverySync),
+    ...evaluateAutoHandoffReleaseGatePreflightGateReasons(policy, releaseGatePreflight)
+  ];
 
   const advisoryReasons = [];
   if (hardGateReasons.length === 0) {
+    if (
+      policy.require_spec_delivery_sync !== true &&
+      specDeliverySync.reason !== 'no-manifests' &&
+      specDeliverySync.passed !== true
+    ) {
+      const deliveryReasons = Array.isArray(specDeliverySync.violations) && specDeliverySync.violations.length > 0
+        ? specDeliverySync.violations
+        : ['spec delivery sync audit reported warnings'];
+      advisoryReasons.push(...deliveryReasons.map((item) => `spec delivery sync advisory: ${item}`));
+    }
     if (releaseGatePreflight.parse_error) {
       advisoryReasons.push(`release gate preflight parse error: ${releaseGatePreflight.parse_error}`);
     } else if (releaseGatePreflight.available !== true) {
@@ -8055,9 +8135,11 @@ async function buildAutoHandoffPreflightCheck(projectPath, options = {}) {
     hard_gate_reasons: hardGateReasons,
     policy: {
       profile: policy.profile,
+      require_spec_delivery_sync: policy.require_spec_delivery_sync === true,
       require_release_gate_preflight: policy.require_release_gate_preflight === true,
       release_evidence_window: policy.release_evidence_window
     },
+    spec_delivery_sync: specDeliverySync,
     release_gate_preflight: releaseGatePreflight,
     signals: {
       history_file: releaseGateSignals.file || releaseGatePreflight.file || null,
@@ -8571,6 +8653,9 @@ function buildAutoHandoffRunRecommendations(projectPath, result) {
   const releaseGatePreflight = result && result.release_gate_preflight && typeof result.release_gate_preflight === 'object'
     ? result.release_gate_preflight
     : null;
+  const specDeliverySync = result && result.spec_delivery_sync && typeof result.spec_delivery_sync === 'object'
+    ? result.spec_delivery_sync
+    : null;
   if (releaseGatePreflight && releaseGatePreflight.blocked === true) {
     push('sce auto handoff evidence --window 5 --json');
     if (
@@ -8596,6 +8681,17 @@ function buildAutoHandoffRunRecommendations(projectPath, result) {
       '--out .sce/reports/release-evidence/release-gate-history.json --json'
     );
   }
+  if (
+    specDeliverySync &&
+    specDeliverySync.reason !== 'no-manifests' &&
+    specDeliverySync.passed !== true
+  ) {
+    push('sce workspace delivery-audit --json --strict');
+    if (Number.isFinite(Number(specDeliverySync.git && specDeliverySync.git.ahead)) && Number(specDeliverySync.git.ahead) > 0) {
+      const branch = normalizeHandoffText(specDeliverySync.git && specDeliverySync.git.branch) || '<branch>';
+      push(`git push origin ${branch}`);
+    }
+  }
 
   const riskLevel = result && result.gates && result.gates.actual && typeof result.gates.actual.risk_level === 'string'
     ? result.gates.actual.risk_level.trim().toLowerCase()
@@ -9888,6 +9984,8 @@ async function runAutoHandoff(projectPath, options = {}) {
     loadGovernanceReleaseGateSignals,
     completeAutoHandoffRunPhase,
     evaluateAutoHandoffOntologyGateReasons,
+    auditSpecDeliverySync,
+    evaluateAutoHandoffSpecDeliveryGateReasons,
     evaluateAutoHandoffReleaseGatePreflightGateReasons,
     failAutoHandoffRunPhase,
     buildAutoHandoffMoquiBaselineSnapshot,
@@ -11717,6 +11815,130 @@ async function loadGovernanceReleaseGateSignals(projectPath, options = {}) {
     const parsed = Number(value);
     return Number.isFinite(parsed) ? parsed : null;
   };
+  const buildSignalsSnapshot = ({ file, totalEntries, latest, aggregates, parseError = null }) => {
+    const latestRiskLevel = normalizeHandoffText(latest && latest.risk_level);
+    const latestWeeklyOpsRiskLevel = normalizeHandoffText(latest && latest.weekly_ops_risk_level);
+    const normalizedTotalEntries = Number.isFinite(Number(totalEntries))
+      ? Number(totalEntries)
+      : 0;
+    const hasEntries = normalizedTotalEntries > 0 || Boolean(latest);
+    return {
+      ...base,
+      available: hasEntries,
+      file: normalizeHandoffText(file) || base.file,
+      total_entries: normalizedTotalEntries,
+      latest_tag: normalizeHandoffText(latest && latest.tag) || null,
+      latest_gate_passed: parseAutoHandoffGateBoolean(latest && latest.gate_passed, null),
+      latest_risk_level: latestRiskLevel
+        ? normalizeAutoHandoffGateRiskLevel(latestRiskLevel)
+        : null,
+      pass_rate_percent: toNumber(aggregates && aggregates.pass_rate_percent),
+      scene_package_batch_pass_rate_percent: toNumber(
+        aggregates && aggregates.scene_package_batch_pass_rate_percent
+      ),
+      scene_package_batch_failed_count: toNumber(
+        aggregates && aggregates.scene_package_batch_failed_count
+      ),
+      drift_alert_rate_percent: toNumber(aggregates && aggregates.drift_alert_rate_percent),
+      drift_alert_runs: toNumber(aggregates && aggregates.drift_alert_runs),
+      drift_blocked_runs: toNumber(aggregates && aggregates.drift_blocked_runs),
+      latest_weekly_ops_blocked: parseAutoHandoffGateBoolean(latest && latest.weekly_ops_blocked, null),
+      latest_weekly_ops_risk_level: latestWeeklyOpsRiskLevel
+        ? normalizeAutoHandoffGateRiskLevel(latestWeeklyOpsRiskLevel)
+        : null,
+      latest_weekly_ops_governance_status: normalizeHandoffText(
+        latest && latest.weekly_ops_governance_status
+      ) || null,
+      latest_weekly_ops_authorization_tier_block_rate_percent: toNumber(
+        latest && latest.weekly_ops_authorization_tier_block_rate_percent
+      ),
+      latest_weekly_ops_dialogue_authorization_block_rate_percent: toNumber(
+        latest && latest.weekly_ops_dialogue_authorization_block_rate_percent
+      ),
+      latest_weekly_ops_config_warning_count: toNumber(
+        latest && latest.weekly_ops_config_warning_count
+      ),
+      latest_weekly_ops_runtime_block_rate_percent: toNumber(
+        latest && latest.weekly_ops_runtime_block_rate_percent
+      ),
+      latest_weekly_ops_runtime_ui_mode_violation_total: toNumber(
+        latest && latest.weekly_ops_runtime_ui_mode_violation_total
+      ),
+      latest_weekly_ops_runtime_ui_mode_violation_rate_percent: toNumber(
+        latest && latest.weekly_ops_runtime_ui_mode_violation_rate_percent
+      ),
+      weekly_ops_known_runs: toNumber(aggregates && aggregates.weekly_ops_known_runs),
+      weekly_ops_blocked_runs: toNumber(aggregates && aggregates.weekly_ops_blocked_runs),
+      weekly_ops_block_rate_percent: toNumber(aggregates && aggregates.weekly_ops_block_rate_percent),
+      weekly_ops_violations_total: toNumber(aggregates && aggregates.weekly_ops_violations_total),
+      weekly_ops_warnings_total: toNumber(aggregates && aggregates.weekly_ops_warnings_total),
+      weekly_ops_config_warnings_total: toNumber(
+        aggregates && aggregates.weekly_ops_config_warnings_total
+      ),
+      weekly_ops_authorization_tier_block_rate_max_percent: toNumber(
+        aggregates && aggregates.weekly_ops_authorization_tier_block_rate_max_percent
+      ),
+      weekly_ops_dialogue_authorization_block_rate_max_percent: toNumber(
+        aggregates && aggregates.weekly_ops_dialogue_authorization_block_rate_max_percent
+      ),
+      weekly_ops_runtime_block_rate_avg_percent: toNumber(
+        aggregates && aggregates.weekly_ops_runtime_block_rate_avg_percent
+      ),
+      weekly_ops_runtime_block_rate_max_percent: toNumber(
+        aggregates && aggregates.weekly_ops_runtime_block_rate_max_percent
+      ),
+      weekly_ops_runtime_ui_mode_violation_known_runs: toNumber(
+        aggregates && aggregates.weekly_ops_runtime_ui_mode_violation_known_runs
+      ),
+      weekly_ops_runtime_ui_mode_violation_runs: toNumber(
+        aggregates && aggregates.weekly_ops_runtime_ui_mode_violation_runs
+      ),
+      weekly_ops_runtime_ui_mode_violation_run_rate_percent: toNumber(
+        aggregates && aggregates.weekly_ops_runtime_ui_mode_violation_run_rate_percent
+      ),
+      weekly_ops_runtime_ui_mode_violation_total: toNumber(
+        aggregates && aggregates.weekly_ops_runtime_ui_mode_violation_total
+      ),
+      weekly_ops_runtime_ui_mode_violation_rate_avg_percent: toNumber(
+        aggregates && aggregates.weekly_ops_runtime_ui_mode_violation_rate_avg_percent
+      ),
+      weekly_ops_runtime_ui_mode_violation_rate_max_percent: toNumber(
+        aggregates && aggregates.weekly_ops_runtime_ui_mode_violation_rate_max_percent
+      ),
+      parse_error: parseError
+    };
+  };
+  const loadFallbackSnapshot = async (parseError = null) => {
+    const reportDir = path.dirname(historyFile);
+    const reportResult = await loadAutoHandoffReleaseGateReports(projectPath, reportDir);
+    const mergedEntries = mergeAutoHandoffReleaseGateHistoryEntries(reportResult.entries);
+    if (mergedEntries.length === 0) {
+      return parseError
+        ? {
+            ...base,
+            parse_error: parseError
+          }
+        : base;
+    }
+    mergedEntries.sort((left, right) => {
+      const leftTs = toAutoHandoffTimestamp(left && left.evaluated_at);
+      const rightTs = toAutoHandoffTimestamp(right && right.evaluated_at);
+      if (rightTs !== leftTs) {
+        return rightTs - leftTs;
+      }
+      const leftTag = normalizeHandoffText(left && left.tag) || '';
+      const rightTag = normalizeHandoffText(right && right.tag) || '';
+      return rightTag.localeCompare(leftTag);
+    });
+    const latest = mergedEntries[0] || null;
+    return buildSignalsSnapshot({
+      file: normalizeHandoffText(latest && latest.file) || reportDir,
+      totalEntries: mergedEntries.length,
+      latest,
+      aggregates: buildAutoHandoffReleaseGateHistoryAggregates(mergedEntries),
+      parseError: null
+    });
+  };
   const base = {
     available: false,
     file: historyFile,
@@ -11758,22 +11980,16 @@ async function loadGovernanceReleaseGateSignals(projectPath, options = {}) {
     parse_error: null
   };
   if (!(await fs.pathExists(historyFile))) {
-    return base;
+    return loadFallbackSnapshot();
   }
   let payload = null;
   try {
     payload = await fs.readJson(historyFile);
   } catch (error) {
-    return {
-      ...base,
-      parse_error: `${error.message}`
-    };
+    return loadFallbackSnapshot(`${error.message}`);
   }
   if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
-    return {
-      ...base,
-      parse_error: 'invalid release gate history payload'
-    };
+    return loadFallbackSnapshot('invalid release gate history payload');
   }
   const entries = Array.isArray(payload.entries) ? payload.entries : [];
   const latest = payload.latest && typeof payload.latest === 'object'
@@ -11782,86 +11998,16 @@ async function loadGovernanceReleaseGateSignals(projectPath, options = {}) {
   const aggregates = payload.aggregates && typeof payload.aggregates === 'object'
     ? payload.aggregates
     : {};
-  const latestRiskLevel = normalizeHandoffText(latest && latest.risk_level);
-  const latestWeeklyOpsRiskLevel = normalizeHandoffText(latest && latest.weekly_ops_risk_level);
-  return {
-    ...base,
-    available: true,
-    total_entries: toNumber(payload.total_entries) || entries.length,
-    latest_tag: normalizeHandoffText(latest && latest.tag) || null,
-    latest_gate_passed: parseAutoHandoffGateBoolean(latest && latest.gate_passed, null),
-    latest_risk_level: latestRiskLevel
-      ? normalizeAutoHandoffGateRiskLevel(latestRiskLevel)
-      : null,
-    pass_rate_percent: toNumber(aggregates.pass_rate_percent),
-    scene_package_batch_pass_rate_percent: toNumber(aggregates.scene_package_batch_pass_rate_percent),
-    scene_package_batch_failed_count: toNumber(aggregates.scene_package_batch_failed_count),
-    drift_alert_rate_percent: toNumber(aggregates.drift_alert_rate_percent),
-    drift_alert_runs: toNumber(aggregates.drift_alert_runs),
-    drift_blocked_runs: toNumber(aggregates.drift_blocked_runs),
-    latest_weekly_ops_blocked: parseAutoHandoffGateBoolean(latest && latest.weekly_ops_blocked, null),
-    latest_weekly_ops_risk_level: latestWeeklyOpsRiskLevel
-      ? normalizeAutoHandoffGateRiskLevel(latestWeeklyOpsRiskLevel)
-      : null,
-    latest_weekly_ops_governance_status: normalizeHandoffText(
-      latest && latest.weekly_ops_governance_status
-    ) || null,
-    latest_weekly_ops_authorization_tier_block_rate_percent: toNumber(
-      latest && latest.weekly_ops_authorization_tier_block_rate_percent
-    ),
-    latest_weekly_ops_dialogue_authorization_block_rate_percent: toNumber(
-      latest && latest.weekly_ops_dialogue_authorization_block_rate_percent
-    ),
-    latest_weekly_ops_config_warning_count: toNumber(
-      latest && latest.weekly_ops_config_warning_count
-    ),
-    latest_weekly_ops_runtime_block_rate_percent: toNumber(
-      latest && latest.weekly_ops_runtime_block_rate_percent
-    ),
-    latest_weekly_ops_runtime_ui_mode_violation_total: toNumber(
-      latest && latest.weekly_ops_runtime_ui_mode_violation_total
-    ),
-    latest_weekly_ops_runtime_ui_mode_violation_rate_percent: toNumber(
-      latest && latest.weekly_ops_runtime_ui_mode_violation_rate_percent
-    ),
-    weekly_ops_known_runs: toNumber(aggregates.weekly_ops_known_runs),
-    weekly_ops_blocked_runs: toNumber(aggregates.weekly_ops_blocked_runs),
-    weekly_ops_block_rate_percent: toNumber(aggregates.weekly_ops_block_rate_percent),
-    weekly_ops_violations_total: toNumber(aggregates.weekly_ops_violations_total),
-    weekly_ops_warnings_total: toNumber(aggregates.weekly_ops_warnings_total),
-    weekly_ops_config_warnings_total: toNumber(aggregates.weekly_ops_config_warnings_total),
-    weekly_ops_authorization_tier_block_rate_max_percent: toNumber(
-      aggregates.weekly_ops_authorization_tier_block_rate_max_percent
-    ),
-    weekly_ops_dialogue_authorization_block_rate_max_percent: toNumber(
-      aggregates.weekly_ops_dialogue_authorization_block_rate_max_percent
-    ),
-    weekly_ops_runtime_block_rate_avg_percent: toNumber(
-      aggregates.weekly_ops_runtime_block_rate_avg_percent
-    ),
-    weekly_ops_runtime_block_rate_max_percent: toNumber(
-      aggregates.weekly_ops_runtime_block_rate_max_percent
-    ),
-    weekly_ops_runtime_ui_mode_violation_known_runs: toNumber(
-      aggregates.weekly_ops_runtime_ui_mode_violation_known_runs
-    ),
-    weekly_ops_runtime_ui_mode_violation_runs: toNumber(
-      aggregates.weekly_ops_runtime_ui_mode_violation_runs
-    ),
-    weekly_ops_runtime_ui_mode_violation_run_rate_percent: toNumber(
-      aggregates.weekly_ops_runtime_ui_mode_violation_run_rate_percent
-    ),
-    weekly_ops_runtime_ui_mode_violation_total: toNumber(
-      aggregates.weekly_ops_runtime_ui_mode_violation_total
-    ),
-    weekly_ops_runtime_ui_mode_violation_rate_avg_percent: toNumber(
-      aggregates.weekly_ops_runtime_ui_mode_violation_rate_avg_percent
-    ),
-    weekly_ops_runtime_ui_mode_violation_rate_max_percent: toNumber(
-      aggregates.weekly_ops_runtime_ui_mode_violation_rate_max_percent
-    ),
-    parse_error: null
-  };
+  if (entries.length === 0 && !latest) {
+    return loadFallbackSnapshot();
+  }
+  return buildSignalsSnapshot({
+    file: historyFile,
+    totalEntries: toNumber(payload.total_entries) || entries.length,
+    latest,
+    aggregates,
+    parseError: null
+  });
 }
 
 async function loadGovernanceHandoffQualitySignals(projectPath) {
@@ -12799,9 +12945,6 @@ function evaluateGovernanceReleaseGateBlockState(assessment) {
     ) {
       reasons.push(`scene-batch-pass-rate-low:${snapshot.scene_package_batch_pass_rate_percent}`);
     }
-    if (Number.isFinite(snapshot.drift_alert_rate_percent) && snapshot.drift_alert_rate_percent > 0) {
-      reasons.push(`drift-alert-rate-positive:${snapshot.drift_alert_rate_percent}`);
-    }
     if (Number.isFinite(snapshot.drift_blocked_runs) && snapshot.drift_blocked_runs > 0) {
       reasons.push(`drift-blocked-runs-positive:${snapshot.drift_blocked_runs}`);
     }
@@ -12995,7 +13138,6 @@ function evaluateGovernanceReleaseGateBlockState(assessment) {
     snapshot.available === true &&
     (
       snapshot.latest_gate_passed === false ||
-      (Number.isFinite(snapshot.drift_alert_rate_percent) && snapshot.drift_alert_rate_percent > 0) ||
       (Number.isFinite(snapshot.drift_blocked_runs) && snapshot.drift_blocked_runs > 0)
     )
   );