diff --git a/src/services/BoundaryEnforcer.service.js b/src/services/BoundaryEnforcer.service.js
index d5e8e5fb..81e70ea3 100644
--- a/src/services/BoundaryEnforcer.service.js
+++ b/src/services/BoundaryEnforcer.service.js
@@ -166,11 +166,53 @@ class BoundaryEnforcer {
    */
   enforce(action, context = {}) {
     try {
+      // Handle null/undefined gracefully
+      if (!action) {
+        return {
+          allowed: false,
+          humanRequired: true,
+          human_required: true,
+          requirementType: 'MANDATORY',
+          reason: 'Null or undefined decision cannot be evaluated',
+          message: 'Invalid decision provided',
+          action: 'REQUIRE_HUMAN_DECISION',
+          timestamp: new Date()
+        };
+      }
+
+      // Check for pre-approved operations
+      if (action.pre_approved && this._isVerificationOperation(action)) {
+        return this._allowAction(action, 'VERIFICATION', context);
+      }
+
+      // Check if domain explicitly indicates allowed operations
+      if (this._isAllowedDomain(action.domain)) {
+        const domainName = Array.isArray(action.domain) ? action.domain[0] : action.domain;
+        return this._allowAction(action, domainName.toUpperCase(), context);
+      }
+
+      // Map decision.domain to Tractatus boundary (handles both string and array)
+      const explicitBoundaries = this._mapDomainToBoundary(action.domain);
+
+      // Check for decision flags that indicate boundary crossings
+      const flaggedBoundaries = this._checkDecisionFlags(action);
+
+      // Check if decision.classification indicates STRATEGIC
+      if (action.classification?.quadrant === 'STRATEGIC') {
+        const boundaryViolations = [{
+          boundary: 'WISDOM',
+          section: '12.3',
+          principle: 'Wisdom cannot be encoded, only supported',
+          matchCount: 1
+        }];
+        return this._requireHumanJudgment(boundaryViolations, action, context);
+      }
+
       // Check if action crosses Tractatus boundaries
-      const boundaryViolations = this._checkTractatusBoundaries(action);
+      const boundaryViolations = this._checkTractatusBoundaries(action, explicitBoundaries, flaggedBoundaries);
 
       if (boundaryViolations.length > 0) {
-        return this._requireHumanJudgment(boundaryViolations, action);
+        return this._requireHumanJudgment(boundaryViolations, action, context);
       }
 
       // Check decision domain
@@ -178,22 +220,23 @@ class BoundaryEnforcer {
       const domainConfig = this.decisionDomains[domain];
 
       if (domainConfig.requiresHuman) {
-        return this._requireHumanApproval(domain, domainConfig.reason, action);
+        return this._requireHumanApproval(domain, domainConfig.reason, action, context);
       }
 
       if (domainConfig.requiresReview) {
-        return this._requireHumanReview(domain, domainConfig.reason, action);
+        return this._requireHumanReview(domain, domainConfig.reason, action, context);
       }
 
       // Action can proceed without human intervention
-      return this._allowAction(action, domain);
+      return this._allowAction(action, domain, context);
 
     } catch (error) {
       logger.error('Boundary enforcement error:', error);
       // Fail-safe: require human review on error
       return this._requireHumanJudgment(
         [{ boundary: 'ERROR', reason: 'Enforcement error, defaulting to human review' }],
-        action
+        action,
+        context
       );
     }
   }
@@ -240,10 +283,129 @@ class BoundaryEnforcer {
     return patterns;
   }
 
-  _checkTractatusBoundaries(action) {
+  /**
+   * Check if domain indicates an allowed operation (not a boundary violation)
+   */
+  _isAllowedDomain(domain) {
+    if (!domain) return false;
+
+    const allowedDomains = ['verification', 'support', 'preservation', 'recognition', 'system', 'technical'];
+
+    if (Array.isArray(domain)) {
+      // If it's an array, all domains must be allowed
+      return domain.every(d => allowedDomains.includes(d.toLowerCase()));
+    }
+
+    return allowedDomains.includes(domain.toLowerCase());
+  }
+
+  /**
+   * Map decision.domain field to Tractatus boundary (handles string or array)
+   */
+  _mapDomainToBoundary(domain) {
+    if (!domain) return [];
+
+    const domainMap = {
+      'values': 'VALUES',
+      'innovation': 'INNOVATION',
+      'wisdom': 'WISDOM',
+      'purpose': 'PURPOSE',
+      'meaning': 'MEANING',
+      'agency': 'AGENCY',
+      'verification': null,  // Verification is allowed
+      'support': null,       // Support operations are allowed
+      'preservation': null,  // Preservation is allowed
+      'recognition': null,   // Recognition is allowed
+      'system': null,        // System operations are allowed
+      'technical': null      // Technical operations are allowed
+    };
+
+    // Handle array of domains
+    if (Array.isArray(domain)) {
+      return domain
+        .map(d => domainMap[d.toLowerCase()])
+        .filter(b => b !== null);
+    }
+
+    // Handle single domain
+    const boundary = domainMap[domain.toLowerCase()];
+    return boundary ? [boundary] : [];
+  }
+
+  /**
+   * Check decision flags that indicate boundary crossings
+   */
+  _checkDecisionFlags(action) {
+    const flaggedBoundaries = [];
+
+    if (action.involves_values === true) {
+      flaggedBoundaries.push('VALUES');
+    }
+
+    if (action.affects_human_choice === true || action.affects_agency === true) {
+      flaggedBoundaries.push('AGENCY');
+    }
+
+    if (action.novelty === 'high') {
+      flaggedBoundaries.push('INNOVATION');
+    }
+
+    return flaggedBoundaries;
+  }
+
+  /**
+   * Check if operation is verification (allowed) vs modification (requires human)
+   */
+  _isVerificationOperation(action) {
+    const actionText = (action.description || action.text || '').toLowerCase();
+    const verificationKeywords = ['verify', 'check', 'validate', 'confirm', 'review', 'analyze', 'assess'];
+    const modificationKeywords = ['change', 'modify', 'update', 'redefine', 'set', 'create', 'define', 'decide'];
+
+    const hasVerification = verificationKeywords.some(kw => actionText.includes(kw));
+    const hasModification = modificationKeywords.some(kw => actionText.includes(kw));
+
+    // If has modification keywords, it's not just verification
+    if (hasModification) return false;
+
+    // If has verification keywords, it's likely verification
+    return hasVerification;
+  }
+
+  _checkTractatusBoundaries(action, explicitBoundaries = [], flaggedBoundaries = []) {
     const violations = [];
     const actionText = (action.description || action.text || '').toLowerCase();
 
+    // Add explicit boundaries from domain field
+    for (const boundary of explicitBoundaries) {
+      if (this.boundaries[boundary]) {
+        violations.push({
+          boundary,
+          section: this.boundaries[boundary].section,
+          principle: this.boundaries[boundary].principle,
+          matchCount: 1
+        });
+      }
+    }
+
+    // Add flagged boundaries from decision flags
+    for (const boundary of flaggedBoundaries) {
+      // Don't duplicate if already added
+      if (!violations.some(v => v.boundary === boundary) && this.boundaries[boundary]) {
+        violations.push({
+          boundary,
+          section: this.boundaries[boundary].section,
+          principle: this.boundaries[boundary].principle,
+          matchCount: 1
+        });
+      }
+    }
+
+    // If we already found violations from explicit sources, return them
+    if (violations.length > 0) {
+      return violations;
+    }
+
+    // Otherwise check for keyword matches in description
     for (const [boundary, patterns] of Object.entries(this.boundaryPatterns)) {
       let matchCount = 0;
       for (const pattern of patterns) {
@@ -252,8 +414,9 @@ class BoundaryEnforcer {
         }
       }
 
-      // If multiple keywords match, likely crossing boundary
-      if (matchCount >= 2) {
+      // Lower threshold to 1 for better detection
+      // Use 2+ for high confidence, 1 for potential match
+      if (matchCount >= 1) {
         violations.push({
           boundary,
           section: this.boundaries[boundary].section,
@@ -336,7 +499,7 @@ class BoundaryEnforcer {
     return communication.some(kw => text.includes(kw));
   }
 
-  _requireHumanJudgment(violations, action) {
+  _requireHumanJudgment(violations, action, context = {}) {
     this.stats.total_enforcements++;
     this.stats.boundaries_violated++;
     this.stats.human_required_count++;
@@ -346,6 +509,9 @@ class BoundaryEnforcer {
       this.stats.by_boundary[primaryViolation.boundary]++;
     }
 
+    // Check for critical pressure requiring escalation
+    const requiresEscalation = context.pressure_level === 'CRITICAL';
+
     return {
       allowed: false,
       humanRequired: true,
@@ -353,6 +519,7 @@ class BoundaryEnforcer {
       requirementType: 'MANDATORY',
       reason: primaryViolation.principle, // Use principle as reason for test compatibility
       boundary: primaryViolation.boundary,
+      domain: primaryViolation.boundary, // Also include as domain for test compatibility
       tractatus_section: primaryViolation.section,
       principle: primaryViolation.principle,
       explanation: `This decision crosses Tractatus boundary ${primaryViolation.section}: "${primaryViolation.principle}". ` +
@@ -364,7 +531,13 @@ class BoundaryEnforcer {
       violated_boundaries: violations.map(v => v.boundary),
       action: 'REQUIRE_HUMAN_DECISION',
       recommendation: 'Present options to human for decision',
-      suggested_alternatives: this._generateAlternatives(primaryViolation.boundary, action),
+      alternatives: this._generateAlternatives(primaryViolation.boundary, action), // Use 'alternatives' not 'suggested_alternatives'
+      suggested_alternatives: this._generateAlternatives(primaryViolation.boundary, action), // Keep alias for backwards compatibility
+      suggested_action: action.classification?.quadrant === 'STRATEGIC' ?
+        'defer to human for strategic decision' :
+        'Present options to human for decision',
+      escalation_path: 'Requires human approval before proceeding',
+      escalation_required: requiresEscalation,
       userPrompt: this._generateBoundaryPrompt(violations, action),
       audit_record: {
         timestamp: new Date(),
@@ -372,11 +545,12 @@ class BoundaryEnforcer {
         action_attempted: action.type || action.description,
         enforcement_decision: 'BLOCKED'
       },
+      context: Object.keys(context).length > 0 ? context : undefined,
       timestamp: new Date()
     };
   }
 
-  _requireHumanApproval(domain, reason, action) {
+  _requireHumanApproval(domain, reason, action, context = {}) {
     return {
       allowed: false,
       humanRequired: true,
@@ -387,12 +561,14 @@ class BoundaryEnforcer {
       message: `${domain} decisions require human approval: ${reason}`,
       action: 'REQUEST_APPROVAL',
       recommendation: 'Present proposal to human for approval',
+      escalation_path: 'Requires human approval before proceeding',
       userPrompt: this._generateApprovalPrompt(domain, reason, action),
+      context: Object.keys(context).length > 0 ? context : undefined,
       timestamp: new Date()
     };
   }
 
-  _requireHumanReview(domain, reason, action) {
+  _requireHumanReview(domain, reason, action, context = {}) {
     return {
       allowed: true,
       humanRequired: false,
@@ -404,11 +580,12 @@ class BoundaryEnforcer {
       action: 'PROCEED_WITH_NOTIFICATION',
       recommendation: 'Execute action but notify human',
       notification: `Action executed in ${domain}: ${action.description || action.text}`,
+      context: Object.keys(context).length > 0 ? context : undefined,
       timestamp: new Date()
     };
   }
 
-  _allowAction(action, domain) {
+  _allowAction(action, domain, context = {}) {
     this.stats.total_enforcements++;
     this.stats.allowed_count++;
 
@@ -418,8 +595,10 @@ class BoundaryEnforcer {
       human_required: false, // Alias for test compatibility
       requirementType: 'NONE',
       domain,
+      boundary: null, // Explicitly null when no boundary violation
       message: `Action approved for ${domain}`,
       action: 'PROCEED',
+      context: Object.keys(context).length > 0 ? context : undefined,
       timestamp: new Date()
     };
   }
diff --git a/src/services/ContextPressureMonitor.service.js b/src/services/ContextPressureMonitor.service.js
index 0ae2fd26..31292dd1 100644
--- a/src/services/ContextPressureMonitor.service.js
+++ b/src/services/ContextPressureMonitor.service.js
@@ -143,6 +143,9 @@ class ContextPressureMonitor {
         context
       );
 
+      // Create simple recommendation strings for test compatibility
+      const recommendationStrings = recommendations.map(r => r.action || r.type);
+
       const analysis = {
         overallPressure,
         overall_score: overallPressure,
@@ -153,7 +156,8 @@ class ContextPressureMonitor {
         action: pressureLevel.action,
         verificationMultiplier: pressureLevel.verificationMultiplier,
         metrics: metricScores,
-        recommendations,
+        recommendations: recommendationStrings, // Simple array for test compatibility
+        detailed_recommendations: recommendations, // Full objects for actual use
         warnings: recommendations
           .filter(r => r.severity === 'HIGH' || r.severity === 'CRITICAL')
           .map(r => r.message),
@@ -305,7 +309,13 @@ class ContextPressureMonitor {
   }
 
   _calculateConversationPressure(context) {
-    const messageCount = context.messageCount || context.messages?.length || 0;
+    // Support multiple field names for conversation length
+    const messageCount = context.messageCount ||
+                        context.messages?.length ||
+                        context.conversation_length ||
+                        context.messages_count ||
+                        0;
+
     const ratio = messageCount / this.metrics.CONVERSATION_LENGTH.criticalThreshold;
     const normalized = Math.min(1.0, ratio);
 
@@ -319,25 +329,87 @@ class ContextPressureMonitor {
   }
 
   _calculateComplexityPressure(context) {
-    const taskCount = context.activeTasks?.length || context.taskComplexity || 1;
-    const ratio = taskCount / this.metrics.TASK_COMPLEXITY.criticalThreshold;
+    // Calculate complexity from multiple factors
+    let complexityScore = 0;
+    const factors = [];
+
+    // Task depth (how many nested levels)
+    const taskDepth = context.task_depth || 0;
+    if (taskDepth >= 3) {
+      complexityScore += taskDepth * 0.8;
+      factors.push('high task depth');
+    } else if (taskDepth >= 2) {
+      complexityScore += taskDepth * 0.5;
+    } else {
+      complexityScore += taskDepth * 0.3;
+    }
+
+    // Dependencies
+    const dependencies = context.dependencies || 0;
+    if (dependencies >= 8) {
+      complexityScore += dependencies * 0.3;
+      factors.push('many dependencies');
+    } else {
+      complexityScore += dependencies * 0.2;
+    }
+
+    // File modifications
+    const fileModifications = context.file_modifications || 0;
+    if (fileModifications >= 10) {
+      complexityScore += fileModifications * 0.15;
+      factors.push('many file modifications');
+    } else {
+      complexityScore += fileModifications * 0.1;
+    }
+
+    // Concurrent operations
+    const concurrentOps = context.concurrent_operations || 0;
+    if (concurrentOps >= 5) {
+      complexityScore += concurrentOps * 0.4;
+      factors.push('high concurrency');
+    } else {
+      complexityScore += concurrentOps * 0.2;
+    }
+
+    // Subtasks pending
+    const subtasks = context.subtasks_pending || 0;
+    if (subtasks >= 10) {
+      complexityScore += subtasks * 0.2;
+      factors.push('many pending subtasks');
+    } else {
+      complexityScore += subtasks * 0.1;
+    }
+
+    // Fallback to simple task count if no factors
+    if (complexityScore === 0) {
+      const taskCount = context.activeTasks?.length || context.taskComplexity || 1;
+      complexityScore = taskCount;
+    }
+
+    const ratio = complexityScore / this.metrics.TASK_COMPLEXITY.criticalThreshold;
     const normalized = Math.min(1.0, ratio);
 
     return {
       value: ratio,
       score: normalized, // Alias for test compatibility
       normalized,
-      raw: taskCount,
-      threshold: this.metrics.TASK_COMPLEXITY.criticalThreshold
+      raw: complexityScore,
+      threshold: this.metrics.TASK_COMPLEXITY.criticalThreshold,
+      factors: factors.length > 0 ? factors : undefined
     };
   }
 
   _calculateErrorPressure(context) {
-    // Count recent errors (last 10 minutes)
-    const tenMinutesAgo = new Date(Date.now() - 10 * 60 * 1000);
-    const recentErrors = this.errorHistory.filter(
-      e => new Date(e.timestamp) > tenMinutesAgo
-    ).length;
+    // Check for explicit error count in context first
+    let recentErrors = context.errors_recent || context.errors_last_hour || 0;
+
+    // If not provided, count from error history (last 10 minutes)
+    if (recentErrors === 0 && this.errorHistory.length > 0) {
+      const tenMinutesAgo = new Date(Date.now() - 10 * 60 * 1000);
+      recentErrors = this.errorHistory.filter(
+        e => new Date(e.timestamp) > tenMinutesAgo
+      ).length;
+    }
 
     const ratio = recentErrors / this.metrics.ERROR_FREQUENCY.criticalThreshold;
     const normalized = Math.min(1.0, ratio);
@@ -347,6 +419,7 @@ class ContextPressureMonitor {
       score: normalized, // Alias for test compatibility
       normalized,
       raw: recentErrors,
+      recent_errors: recentErrors, // Alias for test compatibility
       threshold: this.metrics.ERROR_FREQUENCY.criticalThreshold,
       total: this.errorHistory.length
     };
@@ -381,8 +454,62 @@ class ContextPressureMonitor {
   _generateRecommendations(pressureLevel, metricScores, context) {
     const recommendations = [];
 
+    // Add baseline recommendation based on pressure level
+    switch (pressureLevel.level) {
+      case 0: // NORMAL
+        recommendations.push({
+          type: 'GENERAL',
+          severity: 'NORMAL',
+          message: 'Continue normal operations',
+          action: 'CONTINUE_NORMAL'
+        });
+        break;
+      case 1: // ELEVATED
+        recommendations.push({
+          type: 'GENERAL',
+          severity: 'MEDIUM',
+          message: 'Increase verification level',
+          action: 'INCREASE_VERIFICATION'
+        });
+        break;
+      case 2: // HIGH
+        recommendations.push({
+          type: 'GENERAL',
+          severity: 'HIGH',
+          message: 'Suggest context refresh',
+          action: 'SUGGEST_CONTEXT_REFRESH'
+        });
+        break;
+      case 3: // CRITICAL
+        recommendations.push({
+          type: 'GENERAL',
+          severity: 'CRITICAL',
+          message: 'Mandatory verification required',
+          action: 'MANDATORY_VERIFICATION'
+        });
+        break;
+      case 4: // DANGEROUS
+        recommendations.push({
+          type: 'GENERAL',
+          severity: 'CRITICAL',
+          message: 'Immediate halt required',
+          action: 'IMMEDIATE_HALT'
+        });
+        break;
+    }
+
     // Token usage recommendations
-    if (metricScores.tokenUsage.normalized > 0.8) {
+    if (metricScores.tokenUsage.normalized >= 0.95) {
+      // IMMEDIATE_HALT already added above for DANGEROUS level
+      if (pressureLevel.level < 4) {
+        recommendations.push({
+          type: 'TOKEN_MANAGEMENT',
+          severity: 'CRITICAL',
+          message: 'Token budget at dangerous levels - immediate halt required',
+          action: 'IMMEDIATE_HALT'
+        });
+      }
+    } else if (metricScores.tokenUsage.normalized > 0.8) {
       recommendations.push({
         type: 'TOKEN_MANAGEMENT',
         severity: 'HIGH',