scene-capability-engine 3.0.2 → 3.0.4

package/lib/commands/auto.js

@@ -1538,6 +1538,8 @@ function registerAutoCommands(program) {
     .option('--min-capability-semantic <n>', 'Minimum Moqui capability semantic completeness percent (default: 100)', parseFloat)
     .option('--require-capability-semantic', 'Require capability semantic completeness gate (default: enabled)')
     .option('--no-require-capability-semantic', 'Disable capability semantic completeness gate (not recommended)')
+    .option('--require-capability-lexicon', 'Require capability lexicon normalization gate (default: enabled)')
+    .option('--no-require-capability-lexicon', 'Disable capability lexicon normalization gate (not recommended)')
     .option('--format <type>', 'Matrix report format: json|markdown (default: json)', 'json')
     .option('--out <path>', 'Write matrix report output file')
     .option('--remediation-queue-out <path>', `Write remediation queue lines (default: ${AUTO_HANDOFF_MOQUI_REMEDIATION_QUEUE_FILE})`, AUTO_HANDOFF_MOQUI_REMEDIATION_QUEUE_FILE)
@@ -1586,6 +1588,9 @@ function registerAutoCommands(program) {
           if (result.gates && result.gates.capability_semantic) {
             console.log(chalk.gray(`  Semantic gate: ${result.gates.capability_semantic.passed ? 'pass' : 'fail'}`));
           }
+          if (result.gates && result.gates.capability_lexicon) {
+            console.log(chalk.gray(`  Lexicon gate: ${result.gates.capability_lexicon.passed ? 'pass' : 'fail'}`));
+          }
           if (result.remediation_queue && result.remediation_queue.file) {
             console.log(chalk.gray(`  Remediation queue: ${result.remediation_queue.file} (${result.remediation_queue.goal_count})`));
           }
@@ -1748,6 +1753,15 @@ function registerAutoCommands(program) {
               ? `${moquiSummary.valid_rate_percent}%`
               : 'n/a';
             console.log(chalk.gray(`    Portfolio: ${moquiSummary.portfolio_passed === true ? 'pass' : 'fail'} | avg=${scoreText} | valid-rate=${validRateText}`));
+            const entityRateText = formatAutoHandoffMoquiCoverageMetric(moquiSummary, 'entity_coverage', 'rate_percent', '%');
+            const ruleClosedRateText = formatAutoHandoffMoquiCoverageMetric(moquiSummary, 'business_rule_closed', 'rate_percent', '%');
+            const decisionClosedRateText = formatAutoHandoffMoquiCoverageMetric(moquiSummary, 'decision_closed', 'rate_percent', '%');
+            console.log(chalk.gray(`    Coverage: entity=${entityRateText} | rule-closed=${ruleClosedRateText} | decision-closed=${decisionClosedRateText}`));
+            const regressionText = formatAutoHandoffMoquiCoverageRegressions(
+              moquiBaseline && moquiBaseline.compare ? moquiBaseline.compare : {},
+              3
+            );
+            console.log(chalk.gray(`    Regressions: ${regressionText}`));
           }
         }
         if (result.current_overview && result.current_overview.scene_package_batch) {
@@ -1883,11 +1897,14 @@ function registerAutoCommands(program) {
     .option('--no-require-ontology-validation', 'Gate: disable manifest ontology_validation requirement (not recommended)')
     .option('--require-moqui-baseline', 'Gate: require Moqui baseline portfolio to pass (default: enabled)')
     .option('--no-require-moqui-baseline', 'Gate: disable Moqui baseline portfolio requirement (not recommended)')
+    .option('--max-moqui-matrix-regressions <n>', 'Gate: maximum allowed Moqui matrix regression signals (default: 0)', parseInt)
     .option('--require-scene-package-batch', 'Gate: require scene package publish-batch dry-run gate to pass when applicable (default: enabled)')
     .option('--no-require-scene-package-batch', 'Gate: disable scene package publish-batch dry-run requirement (not recommended)')
     .option('--min-capability-coverage <n>', 'Gate: minimum Moqui capability coverage percent (default: 100)', parseFloat)
     .option('--require-capability-coverage', 'Gate: require capability coverage threshold when capabilities are declared (default: enabled)')
     .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-release-gate-preflight', 'Gate: require release-gate preflight signal to be available and unblocked (default: disabled/advisory)')
     .option('--no-require-release-gate-preflight', 'Gate: disable release-gate preflight hard requirement (default)')
     .option('--release-evidence-window <n>', 'Release evidence trend window size (2-50, default: 5)', parseInt)
@@ -1939,6 +1956,15 @@ function registerAutoCommands(program) {
                 ? `${baselineSummary.valid_rate_percent}%`
                 : 'n/a';
               console.log(chalk.gray(`    Portfolio: ${baselineSummary.portfolio_passed ? 'pass' : 'fail'} | avg=${scoreText} | valid-rate=${validRateText}`));
+              const entityRateText = formatAutoHandoffMoquiCoverageMetric(baselineSummary, 'entity_coverage', 'rate_percent', '%');
+              const ruleClosedRateText = formatAutoHandoffMoquiCoverageMetric(baselineSummary, 'business_rule_closed', 'rate_percent', '%');
+              const decisionClosedRateText = formatAutoHandoffMoquiCoverageMetric(baselineSummary, 'decision_closed', 'rate_percent', '%');
+              console.log(chalk.gray(`    Coverage: entity=${entityRateText} | rule-closed=${ruleClosedRateText} | decision-closed=${decisionClosedRateText}`));
+              const regressionText = formatAutoHandoffMoquiCoverageRegressions(
+                result.moqui_baseline && result.moqui_baseline.compare ? result.moqui_baseline.compare : {},
+                3
+              );
+              console.log(chalk.gray(`    Regressions: ${regressionText}`));
             }
             if (result.moqui_baseline.output && result.moqui_baseline.output.json) {
               console.log(chalk.gray(`    Baseline report: ${result.moqui_baseline.output.json}`));
@@ -8096,6 +8122,13 @@ function buildAutoHandoffRegressionSnapshot(report) {
       ? scenePackageBatch.status
       : gateActual.scene_package_batch_status
   );
+  const moquiBaseline = payload && payload.moqui_baseline ? payload.moqui_baseline : {};
+  const moquiCompare = moquiBaseline && moquiBaseline.compare ? moquiBaseline.compare : {};
+  const moquiMatrixRegressionCount = Number(
+    gateActual.moqui_matrix_regression_count !== undefined
+      ? gateActual.moqui_matrix_regression_count
+      : buildAutoHandoffMoquiCoverageRegressions(moquiCompare).length
+  );
   let sceneBatchPassed = null;
   if (sceneBatchStatus && sceneBatchStatus !== 'skipped') {
     sceneBatchPassed = sceneBatchStatus === 'passed';
@@ -8119,6 +8152,7 @@ function buildAutoHandoffRegressionSnapshot(report) {
     ontology_undecided_decisions: Number.isFinite(ontologyUndecidedDecisions) ? ontologyUndecidedDecisions : null,
     ontology_business_rule_pass_rate_percent: Number.isFinite(businessRulePassRate) ? businessRulePassRate : null,
     ontology_decision_resolved_rate_percent: Number.isFinite(decisionResolvedRate) ? decisionResolvedRate : null,
+    moqui_matrix_regression_count: Number.isFinite(moquiMatrixRegressionCount) ? moquiMatrixRegressionCount : null,
     scene_package_batch_status: sceneBatchStatus || null,
     scene_package_batch_passed: typeof sceneBatchPassed === 'boolean' ? sceneBatchPassed : null,
     scene_package_batch_failure_count: Number.isFinite(sceneBatchFailureCount) ? sceneBatchFailureCount : null,
@@ -8193,6 +8227,12 @@ function buildAutoHandoffRegressionComparison(currentSnapshot, previousSnapshot)
   )
     ? currentSnapshot.scene_package_batch_failure_count - previousSnapshot.scene_package_batch_failure_count
     : null;
+  const deltaMoquiMatrixRegressionCount = (
+    Number.isFinite(currentSnapshot.moqui_matrix_regression_count) &&
+    Number.isFinite(previousSnapshot.moqui_matrix_regression_count)
+  )
+    ? currentSnapshot.moqui_matrix_regression_count - previousSnapshot.moqui_matrix_regression_count
+    : null;
 
   let trend = 'stable';
   if (
@@ -8212,7 +8252,8 @@ function buildAutoHandoffRegressionComparison(currentSnapshot, previousSnapshot)
     (deltaOntologyQualityScore !== null && deltaOntologyQualityScore < 0) ||
     (deltaOntologyUnmappedRules !== null && deltaOntologyUnmappedRules > 0) ||
     (deltaOntologyUndecidedDecisions !== null && deltaOntologyUndecidedDecisions > 0) ||
-    (deltaSceneBatchFailureCount !== null && deltaSceneBatchFailureCount > 0)
+    (deltaSceneBatchFailureCount !== null && deltaSceneBatchFailureCount > 0) ||
+    (deltaMoquiMatrixRegressionCount !== null && deltaMoquiMatrixRegressionCount > 0)
   ) {
     trend = 'degraded';
   }
@@ -8229,6 +8270,7 @@ function buildAutoHandoffRegressionComparison(currentSnapshot, previousSnapshot)
       ontology_undecided_decisions: deltaOntologyUndecidedDecisions,
       ontology_business_rule_pass_rate_percent: deltaBusinessRulePassRate,
       ontology_decision_resolved_rate_percent: deltaDecisionResolvedRate,
+      moqui_matrix_regression_count: deltaMoquiMatrixRegressionCount,
       scene_package_batch_failure_count: deltaSceneBatchFailureCount
     }
   };
@@ -8249,6 +8291,7 @@ function buildAutoHandoffRegressionWindowTrend(series = []) {
         ontology_undecided_decisions: null,
         ontology_business_rule_pass_rate_percent: null,
         ontology_decision_resolved_rate_percent: null,
+        moqui_matrix_regression_count: null,
         scene_package_batch_failure_count: null
       },
       has_baseline: false
@@ -8290,6 +8333,9 @@ function buildAutoHandoffRegressionAggregates(series = []) {
   const sceneBatchFailures = snapshots
     .map(item => Number(item.scene_package_batch_failure_count))
     .filter(value => Number.isFinite(value));
+  const moquiMatrixRegressions = snapshots
+    .map(item => Number(item.moqui_matrix_regression_count))
+    .filter(value => Number.isFinite(value));
   const sceneBatchApplicables = snapshots.filter(item => typeof item.scene_package_batch_passed === 'boolean');
   const sceneBatchPassedCount = sceneBatchApplicables.filter(item => item.scene_package_batch_passed === true).length;
   const sceneBatchFailedCount = sceneBatchApplicables.filter(item => item.scene_package_batch_passed === false).length;
@@ -8332,6 +8378,9 @@ function buildAutoHandoffRegressionAggregates(series = []) {
   const averageSceneBatchFailures = sceneBatchFailures.length > 0
     ? Number((sceneBatchFailures.reduce((sum, value) => sum + value, 0) / sceneBatchFailures.length).toFixed(2))
     : null;
+  const averageMoquiMatrixRegressions = moquiMatrixRegressions.length > 0
+    ? Number((moquiMatrixRegressions.reduce((sum, value) => sum + value, 0) / moquiMatrixRegressions.length).toFixed(2))
+    : null;
   const sceneBatchPassRate = sceneBatchApplicables.length > 0
     ? Number(((sceneBatchPassedCount / sceneBatchApplicables.length) * 100).toFixed(2))
     : null;
@@ -8356,6 +8405,8 @@ function buildAutoHandoffRegressionAggregates(series = []) {
     scene_package_batch_pass_rate_percent: sceneBatchPassRate,
     avg_scene_package_batch_failure_count: averageSceneBatchFailures,
     max_scene_package_batch_failure_count: sceneBatchFailures.length > 0 ? Math.max(...sceneBatchFailures) : null,
+    avg_moqui_matrix_regression_count: averageMoquiMatrixRegressions,
+    max_moqui_matrix_regression_count: moquiMatrixRegressions.length > 0 ? Math.max(...moquiMatrixRegressions) : null,
     risk_levels: riskLevels
   };
 }
@@ -8382,6 +8433,9 @@ function buildAutoHandoffRegressionRiskLayers(series = []) {
     const sceneBatchFailures = scoped
       .map(item => Number(item.scene_package_batch_failure_count))
       .filter(value => Number.isFinite(value));
+    const moquiMatrixRegressions = scoped
+      .map(item => Number(item.moqui_matrix_regression_count))
+      .filter(value => Number.isFinite(value));
     const sceneBatchApplicable = scoped.filter(item => typeof item.scene_package_batch_passed === 'boolean');
     const sceneBatchPassed = sceneBatchApplicable.filter(item => item.scene_package_batch_passed === true).length;
 
@@ -8400,6 +8454,8 @@ function buildAutoHandoffRegressionRiskLayers(series = []) {
       avg_failed_goals: avg(failedGoals),
       avg_ontology_quality_score: avg(ontologyScores),
       avg_scene_package_batch_failure_count: avg(sceneBatchFailures),
+      avg_moqui_matrix_regression_count: avg(moquiMatrixRegressions),
+      max_moqui_matrix_regression_count: moquiMatrixRegressions.length > 0 ? Math.max(...moquiMatrixRegressions) : null,
       scene_package_batch_pass_rate_percent: sceneBatchApplicable.length > 0
         ? Number(((sceneBatchPassed / sceneBatchApplicable.length) * 100).toFixed(2))
         : null
@@ -8432,6 +8488,7 @@ function buildAutoHandoffRegressionRecommendations(payload = {}) {
   const ontologyUnmappedRules = Number(current.ontology_unmapped_rules);
   const ontologyUndecidedDecisions = Number(current.ontology_undecided_decisions);
   const sceneBatchFailureCount = Number(current.scene_package_batch_failure_count);
+  const moquiMatrixRegressionCount = Number(current.moqui_matrix_regression_count);
   const sceneBatchPassed = current.scene_package_batch_passed;
 
   if (trend === 'degraded' || windowTrend === 'degraded') {
@@ -8465,6 +8522,12 @@ function buildAutoHandoffRegressionRecommendations(payload = {}) {
       '`sce scene package-publish-batch --manifest docs/handoffs/handoff-manifest.json --dry-run --json`.'
     );
   }
+  if (Number.isFinite(moquiMatrixRegressionCount) && moquiMatrixRegressionCount > 0) {
+    push(
+      'Recover Moqui matrix regressions and rerun baseline gate: ' +
+      '`sce scene moqui-baseline --include-all --compare-with .kiro/reports/release-evidence/moqui-template-baseline.json --json`.'
+    );
+  }
 
   if ((payload.window && Number(payload.window.actual) > 0) && (payload.window.requested !== payload.window.actual)) {
     push('Increase regression coverage with `sce auto handoff regression --window 10 --json`.');
@@ -8483,6 +8546,137 @@ function formatAutoHandoffRegressionValue(value, fallback = 'n/a') {
   return `${value}`;
 }
 
+function getAutoHandoffMoquiCoverageMatrix(summary = {}) {
+  if (!summary || typeof summary !== 'object') {
+    return {};
+  }
+  return summary.coverage_matrix && typeof summary.coverage_matrix === 'object'
+    ? summary.coverage_matrix
+    : {};
+}
+
+function getAutoHandoffMoquiCoverageMetric(summary = {}, metricName = '', field = 'rate_percent') {
+  const matrix = getAutoHandoffMoquiCoverageMatrix(summary);
+  const metric = matrix && matrix[metricName] && typeof matrix[metricName] === 'object'
+    ? matrix[metricName]
+    : {};
+  const value = Number(metric[field]);
+  return Number.isFinite(value) ? value : null;
+}
+
+function formatAutoHandoffMoquiCoverageMetric(summary = {}, metricName = '', field = 'rate_percent', suffix = '') {
+  const value = getAutoHandoffMoquiCoverageMetric(summary, metricName, field);
+  if (!Number.isFinite(value)) {
+    return 'n/a';
+  }
+  return `${value}${suffix}`;
+}
+
+function getAutoHandoffMoquiCoverageDeltaMatrix(compare = {}) {
+  if (!compare || typeof compare !== 'object') {
+    return {};
+  }
+  return compare.coverage_matrix_deltas && typeof compare.coverage_matrix_deltas === 'object'
+    ? compare.coverage_matrix_deltas
+    : {};
+}
+
+function getAutoHandoffMoquiCoverageDeltaMetric(compare = {}, metricName = '', field = 'rate_percent') {
+  const matrix = getAutoHandoffMoquiCoverageDeltaMatrix(compare);
+  const metric = matrix && matrix[metricName] && typeof matrix[metricName] === 'object'
+    ? matrix[metricName]
+    : {};
+  const value = Number(metric[field]);
+  return Number.isFinite(value) ? value : null;
+}
+
+function formatAutoHandoffMoquiCoverageDeltaMetric(compare = {}, metricName = '', field = 'rate_percent', suffix = '') {
+  const value = getAutoHandoffMoquiCoverageDeltaMetric(compare, metricName, field);
+  if (!Number.isFinite(value)) {
+    return 'n/a';
+  }
+  return `${value}${suffix}`;
+}
+
+function getAutoHandoffMoquiCoverageMetricLabel(metricName = '') {
+  const labels = {
+    graph_valid: 'graph-valid',
+    score_passed: 'score-passed',
+    entity_coverage: 'entity-coverage',
+    relation_coverage: 'relation-coverage',
+    business_rule_coverage: 'business-rule-coverage',
+    business_rule_closed: 'business-rule-closed',
+    decision_coverage: 'decision-coverage',
+    decision_closed: 'decision-closed',
+    baseline_passed: 'baseline-passed'
+  };
+  return labels[metricName] || metricName;
+}
+
+function buildAutoHandoffMoquiCoverageRegressions(compare = {}) {
+  const source = compare && typeof compare === 'object' ? compare : {};
+  const predefined = Array.isArray(source.coverage_matrix_regressions)
+    ? source.coverage_matrix_regressions
+    : null;
+  if (predefined) {
+    const normalized = predefined
+      .map(item => {
+        const metric = normalizeHandoffText(item && item.metric);
+        const deltaRate = Number(item && item.delta_rate_percent);
+        if (!metric || !Number.isFinite(deltaRate) || deltaRate >= 0) {
+          return null;
+        }
+        return {
+          metric,
+          label: normalizeHandoffText(item && item.label) || getAutoHandoffMoquiCoverageMetricLabel(metric),
+          delta_rate_percent: Number(deltaRate.toFixed(2))
+        };
+      })
+      .filter(Boolean);
+    if (normalized.length > 0) {
+      return normalized.sort((a, b) => {
+        if (a.delta_rate_percent !== b.delta_rate_percent) {
+          return a.delta_rate_percent - b.delta_rate_percent;
+        }
+        return `${a.metric}`.localeCompare(`${b.metric}`);
+      });
+    }
+  }
+
+  const deltaMatrix = getAutoHandoffMoquiCoverageDeltaMatrix(source);
+  return Object.entries(deltaMatrix)
+    .map(([metric, value]) => {
+      const deltaRate = Number(value && value.rate_percent);
+      if (!Number.isFinite(deltaRate) || deltaRate >= 0) {
+        return null;
+      }
+      return {
+        metric,
+        label: getAutoHandoffMoquiCoverageMetricLabel(metric),
+        delta_rate_percent: Number(deltaRate.toFixed(2))
+      };
+    })
+    .filter(Boolean)
+    .sort((a, b) => {
+      if (a.delta_rate_percent !== b.delta_rate_percent) {
+        return a.delta_rate_percent - b.delta_rate_percent;
+      }
+      return `${a.metric}`.localeCompare(`${b.metric}`);
+    });
+}
+
+function formatAutoHandoffMoquiCoverageRegressions(compare = {}, limit = 3) {
+  const regressions = buildAutoHandoffMoquiCoverageRegressions(compare);
+  if (regressions.length === 0) {
+    return 'none';
+  }
+  const maxItems = Number.isFinite(Number(limit)) && Number(limit) > 0 ? Number(limit) : regressions.length;
+  return regressions
+    .slice(0, maxItems)
+    .map(item => `${item.label}:${item.delta_rate_percent}%`)
+    .join(' | ');
+}
+
 function renderAutoHandoffRegressionAsciiBar(value, max = 100, width = 20) {
   const parsed = Number(value);
   if (!Number.isFinite(parsed)) {
@@ -8530,7 +8724,8 @@ function renderAutoHandoffRegressionMarkdown(payload = {}) {
       `avg_success=${formatAutoHandoffRegressionValue(scoped.avg_spec_success_rate_percent)}, ` +
       `avg_failed_goals=${formatAutoHandoffRegressionValue(scoped.avg_failed_goals)}, ` +
       `avg_ontology_quality=${formatAutoHandoffRegressionValue(scoped.avg_ontology_quality_score)}, ` +
-      `scene_batch_pass_rate=${formatAutoHandoffRegressionValue(scoped.scene_package_batch_pass_rate_percent)}%`
+      `scene_batch_pass_rate=${formatAutoHandoffRegressionValue(scoped.scene_package_batch_pass_rate_percent)}%, ` +
+      `avg_moqui_matrix_regressions=${formatAutoHandoffRegressionValue(scoped.avg_moqui_matrix_regression_count, '0')}`
     );
   });
 
@@ -8551,6 +8746,7 @@ function renderAutoHandoffRegressionMarkdown(payload = {}) {
     `- Ontology quality delta: ${formatAutoHandoffRegressionValue(delta.ontology_quality_score)}`,
     `- Ontology unmapped rules delta: ${formatAutoHandoffRegressionValue(delta.ontology_unmapped_rules)}`,
     `- Ontology undecided decisions delta: ${formatAutoHandoffRegressionValue(delta.ontology_undecided_decisions)}`,
+    `- Moqui matrix regression count delta: ${formatAutoHandoffRegressionValue(delta.moqui_matrix_regression_count)}`,
     `- Scene package batch failure count delta: ${formatAutoHandoffRegressionValue(delta.scene_package_batch_failure_count)}`,
     '',
     '## Window Trend',
@@ -8559,6 +8755,7 @@ function renderAutoHandoffRegressionMarkdown(payload = {}) {
     `- Success rate delta: ${formatAutoHandoffRegressionValue(windowTrend.delta && windowTrend.delta.spec_success_rate_percent)}`,
     `- Risk level rank delta: ${formatAutoHandoffRegressionValue(windowTrend.delta && windowTrend.delta.risk_level_rank)}`,
     `- Failed goals delta: ${formatAutoHandoffRegressionValue(windowTrend.delta && windowTrend.delta.failed_goals)}`,
+    `- Moqui matrix regression count delta: ${formatAutoHandoffRegressionValue(windowTrend.delta && windowTrend.delta.moqui_matrix_regression_count)}`,
     '',
     '## Aggregates',
     '',
@@ -8578,6 +8775,8 @@ function renderAutoHandoffRegressionMarkdown(payload = {}) {
     `- Scene package batch pass rate: ${formatAutoHandoffRegressionValue(aggregates.scene_package_batch_pass_rate_percent)}%`,
     `- Scene package batch failed sessions: ${formatAutoHandoffRegressionValue(aggregates.scene_package_batch_failed_count, '0')}`,
     `- Avg scene package batch failure count: ${formatAutoHandoffRegressionValue(aggregates.avg_scene_package_batch_failure_count)}`,
+    `- Avg Moqui matrix regression count: ${formatAutoHandoffRegressionValue(aggregates.avg_moqui_matrix_regression_count)}`,
+    `- Max Moqui matrix regression count: ${formatAutoHandoffRegressionValue(aggregates.max_moqui_matrix_regression_count)}`,
     `- Risk levels: low=${formatAutoHandoffRegressionValue(riskLevels.low, '0')}, medium=${formatAutoHandoffRegressionValue(riskLevels.medium, '0')}, high=${formatAutoHandoffRegressionValue(riskLevels.high, '0')}, unknown=${formatAutoHandoffRegressionValue(riskLevels.unknown, '0')}`,
     '',
     '## Trend Series',
@@ -8755,6 +8954,24 @@ function buildAutoHandoffReleaseGateHistoryEntry(entry = {}, options = {}) {
       ? entry.scene_package_batch_failure_count
       : signalMap.scene_package_batch_failure_count
   );
+  const capabilityExpectedUnknownCount = parseAutoHandoffGateNumber(
+    entry.capability_expected_unknown_count !== undefined
+      ? entry.capability_expected_unknown_count
+      : (
+        signalMap.capability_expected_unknown_count !== undefined
+          ? signalMap.capability_expected_unknown_count
+          : signalMap.capability_lexicon_expected_unknown_count
+      )
+  );
+  const capabilityProvidedUnknownCount = parseAutoHandoffGateNumber(
+    entry.capability_provided_unknown_count !== undefined
+      ? entry.capability_provided_unknown_count
+      : (
+        signalMap.capability_provided_unknown_count !== undefined
+          ? signalMap.capability_provided_unknown_count
+          : signalMap.capability_lexicon_provided_unknown_count
+      )
+  );
   const releaseGatePreflightAvailable = parseAutoHandoffGateBoolean(
     entry.release_gate_preflight_available !== undefined
       ? entry.release_gate_preflight_available
@@ -8859,6 +9076,12 @@ function buildAutoHandoffReleaseGateHistoryEntry(entry = {}, options = {}) {
     scene_package_batch_status: sceneBatchStatus || null,
     scene_package_batch_passed: typeof sceneBatchPassed === 'boolean' ? sceneBatchPassed : null,
     scene_package_batch_failure_count: Number.isFinite(sceneBatchFailureCount) ? sceneBatchFailureCount : null,
+    capability_expected_unknown_count: Number.isFinite(capabilityExpectedUnknownCount)
+      ? Math.max(0, Number(capabilityExpectedUnknownCount))
+      : null,
+    capability_provided_unknown_count: Number.isFinite(capabilityProvidedUnknownCount)
+      ? Math.max(0, Number(capabilityProvidedUnknownCount))
+      : null,
     release_gate_preflight_available: typeof releaseGatePreflightAvailable === 'boolean'
       ? releaseGatePreflightAvailable
       : null,
@@ -9021,6 +9244,12 @@ function buildAutoHandoffReleaseGateHistoryAggregates(entries = []) {
   let preflightAvailableRuns = 0;
   let preflightBlockedRuns = 0;
   let preflightHardGateRuns = 0;
+  let capabilityExpectedUnknownKnownRuns = 0;
+  let capabilityExpectedUnknownPositiveRuns = 0;
+  let capabilityProvidedUnknownKnownRuns = 0;
+  let capabilityProvidedUnknownPositiveRuns = 0;
+  const capabilityExpectedUnknownCounts = [];
+  const capabilityProvidedUnknownCounts = [];
   const sceneBatchFailureCounts = [];
   let sceneBatchApplicableCount = 0;
   let sceneBatchPassedCount = 0;
@@ -9069,6 +9298,28 @@ function buildAutoHandoffReleaseGateHistoryAggregates(entries = []) {
     if (Number.isFinite(sceneBatchFailureCount)) {
       sceneBatchFailureCounts.push(sceneBatchFailureCount);
     }
+    const capabilityExpectedUnknownCount = parseAutoHandoffGateNumber(
+      entry && entry.capability_expected_unknown_count
+    );
+    if (Number.isFinite(capabilityExpectedUnknownCount)) {
+      const normalizedCount = Math.max(0, Number(capabilityExpectedUnknownCount));
+      capabilityExpectedUnknownKnownRuns += 1;
+      capabilityExpectedUnknownCounts.push(normalizedCount);
+      if (normalizedCount > 0) {
+        capabilityExpectedUnknownPositiveRuns += 1;
+      }
+    }
+    const capabilityProvidedUnknownCount = parseAutoHandoffGateNumber(
+      entry && entry.capability_provided_unknown_count
+    );
+    if (Number.isFinite(capabilityProvidedUnknownCount)) {
+      const normalizedCount = Math.max(0, Number(capabilityProvidedUnknownCount));
+      capabilityProvidedUnknownKnownRuns += 1;
+      capabilityProvidedUnknownCounts.push(normalizedCount);
+      if (normalizedCount > 0) {
+        capabilityProvidedUnknownPositiveRuns += 1;
+      }
+    }
     const preflightAvailable = parseAutoHandoffGateBoolean(
       entry && entry.release_gate_preflight_available,
       null
@@ -9149,6 +9400,24 @@ function buildAutoHandoffReleaseGateHistoryAggregates(entries = []) {
   const maxSceneBatchFailureCount = sceneBatchFailureCounts.length > 0
     ? Number(Math.max(...sceneBatchFailureCounts).toFixed(2))
     : null;
+  const avgCapabilityExpectedUnknownCount = capabilityExpectedUnknownCounts.length > 0
+    ? Number((capabilityExpectedUnknownCounts.reduce((sum, value) => sum + value, 0) / capabilityExpectedUnknownCounts.length).toFixed(2))
+    : null;
+  const maxCapabilityExpectedUnknownCount = capabilityExpectedUnknownCounts.length > 0
+    ? Number(Math.max(...capabilityExpectedUnknownCounts).toFixed(2))
+    : null;
+  const capabilityExpectedUnknownPositiveRate = capabilityExpectedUnknownKnownRuns > 0
+    ? Number(((capabilityExpectedUnknownPositiveRuns / capabilityExpectedUnknownKnownRuns) * 100).toFixed(2))
+    : null;
+  const avgCapabilityProvidedUnknownCount = capabilityProvidedUnknownCounts.length > 0
+    ? Number((capabilityProvidedUnknownCounts.reduce((sum, value) => sum + value, 0) / capabilityProvidedUnknownCounts.length).toFixed(2))
+    : null;
+  const maxCapabilityProvidedUnknownCount = capabilityProvidedUnknownCounts.length > 0
+    ? Number(Math.max(...capabilityProvidedUnknownCounts).toFixed(2))
+    : null;
+  const capabilityProvidedUnknownPositiveRate = capabilityProvidedUnknownKnownRuns > 0
+    ? Number(((capabilityProvidedUnknownPositiveRuns / capabilityProvidedUnknownKnownRuns) * 100).toFixed(2))
+    : null;
   const driftAlertRate = driftKnownRuns > 0
     ? Number(((driftAlertRuns / driftKnownRuns) * 100).toFixed(2))
     : null;
@@ -9181,6 +9450,16 @@ function buildAutoHandoffReleaseGateHistoryAggregates(entries = []) {
     scene_package_batch_pass_rate_percent: sceneBatchPassRate,
     avg_scene_package_batch_failure_count: avgSceneBatchFailureCount,
     max_scene_package_batch_failure_count: maxSceneBatchFailureCount,
+    capability_expected_unknown_known_runs: capabilityExpectedUnknownKnownRuns,
+    capability_expected_unknown_positive_runs: capabilityExpectedUnknownPositiveRuns,
+    capability_expected_unknown_positive_rate_percent: capabilityExpectedUnknownPositiveRate,
+    avg_capability_expected_unknown_count: avgCapabilityExpectedUnknownCount,
+    max_capability_expected_unknown_count: maxCapabilityExpectedUnknownCount,
+    capability_provided_unknown_known_runs: capabilityProvidedUnknownKnownRuns,
+    capability_provided_unknown_positive_runs: capabilityProvidedUnknownPositiveRuns,
+    capability_provided_unknown_positive_rate_percent: capabilityProvidedUnknownPositiveRate,
+    avg_capability_provided_unknown_count: avgCapabilityProvidedUnknownCount,
+    max_capability_provided_unknown_count: maxCapabilityProvidedUnknownCount,
     drift_known_runs: driftKnownRuns,
     drift_alert_total: driftAlertTotal,
     drift_alert_runs: driftAlertRuns,
@@ -9246,6 +9525,8 @@ async function buildAutoHandoffReleaseGateHistoryIndex(projectPath, options = {}
         risk_level: latestEntry.risk_level,
         scene_package_batch_passed: latestEntry.scene_package_batch_passed,
         scene_package_batch_failure_count: latestEntry.scene_package_batch_failure_count,
+        capability_expected_unknown_count: latestEntry.capability_expected_unknown_count,
+        capability_provided_unknown_count: latestEntry.capability_provided_unknown_count,
         release_gate_preflight_available: latestEntry.release_gate_preflight_available,
         release_gate_preflight_blocked: latestEntry.release_gate_preflight_blocked,
         require_release_gate_preflight: latestEntry.require_release_gate_preflight,
@@ -9291,6 +9572,8 @@ function renderAutoHandoffReleaseGateHistoryMarkdown(payload = {}) {
     lines.push(`- Risk level: ${formatAutoHandoffRegressionValue(latest.risk_level)}`);
     lines.push(`- Scene package batch: ${latest.scene_package_batch_passed === true ? 'pass' : (latest.scene_package_batch_passed === false ? 'fail' : 'n/a')}`);
     lines.push(`- Scene package batch failures: ${formatAutoHandoffRegressionValue(latest.scene_package_batch_failure_count)}`);
+    lines.push(`- Capability expected unknown count: ${formatAutoHandoffRegressionValue(latest.capability_expected_unknown_count, '0')}`);
+    lines.push(`- Capability provided unknown count: ${formatAutoHandoffRegressionValue(latest.capability_provided_unknown_count, '0')}`);
     lines.push(`- Release preflight available: ${latest.release_gate_preflight_available === true ? 'yes' : (latest.release_gate_preflight_available === false ? 'no' : 'n/a')}`);
     lines.push(`- Release preflight blocked: ${latest.release_gate_preflight_blocked === true ? 'yes' : (latest.release_gate_preflight_blocked === false ? 'no' : 'n/a')}`);
     lines.push(`- Release preflight hard-gate: ${latest.require_release_gate_preflight === true ? 'enabled' : (latest.require_release_gate_preflight === false ? 'advisory' : 'n/a')}`);
@@ -9312,6 +9595,12 @@ function renderAutoHandoffReleaseGateHistoryMarkdown(payload = {}) {
   lines.push(`- Scene package batch pass rate: ${formatAutoHandoffRegressionValue(aggregates.scene_package_batch_pass_rate_percent)}%`);
   lines.push(`- Scene package batch failed: ${formatAutoHandoffRegressionValue(aggregates.scene_package_batch_failed_count, '0')}`);
   lines.push(`- Avg scene package batch failures: ${formatAutoHandoffRegressionValue(aggregates.avg_scene_package_batch_failure_count)}`);
+  lines.push(`- Capability expected unknown positive rate: ${formatAutoHandoffRegressionValue(aggregates.capability_expected_unknown_positive_rate_percent)}%`);
+  lines.push(`- Avg capability expected unknown count: ${formatAutoHandoffRegressionValue(aggregates.avg_capability_expected_unknown_count)}`);
+  lines.push(`- Max capability expected unknown count: ${formatAutoHandoffRegressionValue(aggregates.max_capability_expected_unknown_count)}`);
+  lines.push(`- Capability provided unknown positive rate: ${formatAutoHandoffRegressionValue(aggregates.capability_provided_unknown_positive_rate_percent)}%`);
+  lines.push(`- Avg capability provided unknown count: ${formatAutoHandoffRegressionValue(aggregates.avg_capability_provided_unknown_count)}`);
+  lines.push(`- Max capability provided unknown count: ${formatAutoHandoffRegressionValue(aggregates.max_capability_provided_unknown_count)}`);
   lines.push(`- Drift alert runs: ${formatAutoHandoffRegressionValue(aggregates.drift_alert_runs, '0')}`);
   lines.push(`- Drift blocked runs: ${formatAutoHandoffRegressionValue(aggregates.drift_blocked_runs, '0')}`);
   lines.push(`- Drift alert rate: ${formatAutoHandoffRegressionValue(aggregates.drift_alert_rate_percent)}%`);
@@ -9343,6 +9632,14 @@ function renderAutoHandoffReleaseGateHistoryMarkdown(payload = {}) {
       const sceneBatchFailures = formatAutoHandoffRegressionValue(
         entry && entry.scene_package_batch_failure_count
       );
+      const capabilityExpectedUnknown = formatAutoHandoffRegressionValue(
+        entry && entry.capability_expected_unknown_count,
+        '0'
+      );
+      const capabilityProvidedUnknown = formatAutoHandoffRegressionValue(
+        entry && entry.capability_provided_unknown_count,
+        '0'
+      );
       const preflightBlocked = entry && entry.release_gate_preflight_blocked === true
         ? 'yes'
         : (entry && entry.release_gate_preflight_blocked === false ? 'no' : 'n/a');
@@ -9355,7 +9652,8 @@ function renderAutoHandoffReleaseGateHistoryMarkdown(payload = {}) {
         : (entry && entry.drift_blocked === false ? 'no' : 'n/a');
       lines.push(
         `- ${tag} | passed=${passed} | risk=${risk} | scene-batch=${sceneBatch} | ` +
-        `scene-failures=${sceneBatchFailures} | preflight-blocked=${preflightBlocked} | hard-gate=${preflightHardGate} | ` +
+        `scene-failures=${sceneBatchFailures} | capability-unknown=${capabilityExpectedUnknown}/${capabilityProvidedUnknown} | ` +
+        `preflight-blocked=${preflightBlocked} | hard-gate=${preflightHardGate} | ` +
         `drift-alerts=${driftAlerts} | drift-blocked=${driftBlocked} | ` +
         `success=${successRate} | violations=${violations} | at=${evaluatedAt}`
       );
@@ -9426,6 +9724,13 @@ function buildAutoHandoffEvidenceSnapshot(entry = {}) {
   const ontologyMetrics = ontology && typeof ontology.metrics === 'object'
     ? ontology.metrics
     : {};
+  const moquiBaseline = entry && typeof entry.moqui_baseline === 'object'
+    ? entry.moqui_baseline
+    : {};
+  const moquiCompare = moquiBaseline && typeof moquiBaseline.compare === 'object'
+    ? moquiBaseline.compare
+    : {};
+  const moquiMatrixRegressions = buildAutoHandoffMoquiCoverageRegressions(moquiCompare);
   const scenePackageBatch = entry && typeof entry.scene_package_batch === 'object'
     ? entry.scene_package_batch
     : {};
@@ -9490,6 +9795,7 @@ function buildAutoHandoffEvidenceSnapshot(entry = {}) {
       entry.capability_coverage.summary &&
       entry.capability_coverage.summary.passed === true
     ),
+    moqui_matrix_regression_count: moquiMatrixRegressions.length,
     generated_at: normalizeHandoffText(entry.merged_at)
   };
 }
@@ -9534,6 +9840,9 @@ function renderAutoHandoffEvidenceReviewMarkdown(payload = {}) {
   const failureSummary = currentOverview.failure_summary && typeof currentOverview.failure_summary === 'object'
     ? currentOverview.failure_summary
     : {};
+  const currentPolicy = currentOverview.policy && typeof currentOverview.policy === 'object'
+    ? currentOverview.policy
+    : {};
   const ontology = currentOverview.ontology_validation && typeof currentOverview.ontology_validation === 'object'
     ? currentOverview.ontology_validation
     : {};
@@ -9549,9 +9858,16 @@ function renderAutoHandoffEvidenceReviewMarkdown(payload = {}) {
   const moquiSummary = moquiBaseline && moquiBaseline.summary && typeof moquiBaseline.summary === 'object'
     ? moquiBaseline.summary
     : {};
+  const moquiScopeBreakdown = moquiSummary && moquiSummary.scope_breakdown && typeof moquiSummary.scope_breakdown === 'object'
+    ? moquiSummary.scope_breakdown
+    : {};
+  const moquiGapFrequency = Array.isArray(moquiSummary && moquiSummary.gap_frequency)
+    ? moquiSummary.gap_frequency
+    : [];
   const moquiCompare = moquiBaseline && moquiBaseline.compare && typeof moquiBaseline.compare === 'object'
     ? moquiBaseline.compare
     : {};
+  const moquiMatrixRegressions = buildAutoHandoffMoquiCoverageRegressions(moquiCompare);
   const moquiDeltas = moquiCompare && moquiCompare.deltas && typeof moquiCompare.deltas === 'object'
     ? moquiCompare.deltas
     : {};
@@ -9634,7 +9950,8 @@ function renderAutoHandoffEvidenceReviewMarkdown(payload = {}) {
       `avg_success=${formatAutoHandoffRegressionValue(scoped.avg_spec_success_rate_percent)}, ` +
       `avg_failed_goals=${formatAutoHandoffRegressionValue(scoped.avg_failed_goals)}, ` +
       `avg_ontology_quality=${formatAutoHandoffRegressionValue(scoped.avg_ontology_quality_score)}, ` +
-      `scene_batch_pass_rate=${formatAutoHandoffRegressionValue(scoped.scene_package_batch_pass_rate_percent)}%`
+      `scene_batch_pass_rate=${formatAutoHandoffRegressionValue(scoped.scene_package_batch_pass_rate_percent)}%, ` +
+      `avg_moqui_matrix_regressions=${formatAutoHandoffRegressionValue(scoped.avg_moqui_matrix_regression_count, '0')}`
     );
   });
 
@@ -9700,10 +10017,24 @@ function renderAutoHandoffEvidenceReviewMarkdown(payload = {}) {
     `- Avg score: ${formatAutoHandoffRegressionValue(moquiSummary.avg_score)}`,
     `- Valid-rate: ${formatAutoHandoffRegressionValue(moquiSummary.valid_rate_percent)}%`,
     `- Baseline failed templates: ${formatAutoHandoffRegressionValue(moquiSummary.baseline_failed)}`,
+    `- Matrix regression count: ${formatAutoHandoffRegressionValue(moquiMatrixRegressions.length, '0')}`,
+    `- Matrix regression gate (max): ${formatAutoHandoffRegressionValue(currentPolicy.max_moqui_matrix_regressions)}`,
+    `- Scope mix (moqui/suite/other): ${formatAutoHandoffRegressionValue(moquiScopeBreakdown.moqui_erp, '0')}/${formatAutoHandoffRegressionValue(moquiScopeBreakdown.scene_orchestration, '0')}/${formatAutoHandoffRegressionValue(moquiScopeBreakdown.other, '0')}`,
+    `- Entity coverage: ${formatAutoHandoffMoquiCoverageMetric(moquiSummary, 'entity_coverage', 'rate_percent', '%')}`,
+    `- Relation coverage: ${formatAutoHandoffMoquiCoverageMetric(moquiSummary, 'relation_coverage', 'rate_percent', '%')}`,
+    `- Business-rule coverage: ${formatAutoHandoffMoquiCoverageMetric(moquiSummary, 'business_rule_coverage', 'rate_percent', '%')}`,
+    `- Business-rule closed: ${formatAutoHandoffMoquiCoverageMetric(moquiSummary, 'business_rule_closed', 'rate_percent', '%')}`,
+    `- Decision coverage: ${formatAutoHandoffMoquiCoverageMetric(moquiSummary, 'decision_coverage', 'rate_percent', '%')}`,
+    `- Decision closed: ${formatAutoHandoffMoquiCoverageMetric(moquiSummary, 'decision_closed', 'rate_percent', '%')}`,
     `- Delta avg score: ${formatAutoHandoffRegressionValue(moquiDeltas.avg_score)}`,
     `- Delta valid-rate: ${formatAutoHandoffRegressionValue(moquiDeltas.valid_rate_percent)}%`,
+    `- Delta entity coverage: ${formatAutoHandoffMoquiCoverageDeltaMetric(moquiCompare, 'entity_coverage', 'rate_percent', '%')}`,
+    `- Delta business-rule closed: ${formatAutoHandoffMoquiCoverageDeltaMetric(moquiCompare, 'business_rule_closed', 'rate_percent', '%')}`,
+    `- Delta decision closed: ${formatAutoHandoffMoquiCoverageDeltaMetric(moquiCompare, 'decision_closed', 'rate_percent', '%')}`,
+    `- Matrix regressions: ${formatAutoHandoffMoquiCoverageRegressions(moquiCompare, 5)}`,
     `- Newly failed templates: ${Array.isArray(moquiFailedTemplates.newly_failed) && moquiFailedTemplates.newly_failed.length > 0 ? moquiFailedTemplates.newly_failed.join(', ') : 'none'}`,
     `- Recovered templates: ${Array.isArray(moquiFailedTemplates.recovered) && moquiFailedTemplates.recovered.length > 0 ? moquiFailedTemplates.recovered.join(', ') : 'none'}`,
+    `- Top baseline gaps: ${moquiGapFrequency.length > 0 ? moquiGapFrequency.slice(0, 3).map(item => `${item.gap}:${item.count}`).join(' | ') : 'none'}`,
     `- Baseline JSON: ${formatAutoHandoffRegressionValue(moquiBaseline.output && moquiBaseline.output.json)}`,
     '',
     '## Current Scene Package Batch',
@@ -9860,9 +10191,16 @@ function renderAutoHandoffReleaseNotesDraft(payload = {}, context = {}) {
   const moquiSummary = moquiBaseline && moquiBaseline.summary && typeof moquiBaseline.summary === 'object'
     ? moquiBaseline.summary
     : {};
+  const moquiScopeBreakdown = moquiSummary && moquiSummary.scope_breakdown && typeof moquiSummary.scope_breakdown === 'object'
+    ? moquiSummary.scope_breakdown
+    : {};
+  const moquiGapFrequency = Array.isArray(moquiSummary && moquiSummary.gap_frequency)
+    ? moquiSummary.gap_frequency
+    : [];
   const moquiCompare = moquiBaseline && moquiBaseline.compare && typeof moquiBaseline.compare === 'object'
     ? moquiBaseline.compare
     : {};
+  const moquiMatrixRegressions = buildAutoHandoffMoquiCoverageRegressions(moquiCompare);
   const moquiDeltas = moquiCompare && moquiCompare.deltas && typeof moquiCompare.deltas === 'object'
     ? moquiCompare.deltas
     : {};
@@ -9933,7 +10271,8 @@ function renderAutoHandoffReleaseNotesDraft(payload = {}, context = {}) {
       `- ${level}: count=${formatAutoHandoffRegressionValue(scoped.count, '0')}, ` +
       `avg_success=${formatAutoHandoffRegressionValue(scoped.avg_spec_success_rate_percent)}, ` +
       `avg_failed_goals=${formatAutoHandoffRegressionValue(scoped.avg_failed_goals)}, ` +
-      `avg_ontology_quality=${formatAutoHandoffRegressionValue(scoped.avg_ontology_quality_score)}`
+      `avg_ontology_quality=${formatAutoHandoffRegressionValue(scoped.avg_ontology_quality_score)}, ` +
+      `avg_moqui_matrix_regressions=${formatAutoHandoffRegressionValue(scoped.avg_moqui_matrix_regression_count, '0')}`
     );
   });
 
@@ -9965,9 +10304,23 @@ function renderAutoHandoffReleaseNotesDraft(payload = {}, context = {}) {
     `- Moqui baseline avg score: ${formatAutoHandoffRegressionValue(moquiSummary.avg_score)}`,
     `- Moqui baseline valid-rate: ${formatAutoHandoffRegressionValue(moquiSummary.valid_rate_percent)}%`,
     `- Moqui baseline failed templates: ${formatAutoHandoffRegressionValue(moquiSummary.baseline_failed)}`,
+    `- Moqui matrix regression count: ${formatAutoHandoffRegressionValue(moquiMatrixRegressions.length, '0')}`,
+    `- Moqui matrix regression gate (max): ${formatAutoHandoffRegressionValue(currentPolicy.max_moqui_matrix_regressions)}`,
+    `- Moqui scope mix (moqui/suite/other): ${formatAutoHandoffRegressionValue(moquiScopeBreakdown.moqui_erp, '0')}/${formatAutoHandoffRegressionValue(moquiScopeBreakdown.scene_orchestration, '0')}/${formatAutoHandoffRegressionValue(moquiScopeBreakdown.other, '0')}`,
+    `- Moqui entity coverage: ${formatAutoHandoffMoquiCoverageMetric(moquiSummary, 'entity_coverage', 'rate_percent', '%')}`,
+    `- Moqui relation coverage: ${formatAutoHandoffMoquiCoverageMetric(moquiSummary, 'relation_coverage', 'rate_percent', '%')}`,
+    `- Moqui business-rule coverage: ${formatAutoHandoffMoquiCoverageMetric(moquiSummary, 'business_rule_coverage', 'rate_percent', '%')}`,
+    `- Moqui business-rule closed: ${formatAutoHandoffMoquiCoverageMetric(moquiSummary, 'business_rule_closed', 'rate_percent', '%')}`,
+    `- Moqui decision coverage: ${formatAutoHandoffMoquiCoverageMetric(moquiSummary, 'decision_coverage', 'rate_percent', '%')}`,
+    `- Moqui decision closed: ${formatAutoHandoffMoquiCoverageMetric(moquiSummary, 'decision_closed', 'rate_percent', '%')}`,
     `- Moqui baseline avg score delta: ${formatAutoHandoffRegressionValue(moquiDeltas.avg_score)}`,
     `- Moqui baseline valid-rate delta: ${formatAutoHandoffRegressionValue(moquiDeltas.valid_rate_percent)}%`,
+    `- Moqui entity coverage delta: ${formatAutoHandoffMoquiCoverageDeltaMetric(moquiCompare, 'entity_coverage', 'rate_percent', '%')}`,
+    `- Moqui business-rule closed delta: ${formatAutoHandoffMoquiCoverageDeltaMetric(moquiCompare, 'business_rule_closed', 'rate_percent', '%')}`,
+    `- Moqui decision closed delta: ${formatAutoHandoffMoquiCoverageDeltaMetric(moquiCompare, 'decision_closed', 'rate_percent', '%')}`,
+    `- Moqui matrix regressions: ${formatAutoHandoffMoquiCoverageRegressions(moquiCompare, 5)}`,
     `- Moqui newly failed templates: ${Array.isArray(moquiFailedTemplates.newly_failed) && moquiFailedTemplates.newly_failed.length > 0 ? moquiFailedTemplates.newly_failed.join(', ') : 'none'}`,
+    `- Moqui top baseline gaps: ${moquiGapFrequency.length > 0 ? moquiGapFrequency.slice(0, 3).map(item => `${item.gap}:${item.count}`).join(' | ') : 'none'}`,
     `- Scene package batch status: ${formatAutoHandoffRegressionValue(scenePackageBatch.status)}`,
     `- Scene package batch selected: ${formatAutoHandoffRegressionValue(scenePackageBatchSummary.selected)}`,
     `- Scene package batch failed: ${formatAutoHandoffRegressionValue(scenePackageBatchSummary.failed)}`,
@@ -10279,6 +10632,17 @@ function normalizeHandoffMinCapabilitySemantic(semanticCandidate) {
   return Number(parsed.toFixed(2));
 }
 
+function normalizeHandoffMaxMoquiMatrixRegressions(valueCandidate) {
+  if (valueCandidate === undefined || valueCandidate === null || valueCandidate === '') {
+    return 0;
+  }
+  const parsed = Number(valueCandidate);
+  if (!Number.isInteger(parsed) || parsed < 0) {
+    throw new Error('--max-moqui-matrix-regressions must be an integer >= 0.');
+  }
+  return parsed;
+}
+
 function normalizeHandoffOptionalNonNegativeInteger(valueCandidate, optionName) {
   if (valueCandidate === undefined || valueCandidate === null || valueCandidate === '') {
     return null;
@@ -10307,6 +10671,7 @@ function buildAutoHandoffRunPolicy(options = {}) {
     max_risk_level: normalizeHandoffRiskLevel(options.maxRiskLevel),
     min_ontology_score: normalizeHandoffMinOntologyScore(options.minOntologyScore),
     min_capability_coverage_percent: normalizeHandoffMinCapabilityCoverage(options.minCapabilityCoverage),
+    max_moqui_matrix_regressions: normalizeHandoffMaxMoquiMatrixRegressions(options.maxMoquiMatrixRegressions),
     max_unmapped_rules: normalizeHandoffOptionalNonNegativeInteger(
       options.maxUnmappedRules,
       '--max-unmapped-rules'
@@ -10319,6 +10684,7 @@ function buildAutoHandoffRunPolicy(options = {}) {
     require_moqui_baseline: options.requireMoquiBaseline !== false,
     require_scene_package_batch: options.requireScenePackageBatch !== false,
     require_capability_coverage: options.requireCapabilityCoverage !== false,
+    require_capability_lexicon: options.requireCapabilityLexicon !== false,
     require_release_gate_preflight: options.requireReleaseGatePreflight === true,
     dependency_batching: options.dependencyBatching !== false,
     release_evidence_window: normalizeHandoffReleaseEvidenceWindow(options.releaseEvidenceWindow)
@@ -10635,6 +11001,10 @@ function evaluateAutoHandoffMoquiBaselineGateReasons(policy = {}, moquiBaseline
   const summary = baseline && baseline.summary && typeof baseline.summary === 'object'
     ? baseline.summary
     : {};
+  const compare = baseline && baseline.compare && typeof baseline.compare === 'object'
+    ? baseline.compare
+    : {};
+  const matrixRegressions = buildAutoHandoffMoquiCoverageRegressions(compare);
   const status = `${baseline && baseline.status ? baseline.status : 'missing'}`.trim().toLowerCase();
   if (!baseline || baseline.generated !== true) {
     const reason = baseline && baseline.reason ? baseline.reason : 'moqui baseline snapshot missing';
@@ -10653,6 +11023,15 @@ function evaluateAutoHandoffMoquiBaselineGateReasons(policy = {}, moquiBaseline
       `valid_rate=${Number.isFinite(validRate) ? `${validRate}%` : 'n/a'})`
     );
   }
+  if (Number.isInteger(policy.max_moqui_matrix_regressions)) {
+    const limit = Number(policy.max_moqui_matrix_regressions);
+    if (matrixRegressions.length > limit) {
+      reasons.push(
+        `moqui baseline matrix regressions ${matrixRegressions.length} > allowed ${limit} ` +
+        `(${matrixRegressions.slice(0, 3).map(item => `${item.label}:${item.delta_rate_percent}%`).join(' | ')})`
+      );
+    }
+  }
   return reasons;
 }
 
@@ -10734,6 +11113,57 @@ function evaluateAutoHandoffCapabilityCoverageGateReasons(policy = {}, capabilit
   return reasons;
 }
 
+function evaluateAutoHandoffCapabilityLexiconGateReasons(policy = {}, capabilityCoverage = null) {
+  const reasons = [];
+  if (policy.require_capability_lexicon !== true) {
+    return reasons;
+  }
+
+  const coverage = capabilityCoverage && typeof capabilityCoverage === 'object'
+    ? capabilityCoverage
+    : null;
+  if (!coverage) {
+    reasons.push('capability lexicon snapshot missing');
+    return reasons;
+  }
+  if (coverage.status === 'error') {
+    reasons.push(`capability lexicon errored: ${coverage.error || 'unknown error'}`);
+    return reasons;
+  }
+  if (coverage.status === 'skipped') {
+    const totalCapabilities = Number(
+      coverage &&
+      coverage.summary &&
+      coverage.summary.total_capabilities !== undefined
+        ? coverage.summary.total_capabilities
+        : 0
+    );
+    if (Number.isFinite(totalCapabilities) && totalCapabilities <= 0) {
+      return reasons;
+    }
+    reasons.push(`capability lexicon skipped: ${coverage.reason || 'unknown reason'}`);
+    return reasons;
+  }
+
+  const normalization = coverage.normalization && typeof coverage.normalization === 'object'
+    ? coverage.normalization
+    : {};
+  const expectedUnknownCount = Array.isArray(normalization.expected_unknown)
+    ? normalization.expected_unknown.length
+    : 0;
+  const providedUnknownCount = Array.isArray(normalization.provided_unknown)
+    ? normalization.provided_unknown.length
+    : 0;
+  if (expectedUnknownCount > 0) {
+    reasons.push(`capability_lexicon_expected_unknown_count ${expectedUnknownCount} > allowed 0`);
+  }
+  if (providedUnknownCount > 0) {
+    reasons.push(`capability_lexicon_provided_unknown_count ${providedUnknownCount} > allowed 0`);
+  }
+
+  return reasons;
+}
+
 function evaluateAutoHandoffCapabilitySemanticGateReasons(policy = {}, capabilityCoverage = null) {
   const reasons = [];
   if (policy.require_capability_semantic !== true) {
@@ -10854,6 +11284,13 @@ function buildAutoHandoffRunFailureSummary(result = {}) {
   const releaseGateReasons = releaseGatePreflight && Array.isArray(releaseGatePreflight.reasons)
     ? releaseGatePreflight.reasons
     : [];
+  const moquiBaseline = result && result.moqui_baseline && typeof result.moqui_baseline === 'object'
+    ? result.moqui_baseline
+    : null;
+  const moquiCompare = moquiBaseline && moquiBaseline.compare && typeof moquiBaseline.compare === 'object'
+    ? moquiBaseline.compare
+    : {};
+  const moquiMatrixRegressions = buildAutoHandoffMoquiCoverageRegressions(moquiCompare);
   const highlights = [];
   if (typeof result.error === 'string' && result.error.trim()) {
     highlights.push(`error: ${result.error.trim()}`);
@@ -10869,6 +11306,11 @@ function buildAutoHandoffRunFailureSummary(result = {}) {
   if (failedPhase && failedPhase.id) {
     highlights.push(`phase: ${failedPhase.id}${failedPhase.error ? ` (${failedPhase.error})` : ''}`);
   }
+  if (moquiMatrixRegressions.length > 0) {
+    highlights.push(
+      `moqui_matrix_regression: ${moquiMatrixRegressions.slice(0, 3).map(item => `${item.label}:${item.delta_rate_percent}%`).join(' | ')}`
+    );
+  }
   return {
     status: normalizeHandoffText(result && result.status),
     failed_phase: failedPhase
@@ -10880,6 +11322,7 @@ function buildAutoHandoffRunFailureSummary(result = {}) {
       : null,
     gate_failed: gates.passed === false,
     gate_reasons: gateReasons,
+    moqui_matrix_regressions: moquiMatrixRegressions,
     release_gate_preflight_blocked: Boolean(releaseGatePreflight && releaseGatePreflight.blocked === true),
     release_gate_preflight_reasons: releaseGateReasons,
     highlights
@@ -10958,10 +11401,13 @@ function evaluateAutoHandoffRunGates(context = {}) {
     min_spec_success_rate: 100,
     max_risk_level: 'high',
     min_ontology_score: 0,
+    max_moqui_matrix_regressions: 0,
     max_unmapped_rules: null,
     max_undecided_decisions: null,
     require_ontology_validation: true,
-    require_scene_package_batch: true
+    require_scene_package_batch: true,
+    require_capability_coverage: true,
+    require_capability_lexicon: true
   };
   const dryRun = Boolean(context.dryRun);
   const specStatus = context.specStatus || {
@@ -10974,6 +11420,10 @@ function evaluateAutoHandoffRunGates(context = {}) {
   const moquiBaseline = context.moquiBaseline && typeof context.moquiBaseline === 'object'
     ? context.moquiBaseline
     : null;
+  const moquiCompare = moquiBaseline && moquiBaseline.compare && typeof moquiBaseline.compare === 'object'
+    ? moquiBaseline.compare
+    : {};
+  const moquiMatrixRegressions = buildAutoHandoffMoquiCoverageRegressions(moquiCompare);
   const scenePackageBatch = context.scenePackageBatch && typeof context.scenePackageBatch === 'object'
     ? context.scenePackageBatch
     : null;
@@ -11008,6 +11458,7 @@ function evaluateAutoHandoffRunGates(context = {}) {
   reasons.push(...evaluateAutoHandoffMoquiBaselineGateReasons(policy, moquiBaseline));
   reasons.push(...evaluateAutoHandoffScenePackageBatchGateReasons(policy, scenePackageBatch));
   reasons.push(...evaluateAutoHandoffCapabilityCoverageGateReasons(policy, capabilityCoverage));
+  reasons.push(...evaluateAutoHandoffCapabilityLexiconGateReasons(policy, capabilityCoverage));
 
   return {
     passed: reasons.length === 0,
@@ -11048,6 +11499,10 @@ function evaluateAutoHandoffRunGates(context = {}) {
         moquiBaseline.summary &&
         moquiBaseline.summary.portfolio_passed === true
       ),
+      moqui_matrix_regression_count: moquiMatrixRegressions.length,
+      max_moqui_matrix_regressions: Number.isInteger(policy.max_moqui_matrix_regressions)
+        ? Number(policy.max_moqui_matrix_regressions)
+        : null,
       scene_package_batch_status: normalizeHandoffText(scenePackageBatch && scenePackageBatch.status),
       scene_package_batch_passed: Boolean(scenePackageBatch && scenePackageBatch.status === 'passed'),
       capability_coverage_status: normalizeHandoffText(capabilityCoverage && capabilityCoverage.status),
@@ -11055,7 +11510,22 @@ function evaluateAutoHandoffRunGates(context = {}) {
         Number(capabilityCoverage && capabilityCoverage.summary ? capabilityCoverage.summary.coverage_percent : null)
       )
         ? Number(capabilityCoverage.summary.coverage_percent)
-        : null
+        : null,
+      capability_expected_unknown_count: Array.isArray(
+        capabilityCoverage && capabilityCoverage.normalization
+          ? capabilityCoverage.normalization.expected_unknown
+          : null
+      )
+        ? capabilityCoverage.normalization.expected_unknown.length
+        : null,
+      capability_provided_unknown_count: Array.isArray(
+        capabilityCoverage && capabilityCoverage.normalization
+          ? capabilityCoverage.normalization.provided_unknown
+          : null
+      )
+        ? capabilityCoverage.normalization.provided_unknown.length
+        : null,
+      require_capability_lexicon: policy.require_capability_lexicon === true
     },
     reasons
   };
@@ -11187,6 +11657,10 @@ function buildAutoHandoffRunRecommendations(projectPath, result) {
   const moquiSummary = moquiBaseline && moquiBaseline.summary && typeof moquiBaseline.summary === 'object'
     ? moquiBaseline.summary
     : null;
+  const moquiCompare = moquiBaseline && moquiBaseline.compare && typeof moquiBaseline.compare === 'object'
+    ? moquiBaseline.compare
+    : {};
+  const moquiCoverageRegressions = buildAutoHandoffMoquiCoverageRegressions(moquiCompare);
   if (moquiBaseline && moquiBaseline.status === 'error') {
     push('sce scene moqui-baseline --json');
   } else if (moquiSummary && moquiSummary.portfolio_passed === false) {
@@ -11199,6 +11673,26 @@ function buildAutoHandoffRunRecommendations(projectPath, result) {
       '--dry-run --ontology-task-queue-out .kiro/auto/ontology-remediation.lines --json'
     );
   }
+  if (moquiCoverageRegressions.length > 0) {
+    push(
+      `Recover Moqui matrix regressions before next handoff run: ` +
+      `${moquiCoverageRegressions.slice(0, 3).map(item => `${item.label}:${item.delta_rate_percent}%`).join(' | ')}`
+    );
+    push(
+      'sce scene moqui-baseline --include-all ' +
+      '--compare-with .kiro/reports/release-evidence/moqui-template-baseline.json --json'
+    );
+    if (manifestPath) {
+      push(
+        `sce auto handoff run --manifest ${manifestCli} ` +
+        '--max-moqui-matrix-regressions 0 --json'
+      );
+      push(
+        `sce scene package-publish-batch --manifest ${manifestCli} ` +
+        '--dry-run --ontology-task-queue-out .kiro/auto/ontology-remediation.lines --json'
+      );
+    }
+  }
 
   const scenePackageBatch = result && result.scene_package_batch && typeof result.scene_package_batch === 'object'
     ? result.scene_package_batch
@@ -11237,6 +11731,26 @@ function buildAutoHandoffRunRecommendations(projectPath, result) {
   ) {
     push('replace deprecated manifest capabilities with canonical Moqui capability ids and rerun `sce auto handoff run --json`');
   }
+  if (
+    capabilityNormalization &&
+    Array.isArray(capabilityNormalization.expected_unknown) &&
+    capabilityNormalization.expected_unknown.length > 0
+  ) {
+    push(
+      'normalize unknown manifest capabilities and rerun strict gates via ' +
+      '`sce auto handoff capability-matrix --manifest docs/handoffs/handoff-manifest.json --fail-on-gap --json`'
+    );
+  }
+  if (
+    capabilityNormalization &&
+    Array.isArray(capabilityNormalization.provided_unknown) &&
+    capabilityNormalization.provided_unknown.length > 0
+  ) {
+    push(
+      'normalize unknown template capabilities via ' +
+      '`node scripts/moqui-lexicon-audit.js --manifest docs/handoffs/handoff-manifest.json --template-dir .kiro/templates/scene-packages --fail-on-gap --json`'
+    );
+  }
 
   return recommendations;
 }
@@ -11340,6 +11854,20 @@ function buildAutoHandoffReleaseEvidenceEntry(projectPath, result, reportFile =
   const moquiFailedTemplates = moquiCompare && moquiCompare.failed_templates && typeof moquiCompare.failed_templates === 'object'
     ? moquiCompare.failed_templates
     : {};
+  const moquiScopeBreakdown = moquiSummary && moquiSummary.scope_breakdown && typeof moquiSummary.scope_breakdown === 'object'
+    ? moquiSummary.scope_breakdown
+    : {};
+  const moquiCoverageMatrix = moquiSummary && moquiSummary.coverage_matrix && typeof moquiSummary.coverage_matrix === 'object'
+    ? moquiSummary.coverage_matrix
+    : {};
+  const moquiCoverageMatrixDeltas = moquiCompare && moquiCompare.coverage_matrix_deltas
+    && typeof moquiCompare.coverage_matrix_deltas === 'object'
+    ? moquiCompare.coverage_matrix_deltas
+    : {};
+  const moquiCoverageMatrixRegressions = buildAutoHandoffMoquiCoverageRegressions(moquiCompare);
+  const moquiGapFrequency = Array.isArray(moquiSummary && moquiSummary.gap_frequency)
+    ? moquiSummary.gap_frequency
+    : [];
   const scenePackageBatch = result && result.scene_package_batch && typeof result.scene_package_batch === 'object'
     ? result.scene_package_batch
     : {};
@@ -11394,7 +11922,9 @@ function buildAutoHandoffReleaseEvidenceEntry(projectPath, result, reportFile =
         risk_level: normalizeHandoffText(gateActual.risk_level),
         ontology_quality_score: toNumber(gateActual.ontology_quality_score),
         ontology_business_rule_unmapped: toNumber(gateActual.ontology_business_rule_unmapped),
-        ontology_decision_undecided: toNumber(gateActual.ontology_decision_undecided)
+        ontology_decision_undecided: toNumber(gateActual.ontology_decision_undecided),
+        capability_expected_unknown_count: toNumber(gateActual.capability_expected_unknown_count),
+        capability_provided_unknown_count: toNumber(gateActual.capability_provided_unknown_count)
       }
     },
     release_gate_preflight: result && result.release_gate_preflight && typeof result.release_gate_preflight === 'object'
@@ -11443,7 +11973,14 @@ function buildAutoHandoffReleaseEvidenceEntry(projectPath, result, reportFile =
         valid_rate_percent: toNumber(moquiSummary.valid_rate_percent),
         baseline_passed: toNumber(moquiSummary.baseline_passed),
         baseline_failed: toNumber(moquiSummary.baseline_failed),
-        portfolio_passed: moquiSummary.portfolio_passed === true
+        portfolio_passed: moquiSummary.portfolio_passed === true,
+        scope_breakdown: {
+          moqui_erp: toNumber(moquiScopeBreakdown.moqui_erp),
+          scene_orchestration: toNumber(moquiScopeBreakdown.scene_orchestration),
+          other: toNumber(moquiScopeBreakdown.other)
+        },
+        coverage_matrix: moquiCoverageMatrix,
+        gap_frequency: moquiGapFrequency
       },
       compare: Object.keys(moquiCompare).length === 0
         ? null
@@ -11457,6 +11994,8 @@ function buildAutoHandoffReleaseEvidenceEntry(projectPath, result, reportFile =
             baseline_passed: toNumber(moquiDeltas.baseline_passed),
             baseline_failed: toNumber(moquiDeltas.baseline_failed)
           },
+          coverage_matrix_deltas: moquiCoverageMatrixDeltas,
+          coverage_matrix_regressions: moquiCoverageMatrixRegressions,
           failed_templates: {
             newly_failed: Array.isArray(moquiFailedTemplates.newly_failed) ? moquiFailedTemplates.newly_failed : [],
             recovered: Array.isArray(moquiFailedTemplates.recovered) ? moquiFailedTemplates.recovered : []
@@ -11536,6 +12075,16 @@ function buildAutoHandoffReleaseEvidenceEntry(projectPath, result, reportFile =
     },
     continued_from: result && result.continued_from ? result.continued_from : null,
     policy: {
+      max_moqui_matrix_regressions: Number.isFinite(
+        Number(result && result.policy ? result.policy.max_moqui_matrix_regressions : null)
+      )
+        ? Number(result.policy.max_moqui_matrix_regressions)
+        : null,
+      require_capability_lexicon: Boolean(
+        result &&
+        result.policy &&
+        result.policy.require_capability_lexicon === true
+      ),
       require_release_gate_preflight: Boolean(
         result &&
         result.policy &&
@@ -11671,6 +12220,17 @@ async function writeAutoHandoffRunReport(projectPath, result, outCandidate = nul
 function buildAutoHandoffMoquiBaselinePhaseDetails(payload) {
   const baseline = payload && typeof payload === 'object' ? payload : {};
   const summary = baseline.summary && typeof baseline.summary === 'object' ? baseline.summary : null;
+  const compare = baseline.compare && typeof baseline.compare === 'object' ? baseline.compare : {};
+  const regressions = buildAutoHandoffMoquiCoverageRegressions(compare);
+  const scopeBreakdown = summary && summary.scope_breakdown && typeof summary.scope_breakdown === 'object'
+    ? summary.scope_breakdown
+    : null;
+  const coverageMatrix = summary && summary.coverage_matrix && typeof summary.coverage_matrix === 'object'
+    ? summary.coverage_matrix
+    : null;
+  const gapFrequency = summary && Array.isArray(summary.gap_frequency)
+    ? summary.gap_frequency
+    : [];
   return {
     status: baseline.status || 'unknown',
     generated: baseline.generated === true,
@@ -11681,7 +12241,20 @@ function buildAutoHandoffMoquiBaselinePhaseDetails(payload) {
       : null,
     valid_rate_percent: summary && Number.isFinite(Number(summary.valid_rate_percent))
       ? Number(summary.valid_rate_percent)
-      : null
+      : null,
+    scope_breakdown: scopeBreakdown,
+    coverage_matrix: coverageMatrix,
+    gap_frequency_top: gapFrequency.slice(0, 5),
+    entity_coverage_rate_percent: getAutoHandoffMoquiCoverageMetric(summary, 'entity_coverage', 'rate_percent'),
+    relation_coverage_rate_percent: getAutoHandoffMoquiCoverageMetric(summary, 'relation_coverage', 'rate_percent'),
+    business_rule_closed_rate_percent: getAutoHandoffMoquiCoverageMetric(summary, 'business_rule_closed', 'rate_percent'),
+    decision_closed_rate_percent: getAutoHandoffMoquiCoverageMetric(summary, 'decision_closed', 'rate_percent'),
+    coverage_matrix_deltas: getAutoHandoffMoquiCoverageDeltaMatrix(compare),
+    coverage_matrix_regressions: regressions,
+    entity_coverage_delta_rate_percent: getAutoHandoffMoquiCoverageDeltaMetric(compare, 'entity_coverage', 'rate_percent'),
+    business_rule_closed_delta_rate_percent: getAutoHandoffMoquiCoverageDeltaMetric(compare, 'business_rule_closed', 'rate_percent'),
+    decision_closed_delta_rate_percent: getAutoHandoffMoquiCoverageDeltaMetric(compare, 'decision_closed', 'rate_percent'),
+    matrix_regression_count: regressions.length
   };
 }
 
@@ -11778,6 +12351,15 @@ async function buildAutoHandoffMoquiBaselineSnapshot(projectPath) {
   const failedTemplates = compare && compare.failed_templates && typeof compare.failed_templates === 'object'
     ? compare.failed_templates
     : {};
+  const scopeBreakdown = summary && summary.scope_breakdown && typeof summary.scope_breakdown === 'object'
+    ? summary.scope_breakdown
+    : {};
+  const coverageMatrix = summary && summary.coverage_matrix && typeof summary.coverage_matrix === 'object'
+    ? summary.coverage_matrix
+    : {};
+  const gapFrequency = summary && Array.isArray(summary.gap_frequency)
+    ? summary.gap_frequency
+    : [];
 
   return {
     status: summary.portfolio_passed === true ? 'passed' : 'failed',
@@ -11789,13 +12371,22 @@ async function buildAutoHandoffMoquiBaselineSnapshot(projectPath) {
       valid_rate_percent: Number.isFinite(Number(summary.valid_rate_percent)) ? Number(summary.valid_rate_percent) : null,
       baseline_passed: Number(summary.baseline_passed) || 0,
       baseline_failed: Number(summary.baseline_failed) || 0,
-      portfolio_passed: summary.portfolio_passed === true
+      portfolio_passed: summary.portfolio_passed === true,
+      scope_breakdown: {
+        moqui_erp: Number(scopeBreakdown.moqui_erp) || 0,
+        scene_orchestration: Number(scopeBreakdown.scene_orchestration) || 0,
+        other: Number(scopeBreakdown.other) || 0
+      },
+      coverage_matrix: coverageMatrix,
+      gap_frequency: gapFrequency
     },
     compare: compare
       ? {
         previous_generated_at: compare.previous_generated_at || null,
         previous_template_root: compare.previous_template_root || null,
         deltas: compare.deltas || null,
+        coverage_matrix_deltas: compare.coverage_matrix_deltas || null,
+        coverage_matrix_regressions: buildAutoHandoffMoquiCoverageRegressions(compare),
         failed_templates: {
           previous: Array.isArray(failedTemplates.previous) ? failedTemplates.previous : [],
           current: Array.isArray(failedTemplates.current) ? failedTemplates.current : [],
@@ -12604,9 +13195,23 @@ function buildAutoHandoffCapabilityMatrixRecommendations(result = {}) {
   const coverageSummary = capabilityCoverage && capabilityCoverage.summary && typeof capabilityCoverage.summary === 'object'
     ? capabilityCoverage.summary
     : {};
+  const coverageNormalization = capabilityCoverage && capabilityCoverage.normalization &&
+    typeof capabilityCoverage.normalization === 'object'
+    ? capabilityCoverage.normalization
+    : {};
+  const expectedUnknownCount = Array.isArray(coverageNormalization.expected_unknown)
+    ? coverageNormalization.expected_unknown.length
+    : 0;
+  const providedUnknownCount = Array.isArray(coverageNormalization.provided_unknown)
+    ? coverageNormalization.provided_unknown.length
+    : 0;
   const baseline = result && result.moqui_baseline && typeof result.moqui_baseline === 'object'
     ? result.moqui_baseline
     : {};
+  const baselineCompare = baseline && baseline.compare && typeof baseline.compare === 'object'
+    ? baseline.compare
+    : {};
+  const baselineRegressions = buildAutoHandoffMoquiCoverageRegressions(baselineCompare);
 
   if (templateDiff.compatibility === 'needs-sync') {
     push(`Sync template library and rerun: sce auto handoff template-diff --manifest ${manifestCli} --json`);
@@ -12614,6 +13219,12 @@ function buildAutoHandoffCapabilityMatrixRecommendations(result = {}) {
   if (baseline.status === 'error' || (baseline.summary && baseline.summary.portfolio_passed === false)) {
     push('Rebuild Moqui baseline: sce scene moqui-baseline --json');
   }
+  if (baselineRegressions.length > 0) {
+    push(
+      `Recover Moqui matrix regressions: ` +
+      `${baselineRegressions.slice(0, 3).map(item => `${item.label}:${item.delta_rate_percent}%`).join(' | ')}`
+    );
+  }
   if (capabilityCoverage.status === 'skipped') {
     push('Declare `capabilities` in handoff manifest to enable capability matrix coverage gates.');
   }
@@ -12629,6 +13240,13 @@ function buildAutoHandoffCapabilityMatrixRecommendations(result = {}) {
       `sce scene package-ontology-backfill-batch --manifest ${manifestCli} --json`
     );
   }
+  if (expectedUnknownCount > 0 || providedUnknownCount > 0) {
+    push(
+      `Normalize capability lexicon gaps with strict audit: ` +
+      `node scripts/moqui-lexicon-audit.js --manifest ${manifestCli} ` +
+      '--template-dir .kiro/templates/scene-packages --fail-on-gap --json'
+    );
+  }
   if (result.remediation_queue && result.remediation_queue.file) {
     push(
       `Replay remediation queue: sce auto close-loop-batch ${quoteCliArg(result.remediation_queue.file)} --format lines --json`
@@ -12660,12 +13278,31 @@ function renderAutoHandoffCapabilityMatrixMarkdown(payload = {}) {
   const baselineSummary = moquiBaseline && moquiBaseline.summary && typeof moquiBaseline.summary === 'object'
     ? moquiBaseline.summary
     : {};
+  const baselineCompare = moquiBaseline && moquiBaseline.compare && typeof moquiBaseline.compare === 'object'
+    ? moquiBaseline.compare
+    : {};
+  const baselineScopeBreakdown = baselineSummary && baselineSummary.scope_breakdown && typeof baselineSummary.scope_breakdown === 'object'
+    ? baselineSummary.scope_breakdown
+    : {};
+  const baselineGapFrequency = Array.isArray(baselineSummary && baselineSummary.gap_frequency)
+    ? baselineSummary.gap_frequency
+    : [];
   const capabilityCoverage = payload && payload.capability_coverage && typeof payload.capability_coverage === 'object'
     ? payload.capability_coverage
     : {};
   const coverageSummary = capabilityCoverage && capabilityCoverage.summary && typeof capabilityCoverage.summary === 'object'
     ? capabilityCoverage.summary
     : {};
+  const coverageNormalization = capabilityCoverage && capabilityCoverage.normalization &&
+    typeof capabilityCoverage.normalization === 'object'
+    ? capabilityCoverage.normalization
+    : {};
+  const expectedUnknownCount = Array.isArray(coverageNormalization.expected_unknown)
+    ? coverageNormalization.expected_unknown.length
+    : 0;
+  const providedUnknownCount = Array.isArray(coverageNormalization.provided_unknown)
+    ? coverageNormalization.provided_unknown.length
+    : 0;
   const coverage = Array.isArray(capabilityCoverage && capabilityCoverage.coverage)
     ? capabilityCoverage.coverage
     : [];
@@ -12685,6 +13322,7 @@ function renderAutoHandoffCapabilityMatrixMarkdown(payload = {}) {
     `- Capabilities: ${handoff.capability_count !== undefined ? handoff.capability_count : 'n/a'}`,
     `- Min capability coverage: ${policy.min_capability_coverage_percent !== undefined ? `${policy.min_capability_coverage_percent}%` : 'n/a'}`,
     `- Min capability semantic completeness: ${policy.min_capability_semantic_percent !== undefined ? `${policy.min_capability_semantic_percent}%` : 'n/a'}`,
+    `- Capability lexicon gate: ${policy.require_capability_lexicon === false ? 'disabled' : 'enabled'}`,
     '',
     '## Gates',
     '',
@@ -12703,6 +13341,18 @@ function renderAutoHandoffCapabilityMatrixMarkdown(payload = {}) {
     `- Portfolio passed: ${baselineSummary.portfolio_passed === true ? 'yes' : (baselineSummary.portfolio_passed === false ? 'no' : 'n/a')}`,
     `- Avg score: ${formatAutoHandoffRegressionValue(baselineSummary.avg_score)}`,
     `- Valid-rate: ${formatAutoHandoffRegressionValue(baselineSummary.valid_rate_percent)}%`,
+    `- Scope mix (moqui/suite/other): ${formatAutoHandoffRegressionValue(baselineScopeBreakdown.moqui_erp, '0')}/${formatAutoHandoffRegressionValue(baselineScopeBreakdown.scene_orchestration, '0')}/${formatAutoHandoffRegressionValue(baselineScopeBreakdown.other, '0')}`,
+    `- Entity coverage: ${formatAutoHandoffMoquiCoverageMetric(baselineSummary, 'entity_coverage', 'rate_percent', '%')}`,
+    `- Relation coverage: ${formatAutoHandoffMoquiCoverageMetric(baselineSummary, 'relation_coverage', 'rate_percent', '%')}`,
+    `- Business-rule coverage: ${formatAutoHandoffMoquiCoverageMetric(baselineSummary, 'business_rule_coverage', 'rate_percent', '%')}`,
+    `- Business-rule closed: ${formatAutoHandoffMoquiCoverageMetric(baselineSummary, 'business_rule_closed', 'rate_percent', '%')}`,
+    `- Decision coverage: ${formatAutoHandoffMoquiCoverageMetric(baselineSummary, 'decision_coverage', 'rate_percent', '%')}`,
+    `- Decision closed: ${formatAutoHandoffMoquiCoverageMetric(baselineSummary, 'decision_closed', 'rate_percent', '%')}`,
+    `- Entity coverage delta: ${formatAutoHandoffMoquiCoverageDeltaMetric(baselineCompare, 'entity_coverage', 'rate_percent', '%')}`,
+    `- Business-rule closed delta: ${formatAutoHandoffMoquiCoverageDeltaMetric(baselineCompare, 'business_rule_closed', 'rate_percent', '%')}`,
+    `- Decision closed delta: ${formatAutoHandoffMoquiCoverageDeltaMetric(baselineCompare, 'decision_closed', 'rate_percent', '%')}`,
+    `- Matrix regressions: ${formatAutoHandoffMoquiCoverageRegressions(baselineCompare, 5)}`,
+    `- Top baseline gaps: ${baselineGapFrequency.length > 0 ? baselineGapFrequency.slice(0, 3).map(item => `${item.gap}:${item.count}`).join(' | ') : 'none'}`,
     '',
     '## Capability Coverage',
     '',
@@ -12713,6 +13363,8 @@ function renderAutoHandoffCapabilityMatrixMarkdown(payload = {}) {
     `- Uncovered capabilities: ${formatAutoHandoffRegressionValue(coverageSummary.uncovered_capabilities, '0')}`,
     `- Semantic complete: ${formatAutoHandoffRegressionValue(coverageSummary.semantic_complete_percent)}%`,
     `- Semantic passed: ${coverageSummary.semantic_passed === true ? 'yes' : (coverageSummary.semantic_passed === false ? 'no' : 'n/a')}`,
+    `- Expected unknown capability aliases: ${expectedUnknownCount}`,
+    `- Provided unknown capability aliases: ${providedUnknownCount}`,
     '',
     '| Capability | Covered | Semantic Complete | Missing Semantic Dimensions | Matched Templates |',
     '| --- | --- | --- | --- | --- |'
@@ -12767,6 +13419,7 @@ async function buildAutoHandoffCapabilityMatrix(projectPath, options = {}) {
     min_capability_semantic_percent: normalizeHandoffMinCapabilitySemantic(options.minCapabilitySemantic),
     require_capability_coverage: true,
     require_capability_semantic: options.requireCapabilitySemantic !== false,
+    require_capability_lexicon: options.requireCapabilityLexicon !== false,
     require_moqui_baseline: true
   };
 
@@ -12791,11 +13444,16 @@ async function buildAutoHandoffCapabilityMatrix(projectPath, options = {}) {
     policy,
     capabilityCoverage
   );
+  const lexiconGateReasons = evaluateAutoHandoffCapabilityLexiconGateReasons(
+    policy,
+    capabilityCoverage
+  );
   const reasons = [
     ...templateSyncReasons,
     ...baselineGateReasons.map(item => `moqui-baseline:${item}`),
     ...capabilityGateReasons.map(item => `capability-coverage:${item}`),
-    ...semanticGateReasons.map(item => `capability-semantic:${item}`)
+    ...semanticGateReasons.map(item => `capability-semantic:${item}`),
+    ...lexiconGateReasons.map(item => `capability-lexicon:${item}`)
   ];
 
   const result = {
@@ -12840,6 +13498,10 @@ async function buildAutoHandoffCapabilityMatrix(projectPath, options = {}) {
       capability_semantic: {
         passed: semanticGateReasons.length === 0,
         reasons: semanticGateReasons
+      },
+      capability_lexicon: {
+        passed: lexiconGateReasons.length === 0,
+        reasons: lexiconGateReasons
       }
     },
     remediation_queue: null,
@@ -12880,6 +13542,7 @@ function collectAutoHandoffMoquiRemediationGoals(result) {
   const baselineCompare = moquiBaseline && moquiBaseline.compare && typeof moquiBaseline.compare === 'object'
     ? moquiBaseline.compare
     : null;
+  const baselineRegressions = buildAutoHandoffMoquiCoverageRegressions(baselineCompare || {});
   const baselineFailedTemplates = baselineCompare && baselineCompare.failed_templates && typeof baselineCompare.failed_templates === 'object'
     ? baselineCompare.failed_templates
     : {};
@@ -12898,6 +13561,22 @@ function collectAutoHandoffMoquiRemediationGoals(result) {
       pushGoal(`remediate moqui template ${templateId} ontology semantics and close baseline gaps`);
     }
   }
+  if (baselineRegressions.length > 0) {
+    for (const item of baselineRegressions.slice(0, 5)) {
+      pushGoal(
+        `recover moqui matrix regression ${item.label} (${item.delta_rate_percent}%) by closing ontology semantic gaps`
+      );
+      if (item.metric === 'business_rule_closed') {
+        pushGoal('remap governance_contract.business_rules for Moqui templates until closure regression is recovered');
+      }
+      if (item.metric === 'decision_closed') {
+        pushGoal('resolve undecided governance_contract.decision_logic entries in Moqui templates');
+      }
+      if (item.metric === 'entity_coverage' || item.metric === 'relation_coverage') {
+        pushGoal('backfill ontology_model entities/relations for regressed Moqui templates');
+      }
+    }
+  }
 
   const scenePackageBatch = result && result.scene_package_batch && typeof result.scene_package_batch === 'object'
     ? result.scene_package_batch
@@ -13007,6 +13686,16 @@ function collectAutoHandoffMoquiRemediationGoals(result) {
       pushGoal(`align unknown manifest capability ${raw} with Moqui capability lexicon`);
     }
   }
+  if (
+    capabilityNormalization &&
+    Array.isArray(capabilityNormalization.provided_unknown) &&
+    capabilityNormalization.provided_unknown.length > 0
+  ) {
+    for (const item of capabilityNormalization.provided_unknown) {
+      const raw = item && item.raw ? item.raw : '(unknown)';
+      pushGoal(`align unknown template capability ${raw} with Moqui capability lexicon`);
+    }
+  }
 
   return goals;
 }
@@ -13229,6 +13918,13 @@ async function runAutoHandoff(projectPath, options = {}) {
       if (capabilityCoverageGateReasons.length > 0) {
         throw new Error(`handoff capability coverage gate failed: ${capabilityCoverageGateReasons.join('; ')}`);
       }
+      const capabilityLexiconGateReasons = evaluateAutoHandoffCapabilityLexiconGateReasons(
+        result.policy,
+        result.moqui_capability_coverage
+      );
+      if (capabilityLexiconGateReasons.length > 0) {
+        throw new Error(`handoff capability lexicon gate failed: ${capabilityLexiconGateReasons.join('; ')}`);
+      }
     } catch (capabilityCoverageError) {
       failAutoHandoffRunPhase(capabilityCoveragePhase, capabilityCoverageError);
       if (!result.moqui_capability_coverage) {
@@ -14550,6 +15246,18 @@ function normalizeGovernanceHandoffQualitySnapshot(snapshotCandidate) {
     latest_ontology_quality_score: toGovernanceReleaseGateNumber(snapshotCandidate.latest_ontology_quality_score),
     latest_capability_coverage_percent: toGovernanceReleaseGateNumber(snapshotCandidate.latest_capability_coverage_percent),
     latest_capability_coverage_passed: parseAutoHandoffGateBoolean(snapshotCandidate.latest_capability_coverage_passed, null),
+    latest_capability_expected_unknown_count: toGovernanceReleaseGateNumber(
+      snapshotCandidate.latest_capability_expected_unknown_count
+    ),
+    latest_capability_provided_unknown_count: toGovernanceReleaseGateNumber(
+      snapshotCandidate.latest_capability_provided_unknown_count
+    ),
+    latest_moqui_matrix_regression_count: toGovernanceReleaseGateNumber(
+      snapshotCandidate.latest_moqui_matrix_regression_count
+    ),
+    latest_moqui_matrix_regression_gate_max: toGovernanceReleaseGateNumber(
+      snapshotCandidate.latest_moqui_matrix_regression_gate_max
+    ),
     latest_release_gate_preflight_blocked: parseAutoHandoffGateBoolean(
       snapshotCandidate.latest_release_gate_preflight_blocked,
       null
@@ -14558,6 +15266,21 @@ function normalizeGovernanceHandoffQualitySnapshot(snapshotCandidate) {
     gate_pass_rate_percent: toGovernanceReleaseGateNumber(snapshotCandidate.gate_pass_rate_percent),
     capability_coverage_pass_rate_percent: toGovernanceReleaseGateNumber(
       snapshotCandidate.capability_coverage_pass_rate_percent
+    ),
+    capability_expected_unknown_positive_rate_percent: toGovernanceReleaseGateNumber(
+      snapshotCandidate.capability_expected_unknown_positive_rate_percent
+    ),
+    capability_provided_unknown_positive_rate_percent: toGovernanceReleaseGateNumber(
+      snapshotCandidate.capability_provided_unknown_positive_rate_percent
+    ),
+    avg_moqui_matrix_regression_count: toGovernanceReleaseGateNumber(
+      snapshotCandidate.avg_moqui_matrix_regression_count
+    ),
+    max_moqui_matrix_regression_count: toGovernanceReleaseGateNumber(
+      snapshotCandidate.max_moqui_matrix_regression_count
+    ),
+    moqui_matrix_regression_positive_rate_percent: toGovernanceReleaseGateNumber(
+      snapshotCandidate.moqui_matrix_regression_positive_rate_percent
     )
   };
 }
@@ -17226,6 +17949,10 @@ async function loadGovernanceHandoffQualitySignals(projectPath) {
     latest_ontology_quality_score: null,
     latest_capability_coverage_percent: null,
     latest_capability_coverage_passed: null,
+    latest_capability_expected_unknown_count: null,
+    latest_capability_provided_unknown_count: null,
+    latest_moqui_matrix_regression_count: null,
+    latest_moqui_matrix_regression_gate_max: null,
     latest_scene_package_batch_passed: null,
     latest_release_gate_preflight_blocked: null,
     latest_failure_highlights: [],
@@ -17234,6 +17961,11 @@ async function loadGovernanceHandoffQualitySignals(projectPath) {
     capability_coverage_pass_rate_percent: null,
     scene_package_batch_pass_rate_percent: null,
     avg_ontology_quality_score: null,
+    capability_expected_unknown_positive_rate_percent: null,
+    capability_provided_unknown_positive_rate_percent: null,
+    avg_moqui_matrix_regression_count: null,
+    max_moqui_matrix_regression_count: null,
+    moqui_matrix_regression_positive_rate_percent: null,
     parse_error: null
   };
   if (!(await fs.pathExists(evidenceFile))) {
@@ -17298,6 +18030,101 @@ async function loadGovernanceHandoffQualitySignals(projectPath) {
   const latestFailureHighlights = Array.isArray(latestFailureSummary.highlights)
     ? latestFailureSummary.highlights.map(item => `${item || ''}`.trim()).filter(Boolean).slice(0, 5)
     : [];
+  const deriveMoquiMatrixRegressionCount = entry => {
+    if (!entry || typeof entry !== 'object') {
+      return null;
+    }
+    const gate = entry.gate && typeof entry.gate === 'object'
+      ? entry.gate
+      : {};
+    const gateActual = gate.actual && typeof gate.actual === 'object'
+      ? gate.actual
+      : {};
+    const explicit = toNumber(gateActual.moqui_matrix_regression_count);
+    if (Number.isFinite(explicit)) {
+      return Math.max(0, explicit);
+    }
+    const moquiBaseline = entry.moqui_baseline && typeof entry.moqui_baseline === 'object'
+      ? entry.moqui_baseline
+      : {};
+    const compare = moquiBaseline.compare && typeof moquiBaseline.compare === 'object'
+      ? moquiBaseline.compare
+      : null;
+    if (!compare) {
+      return null;
+    }
+    return buildAutoHandoffMoquiCoverageRegressions(compare).length;
+  };
+  const deriveMoquiMatrixRegressionGateMax = entry => {
+    if (!entry || typeof entry !== 'object') {
+      return null;
+    }
+    const gate = entry.gate && typeof entry.gate === 'object'
+      ? entry.gate
+      : {};
+    const gateActual = gate.actual && typeof gate.actual === 'object'
+      ? gate.actual
+      : {};
+    const explicit = toNumber(gateActual.max_moqui_matrix_regressions);
+    if (Number.isFinite(explicit)) {
+      return Math.max(0, explicit);
+    }
+    const policy = entry.policy && typeof entry.policy === 'object'
+      ? entry.policy
+      : {};
+    const fromPolicy = toNumber(policy.max_moqui_matrix_regressions);
+    return Number.isFinite(fromPolicy) ? Math.max(0, fromPolicy) : null;
+  };
+  const deriveCapabilityExpectedUnknownCount = entry => {
+    if (!entry || typeof entry !== 'object') {
+      return null;
+    }
+    const gate = entry.gate && typeof entry.gate === 'object'
+      ? entry.gate
+      : {};
+    const gateActual = gate.actual && typeof gate.actual === 'object'
+      ? gate.actual
+      : {};
+    const explicit = toNumber(gateActual.capability_expected_unknown_count);
+    if (Number.isFinite(explicit)) {
+      return Math.max(0, explicit);
+    }
+    const coverage = entry.capability_coverage && typeof entry.capability_coverage === 'object'
+      ? entry.capability_coverage
+      : {};
+    const normalization = coverage.normalization && typeof coverage.normalization === 'object'
+      ? coverage.normalization
+      : {};
+    const list = Array.isArray(normalization.expected_unknown) ? normalization.expected_unknown : null;
+    return list ? list.length : null;
+  };
+  const deriveCapabilityProvidedUnknownCount = entry => {
+    if (!entry || typeof entry !== 'object') {
+      return null;
+    }
+    const gate = entry.gate && typeof entry.gate === 'object'
+      ? entry.gate
+      : {};
+    const gateActual = gate.actual && typeof gate.actual === 'object'
+      ? gate.actual
+      : {};
+    const explicit = toNumber(gateActual.capability_provided_unknown_count);
+    if (Number.isFinite(explicit)) {
+      return Math.max(0, explicit);
+    }
+    const coverage = entry.capability_coverage && typeof entry.capability_coverage === 'object'
+      ? entry.capability_coverage
+      : {};
+    const normalization = coverage.normalization && typeof coverage.normalization === 'object'
+      ? coverage.normalization
+      : {};
+    const list = Array.isArray(normalization.provided_unknown) ? normalization.provided_unknown : null;
+    return list ? list.length : null;
+  };
+  const latestMoquiMatrixRegressionCount = deriveMoquiMatrixRegressionCount(latest);
+  const latestMoquiMatrixRegressionGateMax = deriveMoquiMatrixRegressionGateMax(latest);
+  const latestCapabilityExpectedUnknownCount = deriveCapabilityExpectedUnknownCount(latest);
+  const latestCapabilityProvidedUnknownCount = deriveCapabilityProvidedUnknownCount(latest);
 
   let failedRuns = 0;
   let gateKnownRuns = 0;
@@ -17306,7 +18133,14 @@ async function loadGovernanceHandoffQualitySignals(projectPath) {
   let capabilityPassedRuns = 0;
   let sceneBatchKnownRuns = 0;
   let sceneBatchPassedRuns = 0;
+  let capabilityExpectedUnknownKnownRuns = 0;
+  let capabilityExpectedUnknownPositiveRuns = 0;
+  let capabilityProvidedUnknownKnownRuns = 0;
+  let capabilityProvidedUnknownPositiveRuns = 0;
+  let moquiMatrixKnownRuns = 0;
+  let moquiMatrixPositiveRuns = 0;
   const ontologyScores = [];
+  const moquiMatrixRegressionCounts = [];
   for (const entry of sessions) {
     const status = normalizeHandoffText(entry && entry.status);
     if (status && !['completed', 'dry-run', 'dry_run'].includes(status)) {
@@ -17359,6 +18193,28 @@ async function loadGovernanceHandoffQualitySignals(projectPath) {
     if (Number.isFinite(ontologyScore)) {
       ontologyScores.push(ontologyScore);
     }
+    const capabilityExpectedUnknownCount = deriveCapabilityExpectedUnknownCount(entry);
+    if (Number.isFinite(capabilityExpectedUnknownCount)) {
+      capabilityExpectedUnknownKnownRuns += 1;
+      if (capabilityExpectedUnknownCount > 0) {
+        capabilityExpectedUnknownPositiveRuns += 1;
+      }
+    }
+    const capabilityProvidedUnknownCount = deriveCapabilityProvidedUnknownCount(entry);
+    if (Number.isFinite(capabilityProvidedUnknownCount)) {
+      capabilityProvidedUnknownKnownRuns += 1;
+      if (capabilityProvidedUnknownCount > 0) {
+        capabilityProvidedUnknownPositiveRuns += 1;
+      }
+    }
+    const moquiMatrixRegressionCount = deriveMoquiMatrixRegressionCount(entry);
+    if (Number.isFinite(moquiMatrixRegressionCount)) {
+      moquiMatrixKnownRuns += 1;
+      moquiMatrixRegressionCounts.push(Math.max(0, moquiMatrixRegressionCount));
+      if (moquiMatrixRegressionCount > 0) {
+        moquiMatrixPositiveRuns += 1;
+      }
+    }
   }
 
   return {
@@ -17379,6 +18235,18 @@ async function loadGovernanceHandoffQualitySignals(projectPath) {
     ),
     latest_capability_coverage_percent: toNumber(latestCapabilitySummary.coverage_percent),
     latest_capability_coverage_passed: parseAutoHandoffGateBoolean(latestCapabilitySummary.passed, null),
+    latest_capability_expected_unknown_count: Number.isFinite(latestCapabilityExpectedUnknownCount)
+      ? latestCapabilityExpectedUnknownCount
+      : null,
+    latest_capability_provided_unknown_count: Number.isFinite(latestCapabilityProvidedUnknownCount)
+      ? latestCapabilityProvidedUnknownCount
+      : null,
+    latest_moqui_matrix_regression_count: Number.isFinite(latestMoquiMatrixRegressionCount)
+      ? latestMoquiMatrixRegressionCount
+      : null,
+    latest_moqui_matrix_regression_gate_max: Number.isFinite(latestMoquiMatrixRegressionGateMax)
+      ? latestMoquiMatrixRegressionGateMax
+      : null,
     latest_scene_package_batch_passed: parseAutoHandoffGateBoolean(latestSceneSummary.batch_gate_passed, null),
     latest_release_gate_preflight_blocked: parseAutoHandoffGateBoolean(latestPreflight.blocked, null),
     latest_failure_highlights: latestFailureHighlights,
@@ -17389,6 +18257,27 @@ async function loadGovernanceHandoffQualitySignals(projectPath) {
     avg_ontology_quality_score: ontologyScores.length > 0
       ? Number((ontologyScores.reduce((sum, item) => sum + item, 0) / ontologyScores.length).toFixed(2))
       : null,
+    capability_expected_unknown_positive_rate_percent: toPercent(
+      capabilityExpectedUnknownPositiveRuns,
+      capabilityExpectedUnknownKnownRuns
+    ),
+    capability_provided_unknown_positive_rate_percent: toPercent(
+      capabilityProvidedUnknownPositiveRuns,
+      capabilityProvidedUnknownKnownRuns
+    ),
+    avg_moqui_matrix_regression_count: moquiMatrixRegressionCounts.length > 0
+      ? Number((
+        moquiMatrixRegressionCounts.reduce((sum, item) => sum + item, 0) /
+        moquiMatrixRegressionCounts.length
+      ).toFixed(2))
+      : null,
+    max_moqui_matrix_regression_count: moquiMatrixRegressionCounts.length > 0
+      ? Number(Math.max(...moquiMatrixRegressionCounts).toFixed(2))
+      : null,
+    moqui_matrix_regression_positive_rate_percent: toPercent(
+      moquiMatrixPositiveRuns,
+      moquiMatrixKnownRuns
+    ),
     parse_error: null
   };
 }
@@ -17417,10 +18306,46 @@ function deriveGovernanceRiskLevel(summary) {
   const handoffFailureRate = Number(handoffQuality.failure_rate_percent);
   const handoffGatePassRate = Number(handoffQuality.gate_pass_rate_percent);
   const handoffCapabilityPassRate = Number(handoffQuality.capability_coverage_pass_rate_percent);
+  const handoffLatestCapabilityExpectedUnknownCount = Number(
+    handoffQuality.latest_capability_expected_unknown_count
+  );
+  const handoffLatestCapabilityProvidedUnknownCount = Number(
+    handoffQuality.latest_capability_provided_unknown_count
+  );
+  const handoffCapabilityExpectedUnknownPositiveRate = Number(
+    handoffQuality.capability_expected_unknown_positive_rate_percent
+  );
+  const handoffCapabilityProvidedUnknownPositiveRate = Number(
+    handoffQuality.capability_provided_unknown_positive_rate_percent
+  );
+  const handoffLatestMoquiMatrixRegressionCount = Number(handoffQuality.latest_moqui_matrix_regression_count);
+  const handoffLatestMoquiMatrixRegressionGateMax = Number(handoffQuality.latest_moqui_matrix_regression_gate_max);
+  const handoffMoquiMatrixRegressionPositiveRate = Number(handoffQuality.moqui_matrix_regression_positive_rate_percent);
   const handoffPreflightBlocked = parseAutoHandoffGateBoolean(
     handoffQuality.latest_release_gate_preflight_blocked,
     null
   );
+  const handoffMatrixRegressionPositive = (
+    Number.isFinite(handoffLatestMoquiMatrixRegressionCount) &&
+    handoffLatestMoquiMatrixRegressionCount > 0
+  );
+  const handoffMatrixRegressionOverGate = (
+    handoffMatrixRegressionPositive &&
+    Number.isFinite(handoffLatestMoquiMatrixRegressionGateMax) &&
+    handoffLatestMoquiMatrixRegressionCount > handoffLatestMoquiMatrixRegressionGateMax
+  );
+  const handoffMatrixRegressionPressureHigh = (
+    Number.isFinite(handoffMoquiMatrixRegressionPositiveRate) &&
+    handoffMoquiMatrixRegressionPositiveRate >= 50
+  );
+  const handoffCapabilityLexiconUnknownPositive = (
+    (Number.isFinite(handoffLatestCapabilityExpectedUnknownCount) && handoffLatestCapabilityExpectedUnknownCount > 0) ||
+    (Number.isFinite(handoffLatestCapabilityProvidedUnknownCount) && handoffLatestCapabilityProvidedUnknownCount > 0)
+  );
+  const handoffCapabilityLexiconUnknownPressureHigh = (
+    (Number.isFinite(handoffCapabilityExpectedUnknownPositiveRate) && handoffCapabilityExpectedUnknownPositiveRate >= 50) ||
+    (Number.isFinite(handoffCapabilityProvidedUnknownPositiveRate) && handoffCapabilityProvidedUnknownPositiveRate >= 50)
+  );
 
   let riskLevel = 'low';
   if (failureRate >= 40 || pendingGoals >= 5) {
@@ -17461,7 +18386,11 @@ function deriveGovernanceRiskLevel(summary) {
       handoffFailed ||
       handoffHighFailureRate ||
       handoffPreflightBlocked === true ||
-      (handoffLatestGatePassed === false && handoffSevereQualityDrop)
+      handoffMatrixRegressionOverGate ||
+      handoffCapabilityLexiconUnknownPositive ||
+      (handoffLatestGatePassed === false && handoffSevereQualityDrop) ||
+      (handoffMatrixRegressionPositive && handoffMatrixRegressionPressureHigh) ||
+      handoffCapabilityLexiconUnknownPressureHigh
     ) {
       riskLevel = 'high';
     } else if (
@@ -17470,7 +18399,11 @@ function deriveGovernanceRiskLevel(summary) {
         (Number.isFinite(handoffGatePassRate) && handoffGatePassRate < 85) ||
         (Number.isFinite(handoffCapabilityPassRate) && handoffCapabilityPassRate < 85) ||
         (Number.isFinite(handoffLatestOntologyScore) && handoffLatestOntologyScore < 85) ||
-        (Number.isFinite(handoffFailureRate) && handoffFailureRate > 0)
+        (Number.isFinite(handoffFailureRate) && handoffFailureRate > 0) ||
+        handoffMatrixRegressionPositive ||
+        (Number.isFinite(handoffMoquiMatrixRegressionPositiveRate) && handoffMoquiMatrixRegressionPositiveRate > 0) ||
+        (Number.isFinite(handoffCapabilityExpectedUnknownPositiveRate) && handoffCapabilityExpectedUnknownPositiveRate > 0) ||
+        (Number.isFinite(handoffCapabilityProvidedUnknownPositiveRate) && handoffCapabilityProvidedUnknownPositiveRate > 0)
       )
     ) {
       riskLevel = 'medium';
@@ -17505,6 +18438,22 @@ function buildGovernanceConcerns(summary) {
   const handoffLatestOntologyScore = Number(handoffQuality.latest_ontology_quality_score);
   const handoffFailureRate = Number(handoffQuality.failure_rate_percent);
   const handoffCapabilityPassRate = Number(handoffQuality.capability_coverage_pass_rate_percent);
+  const handoffLatestCapabilityExpectedUnknownCount = Number(
+    handoffQuality.latest_capability_expected_unknown_count
+  );
+  const handoffLatestCapabilityProvidedUnknownCount = Number(
+    handoffQuality.latest_capability_provided_unknown_count
+  );
+  const handoffCapabilityExpectedUnknownPositiveRate = Number(
+    handoffQuality.capability_expected_unknown_positive_rate_percent
+  );
+  const handoffCapabilityProvidedUnknownPositiveRate = Number(
+    handoffQuality.capability_provided_unknown_positive_rate_percent
+  );
+  const handoffLatestMoquiMatrixRegressionCount = Number(handoffQuality.latest_moqui_matrix_regression_count);
+  const handoffLatestMoquiMatrixRegressionGateMax = Number(handoffQuality.latest_moqui_matrix_regression_gate_max);
+  const handoffMaxMoquiMatrixRegressionCount = Number(handoffQuality.max_moqui_matrix_regression_count);
+  const handoffMoquiMatrixRegressionPositiveRate = Number(handoffQuality.moqui_matrix_regression_positive_rate_percent);
   const handoffPreflightBlocked = parseAutoHandoffGateBoolean(
     handoffQuality.latest_release_gate_preflight_blocked,
     null
@@ -17567,6 +18516,61 @@ function buildGovernanceConcerns(summary) {
     if (Number.isFinite(handoffCapabilityPassRate) && handoffCapabilityPassRate < 85) {
       concerns.push(`Handoff capability coverage pass rate is low at ${handoffCapabilityPassRate}%.`);
     }
+    if (
+      Number.isFinite(handoffLatestCapabilityExpectedUnknownCount) &&
+      handoffLatestCapabilityExpectedUnknownCount > 0
+    ) {
+      concerns.push(
+        `Latest handoff manifest capability unknown count is ${handoffLatestCapabilityExpectedUnknownCount}.`
+      );
+    }
+    if (
+      Number.isFinite(handoffLatestCapabilityProvidedUnknownCount) &&
+      handoffLatestCapabilityProvidedUnknownCount > 0
+    ) {
+      concerns.push(
+        `Latest handoff template capability unknown count is ${handoffLatestCapabilityProvidedUnknownCount}.`
+      );
+    }
+    if (
+      Number.isFinite(handoffCapabilityExpectedUnknownPositiveRate) &&
+      handoffCapabilityExpectedUnknownPositiveRate > 0
+    ) {
+      concerns.push(
+        `Handoff manifest capability unknown positive rate is ${handoffCapabilityExpectedUnknownPositiveRate}%.`
+      );
+    }
+    if (
+      Number.isFinite(handoffCapabilityProvidedUnknownPositiveRate) &&
+      handoffCapabilityProvidedUnknownPositiveRate > 0
+    ) {
+      concerns.push(
+        `Handoff template capability unknown positive rate is ${handoffCapabilityProvidedUnknownPositiveRate}%.`
+      );
+    }
+    if (Number.isFinite(handoffLatestMoquiMatrixRegressionCount) && handoffLatestMoquiMatrixRegressionCount > 0) {
+      concerns.push(
+        `Latest handoff Moqui matrix regression count is ${handoffLatestMoquiMatrixRegressionCount}.`
+      );
+    }
+    if (
+      Number.isFinite(handoffLatestMoquiMatrixRegressionCount) &&
+      Number.isFinite(handoffLatestMoquiMatrixRegressionGateMax) &&
+      handoffLatestMoquiMatrixRegressionCount > handoffLatestMoquiMatrixRegressionGateMax
+    ) {
+      concerns.push(
+        `Latest handoff Moqui matrix regressions exceed gate (${handoffLatestMoquiMatrixRegressionCount} > ` +
+        `${handoffLatestMoquiMatrixRegressionGateMax}).`
+      );
+    }
+    if (Number.isFinite(handoffMoquiMatrixRegressionPositiveRate) && handoffMoquiMatrixRegressionPositiveRate > 0) {
+      concerns.push(
+        `Handoff Moqui matrix regression positive rate is ${handoffMoquiMatrixRegressionPositiveRate}%.`
+      );
+    }
+    if (Number.isFinite(handoffMaxMoquiMatrixRegressionCount) && handoffMaxMoquiMatrixRegressionCount > 0) {
+      concerns.push(`Handoff Moqui matrix regression max is ${handoffMaxMoquiMatrixRegressionCount}.`);
+    }
   }
 
   return concerns;
@@ -17594,6 +18598,21 @@ function buildGovernanceRecommendations(summary) {
   const handoffLatestGatePassed = parseAutoHandoffGateBoolean(handoffQuality.latest_gate_passed, null);
   const handoffFailureRate = Number(handoffQuality.failure_rate_percent);
   const handoffCapabilityPassRate = Number(handoffQuality.capability_coverage_pass_rate_percent);
+  const handoffLatestCapabilityExpectedUnknownCount = Number(
+    handoffQuality.latest_capability_expected_unknown_count
+  );
+  const handoffLatestCapabilityProvidedUnknownCount = Number(
+    handoffQuality.latest_capability_provided_unknown_count
+  );
+  const handoffCapabilityExpectedUnknownPositiveRate = Number(
+    handoffQuality.capability_expected_unknown_positive_rate_percent
+  );
+  const handoffCapabilityProvidedUnknownPositiveRate = Number(
+    handoffQuality.capability_provided_unknown_positive_rate_percent
+  );
+  const handoffLatestMoquiMatrixRegressionCount = Number(handoffQuality.latest_moqui_matrix_regression_count);
+  const handoffLatestMoquiMatrixRegressionGateMax = Number(handoffQuality.latest_moqui_matrix_regression_gate_max);
+  const handoffMoquiMatrixRegressionPositiveRate = Number(handoffQuality.moqui_matrix_regression_positive_rate_percent);
   const handoffPreflightBlocked = parseAutoHandoffGateBoolean(
     handoffQuality.latest_release_gate_preflight_blocked,
     null
@@ -17635,6 +18654,15 @@ function buildGovernanceRecommendations(summary) {
       '`sce auto handoff run --manifest docs/handoffs/handoff-manifest.json --dry-run --json`.'
     );
   } else if (handoffTotalRuns > 0) {
+    const handoffMoquiMatrixRegressionPositive = (
+      Number.isFinite(handoffLatestMoquiMatrixRegressionCount) &&
+      handoffLatestMoquiMatrixRegressionCount > 0
+    );
+    const handoffMoquiMatrixRegressionOverGate = (
+      handoffMoquiMatrixRegressionPositive &&
+      Number.isFinite(handoffLatestMoquiMatrixRegressionGateMax) &&
+      handoffLatestMoquiMatrixRegressionCount > handoffLatestMoquiMatrixRegressionGateMax
+    );
     if (
       (handoffLatestStatus && !['completed', 'dry-run', 'dry_run'].includes(handoffLatestStatus)) ||
       handoffLatestGatePassed === false ||
@@ -17655,6 +18683,38 @@ function buildGovernanceRecommendations(summary) {
         '`sce auto handoff run --manifest docs/handoffs/handoff-manifest.json --dry-run --json`.'
       );
     }
+    if (
+      (Number.isFinite(handoffLatestCapabilityExpectedUnknownCount) && handoffLatestCapabilityExpectedUnknownCount > 0) ||
+      (Number.isFinite(handoffLatestCapabilityProvidedUnknownCount) && handoffLatestCapabilityProvidedUnknownCount > 0) ||
+      (Number.isFinite(handoffCapabilityExpectedUnknownPositiveRate) && handoffCapabilityExpectedUnknownPositiveRate > 0) ||
+      (Number.isFinite(handoffCapabilityProvidedUnknownPositiveRate) && handoffCapabilityProvidedUnknownPositiveRate > 0)
+    ) {
+      recommendations.push(
+        'Normalize capability lexicon gaps with ' +
+        '`node scripts/moqui-lexicon-audit.js --manifest docs/handoffs/handoff-manifest.json ' +
+        '--template-dir .kiro/templates/scene-packages --fail-on-gap --json`.'
+      );
+      recommendations.push(
+        'Re-run strict handoff lexicon gates with ' +
+        '`sce auto handoff run --manifest docs/handoffs/handoff-manifest.json --dry-run --json`.'
+      );
+    }
+    if (
+      handoffMoquiMatrixRegressionPositive ||
+      handoffMoquiMatrixRegressionOverGate ||
+      (Number.isFinite(handoffMoquiMatrixRegressionPositiveRate) && handoffMoquiMatrixRegressionPositiveRate > 0)
+    ) {
+      recommendations.push(
+        'Recover Moqui matrix regressions via ' +
+        '`sce auto handoff run --manifest docs/handoffs/handoff-manifest.json ' +
+        '--dry-run --max-moqui-matrix-regressions 0 --json`.'
+      );
+      recommendations.push(
+        'Inspect Moqui baseline matrix drift with ' +
+        '`sce scene moqui-baseline --include-all ' +
+        '--compare-with .kiro/reports/release-evidence/moqui-template-baseline.json --json`.'
+      );
+    }
   }
 
   return Array.from(new Set(recommendations));
@@ -19002,12 +20062,64 @@ function evaluateGovernanceReleaseGateBlockState(assessment) {
     if (handoffSnapshot.latest_capability_coverage_passed === false) {
       reasons.push('handoff-capability-coverage-failed');
     }
+    if (
+      Number.isFinite(handoffSnapshot.latest_capability_expected_unknown_count) &&
+      handoffSnapshot.latest_capability_expected_unknown_count > 0
+    ) {
+      reasons.push(
+        `handoff-capability-expected-unknown-positive:${handoffSnapshot.latest_capability_expected_unknown_count}`
+      );
+    }
+    if (
+      Number.isFinite(handoffSnapshot.latest_capability_provided_unknown_count) &&
+      handoffSnapshot.latest_capability_provided_unknown_count > 0
+    ) {
+      reasons.push(
+        `handoff-capability-provided-unknown-positive:${handoffSnapshot.latest_capability_provided_unknown_count}`
+      );
+    }
+    if (
+      Number.isFinite(handoffSnapshot.capability_expected_unknown_positive_rate_percent) &&
+      handoffSnapshot.capability_expected_unknown_positive_rate_percent > 0
+    ) {
+      reasons.push(
+        `handoff-capability-expected-unknown-positive-rate:` +
+        `${handoffSnapshot.capability_expected_unknown_positive_rate_percent}`
+      );
+    }
+    if (
+      Number.isFinite(handoffSnapshot.capability_provided_unknown_positive_rate_percent) &&
+      handoffSnapshot.capability_provided_unknown_positive_rate_percent > 0
+    ) {
+      reasons.push(
+        `handoff-capability-provided-unknown-positive-rate:` +
+        `${handoffSnapshot.capability_provided_unknown_positive_rate_percent}`
+      );
+    }
     if (handoffSnapshot.latest_release_gate_preflight_blocked === true) {
       reasons.push('handoff-release-preflight-blocked');
     }
     if (Number.isFinite(handoffSnapshot.failure_rate_percent) && handoffSnapshot.failure_rate_percent > 0) {
       reasons.push(`handoff-failure-rate-positive:${handoffSnapshot.failure_rate_percent}`);
     }
+    const handoffLatestMoquiMatrixRegressionCount = Number(handoffSnapshot.latest_moqui_matrix_regression_count);
+    const handoffLatestMoquiMatrixRegressionGateMax = Number(handoffSnapshot.latest_moqui_matrix_regression_gate_max);
+    if (
+      Number.isFinite(handoffLatestMoquiMatrixRegressionCount) &&
+      handoffLatestMoquiMatrixRegressionCount > 0
+    ) {
+      reasons.push(`handoff-moqui-matrix-regressions-positive:${handoffLatestMoquiMatrixRegressionCount}`);
+    }
+    if (
+      Number.isFinite(handoffLatestMoquiMatrixRegressionCount) &&
+      Number.isFinite(handoffLatestMoquiMatrixRegressionGateMax) &&
+      handoffLatestMoquiMatrixRegressionCount > handoffLatestMoquiMatrixRegressionGateMax
+    ) {
+      reasons.push(
+        `handoff-moqui-matrix-regressions-over-gate:` +
+        `${handoffLatestMoquiMatrixRegressionCount}/${handoffLatestMoquiMatrixRegressionGateMax}`
+      );
+    }
   }
 
   const blockedByReleaseGate = Boolean(
@@ -19024,7 +20136,13 @@ function evaluateGovernanceReleaseGateBlockState(assessment) {
     || `${item}` === 'handoff-latest-gate-failed'
     || `${item}`.startsWith('handoff-ontology-score-low:')
     || `${item}` === 'handoff-capability-coverage-failed'
+    || `${item}`.startsWith('handoff-capability-expected-unknown-positive:')
+    || `${item}`.startsWith('handoff-capability-provided-unknown-positive:')
+    || `${item}`.startsWith('handoff-capability-expected-unknown-positive-rate:')
+    || `${item}`.startsWith('handoff-capability-provided-unknown-positive-rate:')
     || `${item}` === 'handoff-release-preflight-blocked'
+    || `${item}`.startsWith('handoff-moqui-matrix-regressions-positive:')
+    || `${item}`.startsWith('handoff-moqui-matrix-regressions-over-gate:')
   ));
   const blocked = reasons.length > 0 && (blockedByReleaseGate || blockedByHandoffQuality);
   return {
@@ -19066,6 +20184,29 @@ function buildGovernanceCloseLoopRecommendations(finalAssessment, stopReason, st
       '`sce auto handoff run --manifest docs/handoffs/handoff-manifest.json --continue-from latest --continue-strategy failed-only --json`.'
     );
   }
+  if (reasons.some(item => `${item}`.startsWith('handoff-moqui-matrix-regressions-'))) {
+    base.push(
+      'Recover Moqui matrix regressions with ' +
+      '`sce auto handoff run --manifest docs/handoffs/handoff-manifest.json ' +
+      '--dry-run --max-moqui-matrix-regressions 0 --json`.'
+    );
+    base.push(
+      'Inspect Moqui matrix drift with ' +
+      '`sce scene moqui-baseline --include-all ' +
+      '--compare-with .kiro/reports/release-evidence/moqui-template-baseline.json --json`.'
+    );
+  }
+  if (reasons.some(item => `${item}`.startsWith('handoff-capability-') && `${item}`.includes('unknown'))) {
+    base.push(
+      'Normalize capability lexicon gaps with ' +
+      '`node scripts/moqui-lexicon-audit.js --manifest docs/handoffs/handoff-manifest.json ' +
+      '--template-dir .kiro/templates/scene-packages --fail-on-gap --json`.'
+    );
+    base.push(
+      'Re-run strict handoff gates after lexicon normalization with ' +
+      '`sce auto handoff run --manifest docs/handoffs/handoff-manifest.json --dry-run --json`.'
+    );
+  }
   return Array.from(new Set(base));
 }