scene-capability-engine 3.3.26 → 3.4.6

package/lib/commands/studio.js

@@ -10,6 +10,7 @@ const {
 } = require('../spec/domain-modeling');
 const { findRelatedSpecs } = require('../spec/related-specs');
 const { captureTimelineCheckpoint } = require('../runtime/project-timeline');
+const { runProblemEvaluation } = require('../problem/problem-evaluator');
 
 const STUDIO_JOB_API_VERSION = 'sce.studio.job/v0.1';
 const STAGE_ORDER = ['plan', 'generate', 'apply', 'verify', 'release'];
@@ -18,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,
@@ -367,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(', ')}`);
@@ -402,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({
@@ -434,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',
@@ -709,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 [];
@@ -724,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,
@@ -746,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)
@@ -780,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) || ''
+    })
   };
 }
 
@@ -833,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 {
@@ -848,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
     };
   }
 
@@ -872,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',
@@ -885,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
   };
 }
 
@@ -948,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',
@@ -956,17 +1198,145 @@ 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
   };
 }
 
+function summarizeProblemEvaluation(evaluation = {}) {
+  return {
+    passed: evaluation.passed === true,
+    blocked: evaluation.blocked === true,
+    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 : [],
+    report_file: normalizeString(evaluation.report_file) || null
+  };
+}
+
+function deriveGateSignals(steps = []) {
+  const normalized = Array.isArray(steps) ? steps : [];
+  const requiredTotal = normalized.filter((step) => step && step.required !== false).length;
+  const requiredEnabled = normalized.filter((step) => step && step.required !== false && step.enabled !== false).length;
+  return {
+    required_total: requiredTotal,
+    required_enabled: requiredEnabled,
+    required_missing: Math.max(0, requiredTotal - requiredEnabled)
+  };
+}
+
+function buildStageReadiness(job = {}, stage = '', overrides = {}) {
+  const normalizedStage = normalizeString(stage).toLowerCase();
+  const patchBundleReady = normalizeString(job?.artifacts?.patch_bundle_id).length > 0;
+  const verifyReportReady = normalizeString(job?.artifacts?.verify_report).length > 0;
+  const readiness = {
+    prerequisites_ready: true,
+    rollback_ready: isStageCompleted(job, 'apply'),
+    patch_bundle_ready: patchBundleReady,
+    verify_report_ready: verifyReportReady
+  };
+
+  if (normalizedStage === 'generate') {
+    readiness.prerequisites_ready = isStageCompleted(job, 'plan');
+  } else if (normalizedStage === 'apply') {
+    readiness.prerequisites_ready = isStageCompleted(job, 'generate');
+  } else if (normalizedStage === 'verify') {
+    readiness.prerequisites_ready = isStageCompleted(job, 'apply');
+  } else if (normalizedStage === 'release') {
+    readiness.prerequisites_ready = isStageCompleted(job, 'verify');
+  }
+
+  return {
+    ...readiness,
+    ...overrides
+  };
+}
+
+function assignProblemEvalArtifact(job = {}, stage = '', evaluation = {}) {
+  const normalizedStage = normalizeString(stage).toLowerCase();
+  if (!normalizedStage) {
+    return;
+  }
+  job.artifacts = job.artifacts || {};
+  const reports = job.artifacts.problem_eval_reports && typeof job.artifacts.problem_eval_reports === 'object'
+    ? job.artifacts.problem_eval_reports
+    : {};
+  reports[normalizedStage] = normalizeString(evaluation.report_file) || null;
+  job.artifacts.problem_eval_reports = reports;
+}
+
+async function enforceProblemEvaluationForStage(job = {}, stage = '', context = {}, dependencies = {}) {
+  const projectPath = dependencies.projectPath || process.cwd();
+  const fileSystem = dependencies.fileSystem || fs;
+  const evaluation = await runProblemEvaluation({
+    stage,
+    job_id: normalizeString(job.job_id),
+    scene_id: normalizeString(context.scene_id || job?.scene?.id),
+    spec_id: normalizeString(context.spec_id || job?.source?.spec_id || job?.scene?.spec_id),
+    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 || {}
+  }, {
+    projectPath,
+    fileSystem,
+    env: dependencies.env,
+    writeReport: true
+  });
+  assignProblemEvalArtifact(job, stage, evaluation);
+  return evaluation;
+}
+
+async function markStudioStageBlockedByProblemEval(paths, job, stageName, evaluation, fileSystem = fs) {
+  const summary = summarizeProblemEvaluation(evaluation);
+  job.status = `${stageName}_blocked`;
+  job.updated_at = nowIso();
+  job.stages = job.stages || createStageState();
+  job.stages[stageName] = {
+    status: 'blocked',
+    completed_at: null,
+    metadata: {
+      problem_evaluation: summary
+    }
+  };
+  await saveJob(paths, job, fileSystem);
+  await appendStudioEvent(paths, job, `stage.${stageName}.blocked`, {
+    problem_evaluation: summary
+  }, fileSystem);
+  await writeLatestJob(paths, job.job_id, fileSystem);
+
+  const reason = summary.blockers.length > 0
+    ? summary.blockers.join(', ')
+    : 'problem-evaluation-policy';
+  throw new Error(`studio ${stageName} blocked by problem evaluation: ${reason}`);
+}
+
 async function runStudioPlanCommand(options = {}, dependencies = {}) {
   const projectPath = dependencies.projectPath || process.cwd();
   const fileSystem = dependencies.fileSystem || fs;
@@ -1013,6 +1383,63 @@ 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: {
+      id: sceneId,
+      spec_id: domainChainBinding.spec_id || specId || null
+    },
+    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
+      },
+      related_specs: {
+        total_candidates: Number(relatedSpecLookup.total_candidates || 0)
+      }
+    },
+    artifacts: {}
+  };
+  const planProblemEvaluation = await enforceProblemEvaluationForStage(planShadowJob, 'plan', {
+    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
+    },
+    related_specs_count: Number(relatedSpecLookup.total_candidates || 0),
+    stage_readiness: {
+      prerequisites_ready: true,
+      rollback_ready: false,
+      patch_bundle_ready: false,
+      verify_report_ready: false
+    }
+  }, {
+    projectPath,
+    fileSystem,
+    env: dependencies.env
+  });
+  if (!planProblemEvaluation.passed) {
+    const blockers = Array.isArray(planProblemEvaluation.blockers) && planProblemEvaluation.blockers.length > 0
+      ? planProblemEvaluation.blockers.join(', ')
+      : 'problem-evaluation-policy';
+    throw new Error(`studio plan blocked by problem evaluation: ${blockers}`);
+  }
   const stages = createStageState();
   const sessionStore = dependencies.sessionStore || new SessionStore(projectPath);
   const sceneSessionBinding = await sessionStore.beginSceneSession({
@@ -1035,6 +1462,8 @@ 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
     }
@@ -1050,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',
@@ -1088,7 +1519,10 @@ async function runStudioPlanCommand(options = {}, dependencies = {}) {
     artifacts: {
       patch_bundle_id: null,
       verify_report: null,
-      release_ref: null
+      release_ref: null,
+      problem_eval_reports: {
+        plan: normalizeString(planProblemEvaluation.report_file) || null
+      }
     }
   };
 
@@ -1104,6 +1538,8 @@ 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)
   }, fileSystem);
@@ -1138,6 +1574,21 @@ async function runStudioGenerateCommand(options = {}, dependencies = {}) {
     throw new Error(`Scene mismatch: planned scene is "${jobSceneId}" but --scene provided "${sceneArg}"`);
   }
   const sceneId = sceneArg || jobSceneId;
+  const generateProblemEvaluation = await enforceProblemEvaluationForStage(job, 'generate', {
+    scene_id: sceneId,
+    spec_id: normalizeString(job?.source?.spec_id) || normalizeString(job?.scene?.spec_id) || null,
+    goal: normalizeString(job?.source?.goal),
+    domain_chain: job?.source?.domain_chain || {},
+    related_specs_count: Number(job?.source?.related_specs?.total_candidates || 0),
+    stage_readiness: buildStageReadiness(job, 'generate')
+  }, {
+    projectPath,
+    fileSystem,
+    env: dependencies.env
+  });
+  if (!generateProblemEvaluation.passed) {
+    await markStudioStageBlockedByProblemEval(paths, job, 'generate', generateProblemEvaluation, fileSystem);
+  }
   const patchBundleId = normalizeString(options.patchBundle) || `patch-${sceneId}-${Date.now()}`;
   const domainChainMetadata = buildJobDomainChainMetadata(job);
   const generateReportPath = `${STUDIO_REPORTS_DIR}/generate-${job.job_id}.json`;
@@ -1167,6 +1618,7 @@ async function runStudioGenerateCommand(options = {}, dependencies = {}) {
     scene_id: sceneId,
     target: job.target,
     patch_bundle_id: patchBundleId,
+    problem_evaluation: summarizeProblemEvaluation(generateProblemEvaluation),
     domain_chain: domainChainMetadata,
     report: generateReportPath
   });
@@ -1176,6 +1628,7 @@ async function runStudioGenerateCommand(options = {}, dependencies = {}) {
     scene_id: sceneId,
     target: job.target,
     patch_bundle_id: patchBundleId,
+    problem_evaluation: summarizeProblemEvaluation(generateProblemEvaluation),
     domain_chain: domainChainMetadata,
     report: generateReportPath
   }, fileSystem);
@@ -1211,6 +1664,23 @@ async function runStudioApplyCommand(options = {}, dependencies = {}) {
   if (!patchBundleId) {
     throw new Error('--patch-bundle is required (or generate stage must provide one)');
   }
+  const applyProblemEvaluation = await enforceProblemEvaluationForStage(job, 'apply', {
+    scene_id: normalizeString(job?.scene?.id),
+    spec_id: normalizeString(job?.source?.spec_id) || normalizeString(job?.scene?.spec_id) || null,
+    goal: normalizeString(job?.source?.goal),
+    domain_chain: job?.source?.domain_chain || {},
+    related_specs_count: Number(job?.source?.related_specs?.total_candidates || 0),
+    stage_readiness: buildStageReadiness(job, 'apply', {
+      patch_bundle_ready: normalizeString(patchBundleId).length > 0
+    })
+  }, {
+    projectPath,
+    fileSystem,
+    env: dependencies.env
+  });
+  if (!applyProblemEvaluation.passed) {
+    await markStudioStageBlockedByProblemEval(paths, job, 'apply', applyProblemEvaluation, fileSystem);
+  }
 
   job.status = 'applied';
   job.artifacts = job.artifacts || {};
@@ -1219,13 +1689,15 @@ async function runStudioApplyCommand(options = {}, dependencies = {}) {
 
   ensureStageCompleted(job, 'apply', {
     patch_bundle_id: patchBundleId,
-    auth_required: authResult.required
+    auth_required: authResult.required,
+    problem_evaluation: summarizeProblemEvaluation(applyProblemEvaluation)
   });
 
   await saveJob(paths, job, fileSystem);
   await appendStudioEvent(paths, job, 'stage.apply.completed', {
     patch_bundle_id: patchBundleId,
-    auth_required: authResult.required
+    auth_required: authResult.required,
+    problem_evaluation: summarizeProblemEvaluation(applyProblemEvaluation)
   }, fileSystem);
   await writeLatestJob(paths, jobId, fileSystem);
 
@@ -1257,8 +1729,29 @@ 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,
+      convergence_strict: profile === 'strict'
+    }),
+    gate_signals: deriveGateSignals(gateSteps)
+  }, {
+    projectPath,
+    fileSystem,
+    env: dependencies.env
   });
+  if (!verifyProblemEvaluation.passed) {
+    await markStudioStageBlockedByProblemEval(paths, job, 'verify', verifyProblemEvaluation, fileSystem);
+  }
   const gateResult = await executeGateSteps(gateSteps, {
     projectPath,
     commandRunner: dependencies.commandRunner,
@@ -1296,6 +1789,7 @@ async function runStudioVerifyCommand(options = {}, dependencies = {}) {
     passed: gateResult.passed,
     steps: gateResult.steps,
     domain_chain: domainChainMetadata,
+    problem_evaluation: summarizeProblemEvaluation(verifyProblemEvaluation),
     auto_errorbook_records: autoErrorbookRecords
   };
 
@@ -1314,6 +1808,7 @@ async function runStudioVerifyCommand(options = {}, dependencies = {}) {
         profile,
         passed: false,
         report: verifyReportPath,
+        problem_evaluation: summarizeProblemEvaluation(verifyProblemEvaluation),
         domain_chain: domainChainMetadata,
         auto_errorbook_records: autoErrorbookRecords
       }
@@ -1322,6 +1817,7 @@ async function runStudioVerifyCommand(options = {}, dependencies = {}) {
     await appendStudioEvent(paths, job, 'stage.verify.failed', {
       profile,
       report: verifyReportPath,
+      problem_evaluation: summarizeProblemEvaluation(verifyProblemEvaluation),
       domain_chain: domainChainMetadata,
       auto_errorbook_records: autoErrorbookRecords
     }, fileSystem);
@@ -1334,6 +1830,7 @@ async function runStudioVerifyCommand(options = {}, dependencies = {}) {
     profile,
     passed: true,
     report: verifyReportPath,
+    problem_evaluation: summarizeProblemEvaluation(verifyProblemEvaluation),
     domain_chain: domainChainMetadata,
     auto_errorbook_records: autoErrorbookRecords
   });
@@ -1343,6 +1840,7 @@ async function runStudioVerifyCommand(options = {}, dependencies = {}) {
     profile,
     passed: true,
     report: verifyReportPath,
+    problem_evaluation: summarizeProblemEvaluation(verifyProblemEvaluation),
     domain_chain: domainChainMetadata,
     auto_errorbook_records: autoErrorbookRecords
   }, fileSystem);
@@ -1386,10 +1884,46 @@ 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', {
+    scene_id: normalizeString(job?.scene?.id),
+    spec_id: normalizeString(domainChainMetadata.spec_id) || normalizeString(job?.source?.spec_id),
+    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,
+      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
+  }, {
+    projectPath,
+    fileSystem,
+    env: dependencies.env
+  });
+  if (!releaseProblemEvaluation.passed) {
+    await markStudioStageBlockedByProblemEval(paths, job, 'release', releaseProblemEvaluation, fileSystem);
+  }
   const gateResult = await executeGateSteps(gateSteps, {
     projectPath,
     commandRunner: dependencies.commandRunner,
@@ -1429,6 +1963,9 @@ 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
   };
 
@@ -1450,6 +1987,7 @@ async function runStudioReleaseCommand(options = {}, dependencies = {}) {
         passed: false,
         report: releaseReportPath,
         auth_required: authResult.required,
+        problem_evaluation: summarizeProblemEvaluation(releaseProblemEvaluation),
         domain_chain: domainChainMetadata,
         auto_errorbook_records: autoErrorbookRecords
       }
@@ -1460,6 +1998,7 @@ async function runStudioReleaseCommand(options = {}, dependencies = {}) {
       release_ref: releaseRef,
       report: releaseReportPath,
       auth_required: authResult.required,
+      problem_evaluation: summarizeProblemEvaluation(releaseProblemEvaluation),
       domain_chain: domainChainMetadata,
       auto_errorbook_records: autoErrorbookRecords
     }, fileSystem);
@@ -1473,6 +2012,7 @@ async function runStudioReleaseCommand(options = {}, dependencies = {}) {
     release_ref: releaseRef,
     report: releaseReportPath,
     auth_required: authResult.required,
+    problem_evaluation: summarizeProblemEvaluation(releaseProblemEvaluation),
     domain_chain: domainChainMetadata,
     auto_errorbook_records: autoErrorbookRecords
   });
@@ -1504,6 +2044,7 @@ async function runStudioReleaseCommand(options = {}, dependencies = {}) {
     release_ref: releaseRef,
     report: releaseReportPath,
     auth_required: authResult.required,
+    problem_evaluation: summarizeProblemEvaluation(releaseProblemEvaluation),
     domain_chain: domainChainMetadata,
     auto_errorbook_records: autoErrorbookRecords
   }, fileSystem);