scene-capability-engine 3.6.64 → 3.6.67

package/lib/commands/studio.js

@@ -4,6 +4,7 @@ const { spawnSync } = require('child_process');
 const fs = require('fs-extra');
 const chalk = require('chalk');
 const { SessionStore } = require('../runtime/session-store');
+const { buildProjectChannelOutput } = require('../project/project-channel-output');
 const {
   DOMAIN_CHAIN_RELATIVE_PATH,
   ensureSpecDomainArtifacts
@@ -27,6 +28,12 @@ const {
   resolveTaskReference: resolveSharedTaskReference,
   buildCommandPayload: buildSharedCommandPayload
 } = require('../studio/task-envelope');
+const {
+  assessSupremeIntent,
+  buildSupremeRefusalError,
+  writeSupremeIntentEvidence,
+  recordSupremeIntentAssessment
+} = require('../governance/supreme-principles');
 
 const STUDIO_JOB_API_VERSION = 'sce.studio.job/v0.1';
 const STAGE_ORDER = ['plan', 'generate', 'apply', 'verify', 'release'];
@@ -1579,6 +1586,185 @@ function printStudioPayload(payload, options = {}) {
   console.log(`  Status: ${payload.status}`);
   console.log(`  Progress: ${payload.progress.completed}/${payload.progress.total} (${payload.progress.percent}%)`);
   console.log(`  Next: ${payload.next_action}`);
+  if (payload.project_channel && payload.project_channel.project_id) {
+    console.log(`  Project Channel: ${payload.project_channel.project_id} / ${payload.project_channel.channel_id}`);
+  }
+}
+
+function deriveStudioProjectId(projectPath, options = {}, job = {}) {
+  const explicit = normalizeString(options.projectId);
+  if (explicit) {
+    return explicit;
+  }
+  const persisted = normalizeString(job?.session?.project_channel?.project_id);
+  if (persisted) {
+    return persisted;
+  }
+  const folderName = normalizeString(path.basename(projectPath));
+  return folderName || 'project';
+}
+
+function deriveStudioCollabChannelId(options = {}, job = {}) {
+  const explicit = normalizeString(options.collabChannel);
+  if (explicit) {
+    return explicit;
+  }
+  const persisted = normalizeString(job?.session?.project_channel?.channel_id);
+  if (persisted) {
+    return persisted;
+  }
+  const fromChat = normalizeString(options.fromChat) || normalizeString(job?.source?.from_chat);
+  return fromChat || '';
+}
+
+function buildStudioProjectChannelBinding(projectPath, options = {}, job = {}) {
+  const projectId = deriveStudioProjectId(projectPath, options, job);
+  const channelId = deriveStudioCollabChannelId(options, job);
+  if (!projectId || !channelId) {
+    return null;
+  }
+  return {
+    project_id: projectId,
+    channel_id: channelId,
+    source: normalizeString(options.collabChannel) ? 'explicit-collab-channel' : 'chat-session'
+  };
+}
+
+function createStudioSessionStore(projectPath, dependencies = {}) {
+  const fileSystem = dependencies.fileSystem || fs;
+  return dependencies.sessionStore || new SessionStore(projectPath, null, {
+    fileSystem,
+    env: dependencies.env,
+    sqliteModule: dependencies.sqliteModule
+  });
+}
+
+async function resolveStudioProjectChannelFocus(projectPath, options = {}, dependencies = {}) {
+  const binding = buildStudioProjectChannelBinding(projectPath, options);
+  if (!binding) {
+    return null;
+  }
+
+  const sessionStore = createStudioSessionStore(projectPath, dependencies);
+  try {
+    const resolved = await sessionStore.getProjectChannelSession(binding.project_id, binding.channel_id);
+    return {
+      ...binding,
+      ...buildProjectChannelOutput({
+        projectId: binding.project_id,
+        canonicalProjectId: binding.project_id,
+        requestedChannelId: binding.channel_id,
+        storageMode: resolved.storageMode,
+        contextAvailable: resolved.contextAvailable,
+        context: resolved.context,
+        channel: resolved.channel,
+        session: resolved.session,
+        resolvedChannelId: resolved.resolvedChannelId
+      })
+    };
+  } catch (_error) {
+    return {
+      ...binding,
+      context_available: false,
+      storage_mode: 'none',
+      requested_channel_id: normalizeString(binding.channel_id) || null,
+      focused_channel_id: null,
+      channel_id: normalizeString(binding.channel_id) || null,
+      active_scene: null,
+      active_spec_id: null,
+      active_doc: null,
+      active_session_path: null,
+      run_state: null,
+      updated_at: null,
+      resolved_session_id: null
+    };
+  }
+}
+
+async function syncStudioProjectChannel(job, stageDoc, options = {}, dependencies = {}) {
+  const projectPath = dependencies.projectPath || process.cwd();
+  const sessionStore = createStudioSessionStore(projectPath, dependencies);
+  const binding = buildStudioProjectChannelBinding(projectPath, options, job);
+  const sceneSessionId = normalizeString(job?.session?.scene_session_id);
+  if (!binding || !sceneSessionId) {
+    return null;
+  }
+
+  const bound = await sessionStore.bindSessionToProjectChannel(sceneSessionId, {
+    projectId: binding.project_id,
+    channelId: binding.channel_id,
+    activeScene: normalizeString(job?.scene?.id),
+    activeSpecId: normalizeString(job?.scene?.spec_id) || normalizeString(job?.source?.spec_id),
+    activeDoc: normalizeString(stageDoc),
+    focus: true,
+    syncCurrentContext: true
+  });
+
+  job.session = job.session || {};
+  job.session.project_channel = {
+    project_id: binding.project_id,
+    channel_id: binding.channel_id,
+    focused_channel_id: bound.context.focusedChannelId,
+    active_session_path: bound.channel.activeSessionPath,
+    active_scene: bound.channel.activeScene,
+    active_spec_id: bound.channel.activeSpecId,
+    active_doc: bound.channel.activeDoc,
+    source: binding.source,
+    synced_at: nowIso()
+  };
+  return job.session.project_channel;
+}
+
+async function attachStudioProjectChannelPayload(payload, job, dependencies = {}) {
+  const projectPath = dependencies.projectPath || process.cwd();
+  const binding = job?.session?.project_channel;
+  const projectId = normalizeString(binding && binding.project_id);
+  const channelId = normalizeString(binding && binding.channel_id);
+  if (!projectId || !channelId) {
+    return payload;
+  }
+
+  const sessionStore = createStudioSessionStore(projectPath, dependencies);
+  const resolved = await sessionStore.getProjectChannelSession(projectId, channelId);
+  payload.project_channel = buildProjectChannelOutput({
+    projectId,
+    canonicalProjectId: projectId,
+    requestedChannelId: channelId,
+    storageMode: resolved.storageMode,
+    contextAvailable: resolved.contextAvailable,
+    context: resolved.context,
+    channel: resolved.channel,
+    session: resolved.session,
+    resolvedChannelId: resolved.resolvedChannelId,
+    fallback: binding
+  });
+  return payload;
+}
+
+async function persistStudioSupremeIntentAssessment(projectPath, options = {}, assessment = {}, extra = {}, dependencies = {}) {
+  const binding = buildStudioProjectChannelBinding(projectPath, options, extra.job || {});
+  return recordSupremeIntentAssessment({
+    ...assessment,
+    project_id: extra.project_id || (binding ? binding.project_id : null),
+    channel_id: extra.channel_id || (binding ? binding.channel_id : null),
+    session_id: extra.session_id || null,
+    scene_id: extra.scene_id || assessment.scene_id || null,
+    spec_id: extra.spec_id || assessment.spec_id || null,
+    job_id: extra.job_id || null,
+    source_kind: extra.source_kind || assessment.source_kind || 'studio',
+    evidence_path: extra.evidence_path || null,
+    metadata: {
+      channel_binding: binding || null,
+      ...(extra.metadata && typeof extra.metadata === 'object' ? extra.metadata : {})
+    }
+  }, {
+    projectPath,
+    fileSystem: dependencies.fileSystem,
+    env: dependencies.env,
+    sqliteModule: dependencies.sqliteModule,
+    stateStore: dependencies.stateStore,
+    noCache: dependencies.noCache === true
+  });
 }
 
 
@@ -1586,18 +1772,47 @@ async function runStudioPlanCommand(options = {}, dependencies = {}) {
   const projectPath = dependencies.projectPath || process.cwd();
   const fileSystem = dependencies.fileSystem || fs;
   const fromChat = normalizeString(options.fromChat);
-  const sceneId = normalizeString(options.scene);
-  const specId = normalizeString(options.spec);
+  const explicitSceneId = normalizeString(options.scene);
+  const explicitSpecId = normalizeString(options.spec);
   const goal = normalizeString(options.goal);
   const manualSpecMode = options.manualSpec === true;
   const skipSpecGovernance = options.specGovernance === false;
+  const channelFocus = await resolveStudioProjectChannelFocus(projectPath, options, dependencies);
+  const sceneId = explicitSceneId || normalizeString(channelFocus && channelFocus.active_scene);
+  const channelFocusedSpecId = normalizeString(channelFocus && channelFocus.active_spec_id);
+  const boundSpecId = explicitSpecId
+    || (channelFocusedSpecId && await fileSystem.pathExists(path.join(projectPath, '.sce', 'specs', channelFocusedSpecId))
+      ? channelFocusedSpecId
+      : '');
 
   if (!fromChat) {
     throw new Error('--from-chat is required');
   }
   if (!sceneId) {
-    throw new Error('--scene is required');
+    throw new Error('--scene is required unless project/channel context can resolve an active scene');
+  }
+
+  const supremeAssessment = await assessSupremeIntent({
+    text: goal,
+    source_kind: 'studio-plan',
+    scene_id: sceneId,
+    spec_id: boundSpecId || null
+  }, {
+    projectPath,
+    fileSystem
+  });
+  if (!supremeAssessment.planning_allowed) {
+    await persistStudioSupremeIntentAssessment(projectPath, options, supremeAssessment, {
+      scene_id: sceneId,
+      spec_id: boundSpecId || null,
+      source_kind: 'studio-plan',
+      metadata: {
+        refusal_stage: 'pre-plan'
+      }
+    }, dependencies);
+    throw buildSupremeRefusalError(supremeAssessment);
   }
+  const governedGoal = normalizeString(supremeAssessment.effective_text) || goal;
 
   const intakePolicyBundle = await loadStudioIntakePolicy(projectPath, fileSystem);
   const intakePolicy = intakePolicyBundle.policy || {};
@@ -1615,18 +1830,18 @@ async function runStudioPlanCommand(options = {}, dependencies = {}) {
 
   let domainChainBinding = await resolveDomainChainBinding({
     sceneId,
-    specId,
-    goal
+    specId: boundSpecId,
+    goal: governedGoal
   }, {
     projectPath,
     fileSystem
   });
 
   let relatedSpecLookup = await findRelatedSpecs({
-    query: goal,
+    query: governedGoal,
     sceneId,
     limit: 8,
-    excludeSpecId: domainChainBinding.spec_id || specId || null
+    excludeSpecId: domainChainBinding.spec_id || boundSpecId || null
   }, {
     projectPath,
     fileSystem
@@ -1635,25 +1850,29 @@ async function runStudioPlanCommand(options = {}, dependencies = {}) {
   const intake = await runStudioAutoIntake({
     scene_id: sceneId,
     from_chat: fromChat,
-    goal,
-    explicit_spec_id: specId,
+    goal: governedGoal,
+    explicit_spec_id: explicitSpecId,
     domain_chain_binding: domainChainBinding,
     related_specs: relatedSpecLookup,
+    supreme_principles: supremeAssessment,
     apply: !manualSpecMode,
     skip: manualSpecMode
   }, {
     projectPath,
     fileSystem
   });
+  if (intake && intake.decision && intake.decision.action === 'refuse') {
+    throw buildSupremeRefusalError(supremeAssessment);
+  }
 
   const intakeSpecId = normalizeString(intake && intake.selected_spec_id);
-  const effectiveSpecId = intakeSpecId || normalizeString(domainChainBinding.spec_id) || specId || null;
+  const effectiveSpecId = intakeSpecId || normalizeString(domainChainBinding.spec_id) || boundSpecId || null;
 
   if (effectiveSpecId && effectiveSpecId !== normalizeString(domainChainBinding.spec_id)) {
     domainChainBinding = await resolveDomainChainBinding({
       sceneId,
       specId: effectiveSpecId,
-      goal
+      goal: governedGoal
     }, {
       projectPath,
       fileSystem
@@ -1661,7 +1880,7 @@ async function runStudioPlanCommand(options = {}, dependencies = {}) {
   }
 
   relatedSpecLookup = await findRelatedSpecs({
-    query: goal,
+    query: governedGoal,
     sceneId,
     limit: 8,
     excludeSpecId: effectiveSpecId || null
@@ -1686,11 +1905,20 @@ async function runStudioPlanCommand(options = {}, dependencies = {}) {
 
   const jobId = normalizeString(options.job) || createJobId();
   const now = nowIso();
+  const supremeEvidence = effectiveSpecId
+    ? await writeSupremeIntentEvidence(projectPath, effectiveSpecId, {
+      ...supremeAssessment,
+      source_kind: 'studio-plan',
+      spec_id: effectiveSpecId
+    }, {
+      fileSystem
+    })
+    : null;
   const problemContract = normalizeProblemContract(
     domainChainBinding.problem_contract || {},
     {
       scene_id: sceneId,
-      goal,
+      goal: governedGoal,
       problem_statement: normalizeString(domainChainBinding?.summary?.problem_statement),
       verification_plan: normalizeString(domainChainBinding?.summary?.verification_plan)
     }
@@ -1702,8 +1930,18 @@ async function runStudioPlanCommand(options = {}, dependencies = {}) {
       spec_id: effectiveSpecId
     },
     source: {
-      goal: goal || null,
+      goal: governedGoal || null,
+      goal_original: goal || null,
+      supreme_principles: supremeAssessment,
+      supreme_intent_evidence: supremeEvidence ? supremeEvidence.relative_path : null,
       spec_id: effectiveSpecId,
+      scene_source: explicitSceneId ? 'explicit-scene' : 'project-channel-focus',
+      bound_channel_focus: channelFocus ? {
+        project_id: channelFocus.project_id,
+        channel_id: channelFocus.channel_id,
+        active_scene: channelFocus.active_scene || null,
+        active_spec_id: channelFocus.active_spec_id || null
+      } : null,
       problem_contract: problemContract,
       problem_contract_path: domainChainBinding.problem_contract_path || null,
       domain_chain: {
@@ -1719,7 +1957,7 @@ async function runStudioPlanCommand(options = {}, dependencies = {}) {
   const planProblemEvaluation = await enforceProblemEvaluationForStage(planShadowJob, 'plan', {
     scene_id: sceneId,
     spec_id: effectiveSpecId,
-    goal: goal || null,
+    goal: governedGoal || null,
     problem_contract: problemContract,
     domain_chain: {
       resolved: domainChainBinding.resolved === true,
@@ -1747,9 +1985,24 @@ async function runStudioPlanCommand(options = {}, dependencies = {}) {
   const sessionStore = dependencies.sessionStore || new SessionStore(projectPath);
   const sceneSessionBinding = await sessionStore.beginSceneSession({
     sceneId,
-    objective: goal || `Studio scene cycle for ${sceneId}`,
+    objective: governedGoal || `Studio scene cycle for ${sceneId}`,
     tool: normalizeString(options.tool) || 'generic'
   });
+  const supremeLedgerEntry = await persistStudioSupremeIntentAssessment(projectPath, options, supremeAssessment, {
+    session_id: sceneSessionBinding.session.session_id,
+    scene_id: sceneId,
+    spec_id: effectiveSpecId,
+    job_id: jobId,
+    source_kind: 'studio-plan',
+    evidence_path: supremeEvidence ? supremeEvidence.relative_path : null,
+    metadata: {
+      original_goal: goal || null,
+      effective_goal: governedGoal || null,
+      scene_cycle: sceneSessionBinding.scene_cycle,
+      intake_action: intake && intake.decision ? intake.decision.action : null,
+      related_specs_total: Number(relatedSpecLookup.total_candidates || 0)
+    }
+  }, dependencies);
 
   let governanceSnapshot = null;
   let governanceWarning = '';
@@ -1776,6 +2029,7 @@ async function runStudioPlanCommand(options = {}, dependencies = {}) {
       from_chat: fromChat,
       scene_id: sceneId,
       spec_id: effectiveSpecId,
+      scene_source: explicitSceneId ? 'explicit-scene' : 'project-channel-focus',
       scene_session_id: sceneSessionBinding.session.session_id,
       scene_cycle: sceneSessionBinding.scene_cycle,
       domain_chain_resolved: domainChainBinding.resolved === true,
@@ -1792,8 +2046,12 @@ async function runStudioPlanCommand(options = {}, dependencies = {}) {
         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
+        policy_path: intake.policy_path || null,
+        supreme_action: supremeAssessment.action,
+        effective_goal: governedGoal || null
       } : null,
+      supreme_principles: supremeAssessment,
+      supreme_intent_evidence: supremeEvidence ? supremeEvidence.relative_path : null,
       problem_evaluation: summarizeProblemEvaluation(planProblemEvaluation),
       spec_governance: governanceSnapshot ? governanceSnapshot.summary : null,
       spec_governance_warning: governanceWarning || null,
@@ -1810,7 +2068,11 @@ async function runStudioPlanCommand(options = {}, dependencies = {}) {
     status: 'planned',
     source: {
       from_chat: fromChat,
-      goal: goal || null,
+      goal: governedGoal || null,
+      goal_original: goal || null,
+      goal_effective: governedGoal || null,
+      supreme_principles: supremeAssessment,
+      supreme_intent_evidence: supremeEvidence ? supremeEvidence.relative_path : null,
       spec_id: effectiveSpecId,
       problem_contract: problemContract,
       problem_contract_path: domainChainBinding.problem_contract_path || null,
@@ -1821,7 +2083,9 @@ async function runStudioPlanCommand(options = {}, dependencies = {}) {
         intent: intake.intent || null,
         decision: intake.decision || null,
         selected_spec_id: intake.selected_spec_id || effectiveSpecId || null,
-        created_spec: intake.created_spec || null
+        created_spec: intake.created_spec || null,
+        supreme_action: supremeAssessment.action,
+        effective_goal: governedGoal || null
       } : null,
       domain_chain: {
         resolved: domainChainBinding.resolved === true,
@@ -1883,11 +2147,19 @@ async function runStudioPlanCommand(options = {}, dependencies = {}) {
     }
   };
 
+  await syncStudioProjectChannel(job, 'requirements', options, {
+    projectPath,
+    fileSystem,
+    sessionStore
+  });
+
   await saveJob(paths, job, fileSystem);
   const planEvent = await appendStudioEvent(paths, job, 'stage.plan.completed', {
     from_chat: fromChat,
     scene_id: sceneId,
     spec_id: effectiveSpecId,
+    original_goal: goal || null,
+    effective_goal: governedGoal || null,
     scene_session_id: sceneSessionBinding.session.session_id,
     scene_cycle: sceneSessionBinding.scene_cycle,
     target: job.target,
@@ -1902,6 +2174,8 @@ async function runStudioPlanCommand(options = {}, dependencies = {}) {
     intake_created_spec_id: intake && intake.created_spec && intake.created_spec.created
       ? intake.created_spec.spec_id
       : null,
+    supreme_principles: supremeAssessment,
+    supreme_intent_evidence: supremeEvidence ? supremeEvidence.relative_path : null,
     problem_evaluation: summarizeProblemEvaluation(planProblemEvaluation),
     spec_governance: governanceSnapshot ? governanceSnapshot.summary : null,
     spec_governance_warning: governanceWarning || null,
@@ -1916,11 +2190,18 @@ async function runStudioPlanCommand(options = {}, dependencies = {}) {
     projectPath,
     fileSystem
   });
+  await attachStudioProjectChannelPayload(payload, job, {
+    projectPath,
+    fileSystem,
+    sessionStore
+  });
   payload.scene = {
     id: sceneId,
     spec_id: effectiveSpecId
   };
   payload.intake = job.source && job.source.intake ? job.source.intake : null;
+  payload.supreme_principles = supremeAssessment;
+  payload.supreme_intent_record = supremeLedgerEntry || null;
   payload.spec_governance = governanceSnapshot ? governanceSnapshot.summary : null;
   printStudioPayload(payload, options);
   return payload;
@@ -2029,6 +2310,12 @@ async function runStudioGenerateCommand(options = {}, dependencies = {}) {
     report: generateReportPath
   });
 
+  await syncStudioProjectChannel(job, 'design', options, {
+    projectPath,
+    fileSystem,
+    sessionStore: dependencies.sessionStore
+  });
+
   await saveJob(paths, job, fileSystem);
   const generateEvent = await appendStudioEvent(paths, job, 'stage.generate.completed', {
     scene_id: sceneId,
@@ -2046,6 +2333,10 @@ async function runStudioGenerateCommand(options = {}, dependencies = {}) {
     projectPath,
     fileSystem
   });
+  await attachStudioProjectChannelPayload(payload, job, {
+    projectPath,
+    fileSystem
+  });
   printStudioPayload(payload, options);
   return payload;
 }
@@ -2114,6 +2405,12 @@ async function runStudioApplyCommand(options = {}, dependencies = {}) {
     problem_evaluation: summarizeProblemEvaluation(applyProblemEvaluation)
   });
 
+  await syncStudioProjectChannel(job, 'tasks', options, {
+    projectPath,
+    fileSystem,
+    sessionStore: dependencies.sessionStore
+  });
+
   await saveJob(paths, job, fileSystem);
   const applyEvent = await appendStudioEvent(paths, job, 'stage.apply.completed', {
     patch_bundle_id: patchBundleId,
@@ -2132,6 +2429,10 @@ async function runStudioApplyCommand(options = {}, dependencies = {}) {
     projectPath,
     fileSystem
   });
+  await attachStudioProjectChannelPayload(payload, job, {
+    projectPath,
+    fileSystem
+  });
   printStudioPayload(payload, options);
   return payload;
 }
@@ -2267,6 +2568,12 @@ async function runStudioVerifyCommand(options = {}, dependencies = {}) {
     auto_errorbook_records: autoErrorbookRecords
   });
 
+  await syncStudioProjectChannel(job, 'verify', options, {
+    projectPath,
+    fileSystem,
+    sessionStore: dependencies.sessionStore
+  });
+
   await saveJob(paths, job, fileSystem);
   const verifyEvent = await appendStudioEvent(paths, job, 'stage.verify.completed', {
     profile,
@@ -2284,6 +2591,10 @@ async function runStudioVerifyCommand(options = {}, dependencies = {}) {
     projectPath,
     fileSystem
   });
+  await attachStudioProjectChannelPayload(payload, job, {
+    projectPath,
+    fileSystem
+  });
   printStudioPayload(payload, options);
   return payload;
 }
@@ -2493,6 +2804,11 @@ async function runStudioReleaseCommand(options = {}, dependencies = {}) {
       scene_cycle: rollover.next_scene_cycle || null,
       rolled_over_at: nowIso()
     };
+    await syncStudioProjectChannel(job, 'requirements', options, {
+      projectPath,
+      fileSystem,
+      sessionStore
+    });
   }
 
   await saveJob(paths, job, fileSystem);
@@ -2517,6 +2833,10 @@ async function runStudioReleaseCommand(options = {}, dependencies = {}) {
     projectPath,
     fileSystem
   });
+  await attachStudioProjectChannelPayload(payload, job, {
+    projectPath,
+    fileSystem
+  });
   printStudioPayload(payload, options);
   return payload;
 }
@@ -2540,6 +2860,10 @@ async function runStudioResumeCommand(options = {}, dependencies = {}) {
     projectPath,
     fileSystem
   });
+  await attachStudioProjectChannelPayload(payload, job, {
+    projectPath,
+    fileSystem
+  });
   payload.success = true;
   printStudioPayload(payload, options);
   return payload;
@@ -2612,6 +2936,10 @@ async function runStudioRollbackCommand(options = {}, dependencies = {}) {
     projectPath,
     fileSystem
   });
+  await attachStudioProjectChannelPayload(payload, job, {
+    projectPath,
+    fileSystem
+  });
   payload.rollback = { ...job.rollback };
   printStudioPayload(payload, options);
   return payload;
@@ -2684,32 +3012,50 @@ function printStudioIntakePayload(payload, options = {}) {
 async function runStudioIntakeCommand(options = {}, dependencies = {}) {
   const projectPath = dependencies.projectPath || process.cwd();
   const fileSystem = dependencies.fileSystem || fs;
-  const sceneId = normalizeString(options.scene);
+  const explicitSceneId = normalizeString(options.scene);
   const fromChat = normalizeString(options.fromChat);
   const goal = normalizeString(options.goal);
-  const specId = normalizeString(options.spec);
+  const explicitSpecId = normalizeString(options.spec);
+  const channelFocus = await resolveStudioProjectChannelFocus(projectPath, options, dependencies);
+  const sceneId = explicitSceneId || normalizeString(channelFocus && channelFocus.active_scene);
+  const channelFocusedSpecId = normalizeString(channelFocus && channelFocus.active_spec_id);
+  const boundSpecId = explicitSpecId
+    || (channelFocusedSpecId && await fileSystem.pathExists(path.join(projectPath, '.sce', 'specs', channelFocusedSpecId))
+      ? channelFocusedSpecId
+      : '');
 
   if (!sceneId) {
-    throw new Error('--scene is required');
+    throw new Error('--scene is required unless project/channel context can resolve an active scene');
   }
   if (!fromChat) {
     throw new Error('--from-chat is required');
   }
 
+  const supremeAssessment = await assessSupremeIntent({
+    text: goal,
+    source_kind: 'studio-intake',
+    scene_id: sceneId,
+    spec_id: boundSpecId || null
+  }, {
+    projectPath,
+    fileSystem
+  });
+  const governedGoal = normalizeString(supremeAssessment.effective_text) || goal;
+
   const domainChainBinding = await resolveDomainChainBinding({
     sceneId,
-    specId,
-    goal
+    specId: boundSpecId,
+    goal: governedGoal
   }, {
     projectPath,
     fileSystem
   });
 
   const relatedSpecLookup = await findRelatedSpecs({
-    query: goal,
+    query: governedGoal,
     sceneId,
     limit: 8,
-    excludeSpecId: domainChainBinding.spec_id || specId || null
+    excludeSpecId: domainChainBinding.spec_id || boundSpecId || null
   }, {
     projectPath,
     fileSystem
@@ -2718,19 +3064,46 @@ async function runStudioIntakeCommand(options = {}, dependencies = {}) {
   const intake = await runStudioAutoIntake({
     scene_id: sceneId,
     from_chat: fromChat,
-    goal,
-    explicit_spec_id: specId,
+    goal: governedGoal,
+    explicit_spec_id: explicitSpecId,
     domain_chain_binding: domainChainBinding,
     related_specs: relatedSpecLookup,
+    supreme_principles: supremeAssessment,
     apply: options.apply === true,
     skip: options.manualSpec === true
   }, {
     projectPath,
     fileSystem
   });
+  const supremeEvidence = intake && intake.selected_spec_id
+    ? await writeSupremeIntentEvidence(projectPath, intake.selected_spec_id, {
+      ...supremeAssessment,
+      source_kind: 'studio-intake',
+      spec_id: intake.selected_spec_id
+    }, {
+      fileSystem
+    })
+    : null;
+  const supremeLedgerEntry = await persistStudioSupremeIntentAssessment(projectPath, options, supremeAssessment, {
+    scene_id: sceneId,
+    spec_id: intake && intake.selected_spec_id ? intake.selected_spec_id : (boundSpecId || null),
+    source_kind: 'studio-intake',
+    evidence_path: supremeEvidence ? supremeEvidence.relative_path : null,
+    metadata: {
+      original_goal: goal || null,
+      effective_goal: governedGoal || null,
+      intake_action: intake && intake.decision ? intake.decision.action : null,
+      intake_reason: intake && intake.decision ? intake.decision.reason : null,
+      related_specs_total: Number(relatedSpecLookup.total_candidates || 0)
+    }
+  }, dependencies);
 
   const payload = {
     ...intake,
+    original_goal: goal || null,
+    supreme_principles: supremeAssessment,
+    supreme_intent_record: supremeLedgerEntry || null,
+    supreme_intent_evidence: supremeEvidence ? supremeEvidence.relative_path : null,
     domain_chain_source: domainChainBinding.source || 'none',
     domain_chain_spec_id: domainChainBinding.spec_id || null,
     related_specs_total: Number(relatedSpecLookup.total_candidates || 0)
@@ -2852,8 +3225,10 @@ function registerStudioCommands(program) {
   studio
     .command('plan')
     .description('Create/refresh a studio plan job from chat context')
-    .requiredOption('--scene <scene-id>', 'Scene identifier (mandatory primary session anchor)')
+    .option('--scene <scene-id>', 'Scene identifier (defaults to current project/channel focus when resolvable)')
     .requiredOption('--from-chat <session>', 'Chat session identifier or transcript reference')
+    .option('--project-id <project-id>', 'Explicit project id for project + channel/session binding')
+    .option('--collab-channel <channel-id>', 'Explicit collaboration channel id (defaults to --from-chat)')
     .option('--spec <spec-id>', 'Optional spec binding for domain-chain context ingestion')
     .option('--goal <goal>', 'Optional goal summary')
     .option('--manual-spec', 'Legacy bypass flag (disabled by default policy)')
@@ -2866,7 +3241,7 @@ function registerStudioCommands(program) {
   studio
     .command('intake')
     .description('Analyze chat goal and auto-resolve spec binding/create decision')
-    .requiredOption('--scene <scene-id>', 'Scene identifier')
+    .option('--scene <scene-id>', 'Scene identifier (defaults to current project/channel focus when resolvable)')
     .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')