scene-capability-engine 3.4.5 → 3.4.6

package/lib/commands/studio.js

@@ -19,6 +19,8 @@ const STUDIO_EVENT_API_VERSION = 'sce.studio.event/v0.1';
 const VERIFY_PROFILES = new Set(['fast', 'standard', 'strict']);
 const RELEASE_PROFILES = new Set(['standard', 'strict']);
 const STUDIO_REPORTS_DIR = '.sce/reports/studio';
+const DEFAULT_INTERACTIVE_GOVERNANCE_REPORT = '.sce/reports/interactive-governance-report.json';
+const DEFAULT_PROBLEM_CONTRACT_RELATIVE_PATH = path.join('custom', 'problem-contract.json');
 const MAX_OUTPUT_PREVIEW_LENGTH = 2000;
 const DEFAULT_STUDIO_SECURITY_POLICY = Object.freeze({
   enabled: false,
@@ -368,6 +370,7 @@ async function buildVerifyGateSteps(options = {}, dependencies = {}) {
   const projectPath = dependencies.projectPath || process.cwd();
   const fileSystem = dependencies.fileSystem || fs;
   const profile = normalizeString(options.profile) || 'standard';
+  const specId = normalizeString(options.specId || dependencies.specId);
 
   if (!VERIFY_PROFILES.has(profile)) {
     throw new Error(`Invalid verify profile "${profile}". Expected one of: ${Array.from(VERIFY_PROFILES).join(', ')}`);
@@ -403,6 +406,21 @@ async function buildVerifyGateSteps(options = {}, dependencies = {}) {
   }
 
   if (profile === 'standard' || profile === 'strict') {
+    const problemClosureGateScript = path.join(projectPath, 'scripts', 'problem-closure-gate.js');
+    const hasProblemClosureGateScript = await fileSystem.pathExists(problemClosureGateScript);
+    const canRunProblemClosureGate = hasProblemClosureGateScript && Boolean(specId);
+    steps.push({
+      id: 'problem-closure-gate',
+      name: 'problem closure gate (verify)',
+      command: 'node',
+      args: ['scripts/problem-closure-gate.js', '--stage', 'verify', '--spec', specId, '--fail-on-block', '--json'],
+      required: Boolean(specId),
+      enabled: canRunProblemClosureGate,
+      skip_reason: canRunProblemClosureGate
+        ? ''
+        : (specId ? 'scripts/problem-closure-gate.js not found' : 'spec id unavailable for problem-closure gate')
+    });
+
     const governanceScript = path.join(projectPath, 'scripts', 'interactive-governance-report.js');
     const hasGovernanceScript = await fileSystem.pathExists(governanceScript);
     steps.push({
@@ -435,11 +453,32 @@ async function buildReleaseGateSteps(options = {}, dependencies = {}) {
   const projectPath = dependencies.projectPath || process.cwd();
   const fileSystem = dependencies.fileSystem || fs;
   const profile = normalizeString(options.profile) || 'standard';
+  const specId = normalizeString(options.specId || dependencies.specId);
+  const verifyReportPath = normalizeString(options.verifyReportPath || dependencies.verifyReportPath);
   if (!RELEASE_PROFILES.has(profile)) {
     throw new Error(`Invalid release profile "${profile}". Expected one of: ${Array.from(RELEASE_PROFILES).join(', ')}`);
   }
 
   const steps = [];
+  const problemClosureGateScript = path.join(projectPath, 'scripts', 'problem-closure-gate.js');
+  const hasProblemClosureGateScript = await fileSystem.pathExists(problemClosureGateScript);
+  const canRunProblemClosureGate = hasProblemClosureGateScript && Boolean(specId);
+  const problemClosureArgs = ['scripts/problem-closure-gate.js', '--stage', 'release', '--spec', specId, '--fail-on-block', '--json'];
+  if (verifyReportPath) {
+    problemClosureArgs.push('--verify-report', verifyReportPath);
+  }
+  steps.push({
+    id: 'problem-closure-gate',
+    name: 'problem closure gate (release)',
+    command: 'node',
+    args: problemClosureArgs,
+    required: Boolean(specId),
+    enabled: canRunProblemClosureGate,
+    skip_reason: canRunProblemClosureGate
+      ? ''
+      : (specId ? 'scripts/problem-closure-gate.js not found' : 'spec id unavailable for problem-closure gate')
+  });
+
   steps.push({
     id: 'npm-pack-dry-run',
     name: 'npm pack --dry-run',
@@ -710,6 +749,77 @@ async function readSpecDomainChain(projectPath, specId, fileSystem = fs) {
   }
 }
 
+async function readSpecProblemContract(projectPath, specId, fileSystem = fs) {
+  const specRoot = path.join(projectPath, '.sce', 'specs', specId);
+  const contractPath = path.join(specRoot, DEFAULT_PROBLEM_CONTRACT_RELATIVE_PATH);
+  if (!await fileSystem.pathExists(contractPath)) {
+    return null;
+  }
+  try {
+    const payload = await fileSystem.readJson(contractPath);
+    const stat = await fileSystem.stat(contractPath);
+    return {
+      spec_id: specId,
+      contract_path: toRelativePosix(projectPath, contractPath),
+      payload,
+      updated_at: stat && stat.mtime ? stat.mtime.toISOString() : null,
+      mtime_ms: Number(stat && stat.mtimeMs) || 0
+    };
+  } catch (_error) {
+    return null;
+  }
+}
+
+async function readGovernanceSignals(projectPath, fileSystem = fs) {
+  const reportPath = path.join(projectPath, DEFAULT_INTERACTIVE_GOVERNANCE_REPORT);
+  if (!await fileSystem.pathExists(reportPath)) {
+    return {
+      available: false,
+      report_path: null,
+      high_breach_count: 0,
+      medium_breach_count: 0
+    };
+  }
+  const payload = await fileSystem.readJson(reportPath).catch(() => null);
+  const summary = extractGovernanceBreachSignals(payload || {});
+  return {
+    ...summary,
+    report_path: toRelativePosix(projectPath, reportPath)
+  };
+}
+
+async function readVerifyReportSignals(projectPath, verifyReportPath = '', fileSystem = fs) {
+  const normalized = normalizeString(verifyReportPath);
+  if (!normalized) {
+    return {
+      available: false,
+      report_path: null,
+      passed: false,
+      failed_step_count: 0
+    };
+  }
+  const absolutePath = path.isAbsolute(normalized)
+    ? normalized
+    : path.join(projectPath, normalized);
+  if (!await fileSystem.pathExists(absolutePath)) {
+    return {
+      available: false,
+      report_path: normalized,
+      passed: false,
+      failed_step_count: 0
+    };
+  }
+  const payload = await fileSystem.readJson(absolutePath).catch(() => null);
+  const steps = Array.isArray(payload && payload.steps) ? payload.steps : [];
+  const failedStepCount = steps.filter((step) => normalizeString(step && step.status) === 'failed').length;
+  return {
+    available: true,
+    report_path: toRelativePosix(projectPath, absolutePath),
+    passed: payload && payload.passed === true && failedStepCount === 0,
+    failed_step_count: failedStepCount
+  };
+}
+
 function normalizeChainList(value, limit = 5) {
   if (!Array.isArray(value)) {
     return [];
@@ -725,13 +835,97 @@ function normalizeChainList(value, limit = 5) {
     });
 }
 
+function normalizeProblemContract(contract = {}, context = {}) {
+  const source = contract && typeof contract === 'object' ? contract : {};
+  const issueStatement = normalizeString(
+    source.issue_statement
+    || source.issue
+    || source.problem_statement
+    || context.problem_statement
+    || context.goal
+  );
+  const expectedOutcome = normalizeString(
+    source.expected_outcome
+    || source.expected
+    || source.success_criteria
+    || context.verification_plan
+    || (context.scene_id ? `Scene ${context.scene_id} reaches deterministic verification gates.` : '')
+  );
+  const reproductionSteps = normalizeChainList(
+    source.reproduction_steps || source.repro_steps || source.steps,
+    20
+  );
+  const fallbackRepro = reproductionSteps.length > 0
+    ? reproductionSteps
+    : [
+      normalizeString(context.goal) || 'Reproduce the reported issue in the target scene.',
+      'Capture logs and gate evidence for the failing path.'
+    ].filter(Boolean);
+  const forbiddenWorkarounds = normalizeChainList(
+    source.forbidden_workarounds || source.prohibited_workarounds || source.disallowed_workarounds,
+    20
+  );
+  const fallbackForbidden = forbiddenWorkarounds.length > 0
+    ? forbiddenWorkarounds
+    : [
+      'Do not bypass gates or tests.',
+      'Do not silence runtime errors.'
+    ];
+
+  return {
+    issue_statement: issueStatement,
+    expected_outcome: expectedOutcome,
+    reproduction_steps: fallbackRepro,
+    impact_scope: normalizeString(source.impact_scope || source.scope || context.scene_id),
+    forbidden_workarounds: fallbackForbidden
+  };
+}
+
+function extractGovernanceBreachSignals(report = {}) {
+  if (!report || typeof report !== 'object') {
+    return {
+      available: false,
+      high_breach_count: 0,
+      medium_breach_count: 0
+    };
+  }
+  const alerts = Array.isArray(report.alerts) ? report.alerts : [];
+  let highBreachCount = 0;
+  let mediumBreachCount = 0;
+  for (const alert of alerts) {
+    const status = normalizeString(alert && alert.status).toLowerCase();
+    const severity = normalizeString(alert && alert.severity).toLowerCase();
+    if (status !== 'breach') {
+      continue;
+    }
+    if (severity === 'high') {
+      highBreachCount += 1;
+    } else if (severity === 'medium') {
+      mediumBreachCount += 1;
+    }
+  }
+  return {
+    available: true,
+    high_breach_count: highBreachCount,
+    medium_breach_count: mediumBreachCount
+  };
+}
+
 function summarizeDomainChain(payload = {}) {
   const ontology = payload && typeof payload.ontology === 'object' ? payload.ontology : {};
+  const ontologyEvidence = payload && typeof payload.ontology_evidence === 'object' ? payload.ontology_evidence : {};
   const decisionPath = Array.isArray(payload.decision_execution_path) ? payload.decision_execution_path : [];
   const correctionLoop = payload && typeof payload.correction_loop === 'object' ? payload.correction_loop : {};
   const verification = payload && typeof payload.verification === 'object' ? payload.verification : {};
   const hypotheses = Array.isArray(payload.hypotheses) ? payload.hypotheses : [];
   const risks = Array.isArray(payload.risks) ? payload.risks : [];
+  const evidenceBindingCount = (
+    normalizeChainList(ontologyEvidence.entity, 50).length
+    + normalizeChainList(ontologyEvidence.relation, 50).length
+    + normalizeChainList(ontologyEvidence.business_rule, 50).length
+    + normalizeChainList(ontologyEvidence.decision_policy, 50).length
+    + normalizeChainList(ontologyEvidence.execution_flow, 50).length
+  );
 
   return {
     scene_id: normalizeString(payload.scene_id) || null,
@@ -747,6 +941,8 @@ function summarizeDomainChain(payload = {}) {
     hypothesis_count: hypotheses.length,
     risk_count: risks.length,
     decision_path_steps: decisionPath.length,
+    evidence_binding_count: evidenceBindingCount,
+    verification_plan: normalizeString(verification.plan) || null,
     correction_loop: {
       triggers: normalizeChainList(correctionLoop.triggers, 5),
       actions: normalizeChainList(correctionLoop.actions, 5)
@@ -781,7 +977,13 @@ function buildDomainChainRuntimeContext(payload = {}) {
     verification: {
       plan: normalizeString(payload?.verification?.plan) || null,
       gates: normalizeChainList(payload?.verification?.gates, 10)
-    }
+    },
+    problem_contract: normalizeProblemContract(payload?.problem_contract || {}, {
+      scene_id: normalizeString(payload.scene_id) || '',
+      goal: normalizeString(payload?.problem?.statement) || '',
+      problem_statement: normalizeString(payload?.problem?.statement) || '',
+      verification_plan: normalizeString(payload?.verification?.plan) || ''
+    })
   };
 }
 
@@ -834,12 +1036,22 @@ async function resolveDomainChainBinding(options = {}, dependencies = {}) {
       problemStatement: goal || `Studio scene cycle for ${sceneId}`
     });
     const chain = await readSpecDomainChain(projectPath, explicitSpec, fileSystem);
+    const problemContract = await readSpecProblemContract(projectPath, explicitSpec, fileSystem);
     if (!chain) {
       return {
         resolved: false,
         source: 'explicit-spec',
         spec_id: explicitSpec,
-        reason: 'domain_chain_missing'
+        reason: 'domain_chain_missing',
+        problem_contract: problemContract
+          ? normalizeProblemContract(problemContract.payload, {
+            scene_id: sceneId,
+            goal
+          })
+          : normalizeProblemContract({}, {
+            scene_id: sceneId,
+            goal
+          })
       };
     }
     return {
@@ -849,7 +1061,17 @@ async function resolveDomainChainBinding(options = {}, dependencies = {}) {
       chain_path: chain.chain_path,
       updated_at: chain.updated_at,
       summary: summarizeDomainChain(chain.payload),
-      context: buildDomainChainRuntimeContext(chain.payload)
+      context: buildDomainChainRuntimeContext(chain.payload),
+      problem_contract: normalizeProblemContract(
+        problemContract && problemContract.payload ? problemContract.payload : chain.payload?.problem_contract || {},
+        {
+          scene_id: sceneId,
+          goal,
+          problem_statement: normalizeString(chain?.payload?.problem?.statement),
+          verification_plan: normalizeString(chain?.payload?.verification?.plan)
+        }
+      ),
+      problem_contract_path: problemContract ? problemContract.contract_path : null
     };
   }
 
@@ -873,6 +1095,7 @@ async function resolveDomainChainBinding(options = {}, dependencies = {}) {
   }
 
   const selected = candidates[0];
+  const selectedContract = await readSpecProblemContract(projectPath, selected.spec_id, fileSystem);
   return {
     resolved: true,
     source: candidates.length === 1 ? 'scene-auto-single' : 'scene-auto-latest',
@@ -886,7 +1109,17 @@ async function resolveDomainChainBinding(options = {}, dependencies = {}) {
       updated_at: item.updated_at
     })),
     summary: summarizeDomainChain(selected.payload),
-    context: buildDomainChainRuntimeContext(selected.payload)
+    context: buildDomainChainRuntimeContext(selected.payload),
+    problem_contract: normalizeProblemContract(
+      selectedContract && selectedContract.payload ? selectedContract.payload : selected.payload?.problem_contract || {},
+      {
+        scene_id: sceneId,
+        goal,
+        problem_statement: normalizeString(selected?.payload?.problem?.statement),
+        verification_plan: normalizeString(selected?.payload?.verification?.plan)
+      }
+    ),
+    problem_contract_path: selectedContract ? selectedContract.contract_path : null
   };
 }
 
@@ -949,6 +1182,14 @@ function buildJobDomainChainMetadata(job = {}) {
     : null;
   const summary = domainChain && domainChain.summary ? domainChain.summary : null;
   const context = domainChain && domainChain.context ? domainChain.context : null;
+  const problemContract = job?.source?.problem_contract && typeof job.source.problem_contract === 'object'
+    ? job.source.problem_contract
+    : normalizeProblemContract(context && context.problem_contract ? context.problem_contract : {}, {
+      scene_id: normalizeString(job?.scene?.id),
+      goal: normalizeString(job?.source?.goal),
+      problem_statement: normalizeString(summary && summary.problem_statement),
+      verification_plan: normalizeString(summary && summary.verification_plan)
+    });
   return {
     resolved: domainChain && domainChain.resolved === true,
     source: domainChain && domainChain.source ? domainChain.source : 'none',
@@ -957,12 +1198,14 @@ function buildJobDomainChainMetadata(job = {}) {
     reason: domainChain && domainChain.reason ? domainChain.reason : null,
     decision_path_steps: summary ? Number(summary.decision_path_steps || 0) : 0,
     risk_count: summary ? Number(summary.risk_count || 0) : 0,
+    evidence_binding_count: summary ? Number(summary.evidence_binding_count || 0) : 0,
     correction_triggers: summary && summary.correction_loop
       ? normalizeChainList(summary.correction_loop.triggers, 10)
       : [],
     verification_gates: summary
       ? normalizeChainList(summary.verification_gates, 10)
       : [],
+    problem_contract: problemContract,
     summary: summary || null,
     context: context || null
   };
@@ -975,6 +1218,18 @@ function summarizeProblemEvaluation(evaluation = {}) {
     confidence_score: Number(evaluation.confidence_score || 0),
     risk_level: normalizeString(evaluation?.dimensions?.risk?.level) || 'low',
     strategy: normalizeString(evaluation?.dimensions?.strategy?.strategy) || 'direct-execution',
+    contract_score: Number(evaluation?.dimensions?.problem_contract?.score || 0),
+    ontology_score: Number(evaluation?.dimensions?.ontology_alignment?.score || 0),
+    convergence_score: Number(evaluation?.dimensions?.convergence?.score || 0),
+    contract_missing: Array.isArray(evaluation?.dimensions?.problem_contract?.missing)
+      ? evaluation.dimensions.problem_contract.missing
+      : [],
+    ontology_missing_axes: Array.isArray(evaluation?.dimensions?.ontology_alignment?.missing_axes)
+      ? evaluation.dimensions.ontology_alignment.missing_axes
+      : [],
+    convergence_missing: Array.isArray(evaluation?.dimensions?.convergence?.missing)
+      ? evaluation.dimensions.convergence.missing
+      : [],
     blockers: Array.isArray(evaluation.blockers) ? evaluation.blockers : [],
     warnings: Array.isArray(evaluation.warnings) ? evaluation.warnings : [],
     recommendations: Array.isArray(evaluation.recommendations) ? evaluation.recommendations : [],
@@ -1044,6 +1299,7 @@ async function enforceProblemEvaluationForStage(job = {}, stage = '', context =
     goal: normalizeString(context.goal || job?.source?.goal),
     release_channel: normalizeString(context.release_channel || ''),
     domain_chain: context.domain_chain || (job?.source?.domain_chain || {}),
+    problem_contract: context.problem_contract || job?.source?.problem_contract || {},
     related_specs_count: Number(context.related_specs_count || job?.source?.related_specs?.total_candidates || 0),
     stage_readiness: context.stage_readiness || buildStageReadiness(job, stage),
     gate_signals: context.gate_signals || {}
@@ -1127,6 +1383,15 @@ async function runStudioPlanCommand(options = {}, dependencies = {}) {
 
   const jobId = normalizeString(options.job) || createJobId();
   const now = nowIso();
+  const problemContract = normalizeProblemContract(
+    domainChainBinding.problem_contract || {},
+    {
+      scene_id: sceneId,
+      goal: normalizeString(options.goal),
+      problem_statement: normalizeString(domainChainBinding?.summary?.problem_statement),
+      verification_plan: normalizeString(domainChainBinding?.summary?.verification_plan)
+    }
+  );
   const planShadowJob = {
     job_id: jobId,
     scene: {
@@ -1136,6 +1401,8 @@ async function runStudioPlanCommand(options = {}, dependencies = {}) {
     source: {
       goal: normalizeString(options.goal) || null,
       spec_id: domainChainBinding.spec_id || specId || null,
+      problem_contract: problemContract,
+      problem_contract_path: domainChainBinding.problem_contract_path || null,
       domain_chain: {
         resolved: domainChainBinding.resolved === true,
         summary: domainChainBinding.summary || null
@@ -1150,6 +1417,7 @@ async function runStudioPlanCommand(options = {}, dependencies = {}) {
     scene_id: sceneId,
     spec_id: domainChainBinding.spec_id || specId || null,
     goal: normalizeString(options.goal) || null,
+    problem_contract: problemContract,
     domain_chain: {
       resolved: domainChainBinding.resolved === true,
       summary: domainChainBinding.summary || null
@@ -1194,6 +1462,7 @@ async function runStudioPlanCommand(options = {}, dependencies = {}) {
       domain_chain_path: domainChainBinding.chain_path || null,
       domain_chain_summary: domainChainBinding.summary || null,
       domain_chain_reason: domainChainBinding.reason || null,
+      problem_contract: problemContract,
       problem_evaluation: summarizeProblemEvaluation(planProblemEvaluation),
       related_specs_total: Number(relatedSpecLookup.total_candidates || 0),
       related_specs_top: relatedSpecItems
@@ -1210,6 +1479,8 @@ async function runStudioPlanCommand(options = {}, dependencies = {}) {
       from_chat: fromChat,
       goal: normalizeString(options.goal) || null,
       spec_id: domainChainBinding.spec_id || specId || null,
+      problem_contract: problemContract,
+      problem_contract_path: domainChainBinding.problem_contract_path || null,
       domain_chain: {
         resolved: domainChainBinding.resolved === true,
         source: domainChainBinding.source || 'none',
@@ -1267,6 +1538,7 @@ async function runStudioPlanCommand(options = {}, dependencies = {}) {
     domain_chain_source: domainChainBinding.source || 'none',
     domain_chain_spec_id: domainChainBinding.spec_id || null,
     domain_chain_path: domainChainBinding.chain_path || null,
+    problem_contract: problemContract,
     problem_evaluation: summarizeProblemEvaluation(planProblemEvaluation),
     related_specs_total: Number(relatedSpecLookup.total_candidates || 0),
     related_spec_ids: relatedSpecItems.map((item) => item.spec_id)
@@ -1457,16 +1729,19 @@ async function runStudioVerifyCommand(options = {}, dependencies = {}) {
   const autoErrorbookRecords = [];
   const gateSteps = await buildVerifyGateSteps({ profile }, {
     projectPath,
-    fileSystem
+    fileSystem,
+    specId: normalizeString(domainChainMetadata.spec_id) || null
   });
   const verifyProblemEvaluation = await enforceProblemEvaluationForStage(job, 'verify', {
     scene_id: normalizeString(job?.scene?.id),
     spec_id: normalizeString(domainChainMetadata.spec_id) || normalizeString(job?.source?.spec_id),
     goal: normalizeString(job?.source?.goal),
     domain_chain: job?.source?.domain_chain || {},
+    problem_contract: job?.source?.problem_contract || {},
     related_specs_count: Number(job?.source?.related_specs?.total_candidates || 0),
     stage_readiness: buildStageReadiness(job, 'verify', {
-      gate_required_ready: deriveGateSignals(gateSteps).required_missing === 0
+      gate_required_ready: deriveGateSignals(gateSteps).required_missing === 0,
+      convergence_strict: profile === 'strict'
     }),
     gate_signals: deriveGateSignals(gateSteps)
   }, {
@@ -1609,9 +1884,17 @@ async function runStudioReleaseCommand(options = {}, dependencies = {}) {
   const releaseStartedAt = nowIso();
   const domainChainMetadata = buildJobDomainChainMetadata(job);
   const autoErrorbookRecords = [];
-  const gateSteps = await buildReleaseGateSteps({ profile }, {
+  const verifyReportSignals = await readVerifyReportSignals(
     projectPath,
+    normalizeString(job?.artifacts?.verify_report),
     fileSystem
+  );
+  const governanceSignals = await readGovernanceSignals(projectPath, fileSystem);
+  const gateSteps = await buildReleaseGateSteps({ profile }, {
+    projectPath,
+    fileSystem,
+    specId: normalizeString(domainChainMetadata.spec_id) || null,
+    verifyReportPath: normalizeString(job?.artifacts?.verify_report) || null
   });
   const releaseGateSignals = deriveGateSignals(gateSteps);
   const releaseProblemEvaluation = await enforceProblemEvaluationForStage(job, 'release', {
@@ -1620,9 +1903,17 @@ async function runStudioReleaseCommand(options = {}, dependencies = {}) {
     goal: normalizeString(job?.source?.goal),
     release_channel: channel,
     domain_chain: job?.source?.domain_chain || {},
+    problem_contract: job?.source?.problem_contract || {},
     related_specs_count: Number(job?.source?.related_specs?.total_candidates || 0),
     stage_readiness: buildStageReadiness(job, 'release', {
-      gate_required_ready: releaseGateSignals.required_missing === 0
+      gate_required_ready: releaseGateSignals.required_missing === 0,
+      convergence_strict: profile === 'strict',
+      verify_stage_passed: isStageCompleted(job, 'verify'),
+      verify_report_ready: verifyReportSignals.available,
+      verify_report_passed: verifyReportSignals.passed,
+      regression_passed: verifyReportSignals.passed && verifyReportSignals.failed_step_count === 0,
+      governance_report_ready: governanceSignals.available,
+      high_alert_count: Number(governanceSignals.high_breach_count || 0)
     }),
     gate_signals: releaseGateSignals
   }, {
@@ -1672,6 +1963,8 @@ async function runStudioReleaseCommand(options = {}, dependencies = {}) {
     passed: gateResult.passed,
     steps: gateResult.steps,
     domain_chain: domainChainMetadata,
+    verify_signals: verifyReportSignals,
+    governance_signals: governanceSignals,
     problem_evaluation: summarizeProblemEvaluation(releaseProblemEvaluation),
     auto_errorbook_records: autoErrorbookRecords
   };