scene-capability-engine 3.0.8 → 3.2.0

package/docs/starter-kit/handoff-manifest.starter.json

@@ -0,0 +1,32 @@
+{
+  "timestamp": "2026-02-20T00:00:00.000Z",
+  "source_project": "E:/workspace/your-project",
+  "specs": [
+    {
+      "id": "60-10-example-capability-spec",
+      "status": "completed",
+      "scene_package": ".kiro/specs/60-10-example-capability-spec/custom/scene-package.json",
+      "scene_manifest": ".kiro/specs/60-10-example-capability-spec/custom/scene.yaml"
+    }
+  ],
+  "templates": [
+    "sce.scene--example-capability-template--0.1.0"
+  ],
+  "capabilities": [
+    "example-capability-a",
+    "example-capability-b"
+  ],
+  "known_gaps": [],
+  "ontology_validation": {
+    "status": "passed",
+    "quality_score": 90,
+    "business_rules": {
+      "total": 1,
+      "mapped": 1
+    },
+    "decision_logic": {
+      "total": 1,
+      "resolved": 1
+    }
+  }
+}

package/docs/starter-kit/handoff-profile-ci.sample.yml

@@ -0,0 +1,53 @@
+name: Handoff Intake (Profile)
+
+on:
+  workflow_dispatch:
+    inputs:
+      profile:
+        description: "handoff profile: default|moqui|enterprise"
+        required: true
+        default: "moqui"
+      manifest:
+        description: "handoff manifest path"
+        required: true
+        default: "docs/handoffs/handoff-manifest.json"
+
+jobs:
+  handoff-intake:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+
+      - uses: actions/setup-node@v3
+        with:
+          node-version: "20.x"
+          cache: "npm"
+
+      - run: npm ci
+
+      - name: Validate capability matrix (profile scoped)
+        shell: bash
+        run: |
+          set -euo pipefail
+          PROFILE="${{ github.event.inputs.profile }}"
+          MANIFEST="${{ github.event.inputs.manifest }}"
+          npx sce auto handoff capability-matrix \
+            --manifest "${MANIFEST}" \
+            --profile "${PROFILE}" \
+            --fail-on-gap \
+            --json
+
+      - name: Execute handoff run (profile scoped)
+        shell: bash
+        run: |
+          set -euo pipefail
+          PROFILE="${{ github.event.inputs.profile }}"
+          MANIFEST="${{ github.event.inputs.manifest }}"
+          npx sce auto handoff run \
+            --manifest "${MANIFEST}" \
+            --profile "${PROFILE}" \
+            --json
+
+      - name: Build weekly ops summary
+        run: node scripts/release-ops-weekly-summary.js --json
+

package/docs/starter-kit/release.workflow.sample.yml

@@ -0,0 +1,41 @@
+name: Release Starter (SCE)
+
+on:
+  push:
+    tags:
+      - "v*"
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+
+      - uses: actions/setup-node@v3
+        with:
+          node-version: "20.x"
+          cache: "npm"
+
+      - run: npm ci
+      - run: npm test -- --runInBand
+      - run: node scripts/interactive-governance-report.js --period weekly --fail-on-alert --json
+
+      - name: Build release evidence cards
+        shell: bash
+        run: |
+          set -euo pipefail
+          TAG="${GITHUB_REF_NAME}"
+          NOTES_DIR=".kiro/reports/release-evidence"
+          mkdir -p "${NOTES_DIR}"
+
+          node scripts/release-ops-weekly-summary.js \
+            --out "${NOTES_DIR}/weekly-ops-summary-${TAG}.json" \
+            --markdown-out "${NOTES_DIR}/weekly-ops-summary-${TAG}.md" \
+            --json
+
+          RELEASE_TAG="${TAG}" \
+          RELEASE_EVIDENCE_SUMMARY_FILE="${NOTES_DIR}/release-evidence-summary-${TAG}.json" \
+          RELEASE_GOVERNANCE_SNAPSHOT_JSON="${NOTES_DIR}/governance-snapshot-${TAG}.json" \
+          RELEASE_GOVERNANCE_SNAPSHOT_MD="${NOTES_DIR}/governance-snapshot-${TAG}.md" \
+            node scripts/release-governance-snapshot-export.js
+

package/docs/zh/README.md

@@ -190,6 +190,12 @@
 - 主从编排与门禁增强
 - 跨轮次回归与发布治理集成
 
+### [Handoff Profile Integration Guide](../handoff-profile-integration-guide.md)
+**外部项目接入规范（英文）** - `default|moqui|enterprise` 三档 handoff profile 契约
+- profile 默认策略与显式参数覆盖规则
+- 外部项目 manifest/evidence 最小要求
+- 从 `moqui` 到 `enterprise` 的分阶段上线建议
+
 ### [Value 可观测指南](value-observability-guide.md)
 **KPI 量化交付指南** - 快照、基线、趋势、门禁证据
 - 周度 KPI 快照生成
@@ -207,6 +213,12 @@
 - 测试、命令冒烟、打包检查
 - 文档一致性和 Git 准备状态
 
+### [安全治理默认基线](../security-governance-default-baseline.md)
+**默认安全控制（英文）** - 上下文脱敏、审批策略、发布审计证据最小集合
+
+### [发布即用 Starter Kit](../starter-kit/README.md)
+**外部项目接入脚手架（英文）** - handoff manifest 样例与 release workflow 样例
+
 ### [发布归档](releases/README.md)
 **历史发布入口** - 集中查看发布说明与验证报告
 - 版本化发布说明

package/lib/auto/moqui-recovery-sequence.js

@@ -0,0 +1,62 @@
+'use strict';
+
+const DEFAULT_CLUSTER_GOALS_ARG = '.kiro/auto/matrix-remediation.capability-clusters.json';
+const DEFAULT_BASELINE_ARG = '.kiro/reports/release-evidence/moqui-template-baseline.json';
+const DEFAULT_CLUSTER_PHASED_ALIAS = 'npm run run:matrix-remediation-clusters-phased -- --json';
+const DEFAULT_CLUSTER_BATCH_ALIAS = 'npm run run:matrix-remediation-clusters';
+const DEFAULT_BASELINE_PHASED_ALIAS = 'npm run run:matrix-remediation-from-baseline -- --json';
+
+function buildMoquiRegressionRecoverySequenceLines(options = {}) {
+  const clusterGoalsArg = options.clusterGoalsArg || DEFAULT_CLUSTER_GOALS_ARG;
+  const baselineArg = options.baselineArg || DEFAULT_BASELINE_ARG;
+  const clusterPhasedCommand = options.clusterPhasedCommand
+    || `node scripts/moqui-matrix-remediation-phased-runner.js --cluster-goals ${clusterGoalsArg} --json`;
+  const clusterBatchCommand = options.clusterBatchCommand
+    || `sce auto close-loop-batch ${clusterGoalsArg} --format json --batch-parallel 1 --batch-agent-budget 2 --batch-retry-until-complete --json`;
+  const baselinePhasedCommand = options.baselinePhasedCommand
+    || `node scripts/moqui-matrix-remediation-phased-runner.js --baseline ${baselineArg} --json`;
+  const clusterPhasedAlias = options.clusterPhasedAlias || DEFAULT_CLUSTER_PHASED_ALIAS;
+  const clusterBatchAlias = options.clusterBatchAlias || DEFAULT_CLUSTER_BATCH_ALIAS;
+  const baselinePhasedAlias = options.baselinePhasedAlias || DEFAULT_BASELINE_PHASED_ALIAS;
+
+  const includeLabel = options.includeLabel !== false;
+  const includeStep1Alias = options.includeStep1Alias !== false;
+  const includeStep1Fallback = options.includeStep1Fallback !== false;
+  const includeStep1FallbackAlias = options.includeStep1FallbackAlias !== false;
+  const includeStep2Alias = options.includeStep2Alias !== false;
+
+  const wrapCommands = options.wrapCommands === true;
+  const withPeriod = options.withPeriod === true;
+  const formatCommand = command => (wrapCommands ? `\`${command}\`` : command);
+  const suffix = withPeriod ? '.' : '';
+  const lines = [];
+
+  if (includeLabel) {
+    lines.push('Moqui regression recovery sequence (recommended):');
+  }
+  lines.push(`Step 1 (Cluster phased): ${formatCommand(clusterPhasedCommand)}${suffix}`);
+  if (includeStep1Alias) {
+    lines.push(`Step 1 alias: ${formatCommand(clusterPhasedAlias)}${suffix}`);
+  }
+  if (includeStep1Fallback) {
+    lines.push(`Step 1 fallback (cluster batch): ${formatCommand(clusterBatchCommand)}${suffix}`);
+  }
+  if (includeStep1FallbackAlias) {
+    lines.push(`Step 1 fallback alias: ${formatCommand(clusterBatchAlias)}${suffix}`);
+  }
+  lines.push(`Step 2 (Baseline phased): ${formatCommand(baselinePhasedCommand)}${suffix}`);
+  if (includeStep2Alias) {
+    lines.push(`Step 2 alias: ${formatCommand(baselinePhasedAlias)}${suffix}`);
+  }
+
+  return lines;
+}
+
+module.exports = {
+  DEFAULT_CLUSTER_GOALS_ARG,
+  DEFAULT_BASELINE_ARG,
+  DEFAULT_CLUSTER_PHASED_ALIAS,
+  DEFAULT_CLUSTER_BATCH_ALIAS,
+  DEFAULT_BASELINE_PHASED_ALIAS,
+  buildMoquiRegressionRecoverySequenceLines
+};

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) {
@@ -8712,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)) {
@@ -10850,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
+    )
   };
 }
 
@@ -11741,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(
@@ -11834,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) {
@@ -11867,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} ` +
@@ -13409,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.');
@@ -13505,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'}`,
@@ -13599,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 }),
@@ -18911,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
+      }));
     }
   }
 
@@ -20392,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(