@ryuenn3123/agentic-senior-core 3.0.19 → 3.0.21

package/lib/cli/detector/design-evidence.mjs

@@ -25,7 +25,10 @@ const TRANSITION_PATTERN = /\btransition(?:-[a-z]+)?\b/g;
 const ANIMATION_PATTERN = /\banimation(?:-[a-z]+)?\b/g;
 const DURATION_PATTERN = /\b\d+(?:\.\d+)?m?s\b/g;
 const MEDIA_WIDTH_PATTERN = /\((?:min|max)-width:\s*([0-9.]+(?:px|rem|em))\)/g;
-const TAILWIND_UTILITY_PATTERN = /\b([a-z]+(?:-[a-z]+)?)-[^\s"'`{}()<>]+/g;
+const STRING_CLASS_ATTRIBUTE_PATTERN = /\b(?:className|class)\s*=\s*(?:"([^"]*)"|'([^']*)'|\{`([^`]*)`\}|\{"([^"]*)"\}|\{'([^']*)'\})/g;
+const EXPRESSION_CLASS_ATTRIBUTE_PATTERN = /\b(?:className|class|:class)\s*=\s*\{([^}\n]+)\}/g;
+const JSX_INLINE_STYLE_PATTERN = /\bstyle\s*=\s*\{\{([\s\S]*?)\}\}/g;
+const VUE_INLINE_STYLE_PATTERN = /\b:style\s*=\s*["']\{([^"']*)\}["']/g;
 
 async function collectFrontendSourceFilePaths(directoryPath, collectedFilePaths = []) {
   if (collectedFilePaths.length >= FRONTEND_FILE_SCAN_LIMIT) {
@@ -132,6 +135,137 @@ function incrementCountMap(countMap, key) {
   countMap[key] = (countMap[key] || 0) + 1;
 }
 
+function getFirstDefinedCapture(matchGroups) {
+  for (const capturedValue of matchGroups) {
+    if (typeof capturedValue === 'string' && capturedValue.trim().length > 0) {
+      return capturedValue;
+    }
+  }
+
+  return '';
+}
+
+function normalizeEvidenceSample(rawValue) {
+  return String(rawValue || '').replace(/\s+/g, ' ').trim();
+}
+
+function inferUtilityFamily(rawUtilityToken) {
+  const normalizedUtilityToken = String(rawUtilityToken || '')
+    .trim()
+    .split(':')
+    .pop()
+    ?.replace(/^!/, '')
+    ?.replace(/\/.+$/, '')
+    ?.trim();
+
+  if (!normalizedUtilityToken) {
+    return '';
+  }
+
+  if (/^grid(?:-|$)/.test(normalizedUtilityToken)) {
+    return 'grid';
+  }
+
+  if (/^flex(?:-|$)/.test(normalizedUtilityToken)) {
+    return 'flex';
+  }
+
+  if (/^(?:block|inline|hidden|contents)$/.test(normalizedUtilityToken)) {
+    return normalizedUtilityToken;
+  }
+
+  if (/^(?:min|max)-\[/.test(normalizedUtilityToken)) {
+    return 'arbitrary-breakpoint';
+  }
+
+  return normalizedUtilityToken.split('-')[0];
+}
+
+function collectTailwindUtilityFamilies(classValue, utilityFamilyCounts, utilityFamilySamples, utilityFamilySampleSet) {
+  for (const utilityToken of String(classValue || '').split(/\s+/g)) {
+    const utilityFamily = inferUtilityFamily(utilityToken);
+    if (!utilityFamily) {
+      continue;
+    }
+
+    incrementCountMap(utilityFamilyCounts, utilityFamily);
+    pushSampleValue(utilityFamilySamples, utilityFamily, utilityFamilySampleSet);
+  }
+}
+
+function applyInlineStyleInspection(styleSourceText, summary, styleSampleSet) {
+  const normalizedStyleSource = normalizeEvidenceSample(styleSourceText);
+  pushSampleValue(summary.structuredInspection.inlineStyleSamples, normalizedStyleSource, styleSampleSet);
+
+  const hardcodedColorCount = countPatternMatches(styleSourceText, COLOR_PATTERN);
+  const rawSpacingCount = countPatternMatches(styleSourceText, RAW_SPACING_PATTERN);
+  const rawRadiusCount = countPatternMatches(styleSourceText, RAW_RADIUS_PATTERN);
+  const rawShadowCount = countPatternMatches(styleSourceText, RAW_SHADOW_PATTERN);
+  const cssVariableReferenceCount = countPatternMatches(styleSourceText, CSS_VARIABLE_REFERENCE_PATTERN);
+
+  summary.structuredInspection.inlineTokenBypassSignals.hardcodedColorCount += hardcodedColorCount;
+  summary.structuredInspection.inlineTokenBypassSignals.rawSpacingCount += rawSpacingCount;
+  summary.structuredInspection.inlineTokenBypassSignals.rawRadiusCount += rawRadiusCount;
+  summary.structuredInspection.inlineTokenBypassSignals.rawShadowCount += rawShadowCount;
+  summary.structuredInspection.inlineTokenBypassSignals.cssVariableReferenceCount += cssVariableReferenceCount;
+}
+
+function collectStructuredAttributeEvidence(sourceText, summary, classSampleSet, styleSampleSet, utilityFamilySampleSet) {
+  for (const classAttributeMatch of sourceText.matchAll(STRING_CLASS_ATTRIBUTE_PATTERN)) {
+    const classValue = getFirstDefinedCapture(classAttributeMatch.slice(1));
+    if (!classValue) {
+      continue;
+    }
+
+    summary.structuredInspection.classAttributeCount += 1;
+    pushSampleValue(
+      summary.structuredInspection.classAttributeSamples,
+      normalizeEvidenceSample(classValue),
+      classSampleSet
+    );
+    collectTailwindUtilityFamilies(
+      classValue,
+      summary.structuredInspection.utilityFamilyCounts,
+      summary.structuredInspection.utilityFamilySamples,
+      utilityFamilySampleSet
+    );
+  }
+
+  for (const expressionClassAttributeMatch of sourceText.matchAll(EXPRESSION_CLASS_ATTRIBUTE_PATTERN)) {
+    const expressionValue = getFirstDefinedCapture(expressionClassAttributeMatch.slice(1));
+    if (!expressionValue) {
+      continue;
+    }
+
+    summary.structuredInspection.boundClassExpressionCount += 1;
+    pushSampleValue(
+      summary.structuredInspection.classAttributeSamples,
+      normalizeEvidenceSample(expressionValue),
+      classSampleSet
+    );
+  }
+
+  for (const inlineStyleMatch of sourceText.matchAll(JSX_INLINE_STYLE_PATTERN)) {
+    const inlineStyleSource = getFirstDefinedCapture(inlineStyleMatch.slice(1));
+    if (!inlineStyleSource) {
+      continue;
+    }
+
+    summary.structuredInspection.inlineStyleObjectCount += 1;
+    applyInlineStyleInspection(inlineStyleSource, summary, styleSampleSet);
+  }
+
+  for (const vueInlineStyleMatch of sourceText.matchAll(VUE_INLINE_STYLE_PATTERN)) {
+    const inlineStyleSource = getFirstDefinedCapture(vueInlineStyleMatch.slice(1));
+    if (!inlineStyleSource) {
+      continue;
+    }
+
+    summary.structuredInspection.inlineStyleBindingCount += 1;
+    applyInlineStyleInspection(inlineStyleSource, summary, styleSampleSet);
+  }
+}
+
 function createDesignEvidenceSummary(scanRootRelativePaths) {
   return {
     summaryVersion: 'v1',
@@ -203,11 +337,34 @@ function createDesignEvidenceSummary(scanRootRelativePaths) {
       layoutFileCount: 0,
       surfaceFileSamples: [],
     },
+    structuredInspection: {
+      mode: 'attribute-aware-static-scan',
+      classAttributeCount: 0,
+      boundClassExpressionCount: 0,
+      inlineStyleObjectCount: 0,
+      inlineStyleBindingCount: 0,
+      classAttributeSamples: [],
+      inlineStyleSamples: [],
+      utilityFamilyCounts: {},
+      utilityFamilySamples: [],
+      inlineTokenBypassSignals: {
+        hardcodedColorCount: 0,
+        rawSpacingCount: 0,
+        rawRadiusCount: 0,
+        rawShadowCount: 0,
+        cssVariableReferenceCount: 0,
+      },
+    },
     tokenBypassSignals: {
       hardcodedColorCount: 0,
       rawSpacingCount: 0,
       rawRadiusCount: 0,
       rawShadowCount: 0,
+      inlineHardcodedColorCount: 0,
+      inlineRawSpacingCount: 0,
+      inlineRawRadiusCount: 0,
+      inlineRawShadowCount: 0,
+      inlineCssVariableReferenceCount: 0,
     },
   };
 }
@@ -282,6 +439,9 @@ export async function collectFrontendDesignEvidence({
   const letterSpacingSamples = new Set();
   const durationSamples = new Set();
   const utilityFamilySamples = new Set();
+  const structuredClassAttributeSamples = new Set();
+  const structuredInlineStyleSamples = new Set();
+  const structuredUtilityFamilySamples = new Set();
   const seenSurfaceFiles = new Set();
   let hardcodedColorCount = 0;
   let propDrillingCandidateCount = 0;
@@ -314,6 +474,13 @@ export async function collectFrontendDesignEvidence({
     }
 
     registerSurfaceFile(designEvidenceSummary, targetDirectoryPath, scannedFilePath, seenSurfaceFiles);
+    collectStructuredAttributeEvidence(
+      sourceText,
+      designEvidenceSummary,
+      structuredClassAttributeSamples,
+      structuredInlineStyleSamples,
+      structuredUtilityFamilySamples
+    );
 
     for (const cssVariableMatch of sourceText.matchAll(CSS_VARIABLE_DEFINITION_PATTERN)) {
       designEvidenceSummary.cssVariables.definitionCount += 1;
@@ -398,18 +565,25 @@ export async function collectFrontendDesignEvidence({
       uniqueMediaWidths.add(mediaWidthMatch[1]);
     }
 
-    for (const utilityMatch of sourceText.matchAll(TAILWIND_UTILITY_PATTERN)) {
-      const utilityFamily = utilityMatch[1];
-      incrementCountMap(designEvidenceSummary.tailwind.utilityFamilyCounts, utilityFamily);
-      pushSampleValue(designEvidenceSummary.tailwind.utilityFamilySamples, utilityFamily, utilityFamilySamples);
-    }
   }
 
+  designEvidenceSummary.tailwind.utilityFamilyCounts = {
+    ...designEvidenceSummary.structuredInspection.utilityFamilyCounts,
+  };
+  designEvidenceSummary.tailwind.utilityFamilySamples = [
+    ...designEvidenceSummary.structuredInspection.utilityFamilySamples,
+  ];
+
   designEvidenceSummary.tokenBypassSignals = {
     hardcodedColorCount: designEvidenceSummary.colors.hardcodedCount,
     rawSpacingCount: designEvidenceSummary.spacing.rawValueCount,
     rawRadiusCount: designEvidenceSummary.radius.rawValueCount,
     rawShadowCount: designEvidenceSummary.shadow.rawValueCount,
+    inlineHardcodedColorCount: designEvidenceSummary.structuredInspection.inlineTokenBypassSignals.hardcodedColorCount,
+    inlineRawSpacingCount: designEvidenceSummary.structuredInspection.inlineTokenBypassSignals.rawSpacingCount,
+    inlineRawRadiusCount: designEvidenceSummary.structuredInspection.inlineTokenBypassSignals.rawRadiusCount,
+    inlineRawShadowCount: designEvidenceSummary.structuredInspection.inlineTokenBypassSignals.rawShadowCount,
+    inlineCssVariableReferenceCount: designEvidenceSummary.structuredInspection.inlineTokenBypassSignals.cssVariableReferenceCount,
   };
 
   return {
@@ -421,6 +595,15 @@ export async function collectFrontendDesignEvidence({
       tailwindBreakpointUsageCount,
       arbitraryBreakpointCount,
       uniqueMediaWidthCount: uniqueMediaWidths.size,
+      structuredClassAttributeCount: designEvidenceSummary.structuredInspection.classAttributeCount,
+      boundClassExpressionCount: designEvidenceSummary.structuredInspection.boundClassExpressionCount,
+      inlineStyleObjectCount: designEvidenceSummary.structuredInspection.inlineStyleObjectCount,
+      inlineStyleBindingCount: designEvidenceSummary.structuredInspection.inlineStyleBindingCount,
+      inlineStyleTokenBypassCount:
+        designEvidenceSummary.structuredInspection.inlineTokenBypassSignals.hardcodedColorCount
+        + designEvidenceSummary.structuredInspection.inlineTokenBypassSignals.rawSpacingCount
+        + designEvidenceSummary.structuredInspection.inlineTokenBypassSignals.rawRadiusCount
+        + designEvidenceSummary.structuredInspection.inlineTokenBypassSignals.rawShadowCount,
     },
     designEvidenceSummary,
   };

package/lib/cli/detector.mjs

@@ -5,7 +5,6 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 
-import { BLUEPRINT_RECOMMENDATIONS } from './constants.mjs';
 import {
   collectFrontendDesignEvidence,
   FRONTEND_SCAN_IGNORE_DIRECTORY_NAMES,
@@ -600,9 +599,9 @@ export async function detectProjectContext(targetDirectoryPath) {
   if (detectionCandidates.length === 0) {
     return {
       hasExistingProjectFiles,
-      recommendedStackFileName: null,
+      detectedStackFileName: null,
       secondaryStackFileNames: [],
-      recommendedBlueprintFileName: null,
+      detectedBlueprintFileName: null,
       confidenceLabel: null,
       confidenceScore: 0,
       confidenceGap: 0,
@@ -643,9 +642,9 @@ export async function detectProjectContext(targetDirectoryPath) {
 
   return {
     hasExistingProjectFiles,
-    recommendedStackFileName: strongestCandidate.stackFileName,
+    detectedStackFileName: strongestCandidate.stackFileName,
     secondaryStackFileNames,
-    recommendedBlueprintFileName: BLUEPRINT_RECOMMENDATIONS[strongestCandidate.stackFileName] || null,
+    detectedBlueprintFileName: null,
     confidenceLabel,
     confidenceScore: strongestCandidate.confidenceScore,
     confidenceGap,
@@ -656,7 +655,7 @@ export async function detectProjectContext(targetDirectoryPath) {
 }
 
 export function buildDetectionSummary(projectDetection) {
-  if (!projectDetection.recommendedStackFileName) {
+  if (!projectDetection.detectedStackFileName) {
     return 'I did not find enough stack markers to auto-detect this project confidently.';
   }
 
@@ -672,7 +671,7 @@ export function buildDetectionSummary(projectDetection) {
     ? ` Secondary stack signals: ${projectDetection.secondaryStackFileNames.map((stackFileName) => toTitleCase(stackFileName)).join(', ')}.`
     : '';
 
-  return `This folder looks like ${toTitleCase(projectDetection.recommendedStackFileName)} with ${projectDetection.confidenceLabel} confidence based on ${readableEvidence}.${confidenceGapSummary}${secondaryStacksSummary}`;
+  return `This folder looks like ${toTitleCase(projectDetection.detectedStackFileName)} with ${projectDetection.confidenceLabel} confidence based on ${readableEvidence}.${confidenceGapSummary}${secondaryStacksSummary}`;
 }
 
 export function formatDetectionCandidates(rankedCandidates) {

package/lib/cli/init-detection-flow.mjs

@@ -1,35 +1,15 @@
-import {
-  BLUEPRINT_RECOMMENDATIONS,
-} from './constants.mjs';
-
-import {
-  filterBlueprintFileNamesByCandidates,
-  normalizeAdditionalStackSelection,
-} from './init-selection.mjs';
-
-import {
-  toTitleCase,
-} from './utils.mjs';
-
 export function buildExistingProjectMajorConstraints() {
   return [
     'Preserve existing project markers and avoid forced stack migration.',
-    'Keep stack rule loading lazy and scoped to touched code.',
-    'Explicit stack or blueprint overrides always win over auto-detection.',
+    'Use detected runtime markers as evidence only; do not convert them into stack migration or design direction.',
+    'Explicit stack or blueprint overrides are constraints only when the user provides them.',
   ];
 }
 
 export async function resolveDetectedSetupDecision({
   shouldAutoApplyDetectedStack,
   projectDetection,
-  stackFileNames,
-  blueprintFileNames,
-  userInterface,
-  isInteractiveSession,
   detectionTransparency,
-  askYesNo,
-  askStackSelection,
-  askBlueprintSelection,
   initialSelectedManualStackFileName,
   initialSelectedManualBlueprintFileName,
   initialSelectedAdditionalStackFileNames,
@@ -39,78 +19,16 @@ export async function resolveDetectedSetupDecision({
   let selectedAdditionalStackFileNames = initialSelectedAdditionalStackFileNames || [];
   let detectedSetupWasApplied = false;
 
-  const detectedBlueprintFileName = projectDetection.recommendedBlueprintFileName
-    || BLUEPRINT_RECOMMENDATIONS[projectDetection.recommendedStackFileName]
-    || null;
-
   if (shouldAutoApplyDetectedStack) {
-    if (isInteractiveSession) {
-      detectionTransparency.quickConfirmation.offered = true;
-      console.log('\nQuick confirmation for existing project detection:');
-      console.log(`- Suggested stack: ${toTitleCase(projectDetection.recommendedStackFileName)}`);
-      if (detectedBlueprintFileName) {
-        console.log(`- Suggested blueprint: ${toTitleCase(detectedBlueprintFileName)}`);
-      }
-
-      const shouldUseDetectedSetup = await askYesNo(
-        'Use detected setup for this existing project?',
-        userInterface,
-        true
-      );
-
-      if (shouldUseDetectedSetup) {
-        detectedSetupWasApplied = true;
-        detectionTransparency.quickConfirmation.response = 'confirmed-detected';
-        detectionTransparency.decision.mode = 'confirmed-detected';
-        console.log(`Using detected stack automatically for this existing project: ${toTitleCase(projectDetection.recommendedStackFileName)}.`);
-        if (projectDetection.secondaryStackFileNames?.length) {
-          console.log(`Detected additional stack signals: ${projectDetection.secondaryStackFileNames.map((stackFileName) => toTitleCase(stackFileName)).join(', ')}.`);
-        }
-        selectedAdditionalStackFileNames = projectDetection.secondaryStackFileNames || [];
-      } else {
-        const overrideStackFileName = await askStackSelection(
-          'Override detected stack (quick selection):',
-          stackFileNames,
-          userInterface
-        );
-        const overrideBlueprintCandidates = filterBlueprintFileNamesByCandidates(
-          blueprintFileNames,
-          [BLUEPRINT_RECOMMENDATIONS[overrideStackFileName]].filter(Boolean)
-        );
-        const overrideBlueprintFileName = await askBlueprintSelection(
-          'Override detected blueprint (quick selection):',
-          overrideBlueprintCandidates,
-          userInterface
-        );
-
-        selectedManualStackFileName = overrideStackFileName;
-        selectedManualBlueprintFileName = overrideBlueprintFileName;
-        selectedAdditionalStackFileNames = normalizeAdditionalStackSelection(
-          overrideStackFileName,
-          projectDetection.secondaryStackFileNames || []
-        );
-        detectionTransparency.quickConfirmation.response = 'overridden-detected';
-        detectionTransparency.decision.mode = 'overridden-detected';
-        console.log(
-          `Detection override applied: ${toTitleCase(overrideStackFileName)} + ${toTitleCase(overrideBlueprintFileName)}.`
-        );
-      }
-    } else {
-      detectedSetupWasApplied = true;
-      detectionTransparency.quickConfirmation.response = 'non-interactive-auto';
-      detectionTransparency.decision.mode = 'non-interactive-auto';
-      console.log(`Using detected stack automatically for this existing project: ${toTitleCase(projectDetection.recommendedStackFileName)}.`);
-      if (projectDetection.secondaryStackFileNames?.length) {
-        console.log(`Detected additional stack signals: ${projectDetection.secondaryStackFileNames.map((stackFileName) => toTitleCase(stackFileName)).join(', ')}.`);
-      }
-      selectedAdditionalStackFileNames = projectDetection.secondaryStackFileNames || [];
-    }
-  } else if (projectDetection.hasExistingProjectFiles && projectDetection.recommendedStackFileName) {
-    detectionTransparency.quickConfirmation.response = 'explicit-selection-or-low-confidence';
-    detectionTransparency.decision.mode = 'explicit-selection-or-low-confidence';
+    detectionTransparency.quickConfirmation.response = 'evidence-only';
+    detectionTransparency.decision.mode = 'existing-project-evidence-only';
+    selectedAdditionalStackFileNames = [];
+  } else if (projectDetection.hasExistingProjectFiles && projectDetection.detectedStackFileName) {
+    detectionTransparency.quickConfirmation.response = 'evidence-only';
+    detectionTransparency.decision.mode = 'existing-project-evidence-only';
   } else if (!projectDetection.hasExistingProjectFiles) {
     detectionTransparency.quickConfirmation.response = 'not-applicable';
-    detectionTransparency.decision.mode = 'fresh-directory';
+    detectionTransparency.decision.mode = 'fresh-agent-decision-required';
   }
 
   return {
@@ -118,6 +36,5 @@ export async function resolveDetectedSetupDecision({
     selectedManualStackFileName,
     selectedManualBlueprintFileName,
     selectedAdditionalStackFileNames,
-    detectedBlueprintFileName,
   };
-}
+}

package/lib/cli/init-selection.mjs

@@ -2,34 +2,9 @@
  * Init Selection Helpers — stack/blueprint filtering and scope normalization.
  */
 import {
-  BLUEPRINT_RECOMMENDATIONS,
   PROJECT_SCOPE_CHOICES,
-  PROJECT_SCOPE_STACK_FILTERS,
-  WEB_FRONTEND_BLUEPRINT_CANDIDATES,
-  WEB_BACKEND_BLUEPRINT_CANDIDATES,
 } from './constants.mjs';
 
-export function filterStackFileNamesByCandidates(allStackFileNames, preferredStackFileNames) {
-  if (!Array.isArray(preferredStackFileNames) || preferredStackFileNames.length === 0) {
-    return allStackFileNames;
-  }
-
-  const filteredStackFileNames = preferredStackFileNames.filter((stackFileName) => allStackFileNames.includes(stackFileName));
-  return filteredStackFileNames.length > 0 ? filteredStackFileNames : allStackFileNames;
-}
-
-export function filterBlueprintFileNamesByCandidates(allBlueprintFileNames, preferredBlueprintFileNames) {
-  if (!Array.isArray(preferredBlueprintFileNames) || preferredBlueprintFileNames.length === 0) {
-    return allBlueprintFileNames;
-  }
-
-  const filteredBlueprintFileNames = preferredBlueprintFileNames.filter(
-    (blueprintFileName) => allBlueprintFileNames.includes(blueprintFileName)
-  );
-
-  return filteredBlueprintFileNames.length > 0 ? filteredBlueprintFileNames : allBlueprintFileNames;
-}
-
 export function resolveProjectScopeKeyFromLabel(selectedProjectScopeLabel) {
   const projectScopeEntry = PROJECT_SCOPE_CHOICES.find((scopeChoice) => scopeChoice.label === selectedProjectScopeLabel);
   return projectScopeEntry?.key || 'both';
@@ -53,48 +28,7 @@ export function normalizeAdditionalBlueprintSelection(selectedBlueprintFileName,
   )));
 }
 
-export function deriveAdditionalBlueprintFileNamesFromStacks(
-  additionalStackFileNames,
-  allBlueprintFileNames,
-  selectedBlueprintFileName
-) {
-  const derivedBlueprintFileNames = [];
-
-  for (const additionalStackFileName of additionalStackFileNames || []) {
-    const mappedBlueprintFileName = BLUEPRINT_RECOMMENDATIONS[additionalStackFileName];
-    if (!mappedBlueprintFileName) {
-      continue;
-    }
-
-    if (!allBlueprintFileNames.includes(mappedBlueprintFileName)) {
-      continue;
-    }
-
-    if (mappedBlueprintFileName === selectedBlueprintFileName) {
-      continue;
-    }
-
-    derivedBlueprintFileNames.push(mappedBlueprintFileName);
-  }
-
-  return Array.from(new Set(derivedBlueprintFileNames));
-}
-
-export function resolveScopeStackCandidates(projectScopeKey) {
-  return PROJECT_SCOPE_STACK_FILTERS[projectScopeKey] || null;
-}
-
 export function resolveScopeBlueprintCandidates(projectScopeKey) {
-  if (projectScopeKey === 'frontend-only') {
-    return WEB_FRONTEND_BLUEPRINT_CANDIDATES;
-  }
-
-  if (projectScopeKey === 'backend-only') {
-    return WEB_BACKEND_BLUEPRINT_CANDIDATES;
-  }
-
-  return Array.from(new Set([
-    ...WEB_FRONTEND_BLUEPRINT_CANDIDATES,
-    ...WEB_BACKEND_BLUEPRINT_CANDIDATES,
-  ]));
+  void projectScopeKey;
+  return null;
 }

package/lib/cli/project-scaffolder/constants.mjs

@@ -61,7 +61,7 @@ export const DESIGN_REQUIRED_SECTIONS = [
   'Responsive Strategy and Cross-Viewport Adaptation Matrix',
   'Interaction, Motion, and Feedback Rules',
   'Component Language, Morphology, and Shared Patterns',
-  'Context Hygiene and Approved Reference Boundaries',
+  'Context Hygiene and Source Boundaries',
   'Accessibility Non-Negotiables',
   'Anti-Patterns to Avoid',
   'Implementation Notes for Future UI Tasks',