@ryuenn3123/agentic-senior-core 3.0.19 → 3.0.20

package/lib/cli/project-scaffolder/design-contract.mjs

@@ -36,7 +36,6 @@ function buildStructureFirstSeedSignals({
   supplementalFields = {},
 }) {
   const normalizedDescription = String(projectDescription || '').trim();
-  const normalizedDomain = String(primaryDomain || '').trim().toLowerCase();
   const repoEvidenceSummary = supplementalFields?.repoEvidence?.designEvidenceSummary || null;
   const hasRepoEvidence = Boolean(
     repoEvidenceSummary
@@ -49,38 +48,37 @@ function buildStructureFirstSeedSignals({
   const projectContextLabel = normalizedDescription
     ? `the product context "${normalizedDescription}"`
     : 'the current product context';
-  const isMobileLikeSurface = normalizedDomain.includes('mobile');
 
   return {
-    designPhilosophy: `Use ${evidenceSourceLabel} to synthesize a project-specific design system for ${projectName || 'this project'}. Treat this seed as structural scaffolding that must be refined before UI implementation, not as final art direction.`,
-    brandAdjectives: ['project-specific', 'intentional', 'evidence-led'],
-    antiAdjectives: ['template-neutral', 'copycat', 'unjustified-defaults'],
-    typographyScaleRatio: '1.200',
-    baseGridUnit: 8,
-    spacingPattern: isMobileLikeSurface ? 'mobile-first-single-axis' : 'adaptive-task-priority',
-    densityMode: isMobileLikeSurface ? 'touch-priority' : 'adaptive-task-priority',
-    colorIntent: `Define palette roles from ${projectContextLabel} and refine them with repo evidence. Treat the listed palette roles as minimum semantic categories, not final visual choices.`,
-    paletteRoles: ['base', 'surface', 'text', 'muted', 'accent', 'border', 'focus', 'success', 'warning', 'danger'],
+    designPhilosophy: `Use ${evidenceSourceLabel} to synthesize the design system for ${projectName || 'this project'}. This seed is only a decision scaffold: the LLM must choose the visual language, libraries, color system, typography, spacing, and interaction model from ${projectContextLabel}, current repo evidence, and live official documentation when a technology claim is needed.`,
+    brandAdjectives: ['agent-synthesized-from-current-context'],
+    antiAdjectives: ['offline-prescribed-style', 'template-by-default', 'scale-only-responsive', 'unresearched-library-choice'],
+    typographyScaleRatio: 'agent-calibrated-from-content-platform-and-readability',
+    baseGridUnit: 'agent-calibrated-from-platform-density-and-implementation-stack',
+    spacingPattern: 'agent-defined-from-task-flow-and-viewport-needs',
+    densityMode: 'agent-defined-from-user-task-device-and-content-pressure',
+    colorIntent: `Choose semantic palette roles from ${projectContextLabel}, current repo evidence, and accessibility needs. Do not inherit fixed palettes or generic SaaS color defaults from this scaffold.`,
+    paletteRoles: ['agent-defined-semantic-roles'],
     distinctiveMoves: [
-      'Derive one memorable signature move from the product task, current repo evidence, and the active brief before locking the layout language.',
-      'Use task priority, hierarchy, and surface relationships to replace template-neutral hero or card-grid defaults.',
-      'Document why the final visual move belongs to this project and what generic fallback it intentionally avoids.',
+      'Research and choose a current, project-fit visual direction instead of inheriting any offline preset from this scaffold.',
+      'Define at least one recognizable design move from the product task, audience, content, and repo evidence before implementation.',
+      'Document why the chosen move belongs to this project and which common LLM bad habit it intentionally avoids.',
     ],
-    motionPurpose: 'Use motion to clarify causality, hierarchy, state feedback, and perceived product quality. The final motion tone must be refined from repo evidence and the active brief, not inherited from this seed alone.',
-    motionChoreography: 'Keep motion purposeful, reduced-motion-safe, and tied to state or surface changes. Any signature choreography must be justified in docs/DESIGN.md before it becomes part of the system.',
+    motionPurpose: 'Use modern motion when it improves hierarchy, continuity, feedback, memorability, or perceived product quality. If implementation needs a motion library, the LLM must choose a current compatible option from official docs instead of relying on an offline default.',
+    motionChoreography: 'Define choreography from the product experience and implementation stack. Keep it performant and reduced-motion-safe; do not suppress rich interaction by default.',
     motionDurations: {
-      desktop: 180,
-      mobile: 240,
+      desktop: 'agent-calibrated',
+      mobile: 'agent-calibrated',
     },
     componentMorphology: {
-      mobile: 'Simplify the primary task surface, keep decisive actions in easy reach, and move supporting context behind explicit disclosure when space gets tight.',
-      tablet: 'Preserve task continuity while compressing tertiary chrome and keeping priority boundaries obvious across shared surfaces.',
-      desktop: 'Expose the richest version of the task flow and supporting context without defaulting to symmetrical template composition.',
+      mobile: 'Recompose the experience for touch, task priority, and constrained attention. Mobile should be a deliberate mobile design, not a shrunken desktop.',
+      tablet: 'Regroup surfaces for medium-width use, preserving task clarity without cloning either desktop or mobile blindly.',
+      desktop: 'Use the available space to improve hierarchy, scanability, and interaction quality without defaulting to template grids or generic dashboard chrome.',
     },
     mutationRules: {
-      mobile: 'Recompose the flow around the first decisive action, collapse secondary navigation into explicit overlays or sheets, and re-rank supporting context below the primary task.',
-      tablet: 'Preserve task continuity with fewer simultaneous surfaces, condensed chrome, and explicit boundaries between primary, supporting, and deferred content.',
-      desktop: 'Expose the fullest version of the task flow, supporting context, and navigation system without falling back to interchangeable dashboard or hero defaults.',
+      mobile: 'Define a mobile-specific composition with reordered, merged, or disclosed content where appropriate. Scale-only shrink behavior is failure.',
+      tablet: 'Define a tablet-specific regrouping strategy rather than a width-only reduction of desktop.',
+      desktop: 'Define a desktop composition that uses space intentionally and avoids generic equal-weight modules unless the project evidence justifies them.',
     },
   };
 }
@@ -115,8 +113,12 @@ function buildDesignIntentContractObject({
       name: projectName,
       context: projectDescription,
       domain: primaryDomain,
-      stack: toTitleCase(initContext.stackFileName),
-      blueprint: toTitleCase(initContext.blueprintFileName),
+      runtimeConstraint: initContext.stackFileName === 'agent-decision-runtime.md'
+        ? 'agent-recommendation-required'
+        : toTitleCase(initContext.stackFileName),
+      architectureConstraint: initContext.blueprintFileName === 'agent-decision-architecture.md'
+        ? 'agent-recommendation-required'
+        : toTitleCase(initContext.blueprintFileName),
     },
     designPhilosophy: inferredKeywords.designPhilosophy,
     brandAdjectives: inferredKeywords.brandAdjectives,
@@ -124,7 +126,8 @@ function buildDesignIntentContractObject({
     visualDirection: {
       seedMode: 'scaffold-only',
       requiresProjectSpecificSynthesis: true,
-      trendStance: 'trend-aware-not-trend-chasing',
+      selectionAuthority: 'agent-llm-after-current-context-repo-evidence-and-live-official-docs',
+      trendStance: 'current-context-first-not-offline-preset-first',
       distinctiveMoves: inferredKeywords.distinctiveMoves,
       copiedReferenceAllowed: false,
     },
@@ -169,6 +172,7 @@ function buildDesignIntentContractObject({
       paletteRoles: inferredKeywords.paletteRoles,
       rolePolicy: 'minimum-semantic-scaffold',
       rolesAreMinimumScaffold: true,
+      rolesMustBeAgentDefined: true,
       intent: inferredKeywords.colorIntent,
     },
     crossViewportAdaptation: {
@@ -231,6 +235,8 @@ function buildDesignIntentContractObject({
       requireRepoEvidenceAlignment: true,
       forbidScreenshotDependency: true,
       handoffFormatVersion: 'ui-handoff-v1',
+      requirePerSurfaceMutationOps: true,
+      forbidUniformSiblingSurfaceTreatment: true,
       semanticReviewFocus: [
         'distinctiveness-vs-genericity',
         'contract-fidelity',
@@ -245,77 +251,99 @@ function buildDesignIntentContractObject({
       status: 'seed-needs-refinement',
       seedMode: 'structure-first-scaffold',
       requiresTaskSpecificRefinement: true,
-      primaryExperienceGoal: `Refine the main ${String(primaryDomain || 'product').toLowerCase()} journey in ${projectName} so the first decisive action, supporting context, and signature move come from repo evidence and the active brief rather than scaffold defaults.`,
+      primaryExperienceGoal: `Ask the LLM to define the main ${String(primaryDomain || 'product').toLowerCase()} journey in ${projectName} from repo evidence, product context, user goals, and current official documentation where technology choices matter. This scaffold must not prescribe the final visual layout.`,
       surfacePlan: [
         {
-          surfaceId: 'primary-entry-surface',
-          role: 'primary-task-entry',
-          goal: `Map the first meaningful task in ${projectName} and replace generic hero filler with task-first hierarchy justified by repo evidence and the active brief.`,
-          primaryAction: 'Define the first decisive action or decision point explicitly during refinement instead of inheriting placeholder CTA language.',
-          supportingModules: ['context', 'proof', 'navigation'],
-          signatureMoveHint: 'Document one project-specific signature move for the primary surface and explain which generic fallback it intentionally rejects.',
+          surfaceId: 'agent-defined-primary-experience',
+          role: 'llm-synthesized-from-current-context',
+          goal: `Define the primary UI experience for ${projectName} from the actual product task, audience, data, and repo evidence before coding.`,
+          primaryAction: 'The LLM must choose the first decisive action or reading path and explain why it fits the project.',
+          supportingModules: ['agent-defined-from-current-context'],
+          layoutAntiPatternToAvoid: 'template-default-without-product-rationale',
+          signatureMoveHint: 'Choose and document one project-specific visual, interaction, or content move. Do not inherit it from this scaffold.',
         },
         {
-          surfaceId: 'supporting-proof-surface',
-          role: 'trust-and-context',
-          goal: 'Define how proof, explanation, or operational context supports the main task without turning the layout into a template-neutral secondary rail.',
-          primaryAction: 'Clarify what supporting proof or status belongs near the main task once the product-specific flow is confirmed.',
-          supportingModules: ['status', 'metadata', 'secondary-actions'],
-          signatureMoveHint: 'Explain how this supporting surface reinforces the primary task without competing for dominance or collapsing into generic chrome.',
+          surfaceId: 'agent-defined-supporting-experience',
+          role: 'llm-synthesized-supporting-context',
+          goal: 'Define supporting, proof, utility, or recovery surfaces from actual user needs instead of cloning generic cards or rails.',
+          primaryAction: 'The LLM must decide what belongs beside, below, hidden behind disclosure, or removed based on task priority.',
+          supportingModules: ['agent-defined-from-current-context'],
+          layoutAntiPatternToAvoid: 'scale-only-responsive-layout',
+          signatureMoveHint: 'Explain how supporting content changes across viewports and why the change improves the experience.',
         },
       ],
       componentGraph: {
         nodes: [
           {
-            id: 'primary-action-surface',
-            role: 'task-driver',
+            id: 'agent-defined-primary-experience',
+            role: 'primary-experience-after-synthesis',
             priority: 'high',
           },
           {
-            id: 'supporting-context-rail',
-            role: 'context-support',
-            priority: 'medium',
-          },
-          {
-            id: 'feedback-status-module',
-            role: 'feedback-and-proof',
+            id: 'agent-defined-supporting-experience',
+            role: 'supporting-experience-after-synthesis',
             priority: 'medium',
           },
         ],
         edges: [
           {
-            from: 'primary-action-surface',
-            to: 'supporting-context-rail',
-            relationship: 'context-support',
-          },
-          {
-            from: 'primary-action-surface',
-            to: 'feedback-status-module',
-            relationship: 'state-feedback',
+            from: 'agent-defined-primary-experience',
+            to: 'agent-defined-supporting-experience',
+            relationship: 'agent-defined-from-task-priority',
           },
         ],
       },
       contentPriorityMap: {
         primary: [
-          'core-task-entry',
-          'primary-status-or-value-message',
-          'decisive-action-labeling',
+          'agent-defined-core-task-or-reading-path',
         ],
         secondary: [
-          'supporting-proof',
-          'navigation-context',
-          'secondary-actions',
+          'agent-defined-supporting-context',
         ],
         deferred: [
-          'deep-explanation',
-          'tertiary-metadata',
-          'low-priority-decoration',
+          'agent-defined-deferred-or-hidden-content',
         ],
       },
       viewportMutationPlan: {
-        mobile: inferredKeywords.mutationRules.mobile,
-        tablet: inferredKeywords.mutationRules.tablet,
-        desktop: inferredKeywords.mutationRules.desktop,
+        mobile: {
+          primaryOperation: 'agent-defined-mobile-recomposition',
+          requiredSurfaceActions: [
+            'choose-mobile-specific-task-order',
+            'merge-disclose-or-remove-low-priority-content',
+            'adapt-interaction-model-for-touch',
+          ],
+          forbiddenPatterns: [
+            'scale-only-shrink',
+            'desktop-order-preserved-without-priority-shift',
+          ],
+          rationale: inferredKeywords.mutationRules.mobile,
+        },
+        tablet: {
+          primaryOperation: 'agent-defined-tablet-regrouping',
+          requiredSurfaceActions: [
+            'define-medium-width-information-architecture',
+            'avoid-cloning-desktop-by-width-only',
+            'preserve-task-clarity',
+          ],
+          forbiddenPatterns: [
+            'desktop-layout-reduced-by-width-only',
+            'uniform-module-grid-without-role-change',
+          ],
+          rationale: inferredKeywords.mutationRules.tablet,
+        },
+        desktop: {
+          primaryOperation: 'agent-defined-desktop-composition',
+          requiredSurfaceActions: [
+            'use-space-to-improve-hierarchy',
+            'define-scan-pattern-and-action-priority',
+            'avoid-equalizing-unrelated-content',
+          ],
+          forbiddenPatterns: [
+            'template-shell-without-product-rationale',
+            'interchangeable-dashboard-or-landing-chrome',
+          ],
+          rationale: inferredKeywords.mutationRules.desktop,
+        },
       },
       interactionStateMatrix: [
         {
@@ -330,11 +358,11 @@ function buildDesignIntentContractObject({
         },
       ],
       taskFlowNarrative: [
-        `Entry: refine how ${projectName} establishes the first meaningful action using current task evidence instead of generic product-marketing framing.`,
-        'Decision: define the hierarchy, proof, and state language that help the user choose the next step without defaulting to generic card-grid or hero habits.',
-        'Resolution: specify the feedback, recovery path, and next useful action so progress remains visible without hiding behind decorative confirmation states.',
+        `Entry: the LLM must define how ${projectName} starts the user journey from real product evidence instead of a generic opening pattern.`,
+        'Decision: the LLM must define hierarchy, proof, state language, and interaction behavior from the actual task.',
+        'Resolution: the LLM must define feedback, recovery, and next-useful-action behavior without defaulting to leftover template chrome.',
       ],
-      signatureMoveRationale: 'Explain which project-specific surface, motion, typographic, or compositional move anchors the system and why a generic fallback would weaken the product.',
+      signatureMoveRationale: 'The LLM must choose the project-specific visual, motion, typographic, compositional, or interaction move after reading current context and explain why a generic fallback would weaken the product.',
       implementationGuardrails: {
         requireBuildFromHandoff: true,
         requireGapNotesBeforeFallback: true,
@@ -343,10 +371,11 @@ function buildDesignIntentContractObject({
     },
     reviewRubric: {
       version: 'ui-rubric-v1',
+      genericityAutoFail: true,
       dimensions: [
         {
           key: 'distinctiveness',
-          blockingByDefault: false,
+          blockingByDefault: true,
           question: 'Does the UI feel authored and project-specific rather than like a default framework or template kit?',
         },
         {
@@ -371,18 +400,20 @@ function buildDesignIntentContractObject({
         },
       ],
       genericitySignals: [
-        'safe-centered-hero-without-product-rationale',
-        'balanced-card-grid-without-priority-shift',
-        'default-framework-button-and-input-treatment',
-        'trend-gradient-without-structural-role',
-        'interchangeable-dashboard-chrome',
+        'offline-prescribed-style-used-as-final-direction',
+        'unresearched-library-or-framework-choice',
+        'default-component-kit-treatment-without-product-rationale',
+        'scale-only-responsive-layout',
+        'template-shell-without-product-rationale',
+        'inaccessible-or-decorative-motion',
       ],
       validBoldSignals: [
-        'one-clear-signature-move',
-        'project-specific-layout-tension',
-        'purposeful-motion-as-identity',
-        'distinct-typographic-hierarchy',
-        'non-template-task-priority',
+        'context-derived-visual-direction',
+        'official-docs-backed-library-choice',
+        'responsive-recomposition-by-task-priority',
+        'purposeful-motion-with-reduced-motion-path',
+        'documented-design-rationale-before-code',
+        'clean-component-and-token-architecture',
       ],
       reportingRules: {
         mustExplainGenericity: true,
@@ -396,7 +427,7 @@ function buildDesignIntentContractObject({
         'current-repo-evidence',
         'current-user-brief',
         'current-project-docs',
-        'explicitly-approved-reference-systems',
+        'explicitly-approved-current-task-constraints',
       ],
       taintedSources: [
         'prior-chat-visual-memory',
@@ -407,7 +438,7 @@ function buildDesignIntentContractObject({
       repoEvidenceOverridesMemory: true,
       requireExplicitContinuityApproval: true,
       forbidCarryoverWhenUnapproved: true,
-      approvedReferenceUsage: 'Adapt reasoning and constraints from approved references without copying the surface 1:1.',
+      approvedExternalConstraintUsage: 'Convert explicit user-supplied external constraints into current-project rules without comparing against or imitating the source surface.',
       driftSignals: [
         'palette-reused-without-brief-support',
         'motion-signature-reused-without-approval',
@@ -419,15 +450,17 @@ function buildDesignIntentContractObject({
       'Major interface decisions must be explainable in product and user terms.',
       'Accessibility, responsiveness, and implementation realism are non-negotiable.',
       'Cross-viewport behavior must reorganize tasks and navigation, not just scale the desktop layout down.',
-      'Motion may add character, memorability, and continuity when it improves the product experience, but it must stay purposeful, performant, and optional for reduced-motion users.',
-      'At least one surface, compositional move, typographic decision, or motion motif should be recognizable at a glance.',
+      'Modern libraries and interaction patterns may be used when the LLM verifies they fit the project and current official docs.',
+      'Motion may be rich and memorable when it improves the product experience, but it must stay purposeful, performant, and optional for reduced-motion users.',
+      'At least one visual, interaction, content, or motion decision must be recognizable at a glance and justified from context.',
     ],
     forbiddenPatterns: [
-      'generic-saas-hero',
-      'copycat-brand-system',
-      'unjustified-default-gradients',
-      'placeholder-design-language',
+      'offline-prescribed-style-used-as-final-direction',
+      'unresearched-library-or-framework-choice',
+      'default-component-kit-treatment-without-product-rationale',
       'scale-only-responsive-layout',
+      'template-shell-without-product-rationale',
+      'single-safe-typographic-family-without-role-contrast-or-rationale',
     ],
     validationHints: {
       rejectArbitraryHexOnlyPalette: true,
@@ -444,6 +477,7 @@ function buildDesignIntentContractObject({
       requireStructuredDesignHandoff: true,
       requireReviewRubric: true,
       requireGenericityExplanation: true,
+      genericityAutoFail: true,
       requireSignatureMove: true,
       rejectTemplateNeutralLayout: true,
     },
@@ -493,11 +527,11 @@ export function validateDesignIntentContract(designIntentContract) {
   if (!designIntentContract.mathSystems || typeof designIntentContract.mathSystems !== 'object') {
     validationErrors.push('designIntent.mathSystems must exist.');
   } else {
-    if (!/^\d+(\.\d+)?$/.test(String(designIntentContract.mathSystems.typographyScaleRatio || '').trim())) {
-      validationErrors.push('designIntent.mathSystems.typographyScaleRatio must be numeric text.');
+    if (!String(designIntentContract.mathSystems.typographyScaleRatio || '').trim()) {
+      validationErrors.push('designIntent.mathSystems.typographyScaleRatio must describe the chosen or pending type scale decision.');
     }
-    if (!Number.isInteger(designIntentContract.mathSystems.baseGridUnit) || designIntentContract.mathSystems.baseGridUnit <= 0) {
-      validationErrors.push('designIntent.mathSystems.baseGridUnit must be a positive integer.');
+    if (!String(designIntentContract.mathSystems.baseGridUnit || '').trim()) {
+      validationErrors.push('designIntent.mathSystems.baseGridUnit must describe the chosen or pending spacing grid decision.');
     }
   }
 
@@ -563,14 +597,11 @@ export function validateDesignIntentContract(designIntentContract) {
       validationErrors.push('designIntent.colorTruth.intent must be a non-empty string.');
     }
     const paletteRoles = designIntentContract.colorTruth.paletteRoles;
-    if (!Array.isArray(paletteRoles) || paletteRoles.length < 4) {
-      validationErrors.push('designIntent.colorTruth.paletteRoles must define the minimum semantic palette roles.');
-    } else {
-      for (const requiredPaletteRole of ['base', 'surface', 'text', 'accent']) {
-        if (!paletteRoles.includes(requiredPaletteRole)) {
-          validationErrors.push(`designIntent.colorTruth.paletteRoles is missing "${requiredPaletteRole}".`);
-        }
-      }
+    if (!Array.isArray(paletteRoles) || paletteRoles.length < 1) {
+      validationErrors.push('designIntent.colorTruth.paletteRoles must define or request agent-defined semantic palette roles.');
+    }
+    if (designIntentContract.colorTruth.rolesMustBeAgentDefined !== true) {
+      validationErrors.push('designIntent.colorTruth.rolesMustBeAgentDefined must equal true.');
     }
   }
 
@@ -697,8 +728,8 @@ export function validateDesignIntentContract(designIntentContract) {
     if (!Array.isArray(designIntentContract.contextHygiene.taintedSources) || designIntentContract.contextHygiene.taintedSources.length < 3) {
       validationErrors.push('designIntent.contextHygiene.taintedSources must list tainted carryover sources.');
     }
-    if (!String(designIntentContract.contextHygiene.approvedReferenceUsage || '').trim()) {
-      validationErrors.push('designIntent.contextHygiene.approvedReferenceUsage must be a non-empty string.');
+    if (!String(designIntentContract.contextHygiene.approvedExternalConstraintUsage || '').trim()) {
+      validationErrors.push('designIntent.contextHygiene.approvedExternalConstraintUsage must be a non-empty string.');
     }
   }
 
@@ -719,6 +750,8 @@ export function validateDesignIntentContract(designIntentContract) {
       'requireStructuredHandoff',
       'requireRepoEvidenceAlignment',
       'forbidScreenshotDependency',
+      'requirePerSurfaceMutationOps',
+      'forbidUniformSiblingSurfaceTreatment',
     ]) {
       if (designIntentContract.designExecutionPolicy[requiredFlagName] !== true) {
         validationErrors.push(`designIntent.designExecutionPolicy.${requiredFlagName} must equal true.`);
@@ -779,8 +812,22 @@ export function validateDesignIntentContract(designIntentContract) {
       validationErrors.push('designIntent.designExecutionHandoff.viewportMutationPlan must exist.');
     } else {
       for (const viewportKey of ['mobile', 'tablet', 'desktop']) {
-        if (!String(viewportMutationPlan[viewportKey] || '').trim()) {
-          validationErrors.push(`designIntent.designExecutionHandoff.viewportMutationPlan.${viewportKey} must be a non-empty string.`);
+        const viewportPlan = viewportMutationPlan[viewportKey];
+        if (!viewportPlan || typeof viewportPlan !== 'object') {
+          validationErrors.push(`designIntent.designExecutionHandoff.viewportMutationPlan.${viewportKey} must be an object.`);
+          continue;
+        }
+        if (!String(viewportPlan.primaryOperation || '').trim()) {
+          validationErrors.push(`designIntent.designExecutionHandoff.viewportMutationPlan.${viewportKey}.primaryOperation must be a non-empty string.`);
+        }
+        if (!Array.isArray(viewportPlan.requiredSurfaceActions) || viewportPlan.requiredSurfaceActions.length < 2) {
+          validationErrors.push(`designIntent.designExecutionHandoff.viewportMutationPlan.${viewportKey}.requiredSurfaceActions must contain at least two actions.`);
+        }
+        if (!Array.isArray(viewportPlan.forbiddenPatterns) || viewportPlan.forbiddenPatterns.length < 1) {
+          validationErrors.push(`designIntent.designExecutionHandoff.viewportMutationPlan.${viewportKey}.forbiddenPatterns must contain at least one anti-pattern.`);
+        }
+        if (!String(viewportPlan.rationale || '').trim()) {
+          validationErrors.push(`designIntent.designExecutionHandoff.viewportMutationPlan.${viewportKey}.rationale must be a non-empty string.`);
         }
       }
     }
@@ -815,6 +862,9 @@ export function validateDesignIntentContract(designIntentContract) {
     if (designIntentContract.reviewRubric.version !== 'ui-rubric-v1') {
       validationErrors.push('designIntent.reviewRubric.version must equal "ui-rubric-v1".');
     }
+    if (designIntentContract.reviewRubric.genericityAutoFail !== true) {
+      validationErrors.push('designIntent.reviewRubric.genericityAutoFail must equal true.');
+    }
     if (!Array.isArray(designIntentContract.reviewRubric.dimensions) || designIntentContract.reviewRubric.dimensions.length < 5) {
       validationErrors.push('designIntent.reviewRubric.dimensions must define the required rubric dimensions.');
     } else {
@@ -861,6 +911,10 @@ export function validateDesignIntentContract(designIntentContract) {
     }
   }
 
+  if (!Array.isArray(designIntentContract.forbiddenPatterns) || designIntentContract.forbiddenPatterns.length < 4) {
+    validationErrors.push('designIntent.forbiddenPatterns must list concrete anti-generic patterns.');
+  }
+
   return validationErrors;
 }