@ryuenn3123/agentic-senior-core 3.0.50 → 4.0.0

package/lib/cli/project-scaffolder/design-contract/validation/execution-validators.mjs

@@ -0,0 +1,328 @@
+/**
+ * Validators for the design execution policy, the structured execution
+ * handoff, the review rubric, the required design sections list, and the
+ * forbidden patterns list. These collectively gate the structured handoff
+ * payload that downstream UI judges and review tooling consume.
+ */
+
+import { hasNonEmptyString } from './helpers.mjs';
+import { DESIGN_REQUIRED_SECTIONS } from '../../constants.mjs';
+
+export function validateDesignExecutionPolicy(designIntentContract, validationErrors) {
+  if (!designIntentContract.designExecutionPolicy || typeof designIntentContract.designExecutionPolicy !== 'object') {
+    validationErrors.push('designIntent.designExecutionPolicy must exist.');
+    return validationErrors;
+  }
+  const designExecutionPolicy = designIntentContract.designExecutionPolicy;
+  if (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',
+    'separateRequiredOutcomesFromCandidateMoves',
+    'forbidCandidateMovesAsLockedRequirements',
+    'forbidLibraryThemeAsVisualAuthority',
+    'forbidLiteralAnchorChromeWithoutProductFunction',
+    'requirePerSurfaceMutationOps',
+    'forbidUniformSiblingSurfaceTreatment',
+    'zeroBasedRedesignResetsPriorVisualsWhenRequested',
+  ]) {
+    if (designExecutionPolicy[requiredFlagName] !== true) {
+      validationErrors.push(`designIntent.designExecutionPolicy.${requiredFlagName} must equal true.`);
+    }
+  }
+  if (designExecutionPolicy.handoffFormatVersion !== 'ui-handoff-v1') {
+    validationErrors.push('designIntent.designExecutionPolicy.handoffFormatVersion must equal "ui-handoff-v1".');
+  }
+  if (
+    !Array.isArray(designExecutionPolicy.semanticReviewFocus)
+    || designExecutionPolicy.semanticReviewFocus.length < 4
+  ) {
+    validationErrors.push('designIntent.designExecutionPolicy.semanticReviewFocus must list the required review dimensions.');
+  }
+  return validationErrors;
+}
+
+function validateHandoffComponentGraph(designExecutionHandoff, validationErrors) {
+  const componentGraph = designExecutionHandoff.componentGraph;
+  if (!componentGraph || typeof componentGraph !== 'object') {
+    validationErrors.push('designIntent.designExecutionHandoff.componentGraph must exist.');
+    return;
+  }
+  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.');
+  }
+}
+
+function validateHandoffContentPriorityMap(designExecutionHandoff, validationErrors) {
+  const contentPriorityMap = designExecutionHandoff.contentPriorityMap;
+  if (!contentPriorityMap || typeof contentPriorityMap !== 'object') {
+    validationErrors.push('designIntent.designExecutionHandoff.contentPriorityMap must exist.');
+    return;
+  }
+  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.`);
+    }
+  }
+}
+
+function validateHandoffViewportMutationPlan(designExecutionHandoff, validationErrors) {
+  const viewportMutationPlan = designExecutionHandoff.viewportMutationPlan;
+  if (!viewportMutationPlan || typeof viewportMutationPlan !== 'object') {
+    validationErrors.push('designIntent.designExecutionHandoff.viewportMutationPlan must exist.');
+    return;
+  }
+  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.`);
+    }
+  }
+}
+
+function validateHandoffExpressionFlexibility(designExecutionHandoff, validationErrors) {
+  const expressionFlexibility = designExecutionHandoff.expressionFlexibility;
+  if (!expressionFlexibility || typeof expressionFlexibility !== 'object') {
+    validationErrors.push('designIntent.designExecutionHandoff.expressionFlexibility must exist.');
+    return;
+  }
+  if (!Array.isArray(expressionFlexibility.lockedOutcomes) || expressionFlexibility.lockedOutcomes.length < 3) {
+    validationErrors.push('designIntent.designExecutionHandoff.expressionFlexibility.lockedOutcomes must list locked outcomes.');
+  }
+  if (!Array.isArray(expressionFlexibility.candidateSignatureMoves) || expressionFlexibility.candidateSignatureMoves.length < 1) {
+    validationErrors.push('designIntent.designExecutionHandoff.expressionFlexibility.candidateSignatureMoves must include at least one candidate move placeholder.');
+  }
+  if (!Array.isArray(expressionFlexibility.flexibleAxes) || expressionFlexibility.flexibleAxes.length < 4) {
+    validationErrors.push('designIntent.designExecutionHandoff.expressionFlexibility.flexibleAxes must list flexible implementation axes.');
+  }
+  if (!String(expressionFlexibility.lockingRule || '').includes('candidate')) {
+    validationErrors.push('designIntent.designExecutionHandoff.expressionFlexibility.lockingRule must explain when candidate moves become required.');
+  }
+}
+
+function validateHandoffCreativeCommitment(designExecutionHandoff, validationErrors) {
+  const creativeCommitment = designExecutionHandoff.creativeCommitment;
+  if (!creativeCommitment || typeof creativeCommitment !== 'object') {
+    validationErrors.push('designIntent.designExecutionHandoff.creativeCommitment must exist.');
+    return;
+  }
+  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.');
+  }
+}
+
+function validateHandoffImplementationGuardrails(designExecutionHandoff, validationErrors) {
+  const implementationGuardrails = designExecutionHandoff.implementationGuardrails;
+  if (!implementationGuardrails || typeof implementationGuardrails !== 'object') {
+    validationErrors.push('designIntent.designExecutionHandoff.implementationGuardrails must exist.');
+    return;
+  }
+  for (const requiredFlagName of [
+    'requireBuildFromHandoff',
+    'requireGapNotesBeforeFallback',
+    'forbidGenericLayoutFallbackWithoutReason',
+    'requireLockedVsFlexibleDecisionReview',
+    'forbidCandidateMoveHardcoding',
+    'forbidTestingDemoCopyInUi',
+    'forbidTerminalOnlyUserFlows',
+  ]) {
+    if (implementationGuardrails[requiredFlagName] !== true) {
+      validationErrors.push(`designIntent.designExecutionHandoff.implementationGuardrails.${requiredFlagName} must equal true.`);
+    }
+  }
+}
+
+export function validateDesignExecutionHandoff(designIntentContract, validationErrors) {
+  if (!designIntentContract.designExecutionHandoff || typeof designIntentContract.designExecutionHandoff !== 'object') {
+    validationErrors.push('designIntent.designExecutionHandoff must exist.');
+    return validationErrors;
+  }
+
+  const designExecutionHandoff = designIntentContract.designExecutionHandoff;
+  if (designExecutionHandoff.version !== 'ui-handoff-v1') {
+    validationErrors.push('designIntent.designExecutionHandoff.version must equal "ui-handoff-v1".');
+  }
+  if (designExecutionHandoff.seedMode !== 'structure-first-scaffold') {
+    validationErrors.push('designIntent.designExecutionHandoff.seedMode must equal "structure-first-scaffold".');
+  }
+  if (designExecutionHandoff.requiresTaskSpecificRefinement !== true) {
+    validationErrors.push('designIntent.designExecutionHandoff.requiresTaskSpecificRefinement must equal true.');
+  }
+  if (!String(designExecutionHandoff.primaryExperienceGoal || '').trim()) {
+    validationErrors.push('designIntent.designExecutionHandoff.primaryExperienceGoal must be a non-empty string.');
+  }
+  if (!Array.isArray(designExecutionHandoff.surfacePlan) || designExecutionHandoff.surfacePlan.length < 1) {
+    validationErrors.push('designIntent.designExecutionHandoff.surfacePlan must define at least one planned surface.');
+  }
+
+  validateHandoffComponentGraph(designExecutionHandoff, validationErrors);
+  validateHandoffContentPriorityMap(designExecutionHandoff, validationErrors);
+  validateHandoffViewportMutationPlan(designExecutionHandoff, validationErrors);
+
+  if (!Array.isArray(designExecutionHandoff.interactionStateMatrix) || designExecutionHandoff.interactionStateMatrix.length < 1) {
+    validationErrors.push('designIntent.designExecutionHandoff.interactionStateMatrix must list key component state expectations.');
+  }
+
+  validateHandoffExpressionFlexibility(designExecutionHandoff, validationErrors);
+
+  if (!Array.isArray(designExecutionHandoff.taskFlowNarrative) || designExecutionHandoff.taskFlowNarrative.length < 2) {
+    validationErrors.push('designIntent.designExecutionHandoff.taskFlowNarrative must describe the key UI task flow in sequence.');
+  }
+  if (!String(designExecutionHandoff.signatureMoveRationale || '').trim()) {
+    validationErrors.push('designIntent.designExecutionHandoff.signatureMoveRationale must explain the chosen authored move.');
+  }
+
+  validateHandoffCreativeCommitment(designExecutionHandoff, validationErrors);
+  validateHandoffImplementationGuardrails(designExecutionHandoff, validationErrors);
+  return validationErrors;
+}
+
+export function validateReviewRubric(designIntentContract, validationErrors) {
+  if (!designIntentContract.reviewRubric || typeof designIntentContract.reviewRubric !== 'object') {
+    validationErrors.push('designIntent.reviewRubric must exist.');
+    return validationErrors;
+  }
+  const reviewRubric = designIntentContract.reviewRubric;
+  if (reviewRubric.version !== 'ui-rubric-v1') {
+    validationErrors.push('designIntent.reviewRubric.version must equal "ui-rubric-v1".');
+  }
+  if (reviewRubric.genericityAutoFail !== true) {
+    validationErrors.push('designIntent.reviewRubric.genericityAutoFail must equal true.');
+  }
+  if (!Array.isArray(reviewRubric.dimensions) || 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 (!reviewRubric.dimensions.some((dimension) => dimension?.key === requiredRubricKey)) {
+        validationErrors.push(`designIntent.reviewRubric.dimensions is missing "${requiredRubricKey}".`);
+      }
+    }
+  }
+  if (!Array.isArray(reviewRubric.genericitySignals) || 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',
+      'decorative-line-or-calibration-wallpaper-without-product-function',
+      'measurement-or-calibration-marks-used-as-page-background',
+      'testing-demo-or-placeholder-copy-shipped-to-ui',
+      'terminal-only-user-flow-without-product-reason',
+      'motion-or-3d-omitted-from-fear-without-fit-analysis',
+    ]) {
+      if (!reviewRubric.genericitySignals.includes(requiredSignal)) {
+        validationErrors.push(`designIntent.reviewRubric.genericitySignals must include "${requiredSignal}".`);
+      }
+    }
+  }
+  if (!Array.isArray(reviewRubric.validBoldSignals) || 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 (!reviewRubric.validBoldSignals.includes(requiredSignal)) {
+        validationErrors.push(`designIntent.reviewRubric.validBoldSignals must include "${requiredSignal}".`);
+      }
+    }
+  }
+  if (!reviewRubric.reportingRules || typeof reviewRubric.reportingRules !== 'object') {
+    validationErrors.push('designIntent.reviewRubric.reportingRules must exist.');
+    return validationErrors;
+  }
+  for (const requiredFlagName of [
+    'mustExplainGenericity',
+    'mustSeparateTasteFromFailure',
+    'contractFidelityOverridesPersonalTaste',
+  ]) {
+    if (reviewRubric.reportingRules[requiredFlagName] !== true) {
+      validationErrors.push(`designIntent.reviewRubric.reportingRules.${requiredFlagName} must equal true.`);
+    }
+  }
+  return validationErrors;
+}
+
+export function validateRequiredSectionsAndForbiddenPatterns(designIntentContract, validationErrors) {
+  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.');
+    return validationErrors;
+  }
+  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',
+    'decorative-line-or-calibration-wallpaper-without-product-function',
+    'measurement-or-calibration-marks-used-as-page-background',
+    'testing-demo-or-placeholder-copy-shipped-to-ui',
+    'terminal-only-user-flow-without-product-reason',
+    'motion-or-3d-omitted-from-fear-without-fit-analysis',
+  ]) {
+    if (!designIntentContract.forbiddenPatterns.includes(requiredPattern)) {
+      validationErrors.push(`designIntent.forbiddenPatterns must include "${requiredPattern}".`);
+    }
+  }
+  return validationErrors;
+}

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

@@ -0,0 +1,8 @@
+/**
+ * Tiny validator helpers shared across the design contract validation
+ * sub-modules. Pure, side-effect free.
+ */
+
+export function hasNonEmptyString(value) {
+  return typeof value === 'string' && value.trim().length > 0;
+}

package/lib/cli/project-scaffolder/design-contract/validation/structural-validators.mjs

@@ -0,0 +1,79 @@
+/**
+ * Structural-shape validators for the design intent contract: top-level mode,
+ * project block, design philosophy, external research intake, and the design
+ * flexibility policy. Each validator pushes its findings onto the shared error
+ * accumulator and returns it.
+ */
+
+import { hasNonEmptyString } from './helpers.mjs';
+
+export function validateModeAndProjectShape(designIntentContract, validationErrors) {
+  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.');
+  }
+  return validationErrors;
+}
+
+export function validateExternalResearchIntake(designIntentContract, validationErrors) {
+  if (!designIntentContract.externalResearchIntake || typeof designIntentContract.externalResearchIntake !== 'object') {
+    validationErrors.push('designIntent.externalResearchIntake must exist.');
+    return validationErrors;
+  }
+
+  const externalResearchIntake = designIntentContract.externalResearchIntake;
+  if (externalResearchIntake.userSuppliedResearchPolicy !== 'read-as-candidate-evidence-not-final-prescription') {
+    validationErrors.push('designIntent.externalResearchIntake.userSuppliedResearchPolicy must preserve user research as candidate evidence.');
+  }
+  if (externalResearchIntake.requireOfficialDocsVerificationForTechnologyClaims !== true) {
+    validationErrors.push('designIntent.externalResearchIntake.requireOfficialDocsVerificationForTechnologyClaims must equal true.');
+  }
+  if (
+    !Array.isArray(externalResearchIntake.candidateDomains)
+    || !externalResearchIntake.candidateDomains.includes('motion-and-scroll')
+  ) {
+    validationErrors.push('designIntent.externalResearchIntake.candidateDomains must include motion-and-scroll.');
+  }
+  return validationErrors;
+}
+
+export function validateDesignFlexibilityPolicy(designIntentContract, validationErrors) {
+  if (!designIntentContract.designFlexibilityPolicy || typeof designIntentContract.designFlexibilityPolicy !== 'object') {
+    validationErrors.push('designIntent.designFlexibilityPolicy must exist.');
+    return validationErrors;
+  }
+
+  const designFlexibilityPolicy = designIntentContract.designFlexibilityPolicy;
+  if (designFlexibilityPolicy.mode !== 'locked-outcomes-flexible-expression') {
+    validationErrors.push('designIntent.designFlexibilityPolicy.mode must equal "locked-outcomes-flexible-expression".');
+  }
+  if (!hasNonEmptyString(designFlexibilityPolicy.contractRole)) {
+    validationErrors.push('designIntent.designFlexibilityPolicy.contractRole must be a non-empty string.');
+  }
+  if (!Array.isArray(designFlexibilityPolicy.lockedOutcomeTypes) || designFlexibilityPolicy.lockedOutcomeTypes.length < 4) {
+    validationErrors.push('designIntent.designFlexibilityPolicy.lockedOutcomeTypes must list the locked outcome categories.');
+  }
+  if (!Array.isArray(designFlexibilityPolicy.flexibleExpressionAxes) || designFlexibilityPolicy.flexibleExpressionAxes.length < 4) {
+    validationErrors.push('designIntent.designFlexibilityPolicy.flexibleExpressionAxes must list flexible expression axes.');
+  }
+  if (!hasNonEmptyString(designFlexibilityPolicy.tokenLockingRule)) {
+    validationErrors.push('designIntent.designFlexibilityPolicy.tokenLockingRule must be a non-empty string.');
+  }
+  if (!String(designFlexibilityPolicy.signatureMovePolicy || '').includes('candidate')) {
+    validationErrors.push('designIntent.designFlexibilityPolicy.signatureMovePolicy must separate candidate moves from required outcomes.');
+  }
+  if (!String(designFlexibilityPolicy.libraryVisualLanguagePolicy || '').includes('Libraries supply')) {
+    validationErrors.push('designIntent.designFlexibilityPolicy.libraryVisualLanguagePolicy must keep libraries from dictating visual language.');
+  }
+  if (!String(designFlexibilityPolicy.literalAnchorPolicy || '').includes('Translate anchors')) {
+    validationErrors.push('designIntent.designFlexibilityPolicy.literalAnchorPolicy must require non-literal anchor translation.');
+  }
+  return validationErrors;
+}

package/lib/cli/project-scaffolder/design-contract/validation/system-validators.mjs

@@ -0,0 +1,256 @@
+/**
+ * Validators for token system, color truth, viewport adaptation, motion
+ * system, component morphology, accessibility policy, and context hygiene
+ * sections. These cover the structured systems that drive UI implementation.
+ */
+
+import { hasNonEmptyString } from './helpers.mjs';
+
+function validateTokenLockingPolicy(tokenSystem, validationErrors) {
+  const tokenLockingPolicy = tokenSystem.tokenLockingPolicy;
+  if (!tokenLockingPolicy || typeof tokenLockingPolicy !== 'object') {
+    validationErrors.push('designIntent.tokenSystem.tokenLockingPolicy must exist.');
+    return;
+  }
+  if (tokenLockingPolicy.defaultLockState !== 'semantic-roles-locked-primitives-flexible') {
+    validationErrors.push('designIntent.tokenSystem.tokenLockingPolicy.defaultLockState must preserve semantic roles while keeping primitives flexible.');
+  }
+  if (!Array.isArray(tokenLockingPolicy.flexibleByDefault) || tokenLockingPolicy.flexibleByDefault.length < 4) {
+    validationErrors.push('designIntent.tokenSystem.tokenLockingPolicy.flexibleByDefault must list flexible primitive axes.');
+  }
+  if (!hasNonEmptyString(tokenLockingPolicy.promotionRule)) {
+    validationErrors.push('designIntent.tokenSystem.tokenLockingPolicy.promotionRule must be a non-empty string.');
+  }
+}
+
+function validateTokenFallbackAndNaming(tokenSystem, validationErrors) {
+  const fallbackPolicy = 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 = tokenSystem.namingConstraints;
+  if (!namingConstraints || typeof namingConstraints !== 'object') {
+    validationErrors.push('designIntent.tokenSystem.namingConstraints must exist.');
+    return;
+  }
+  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.');
+  }
+}
+
+export function validateTokenSystem(designIntentContract, validationErrors) {
+  if (!designIntentContract.tokenSystem || typeof designIntentContract.tokenSystem !== 'object') {
+    validationErrors.push('designIntent.tokenSystem must exist.');
+    return validationErrors;
+  }
+
+  const tokenSystem = designIntentContract.tokenSystem;
+  const taxonomyOrder = tokenSystem.taxonomyOrder;
+  if (!Array.isArray(taxonomyOrder) || taxonomyOrder.join('|') !== 'primitive|semantic|component') {
+    validationErrors.push('designIntent.tokenSystem.taxonomyOrder must equal ["primitive","semantic","component"].');
+  }
+  if (tokenSystem.primitiveColorSpace !== 'OKLCH') {
+    validationErrors.push('designIntent.tokenSystem.primitiveColorSpace must equal "OKLCH".');
+  }
+  if (tokenSystem.requireSemanticAliases !== true) {
+    validationErrors.push('designIntent.tokenSystem.requireSemanticAliases must equal true.');
+  }
+  if (tokenSystem.semanticAliasesMutableWithoutComponentRewrite !== true) {
+    validationErrors.push('designIntent.tokenSystem.semanticAliasesMutableWithoutComponentRewrite must equal true.');
+  }
+  if (tokenSystem.componentTokensConsumeSemantic !== true) {
+    validationErrors.push('designIntent.tokenSystem.componentTokensConsumeSemantic must equal true.');
+  }
+
+  validateTokenLockingPolicy(tokenSystem, validationErrors);
+  validateTokenFallbackAndNaming(tokenSystem, validationErrors);
+  return validationErrors;
+}
+
+export function validateColorTruth(designIntentContract, validationErrors) {
+  if (!designIntentContract.colorTruth || typeof designIntentContract.colorTruth !== 'object') {
+    validationErrors.push('designIntent.colorTruth must exist.');
+    return validationErrors;
+  }
+  const colorTruth = designIntentContract.colorTruth;
+  if (colorTruth.format !== 'OKLCH') {
+    validationErrors.push('designIntent.colorTruth.format must equal "OKLCH".');
+  }
+  if (colorTruth.allowHexDerivatives !== true) {
+    validationErrors.push('designIntent.colorTruth.allowHexDerivatives must equal true.');
+  }
+  if (!String(colorTruth.intent || '').trim()) {
+    validationErrors.push('designIntent.colorTruth.intent must be a non-empty string.');
+  }
+  const paletteRoles = colorTruth.paletteRoles;
+  if (!Array.isArray(paletteRoles) || paletteRoles.length < 1) {
+    validationErrors.push('designIntent.colorTruth.paletteRoles must define or request agent-defined semantic palette roles.');
+  }
+  if (colorTruth.rolesMustBeAgentDefined !== true) {
+    validationErrors.push('designIntent.colorTruth.rolesMustBeAgentDefined must equal true.');
+  }
+  return validationErrors;
+}
+
+export function validateCrossViewportAdaptation(designIntentContract, validationErrors) {
+  if (!designIntentContract.crossViewportAdaptation || typeof designIntentContract.crossViewportAdaptation !== 'object') {
+    validationErrors.push('designIntent.crossViewportAdaptation must exist.');
+    return validationErrors;
+  }
+  const mutationRules = designIntentContract.crossViewportAdaptation.mutationRules;
+  if (!mutationRules || typeof mutationRules !== 'object') {
+    validationErrors.push('designIntent.crossViewportAdaptation.mutationRules must exist.');
+    return validationErrors;
+  }
+  for (const viewportKey of ['mobile', 'tablet', 'desktop']) {
+    if (!String(mutationRules[viewportKey] || '').trim()) {
+      validationErrors.push(`designIntent.crossViewportAdaptation.mutationRules.${viewportKey} must be a non-empty string.`);
+    }
+  }
+  return validationErrors;
+}
+
+export function validateMotionSystem(designIntentContract, validationErrors) {
+  if (!designIntentContract.motionSystem || typeof designIntentContract.motionSystem !== 'object') {
+    validationErrors.push('designIntent.motionSystem must exist.');
+    return validationErrors;
+  }
+  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.');
+  }
+  return validationErrors;
+}
+
+export function validateComponentMorphology(designIntentContract, validationErrors) {
+  if (!designIntentContract.componentMorphology || typeof designIntentContract.componentMorphology !== 'object') {
+    validationErrors.push('designIntent.componentMorphology must exist.');
+    return validationErrors;
+  }
+  const componentMorphology = designIntentContract.componentMorphology;
+  if (componentMorphology.requireStateBehaviorMatrix !== true) {
+    validationErrors.push('designIntent.componentMorphology.requireStateBehaviorMatrix must equal true.');
+  }
+  if (!Array.isArray(componentMorphology.stateKeys) || componentMorphology.stateKeys.length < 4) {
+    validationErrors.push('designIntent.componentMorphology.stateKeys must contain multiple interaction states.');
+  }
+  const viewportBehavior = componentMorphology.viewportBehavior;
+  if (!viewportBehavior || typeof viewportBehavior !== 'object') {
+    validationErrors.push('designIntent.componentMorphology.viewportBehavior must exist.');
+    return validationErrors;
+  }
+  for (const viewportKey of ['mobile', 'tablet', 'desktop']) {
+    if (!String(viewportBehavior[viewportKey] || '').trim()) {
+      validationErrors.push(`designIntent.componentMorphology.viewportBehavior.${viewportKey} must be a non-empty string.`);
+    }
+  }
+  return validationErrors;
+}
+
+export function validateAccessibilityPolicy(designIntentContract, validationErrors) {
+  if (!designIntentContract.accessibilityPolicy || typeof designIntentContract.accessibilityPolicy !== 'object') {
+    validationErrors.push('designIntent.accessibilityPolicy must exist.');
+    return validationErrors;
+  }
+  const accessibilityPolicy = designIntentContract.accessibilityPolicy;
+  if (accessibilityPolicy.hardComplianceFloor !== 'WCAG-2.2-AA') {
+    validationErrors.push('designIntent.accessibilityPolicy.hardComplianceFloor must equal "WCAG-2.2-AA".');
+  }
+  if (accessibilityPolicy.advisoryContrastModel !== 'APCA') {
+    validationErrors.push('designIntent.accessibilityPolicy.advisoryContrastModel must equal "APCA".');
+  }
+  if (accessibilityPolicy.failOnHardViolations !== true) {
+    validationErrors.push('designIntent.accessibilityPolicy.failOnHardViolations must equal true.');
+  }
+  if (accessibilityPolicy.advisoryFindingsDoNotBlockByDefault !== true) {
+    validationErrors.push('designIntent.accessibilityPolicy.advisoryFindingsDoNotBlockByDefault must equal true.');
+  }
+  const hardRequirements = 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 = accessibilityPolicy.advisoryChecks;
+  if (!advisoryChecks || typeof advisoryChecks !== 'object') {
+    validationErrors.push('designIntent.accessibilityPolicy.advisoryChecks must exist.');
+    return validationErrors;
+  }
+  for (const advisoryKey of [
+    'perceptualContrastReview',
+    'darkModeContrastTuning',
+    'typographyReadabilityTuning',
+  ]) {
+    if (advisoryChecks[advisoryKey] !== true) {
+      validationErrors.push(`designIntent.accessibilityPolicy.advisoryChecks.${advisoryKey} must equal true.`);
+    }
+  }
+  return validationErrors;
+}
+
+export function validateContextHygiene(designIntentContract, validationErrors) {
+  if (!designIntentContract.contextHygiene || typeof designIntentContract.contextHygiene !== 'object') {
+    validationErrors.push('designIntent.contextHygiene must exist.');
+    return validationErrors;
+  }
+  const contextHygiene = designIntentContract.contextHygiene;
+  if (contextHygiene.continuityMode !== 'opt-in-only') {
+    validationErrors.push('designIntent.contextHygiene.continuityMode must equal "opt-in-only".');
+  }
+  if (contextHygiene.repoEvidenceOverridesMemory !== true) {
+    validationErrors.push('designIntent.contextHygiene.repoEvidenceOverridesMemory must equal true.');
+  }
+  if (contextHygiene.requireExplicitContinuityApproval !== true) {
+    validationErrors.push('designIntent.contextHygiene.requireExplicitContinuityApproval must equal true.');
+  }
+  if (contextHygiene.forbidCarryoverWhenUnapproved !== true) {
+    validationErrors.push('designIntent.contextHygiene.forbidCarryoverWhenUnapproved must equal true.');
+  }
+  if (!Array.isArray(contextHygiene.allowedSources) || contextHygiene.allowedSources.length < 4) {
+    validationErrors.push('designIntent.contextHygiene.allowedSources must list the approved design evidence sources.');
+  }
+  if (!Array.isArray(contextHygiene.taintedSources) || contextHygiene.taintedSources.length < 3) {
+    validationErrors.push('designIntent.contextHygiene.taintedSources must list tainted carryover sources.');
+  }
+  if (!String(contextHygiene.approvedExternalConstraintUsage || '').trim()) {
+    validationErrors.push('designIntent.contextHygiene.approvedExternalConstraintUsage must be a non-empty string.');
+  }
+  return validationErrors;
+}