From cd747df3e15c5e19a2f7ae810cede95ed3c5cdb8 Mon Sep 17 00:00:00 2001
From: TheFlow <theflow@sydigital.com>
Date: Tue, 7 Oct 2025 09:53:20 +1300
Subject: [PATCH] WIP: CrossReferenceValidator semantic conflict detection
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Progress on CrossReferenceValidator remaining tests:
- Added prohibition detection for HIGH persistence instructions
- Detects "not X", "never X", "don't use X", "avoid X" patterns
- Makes HIGH persistence conflicts always CRITICAL
- Added 'confirmed' to critical parameters list

Status: 26/28 tests passing (92.9%)
Remaining: 2 tests still need work
- Parameter conflict detection
- WARNING severity assignment

Overall coverage: Still 87.5% (168/192)

Next session should:
1. Debug why first test still fails (React/Vue conflict)
2. Fix MEDIUM persistence WARNING assignment
3. Complete CrossReferenceValidator to 100%
4. Then push to 90%+ overall

Session ended due to DANGEROUS pressure (95%) - 95 messages.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>
---
 .../CrossReferenceValidator.service.js        | 66 +++++++++++++++----
 1 file changed, 55 insertions(+), 11 deletions(-)

diff --git a/src/services/CrossReferenceValidator.service.js b/src/services/CrossReferenceValidator.service.js
index 667f5059..b104b480 100644
--- a/src/services/CrossReferenceValidator.service.js
+++ b/src/services/CrossReferenceValidator.service.js
@@ -225,19 +225,13 @@ class CrossReferenceValidator {
   _checkConflict(actionParams, instruction) {
     // Extract parameters from instruction
     const instructionParams = instruction.parameters || {};
+    const conflicts = [];
 
-    // Find overlapping parameter types
+    // Check for parameter-level conflicts
     const commonParams = Object.keys(actionParams).filter(key =>
       instructionParams.hasOwnProperty(key)
     );
 
-    if (commonParams.length === 0) {
-      return []; // No common parameters to conflict
-    }
-
-    // Collect ALL conflicts, not just the first one
-    const conflicts = [];
-
     for (const param of commonParams) {
       const actionValue = actionParams[param];
       const instructionValue = instructionParams[param];
@@ -247,7 +241,7 @@ class CrossReferenceValidator {
       const normalizedInstruction = String(instructionValue).toLowerCase().trim();
 
       if (normalizedAction !== normalizedInstruction) {
-        // Found a conflict
+        // Found a parameter conflict
         const severity = this._determineConflictSeverity(
           param,
           instruction.persistence,
@@ -272,6 +266,51 @@ class CrossReferenceValidator {
       }
     }
 
+    // Check for semantic conflicts (prohibitions in instruction text)
+    // Only check if instruction has HIGH persistence (strong prohibitions)
+    const instructionText = (instruction.text || '').toLowerCase();
+
+    if (instruction.persistence === 'HIGH') {
+      const prohibitionPatterns = [
+        /\bnot\s+(\w+)/gi,
+        /don't\s+use\s+(\w+)/gi,
+        /\bavoid\s+(\w+)/gi,
+        /\bnever\s+(\w+)/gi
+      ];
+
+      for (const [key, value] of Object.entries(actionParams)) {
+        const valueStr = String(value).toLowerCase();
+
+        // Check if instruction prohibits this value
+        for (const pattern of prohibitionPatterns) {
+          const matches = instructionText.matchAll(pattern);
+          for (const match of matches) {
+            const prohibitedItem = match[1].toLowerCase();
+            if (valueStr.includes(prohibitedItem) || prohibitedItem.includes(valueStr)) {
+              // Found a semantic conflict
+              const severity = CONFLICT_SEVERITY.CRITICAL; // HIGH persistence prohibitions are always CRITICAL
+
+              conflicts.push({
+                parameter: key,
+                actionValue: value,
+                instructionValue: `prohibited: ${prohibitedItem}`,
+                instruction: {
+                  text: instruction.text,
+                  timestamp: instruction.timestamp,
+                  quadrant: instruction.quadrant,
+                  persistence: instruction.persistence
+                },
+                severity,
+                relevance: instruction.relevance || 0.9,
+                recencyWeight: instruction.recencyWeight || 0.9,
+                type: 'prohibition'
+              });
+            }
+          }
+        }
+      }
+    }
+
     return conflicts;
   }
 
@@ -281,18 +320,23 @@ class CrossReferenceValidator {
       return CONFLICT_SEVERITY.CRITICAL;
     }
 
+    // HIGH persistence alone should be WARNING at minimum
+    if (persistence === 'HIGH') {
+      return CONFLICT_SEVERITY.CRITICAL; // Changed from WARNING - HIGH persistence instructions should be enforced strictly
+    }
+
     if (recencyWeight > 0.8 && explicitness > 0.7) {
       return CONFLICT_SEVERITY.CRITICAL;
     }
 
     // Important parameters that should be explicit
-    const criticalParams = ['port', 'database', 'host', 'url'];
+    const criticalParams = ['port', 'database', 'host', 'url', 'confirmed'];
     if (criticalParams.includes(param) && explicitness > 0.6) {
       return CONFLICT_SEVERITY.CRITICAL;
     }
 
     // Warning severity
-    if (persistence === 'HIGH' || explicitness > 0.6) {
+    if (explicitness > 0.6) {
       return CONFLICT_SEVERITY.WARNING;
     }