@domainlang/language 0.11.0 → 0.13.0

package/src/sdk/types.ts

@@ -13,6 +13,7 @@ import type {
     Model,
     NamespaceDeclaration,
     Relationship,
+    SidePattern,
     Team,
 } from '../generated/ast.js';
 import type { DomainLangServices } from '../domain-lang-module.js';
@@ -281,30 +282,104 @@ export interface BcQueryBuilder extends QueryBuilder<BoundedContext> {
 }
 
 /**
- * Unified view of a relationship between two BoundedContexts.
- * Relationships can be defined in BoundedContext blocks or ContextMap.
+ * One side of a relationship: the bounded context and its annotated integration patterns.
+ * For symmetric relationships `patterns` is always empty — the pattern lives on the relationship itself.
+ */
+export interface RelationshipSide {
+    /** The bounded context on this side */
+    readonly context: BoundedContext;
+    /** Integration patterns annotated on this side (directional relationships only) */
+    readonly patterns: readonly SidePattern[];
+}
+
+/**
+ * DDD kind of a directional relationship.
+ * Fully discriminates all three structural cases.
+ */
+export type DirectionalKind = 'UpstreamDownstream' | 'CustomerSupplier' | 'Bidirectional';
+
+/**
+ * Directional relationship: has an arrow expressing dependency between two contexts.
+ * Discriminate on `type` to access directional or symmetric properties.
+ * Discriminate on `kind` to handle upstream/downstream vs customer/supplier vs bidirectional.
  */
-export interface RelationshipView {
-    /** Left-hand side BoundedContext */
-    readonly left: BoundedContext;
-    /** Right-hand side BoundedContext */
-    readonly right: BoundedContext;
-    /** Relationship direction arrow */
-    readonly arrow: '->' | '<-' | '<->' | '><';
-    /** Integration patterns on left side (e.g., ['OHS', 'PL']) */
-    readonly leftPatterns: readonly string[];
-    /** Integration patterns on right side (e.g., ['CF', 'ACL']) */
-    readonly rightPatterns: readonly string[];
-    /** Explicit relationship type if specified */
-    readonly type?: string;
-    /** SDK-inferred relationship type based on patterns */
-    readonly inferredType?: string;
+export interface DirectionalRelationshipView {
+    readonly type: 'directional';
+    /** DDD semantic kind — determines which roles each side plays */
+    readonly kind: DirectionalKind;
+    /** Arrow as written in source (use for display/serialization) */
+    readonly arrow: '->' | '<-' | '<->';
+    /** Left side as written in source — always defined */
+    readonly left: RelationshipSide;
+    /** Right side as written in source — always defined */
+    readonly right: RelationshipSide;
+    /**
+     * The upstream (provider) side with its patterns.
+     * Defined when `kind` is `'UpstreamDownstream'` or `'CustomerSupplier'`.
+     * `undefined` when `kind` is `'Bidirectional'` — no upstream role exists.
+     */
+    readonly upstream: RelationshipSide | undefined;
+    /**
+     * The downstream (consumer) side with its patterns.
+     * Defined when `kind` is `'UpstreamDownstream'` or `'CustomerSupplier'`.
+     * `undefined` when `kind` is `'Bidirectional'` — no downstream role exists.
+     */
+    readonly downstream: RelationshipSide | undefined;
     /** Source of the relationship definition */
     readonly source: 'BoundedContext' | 'ContextMap';
     /** Original AST relationship node */
     readonly astNode: Relationship;
 }
 
+/** Resolved symmetric integration pattern kind. */
+export type SymmetricKind = 'SharedKernel' | 'Partnership' | 'SeparateWays';
+
+/**
+ * Symmetric relationship: no arrow; neither context is upstream or downstream.
+ * Discriminate on `type` to access directional or symmetric properties.
+ */
+export interface SymmetricRelationshipView {
+    readonly type: 'symmetric';
+    /**
+     * Always-resolved symmetric integration pattern.
+     * `><` resolves to `'SeparateWays'`.
+     */
+    readonly kind: SymmetricKind;
+    /**
+     * Left side as written in source.
+     * `patterns` is always empty — symmetric patterns attach to the relationship, not each side.
+     */
+    readonly left: RelationshipSide;
+    /**
+     * Right side as written in source.
+     * `patterns` is always empty — symmetric patterns attach to the relationship, not each side.
+     */
+    readonly right: RelationshipSide;
+    /** Source of the relationship definition */
+    readonly source: 'BoundedContext' | 'ContextMap';
+    /** Original AST relationship node */
+    readonly astNode: Relationship;
+}
+
+/**
+ * Unified view of a relationship between two BoundedContexts.
+ * Relationships can be defined in BoundedContext blocks or ContextMap.
+ * Discriminate on `type` to access directional or symmetric properties.
+ *
+ * @example
+ * ```typescript
+ * for (const rel of query.relationships()) {
+ *   if (rel.type === 'symmetric') {
+ *     console.log(rel.kind); // 'SharedKernel' | 'Partnership' | 'SeparateWays'
+ *   } else {
+ *     console.log(rel.kind);  // 'UpstreamDownstream' | 'CustomerSupplier' | 'Bidirectional'
+ *     console.log(rel.arrow); // '->' | '<-' | '<->'
+ *   }
+ * }
+ * ```
+ */
+export type RelationshipView = DirectionalRelationshipView | SymmetricRelationshipView;
+
 /**
  * Internal index structure for O(1) lookups.
  * Not exported from public API.

package/src/sdk/validator.ts

@@ -75,6 +75,52 @@ function toValidationDiagnostic(
     };
 }
 
+/**
+ * Collect errors and warnings from an array of Langium documents.
+ */
+function collectDiagnostics(
+    allDocuments: Iterable<{ uri: { fsPath: string }; diagnostics?: Array<{ severity?: number; message: string; range: { start: { line: number; character: number } } }> }>
+): { errors: ValidationDiagnostic[]; warnings: ValidationDiagnostic[] } {
+    const errors: ValidationDiagnostic[] = [];
+    const warnings: ValidationDiagnostic[] = [];
+    for (const doc of allDocuments) {
+        const diagnostics = doc.diagnostics ?? [];
+        const docPath = doc.uri.fsPath;
+        for (const diagnostic of diagnostics) {
+            const validationDiag = toValidationDiagnostic(diagnostic, docPath);
+            if (diagnostic.severity === 1) {
+                errors.push(validationDiag);
+            } else if (diagnostic.severity === 2) {
+                warnings.push(validationDiag);
+            }
+        }
+    }
+    return { errors, warnings };
+}
+
+/**
+ * Count Domain and BoundedContext elements across all documents.
+ */
+function countModelElements(
+    allDocuments: Iterable<{ parseResult?: { value: unknown } }>
+): { domainCount: number; bcCount: number } {
+    let domainCount = 0;
+    let bcCount = 0;
+    for (const doc of allDocuments) {
+        const model = doc.parseResult?.value;
+        if (isModel(model)) {
+            for (const element of model.children ?? []) {
+                if (element.$type === 'Domain') {
+                    domainCount++;
+                } else if (element.$type === 'BoundedContext') {
+                    bcCount++;
+                }
+            }
+        }
+    }
+    return { domainCount, bcCount };
+}
+
 /**
  * Validates a DomainLang model file and all its imports.
  * 
@@ -152,40 +198,9 @@ export async function validateFile(
     const allDocuments = Array.from(shared.workspace.LangiumDocuments.all);
     await shared.workspace.DocumentBuilder.build(allDocuments, { validation: true });
 
-    // Collect diagnostics from all loaded documents (entry + imports)
-    const errors: ValidationDiagnostic[] = [];
-    const warnings: ValidationDiagnostic[] = [];
-
-    for (const doc of allDocuments) {
-        const diagnostics = doc.diagnostics ?? [];
-        const diagnosticFile = doc.uri.fsPath;
-
-        for (const diagnostic of diagnostics) {
-            const validationDiag = toValidationDiagnostic(diagnostic, diagnosticFile);
-            if (diagnostic.severity === 1) {
-                errors.push(validationDiag);
-            } else if (diagnostic.severity === 2) {
-                warnings.push(validationDiag);
-            }
-        }
-    }
-
-    // Count model elements across all documents
-    let domainCount = 0;
-    let bcCount = 0;
-
-    for (const doc of allDocuments) {
-        const model = doc.parseResult?.value;
-        if (isModel(model)) {
-            for (const element of model.children ?? []) {
-                if (element.$type === 'Domain') {
-                    domainCount++;
-                } else if (element.$type === 'BoundedContext') {
-                    bcCount++;
-                }
-            }
-        }
-    }
+    // Collect diagnostics and count elements from all loaded documents (entry + imports)
+    const { errors, warnings } = collectDiagnostics(allDocuments);
+    const { domainCount, bcCount } = countModelElements(allDocuments);
 
     return {
         valid: errors.length === 0,
@@ -314,41 +329,9 @@ export async function validateWorkspace(
     const allDocuments = Array.from(shared.workspace.LangiumDocuments.all);
     await shared.workspace.DocumentBuilder.build(allDocuments, { validation: true });
 
-    // Collect diagnostics from ALL documents (not just entry)
-    const errors: ValidationDiagnostic[] = [];
-    const warnings: ValidationDiagnostic[] = [];
-
-    for (const doc of allDocuments) {
-        const diagnostics = doc.diagnostics ?? [];
-        const docPath = doc.uri.fsPath;
-        
-        for (const diagnostic of diagnostics) {
-            const validationDiag = toValidationDiagnostic(diagnostic, docPath);
-            
-            if (diagnostic.severity === 1) {
-                errors.push(validationDiag);
-            } else if (diagnostic.severity === 2) {
-                warnings.push(validationDiag);
-            }
-        }
-    }
-
-    // Count model elements across all documents
-    let domainCount = 0;
-    let bcCount = 0;
-
-    for (const doc of allDocuments) {
-        const model = doc.parseResult?.value;
-        if (isModel(model)) {
-            for (const element of model.children ?? []) {
-                if (element.$type === 'Domain') {
-                    domainCount++;
-                } else if (element.$type === 'BoundedContext') {
-                    bcCount++;
-                }
-            }
-        }
-    }
+    // Collect diagnostics and count elements from ALL documents (not just entry)
+    const { errors, warnings } = collectDiagnostics(allDocuments);
+    const { domainCount, bcCount } = countModelElements(allDocuments);
 
     return {
         valid: errors.length === 0,

package/src/services/performance-optimizer.ts

@@ -23,8 +23,8 @@ import fs from 'node:fs/promises';
  * always correct and immediate.
  */
 export class PerformanceOptimizer {
-    private lockFileCache = new Map<string, LockFile>();
-    private manifestCache = new Map<string, unknown>();
+    private readonly lockFileCache = new Map<string, LockFile>();
+    private readonly manifestCache = new Map<string, unknown>();
 
     /**
      * Gets a lock file from cache or loads it from disk.
@@ -55,7 +55,7 @@ export class PerformanceOptimizer {
     /**
      * Gets a manifest file from cache or loads it from disk.
      */
-    async getCachedManifest(manifestPath: string): Promise<unknown | undefined> {
+    async getCachedManifest(manifestPath: string): Promise<unknown> {
         const cacheKey = this.normalizePath(manifestPath);
         const cached = this.manifestCache.get(cacheKey);
 
@@ -121,9 +121,7 @@ let globalOptimizer: PerformanceOptimizer | undefined;
  * Gets the global performance optimizer instance.
  */
 export function getGlobalOptimizer(): PerformanceOptimizer {
-    if (!globalOptimizer) {
-        globalOptimizer = new PerformanceOptimizer();
-    }
+    globalOptimizer ??= new PerformanceOptimizer();
     return globalOptimizer;
 }
 

package/src/services/relationship-inference.ts

@@ -3,20 +3,26 @@ import type {
     Relationship, 
     StructureElement, 
     BoundedContext,
-    ContextMap
+    ContextMap,
+    DirectionalRelationship,
+    SymmetricRelationship
 } from '../generated/ast.js';
 import { 
     isBoundedContext, 
     isContextMap, 
-    isNamespaceDeclaration 
+    isNamespaceDeclaration,
+    isDirectionalRelationship,
+    isSymmetricRelationship,
+    isSupplier,
+    isCustomer
 } from '../generated/ast.js';
 
 /**
- * Enriches relationships in the model by inferring relationship types
- * from roles and arrow directions.
+ * Enriches relationships in the model by inferring relationship kinds
+ * from AST node type, patterns, and arrow direction.
  * 
- * This service walks the entire model structure and applies inference
- * rules to relationships that don't have an explicit type.
+ * With the entity–relationship–entity grammar, symmetric relationships
+ * derive their kind directly from the AST node type (no heuristics).
  * 
  * @param model - The root model to process
  */
@@ -26,17 +32,14 @@ export function setInferredRelationshipTypes(model: Model): void {
 
 /**
  * Recursively walks structure elements to find and enrich relationships.
- * 
- * @param elements - Array of structure elements to process
- * @param containerBc - Optional container bounded context (for nested contexts)
  */
 function walkStructureElements(
     elements: StructureElement[] = [], 
-    containerBc?: BoundedContext
+    _containerBc?: BoundedContext
 ): void {
     for (const element of elements) {
-    if (isNamespaceDeclaration(element)) {
-            walkStructureElements(element.children, containerBc);
+        if (isNamespaceDeclaration(element)) {
+            walkStructureElements(element.children, _containerBc);
         } else if (isBoundedContext(element)) {
             processContextRelationships(element);
         } else if (isContextMap(element)) {
@@ -47,8 +50,6 @@ function walkStructureElements(
 
 /**
  * Processes relationships within a bounded context.
- * 
- * @param context - The bounded context to process
  */
 function processContextRelationships(context: BoundedContext): void {
     for (const rel of context.relationships) {
@@ -58,8 +59,6 @@ function processContextRelationships(context: BoundedContext): void {
 
 /**
  * Processes relationships within a context map.
- * 
- * @param map - The context map to process
  */
 function processMapRelationships(map: ContextMap): void {
     if (map.relationships) {
@@ -70,52 +69,42 @@ function processMapRelationships(map: ContextMap): void {
 }
 
 /**
- * Enriches a single relationship by inferring its type if not explicitly set.
- * 
- * @param rel - The relationship to enrich
+ * Enriches a single relationship by inferring its kind.
  */
 function enrichRelationship(rel: Relationship): void {
-    if (!rel.type) {
-        rel.inferredType = inferRelationshipType(rel);
+    if (isSymmetricRelationship(rel)) {
+        rel.inferredKind = inferSymmetricKind(rel);
+    } else if (isDirectionalRelationship(rel)) {
+        rel.inferredKind = inferDirectionalKind(rel);
     }
 }
 
 /**
- * Infers relationship type from arrow direction and roles.
- * 
- * Inference rules:
- * - `><` → SeparateWays
- * - `<->` with P roles → Partnership
- * - `<->` with SK roles → SharedKernel
- * - `->` or `<-` → UpstreamDownstream
- * 
- * @param relationship - The relationship to analyze
- * @returns The inferred type or undefined if no rule matches
+ * Infers kind for symmetric relationships — derived from AST node type.
+ * No heuristics needed: the pattern is structurally part of the relationship.
  */
-function inferRelationshipType(relationship: Relationship): string | undefined {
-    const leftPatterns = (relationship.leftPatterns ?? []).map((r: string) => r.toUpperCase());
-    const rightPatterns = (relationship.rightPatterns ?? []).map((r: string) => r.toUpperCase());
-
-    if (relationship.arrow === '><') {
-        return 'SeparateWays';
+function inferSymmetricKind(rel: SymmetricRelationship): string {
+    if (rel.pattern) {
+        return rel.pattern.$type;  // 'SharedKernel', 'Partnership', or 'SeparateWays'
     }
-    
-    if (relationship.arrow === '<->') {
-        const noPatterns = leftPatterns.length === 0 && rightPatterns.length === 0;
-        const bothPartners = leftPatterns.includes('P') && rightPatterns.includes('P');
-        
-        if (noPatterns || bothPartners) {
-            return 'Partnership';
-        }
-        
-        if (leftPatterns.includes('SK') && rightPatterns.includes('SK')) {
-            return 'SharedKernel';
-        }
+    if (rel.arrow === '><') {
+        return 'SeparateWays';
     }
+    return 'SeparateWays'; // `><` is the only non-pattern symmetric form
+}
+
+/**
+ * Infers kind for directional relationships from side patterns.
+ * 
+ * - Customer/Supplier: has [S] or [C] patterns
+ * - UpstreamDownstream: default for all directional relationships
+ */
+function inferDirectionalKind(rel: DirectionalRelationship): string {
+    const hasSupplier = rel.leftPatterns.some(isSupplier) || rel.rightPatterns.some(isSupplier);
+    const hasCustomer = rel.leftPatterns.some(isCustomer) || rel.rightPatterns.some(isCustomer);
     
-    if (relationship.arrow === '->' || relationship.arrow === '<-') {
-        return 'UpstreamDownstream';
+    if (hasSupplier || hasCustomer) {
+        return 'CustomerSupplier';
     }
-    
-    return undefined;
-} 
+    return 'UpstreamDownstream';
+}

package/src/utils/import-utils.ts

@@ -1,82 +1,21 @@
 import path from 'node:path';
 import { URI, type LangiumDocument, type LangiumDocuments } from 'langium';
 import type { Model } from '../generated/ast.js';
-import { ManifestManager } from '../services/workspace-manager.js';
-import { ImportResolver } from '../services/import-resolver.js';
-import type { DomainLangServices } from '../domain-lang-module.js';
-
-/**
- * Lazily initialized workspace manager for standalone (non-LSP) usage.
- * Used by import graph building when no DI-injected ImportResolver is available.
- * 
- * @deprecated Prefer passing an ImportResolver from the DI container.
- * These singletons exist only for backwards compatibility with callers
- * that haven't been updated to pass through DI services.
- */
-let standaloneManifestManager: ManifestManager | undefined;
-let standaloneImportResolver: ImportResolver | undefined;
-let lastInitializedDir: string | undefined;
-
-/**
- * Gets or creates a standalone import resolver for non-LSP contexts.
- * Creates its own ManifestManager if not previously initialized for this directory.
- *
- * @deprecated Prefer using services.imports.ImportResolver directly.
- * @param startDir - Directory to start workspace search from
- * @returns Promise resolving to the import resolver
- */
-async function getStandaloneImportResolver(startDir: string): Promise<ImportResolver> {
-  // Re-initialize if directory changed (workspace boundary)
-  if (lastInitializedDir !== startDir || !standaloneImportResolver) {
-    standaloneManifestManager = new ManifestManager();
-    try {
-      await standaloneManifestManager.initialize(startDir);
-    } catch (error) {
-      console.warn(`Failed to initialize workspace: ${error instanceof Error ? error.message : String(error)}`);
-    }
-    const services = {
-      imports: { ManifestManager: standaloneManifestManager }
-    } as DomainLangServices;
-    standaloneImportResolver = new ImportResolver(services);
-    lastInitializedDir = startDir;
-  }
-  return standaloneImportResolver;
-}
-
-/**
- * Resolves an import path to an absolute file URI.
- * 
- * @deprecated Prefer using ImportResolver.resolveForDocument() from the DI container.
- * This function creates standalone instances outside the DI system.
- * 
- * @param importingDoc - The document containing the import statement
- * @param rawImportPath - The raw import path from the import statement
- * @returns Resolved URI to the imported file
- * @throws {Error} If the import cannot be resolved
- */
-export async function resolveImportPath(
-  importingDoc: LangiumDocument,
-  rawImportPath: string
-): Promise<URI> {
-  const baseDir = path.dirname(importingDoc.uri.fsPath);
-  const resolver = await getStandaloneImportResolver(baseDir);
-  return resolver.resolveFrom(baseDir, rawImportPath);
-}
+import type { ImportResolver } from '../services/import-resolver.js';
 
 /**
  * Ensures the import graph is loaded from an entry file.
- * 
+ *
  * @param entryFilePath - Absolute or workspace-relative path to entry file
  * @param langiumDocuments - The Langium documents manager
- * @param importResolver - Optional DI-injected ImportResolver. When provided,
- *   uses it instead of creating standalone instances. Recommended for LSP contexts.
+ * @param importResolver - DI-injected ImportResolver from the language services
  * @returns Set of URIs (as strings) for all documents in the import graph
  * @throws {Error} If entry file cannot be resolved or loaded
  */
 export async function ensureImportGraphFromEntryFile(
   entryFilePath: string,
   langiumDocuments: LangiumDocuments,
-  importResolver?: ImportResolver
+  importResolver: ImportResolver
 ): Promise<Set<string>> {
   const entryUri = URI.file(path.resolve(entryFilePath));
   const entryDoc = await langiumDocuments.getOrCreateDocument(entryUri);
@@ -85,17 +24,16 @@ export async function ensureImportGraphFromEntryFile(
 
 /**
  * Recursively builds the import graph from a document.
- * 
+ *
  * @param document - The starting document
  * @param langiumDocuments - The Langium documents manager
- * @param importResolver - Optional DI-injected ImportResolver. When provided,
- *   uses it instead of creating standalone instances. Recommended for LSP contexts.
+ * @param importResolver - DI-injected ImportResolver from the language services
  * @returns Set of URIs (as strings) for all documents in the import graph
  */
 export async function ensureImportGraphFromDocument(
   document: LangiumDocument,
   langiumDocuments: LangiumDocuments,
-  importResolver?: ImportResolver
+  importResolver: ImportResolver
 ): Promise<Set<string>> {
   const visited = new Set<string>();
 
@@ -107,12 +45,9 @@ export async function ensureImportGraphFromDocument(
     const model = doc.parseResult.value as unknown as Model;
     for (const imp of model.imports ?? []) {
       if (!imp.uri) continue;
-      
+
       try {
-        // Use DI-injected resolver when available, falling back to standalone
-        const resolvedUri = importResolver
-          ? await importResolver.resolveForDocument(doc, imp.uri)
-          : await resolveImportPath(doc, imp.uri);
+        const resolvedUri = await importResolver.resolveForDocument(doc, imp.uri);
         const childDoc = await langiumDocuments.getOrCreateDocument(resolvedUri);
         await visit(childDoc);
       } catch {

package/src/validation/constants.ts

@@ -48,9 +48,12 @@ export const IssueCodes = {
     BoundedContextTeamConflict: 'bounded-context-team-conflict',
     
     // Integration Pattern Issues
-    SharedKernelNotBidirectional: 'shared-kernel-not-bidirectional',
     AclOnWrongSide: 'acl-on-wrong-side',
     ConformistOnWrongSide: 'conformist-on-wrong-side',
+    OhsOnWrongSide: 'ohs-on-wrong-side',
+    SupplierOnWrongSide: 'supplier-on-wrong-side',
+    CustomerOnWrongSide: 'customer-on-wrong-side',
+    SelfSymmetricRelationship: 'self-symmetric-relationship',
     TooManyPatterns: 'too-many-patterns',
     
     // Context/Domain Map Issues
@@ -167,13 +170,6 @@ export const ValidationMessages = {
     // Integration Pattern & Relationship Validation
     // ========================================================================
 
-    /**
-     * Warning when SharedKernel pattern uses incorrect arrow direction.
-     * SharedKernel requires bidirectional relationship.
-     */
-    SHARED_KERNEL_MUST_BE_BIDIRECTIONAL: (leftContext: string, rightContext: string, arrow: string) =>
-        `SharedKernel between '${leftContext}' and '${rightContext}' requires bidirectional arrow '<->', not '${arrow}'.`,
-
     /**
      * Warning when Anti-Corruption Layer is on the wrong side of relationship.
      * ACL should protect the consuming context (downstream).
@@ -188,6 +184,33 @@ export const ValidationMessages = {
     CONFORMIST_ON_WRONG_SIDE: (context: string, side: 'left' | 'right') =>
         `Conformist (CF) on '${context}' should be on downstream (consuming) side, not ${side} side.`,
 
+    /**
+     * Warning when Open Host Service is on the wrong side of relationship.
+     * OHS should be on the upstream (providing) side.
+     */
+    OHS_ON_WRONG_SIDE: (context: string, side: 'left' | 'right') =>
+        `Open Host Service (OHS) on '${context}' should be on upstream (providing) side, not ${side} side.`,
+
+    /**
+     * Error when Supplier is on the wrong side of relationship.
+     * Supplier must always be upstream.
+     */
+    SUPPLIER_ON_WRONG_SIDE: (context: string, _side: 'left' | 'right') =>
+        `Supplier (S) on '${context}' must be on the upstream side. Supplier is always the provider in a Customer/Supplier relationship.`,
+
+    /**
+     * Error when Customer is on the wrong side of relationship.
+     * Customer must always be downstream.
+     */
+    CUSTOMER_ON_WRONG_SIDE: (context: string, _side: 'left' | 'right') =>
+        `Customer (C) on '${context}' must be on the downstream side. Customer is always the consumer in a Customer/Supplier relationship.`,
+
+    /**
+     * Warning when a symmetric relationship references the same context on both sides.
+     */
+    SELF_SYMMETRIC_RELATIONSHIP: (context: string) =>
+        `Symmetric relationship with self: '${context}' has a symmetric relationship with itself. This is likely unintended.`,
+
     /**
      * Info message when relationship has too many integration patterns.
      * Suggests possible syntax confusion.
@@ -311,7 +334,7 @@ export const ValidationMessages = {
      */
     CONTEXT_MAP_NO_RELATIONSHIPS: (name: string, count: number) =>
         `Context Map '${name}' contains ${count} contexts but no documented relationships.\n` +
-        `Hint: Add relationships to show how contexts integrate (e.g., '[OHS] A -> [CF] B').`,
+        `Hint: Add relationships to show how contexts integrate (e.g., 'A [OHS] -> [CF] B').`,
 
     /**
      * Warning when a context map contains duplicate relationships.