scene-capability-engine 3.0.7 → 3.1.0

package/lib/commands/auto.js

@@ -6,6 +6,7 @@ const AutonomousEngine = require('../auto/autonomous-engine');
 const { mergeConfigs, DEFAULT_CONFIG } = require('../auto/config-schema');
 const { runAutoCloseLoop } = require('../auto/close-loop-runner');
 const { analyzeGoalSemantics } = require('../auto/semantic-decomposer');
+const { buildMoquiRegressionRecoverySequenceLines } = require('../auto/moqui-recovery-sequence');
 const MOQUI_CAPABILITY_LEXICON = require('../data/moqui-capability-lexicon.json');
 const fs = require('fs-extra');
 const path = require('path');
@@ -27,8 +28,68 @@ const AUTO_HANDOFF_SCENE_PACKAGE_BATCH_TASK_QUEUE_FILE = '.kiro/auto/ontology-re
 const AUTO_HANDOFF_MOQUI_CAPABILITY_COVERAGE_JSON_FILE = '.kiro/reports/release-evidence/moqui-capability-coverage.json';
 const AUTO_HANDOFF_MOQUI_CAPABILITY_COVERAGE_MARKDOWN_FILE = '.kiro/reports/release-evidence/moqui-capability-coverage.md';
 const AUTO_HANDOFF_MOQUI_REMEDIATION_QUEUE_FILE = '.kiro/auto/moqui-remediation.lines';
+const AUTO_HANDOFF_MOQUI_CLUSTER_REMEDIATION_FILE = '.kiro/auto/matrix-remediation.capability-clusters.json';
 const AUTO_HANDOFF_CLI_SCRIPT_FILE = path.resolve(__dirname, '..', '..', 'bin', 'scene-capability-engine.js');
 const MOQUI_CAPABILITY_LEXICON_INDEX = buildMoquiCapabilityLexiconIndex(MOQUI_CAPABILITY_LEXICON);
+const AUTO_HANDOFF_POLICY_PROFILE_PRESETS = {
+  default: {
+    min_spec_success_rate: 100,
+    max_risk_level: 'high',
+    min_ontology_score: 0,
+    min_capability_coverage_percent: 100,
+    min_capability_semantic_percent: 100,
+    max_moqui_matrix_regressions: 0,
+    max_unmapped_rules: null,
+    max_undecided_decisions: null,
+    require_ontology_validation: true,
+    require_moqui_baseline: true,
+    require_scene_package_batch: true,
+    require_capability_coverage: true,
+    require_capability_semantic: true,
+    require_capability_lexicon: true,
+    require_release_gate_preflight: false,
+    dependency_batching: true,
+    release_evidence_window: 5
+  },
+  moqui: {
+    min_spec_success_rate: 100,
+    max_risk_level: 'high',
+    min_ontology_score: 0,
+    min_capability_coverage_percent: 100,
+    min_capability_semantic_percent: 100,
+    max_moqui_matrix_regressions: 0,
+    max_unmapped_rules: null,
+    max_undecided_decisions: null,
+    require_ontology_validation: true,
+    require_moqui_baseline: true,
+    require_scene_package_batch: true,
+    require_capability_coverage: true,
+    require_capability_semantic: true,
+    require_capability_lexicon: true,
+    require_release_gate_preflight: false,
+    dependency_batching: true,
+    release_evidence_window: 5
+  },
+  enterprise: {
+    min_spec_success_rate: 100,
+    max_risk_level: 'medium',
+    min_ontology_score: 0,
+    min_capability_coverage_percent: 100,
+    min_capability_semantic_percent: 100,
+    max_moqui_matrix_regressions: 0,
+    max_unmapped_rules: null,
+    max_undecided_decisions: null,
+    require_ontology_validation: true,
+    require_moqui_baseline: true,
+    require_scene_package_batch: true,
+    require_capability_coverage: true,
+    require_capability_semantic: true,
+    require_capability_lexicon: true,
+    require_release_gate_preflight: true,
+    dependency_batching: true,
+    release_evidence_window: 10
+  }
+};
 
 /**
  * Register auto commands
@@ -1532,6 +1593,7 @@ function registerAutoCommands(program) {
     .command('capability-matrix')
     .description('Build Moqui template capability matrix from handoff manifest and local template library')
     .requiredOption('--manifest <path>', 'Path to handoff-manifest.json')
+    .option('--profile <profile>', 'Handoff policy profile: default|moqui|enterprise (default: default)', 'default')
     .option('--strict', 'Fail when manifest validation contains errors')
     .option('--strict-warnings', 'Fail when manifest validation contains warnings')
     .option('--min-capability-coverage <n>', 'Minimum Moqui capability coverage percent (default: 100)', parseFloat)
@@ -1567,6 +1629,7 @@ function registerAutoCommands(program) {
           console.log(chalk.blue('Auto handoff capability matrix:'));
           console.log(chalk.gray(`  Status: ${result.status}`));
           console.log(chalk.gray(`  Manifest: ${result.manifest_path}`));
+          console.log(chalk.gray(`  Policy profile: ${result.policy && result.policy.profile ? result.policy.profile : 'default'}`));
           console.log(chalk.gray(`  Capabilities: ${result.handoff.capability_count}`));
           if (result.capability_coverage && result.capability_coverage.summary) {
             const summary = result.capability_coverage.summary;
@@ -1871,6 +1934,7 @@ function registerAutoCommands(program) {
     .command('run')
     .description('Execute handoff integration pipeline: plan -> queue -> close-loop-batch -> observability')
     .requiredOption('--manifest <path>', 'Path to handoff-manifest.json')
+    .option('--profile <profile>', 'Handoff policy profile: default|moqui|enterprise (default: default)', 'default')
     .option('--out <path>', 'Write handoff run report JSON to file')
     .option('--queue-out <path>', `Queue output file (default: ${AUTO_HANDOFF_DEFAULT_QUEUE_FILE})`, AUTO_HANDOFF_DEFAULT_QUEUE_FILE)
     .option('--append', 'Append generated goals to existing queue file')
@@ -1889,7 +1953,7 @@ function registerAutoCommands(program) {
     .option('--batch-retry-until-complete', 'Retry until all goals complete or retry max is reached')
     .option('--batch-retry-max-rounds <n>', 'Max retry rounds when --batch-retry-until-complete is enabled', parseInt)
     .option('--min-spec-success-rate <n>', 'Gate: minimum handoff spec success rate percent (default: 100)', parseFloat)
-    .option('--max-risk-level <level>', 'Gate: maximum allowed risk level (low|medium|high)', 'high')
+    .option('--max-risk-level <level>', 'Gate: maximum allowed risk level (low|medium|high)')
     .option('--min-ontology-score <n>', 'Gate: minimum ontology quality score (0-100, default: 0)', parseFloat)
     .option('--max-unmapped-rules <n>', 'Gate: maximum allowed unmapped business rules (optional)', parseInt)
     .option('--max-undecided-decisions <n>', 'Gate: maximum allowed undecided decisions (optional)', parseInt)
@@ -1919,6 +1983,7 @@ function registerAutoCommands(program) {
           console.log(chalk.gray(`  Session: ${result.session_id}`));
           console.log(chalk.gray(`  Status: ${result.status}`));
           console.log(chalk.gray(`  Manifest: ${result.manifest_path}`));
+          console.log(chalk.gray(`  Policy profile: ${result.policy && result.policy.profile ? result.policy.profile : 'default'}`));
           console.log(chalk.gray(`  Specs: ${result.handoff && result.handoff.spec_count ? result.handoff.spec_count : 0}`));
           console.log(chalk.gray(`  Queue goals: ${result.queue && result.queue.goal_count ? result.queue.goal_count : 0}`));
           if (result.template_diff) {
@@ -4701,6 +4766,67 @@ function buildBatchMetrics(results, totalGoals) {
   };
 }
 
+function applyAdaptiveRateLimitBackpressure({
+  currentBatchParallel,
+  currentBatchAgentBudget,
+  rateLimitSignals,
+  rateLimitBackoffMs,
+  rateLimitLaunchHoldMs,
+  inputGoals
+}) {
+  const next = {
+    batchParallel: Number.isInteger(currentBatchParallel) ? currentBatchParallel : 1,
+    batchAgentBudget: currentBatchAgentBudget,
+    applied: false,
+    level: 'none',
+    signalsPerGoal: 0
+  };
+
+  const safeGoals = Math.max(1, Number(inputGoals) || 1);
+  const normalizedSignals = Math.max(0, Number(rateLimitSignals) || 0);
+  const normalizedBackoffMs = Math.max(0, Number(rateLimitBackoffMs) || 0);
+  const normalizedLaunchHoldMs = Math.max(0, Number(rateLimitLaunchHoldMs) || 0);
+  const signalsPerGoal = normalizedSignals / safeGoals;
+  next.signalsPerGoal = Number(signalsPerGoal.toFixed(2));
+
+  if (normalizedSignals <= 0 && normalizedBackoffMs <= 0 && normalizedLaunchHoldMs <= 0) {
+    return next;
+  }
+
+  const severePressure = (
+    signalsPerGoal >= 1.5 ||
+    normalizedBackoffMs >= 4000 ||
+    normalizedLaunchHoldMs >= 2000
+  );
+  next.level = severePressure ? 'severe' : 'mild';
+
+  const normalizePositiveInteger = (value, fallback = 1) => {
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < 1) {
+      return fallback;
+    }
+    return parsed;
+  };
+
+  const currentParallel = normalizePositiveInteger(next.batchParallel, 1);
+  const reducedParallel = severePressure
+    ? Math.max(1, Math.floor(currentParallel / 2))
+    : Math.max(1, currentParallel - 1);
+  next.batchParallel = reducedParallel;
+  next.applied = reducedParallel !== currentParallel;
+
+  if (currentBatchAgentBudget !== null && currentBatchAgentBudget !== undefined) {
+    const currentBudget = normalizePositiveInteger(currentBatchAgentBudget, 1);
+    const reducedBudget = severePressure
+      ? Math.max(1, Math.floor(currentBudget / 2))
+      : Math.max(1, currentBudget - 1);
+    next.batchAgentBudget = reducedBudget;
+    next.applied = next.applied || reducedBudget !== currentBudget;
+  }
+
+  return next;
+}
+
 async function runCloseLoopBatchGoals(goals, options) {
   const continueOnError = Boolean(options.continueOnError);
   const batchParallel = normalizeBatchParallel(options.batchParallel);
@@ -4996,16 +5122,25 @@ async function runCloseLoopBatchWithRetries(goals, options) {
     let nextBatchParallel = adaptiveBatchParallel;
     let nextBatchAgentBudget = adaptiveBatchAgentBudget;
     let adaptiveBackpressureApplied = false;
+    let backpressureLevel = 'none';
+    let roundRateLimitSignalsPerGoal = Number(
+      (roundRateLimitSignals / Math.max(1, pendingEntries.length)).toFixed(2)
+    );
     const hasRateLimitPressure = roundRateLimitSignals > 0 || roundRateLimitBackoffMs > 0 || roundMaxLaunchHoldMs > 0;
     if (retryStrategy === 'adaptive' && retryEntries.length > 0 && hasRateLimitPressure) {
-      if (nextBatchParallel > 1) {
-        nextBatchParallel -= 1;
-        adaptiveBackpressureApplied = true;
-      }
-      if (nextBatchAgentBudget !== null && nextBatchAgentBudget > 1) {
-        nextBatchAgentBudget -= 1;
-        adaptiveBackpressureApplied = true;
-      }
+      const backpressure = applyAdaptiveRateLimitBackpressure({
+        currentBatchParallel: adaptiveBatchParallel,
+        currentBatchAgentBudget: adaptiveBatchAgentBudget,
+        rateLimitSignals: roundRateLimitSignals,
+        rateLimitBackoffMs: roundRateLimitBackoffMs,
+        rateLimitLaunchHoldMs: roundMaxLaunchHoldMs,
+        inputGoals: pendingEntries.length
+      });
+      nextBatchParallel = backpressure.batchParallel;
+      nextBatchAgentBudget = backpressure.batchAgentBudget;
+      adaptiveBackpressureApplied = backpressure.applied;
+      backpressureLevel = backpressure.level;
+      roundRateLimitSignalsPerGoal = backpressure.signalsPerGoal;
     }
 
     retryHistory.push({
@@ -5019,9 +5154,11 @@ async function runCloseLoopBatchWithRetries(goals, options) {
       unprocessed_goals: unprocessedCount,
       stopped_early: Boolean(run.stoppedEarly),
       rate_limit_signals: roundRateLimitSignals,
+      rate_limit_signals_per_goal: roundRateLimitSignalsPerGoal,
       rate_limit_backoff_ms: roundRateLimitBackoffMs,
       rate_limit_launch_hold_ms: roundMaxLaunchHoldMs,
       adaptive_backpressure_applied: adaptiveBackpressureApplied,
+      backpressure_level: backpressureLevel,
       next_batch_parallel: nextBatchParallel,
       next_batch_agent_budget: nextBatchAgentBudget
     });
@@ -8640,6 +8777,12 @@ function buildAutoHandoffRegressionRecommendations(payload = {}) {
       '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`.'
     );
+    for (const line of buildMoquiRegressionRecoverySequenceLines({
+      wrapCommands: true,
+      withPeriod: true
+    })) {
+      push(line);
+    }
   }
 
   if ((payload.window && Number(payload.window.actual) > 0) && (payload.window.requested !== payload.window.actual)) {
@@ -10778,29 +10921,144 @@ function normalizeHandoffReleaseEvidenceWindow(windowCandidate) {
   return parsed;
 }
 
+function normalizeAutoHandoffPolicyProfile(profileCandidate, optionName = '--profile') {
+  const normalized = typeof profileCandidate === 'string'
+    ? profileCandidate.trim().toLowerCase()
+    : 'default';
+  if (!normalized) {
+    return 'default';
+  }
+  if (!AUTO_HANDOFF_POLICY_PROFILE_PRESETS[normalized]) {
+    const allowed = Object.keys(AUTO_HANDOFF_POLICY_PROFILE_PRESETS).join(', ');
+    throw new Error(`${optionName} must be one of: ${allowed}.`);
+  }
+  return normalized;
+}
+
+function resolveAutoHandoffPolicyPreset(profileCandidate, optionName) {
+  const profile = normalizeAutoHandoffPolicyProfile(profileCandidate, optionName);
+  const preset = AUTO_HANDOFF_POLICY_PROFILE_PRESETS[profile];
+  return {
+    profile,
+    preset: {
+      ...preset
+    }
+  };
+}
+
+function resolveAutoHandoffPolicyOptionNumber(valueCandidate, fallbackValue) {
+  if (valueCandidate === undefined || valueCandidate === null || valueCandidate === '') {
+    return fallbackValue;
+  }
+  return valueCandidate;
+}
+
+function resolveAutoHandoffPolicyOptionBoolean(valueCandidate, fallbackValue) {
+  if (valueCandidate === undefined || valueCandidate === null) {
+    return fallbackValue === true;
+  }
+  return valueCandidate === true;
+}
+
 function buildAutoHandoffRunPolicy(options = {}) {
+  const { profile, preset } = resolveAutoHandoffPolicyPreset(options.profile, '--profile');
   return {
-    min_spec_success_rate: normalizeHandoffMinSpecSuccessRate(options.minSpecSuccessRate),
-    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),
+    profile,
+    min_spec_success_rate: normalizeHandoffMinSpecSuccessRate(
+      resolveAutoHandoffPolicyOptionNumber(options.minSpecSuccessRate, preset.min_spec_success_rate)
+    ),
+    max_risk_level: normalizeHandoffRiskLevel(
+      resolveAutoHandoffPolicyOptionNumber(options.maxRiskLevel, preset.max_risk_level)
+    ),
+    min_ontology_score: normalizeHandoffMinOntologyScore(
+      resolveAutoHandoffPolicyOptionNumber(options.minOntologyScore, preset.min_ontology_score)
+    ),
+    min_capability_coverage_percent: normalizeHandoffMinCapabilityCoverage(
+      resolveAutoHandoffPolicyOptionNumber(
+        options.minCapabilityCoverage,
+        preset.min_capability_coverage_percent
+      )
+    ),
+    max_moqui_matrix_regressions: normalizeHandoffMaxMoquiMatrixRegressions(
+      resolveAutoHandoffPolicyOptionNumber(
+        options.maxMoquiMatrixRegressions,
+        preset.max_moqui_matrix_regressions
+      )
+    ),
     max_unmapped_rules: normalizeHandoffOptionalNonNegativeInteger(
-      options.maxUnmappedRules,
+      resolveAutoHandoffPolicyOptionNumber(options.maxUnmappedRules, preset.max_unmapped_rules),
       '--max-unmapped-rules'
     ),
     max_undecided_decisions: normalizeHandoffOptionalNonNegativeInteger(
-      options.maxUndecidedDecisions,
+      resolveAutoHandoffPolicyOptionNumber(options.maxUndecidedDecisions, preset.max_undecided_decisions),
       '--max-undecided-decisions'
     ),
-    require_ontology_validation: options.requireOntologyValidation !== false,
-    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)
+    require_ontology_validation: resolveAutoHandoffPolicyOptionBoolean(
+      options.requireOntologyValidation,
+      preset.require_ontology_validation
+    ),
+    require_moqui_baseline: resolveAutoHandoffPolicyOptionBoolean(
+      options.requireMoquiBaseline,
+      preset.require_moqui_baseline
+    ),
+    require_scene_package_batch: resolveAutoHandoffPolicyOptionBoolean(
+      options.requireScenePackageBatch,
+      preset.require_scene_package_batch
+    ),
+    require_capability_coverage: resolveAutoHandoffPolicyOptionBoolean(
+      options.requireCapabilityCoverage,
+      preset.require_capability_coverage
+    ),
+    require_capability_lexicon: resolveAutoHandoffPolicyOptionBoolean(
+      options.requireCapabilityLexicon,
+      preset.require_capability_lexicon
+    ),
+    require_release_gate_preflight: resolveAutoHandoffPolicyOptionBoolean(
+      options.requireReleaseGatePreflight,
+      preset.require_release_gate_preflight
+    ),
+    dependency_batching: resolveAutoHandoffPolicyOptionBoolean(
+      options.dependencyBatching,
+      preset.dependency_batching
+    ),
+    release_evidence_window: normalizeHandoffReleaseEvidenceWindow(
+      resolveAutoHandoffPolicyOptionNumber(options.releaseEvidenceWindow, preset.release_evidence_window)
+    )
+  };
+}
+
+function buildAutoHandoffCapabilityMatrixPolicy(options = {}) {
+  const { profile, preset } = resolveAutoHandoffPolicyPreset(options.profile, '--profile');
+  return {
+    profile,
+    min_capability_coverage_percent: normalizeHandoffMinCapabilityCoverage(
+      resolveAutoHandoffPolicyOptionNumber(
+        options.minCapabilityCoverage,
+        preset.min_capability_coverage_percent
+      )
+    ),
+    min_capability_semantic_percent: normalizeHandoffMinCapabilitySemantic(
+      resolveAutoHandoffPolicyOptionNumber(
+        options.minCapabilitySemantic,
+        preset.min_capability_semantic_percent
+      )
+    ),
+    require_capability_coverage: resolveAutoHandoffPolicyOptionBoolean(
+      options.requireCapabilityCoverage,
+      preset.require_capability_coverage
+    ),
+    require_capability_semantic: resolveAutoHandoffPolicyOptionBoolean(
+      options.requireCapabilitySemantic,
+      preset.require_capability_semantic
+    ),
+    require_capability_lexicon: resolveAutoHandoffPolicyOptionBoolean(
+      options.requireCapabilityLexicon,
+      preset.require_capability_lexicon
+    ),
+    require_moqui_baseline: resolveAutoHandoffPolicyOptionBoolean(
+      options.requireMoquiBaseline,
+      preset.require_moqui_baseline
+    )
   };
 }
 
@@ -11669,6 +11927,27 @@ function buildAutoHandoffRunRecommendations(projectPath, result) {
   const processedGoals = Number(summary && summary.processed_goals) || 0;
   const failedGoals = Number(summary && summary.failed_goals) || 0;
   const hasPendingOrFailed = totalGoals > 0 && (failedGoals > 0 || processedGoals < totalGoals);
+  const moquiBaseline = result && result.moqui_baseline && typeof result.moqui_baseline === 'object'
+    ? result.moqui_baseline
+    : null;
+  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);
+  const pushMoquiClusterFirstRecoverySequence = () => {
+    const lines = buildMoquiRegressionRecoverySequenceLines({
+      clusterGoalsArg: quoteCliArg(AUTO_HANDOFF_MOQUI_CLUSTER_REMEDIATION_FILE),
+      baselineArg: quoteCliArg(AUTO_HANDOFF_MOQUI_BASELINE_JSON_FILE),
+      wrapCommands: false,
+      withPeriod: false
+    });
+    for (const line of lines) {
+      push(line);
+    }
+  };
 
   if (manifestPath && result.session_id && hasPendingOrFailed) {
     push(
@@ -11762,18 +12041,11 @@ function buildAutoHandoffRunRecommendations(projectPath, result) {
         toAutoHandoffCliPath(projectPath, result.remediation_queue.file)
       )} --format lines --json`
     );
+    if (moquiCoverageRegressions.length > 0) {
+      pushMoquiClusterFirstRecoverySequence();
+    }
   }
 
-  const moquiBaseline = result && result.moqui_baseline && typeof result.moqui_baseline === 'object'
-    ? result.moqui_baseline
-    : null;
-  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) {
@@ -11795,6 +12067,7 @@ function buildAutoHandoffRunRecommendations(projectPath, result) {
       'sce scene moqui-baseline --include-all ' +
       '--compare-with .kiro/reports/release-evidence/moqui-template-baseline.json --json'
     );
+    pushMoquiClusterFirstRecoverySequence();
     if (manifestPath) {
       push(
         `sce auto handoff run --manifest ${manifestCli} ` +
@@ -13337,6 +13610,14 @@ function buildAutoHandoffCapabilityMatrixRecommendations(result = {}) {
       `Recover Moqui matrix regressions: ` +
       `${baselineRegressions.slice(0, 3).map(item => `${item.label}:${item.delta_rate_percent}%`).join(' | ')}`
     );
+    for (const line of buildMoquiRegressionRecoverySequenceLines({
+      clusterGoalsArg: quoteCliArg(AUTO_HANDOFF_MOQUI_CLUSTER_REMEDIATION_FILE),
+      baselineArg: quoteCliArg(AUTO_HANDOFF_MOQUI_BASELINE_JSON_FILE),
+      wrapCommands: false,
+      withPeriod: false
+    })) {
+      push(line);
+    }
   }
   if (capabilityCoverage.status === 'skipped') {
     push('Declare `capabilities` in handoff manifest to enable capability matrix coverage gates.');
@@ -13433,6 +13714,7 @@ function renderAutoHandoffCapabilityMatrixMarkdown(payload = {}) {
     `- Specs: ${handoff.spec_count !== undefined ? handoff.spec_count : 'n/a'}`,
     `- Templates: ${handoff.template_count !== undefined ? handoff.template_count : 'n/a'}`,
     `- Capabilities: ${handoff.capability_count !== undefined ? handoff.capability_count : 'n/a'}`,
+    `- Policy profile: ${policy.profile || 'default'}`,
     `- 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'}`,
@@ -13527,14 +13809,7 @@ async function buildAutoHandoffCapabilityMatrix(projectPath, options = {}) {
     strictWarnings: options.strictWarnings
   });
 
-  const policy = {
-    min_capability_coverage_percent: normalizeHandoffMinCapabilityCoverage(options.minCapabilityCoverage),
-    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
-  };
+  const policy = buildAutoHandoffCapabilityMatrixPolicy(options);
 
   const [templateDiff, moquiBaseline, capabilityCoverage] = await Promise.all([
     buildAutoHandoffTemplateDiff(projectPath, { handoff: plan.handoff }),
@@ -18839,6 +19114,10 @@ function buildGovernanceRecommendations(summary) {
         '`sce scene moqui-baseline --include-all ' +
         '--compare-with .kiro/reports/release-evidence/moqui-template-baseline.json --json`.'
       );
+      recommendations.push(...buildMoquiRegressionRecoverySequenceLines({
+        wrapCommands: true,
+        withPeriod: true
+      }));
     }
   }
 
@@ -20320,6 +20599,10 @@ function buildGovernanceCloseLoopRecommendations(finalAssessment, stopReason, st
       '`sce scene moqui-baseline --include-all ' +
       '--compare-with .kiro/reports/release-evidence/moqui-template-baseline.json --json`.'
     );
+    base.push(...buildMoquiRegressionRecoverySequenceLines({
+      wrapCommands: true,
+      withPeriod: true
+    }));
   }
   if (reasons.some(item => `${item}`.startsWith('handoff-capability-') && `${item}`.includes('unknown'))) {
     base.push(