scene-capability-engine 3.4.5 → 3.5.0

package/lib/commands/studio.js

@@ -11,6 +11,10 @@ const {
 const { findRelatedSpecs } = require('../spec/related-specs');
 const { captureTimelineCheckpoint } = require('../runtime/project-timeline');
 const { runProblemEvaluation } = require('../problem/problem-evaluator');
+const {
+  runStudioAutoIntake,
+  runStudioSpecGovernance
+} = require('../studio/spec-intake-governor');
 
 const STUDIO_JOB_API_VERSION = 'sce.studio.job/v0.1';
 const STAGE_ORDER = ['plan', 'generate', 'apply', 'verify', 'release'];
@@ -19,6 +23,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 +374,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 +410,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 +457,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 +753,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 +839,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 +945,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 +981,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 +1040,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 +1065,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 +1099,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 +1113,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 +1186,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 +1202,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 +1222,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 +1303,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 || {}
@@ -1087,6 +1347,9 @@ async function runStudioPlanCommand(options = {}, dependencies = {}) {
   const fromChat = normalizeString(options.fromChat);
   const sceneId = normalizeString(options.scene);
   const specId = normalizeString(options.spec);
+  const goal = normalizeString(options.goal);
+  const manualSpecMode = options.manualSpec === true;
+  const skipSpecGovernance = options.specGovernance === false;
 
   if (!fromChat) {
     throw new Error('--from-chat is required');
@@ -1094,16 +1357,18 @@ async function runStudioPlanCommand(options = {}, dependencies = {}) {
   if (!sceneId) {
     throw new Error('--scene is required');
   }
-  const domainChainBinding = await resolveDomainChainBinding({
+
+  let domainChainBinding = await resolveDomainChainBinding({
     sceneId,
     specId,
-    goal: normalizeString(options.goal)
+    goal
   }, {
     projectPath,
     fileSystem
   });
-  const relatedSpecLookup = await findRelatedSpecs({
-    query: normalizeString(options.goal),
+
+  let relatedSpecLookup = await findRelatedSpecs({
+    query: goal,
     sceneId,
     limit: 8,
     excludeSpecId: domainChainBinding.spec_id || specId || null
@@ -1111,6 +1376,45 @@ async function runStudioPlanCommand(options = {}, dependencies = {}) {
     projectPath,
     fileSystem
   });
+
+  const intake = await runStudioAutoIntake({
+    scene_id: sceneId,
+    from_chat: fromChat,
+    goal,
+    explicit_spec_id: specId,
+    domain_chain_binding: domainChainBinding,
+    related_specs: relatedSpecLookup,
+    apply: !manualSpecMode,
+    skip: manualSpecMode
+  }, {
+    projectPath,
+    fileSystem
+  });
+
+  const intakeSpecId = normalizeString(intake && intake.selected_spec_id);
+  const effectiveSpecId = intakeSpecId || normalizeString(domainChainBinding.spec_id) || specId || null;
+
+  if (effectiveSpecId && effectiveSpecId !== normalizeString(domainChainBinding.spec_id)) {
+    domainChainBinding = await resolveDomainChainBinding({
+      sceneId,
+      specId: effectiveSpecId,
+      goal
+    }, {
+      projectPath,
+      fileSystem
+    });
+  }
+
+  relatedSpecLookup = await findRelatedSpecs({
+    query: goal,
+    sceneId,
+    limit: 8,
+    excludeSpecId: effectiveSpecId || null
+  }, {
+    projectPath,
+    fileSystem
+  });
+
   const relatedSpecItems = Array.isArray(relatedSpecLookup.related_specs)
     ? relatedSpecLookup.related_specs.map((item) => ({
       spec_id: item.spec_id,
@@ -1127,15 +1431,26 @@ async function runStudioPlanCommand(options = {}, dependencies = {}) {
 
   const jobId = normalizeString(options.job) || createJobId();
   const now = nowIso();
+  const problemContract = normalizeProblemContract(
+    domainChainBinding.problem_contract || {},
+    {
+      scene_id: sceneId,
+      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
+      spec_id: effectiveSpecId
     },
     source: {
-      goal: normalizeString(options.goal) || null,
-      spec_id: domainChainBinding.spec_id || specId || null,
+      goal: goal || null,
+      spec_id: effectiveSpecId,
+      problem_contract: problemContract,
+      problem_contract_path: domainChainBinding.problem_contract_path || null,
       domain_chain: {
         resolved: domainChainBinding.resolved === true,
         summary: domainChainBinding.summary || null
@@ -1148,8 +1463,9 @@ async function runStudioPlanCommand(options = {}, dependencies = {}) {
   };
   const planProblemEvaluation = await enforceProblemEvaluationForStage(planShadowJob, 'plan', {
     scene_id: sceneId,
-    spec_id: domainChainBinding.spec_id || specId || null,
-    goal: normalizeString(options.goal) || null,
+    spec_id: effectiveSpecId,
+    goal: goal || null,
+    problem_contract: problemContract,
     domain_chain: {
       resolved: domainChainBinding.resolved === true,
       summary: domainChainBinding.summary || null
@@ -1176,16 +1492,35 @@ async function runStudioPlanCommand(options = {}, dependencies = {}) {
   const sessionStore = dependencies.sessionStore || new SessionStore(projectPath);
   const sceneSessionBinding = await sessionStore.beginSceneSession({
     sceneId,
-    objective: normalizeString(options.goal) || `Studio scene cycle for ${sceneId}`,
+    objective: goal || `Studio scene cycle for ${sceneId}`,
     tool: normalizeString(options.tool) || 'generic'
   });
+
+  let governanceSnapshot = null;
+  let governanceWarning = '';
+  const autoRunGovernance = !(skipSpecGovernance)
+    && (!intake || !intake.policy || !intake.policy.governance || intake.policy.governance.auto_run_on_plan !== false);
+  if (autoRunGovernance) {
+    try {
+      governanceSnapshot = await runStudioSpecGovernance({
+        apply: true,
+        scene: sceneId
+      }, {
+        projectPath,
+        fileSystem
+      });
+    } catch (error) {
+      governanceWarning = normalizeString(error && error.message);
+    }
+  }
+
   stages.plan = {
     status: 'completed',
     completed_at: now,
     metadata: {
       from_chat: fromChat,
       scene_id: sceneId,
-      spec_id: domainChainBinding.spec_id || specId || null,
+      spec_id: effectiveSpecId,
       scene_session_id: sceneSessionBinding.session.session_id,
       scene_cycle: sceneSessionBinding.scene_cycle,
       domain_chain_resolved: domainChainBinding.resolved === true,
@@ -1194,7 +1529,19 @@ 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,
+      intake: intake ? {
+        enabled: intake.enabled === true,
+        intent_type: intake.intent ? intake.intent.intent_type : null,
+        decision_action: intake.decision ? intake.decision.action : null,
+        decision_reason: intake.decision ? intake.decision.reason : null,
+        selected_spec_id: intake.selected_spec_id || effectiveSpecId || null,
+        created_spec_id: intake.created_spec && intake.created_spec.created ? intake.created_spec.spec_id : null,
+        policy_path: intake.policy_path || null
+      } : null,
       problem_evaluation: summarizeProblemEvaluation(planProblemEvaluation),
+      spec_governance: governanceSnapshot ? governanceSnapshot.summary : null,
+      spec_governance_warning: governanceWarning || null,
       related_specs_total: Number(relatedSpecLookup.total_candidates || 0),
       related_specs_top: relatedSpecItems
     }
@@ -1208,13 +1555,24 @@ async function runStudioPlanCommand(options = {}, dependencies = {}) {
     status: 'planned',
     source: {
       from_chat: fromChat,
-      goal: normalizeString(options.goal) || null,
-      spec_id: domainChainBinding.spec_id || specId || null,
+      goal: goal || null,
+      spec_id: effectiveSpecId,
+      problem_contract: problemContract,
+      problem_contract_path: domainChainBinding.problem_contract_path || null,
+      intake: intake ? {
+        enabled: intake.enabled === true,
+        policy_path: intake.policy_path || null,
+        policy_loaded_from: intake.policy_loaded_from || null,
+        intent: intake.intent || null,
+        decision: intake.decision || null,
+        selected_spec_id: intake.selected_spec_id || effectiveSpecId || null,
+        created_spec: intake.created_spec || null
+      } : null,
       domain_chain: {
         resolved: domainChainBinding.resolved === true,
         source: domainChainBinding.source || 'none',
         reason: domainChainBinding.reason || null,
-        spec_id: domainChainBinding.spec_id || null,
+        spec_id: effectiveSpecId || domainChainBinding.spec_id || null,
         chain_path: domainChainBinding.chain_path || null,
         candidate_count: Number.isFinite(Number(domainChainBinding.candidate_count))
           ? Number(domainChainBinding.candidate_count)
@@ -1229,11 +1587,20 @@ async function runStudioPlanCommand(options = {}, dependencies = {}) {
         scene_id: relatedSpecLookup.scene_id || null,
         total_candidates: Number(relatedSpecLookup.total_candidates || 0),
         items: relatedSpecItems
-      }
+      },
+      spec_governance: governanceSnapshot
+        ? {
+          status: governanceSnapshot.summary ? governanceSnapshot.summary.status : null,
+          alert_count: governanceSnapshot.summary ? Number(governanceSnapshot.summary.alert_count || 0) : 0,
+          report_file: governanceSnapshot.report_file || null,
+          scene_index_file: governanceSnapshot.scene_index_file || null
+        }
+        : null,
+      spec_governance_warning: governanceWarning || null
     },
     scene: {
       id: sceneId,
-      spec_id: domainChainBinding.spec_id || specId || null,
+      spec_id: effectiveSpecId,
       related_spec_ids: relatedSpecItems.map((item) => item.spec_id)
     },
     session: {
@@ -1249,6 +1616,12 @@ async function runStudioPlanCommand(options = {}, dependencies = {}) {
       patch_bundle_id: null,
       verify_report: null,
       release_ref: null,
+      spec_portfolio_report: governanceSnapshot && governanceSnapshot.report_file
+        ? governanceSnapshot.report_file
+        : null,
+      spec_scene_index: governanceSnapshot && governanceSnapshot.scene_index_file
+        ? governanceSnapshot.scene_index_file
+        : null,
       problem_eval_reports: {
         plan: normalizeString(planProblemEvaluation.report_file) || null
       }
@@ -1259,7 +1632,7 @@ async function runStudioPlanCommand(options = {}, dependencies = {}) {
   await appendStudioEvent(paths, job, 'stage.plan.completed', {
     from_chat: fromChat,
     scene_id: sceneId,
-    spec_id: domainChainBinding.spec_id || specId || null,
+    spec_id: effectiveSpecId,
     scene_session_id: sceneSessionBinding.session.session_id,
     scene_cycle: sceneSessionBinding.scene_cycle,
     target: job.target,
@@ -1267,13 +1640,28 @@ 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,
+    intake_action: intake && intake.decision ? intake.decision.action : null,
+    intake_reason: intake && intake.decision ? intake.decision.reason : null,
+    intake_selected_spec_id: intake ? intake.selected_spec_id || effectiveSpecId || null : effectiveSpecId,
+    intake_created_spec_id: intake && intake.created_spec && intake.created_spec.created
+      ? intake.created_spec.spec_id
+      : null,
     problem_evaluation: summarizeProblemEvaluation(planProblemEvaluation),
+    spec_governance: governanceSnapshot ? governanceSnapshot.summary : null,
+    spec_governance_warning: governanceWarning || null,
     related_specs_total: Number(relatedSpecLookup.total_candidates || 0),
     related_spec_ids: relatedSpecItems.map((item) => item.spec_id)
   }, fileSystem);
   await writeLatestJob(paths, jobId, fileSystem);
 
   const payload = buildCommandPayload('studio-plan', job);
+  payload.scene = {
+    id: sceneId,
+    spec_id: effectiveSpecId
+  };
+  payload.intake = job.source && job.source.intake ? job.source.intake : null;
+  payload.spec_governance = governanceSnapshot ? governanceSnapshot.summary : null;
   printStudioPayload(payload, options);
   return payload;
 }
@@ -1457,16 +1845,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 +2000,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 +2019,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 +2079,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
   };
@@ -1885,6 +2294,116 @@ async function runStudioEventsCommand(options = {}, dependencies = {}) {
   return payload;
 }
 
+function printStudioIntakePayload(payload, options = {}) {
+  if (options.json) {
+    console.log(JSON.stringify(payload, null, 2));
+    return;
+  }
+
+  console.log(chalk.blue('Studio intake'));
+  console.log(`  Scene: ${payload.scene_id || 'n/a'}`);
+  console.log(`  Goal: ${payload.goal || '(empty)'}`);
+  console.log(`  Intent: ${payload.intent && payload.intent.intent_type ? payload.intent.intent_type : 'unknown'}`);
+  console.log(`  Decision: ${payload.decision && payload.decision.action ? payload.decision.action : 'none'}`);
+  console.log(`  Spec: ${payload.selected_spec_id || 'n/a'}`);
+}
+
+async function runStudioIntakeCommand(options = {}, dependencies = {}) {
+  const projectPath = dependencies.projectPath || process.cwd();
+  const fileSystem = dependencies.fileSystem || fs;
+  const sceneId = normalizeString(options.scene);
+  const fromChat = normalizeString(options.fromChat);
+  const goal = normalizeString(options.goal);
+  const specId = normalizeString(options.spec);
+
+  if (!sceneId) {
+    throw new Error('--scene is required');
+  }
+  if (!fromChat) {
+    throw new Error('--from-chat is required');
+  }
+
+  const domainChainBinding = await resolveDomainChainBinding({
+    sceneId,
+    specId,
+    goal
+  }, {
+    projectPath,
+    fileSystem
+  });
+
+  const relatedSpecLookup = await findRelatedSpecs({
+    query: goal,
+    sceneId,
+    limit: 8,
+    excludeSpecId: domainChainBinding.spec_id || specId || null
+  }, {
+    projectPath,
+    fileSystem
+  });
+
+  const intake = await runStudioAutoIntake({
+    scene_id: sceneId,
+    from_chat: fromChat,
+    goal,
+    explicit_spec_id: specId,
+    domain_chain_binding: domainChainBinding,
+    related_specs: relatedSpecLookup,
+    apply: options.apply === true,
+    skip: options.manualSpec === true
+  }, {
+    projectPath,
+    fileSystem
+  });
+
+  const payload = {
+    ...intake,
+    domain_chain_source: domainChainBinding.source || 'none',
+    domain_chain_spec_id: domainChainBinding.spec_id || null,
+    related_specs_total: Number(relatedSpecLookup.total_candidates || 0)
+  };
+  printStudioIntakePayload(payload, options);
+  return payload;
+}
+
+function printStudioPortfolioPayload(payload, options = {}) {
+  if (options.json) {
+    console.log(JSON.stringify(payload, null, 2));
+    return;
+  }
+  const summary = payload.summary || {};
+  console.log(chalk.blue('Studio portfolio governance'));
+  console.log(`  Status: ${summary.status || 'unknown'}`);
+  console.log(`  Scenes: ${summary.scene_count || 0}`);
+  console.log(`  Specs: ${summary.total_specs || 0}`);
+  console.log(`  Active: ${summary.active_specs || 0}`);
+  console.log(`  Completed: ${summary.completed_specs || 0}`);
+  console.log(`  Stale: ${summary.stale_specs || 0}`);
+  console.log(`  Duplicate pairs: ${summary.duplicate_pairs || 0}`);
+  console.log(`  Overflow scenes: ${summary.overflow_scenes || 0}`);
+}
+
+async function runStudioPortfolioCommand(options = {}, dependencies = {}) {
+  const projectPath = dependencies.projectPath || process.cwd();
+  const fileSystem = dependencies.fileSystem || fs;
+  const payload = await runStudioSpecGovernance({
+    scene: normalizeString(options.scene),
+    apply: options.apply !== false
+  }, {
+    projectPath,
+    fileSystem
+  });
+
+  if (options.strict && payload.summary && Number(payload.summary.alert_count || 0) > 0) {
+    throw new Error(
+      `studio portfolio governance has alerts: ${payload.summary.alert_count} (duplicate/stale/overflow)`
+    );
+  }
+
+  printStudioPortfolioPayload(payload, options);
+  return payload;
+}
+
 async function runStudioCommand(handler, options, stageName = '') {
   try {
     const stage = normalizeString(stageName) || 'unknown';
@@ -1928,11 +2447,34 @@ function registerStudioCommands(program) {
     .requiredOption('--from-chat <session>', 'Chat session identifier or transcript reference')
     .option('--spec <spec-id>', 'Optional spec binding for domain-chain context ingestion')
     .option('--goal <goal>', 'Optional goal summary')
+    .option('--manual-spec', 'Disable auto intake and only use explicit --spec or existing scene binding')
     .option('--target <target>', 'Target integration profile', 'default')
+    .option('--no-spec-governance', 'Skip auto portfolio governance snapshot on plan stage')
     .option('--job <job-id>', 'Reuse an explicit studio job id')
     .option('--json', 'Print machine-readable JSON output')
     .action(async (options) => runStudioCommand(runStudioPlanCommand, options, 'plan'));
 
+  studio
+    .command('intake')
+    .description('Analyze chat goal and auto-resolve spec binding/create decision')
+    .requiredOption('--scene <scene-id>', 'Scene identifier')
+    .requiredOption('--from-chat <session>', 'Chat session identifier or transcript reference')
+    .option('--spec <spec-id>', 'Optional explicit spec id')
+    .option('--goal <goal>', 'Goal text used for intent classification')
+    .option('--apply', 'Create spec when decision is create_spec')
+    .option('--manual-spec', 'Disable auto intake and keep explicit/manual binding only')
+    .option('--json', 'Print machine-readable JSON output')
+    .action(async (options) => runStudioCommand(runStudioIntakeCommand, options, 'intake'));
+
+  studio
+    .command('portfolio')
+    .description('Build scene-organized spec governance portfolio')
+    .option('--scene <scene-id>', 'Optional scene filter')
+    .option('--no-apply', 'Do not write portfolio/index artifacts to .sce/spec-governance/')
+    .option('--strict', 'Fail when governance alerts are detected')
+    .option('--json', 'Print machine-readable JSON output')
+    .action(async (options) => runStudioCommand(runStudioPortfolioCommand, options, 'portfolio'));
+
   studio
     .command('generate')
     .description('Generate patch bundle metadata for a planned studio job (scene inherited from plan)')
@@ -2017,12 +2559,14 @@ module.exports = {
   resolveNextAction,
   buildProgress,
   runStudioPlanCommand,
+  runStudioIntakeCommand,
   runStudioGenerateCommand,
   runStudioApplyCommand,
   runStudioVerifyCommand,
   runStudioReleaseCommand,
   runStudioRollbackCommand,
   runStudioEventsCommand,
+  runStudioPortfolioCommand,
   runStudioResumeCommand,
   registerStudioCommands
 };