scene-capability-engine 3.6.39 → 3.6.44

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)
     )
   );

package/lib/commands/collab.js

@@ -90,7 +90,10 @@ function registerCollabCommands(program) {
             console.log(chalk.gray('Type:'), status.metadata.type);
             console.log(chalk.gray('Status:'), status.metadata.status.current);
             if (status.metadata.assignment) {
-              console.log(chalk.gray('Assigned to:'), status.metadata.assignment.sceInstance);
+              console.log(
+                chalk.gray('Assigned to:'),
+                status.metadata.assignment.sceInstance || status.metadata.assignment.kiroInstance
+              );
             }
             if (status.metadata.dependencies && status.metadata.dependencies.length > 0) {
               console.log(chalk.gray('Dependencies:'));
@@ -105,8 +108,11 @@ function registerCollabCommands(program) {
 
             for (const { name, metadata } of status.specs) {
               const symbol = getStatusSymbol(metadata.status.current);
+              const assignedInstance = metadata.assignment
+                ? (metadata.assignment.sceInstance || metadata.assignment.kiroInstance)
+                : null;
               const assignment = metadata.assignment 
-                ? chalk.gray(`(${metadata.assignment.sceInstance})`)
+                ? chalk.gray(`(${assignedInstance})`)
                 : chalk.gray('(unassigned)');
               console.log(`${symbol} ${name} ${assignment}`);
             }
@@ -127,12 +133,12 @@ function registerCollabCommands(program) {
   collab
     .command('assign <spec-name> <SCE-instance>')
     .description('Assign a spec to a SCE instance')
-    .action(async (specName, kiroInstance) => {
+    .action(async (specName, sceInstance) => {
       try {
         const workspaceRoot = process.cwd();
         const manager = new CollaborationManager(workspaceRoot);
 
-        const result = await manager.assignSpec(specName, kiroInstance);
+        const result = await manager.assignSpec(specName, sceInstance);
 
         if (result.success) {
           console.log(chalk.green('✓'), result.message);

package/lib/commands/status.js

@@ -30,10 +30,10 @@ async function statusCommand(options = {}) {
   
   try {
     // 1. Check if .sce/ exists
-    const kiroPath = path.join(projectPath, '.sce');
-    const kiroExists = await fs.pathExists(kiroPath);
+    const scePath = path.join(projectPath, '.sce');
+    const sceExists = await fs.pathExists(scePath);
     
-    if (!kiroExists) {
+    if (!sceExists) {
       console.log(chalk.yellow('⚠️  No .sce/ directory found'));
       console.log();
       console.log('This project has not been adopted yet.');

package/lib/commands/studio.js

@@ -502,6 +502,14 @@ async function buildReleaseGateSteps(options = {}, dependencies = {}) {
     required: true
   });
 
+  steps.push({
+    id: 'spec-delivery-audit',
+    name: 'spec delivery sync audit',
+    command: 'node',
+    args: ['bin/sce.js', 'workspace', 'delivery-audit', '--json', '--strict'],
+    required: true
+  });
+
   const gitManagedGateScript = path.join(projectPath, 'scripts', 'git-managed-gate.js');
   const hasGitManagedGateScript = await fileSystem.pathExists(gitManagedGateScript);
   steps.push({

package/lib/repo/config-manager.js

@@ -131,8 +131,8 @@ class ConfigManager {
 
     try {
       // Ensure .sce directory exists
-      const kiroDir = path.dirname(configPath);
-      await fs.mkdir(kiroDir, { recursive: true });
+      const sceDir = path.dirname(configPath);
+      await fs.mkdir(sceDir, { recursive: true });
 
       // Write configuration with pretty formatting
       const jsonContent = JSON.stringify(config, null, 2);

package/lib/spec/bootstrap/context-collector.js

@@ -7,14 +7,15 @@ class ContextCollector {
   }
 
   async collect() {
-    const kiroDir = path.join(this.projectPath, '.sce');
-    const specsDir = path.join(kiroDir, 'specs');
-    const hasKiro = await fs.pathExists(kiroDir);
+    const sceDir = path.join(this.projectPath, '.sce');
+    const specsDir = path.join(sceDir, 'specs');
+    const hasSceDir = await fs.pathExists(sceDir);
     const existingSpecs = await this._listSpecs(specsDir);
 
     return {
       projectPath: this.projectPath,
-      hasKiro,
+      hasSceDir,
+      hasKiro: hasSceDir,
       specsDir,
       existingSpecs,
       totalSpecs: existingSpecs.length,

package/lib/spec-gate/rules/default-rules.js

@@ -87,25 +87,25 @@ function createDefaultRules(projectPath = process.cwd()) {
       id: 'config_consistency',
       description: 'Verify project-level sce config baseline exists',
       async execute() {
-        const kiroDir = path.join(projectPath, '.sce');
-        const configDir = path.join(kiroDir, 'config');
-        const hasKiro = await fs.pathExists(kiroDir);
+        const sceDir = path.join(projectPath, '.sce');
+        const configDir = path.join(sceDir, 'config');
+        const hasSceDir = await fs.pathExists(sceDir);
         const hasConfig = await fs.pathExists(configDir);
 
-        const ratio = hasKiro && hasConfig ? 1 : hasKiro ? 0.5 : 0;
+        const ratio = hasSceDir && hasConfig ? 1 : hasSceDir ? 0.5 : 0;
         const warnings = [];
-        if (!hasKiro) {
+        if (!hasSceDir) {
           warnings.push('.sce directory missing');
         }
-        if (hasKiro && !hasConfig) {
+        if (hasSceDir && !hasConfig) {
           warnings.push('.sce/config directory missing');
         }
 
         return {
-          passed: hasKiro,
+          passed: hasSceDir,
           ratio,
           details: {
-            hasKiro,
+            hasSceDir,
             hasConfig
           },
           warnings