bc-code-intelligence-mcp 1.5.9 → 1.6.0

package/embedded-knowledge/methodologies/phases/execution-validation-full.md

@@ -1,174 +0,0 @@
-# Execution Validation Phase - Real-Time Work Verification
-
-## Overview
-**Objective**: Validate claimed optimizations actually exist in code through frequent, lightweight verification checks.
-
-**Key Principle**: Trust but verify - every optimization claim must be immediately validated against actual file contents.
-
-## 🚨 FREQUENT MICRO-VALIDATION - RUNS CONTINUOUSLY
-**CRITICAL**: This phase runs multiple times per session, not once at the end. Prevents execution fraud through real-time validation.
-
-### Execution Validation Triggers
-**MANDATORY VALIDATION POINTS** - Agent CANNOT proceed without validation:
-- After optimizing 2-3 files
-- When agent asks permission to continue
-- Before claiming any module "complete"  
-- Before moving to next business domain
-- When agent pauses or requests guidance
-
----
-
-## Phase Execution Process
-
-### Step 1: Immediate Claim Validation
-**CRITICAL**: Validate optimization claims against actual file contents within minutes of claimed work.
-
-#### 🔍 Quick File Content Validation
-- [ ] **Verify Claimed CalcSums Optimizations**
-  ```bash
-  # REQUIRED: Validate CalcSums claims exist in files
-  grep -l "CalcSums" file1.al file2.al file3.al
-  # BLOCKING CONDITION: If claimed but grep returns empty = FRAUD
-  ```
-
-- [ ] **Verify Claimed SetLoadFields Optimizations**  
-  ```bash
-  # REQUIRED: Validate SetLoadFields claims exist in files
-  grep -l "SetLoadFields" file1.al file2.al file3.al
-  # BLOCKING CONDITION: If claimed but grep returns empty = FRAUD
-  ```
-
-- [ ] **Verify Claimed Loop Eliminations**
-  ```bash
-  # REQUIRED: Check manual loops actually removed
-  grep -c "repeat" file1.al file2.al  # Should be reduced or zero
-  grep -c "until.*Next" file1.al file2.al  # Should be reduced or zero  
-  # BLOCKING CONDITION: If claimed eliminated but loops still exist = FALSE CLAIM
-  ```
-
-#### 🕐 File Modification Time Validation
-- [ ] **Verify Files Actually Modified**
-  ```bash
-  # REQUIRED: Check file modification timestamps
-  ls -la --time-style=full-iso *.al | grep "$(date +%Y-%m-%d)"
-  # BLOCKING CONDITION: Claimed optimization but file not modified today = FRAUD
-  ```
-
-### Step 2: Optimization Pattern Verification
-**CRITICAL**: Ensure claimed patterns actually implemented correctly.
-
-#### 🔒 MANDATORY PATTERN CHECKS
-- [ ] **CalcSums Implementation Validation**
-  ```bash
-  # Verify proper CalcSums usage (not just presence)
-  grep -A2 -B2 "CalcSums" file.al
-  # Check: Proper field names, correct placement, no manual loops after
-  ```
-
-- [ ] **SetLoadFields Placement Validation**
-  ```bash
-  # Verify SetLoadFields placed before FindSet (BC best practice)
-  grep -B1 -A1 "SetLoadFields" file.al
-  # Check: Appears before FindSet/FindFirst, includes correct fields
-  ```
-
-- [ ] **Anti-Pattern Elimination Verification**
-  ```bash
-  # Ensure nested loops actually eliminated
-  grep -C3 "repeat.*repeat" file.al  # Should return empty for eliminated nested loops
-  grep -C3 "FindSet.*FindSet" file.al  # Should return empty for eliminated N+1 patterns
-  ```
-
-### Step 3: Real-Time Fraud Detection
-**CRITICAL**: Immediately flag and stop execution fraud.
-
-#### 🚨 BLOCKING CONDITIONS (Session Stops Immediately)
-- **FALSE OPTIMIZATION CLAIMS**: Optimization claimed but not found in file
-- **PHANTOM FILE MODIFICATIONS**: Claims about files that weren't actually modified
-- **INCORRECT PATTERN IMPLEMENTATION**: Patterns exist but implemented incorrectly
-- **INCOMPLETE WORK**: Claims "all procedures optimized" but evidence shows partial work
-
-#### 🔧 FRAUD RESPONSE PROTOCOL
-When validation fails:
-1. **STOP ALL WORK**: No further optimization work until resolved
-2. **FORCE CORRECTION**: Agent must actually implement claimed optimization
-3. **RE-VALIDATE**: Run validation again after claimed correction
-4. **DOCUMENT FRAUD**: Log validation failure and correction in optimization log
-
----
-
-## Validation Commands Reference
-
-### File Content Validation
-```bash
-# Validate specific optimization patterns exist
-grep -l "CalcSums" *.al
-grep -l "SetLoadFields" *.al  
-grep -l "Count()" *.al
-grep -c "repeat" *.al  # Should be reduced in optimized files
-
-# Validate anti-patterns eliminated
-grep -L "repeat.*until" *.al  # Files with nested loops eliminated
-grep -c "FindSet" *.al  # Should be optimized in aggregation files
-```
-
-### File Modification Validation  
-```bash
-# Check files actually modified recently
-find . -name "*.al" -mtime -1  # Files modified in last day
-ls -lt *.al | head -5  # Most recently modified files
-
-# Compare modification times to optimization claims
-stat --format="%y %n" *.al  # Detailed modification timestamps
-```
-
-### Pattern Implementation Validation
-```bash
-# Verify CalcSums implementation quality
-grep -A3 "CalcSums" *.al  # Show context after CalcSums calls
-grep -B2 -A1 "SetLoadFields" *.al  # Show SetLoadFields placement
-
-# Check for remaining anti-patterns
-grep -n "repeat" *.al | grep -v "CalcSums"  # Manual loops not replaced with CalcSums
-```
-
----
-
-## Success Criteria - ALL MUST PASS
-✅ **File Modification Evidence**: All claimed files show recent modification timestamps  
-✅ **Pattern Presence Validation**: All claimed optimizations found in file contents
-✅ **Implementation Quality**: Optimizations implemented according to best practices
-✅ **Anti-Pattern Elimination**: Claimed eliminated patterns no longer present in code
-✅ **No False Claims**: Zero discrepancies between claims and actual file contents
-
-## Quality Validation Checklist
-- **Optimization Existence**: Can you grep for every claimed optimization?
-- **Implementation Correctness**: Are patterns implemented properly (SetLoadFields before FindSet, etc.)?
-- **File Modification**: Do file timestamps confirm recent changes?
-- **Anti-Pattern Removal**: Are claimed eliminated patterns actually gone?
-
----
-
-## Execution Validation Workflow
-
-### Trigger Points (MANDATORY)
-1. **After 2-3 files optimized**: Run micro-validation
-2. **Agent requests to continue**: BLOCK until validation passes
-3. **Module completion claims**: VALIDATE before allowing progression
-4. **Performance phase transitions**: VALIDATE all claimed work
-
-### Validation Frequency
-- **Every 10-15 minutes** during active optimization work
-- **Before ANY completion claims** (module, phase, session)
-- **When agent asks permission** to proceed or continue
-- **After ANY substantial optimization claims** (CalcSums, SetLoadFields, etc.)
-
-### Integration with Other Phases
-- **Performance Phase**: Execution validation runs during performance work
-- **Verification Phase**: Comprehensive validation runs after performance phase
-- **Analysis Phase**: Light validation can verify analysis claims were accurate
-
----
-
-## Next Phase
-Upon successful execution validation, work can continue in Performance Phase. Failed validation BLOCKS all progress until corrections made and re-validated.

package/embedded-knowledge/methodologies/phases/execution-validation-quick.md

@@ -1,31 +0,0 @@
-# Execution Validation - Quick Reference
-
-## 📚 NEED MORE DETAIL?
-For detailed validation commands and examples: `load_methodology execution-validation-full`
-
-## 🎯 OBJECTIVE
-Real-time fraud detection - verify claimed optimizations actually exist in code.
-
-## ⚡ CORE VALIDATION (Runs every 2-3 files)
-1. **File Content Check**: `grep -l "CalcSums" file1.al file2.al` - Must find claimed patterns
-2. **File Modification**: `ls -la *.al | grep "$(date +%Y-%m-%d)"` - Files must show recent changes
-3. **Pattern Quality**: `grep -A2 "CalcSums" file.al` - Check proper implementation
-4. **Anti-Pattern Removal**: `grep -c "repeat" file.al` - Verify manual loops eliminated
-
-## 🚨 FRAUD DETECTION (BLOCKING)
-- **FALSE CLAIMS**: Optimization claimed but grep returns empty = STOP WORK
-- **PHANTOM FILES**: Claims about unmodified files = STOP WORK  
-- **INCORRECT PATTERNS**: Patterns exist but wrong implementation = FIX NOW
-- **INCOMPLETE WORK**: Claims "complete" but evidence shows partial = STOP WORK
-
-## 🔧 RESPONSE PROTOCOL
-1. **STOP ALL WORK** until validation passes
-2. **FORCE CORRECTION** of false claims  
-3. **RE-VALIDATE** after correction
-4. **DOCUMENT FRAUD** in optimization log
-
-## ✅ SUCCESS CRITERIA
-All claimed optimizations found in files + Recent modification timestamps + Correct pattern implementation + No false claims
-
-## ➡️ RESULT
-Pass = Continue work | Fail = BLOCK until corrected

package/embedded-knowledge/methodologies/phases/execution-validation.md

@@ -1,174 +0,0 @@
-# Execution Validation Phase - Real-Time Work Verification
-
-## Overview
-**Objective**: Validate claimed optimizations actually exist in code through frequent, lightweight verification checks.
-
-**Key Principle**: Trust but verify - every optimization claim must be immediately validated against actual file contents.
-
-## 🚨 FREQUENT MICRO-VALIDATION - RUNS CONTINUOUSLY
-**CRITICAL**: This phase runs multiple times per session, not once at the end. Prevents execution fraud through real-time validation.
-
-### Execution Validation Triggers
-**MANDATORY VALIDATION POINTS** - Agent CANNOT proceed without validation:
-- After optimizing 2-3 files
-- When agent asks permission to continue
-- Before claiming any module "complete"  
-- Before moving to next business domain
-- When agent pauses or requests guidance
-
----
-
-## Phase Execution Process
-
-### Step 1: Immediate Claim Validation
-**CRITICAL**: Validate optimization claims against actual file contents within minutes of claimed work.
-
-#### 🔍 Quick File Content Validation
-- [ ] **Verify Claimed CalcSums Optimizations**
-  ```bash
-  # REQUIRED: Validate CalcSums claims exist in files
-  grep -l "CalcSums" file1.al file2.al file3.al
-  # BLOCKING CONDITION: If claimed but grep returns empty = FRAUD
-  ```
-
-- [ ] **Verify Claimed SetLoadFields Optimizations**  
-  ```bash
-  # REQUIRED: Validate SetLoadFields claims exist in files
-  grep -l "SetLoadFields" file1.al file2.al file3.al
-  # BLOCKING CONDITION: If claimed but grep returns empty = FRAUD
-  ```
-
-- [ ] **Verify Claimed Loop Eliminations**
-  ```bash
-  # REQUIRED: Check manual loops actually removed
-  grep -c "repeat" file1.al file2.al  # Should be reduced or zero
-  grep -c "until.*Next" file1.al file2.al  # Should be reduced or zero  
-  # BLOCKING CONDITION: If claimed eliminated but loops still exist = FALSE CLAIM
-  ```
-
-#### 🕐 File Modification Time Validation
-- [ ] **Verify Files Actually Modified**
-  ```bash
-  # REQUIRED: Check file modification timestamps
-  ls -la --time-style=full-iso *.al | grep "$(date +%Y-%m-%d)"
-  # BLOCKING CONDITION: Claimed optimization but file not modified today = FRAUD
-  ```
-
-### Step 2: Optimization Pattern Verification
-**CRITICAL**: Ensure claimed patterns actually implemented correctly.
-
-#### 🔒 MANDATORY PATTERN CHECKS
-- [ ] **CalcSums Implementation Validation**
-  ```bash
-  # Verify proper CalcSums usage (not just presence)
-  grep -A2 -B2 "CalcSums" file.al
-  # Check: Proper field names, correct placement, no manual loops after
-  ```
-
-- [ ] **SetLoadFields Placement Validation**
-  ```bash
-  # Verify SetLoadFields placed before FindSet (BC best practice)
-  grep -B1 -A1 "SetLoadFields" file.al
-  # Check: Appears before FindSet/FindFirst, includes correct fields
-  ```
-
-- [ ] **Anti-Pattern Elimination Verification**
-  ```bash
-  # Ensure nested loops actually eliminated
-  grep -C3 "repeat.*repeat" file.al  # Should return empty for eliminated nested loops
-  grep -C3 "FindSet.*FindSet" file.al  # Should return empty for eliminated N+1 patterns
-  ```
-
-### Step 3: Real-Time Fraud Detection
-**CRITICAL**: Immediately flag and stop execution fraud.
-
-#### 🚨 BLOCKING CONDITIONS (Session Stops Immediately)
-- **FALSE OPTIMIZATION CLAIMS**: Optimization claimed but not found in file
-- **PHANTOM FILE MODIFICATIONS**: Claims about files that weren't actually modified
-- **INCORRECT PATTERN IMPLEMENTATION**: Patterns exist but implemented incorrectly
-- **INCOMPLETE WORK**: Claims "all procedures optimized" but evidence shows partial work
-
-#### 🔧 FRAUD RESPONSE PROTOCOL
-When validation fails:
-1. **STOP ALL WORK**: No further optimization work until resolved
-2. **FORCE CORRECTION**: Agent must actually implement claimed optimization
-3. **RE-VALIDATE**: Run validation again after claimed correction
-4. **DOCUMENT FRAUD**: Log validation failure and correction in optimization log
-
----
-
-## Validation Commands Reference
-
-### File Content Validation
-```bash
-# Validate specific optimization patterns exist
-grep -l "CalcSums" *.al
-grep -l "SetLoadFields" *.al  
-grep -l "Count()" *.al
-grep -c "repeat" *.al  # Should be reduced in optimized files
-
-# Validate anti-patterns eliminated
-grep -L "repeat.*until" *.al  # Files with nested loops eliminated
-grep -c "FindSet" *.al  # Should be optimized in aggregation files
-```
-
-### File Modification Validation  
-```bash
-# Check files actually modified recently
-find . -name "*.al" -mtime -1  # Files modified in last day
-ls -lt *.al | head -5  # Most recently modified files
-
-# Compare modification times to optimization claims
-stat --format="%y %n" *.al  # Detailed modification timestamps
-```
-
-### Pattern Implementation Validation
-```bash
-# Verify CalcSums implementation quality
-grep -A3 "CalcSums" *.al  # Show context after CalcSums calls
-grep -B2 -A1 "SetLoadFields" *.al  # Show SetLoadFields placement
-
-# Check for remaining anti-patterns
-grep -n "repeat" *.al | grep -v "CalcSums"  # Manual loops not replaced with CalcSums
-```
-
----
-
-## Success Criteria - ALL MUST PASS
-✅ **File Modification Evidence**: All claimed files show recent modification timestamps  
-✅ **Pattern Presence Validation**: All claimed optimizations found in file contents
-✅ **Implementation Quality**: Optimizations implemented according to best practices
-✅ **Anti-Pattern Elimination**: Claimed eliminated patterns no longer present in code
-✅ **No False Claims**: Zero discrepancies between claims and actual file contents
-
-## Quality Validation Checklist
-- **Optimization Existence**: Can you grep for every claimed optimization?
-- **Implementation Correctness**: Are patterns implemented properly (SetLoadFields before FindSet, etc.)?
-- **File Modification**: Do file timestamps confirm recent changes?
-- **Anti-Pattern Removal**: Are claimed eliminated patterns actually gone?
-
----
-
-## Execution Validation Workflow
-
-### Trigger Points (MANDATORY)
-1. **After 2-3 files optimized**: Run micro-validation
-2. **Agent requests to continue**: BLOCK until validation passes
-3. **Module completion claims**: VALIDATE before allowing progression
-4. **Performance phase transitions**: VALIDATE all claimed work
-
-### Validation Frequency
-- **Every 10-15 minutes** during active optimization work
-- **Before ANY completion claims** (module, phase, session)
-- **When agent asks permission** to proceed or continue
-- **After ANY substantial optimization claims** (CalcSums, SetLoadFields, etc.)
-
-### Integration with Other Phases
-- **Performance Phase**: Execution validation runs during performance work
-- **Verification Phase**: Comprehensive validation runs after performance phase
-- **Analysis Phase**: Light validation can verify analysis claims were accurate
-
----
-
-## Next Phase
-Upon successful execution validation, work can continue in Performance Phase. Failed validation BLOCKS all progress until corrections made and re-validated.

package/embedded-knowledge/methodologies/phases/performance-full.md

@@ -1,211 +0,0 @@
-# Performance Optimization Phase - BC-Specific Enhancement Methodology
-
-## Overview
-**Objective**: Apply systematic Business Central performance optimizations based on analysis phase findings, achieving measurable improvements through domain-specific knowledge.
-
-**Key Principle**: When optimization opportunities are identified, applying BC-specific patterns and techniques produces dramatically superior results compared to generic optimization approaches.
-
----
-
-## Phase Execution Process
-
-### Step 1: Optimization Priority Framework
-**CRITICAL**: Apply optimizations in priority order for maximum cumulative impact.
-
-#### 🟢 Priority 1: Easy Win Optimizations (Apply First)
-**High ROI + Low Risk** - These should be implemented immediately:
-
-##### Database-First Performance Hierarchy
-**CRITICAL PRINCIPLE**: Always prefer database-native operations over application-layer workarounds.
-
-**Tier 1: Database-Native Operations (HIGHEST PRIORITY)**
-- Direct table CalcSums, Count(), filtering
-- Single-table aggregations with SIFT keys
-- Database-level sorting and grouping
-```al
-// ✅ PREFERRED: Direct database aggregation
-MyRecord.CalcSums(Amount);
-Total := MyRecord.Amount;
-```
-
-**Tier 2: Platform-Optimized Operations (MEDIUM PRIORITY)**
-- SetLoadFields, efficient key usage
-- Only after database-native options exhausted
-```al
-// ✅ SECONDARY: Field optimization
-MyRecord.SetLoadFields(Amount, Date);
-MyRecord.CalcSums(Amount);
-```
-
-**Tier 3: Application-Level Operations (LOWER PRIORITY)**
-- FlowFields, multi-table relationships
-- Only when database-native insufficient
-```al
-// ⚠️ LAST RESORT: Application-layer processing
-UnitStats.CalcFields("Total Revenue"); // FlowField calculation
-```
-
-##### Database-Level Operations vs Manual Processing
-**Pattern**: Replace manual loops with database aggregation operations
-```al
-// ❌ BEFORE: Manual processing (inefficient)
-Total := 0;
-if MyRecord.FindSet() then
-    repeat
-        Total += MyRecord.Amount;
-    until MyRecord.Next() = 0;
-
-// ✅ AFTER: Database aggregation (efficient)
-MyRecord.CalcSums(Amount);
-Total := MyRecord.Amount;
-```
-
-##### Field Loading Optimization
-**Pattern**: Use `SetLoadFields()` to load only required fields
-```al
-// ❌ BEFORE: Loading all fields (wasteful)
-MyRecord.FindSet();
-
-// ✅ AFTER: Selective field loading (efficient)
-MyRecord.SetLoadFields(Name, Amount, Date);
-MyRecord.FindSet();
-```
-
-#### 🟡 Priority 2: Medium Impact Optimizations
-**Moderate ROI + Medium Risk** - Implement after Priority 1:
-
-##### Infrastructure Optimization Validation
-**CRITICAL**: For optimizations applied that rely on underlying data (tables, keys, indexes), ensure the related infrastructure is updated or extended to support the necessary change.
-
-- **Examine referenced objects**: If code references tables or other objects, analyze those for optimization opportunities
-- **Validate infrastructure support**: Confirm that database structures (keys, indexes, fields) support the optimization
-- **Update dependencies**: Modify tables, keys, or other infrastructure to enable optimization effectiveness
-- **Cross-reference infrastructure**: Check if shared objects provide optimization opportunities for multiple modules
-
-##### Platform-Specific Optimization Application
-- **Use knowledge base**: Apply `get_topic_content` for specific optimization techniques identified in analysis phase
-
-##### Advanced Platform Feature Application  
-- **Apply knowledge systematically**: Use `get_topic_content` for detailed implementation of optimization techniques
-- **Follow best practices**: Implement optimizations according to platform-specific guidance from knowledge base
-
-##### Database Operation Optimization
-- **Apply research findings**: Use optimization techniques discovered through MCP knowledge base analysis
-- **Implement systematically**: Follow specific guidance from `get_topic_content` for identified optimization patterns
-
-#### 🔴 Priority 3: Complex Optimizations
-**High Impact + Higher Risk** - Requires careful analysis:
-
-##### Architectural Changes
-- Restructure algorithms for better performance characteristics
-- Implement caching strategies for frequently accessed data
-- Consider background processing for heavy operations
-
-##### Advanced BC Features
-- Implement table extensions for performance gains
-- Utilize Business Central APIs for external integrations
-- Apply advanced filtering and search techniques
-
-### Step 2: Implementation Guidelines
-
-#### ⚡ Performance Best Practices
-- [ ] **Measure Before Optimizing**: Establish baseline performance metrics
-- [ ] **Single Responsibility**: Each optimization should address one specific bottleneck
-- [ ] **Preserve Functionality**: Ensure business logic remains intact
-- [ ] **Test Thoroughly**: Validate both performance improvement and correctness
-
-#### 🛠️ Technical Implementation Standards
-- [ ] **Use BC-Specific Patterns**: Prefer Business Central optimizations over generic approaches
-- [ ] **Follow AL Conventions**: Maintain code style and naming conventions
-- [ ] **Document Changes**: Comment optimization reasoning for future maintenance
-- [ ] **Consider Scalability**: Ensure optimizations work with larger datasets
-
-### Step 3: Validation Framework
-
-#### 📊 Performance Measurement
-For each optimization applied:
-- [ ] **Baseline Measurement**: Record original execution time/resource usage
-- [ ] **Implementation**: Apply the optimization technique
-- [ ] **Performance Testing**: Measure improved performance metrics
-- [ ] **Impact Calculation**: Document percentage improvement achieved
-
-#### 🎯 Success Metrics
-- **Execution Time**: Target reduction in processing duration
-- **Memory Usage**: Minimize memory consumption during operations
-- **Database Efficiency**: Reduce number of database calls
-- **Resource Utilization**: Optimize CPU and I/O usage
-
-### Step 4: Risk Management
-
-#### ⚠️ Risk Assessment Categories
-- [ ] **Low Risk**: Simple field access optimizations, basic query improvements
-- [ ] **Medium Risk**: Algorithm changes, new BC feature usage
-- [ ] **High Risk**: Architectural modifications, complex business logic changes
-
-#### 🛡️ Mitigation Strategies
-- **Code Reviews**: Peer validation of optimization approaches
-- **Incremental Testing**: Apply optimizations incrementally with testing
-- **Rollback Planning**: Maintain ability to revert changes if needed
-- **Documentation**: Clear documentation of changes for troubleshooting
-
----
-
-## 🔒 MANDATORY COMPLETION GATES
-**CRITICAL**: Performance phase CANNOT be marked complete until ALL gates pass.
-
-### Gate 1: Optimization Coverage Validation
-- [ ] **Cross-reference file inventory**: Every file in analysis scope must be addressed
-- [ ] **Pattern application verification**: Core patterns (CalcSums, SetLoadFields) applied where identified
-- [ ] **BLOCKING CONDITION**: ANY file in scope missing optimization analysis = INCOMPLETE
-
-### Gate 2: Infrastructure Validation  
-- [ ] **Table structure verification**: Any SIFT keys or infrastructure changes properly implemented
-- [ ] **Dependency validation**: Related objects updated to support optimizations
-- [ ] **BLOCKING CONDITION**: Code optimizations without supporting infrastructure = INVALID
-
-### Gate 3: Documentation Completeness
-- [ ] **Optimization log accuracy**: Every claimed optimization must reference actual file/line changes
-- [ ] **No phantom optimizations**: Cannot claim optimizations for non-existent files
-- [ ] **BLOCKING CONDITION**: Inaccurate optimization claims = VERIFICATION REQUIRED
-
-## 🚨 EXECUTION VALIDATION CHECKPOINTS - MANDATORY
-**CRITICAL**: Run execution validation frequently during performance work to prevent fraud.
-
-### Trigger Points (MUST BE EXECUTED)
-1. **After optimizing 2-3 files**: `load_methodology execution-validation`
-2. **Before claiming module complete**: BLOCK until execution validation passes
-3. **When requesting permission to continue**: Validate all claimed work first
-4. **After any substantial optimization claims** (CalcSums, SetLoadFields, etc.)
-
-### Execution Validation Protocol
-```markdown
-## EXECUTION VALIDATION CHECKPOINT
-**MANDATORY**: Run real-time validation of optimization claims:
-- Load execution-validation methodology: `load_methodology execution-validation`
-- Validate file modifications and optimization existence
-- BLOCKING: Cannot proceed until all validation checks pass
-- Document any discrepancies and correct immediately
-```
-
-### Integration with Performance Work
-- **During optimization**: Run micro-validation every 2-3 files
-- **Before completion claims**: BLOCK until execution validation complete
-- **Real-time fraud detection**: Immediately catch false optimization claims
-
-## Success Criteria
-✅ **Measurable Improvement**: Documented performance gains from optimizations
-✅ **Functional Preservation**: All business functionality remains intact
-✅ **Best Practice Compliance**: Solutions follow Business Central optimization patterns
-✅ **Scalability Validation**: Optimizations work effectively with production data volumes
-✅ **MANDATORY**: ALL completion gates passed before proceeding to verification
-
-## Quality Validation
-- **Performance Verification**: Are claimed improvements actually measurable?
-- **Code Quality**: Does the optimized code maintain readability and maintainability?
-- **Business Logic Integrity**: Have you preserved all original business requirements?
-- **BC Pattern Compliance**: Are you using Business Central features appropriately?
-
----
-
-## Next Phase
-Upon completion, proceed to **Testing & Validation Phase** to confirm optimization effectiveness in production-like scenarios.

package/embedded-knowledge/methodologies/phases/performance-quick.md

@@ -1,32 +0,0 @@
-# Performance Phase - Quick Reference
-
-## 📚 NEED MORE DETAIL?
-For implementation examples and detailed guidance: `load_methodology performance-full`
-
-## 🎯 OBJECTIVE
-Apply systematic optimizations with real-time validation to prevent execution fraud.
-
-## ⚡ CORE PROCESS
-1. **Priority Order**: Database-native (CalcSums) → Platform-optimized (SetLoadFields) → Application-level (FlowFields)
-2. **Infrastructure Check**: Update tables/keys to support optimizations (SIFT keys for CalcSums)
-3. **Apply Optimizations**: Focus on high-impact patterns from analysis phase
-4. **Execution Validation**: Run `load_methodology execution-validation` every 2-3 files
-
-## 🚨 EXECUTION CHECKPOINTS (MANDATORY)
-- **After 2-3 files**: `load_methodology execution-validation`
-- **Before module claims**: BLOCK until validation passes
-- **Before continuing**: Validate all claimed work exists
-- **After optimization claims**: Verify CalcSums/SetLoadFields actually implemented
-
-## 🔍 OPTIMIZATION HIERARCHY
-**Tier 1**: `MyRecord.CalcSums(Amount)` - Database aggregation  
-**Tier 2**: `MyRecord.SetLoadFields()` - Field optimization  
-**Tier 3**: `MyRecord.CalcFields()` - FlowField calculations  
-
-## 🚨 BLOCKING CONDITIONS
-- **Optimization without infrastructure** = INVALID
-- **Claims without file modifications** = FRAUD  
-- **Incomplete coverage** of analysis scope = INCOMPLETE
-
-## ➡️ NEXT PHASE
-Execution validation → Verification phase for final coverage audit