@ryuenn3123/agentic-senior-core 3.0.37 → 3.0.38

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

@@ -1,5 +1,45 @@
 import { toTitleCase } from '../utils.mjs';
 import { DESIGN_REQUIRED_SECTIONS } from './constants.mjs';
+import { validateDesignIntentContract } from './design-contract/validation.mjs';
+
+const GENERICITY_DRIFT_SIGNALS = [
+  'offline-prescribed-style-used-as-final-direction',
+  'unresearched-library-or-framework-choice',
+  'missing-conceptual-anchor-without-external-research',
+  'visual-decisions-not-derived-from-conceptual-anchor',
+  'ai-safe-ui-template-look',
+  'ai-color-default-palette-without-product-role-behavior',
+  'brandless-clean-template-look',
+  'interchangeable-product-renaming-test-fails',
+  'decorative-grid-or-glow-wallpaper-without-product-function',
+  'safe-cream-slate-or-monochrome-palette-used-as-readability-excuse',
+  'generic-abstract-logo-or-iconography',
+  'timid-anchor-that-renames-dashboard-or-admin-shell',
+  'motion-suppressed-without-accessibility-or-performance-reason',
+  'motion-or-3d-omitted-from-fear-without-fit-analysis',
+  'scale-only-responsive-layout',
+  'zero-based-redesign-kept-prior-visual-dna',
+  'restyle-instead-of-recomposition',
+];
+
+const FORBIDDEN_PATTERN_SIGNALS = [
+  ...GENERICITY_DRIFT_SIGNALS.filter((signal) => signal !== 'unresearched-library-or-framework-choice'),
+  'single-safe-typographic-family-without-role-contrast-or-rationale',
+];
+
+const VALID_BOLD_SIGNALS = [
+  'single-cohesive-conceptual-anchor',
+  'high-variance-candidate-selection',
+  'context-derived-visual-direction',
+  'three-at-a-glance-product-specific-signals',
+  'visually-exploratory-accessible-palette-derived-from-product',
+  'audacious-accessible-palette-with-product-role-behavior',
+  'background-or-geometry-serves-product-function',
+  'motion-or-spatial-experience-derived-from-anchor',
+  'explicit-3d-canvas-fit-or-nonfit-decision',
+  'responsive-recomposition-by-task-priority',
+  'purposeful-motion-with-reduced-motion-path',
+];
 
 export function shouldBootstrapDesignDocument(discoveryAnswers, initContext) {
   const normalizedDomain = String(discoveryAnswers.primaryDomain || '').trim().toLowerCase();
@@ -51,26 +91,26 @@ function buildStructureFirstSeedSignals({
     : 'the current product context';
 
   return {
-    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.`,
+    designPhilosophy: `Synthesize design for ${projectName || 'this project'} from ${evidenceSourceLabel}. Choose visual language, libraries, color, type, spacing, and interaction from ${projectContextLabel}; verify technology claims with official docs.`,
     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.`,
+    colorIntent: `Choose semantic palette roles from ${projectContextLabel}, repo evidence, and accessibility. Reject scaffold or SaaS palette defaults.`,
     paletteRoles: ['agent-defined-semantic-roles'],
     distinctiveMoves: [
-      'Choose one recognizable design move from product task, audience, content, repo evidence, and current docs; do not inherit a scaffold preset.',
+      'Choose one product-specific move from task, audience, content, repo evidence, and docs.',
     ],
-    motionPurpose: 'Default to a modern motion plan for UI work: use expressive transitions, spatial choreography, micro-interactions, and motion libraries when they strengthen 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.',
+    motionPurpose: 'Use expressive motion when it improves hierarchy, continuity, feedback, memorability, or confidence. Verify new motion libraries with official docs.',
     componentMorphology: {
-      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.',
+      mobile: 'Recompose for touch, task priority, and constrained attention.',
+      tablet: 'Regroup surfaces for medium width without cloning desktop or mobile.',
+      desktop: 'Use space for hierarchy and scanability; avoid template grids.',
     },
     mutationRules: {
-      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.',
+      mobile: 'Reorder, merge, or disclose content for mobile. Reject scale-only shrink.',
+      tablet: 'Regroup for tablet instead of width-only desktop reduction.',
+      desktop: 'Use space intentionally; avoid equal-weight modules without evidence.',
     },
   };
 }
@@ -132,7 +172,7 @@ function buildDesignIntentContractObject({
         'ui-primitives-or-rich-media',
         'typography-and-interaction',
       ],
-      finalDecisionAuthority: 'agent-llm-from-project-fit-accessibility-performance-maintainability-and-current-official-docs',
+      finalDecisionAuthority: 'project-fit-accessibility-performance-maintainability-official-docs',
     },
     conceptualAnchor: {
       mode: 'required-when-no-external-research',
@@ -163,7 +203,7 @@ function buildDesignIntentContractObject({
           'typographicDecision',
         ],
         rejectGenericQualityWordsOnly: true,
-        specificityFloor: 'name-a-real-material-instrument-artifact-architecture-editorial-genre-cinematic-behavior-exhibition-system-scientific-apparatus-or-industrial-mechanism',
+        specificityFloor: 'name-real-material-instrument-artifact-architecture-editorial-genre-cinematic-behavior-exhibition-system-scientific-apparatus-or-industrial-mechanism',
       },
       forbiddenFinalAnchorTerms: [
         'dashboard',
@@ -219,64 +259,64 @@ function buildDesignIntentContractObject({
     },
     derivedTokenLogic: {
       anchorReference: 'agent-defined-anchor-reference',
-      colorDerivationSource: 'Agent must explain how semantic color roles derive from the chosen anchorReference; default blue or generic SaaS palettes are invalid without anchor evidence.',
-      spacingDerivationSource: 'Agent must explain how base grid, rhythm, density, and spacing exceptions derive from the chosen anchorReference.',
-      typographyDerivationSource: 'Agent must explain how display, body, metadata, and data typography roles derive from the chosen anchorReference.',
-      motionDerivationSource: 'Agent must explain how duration, easing, choreography, and reduced-motion alternatives derive from the chosen anchorReference.',
-      validationRule: 'Every primitive, semantic, component, typography, spacing, and motion token must trace back to anchorReference; if a token cannot be explained from the anchor, revise the token.',
+      colorDerivationSource: 'Explain semantic color roles from anchorReference; reject generic palettes without anchor evidence.',
+      spacingDerivationSource: 'Explain grid, rhythm, density, and exceptions from anchorReference.',
+      typographyDerivationSource: 'Explain display, body, metadata, and data roles from anchorReference.',
+      motionDerivationSource: 'Explain duration, easing, choreography, and reduced-motion from anchorReference.',
+      validationRule: 'Every token must trace to anchorReference; revise tokens that cannot.',
     },
     motionPaletteDecision: {
       productCategorySignal: 'agent-inferred-starting-heuristic',
-      densityDecisionSource: 'Agent must choose motion density from task, content density, brand intent, device/performance, and accessibility evidence; product categories are heuristics, not style presets.',
+      densityDecisionSource: 'Choose motion density from task, content, brand, device, performance, and accessibility. Categories are heuristics.',
       requiredInteractionStates: ['default', 'hover', 'focus-visible', 'active', 'disabled', 'loading', 'empty', 'error', 'success', 'transition'],
       paletteAutopilotRisks: ['dark-slate-default', 'cream-beige-default', 'purple-blue-gradient-default', 'monochrome-template-default', 'uniform-card-surface-default', 'generic-grid-wallpaper-default', 'soft-glow-ai-template-default', 'cyber-neon-terminal-default'],
-      spatialDecision: 'Agent must state whether 3D/canvas/WebGL is useful or unnecessary for product understanding, exploration, or storytelling; if omitted, name the product, content-density, performance, accessibility, or device reason and the replacement interaction quality.',
+      spatialDecision: 'State 3D/canvas/WebGL fit. If omitted, name product-fit reason and replacement interaction quality.',
     },
     aiSafeUiAudit: {
       status: 'agent-must-complete-before-ui-implementation',
-      failureDefinition: 'UI is AI-safe when it relies on predictable card stacks, rounded template panels, generic abstract logos, decorative grid wallpaper, beige or slate safety palettes, soft glow backgrounds, or first-output composition with only local copy swapped in.',
-      interchangeabilityTest: `If this UI can be renamed from ${projectName} to another product category without changing composition, palette, iconography, and motion language, the design is genericity drift and must be revised.`,
+      failureDefinition: 'AI-safe UI uses template cards, generic marks, decorative grid wallpaper, safe palettes, glow backgrounds, or copied scaffold composition.',
+      interchangeabilityTest: `If this UI can be renamed from ${projectName} to another product category without changing composition, palette, iconography, and motion, revise it.`,
       requiredProductSpecificSignals: [
         'agent-defined-product-specific-data-treatment',
         'agent-defined-product-specific-motion-or-state-behavior',
         'agent-defined-product-specific-morphology-iconography-or-spatial-structure',
       ],
-      paletteExplorationRule: 'Use a visually exploratory product-derived palette while preserving WCAG contrast and status clarity; do not use readability as an excuse for cream, slate, monochrome, or gradient defaults.',
-      backgroundPatternRule: 'Lines, grids, scanlines, noise, glows, blobs, logos, and geometric decoration must serve a named product function such as alignment, measurement, navigation, crop guidance, timeline reading, status, or motion continuity.',
+      paletteExplorationRule: 'Use a visually exploratory product-derived palette with WCAG contrast and status clarity.',
+      backgroundPatternRule: 'Lines, grids, scanlines, noise, glows, blobs, logos, and geometry must serve a named product function.',
       aiColorAudit: {
         status: 'agent-must-complete-before-ui-implementation',
-        failureDefinition: 'AI color drift happens when a palette uses safe or fashionable defaults before deriving semantic roles from the product anchor.',
+        failureDefinition: 'AI color drift uses safe defaults before deriving roles from the product anchor.',
         autopilotRisks: ['cream-editorial-default', 'dark-slate-dashboard-default', 'purple-blue-gradient-default', 'monochrome-minimal-default', 'cyber-neon-terminal-default', 'soft-glow-atmosphere-default'],
         requiredEvidence: [
           'anchor-derived-color-logic',
           'semantic-role-contrast-beyond-surface-decoration',
           'product-specific-color-behavior-that-would-not-transfer',
         ],
-        reviewQuestion: 'Why does this palette belong to this product instead of a generic first-pass AI UI?',
+        reviewQuestion: 'Why does this palette belong to this product?',
       },
       motionSpatialCourageAudit: {
         status: 'agent-must-complete-before-ui-implementation',
-        defaultStance: 'Treat motion, scroll choreography, canvas, WebGL, and 3D as first-class options; omit them only with a product, content-density, performance, accessibility, or device reason.',
+        defaultStance: 'Treat motion, scroll choreography, canvas, WebGL, and 3D as first-class options.',
         requiredDecisionFields: [
           'signature-motion-or-interaction',
           'spatial-or-3d-fit',
           'performance-and-reduced-motion-fallback',
         ],
-        rejectionRule: 'Do not mark 3D/canvas unnecessary by habit; state the product reason and the replacement interaction quality.',
-        reviewQuestion: 'Did the agent make the experience as expressive as the product can responsibly support?',
+        rejectionRule: 'State a product reason and replacement interaction quality before omitting 3D/canvas.',
+        reviewQuestion: 'Is the interaction as expressive as the product can responsibly support?',
       },
-      reviewQuestion: 'What at-a-glance visual evidence proves this screen belongs to this product and not a generic AI-generated template?',
+      reviewQuestion: 'What visible evidence proves this is product-specific?',
       blockingByDefault: true,
     },
     libraryResearchStatus: 'pending-verification',
     libraryDecisions: [
       {
         library: 'agent-defined-or-none',
-        purpose: 'Agent must verify any UI, animation, scroll, 3D, canvas, chart, icon, or styling library against current official docs before implementation.',
+        purpose: 'Verify UI-related libraries against current official docs before imports.',
         verifiedAt: null,
         sourceUrl: null,
         stableVersion: null,
-        fallbackIfUnavailable: 'Use native CSS, browser APIs, or existing project dependencies until live verification is available.',
+        fallbackIfUnavailable: 'Use native CSS, browser APIs, or existing dependencies.',
       },
     ],
     mathSystems: {
@@ -391,12 +431,12 @@ function buildDesignIntentContractObject({
       status: 'seed-needs-refinement',
       seedMode: 'structure-first-scaffold',
       requiresTaskSpecificRefinement: true,
-      primaryExperienceGoal: `Define the main ${String(primaryDomain || 'product').toLowerCase()} journey for ${projectName} from repo evidence, the brief, and current docs. The seed must not prescribe final layout.`,
+      primaryExperienceGoal: `Define the main ${String(primaryDomain || 'product').toLowerCase()} journey for ${projectName} from repo evidence, brief, and docs.`,
       surfacePlan: [
         {
           surfaceId: 'agent-defined-primary-experience',
           role: 'primary-context-synthesized-by-agent',
-          goal: 'Choose the first task or reading path from product evidence and reject template shells.',
+          goal: 'Choose the first task path from product evidence; reject template shells.',
           antiPatterns: ['dashboard-default', 'scale-only-responsive-layout'],
         },
       ],
@@ -471,12 +511,12 @@ function buildDesignIntentContractObject({
         {
           componentId: 'primary-interaction',
           states: ['default', 'hover', 'focus', 'loading', 'error'],
-          notes: 'Refine states from project language and the conceptual anchor; do not use anonymous default panels.',
+          notes: 'Refine states from project language and anchor; reject anonymous panels.',
         },
       ],
       taskFlowNarrative: [
-        `Entry: define how ${projectName} starts the journey from real evidence, not a generic opener.`,
-        'Resolution: define proof, feedback, recovery, and next action without leftover template chrome.',
+        `Entry: start ${projectName} from real evidence, not a generic opener.`,
+        'Resolution: define proof, feedback, recovery, and next action.',
       ],
       visualResetStrategy: {
         activatesWhenUserRequests: [
@@ -487,7 +527,7 @@ function buildDesignIntentContractObject({
         existingUiForbiddenAs: ['palette-source', 'layout-source', 'motion-source'],
         requiredResetAxes: ['composition', 'hierarchy', 'motion-or-interaction', 'responsive-information-architecture'],
       },
-      signatureMoveRationale: 'Agent must choose one project-specific visual, motion, typographic, or interaction move and explain why generic fallback weakens it.',
+      signatureMoveRationale: 'Choose one project-specific visual, motion, type, or interaction move.',
       creativeCommitment: {
         status: 'agent-must-complete-before-ui-implementation',
         requiredFields: [
@@ -495,7 +535,7 @@ function buildDesignIntentContractObject({
           'signatureMotion',
           'typographicDecision',
         ],
-        failureMode: 'generic quality words without a named real-world reference are not enough',
+        failureMode: 'generic quality words without a real-world reference fail',
       },
       implementationGuardrails: {
         requireBuildFromHandoff: true,
@@ -510,61 +550,31 @@ function buildDesignIntentContractObject({
         {
           key: 'distinctiveness',
           blockingByDefault: true,
-          question: 'Does the UI feel authored and project-specific rather than like a default framework or template kit?',
+          question: 'Is the UI authored and product-specific?',
         },
         {
           key: 'contractFidelity',
           blockingByDefault: true,
-          question: 'Does the changed UI still follow the explicit design contract, interaction priorities, and accessibility boundaries?',
+          question: 'Does the UI follow contract, priorities, and accessibility?',
         },
         {
           key: 'visualConsistency',
           blockingByDefault: false,
-          question: 'Do typography, spacing, color usage, and component behaviors still feel like one system?',
+          question: 'Do type, spacing, color, and states form one system?',
         },
         {
           key: 'heuristicUxQuality',
           blockingByDefault: false,
-          question: 'Does the UI preserve task clarity, feedback quality, and user confidence in the touched flows?',
+          question: 'Does the UI preserve clarity, feedback, and confidence?',
         },
         {
           key: 'motionDiscipline',
           blockingByDefault: false,
-          question: 'Does motion act as part of the design language while staying purposeful, performant, reduced-motion-safe, and consistent with the product tone?',
+          question: 'Is motion purposeful, performant, reduced-motion-safe, and on-tone?',
         },
       ],
-      genericitySignals: [
-        'offline-prescribed-style-used-as-final-direction',
-        'unresearched-library-or-framework-choice',
-        'missing-conceptual-anchor-without-external-research',
-        'visual-decisions-not-derived-from-conceptual-anchor',
-        'ai-safe-ui-template-look',
-        'ai-color-default-palette-without-product-role-behavior',
-        'brandless-clean-template-look',
-        'interchangeable-product-renaming-test-fails',
-        'decorative-grid-or-glow-wallpaper-without-product-function',
-        'safe-cream-slate-or-monochrome-palette-used-as-readability-excuse',
-        'generic-abstract-logo-or-iconography',
-        'timid-anchor-that-renames-dashboard-or-admin-shell',
-        'motion-suppressed-without-accessibility-or-performance-reason',
-        'motion-or-3d-omitted-from-fear-without-fit-analysis',
-        'scale-only-responsive-layout',
-        'zero-based-redesign-kept-prior-visual-dna',
-        'restyle-instead-of-recomposition',
-      ],
-      validBoldSignals: [
-        'single-cohesive-conceptual-anchor',
-        'high-variance-candidate-selection',
-        'context-derived-visual-direction',
-        'three-at-a-glance-product-specific-signals',
-        'visually-exploratory-accessible-palette-derived-from-product',
-        'audacious-accessible-palette-with-product-role-behavior',
-        'background-or-geometry-serves-product-function',
-        'motion-or-spatial-experience-derived-from-anchor',
-        'explicit-3d-canvas-fit-or-nonfit-decision',
-        'responsive-recomposition-by-task-priority',
-        'purposeful-motion-with-reduced-motion-path',
-      ],
+      genericitySignals: [...GENERICITY_DRIFT_SIGNALS],
+      validBoldSignals: [...VALID_BOLD_SIGNALS],
       reportingRules: {
         mustExplainGenericity: true,
         mustSeparateTasteFromFailure: true,
@@ -588,74 +598,45 @@ function buildDesignIntentContractObject({
       repoEvidenceOverridesMemory: true,
       requireExplicitContinuityApproval: true,
       forbidCarryoverWhenUnapproved: true,
-      approvedExternalConstraintUsage: 'Convert explicit user-supplied external constraints into current-project rules without comparing against or imitating the source surface.',
+      approvedExternalConstraintUsage: 'Convert approved external constraints into current-project rules; do not imitate source surfaces.',
       driftSignals: [
         'palette-reused-without-brief-support',
         'prior-ui-visual-dna-carried-into-reset-request',
       ],
     },
-    experiencePrinciples: [
-      'Design must feel project-specific, not interchangeable with generic SaaS templates.',
-      'Readable UI must still avoid AI-safe template look; safety is not a substitute for authored visual direction.',
-      'Major interface decisions must be explainable in product and user terms.',
-      'Accessibility, responsiveness, and implementation realism are non-negotiable.',
-      'Accessibility is the floor, not a reason to erase visual personality or fall back to AI color defaults.',
-      'Cross-viewport behavior must reorganize tasks and navigation, not just scale the desktop layout down.',
-      'A single agent-chosen conceptual anchor must unify typography, spacing, morphology, motion, and responsive composition when user research is absent.',
-      'Expressive motion and spatial interaction are expected for modern UI work when they support the anchor; keep them accessible and performant instead of suppressing them by default.',
-      'When the user asks for a zero-based redesign, existing UI becomes content and behavior evidence only; prior visual DNA must be discarded unless explicitly approved.',
-    ],
-    forbiddenPatterns: [
-      'offline-prescribed-style-used-as-final-direction',
-      'missing-conceptual-anchor-without-external-research',
-      'visual-decisions-not-derived-from-conceptual-anchor',
-      'ai-safe-ui-template-look',
-      'ai-color-default-palette-without-product-role-behavior',
-      'brandless-clean-template-look',
-      'interchangeable-product-renaming-test-fails',
-      'decorative-grid-or-glow-wallpaper-without-product-function',
-      'safe-cream-slate-or-monochrome-palette-used-as-readability-excuse',
-      'generic-abstract-logo-or-iconography',
-      'timid-anchor-that-renames-dashboard-or-admin-shell',
-      'motion-suppressed-without-accessibility-or-performance-reason',
-      'motion-or-3d-omitted-from-fear-without-fit-analysis',
-      'scale-only-responsive-layout',
-      'zero-based-redesign-kept-prior-visual-dna',
-      'restyle-instead-of-recomposition',
-      'single-safe-typographic-family-without-role-contrast-or-rationale',
+    forbiddenPatterns: [...FORBIDDEN_PATTERN_SIGNALS],
+    validationHints: [
+      'rejectArbitraryHexOnlyPalette',
+      'requireViewportMutationRules',
+      'requirePerceptualColorRationale',
+      'requireTokenLayering',
+      'requireTokenAliasingPlan',
+      'allowHexDerivatives',
+      'requireMotionRationale',
+      'requireStateMorphology',
+      'requireAccessibilitySplit',
+      'requireWcagHardFloor',
+      'requireStructuredDesignExecutionPolicy',
+      'requireStructuredDesignHandoff',
+      'requireVisualResetStrategyWhenZeroBasedRedesignRequested',
+      'requireConceptualAnchorWhenNoExternalResearch',
+      'requireAgentLedAnchorResearchWhenUserResearchMissing',
+      'rejectTimidDashboardAnchor',
+      'requireReviewRubric',
+      'requireGenericityExplanation',
+      'genericityAutoFail',
+      'requireSignatureMove',
+      'rejectTemplateNeutralLayout',
+      'requireAiSafeUiAudit',
+      'requireAiColorAudit',
+      'rejectAiColorDefaults',
+      'requireMotionSpatialCourageAudit',
+      'requireExplicit3dCanvasFitDecision',
+      'rejectSafetyAsCreativitySubstitute',
+      'rejectAiSafeUiTemplateLook',
+      'requireThreeProductSpecificSignals',
+      'rejectDecorativeBackgroundPatternsWithoutProductFunction',
     ],
-    validationHints: {
-      rejectArbitraryHexOnlyPalette: true,
-      requireViewportMutationRules: true,
-      requirePerceptualColorRationale: true,
-      requireTokenLayering: true,
-      requireTokenAliasingPlan: true,
-      allowHexDerivatives: true,
-      requireMotionRationale: true,
-      requireStateMorphology: true,
-      requireAccessibilitySplit: true,
-      requireWcagHardFloor: true,
-      requireStructuredDesignExecutionPolicy: true,
-      requireStructuredDesignHandoff: true,
-      requireVisualResetStrategyWhenZeroBasedRedesignRequested: true,
-      requireConceptualAnchorWhenNoExternalResearch: true,
-      requireAgentLedAnchorResearchWhenUserResearchMissing: true,
-      rejectTimidDashboardAnchor: true,
-      requireReviewRubric: true,
-      requireGenericityExplanation: true,
-      genericityAutoFail: true,
-      requireSignatureMove: true,
-      rejectTemplateNeutralLayout: true,
-      requireAiSafeUiAudit: true,
-      requireAiColorAudit: true,
-      rejectAiColorDefaults: true,
-      requireMotionSpatialCourageAudit: true,
-      requireExplicit3dCanvasFitDecision: true,
-      rejectSafetyAsCreativitySubstitute: true,
-      rejectAiSafeUiTemplateLook: true,
-      requireThreeProductSpecificSignals: true,
-      rejectDecorativeBackgroundPatternsWithoutProductFunction: true,
-    },
     requiredDesignSections: DESIGN_REQUIRED_SECTIONS,
     implementation: {
       requiredDeliverables: ['docs/DESIGN.md', 'docs/design-intent.json'],
@@ -681,793 +662,7 @@ function buildDesignIntentContractObject({
   };
 }
 
-function hasNonEmptyString(value) {
-  return typeof value === 'string' && value.trim().length > 0;
-}
-
-export function validateDesignContractCompleteness(designIntentContract) {
-  const validationIssues = [];
-  const conceptualAnchor = designIntentContract?.conceptualAnchor;
-  const derivedTokenLogic = designIntentContract?.derivedTokenLogic;
-  const libraryDecisions = designIntentContract?.libraryDecisions;
-
-  const anchorReference = conceptualAnchor?.anchorReference || derivedTokenLogic?.anchorReference;
-  if (!hasNonEmptyString(anchorReference)) {
-    validationIssues.push('designIntent.conceptualAnchor.anchorReference must be a stable non-empty ID for deterministic validation.');
-  }
-
-  if (!derivedTokenLogic || typeof derivedTokenLogic !== 'object') {
-    validationIssues.push('designIntent.derivedTokenLogic must exist.');
-  } else {
-    if (derivedTokenLogic.anchorReference !== anchorReference) {
-      validationIssues.push('designIntent.derivedTokenLogic.anchorReference must exactly match designIntent.conceptualAnchor.anchorReference.');
-    }
-
-    for (const requiredFieldName of [
-      'colorDerivationSource',
-      'spacingDerivationSource',
-      'typographyDerivationSource',
-      'motionDerivationSource',
-      'validationRule',
-    ]) {
-      if (!hasNonEmptyString(derivedTokenLogic[requiredFieldName])) {
-        validationIssues.push(`designIntent.derivedTokenLogic.${requiredFieldName} must be a non-empty string.`);
-      }
-    }
-
-    if (
-      hasNonEmptyString(derivedTokenLogic.validationRule)
-      && !derivedTokenLogic.validationRule.includes('anchorReference')
-    ) {
-      validationIssues.push('designIntent.derivedTokenLogic.validationRule must require traceability to anchorReference.');
-    }
-  }
-
-  if (!['verified', 'pending-verification', 'no-external-library-needed'].includes(designIntentContract?.libraryResearchStatus)) {
-    validationIssues.push('designIntent.libraryResearchStatus must be verified, pending-verification, or no-external-library-needed.');
-  }
-
-  if (!Array.isArray(libraryDecisions)) {
-    validationIssues.push('designIntent.libraryDecisions must be an array.');
-  } else {
-    for (const [libraryIndex, libraryDecision] of libraryDecisions.entries()) {
-      if (!libraryDecision || typeof libraryDecision !== 'object') {
-        validationIssues.push(`designIntent.libraryDecisions[${libraryIndex}] must be an object.`);
-        continue;
-      }
-
-      if (!hasNonEmptyString(libraryDecision.library)) {
-        validationIssues.push(`designIntent.libraryDecisions[${libraryIndex}].library must be a non-empty string.`);
-      }
-      if (!hasNonEmptyString(libraryDecision.purpose)) {
-        validationIssues.push(`designIntent.libraryDecisions[${libraryIndex}].purpose must be a non-empty string.`);
-      }
-
-      const hasVerification = hasNonEmptyString(libraryDecision.verifiedAt)
-        && hasNonEmptyString(libraryDecision.sourceUrl);
-      const hasFallback = hasNonEmptyString(libraryDecision.fallbackIfUnavailable);
-
-      if (!hasVerification && !hasFallback) {
-        validationIssues.push(`designIntent.libraryDecisions[${libraryIndex}] must either record verification source or provide fallbackIfUnavailable.`);
-      }
-    }
-  }
-
-  return validationIssues;
-}
-
-export function validateDesignIntentContract(designIntentContract) {
-  const validationErrors = [];
-
-  if (!designIntentContract || typeof designIntentContract !== 'object') {
-    return ['Design intent contract must be an object.'];
-  }
-
-  validationErrors.push(...validateDesignContractCompleteness(designIntentContract));
-
-  if (designIntentContract.mode !== 'dynamic') {
-    validationErrors.push('designIntent.mode must equal "dynamic".');
-  }
-
-  if (!designIntentContract.project || typeof designIntentContract.project !== 'object') {
-    validationErrors.push('designIntent.project must exist.');
-  }
-
-  if (!designIntentContract.designPhilosophy || typeof designIntentContract.designPhilosophy !== 'string') {
-    validationErrors.push('designIntent.designPhilosophy must be a non-empty string.');
-  }
-
-  if (!designIntentContract.externalResearchIntake || typeof designIntentContract.externalResearchIntake !== 'object') {
-    validationErrors.push('designIntent.externalResearchIntake must exist.');
-  } else {
-    if (designIntentContract.externalResearchIntake.userSuppliedResearchPolicy !== 'read-as-candidate-evidence-not-final-prescription') {
-      validationErrors.push('designIntent.externalResearchIntake.userSuppliedResearchPolicy must preserve user research as candidate evidence.');
-    }
-    if (designIntentContract.externalResearchIntake.requireOfficialDocsVerificationForTechnologyClaims !== true) {
-      validationErrors.push('designIntent.externalResearchIntake.requireOfficialDocsVerificationForTechnologyClaims must equal true.');
-    }
-    if (
-      !Array.isArray(designIntentContract.externalResearchIntake.candidateDomains)
-      || !designIntentContract.externalResearchIntake.candidateDomains.includes('motion-and-scroll')
-    ) {
-      validationErrors.push('designIntent.externalResearchIntake.candidateDomains must include motion-and-scroll.');
-    }
-  }
-
-  if (!designIntentContract.conceptualAnchor || typeof designIntentContract.conceptualAnchor !== 'object') {
-    validationErrors.push('designIntent.conceptualAnchor must exist.');
-  } else {
-    const conceptualAnchor = designIntentContract.conceptualAnchor;
-    if (conceptualAnchor.mode !== 'required-when-no-external-research') {
-      validationErrors.push('designIntent.conceptualAnchor.mode must equal "required-when-no-external-research".');
-    }
-    if (conceptualAnchor.seedMode !== 'selection-policy-only') {
-      validationErrors.push('designIntent.conceptualAnchor.seedMode must equal "selection-policy-only".');
-    }
-    if (conceptualAnchor.requiresAgentSelectionBeforeUiImplementation !== true) {
-      validationErrors.push('designIntent.conceptualAnchor.requiresAgentSelectionBeforeUiImplementation must equal true.');
-    }
-    if (!hasNonEmptyString(conceptualAnchor.anchorReference)) {
-      validationErrors.push('designIntent.conceptualAnchor.anchorReference must be a stable non-empty ID.');
-    }
-    const userResearchAbsencePolicy = conceptualAnchor.userResearchAbsencePolicy;
-    if (!userResearchAbsencePolicy || typeof userResearchAbsencePolicy !== 'object') {
-      validationErrors.push('designIntent.conceptualAnchor.userResearchAbsencePolicy must exist.');
-    } else {
-      if (userResearchAbsencePolicy.userSuppliedResearchOnly !== true) {
-        validationErrors.push('designIntent.conceptualAnchor.userResearchAbsencePolicy.userSuppliedResearchOnly must equal true.');
-      }
-      if (userResearchAbsencePolicy.scaffoldSeedDoesNotCountAsResearch !== true) {
-        validationErrors.push('designIntent.conceptualAnchor.userResearchAbsencePolicy.scaffoldSeedDoesNotCountAsResearch must equal true.');
-      }
-      if (userResearchAbsencePolicy.priorUiDoesNotCountAsResearch !== true) {
-        validationErrors.push('designIntent.conceptualAnchor.userResearchAbsencePolicy.priorUiDoesNotCountAsResearch must equal true.');
-      }
-      if (userResearchAbsencePolicy.requireAgentLedResearchWhenAvailable !== true) {
-        validationErrors.push('designIntent.conceptualAnchor.userResearchAbsencePolicy.requireAgentLedResearchWhenAvailable must equal true.');
-      }
-    }
-    const candidateSelectionPolicy = conceptualAnchor.candidateSelectionPolicy;
-    if (!candidateSelectionPolicy || typeof candidateSelectionPolicy !== 'object') {
-      validationErrors.push('designIntent.conceptualAnchor.candidateSelectionPolicy must exist.');
-    } else {
-      if (candidateSelectionPolicy.considerAtLeast < 3) {
-        validationErrors.push('designIntent.conceptualAnchor.candidateSelectionPolicy.considerAtLeast must be at least 3.');
-      }
-      if (candidateSelectionPolicy.discardObviousCandidateCount < 2) {
-        validationErrors.push('designIntent.conceptualAnchor.candidateSelectionPolicy.discardObviousCandidateCount must be at least 2.');
-      }
-      if (candidateSelectionPolicy.minimumCandidateDistance !== 'high') {
-        validationErrors.push('designIntent.conceptualAnchor.candidateSelectionPolicy.minimumCandidateDistance must equal "high".');
-      }
-      if (candidateSelectionPolicy.discardPredictableCandidates !== true) {
-        validationErrors.push('designIntent.conceptualAnchor.candidateSelectionPolicy.discardPredictableCandidates must equal true.');
-      }
-      if (candidateSelectionPolicy.preferDistinctiveOverSafe !== true) {
-        validationErrors.push('designIntent.conceptualAnchor.candidateSelectionPolicy.preferDistinctiveOverSafe must equal true.');
-      }
-      if (candidateSelectionPolicy.doNotRevealHiddenCandidateList !== true) {
-        validationErrors.push('designIntent.conceptualAnchor.candidateSelectionPolicy.doNotRevealHiddenCandidateList must equal true.');
-      }
-      if (candidateSelectionPolicy.outputOnlyChosenAnchor !== true) {
-        validationErrors.push('designIntent.conceptualAnchor.candidateSelectionPolicy.outputOnlyChosenAnchor must equal true.');
-      }
-    }
-    const creativeCommitmentPolicy = conceptualAnchor.creativeCommitmentPolicy;
-    if (!creativeCommitmentPolicy || typeof creativeCommitmentPolicy !== 'object') {
-      validationErrors.push('designIntent.conceptualAnchor.creativeCommitmentPolicy must exist.');
-    } else {
-      if (creativeCommitmentPolicy.requiredBeforeComplianceReview !== true) {
-        validationErrors.push('designIntent.conceptualAnchor.creativeCommitmentPolicy.requiredBeforeComplianceReview must equal true.');
-      }
-      if (creativeCommitmentPolicy.recordInDesignDocs !== true) {
-        validationErrors.push('designIntent.conceptualAnchor.creativeCommitmentPolicy.recordInDesignDocs must equal true.');
-      }
-      if (
-        !Array.isArray(creativeCommitmentPolicy.requiredCommitmentFields)
-        || !creativeCommitmentPolicy.requiredCommitmentFields.includes('specificReferencePoint')
-        || !creativeCommitmentPolicy.requiredCommitmentFields.includes('signatureMotion')
-        || !creativeCommitmentPolicy.requiredCommitmentFields.includes('typographicDecision')
-      ) {
-        validationErrors.push('designIntent.conceptualAnchor.creativeCommitmentPolicy.requiredCommitmentFields must include specificReferencePoint, signatureMotion, and typographicDecision.');
-      }
-      if (creativeCommitmentPolicy.rejectGenericQualityWordsOnly !== true) {
-        validationErrors.push('designIntent.conceptualAnchor.creativeCommitmentPolicy.rejectGenericQualityWordsOnly must equal true.');
-      }
-    }
-    if (
-      !Array.isArray(conceptualAnchor.forbiddenFinalAnchorTerms)
-      || !conceptualAnchor.forbiddenFinalAnchorTerms.includes('dashboard')
-      || !conceptualAnchor.forbiddenFinalAnchorTerms.includes('cards')
-      || !conceptualAnchor.forbiddenFinalAnchorTerms.includes('safe-admin-layout')
-    ) {
-      validationErrors.push('designIntent.conceptualAnchor.forbiddenFinalAnchorTerms must reject basic UI labels.');
-    }
-    if (
-      !Array.isArray(conceptualAnchor.sourceDomains)
-      || conceptualAnchor.sourceDomains.length < 4
-      || !conceptualAnchor.sourceDomains.includes('complex-physical-engineering')
-      || !conceptualAnchor.sourceDomains.includes('cinematic-spatial-interface')
-      || !conceptualAnchor.sourceDomains.includes('premium-interactive-web-experiences')
-    ) {
-      validationErrors.push('designIntent.conceptualAnchor.sourceDomains must list broad non-template anchor domains.');
-    }
-    const visualRiskBudget = conceptualAnchor.visualRiskBudget;
-    if (!visualRiskBudget || typeof visualRiskBudget !== 'object') {
-      validationErrors.push('designIntent.conceptualAnchor.visualRiskBudget must exist.');
-    } else {
-      if (visualRiskBudget.mode !== 'high-distinctiveness-with-accessibility-and-performance-guardrails') {
-        validationErrors.push('designIntent.conceptualAnchor.visualRiskBudget.mode must preserve high-distinctiveness guardrails.');
-      }
-      if (visualRiskBudget.allowRichMotionAndMicroInteraction !== true) {
-        validationErrors.push('designIntent.conceptualAnchor.visualRiskBudget.allowRichMotionAndMicroInteraction must equal true.');
-      }
-      if (visualRiskBudget.rejectTimidDefaultWhenAnchorSupportsExpressiveUi !== true) {
-        validationErrors.push('designIntent.conceptualAnchor.visualRiskBudget.rejectTimidDefaultWhenAnchorSupportsExpressiveUi must equal true.');
-      }
-      if (visualRiskBudget.requireReducedMotionFallback !== true) {
-        validationErrors.push('designIntent.conceptualAnchor.visualRiskBudget.requireReducedMotionFallback must equal true.');
-      }
-    }
-    if (
-      !Array.isArray(conceptualAnchor.requiredDerivedAxes)
-      || !conceptualAnchor.requiredDerivedAxes.includes('typography')
-      || !conceptualAnchor.requiredDerivedAxes.includes('responsive-composition')
-    ) {
-      validationErrors.push('designIntent.conceptualAnchor.requiredDerivedAxes must include typography and responsive-composition.');
-    }
-    const finalAnchorContract = conceptualAnchor.finalAnchorContract;
-    if (!finalAnchorContract || typeof finalAnchorContract !== 'object') {
-      validationErrors.push('designIntent.conceptualAnchor.finalAnchorContract must exist.');
-    } else {
-      if (
-        !Array.isArray(finalAnchorContract.requiredFields)
-        || !finalAnchorContract.requiredFields.includes('anchorReference')
-        || !finalAnchorContract.requiredFields.includes('agentResearchMode')
-        || !finalAnchorContract.requiredFields.includes('specificReferencePoint')
-        || !finalAnchorContract.requiredFields.includes('signatureMotion')
-        || !finalAnchorContract.requiredFields.includes('typographicDecision')
-        || !finalAnchorContract.requiredFields.includes('derivedTokenLogic')
-        || !finalAnchorContract.requiredFields.includes('visualRiskBudget')
-        || !finalAnchorContract.requiredFields.includes('motionRiskBudget')
-        || !finalAnchorContract.requiredFields.includes('cohesionChecks')
-      ) {
-        validationErrors.push('designIntent.conceptualAnchor.finalAnchorContract.requiredFields must require anchorReference, agentResearchMode, specificReferencePoint, signatureMotion, typographicDecision, derivedTokenLogic, visualRiskBudget, motionRiskBudget, and cohesionChecks.');
-      }
-      if (
-        !Array.isArray(finalAnchorContract.derivedTokenLogicAxes)
-        || !finalAnchorContract.derivedTokenLogicAxes.includes('motion')
-        || !finalAnchorContract.derivedTokenLogicAxes.includes('morphology')
-      ) {
-        validationErrors.push('designIntent.conceptualAnchor.finalAnchorContract.derivedTokenLogicAxes must include motion and morphology.');
-      }
-      if (
-        !Array.isArray(finalAnchorContract.cohesionChecks)
-        || !finalAnchorContract.cohesionChecks.includes('no-dashboard-mental-model')
-        || !finalAnchorContract.cohesionChecks.includes('motion-derived-from-anchor')
-      ) {
-        validationErrors.push('designIntent.conceptualAnchor.finalAnchorContract.cohesionChecks must reject dashboard mental models and require motion derivation.');
-      }
-    }
-  }
-
-  if (!designIntentContract.mathSystems || typeof designIntentContract.mathSystems !== 'object') {
-    validationErrors.push('designIntent.mathSystems must exist.');
-  } else {
-    if (!String(designIntentContract.mathSystems.typographyScaleRatio || '').trim()) {
-      validationErrors.push('designIntent.mathSystems.typographyScaleRatio must describe the chosen or pending type scale decision.');
-    }
-    if (!String(designIntentContract.mathSystems.baseGridUnit || '').trim()) {
-      validationErrors.push('designIntent.mathSystems.baseGridUnit must describe the chosen or pending spacing grid decision.');
-    }
-  }
-
-  if (!designIntentContract.aiSafeUiAudit || typeof designIntentContract.aiSafeUiAudit !== 'object') {
-    validationErrors.push('designIntent.aiSafeUiAudit must exist.');
-  } else {
-    const aiSafeUiAudit = designIntentContract.aiSafeUiAudit;
-    if (aiSafeUiAudit.status !== 'agent-must-complete-before-ui-implementation') {
-      validationErrors.push('designIntent.aiSafeUiAudit.status must require completion before UI implementation.');
-    }
-    if (!String(aiSafeUiAudit.failureDefinition || '').includes('AI-safe')) {
-      validationErrors.push('designIntent.aiSafeUiAudit.failureDefinition must define AI-safe UI drift.');
-    }
-    if (!String(aiSafeUiAudit.interchangeabilityTest || '').includes('renamed')) {
-      validationErrors.push('designIntent.aiSafeUiAudit.interchangeabilityTest must include the rename/interchangeability test.');
-    }
-    if (!Array.isArray(aiSafeUiAudit.requiredProductSpecificSignals) || aiSafeUiAudit.requiredProductSpecificSignals.length < 3) {
-      validationErrors.push('designIntent.aiSafeUiAudit.requiredProductSpecificSignals must list at least three product-specific signals.');
-    }
-    if (!String(aiSafeUiAudit.paletteExplorationRule || '').trim()) {
-      validationErrors.push('designIntent.aiSafeUiAudit.paletteExplorationRule must be a non-empty string.');
-    }
-    if (!String(aiSafeUiAudit.backgroundPatternRule || '').trim()) {
-      validationErrors.push('designIntent.aiSafeUiAudit.backgroundPatternRule must be a non-empty string.');
-    }
-    if (!aiSafeUiAudit.aiColorAudit || typeof aiSafeUiAudit.aiColorAudit !== 'object') {
-      validationErrors.push('designIntent.aiSafeUiAudit.aiColorAudit must exist.');
-    } else {
-      if (aiSafeUiAudit.aiColorAudit.status !== 'agent-must-complete-before-ui-implementation') {
-        validationErrors.push('designIntent.aiSafeUiAudit.aiColorAudit.status must require completion before UI implementation.');
-      }
-      if (!String(aiSafeUiAudit.aiColorAudit.failureDefinition || '').includes('AI color')) {
-        validationErrors.push('designIntent.aiSafeUiAudit.aiColorAudit.failureDefinition must define AI color drift.');
-      }
-      if (!Array.isArray(aiSafeUiAudit.aiColorAudit.autopilotRisks) || aiSafeUiAudit.aiColorAudit.autopilotRisks.length < 4) {
-        validationErrors.push('designIntent.aiSafeUiAudit.aiColorAudit.autopilotRisks must list common autopilot palettes.');
-      }
-      if (!Array.isArray(aiSafeUiAudit.aiColorAudit.requiredEvidence) || aiSafeUiAudit.aiColorAudit.requiredEvidence.length < 3) {
-        validationErrors.push('designIntent.aiSafeUiAudit.aiColorAudit.requiredEvidence must list color evidence requirements.');
-      }
-      if (!String(aiSafeUiAudit.aiColorAudit.reviewQuestion || '').trim()) {
-        validationErrors.push('designIntent.aiSafeUiAudit.aiColorAudit.reviewQuestion must be a non-empty string.');
-      }
-    }
-    if (!aiSafeUiAudit.motionSpatialCourageAudit || typeof aiSafeUiAudit.motionSpatialCourageAudit !== 'object') {
-      validationErrors.push('designIntent.aiSafeUiAudit.motionSpatialCourageAudit must exist.');
-    } else {
-      if (aiSafeUiAudit.motionSpatialCourageAudit.status !== 'agent-must-complete-before-ui-implementation') {
-        validationErrors.push('designIntent.aiSafeUiAudit.motionSpatialCourageAudit.status must require completion before UI implementation.');
-      }
-      if (!String(aiSafeUiAudit.motionSpatialCourageAudit.defaultStance || '').includes('first-class options')) {
-        validationErrors.push('designIntent.aiSafeUiAudit.motionSpatialCourageAudit.defaultStance must treat motion and spatial UI as first-class options.');
-      }
-      if (!Array.isArray(aiSafeUiAudit.motionSpatialCourageAudit.requiredDecisionFields) || aiSafeUiAudit.motionSpatialCourageAudit.requiredDecisionFields.length < 3) {
-        validationErrors.push('designIntent.aiSafeUiAudit.motionSpatialCourageAudit.requiredDecisionFields must list required motion/spatial decisions.');
-      }
-      if (!String(aiSafeUiAudit.motionSpatialCourageAudit.rejectionRule || '').includes('product reason')) {
-        validationErrors.push('designIntent.aiSafeUiAudit.motionSpatialCourageAudit.rejectionRule must require a product reason before omitting spatial UI.');
-      }
-      if (!String(aiSafeUiAudit.motionSpatialCourageAudit.reviewQuestion || '').trim()) {
-        validationErrors.push('designIntent.aiSafeUiAudit.motionSpatialCourageAudit.reviewQuestion must be a non-empty string.');
-      }
-    }
-    if (!String(aiSafeUiAudit.reviewQuestion || '').trim()) {
-      validationErrors.push('designIntent.aiSafeUiAudit.reviewQuestion must be a non-empty string.');
-    }
-    if (aiSafeUiAudit.blockingByDefault !== true) {
-      validationErrors.push('designIntent.aiSafeUiAudit.blockingByDefault must equal true.');
-    }
-  }
-
-  if (!designIntentContract.tokenSystem || typeof designIntentContract.tokenSystem !== 'object') {
-    validationErrors.push('designIntent.tokenSystem must exist.');
-  } else {
-    const taxonomyOrder = designIntentContract.tokenSystem.taxonomyOrder;
-    if (!Array.isArray(taxonomyOrder) || taxonomyOrder.join('|') !== 'primitive|semantic|component') {
-      validationErrors.push('designIntent.tokenSystem.taxonomyOrder must equal ["primitive","semantic","component"].');
-    }
-    if (designIntentContract.tokenSystem.primitiveColorSpace !== 'OKLCH') {
-      validationErrors.push('designIntent.tokenSystem.primitiveColorSpace must equal "OKLCH".');
-    }
-    if (designIntentContract.tokenSystem.requireSemanticAliases !== true) {
-      validationErrors.push('designIntent.tokenSystem.requireSemanticAliases must equal true.');
-    }
-    if (designIntentContract.tokenSystem.semanticAliasesMutableWithoutComponentRewrite !== true) {
-      validationErrors.push('designIntent.tokenSystem.semanticAliasesMutableWithoutComponentRewrite must equal true.');
-    }
-    if (designIntentContract.tokenSystem.componentTokensConsumeSemantic !== true) {
-      validationErrors.push('designIntent.tokenSystem.componentTokensConsumeSemantic must equal true.');
-    }
-    const fallbackPolicy = designIntentContract.tokenSystem.fallbackPolicy;
-    if (!fallbackPolicy || typeof fallbackPolicy !== 'object') {
-      validationErrors.push('designIntent.tokenSystem.fallbackPolicy must exist.');
-    } else {
-      if (fallbackPolicy.forbidRawHexOutsidePrimitives !== true) {
-        validationErrors.push('designIntent.tokenSystem.fallbackPolicy.forbidRawHexOutsidePrimitives must equal true.');
-      }
-      if (fallbackPolicy.forbidRawSpacingOutsidePrimitives !== true) {
-        validationErrors.push('designIntent.tokenSystem.fallbackPolicy.forbidRawSpacingOutsidePrimitives must equal true.');
-      }
-      if (fallbackPolicy.requireDocumentedExceptionForLegacyBypass !== true) {
-        validationErrors.push('designIntent.tokenSystem.fallbackPolicy.requireDocumentedExceptionForLegacyBypass must equal true.');
-      }
-    }
-    const namingConstraints = designIntentContract.tokenSystem.namingConstraints;
-    if (!namingConstraints || typeof namingConstraints !== 'object') {
-      validationErrors.push('designIntent.tokenSystem.namingConstraints must exist.');
-    } else {
-      if (namingConstraints.forbidCurlyBracesInNames !== true) {
-        validationErrors.push('designIntent.tokenSystem.namingConstraints.forbidCurlyBracesInNames must equal true.');
-      }
-      if (namingConstraints.forbidDotsInNames !== true) {
-        validationErrors.push('designIntent.tokenSystem.namingConstraints.forbidDotsInNames must equal true.');
-      }
-      if (namingConstraints.forbidSquareBracketsInNames !== true) {
-        validationErrors.push('designIntent.tokenSystem.namingConstraints.forbidSquareBracketsInNames must equal true.');
-      }
-    }
-  }
-
-  if (!designIntentContract.colorTruth || typeof designIntentContract.colorTruth !== 'object') {
-    validationErrors.push('designIntent.colorTruth must exist.');
-  } else {
-    if (designIntentContract.colorTruth.format !== 'OKLCH') {
-      validationErrors.push('designIntent.colorTruth.format must equal "OKLCH".');
-    }
-    if (designIntentContract.colorTruth.allowHexDerivatives !== true) {
-      validationErrors.push('designIntent.colorTruth.allowHexDerivatives must equal true.');
-    }
-    if (!String(designIntentContract.colorTruth.intent || '').trim()) {
-      validationErrors.push('designIntent.colorTruth.intent must be a non-empty string.');
-    }
-    const paletteRoles = designIntentContract.colorTruth.paletteRoles;
-    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.');
-    }
-  }
-
-  if (!designIntentContract.crossViewportAdaptation || typeof designIntentContract.crossViewportAdaptation !== 'object') {
-    validationErrors.push('designIntent.crossViewportAdaptation must exist.');
-  } else {
-    const mutationRules = designIntentContract.crossViewportAdaptation.mutationRules;
-    if (!mutationRules || typeof mutationRules !== 'object') {
-      validationErrors.push('designIntent.crossViewportAdaptation.mutationRules must exist.');
-    } else {
-      for (const viewportKey of ['mobile', 'tablet', 'desktop']) {
-        if (!String(mutationRules[viewportKey] || '').trim()) {
-          validationErrors.push(`designIntent.crossViewportAdaptation.mutationRules.${viewportKey} must be a non-empty string.`);
-        }
-      }
-    }
-  }
-
-  if (!designIntentContract.motionSystem || typeof designIntentContract.motionSystem !== 'object') {
-    validationErrors.push('designIntent.motionSystem must exist.');
-  } else {
-    if (designIntentContract.motionSystem.allowMeaningfulMotion !== true) {
-      validationErrors.push('designIntent.motionSystem.allowMeaningfulMotion must equal true.');
-    }
-    if (!String(designIntentContract.motionSystem.purpose || '').trim()) {
-      validationErrors.push('designIntent.motionSystem.purpose must be a non-empty string.');
-    }
-    if (designIntentContract.motionSystem.respectReducedMotion !== true) {
-      validationErrors.push('designIntent.motionSystem.respectReducedMotion must equal true.');
-    }
-  }
-
-  if (!designIntentContract.componentMorphology || typeof designIntentContract.componentMorphology !== 'object') {
-    validationErrors.push('designIntent.componentMorphology must exist.');
-  } else {
-    if (designIntentContract.componentMorphology.requireStateBehaviorMatrix !== true) {
-      validationErrors.push('designIntent.componentMorphology.requireStateBehaviorMatrix must equal true.');
-    }
-    if (!Array.isArray(designIntentContract.componentMorphology.stateKeys) || designIntentContract.componentMorphology.stateKeys.length < 4) {
-      validationErrors.push('designIntent.componentMorphology.stateKeys must contain multiple interaction states.');
-    }
-    const viewportBehavior = designIntentContract.componentMorphology.viewportBehavior;
-    if (!viewportBehavior || typeof viewportBehavior !== 'object') {
-      validationErrors.push('designIntent.componentMorphology.viewportBehavior must exist.');
-    } else {
-      for (const viewportKey of ['mobile', 'tablet', 'desktop']) {
-        if (!String(viewportBehavior[viewportKey] || '').trim()) {
-          validationErrors.push(`designIntent.componentMorphology.viewportBehavior.${viewportKey} must be a non-empty string.`);
-        }
-      }
-    }
-  }
-
-  if (!designIntentContract.accessibilityPolicy || typeof designIntentContract.accessibilityPolicy !== 'object') {
-    validationErrors.push('designIntent.accessibilityPolicy must exist.');
-  } else {
-    if (designIntentContract.accessibilityPolicy.hardComplianceFloor !== 'WCAG-2.2-AA') {
-      validationErrors.push('designIntent.accessibilityPolicy.hardComplianceFloor must equal "WCAG-2.2-AA".');
-    }
-    if (designIntentContract.accessibilityPolicy.advisoryContrastModel !== 'APCA') {
-      validationErrors.push('designIntent.accessibilityPolicy.advisoryContrastModel must equal "APCA".');
-    }
-    if (designIntentContract.accessibilityPolicy.failOnHardViolations !== true) {
-      validationErrors.push('designIntent.accessibilityPolicy.failOnHardViolations must equal true.');
-    }
-    if (designIntentContract.accessibilityPolicy.advisoryFindingsDoNotBlockByDefault !== true) {
-      validationErrors.push('designIntent.accessibilityPolicy.advisoryFindingsDoNotBlockByDefault must equal true.');
-    }
-    const hardRequirements = designIntentContract.accessibilityPolicy.hardRequirements;
-    if (!hardRequirements || typeof hardRequirements !== 'object') {
-      validationErrors.push('designIntent.accessibilityPolicy.hardRequirements must exist.');
-    } else {
-      for (const requirementKey of [
-        'textContrastMinimum',
-        'nonTextContrast',
-        'useOfColorOnlyProhibited',
-        'focusVisible',
-        'focusAppearance',
-        'targetSizeMinimum',
-        'keyboardAccess',
-        'reflowRequired',
-        'accessibleAuthenticationMinimum',
-        'statusMessagesAndDynamicStateAccess',
-      ]) {
-        if (hardRequirements[requirementKey] !== true) {
-          validationErrors.push(`designIntent.accessibilityPolicy.hardRequirements.${requirementKey} must equal true.`);
-        }
-      }
-    }
-    const advisoryChecks = designIntentContract.accessibilityPolicy.advisoryChecks;
-    if (!advisoryChecks || typeof advisoryChecks !== 'object') {
-      validationErrors.push('designIntent.accessibilityPolicy.advisoryChecks must exist.');
-    } else {
-      for (const advisoryKey of [
-        'perceptualContrastReview',
-        'darkModeContrastTuning',
-        'typographyReadabilityTuning',
-      ]) {
-        if (advisoryChecks[advisoryKey] !== true) {
-          validationErrors.push(`designIntent.accessibilityPolicy.advisoryChecks.${advisoryKey} must equal true.`);
-        }
-      }
-    }
-  }
-
-  if (!designIntentContract.contextHygiene || typeof designIntentContract.contextHygiene !== 'object') {
-    validationErrors.push('designIntent.contextHygiene must exist.');
-  } else {
-    if (designIntentContract.contextHygiene.continuityMode !== 'opt-in-only') {
-      validationErrors.push('designIntent.contextHygiene.continuityMode must equal "opt-in-only".');
-    }
-    if (designIntentContract.contextHygiene.repoEvidenceOverridesMemory !== true) {
-      validationErrors.push('designIntent.contextHygiene.repoEvidenceOverridesMemory must equal true.');
-    }
-    if (designIntentContract.contextHygiene.requireExplicitContinuityApproval !== true) {
-      validationErrors.push('designIntent.contextHygiene.requireExplicitContinuityApproval must equal true.');
-    }
-    if (designIntentContract.contextHygiene.forbidCarryoverWhenUnapproved !== true) {
-      validationErrors.push('designIntent.contextHygiene.forbidCarryoverWhenUnapproved must equal true.');
-    }
-    if (!Array.isArray(designIntentContract.contextHygiene.allowedSources) || designIntentContract.contextHygiene.allowedSources.length < 4) {
-      validationErrors.push('designIntent.contextHygiene.allowedSources must list the approved design evidence sources.');
-    }
-    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.approvedExternalConstraintUsage || '').trim()) {
-      validationErrors.push('designIntent.contextHygiene.approvedExternalConstraintUsage must be a non-empty string.');
-    }
-  }
-
-  if (!designIntentContract.designExecutionPolicy || typeof designIntentContract.designExecutionPolicy !== 'object') {
-    validationErrors.push('designIntent.designExecutionPolicy must exist.');
-  } else {
-    if (designIntentContract.designExecutionPolicy.representationStrategy !== 'surface-plan-v1') {
-      validationErrors.push('designIntent.designExecutionPolicy.representationStrategy must equal "surface-plan-v1".');
-    }
-    for (const requiredFlagName of [
-      'requireSurfacePlan',
-      'requireComponentGraph',
-      'requireViewportMutationPlan',
-      'requireInteractionStateMatrix',
-      'requireContentPriorityMap',
-      'requireTaskFlowNarrative',
-      'requireSignatureMoveRationale',
-      'requireCreativeCommitmentGate',
-      'requireStructuredHandoff',
-      'requireRepoEvidenceAlignment',
-      'forbidScreenshotDependency',
-      'requirePerSurfaceMutationOps',
-      'forbidUniformSiblingSurfaceTreatment',
-      'zeroBasedRedesignResetsPriorVisualsWhenRequested',
-    ]) {
-      if (designIntentContract.designExecutionPolicy[requiredFlagName] !== true) {
-        validationErrors.push(`designIntent.designExecutionPolicy.${requiredFlagName} must equal true.`);
-      }
-    }
-    if (designIntentContract.designExecutionPolicy.handoffFormatVersion !== 'ui-handoff-v1') {
-      validationErrors.push('designIntent.designExecutionPolicy.handoffFormatVersion must equal "ui-handoff-v1".');
-    }
-    if (
-      !Array.isArray(designIntentContract.designExecutionPolicy.semanticReviewFocus)
-      || designIntentContract.designExecutionPolicy.semanticReviewFocus.length < 4
-    ) {
-      validationErrors.push('designIntent.designExecutionPolicy.semanticReviewFocus must list the required review dimensions.');
-    }
-  }
-
-  if (!designIntentContract.designExecutionHandoff || typeof designIntentContract.designExecutionHandoff !== 'object') {
-    validationErrors.push('designIntent.designExecutionHandoff must exist.');
-  } else {
-    if (designIntentContract.designExecutionHandoff.version !== 'ui-handoff-v1') {
-      validationErrors.push('designIntent.designExecutionHandoff.version must equal "ui-handoff-v1".');
-    }
-    if (designIntentContract.designExecutionHandoff.seedMode !== 'structure-first-scaffold') {
-      validationErrors.push('designIntent.designExecutionHandoff.seedMode must equal "structure-first-scaffold".');
-    }
-    if (designIntentContract.designExecutionHandoff.requiresTaskSpecificRefinement !== true) {
-      validationErrors.push('designIntent.designExecutionHandoff.requiresTaskSpecificRefinement must equal true.');
-    }
-    if (!String(designIntentContract.designExecutionHandoff.primaryExperienceGoal || '').trim()) {
-      validationErrors.push('designIntent.designExecutionHandoff.primaryExperienceGoal must be a non-empty string.');
-    }
-    if (!Array.isArray(designIntentContract.designExecutionHandoff.surfacePlan) || designIntentContract.designExecutionHandoff.surfacePlan.length < 1) {
-      validationErrors.push('designIntent.designExecutionHandoff.surfacePlan must define at least one planned surface.');
-    }
-    const componentGraph = designIntentContract.designExecutionHandoff.componentGraph;
-    if (!componentGraph || typeof componentGraph !== 'object') {
-      validationErrors.push('designIntent.designExecutionHandoff.componentGraph must exist.');
-    } else {
-      if (!Array.isArray(componentGraph.nodes) || componentGraph.nodes.length < 2) {
-        validationErrors.push('designIntent.designExecutionHandoff.componentGraph.nodes must list the primary execution nodes.');
-      }
-      if (!Array.isArray(componentGraph.edges) || componentGraph.edges.length < 1) {
-        validationErrors.push('designIntent.designExecutionHandoff.componentGraph.edges must define relationships between UI nodes.');
-      }
-    }
-    const contentPriorityMap = designIntentContract.designExecutionHandoff.contentPriorityMap;
-    if (!contentPriorityMap || typeof contentPriorityMap !== 'object') {
-      validationErrors.push('designIntent.designExecutionHandoff.contentPriorityMap must exist.');
-    } else {
-      for (const priorityBucket of ['primary', 'secondary', 'deferred']) {
-        if (!Array.isArray(contentPriorityMap[priorityBucket]) || contentPriorityMap[priorityBucket].length < 1) {
-          validationErrors.push(`designIntent.designExecutionHandoff.contentPriorityMap.${priorityBucket} must contain at least one item.`);
-        }
-      }
-    }
-    const viewportMutationPlan = designIntentContract.designExecutionHandoff.viewportMutationPlan;
-    if (!viewportMutationPlan || typeof viewportMutationPlan !== 'object') {
-      validationErrors.push('designIntent.designExecutionHandoff.viewportMutationPlan must exist.');
-    } else {
-      for (const viewportKey of ['mobile', 'tablet', 'desktop']) {
-        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.`);
-        }
-      }
-    }
-    if (!Array.isArray(designIntentContract.designExecutionHandoff.interactionStateMatrix) || designIntentContract.designExecutionHandoff.interactionStateMatrix.length < 1) {
-      validationErrors.push('designIntent.designExecutionHandoff.interactionStateMatrix must list key component state expectations.');
-    }
-    if (!Array.isArray(designIntentContract.designExecutionHandoff.taskFlowNarrative) || designIntentContract.designExecutionHandoff.taskFlowNarrative.length < 2) {
-      validationErrors.push('designIntent.designExecutionHandoff.taskFlowNarrative must describe the key UI task flow in sequence.');
-    }
-    if (!String(designIntentContract.designExecutionHandoff.signatureMoveRationale || '').trim()) {
-      validationErrors.push('designIntent.designExecutionHandoff.signatureMoveRationale must explain the chosen authored move.');
-    }
-    const creativeCommitment = designIntentContract.designExecutionHandoff.creativeCommitment;
-    if (!creativeCommitment || typeof creativeCommitment !== 'object') {
-      validationErrors.push('designIntent.designExecutionHandoff.creativeCommitment must exist.');
-    } else {
-      if (creativeCommitment.status !== 'agent-must-complete-before-ui-implementation') {
-        validationErrors.push('designIntent.designExecutionHandoff.creativeCommitment.status must equal "agent-must-complete-before-ui-implementation".');
-      }
-      if (
-        !Array.isArray(creativeCommitment.requiredFields)
-        || !creativeCommitment.requiredFields.includes('specificReferencePoint')
-        || !creativeCommitment.requiredFields.includes('signatureMotion')
-        || !creativeCommitment.requiredFields.includes('typographicDecision')
-      ) {
-        validationErrors.push('designIntent.designExecutionHandoff.creativeCommitment.requiredFields must include specificReferencePoint, signatureMotion, and typographicDecision.');
-      }
-      if (!hasNonEmptyString(creativeCommitment.failureMode)) {
-        validationErrors.push('designIntent.designExecutionHandoff.creativeCommitment.failureMode must be a non-empty string.');
-      }
-    }
-    const implementationGuardrails = designIntentContract.designExecutionHandoff.implementationGuardrails;
-    if (!implementationGuardrails || typeof implementationGuardrails !== 'object') {
-      validationErrors.push('designIntent.designExecutionHandoff.implementationGuardrails must exist.');
-    } else {
-      for (const requiredFlagName of [
-        'requireBuildFromHandoff',
-        'requireGapNotesBeforeFallback',
-        'forbidGenericLayoutFallbackWithoutReason',
-      ]) {
-        if (implementationGuardrails[requiredFlagName] !== true) {
-          validationErrors.push(`designIntent.designExecutionHandoff.implementationGuardrails.${requiredFlagName} must equal true.`);
-        }
-      }
-    }
-  }
-
-  if (!designIntentContract.reviewRubric || typeof designIntentContract.reviewRubric !== 'object') {
-    validationErrors.push('designIntent.reviewRubric must exist.');
-  } else {
-    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 {
-      for (const requiredRubricKey of [
-        'distinctiveness',
-        'contractFidelity',
-        'visualConsistency',
-        'heuristicUxQuality',
-        'motionDiscipline',
-      ]) {
-        if (!designIntentContract.reviewRubric.dimensions.some((dimension) => dimension?.key === requiredRubricKey)) {
-          validationErrors.push(`designIntent.reviewRubric.dimensions is missing "${requiredRubricKey}".`);
-        }
-      }
-    }
-    if (!Array.isArray(designIntentContract.reviewRubric.genericitySignals) || designIntentContract.reviewRubric.genericitySignals.length < 3) {
-      validationErrors.push('designIntent.reviewRubric.genericitySignals must list common genericity drift signals.');
-    } else {
-      for (const requiredSignal of [
-        'ai-safe-ui-template-look',
-        'ai-color-default-palette-without-product-role-behavior',
-        'interchangeable-product-renaming-test-fails',
-        'decorative-grid-or-glow-wallpaper-without-product-function',
-        'motion-or-3d-omitted-from-fear-without-fit-analysis',
-      ]) {
-        if (!designIntentContract.reviewRubric.genericitySignals.includes(requiredSignal)) {
-          validationErrors.push(`designIntent.reviewRubric.genericitySignals must include "${requiredSignal}".`);
-        }
-      }
-    }
-    if (!Array.isArray(designIntentContract.reviewRubric.validBoldSignals) || designIntentContract.reviewRubric.validBoldSignals.length < 3) {
-      validationErrors.push('designIntent.reviewRubric.validBoldSignals must list legitimate authored signals.');
-    } else {
-      for (const requiredSignal of [
-        'three-at-a-glance-product-specific-signals',
-        'visually-exploratory-accessible-palette-derived-from-product',
-        'audacious-accessible-palette-with-product-role-behavior',
-        'motion-or-spatial-experience-derived-from-anchor',
-      ]) {
-        if (!designIntentContract.reviewRubric.validBoldSignals.includes(requiredSignal)) {
-          validationErrors.push(`designIntent.reviewRubric.validBoldSignals must include "${requiredSignal}".`);
-        }
-      }
-    }
-    if (!designIntentContract.reviewRubric.reportingRules || typeof designIntentContract.reviewRubric.reportingRules !== 'object') {
-      validationErrors.push('designIntent.reviewRubric.reportingRules must exist.');
-    } else {
-      for (const requiredFlagName of [
-        'mustExplainGenericity',
-        'mustSeparateTasteFromFailure',
-        'contractFidelityOverridesPersonalTaste',
-      ]) {
-        if (designIntentContract.reviewRubric.reportingRules[requiredFlagName] !== true) {
-          validationErrors.push(`designIntent.reviewRubric.reportingRules.${requiredFlagName} must equal true.`);
-        }
-      }
-    }
-  }
-
-  if (!Array.isArray(designIntentContract.requiredDesignSections) || designIntentContract.requiredDesignSections.length !== DESIGN_REQUIRED_SECTIONS.length) {
-    validationErrors.push('designIntent.requiredDesignSections must match the required design contract sections.');
-  } else {
-    for (const requiredSectionName of DESIGN_REQUIRED_SECTIONS) {
-      if (!designIntentContract.requiredDesignSections.includes(requiredSectionName)) {
-        validationErrors.push(`designIntent.requiredDesignSections is missing "${requiredSectionName}".`);
-      }
-    }
-  }
-
-  if (!Array.isArray(designIntentContract.forbiddenPatterns) || designIntentContract.forbiddenPatterns.length < 4) {
-    validationErrors.push('designIntent.forbiddenPatterns must list concrete anti-generic patterns.');
-  } else {
-    for (const requiredPattern of [
-      'ai-safe-ui-template-look',
-      'ai-color-default-palette-without-product-role-behavior',
-      'interchangeable-product-renaming-test-fails',
-      'decorative-grid-or-glow-wallpaper-without-product-function',
-      'motion-or-3d-omitted-from-fear-without-fit-analysis',
-    ]) {
-      if (!designIntentContract.forbiddenPatterns.includes(requiredPattern)) {
-        validationErrors.push(`designIntent.forbiddenPatterns must include "${requiredPattern}".`);
-      }
-    }
-  }
-
-  return validationErrors;
-}
+export { validateDesignContractCompleteness, validateDesignIntentContract } from './design-contract/validation.mjs';
 
 export function buildDesignIntentSeedFromSignals({
   projectName,