scene-capability-engine 3.3.23 → 3.3.25

package/lib/spec/domain-modeling.js

@@ -0,0 +1,439 @@
+const fs = require('fs-extra');
+const path = require('path');
+
+const DOMAIN_MAP_RELATIVE_PATH = path.join('custom', 'problem-domain-map.md');
+const SCENE_SPEC_RELATIVE_PATH = path.join('custom', 'scene-spec.md');
+const DOMAIN_CHAIN_RELATIVE_PATH = path.join('custom', 'problem-domain-chain.json');
+const DOMAIN_CHAIN_API_VERSION = 'sce.problem-domain-chain/v0.1';
+
+function normalizeText(value) {
+  if (typeof value !== 'string') {
+    return '';
+  }
+  return value.trim();
+}
+
+function resolveSpecPaths(projectPath, specId) {
+  const specPath = path.join(projectPath, '.sce', 'specs', specId);
+  return {
+    specPath,
+    domainMapPath: path.join(specPath, DOMAIN_MAP_RELATIVE_PATH),
+    sceneSpecPath: path.join(specPath, SCENE_SPEC_RELATIVE_PATH),
+    domainChainPath: path.join(specPath, DOMAIN_CHAIN_RELATIVE_PATH)
+  };
+}
+
+function buildProblemDomainMindMap(specId, options = {}) {
+  const sceneId = normalizeText(options.sceneId) || `scene.${specId.replace(/[^a-zA-Z0-9]+/g, '-').toLowerCase()}`;
+  const problemStatement = normalizeText(options.problemStatement) || 'TBD: describe the primary business problem';
+  const primaryFlow = normalizeText(options.primaryFlow) || 'TBD: define core user/business flow';
+  const verificationPlan = normalizeText(options.verificationPlan) || 'TBD: define validation and rollback criteria';
+
+  return `# Problem Domain Mind Map
+
+> Mandatory artifact: use this map to expand the problem domain before implementation.
+> Policy: after two failed fix rounds, diagnostics must be added before the next patch round.
+
+## Root Problem
+
+- Scene: \`${sceneId}\`
+- Spec: \`${specId}\`
+- Problem Statement: ${problemStatement}
+- Primary Flow: ${primaryFlow}
+
+## Domain Mind Map
+
+\`\`\`mermaid
+mindmap
+  root((${specId}))
+    Problem
+      Symptom
+      Root Cause Hypothesis
+      Constraints
+    Ontology
+      Entity
+      Relation
+      Business Rule
+      Decision Policy
+      Execution Flow
+    Stakeholders
+      User
+      Operator
+      Maintainer
+    Risk
+      Wrong Direction
+      Data Integrity
+      Security
+      Rollback
+    Validation
+      Test Evidence
+      Runtime Signal
+      Gate Criteria
+\`\`\`
+
+## Layered Exploration Chain
+
+1. Clarify symptom scope and affected boundaries.
+2. Enumerate entities, relations, and rule constraints.
+3. Identify decision points and execution paths.
+4. Produce candidate fixes and risk tradeoffs.
+5. Define verification path and measurable acceptance.
+
+## Correction Loop
+
+- Expected Wrong-Direction Signals:
+  - requirement drift
+  - ontology mismatch
+  - repeated failed remediation
+- Correction Actions:
+  - update this map
+  - add debug evidence
+  - adjust scene-spec contract before coding
+
+## Verification Plan
+
+- ${verificationPlan}
+`;
+}
+
+function buildSceneSpec(specId, options = {}) {
+  const sceneId = normalizeText(options.sceneId) || `scene.${specId.replace(/[^a-zA-Z0-9]+/g, '-').toLowerCase()}`;
+  const problemStatement = normalizeText(options.problemStatement) || 'TBD';
+  const primaryFlow = normalizeText(options.primaryFlow) || 'TBD';
+  const verificationPlan = normalizeText(options.verificationPlan) || 'TBD';
+
+  return `# Scene Spec
+
+> Mandatory artifact: scene-oriented contract for implementation and gating.
+
+## Scene Definition
+
+- Scene ID: \`${sceneId}\`
+- Spec ID: \`${specId}\`
+- Objective: ${problemStatement}
+- Primary Flow: ${primaryFlow}
+
+## Scope & Boundaries
+
+- In Scope:
+  - core scene behavior
+  - required integrations
+- Out of Scope:
+  - unrelated legacy refactors
+  - uncontrolled workaround paths
+
+## Ontology Coverage
+
+| Layer | Required Mapping |
+| --- | --- |
+| Entity | list key domain entities |
+| Relation | list key relations |
+| Business Rule | list enforceable rules |
+| Decision Policy | list decision points |
+| Execution Flow | list end-to-end action chain |
+
+## Decision & Execution Path
+
+1. Trigger condition and entry point.
+2. Decision policy branch(es).
+3. Service/tool execution sequence.
+4. Expected outputs and side effects.
+5. Failure path and rollback criteria.
+
+## Acceptance & Gate
+
+- Functional acceptance: define testable behaviors.
+- Technical acceptance: define gate/test requirements.
+- Verification Plan: ${verificationPlan}
+`;
+}
+
+function buildProblemDomainChain(specId, options = {}) {
+  const sceneId = normalizeText(options.sceneId) || `scene.${specId.replace(/[^a-zA-Z0-9]+/g, '-').toLowerCase()}`;
+  const problemStatement = normalizeText(options.problemStatement) || 'TBD: describe the primary business problem';
+  const primaryFlow = normalizeText(options.primaryFlow) || 'TBD: define core user/business flow';
+  const verificationPlan = normalizeText(options.verificationPlan) || 'TBD: define validation and rollback criteria';
+  const now = new Date().toISOString();
+
+  return {
+    api_version: DOMAIN_CHAIN_API_VERSION,
+    generated_at: now,
+    scene_id: sceneId,
+    spec_id: specId,
+    problem: {
+      statement: problemStatement,
+      scope: 'TBD: define boundary and excluded domains',
+      symptom: 'TBD: observable symptom and impact'
+    },
+    ontology: {
+      entity: ['TBD: primary entity'],
+      relation: ['TBD: key relation'],
+      business_rule: ['TBD: enforceable business rule'],
+      decision_policy: ['TBD: decision condition and policy'],
+      execution_flow: ['TBD: action chain and side effects']
+    },
+    hypotheses: [
+      {
+        id: 'H1',
+        statement: 'TBD: root-cause hypothesis',
+        evidence: ['TBD: evidence or signal'],
+        confidence: 'low'
+      }
+    ],
+    risks: [
+      {
+        id: 'R1',
+        type: 'wrong-direction',
+        statement: 'TBD: direction drift risk',
+        mitigation: 'TBD: correction checkpoint'
+      }
+    ],
+    decision_execution_path: [
+      {
+        step: 1,
+        action: 'entry',
+        decision: 'TBD: trigger condition',
+        expected_result: 'TBD: expected output'
+      },
+      {
+        step: 2,
+        action: 'route',
+        decision: 'TBD: policy branch',
+        expected_result: 'TBD: branch result'
+      },
+      {
+        step: 3,
+        action: 'execute',
+        decision: 'TBD: execution rule',
+        expected_result: 'TBD: side effect and data change'
+      }
+    ],
+    correction_loop: {
+      triggers: [
+        'gate failure',
+        'ontology mismatch',
+        'two failed fix rounds'
+      ],
+      actions: [
+        'refresh domain map',
+        'attach debug evidence',
+        'rebuild scene spec contract'
+      ]
+    },
+    verification: {
+      plan: verificationPlan,
+      gates: [
+        'spec-gate',
+        'tests',
+        'release preflight'
+      ]
+    }
+  };
+}
+
+function validateProblemDomainMapContent(content = '') {
+  const checks = {
+    hasRootProblem: /##\s+Root Problem/i.test(content),
+    hasMindMapBlock: /```mermaid[\s\S]*mindmap/i.test(content),
+    hasLayeredExplorationChain: /##\s+Layered Exploration Chain/i.test(content),
+    hasCorrectionLoop: /##\s+Correction Loop/i.test(content)
+  };
+  const passed = Object.values(checks).every(Boolean);
+  return { passed, checks };
+}
+
+function validateSceneSpecContent(content = '') {
+  const checks = {
+    hasSceneDefinition: /##\s+Scene Definition/i.test(content),
+    hasOntologyCoverage: /##\s+Ontology Coverage/i.test(content),
+    hasDecisionExecutionPath: /##\s+Decision & Execution Path/i.test(content),
+    hasAcceptanceGate: /##\s+Acceptance & Gate/i.test(content)
+  };
+  const passed = Object.values(checks).every(Boolean);
+  return { passed, checks };
+}
+
+function isNonEmptyString(value) {
+  return typeof value === 'string' && value.trim().length > 0;
+}
+
+function hasNonEmptyStringArray(value) {
+  return Array.isArray(value) && value.some((item) => isNonEmptyString(item));
+}
+
+function validateProblemDomainChainPayload(payload = {}, specId = '') {
+  const checks = {
+    apiVersion: isNonEmptyString(payload.api_version),
+    sceneId: isNonEmptyString(payload.scene_id),
+    specId: isNonEmptyString(payload.spec_id) && (!specId || payload.spec_id === specId),
+    problemStatement: isNonEmptyString(payload?.problem?.statement),
+    ontologyEntity: hasNonEmptyStringArray(payload?.ontology?.entity),
+    ontologyRelation: hasNonEmptyStringArray(payload?.ontology?.relation),
+    ontologyBusinessRule: hasNonEmptyStringArray(payload?.ontology?.business_rule),
+    ontologyDecisionPolicy: hasNonEmptyStringArray(payload?.ontology?.decision_policy),
+    ontologyExecutionFlow: hasNonEmptyStringArray(payload?.ontology?.execution_flow),
+    hasHypotheses: Array.isArray(payload.hypotheses) && payload.hypotheses.length > 0,
+    hasRisks: Array.isArray(payload.risks) && payload.risks.length > 0,
+    hasDecisionPath: Array.isArray(payload.decision_execution_path) && payload.decision_execution_path.length >= 3,
+    hasCorrectionTriggers: hasNonEmptyStringArray(payload?.correction_loop?.triggers),
+    hasCorrectionActions: hasNonEmptyStringArray(payload?.correction_loop?.actions),
+    hasVerificationGates: hasNonEmptyStringArray(payload?.verification?.gates)
+  };
+  return {
+    passed: Object.values(checks).every(Boolean),
+    checks
+  };
+}
+
+async function ensureSpecDomainArtifacts(projectPath, specId, options = {}) {
+  const fileSystem = options.fileSystem || fs;
+  const dryRun = options.dryRun === true;
+  const force = options.force === true;
+
+  const paths = resolveSpecPaths(projectPath, specId);
+  const domainMapContent = buildProblemDomainMindMap(specId, options);
+  const sceneSpecContent = buildSceneSpec(specId, options);
+  const domainChainPayload = buildProblemDomainChain(specId, options);
+
+  const created = {
+    domain_map: false,
+    scene_spec: false,
+    domain_chain: false
+  };
+
+  if (!dryRun) {
+    await fileSystem.ensureDir(path.dirname(paths.domainMapPath));
+
+    const hasDomainMap = await fileSystem.pathExists(paths.domainMapPath);
+    if (force || !hasDomainMap) {
+      await fileSystem.writeFile(paths.domainMapPath, domainMapContent, 'utf8');
+      created.domain_map = true;
+    }
+
+    const hasSceneSpec = await fileSystem.pathExists(paths.sceneSpecPath);
+    if (force || !hasSceneSpec) {
+      await fileSystem.writeFile(paths.sceneSpecPath, sceneSpecContent, 'utf8');
+      created.scene_spec = true;
+    }
+
+    const hasDomainChain = await fileSystem.pathExists(paths.domainChainPath);
+    if (force || !hasDomainChain) {
+      await fileSystem.writeJson(paths.domainChainPath, domainChainPayload, { spaces: 2 });
+      created.domain_chain = true;
+    }
+  } else {
+    created.domain_map = true;
+    created.scene_spec = true;
+    created.domain_chain = true;
+  }
+
+  return {
+    paths: {
+      domain_map: paths.domainMapPath,
+      scene_spec: paths.sceneSpecPath,
+      domain_chain: paths.domainChainPath
+    },
+    created,
+    preview: {
+      domain_map: domainMapContent,
+      scene_spec: sceneSpecContent,
+      domain_chain: domainChainPayload
+    }
+  };
+}
+
+async function validateSpecDomainArtifacts(projectPath, specId, fileSystem = fs) {
+  const paths = resolveSpecPaths(projectPath, specId);
+  const warnings = [];
+  const details = {
+    domain_map: {
+      path: paths.domainMapPath,
+      exists: false,
+      checks: {}
+    },
+    scene_spec: {
+      path: paths.sceneSpecPath,
+      exists: false,
+      checks: {}
+    },
+    domain_chain: {
+      path: paths.domainChainPath,
+      exists: false,
+      checks: {}
+    }
+  };
+
+  let passedChecks = 0;
+  const totalChecks = 3;
+
+  const hasDomainMap = await fileSystem.pathExists(paths.domainMapPath);
+  details.domain_map.exists = hasDomainMap;
+  if (!hasDomainMap) {
+    warnings.push(`Missing required artifact: ${DOMAIN_MAP_RELATIVE_PATH}`);
+  } else {
+    const content = await fileSystem.readFile(paths.domainMapPath, 'utf8');
+    const evaluation = validateProblemDomainMapContent(content);
+    details.domain_map.checks = evaluation.checks;
+    if (evaluation.passed) {
+      passedChecks += 1;
+    } else {
+      warnings.push(`Invalid ${DOMAIN_MAP_RELATIVE_PATH}: missing mandatory sections`);
+    }
+  }
+
+  const hasSceneSpec = await fileSystem.pathExists(paths.sceneSpecPath);
+  details.scene_spec.exists = hasSceneSpec;
+  if (!hasSceneSpec) {
+    warnings.push(`Missing required artifact: ${SCENE_SPEC_RELATIVE_PATH}`);
+  } else {
+    const content = await fileSystem.readFile(paths.sceneSpecPath, 'utf8');
+    const evaluation = validateSceneSpecContent(content);
+    details.scene_spec.checks = evaluation.checks;
+    if (evaluation.passed) {
+      passedChecks += 1;
+    } else {
+      warnings.push(`Invalid ${SCENE_SPEC_RELATIVE_PATH}: missing mandatory sections`);
+    }
+  }
+
+  const hasDomainChain = await fileSystem.pathExists(paths.domainChainPath);
+  details.domain_chain.exists = hasDomainChain;
+  if (!hasDomainChain) {
+    warnings.push(`Missing required artifact: ${DOMAIN_CHAIN_RELATIVE_PATH}`);
+  } else {
+    let payload = null;
+    try {
+      payload = await fileSystem.readJson(paths.domainChainPath);
+    } catch (error) {
+      warnings.push(`Invalid ${DOMAIN_CHAIN_RELATIVE_PATH}: malformed JSON (${error.message})`);
+    }
+    if (payload) {
+      const evaluation = validateProblemDomainChainPayload(payload, specId);
+      details.domain_chain.checks = evaluation.checks;
+      if (evaluation.passed) {
+        passedChecks += 1;
+      } else {
+        warnings.push(`Invalid ${DOMAIN_CHAIN_RELATIVE_PATH}: missing mandatory chain fields`);
+      }
+    }
+  }
+
+  return {
+    passed: passedChecks === totalChecks,
+    ratio: passedChecks / totalChecks,
+    details,
+    warnings
+  };
+}
+
+module.exports = {
+  DOMAIN_MAP_RELATIVE_PATH,
+  SCENE_SPEC_RELATIVE_PATH,
+  DOMAIN_CHAIN_RELATIVE_PATH,
+  DOMAIN_CHAIN_API_VERSION,
+  buildProblemDomainMindMap,
+  buildSceneSpec,
+  buildProblemDomainChain,
+  ensureSpecDomainArtifacts,
+  validateSpecDomainArtifacts
+};

package/lib/spec/related-specs.js

@@ -0,0 +1,260 @@
+const path = require('path');
+const fs = require('fs-extra');
+const { DOMAIN_CHAIN_RELATIVE_PATH } = require('./domain-modeling');
+
+function normalizeText(value) {
+  if (typeof value !== 'string') {
+    return '';
+  }
+  return value.trim();
+}
+
+function clampPositiveInteger(value, fallback, max = 100) {
+  const parsed = Number.parseInt(String(value), 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    return fallback;
+  }
+  return Math.min(parsed, max);
+}
+
+function tokenizeText(value) {
+  const normalized = normalizeText(value).toLowerCase();
+  if (!normalized) {
+    return [];
+  }
+  return Array.from(new Set(
+    normalized
+      .split(/[^a-z0-9\u4e00-\u9fff]+/i)
+      .map((item) => item.trim())
+      .filter((item) => item.length >= 2 || /[\u4e00-\u9fff]/.test(item))
+  ));
+}
+
+function extractSceneIdFromSceneSpec(markdown) {
+  const content = normalizeText(markdown);
+  if (!content) {
+    return null;
+  }
+  const match = content.match(/Scene ID:\s*`([^`]+)`/i);
+  if (!match || !match[1]) {
+    return null;
+  }
+  return match[1].trim() || null;
+}
+
+async function safeReadJson(filePath, fileSystem = fs) {
+  if (!await fileSystem.pathExists(filePath)) {
+    return null;
+  }
+  try {
+    return await fileSystem.readJson(filePath);
+  } catch (_error) {
+    return null;
+  }
+}
+
+async function safeReadFile(filePath, fileSystem = fs) {
+  if (!await fileSystem.pathExists(filePath)) {
+    return '';
+  }
+  try {
+    return await fileSystem.readFile(filePath, 'utf8');
+  } catch (_error) {
+    return '';
+  }
+}
+
+async function resolveSpecSearchEntries(projectPath, fileSystem = fs) {
+  const specsRoot = path.join(projectPath, '.sce', 'specs');
+  if (!await fileSystem.pathExists(specsRoot)) {
+    return [];
+  }
+
+  const names = await fileSystem.readdir(specsRoot);
+  const entries = [];
+
+  for (const specId of names) {
+    const specRoot = path.join(specsRoot, specId);
+    let stat = null;
+    try {
+      stat = await fileSystem.stat(specRoot);
+    } catch (_error) {
+      continue;
+    }
+    if (!stat || !stat.isDirectory()) {
+      continue;
+    }
+
+    const domainChainPath = path.join(specRoot, DOMAIN_CHAIN_RELATIVE_PATH);
+    const sceneSpecPath = path.join(specRoot, 'custom', 'scene-spec.md');
+    const domainMapPath = path.join(specRoot, 'custom', 'problem-domain-map.md');
+    const requirementsPath = path.join(specRoot, 'requirements.md');
+    const designPath = path.join(specRoot, 'design.md');
+
+    const [
+      domainChain,
+      sceneSpecContent,
+      domainMapContent,
+      requirementsContent,
+      designContent
+    ] = await Promise.all([
+      safeReadJson(domainChainPath, fileSystem),
+      safeReadFile(sceneSpecPath, fileSystem),
+      safeReadFile(domainMapPath, fileSystem),
+      safeReadFile(requirementsPath, fileSystem),
+      safeReadFile(designPath, fileSystem)
+    ]);
+
+    const sceneId = normalizeText(
+      (domainChain && domainChain.scene_id) || extractSceneIdFromSceneSpec(sceneSpecContent) || ''
+    ) || null;
+    const problemStatement = normalizeText(
+      (domainChain && domainChain.problem && domainChain.problem.statement) || ''
+    ) || null;
+
+    const ontologyText = domainChain && domainChain.ontology
+      ? [
+        ...(Array.isArray(domainChain.ontology.entity) ? domainChain.ontology.entity : []),
+        ...(Array.isArray(domainChain.ontology.relation) ? domainChain.ontology.relation : []),
+        ...(Array.isArray(domainChain.ontology.business_rule) ? domainChain.ontology.business_rule : []),
+        ...(Array.isArray(domainChain.ontology.decision_policy) ? domainChain.ontology.decision_policy : []),
+        ...(Array.isArray(domainChain.ontology.execution_flow) ? domainChain.ontology.execution_flow : [])
+      ].join(' ')
+      : '';
+
+    const searchableText = [
+      specId,
+      sceneId || '',
+      problemStatement || '',
+      ontologyText,
+      sceneSpecContent.slice(0, 4000),
+      domainMapContent.slice(0, 3000),
+      requirementsContent.slice(0, 3000),
+      designContent.slice(0, 3000)
+    ].join('\n');
+
+    entries.push({
+      spec_id: specId,
+      scene_id: sceneId,
+      problem_statement: problemStatement,
+      updated_at: stat.mtime ? stat.mtime.toISOString() : null,
+      searchable_text: searchableText.toLowerCase()
+    });
+  }
+
+  return entries;
+}
+
+function calculateSpecRelevance(entry, queryTokens = [], sceneId = '') {
+  let score = 0;
+  const reasons = [];
+  const matchedTokens = [];
+  const normalizedSceneId = normalizeText(sceneId).toLowerCase();
+  const entrySceneId = normalizeText(entry.scene_id).toLowerCase();
+  const haystack = entry.searchable_text || '';
+
+  if (normalizedSceneId && entrySceneId) {
+    if (entrySceneId === normalizedSceneId) {
+      score += 90;
+      reasons.push('scene_exact');
+    } else if (entrySceneId.includes(normalizedSceneId) || normalizedSceneId.includes(entrySceneId)) {
+      score += 35;
+      reasons.push('scene_partial');
+    }
+  }
+
+  for (const token of queryTokens) {
+    if (!token || token.length < 2) {
+      continue;
+    }
+    if (haystack.includes(token)) {
+      score += 9;
+      matchedTokens.push(token);
+    }
+  }
+
+  if (matchedTokens.length > 0) {
+    reasons.push('query_overlap');
+  }
+
+  return {
+    score,
+    reasons,
+    matched_tokens: Array.from(new Set(matchedTokens)).slice(0, 20)
+  };
+}
+
+async function buildDerivedQueryFromSpec(projectPath, specId, fileSystem = fs) {
+  const specs = await resolveSpecSearchEntries(projectPath, fileSystem);
+  const selected = specs.find((item) => item.spec_id === specId);
+  if (!selected) {
+    return '';
+  }
+  return [
+    selected.problem_statement || '',
+    selected.scene_id || '',
+    selected.spec_id || ''
+  ].join(' ').trim();
+}
+
+async function findRelatedSpecs(options = {}, dependencies = {}) {
+  const projectPath = dependencies.projectPath || process.cwd();
+  const fileSystem = dependencies.fileSystem || fs;
+  const limit = clampPositiveInteger(options.limit, 5, 50);
+  const sceneId = normalizeText(options.sceneId || options.scene);
+  const excludeSpecId = normalizeText(options.excludeSpecId);
+  const sourceSpecId = normalizeText(options.sourceSpecId || options.spec);
+
+  let query = normalizeText(options.query);
+  if (!query && sourceSpecId) {
+    query = await buildDerivedQueryFromSpec(projectPath, sourceSpecId, fileSystem);
+  }
+
+  const queryTokens = tokenizeText(query);
+  const entries = await resolveSpecSearchEntries(projectPath, fileSystem);
+  const ranked = [];
+
+  for (const entry of entries) {
+    if (excludeSpecId && entry.spec_id === excludeSpecId) {
+      continue;
+    }
+    const relevance = calculateSpecRelevance(entry, queryTokens, sceneId);
+    if (relevance.score <= 0) {
+      continue;
+    }
+    ranked.push({
+      spec_id: entry.spec_id,
+      scene_id: entry.scene_id,
+      problem_statement: entry.problem_statement,
+      updated_at: entry.updated_at,
+      score: relevance.score,
+      reasons: relevance.reasons,
+      matched_tokens: relevance.matched_tokens
+    });
+  }
+
+  ranked.sort((left, right) => {
+    if (right.score !== left.score) {
+      return right.score - left.score;
+    }
+    return String(right.updated_at || '').localeCompare(String(left.updated_at || ''));
+  });
+
+  return {
+    mode: 'spec-related',
+    success: true,
+    query: query || '',
+    scene_id: sceneId || null,
+    source_spec_id: sourceSpecId || null,
+    total_candidates: ranked.length,
+    related_specs: ranked.slice(0, limit)
+  };
+}
+
+module.exports = {
+  tokenizeText,
+  resolveSpecSearchEntries,
+  calculateSpecRelevance,
+  findRelatedSpecs
+};
+

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

@@ -11,6 +11,7 @@ const DEFAULT_GATE_POLICY = {
     mandatory: { enabled: true, weight: 30, hard_fail: true },
     tests: { enabled: true, weight: 25, hard_fail: true },
     docs: { enabled: true, weight: 15, hard_fail: false },
+    domain_scene_modeling: { enabled: true, weight: 25, hard_fail: true },
     config_consistency: { enabled: true, weight: 15, hard_fail: false },
     traceability: { enabled: true, weight: 15, hard_fail: false }
   }