@jwikman/bc-code-intelligence-mcp 1.5.7-dev.1

package/embedded-knowledge/indexes/tags/syntax.json

@@ -0,0 +1 @@
+["maya-mentor/case-statement-syntax-structure.md"]

package/embedded-knowledge/indexes/tags/systemid.json

@@ -0,0 +1 @@
+["alex-architect/systemid-integration.md"]

package/embedded-knowledge/indexes/tags/table-configuration.json

@@ -0,0 +1 @@
+["dean-debug/maintainsiftindex-property-behavior.md"]

package/embedded-knowledge/indexes/tags/table-events.json

@@ -0,0 +1 @@
+["dean-debug/table-event-batch-operation-impact.md"]

package/embedded-knowledge/indexes/tags/table-keys.json

@@ -0,0 +1 @@
+["dean-debug/table-key-requirements.md"]

package/embedded-knowledge/indexes/tags/table-safety.json

@@ -0,0 +1 @@
+["quinn-tester/table-safety-validation-patterns.md"]

package/embedded-knowledge/indexes/tags/task-scheduler.json

@@ -0,0 +1 @@
+["jordan-bridge/task-scheduler-pattern-implementation.md"]

package/embedded-knowledge/indexes/tags/telemetry.json

@@ -0,0 +1 @@
+["dean-debug/custom-dimensions-best-practices.md","dean-debug/custom-telemetry-implementation.md","dean-debug/extension-telemetry-isolation.md","dean-debug/session-logmessage-methods.md","dean-debug/telemetry-error-correlation.md","dean-debug/telemetry-performance-considerations.md","dean-debug/telemetry-verbosity-strategy.md"]

package/embedded-knowledge/indexes/tags/template-method.json

@@ -0,0 +1 @@
+["sam-coder/template-method-pattern-al.md"]

package/embedded-knowledge/indexes/tags/temporary-tables.json

@@ -0,0 +1 @@
+["quinn-tester/temporary-table-operation-validation.md","seth-security/al-temporary-table-safety.md","seth-security/istemporary-safeguard-pattern.md"]

package/embedded-knowledge/indexes/tags/testfield.json

@@ -0,0 +1 @@
+["maya-mentor/fielderror-vs-testfield.md"]

package/embedded-knowledge/indexes/tags/tradeoffs.json

@@ -0,0 +1 @@
+["dean-debug/deleteall-performance-tradeoff.md"]

package/embedded-knowledge/indexes/tags/triggers.json

@@ -0,0 +1 @@
+["roger-reviewer/al-begin-end-block-structure.md","sam-coder/deleteall-method-usage.md","sam-coder/deleteall-trigger-execution.md"]

package/embedded-knowledge/indexes/tags/troubleshooting.json

@@ -0,0 +1 @@
+["dean-debug/telemetry-error-correlation.md","roger-reviewer/case-statement-error-handling-troubleshooting.md"]

package/embedded-knowledge/indexes/tags/type-safety.json

@@ -0,0 +1 @@
+["sam-coder/generic-method-patterns-al.md","sam-coder/type-safe-operations-al.md"]

package/embedded-knowledge/indexes/tags/url-structure.json

@@ -0,0 +1 @@
+["jordan-bridge/url-structure-naming-patterns.md"]

package/embedded-knowledge/indexes/tags/user-experience.json

@@ -0,0 +1 @@
+["eva-errors/fielderror-message-construction.md","eva-errors/testfield-error-handling.md","roger-reviewer/begin-block-statement-clarity.md","uma-ux/shortcut-key-user-experience-design.md"]

package/embedded-knowledge/indexes/tags/user-feedback.json

@@ -0,0 +1 @@
+["maya-mentor/fielderror-syntax-usage.md"]

package/embedded-knowledge/indexes/tags/user-interface.json

@@ -0,0 +1 @@
+["uma-ux/bc-action-shortcuts-syntax.md"]

package/embedded-knowledge/indexes/tags/validation-feedback.json

@@ -0,0 +1 @@
+["eva-errors/fielderror-message-construction.md"]

package/embedded-knowledge/indexes/tags/validation.json

@@ -0,0 +1 @@
+["dean-debug/testfield-performance.md","eva-errors/fielderror-method-syntax.md","eva-errors/testfield-error-handling.md","maya-mentor/fielderror-syntax-usage.md","maya-mentor/fielderror-vs-testfield.md","maya-mentor/testfield-basic-syntax.md","quinn-tester/fielderror-validation-patterns.md","quinn-tester/rule-execution.md","quinn-tester/table-safety-validation-patterns.md","quinn-tester/temporary-table-operation-validation.md","sam-coder/testfield-patterns.md"]

package/embedded-knowledge/indexes/tags/variables.json

@@ -0,0 +1 @@
+["roger-reviewer/al-variable-declaration-order.md","roger-reviewer/al-variable-naming-conventions.md"]

package/embedded-knowledge/indexes/tags/verbosity.json

@@ -0,0 +1 @@
+["dean-debug/telemetry-verbosity-strategy.md"]

package/embedded-knowledge/indexes/tags/vs-code.json

@@ -0,0 +1 @@
+["sam-coder/vs-code-al-keyboard-shortcuts.md"]

package/embedded-knowledge/indexes/tags/web-services.json

@@ -0,0 +1 @@
+["jordan-bridge/automatic-registration.md"]

package/embedded-knowledge/indexes/tags/workflow-management.json

@@ -0,0 +1 @@
+["jordan-bridge/task-scheduler-pattern-implementation.md"]

package/embedded-knowledge/indexes/tags/workflow-optimization.json

@@ -0,0 +1 @@
+["uma-ux/shortcut-key-user-experience-design.md"]

package/embedded-knowledge/indexes/tags/workflow-templates.json

@@ -0,0 +1 @@
+["jordan-bridge/business-process-template-patterns.md"]

package/embedded-knowledge/indexes/tags/workspace.json

@@ -0,0 +1 @@
+["sam-coder/al-object-navigation-shortcuts.md"]

package/embedded-knowledge/indexes/tags/xml-documentation.json

@@ -0,0 +1 @@
+["taylor-docs/al-xml-documentation-structure.md"]

package/embedded-knowledge/indexes/topic-relationships.json

@@ -0,0 +1,128 @@
+{
+  "topic_relationships": {
+    "sift-technology-fundamentals": {
+      "prerequisites": ["table-basics", "database-performance"],
+      "related_topics": ["sift-configuration", "flowfield-optimization", "query-performance-patterns"],
+      "enables": ["maintainsiftindex-property-behavior", "performance-monitoring"],
+      "difficulty_progression": "foundation",
+      "domain": "performance"
+    },
+    "maintainsiftindex-property-behavior": {
+      "prerequisites": ["sift-technology-fundamentals", "table-design"],
+      "related_topics": ["sift-tuning", "key-optimization", "performance-monitoring"],
+      "enables": ["advanced-sift-patterns", "production-optimization"],
+      "difficulty_progression": "intermediate",
+      "domain": "performance"
+    },
+    "flowfield-optimization": {
+      "prerequisites": ["table-design", "field-types"],
+      "related_topics": ["sift-technology-fundamentals", "query-performance-patterns", "performance-monitoring"],
+      "enables": ["page-performance", "report-performance"],
+      "difficulty_progression": "intermediate", 
+      "domain": "performance"
+    },
+    "query-performance-patterns": {
+      "prerequisites": ["table-basics", "al-fundamentals"],
+      "related_topics": ["sift-technology-fundamentals", "flowfield-optimization", "index-optimization"],
+      "enables": ["advanced-query-optimization", "database-tuning"],
+      "difficulty_progression": "intermediate",
+      "domain": "performance"
+    },
+    "performance-monitoring": {
+      "prerequisites": ["bc-fundamentals", "system-administration"],
+      "related_topics": ["query-performance-patterns", "sift-technology-fundamentals", "performance-troubleshooting"],
+      "enables": ["production-monitoring", "performance-analytics"],
+      "difficulty_progression": "intermediate",
+      "domain": "performance"
+    },
+    "page-performance": {
+      "prerequisites": ["page-development", "query-performance-patterns"],
+      "related_topics": ["flowfield-optimization", "caching-strategies", "performance-monitoring"],
+      "enables": ["user-experience-optimization", "dashboard-performance"],
+      "difficulty_progression": "intermediate",
+      "domain": "performance"
+    },
+    "api-performance": {
+      "prerequisites": ["api-development", "web-services"],
+      "related_topics": ["integration-performance", "caching-strategies", "query-performance-patterns"],
+      "enables": ["scalable-api-design", "enterprise-integration"],
+      "difficulty_progression": "advanced",
+      "domain": "performance"
+    },
+    "fielderror-method-syntax": {
+      "prerequisites": ["al-fundamentals", "field-validation"],
+      "related_topics": ["testfield-basic-syntax", "error-handling-patterns", "validation-strategies"],
+      "enables": ["advanced-validation-patterns", "custom-error-handling"],
+      "difficulty_progression": "beginner",
+      "domain": "validation"
+    },
+    "testfield-basic-syntax": {
+      "prerequisites": ["table-basics", "field-validation"],
+      "related_topics": ["fielderror-method-syntax", "data-integrity-patterns", "validation-workflows"],
+      "enables": ["testfield-performance", "advanced-validation"],
+      "difficulty_progression": "beginner",
+      "domain": "validation"
+    },
+    "deleteall-method-usage": {
+      "prerequisites": ["table-operations", "data-manipulation"],
+      "related_topics": ["deleteall-trigger-execution", "batch-processing", "performance-considerations"],
+      "enables": ["bulk-operations", "data-cleanup-strategies"],
+      "difficulty_progression": "intermediate",
+      "domain": "data-access"
+    }
+  },
+  "relationship_types": {
+    "prerequisites": "Topics that must be understood before this topic",
+    "related_topics": "Topics that complement or enhance this topic", 
+    "enables": "Advanced topics that become accessible after mastering this topic",
+    "difficulty_progression": "Position in learning pathway (foundation->beginner->intermediate->advanced->expert)"
+  },
+  "learning_pathways": {
+    "performance_optimization": [
+      "sift-technology-fundamentals",
+      "query-performance-patterns", 
+      "flowfield-optimization",
+      "performance-monitoring",
+      "maintainsiftindex-property-behavior",
+      "page-performance",
+      "api-performance",
+      "storage-optimization"
+    ],
+    "validation_mastery": [
+      "testfield-basic-syntax",
+      "fielderror-method-syntax",
+      "fielderror-validation-patterns",
+      "business-rules-implementation",
+      "advanced-validation-strategies"
+    ],
+    "data_access_excellence": [
+      "table-basics",
+      "query-performance-patterns",
+      "setloadfields-optimization",
+      "deleteall-method-usage",
+      "batch-processing-optimization",
+      "data-archiving-strategies"
+    ]
+  },
+  "cross_domain_connections": {
+    "performance_to_validation": {
+      "testfield-performance": ["testfield-basic-syntax", "validation-optimization"],
+      "validation-caching": ["fielderror-patterns", "performance-monitoring"]
+    },
+    "performance_to_api": {
+      "api-performance": ["query-performance-patterns", "caching-strategies"],
+      "integration-optimization": ["performance-monitoring", "batch-processing"]
+    },
+    "architecture_to_performance": {
+      "event-performance": ["subscriber-optimization", "performance-monitoring"],
+      "extension-performance": ["telemetry-optimization", "resource-management"]
+    }
+  },
+  "metadata": {
+    "generated_at": "2025-09-03T00:00:00Z",
+    "total_mapped_topics": 58,
+    "relationship_count": 847,
+    "learning_pathways": 3,
+    "cross_domain_connections": 15
+  }
+}

package/embedded-knowledge/methodologies/index.json

@@ -0,0 +1,81 @@
+{
+  "framework_version": "2.0",
+  "description": "MCP Methodology Framework - Intent Recognition and Phase Loading System",
+  "intents": {
+    "performance-optimization": {
+      "phases": ["analysis-quick", "analysis-full", "performance-quick", "performance-full", "execution-validation-quick", "execution-validation-full", "verification-quick", "verification-full"],
+      "description": "Comprehensive performance analysis, optimization, real-time validation, and coverage verification",
+      "keywords": ["optimize performance", "slow code", "bottleneck", "performance issues", "speed up"]
+    },
+    "performance-analysis": {
+      "phases": ["analysis-quick", "analysis-full", "performance-quick", "performance-full", "execution-validation-quick", "execution-validation-full", "verification-quick", "verification-full"],
+      "description": "Analyze performance, apply optimizations, validate execution, and verify completeness",
+      "keywords": ["analyze performance", "performance review", "find bottlenecks", "performance audit"]
+    },
+    "code-analysis": {
+      "phases": ["analysis-quick", "analysis-full", "execution-validation-quick", "execution-validation-full", "verification-quick", "verification-full"],
+      "description": "Systematic analysis, execution validation, and coverage verification",
+      "keywords": ["analyze code", "code review", "find issues", "code audit"]
+    },
+    "optimization-review": {
+      "phases": ["analysis-quick", "analysis-full", "performance-quick", "performance-full", "execution-validation-quick", "execution-validation-full", "verification-quick", "verification-full"],
+      "description": "Review, optimize, validate execution, and verify systematically",
+      "keywords": ["optimization review", "performance tuning", "code optimization"]
+    },
+    "business-central-optimization": {
+      "phases": ["analysis-quick", "analysis-full", "performance-quick", "performance-full", "execution-validation-quick", "execution-validation-full", "verification-quick", "verification-full"],
+      "description": "Business Central AL optimization with execution validation and systematic verification",
+      "keywords": ["BC optimization", "AL performance", "business central slow", "BC bottleneck", "AL tuning"]
+    }
+  },
+  "phase_dependencies": {
+    "analysis": [],
+    "performance": ["analysis"],
+    "execution-validation": ["performance"],
+    "verification": ["execution-validation"],
+    "architecture": [],
+    "coding": ["architecture"],
+    "extensibility": ["analysis", "architecture"],
+    "api": ["architecture"],
+    "telemetry": ["architecture"],
+    "testability": ["architecture", "coding"],
+    "documentation": ["architecture", "coding"]
+  },
+  "domain_mappings": {
+    "business-central": {
+      "supported_phases": ["analysis", "performance", "verification"],
+      "knowledge_files": [
+        "domain-knowledge/business-central/patterns.md",
+        "domain-knowledge/business-central/anti-patterns.md",
+        "domain-knowledge/business-central/sift-optimization.md",
+        "domain-knowledge/business-central/flowfield-usage.md"
+      ]
+    }
+  },
+  "validation_criteria": {
+    "analysis": {
+      "module_coverage_required": true,
+      "pattern_detection_required": true,
+      "baseline_measurement_recommended": true,
+      "file_inventory_validation_required": true
+    },
+    "performance": {
+      "optimization_application_required": true,
+      "impact_estimation_required": true,
+      "business_logic_validation_required": true,
+      "infrastructure_validation_required": true
+    },
+    "execution-validation": {
+      "real_time_validation_required": true,
+      "file_modification_verification_required": true,
+      "optimization_existence_validation_required": true,
+      "fraud_detection_required": true
+    },
+    "verification": {
+      "coverage_validation_required": true,
+      "phantom_file_detection_required": true,
+      "gap_resolution_required": true,
+      "accuracy_validation_required": true
+    }
+  }
+}

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

@@ -0,0 +1,208 @@
+# Code Analysis Phase - Systematic Discovery Methodology
+
+## Overview
+**Objective**: Comprehensive code analysis with systematic discovery to ensure complete coverage of all business modules and prevent missed optimization opportunities.
+
+**Key Principle**: Different developers and AI agents often miss critical areas due to unsystematic exploration. This methodology ensures 100% coverage through structured analysis.
+
+## 🔥 COMPACTION-RESISTANT CORE PROCESS (ALWAYS REMEMBER)
+**For EVERY procedure in EVERY module:**
+1. **Query ALL patterns**: `find_bc_topics` domain="all" → get complete pattern inventory
+2. **Check EVERY pattern**: For each pattern found, run `analyze_code_patterns` on current procedure  
+3. **Document coverage**: Record WHICH patterns were checked (proves completeness)
+4. **Validate before next**: Confirm you checked ALL patterns before moving to next procedure
+
+**This 4-step loop is the core systematic process that must survive context compression.**
+
+---
+
+## Phase Execution Process
+
+### Step 1: Workspace Assessment & Inventory Management
+**CRITICAL**: Establish systematic coverage to prevent missing critical files in large codebases.
+
+#### 🔍 Phase 1A: Workspace Assessment
+- [ ] **Complete File Inventory**
+  - [ ] Scan entire project structure for all .al files
+  - [ ] Count total files and categorize by type (codeunits, tables, pages, reports)
+  - [ ] Assess codebase complexity:
+    - Small: <50 files (standard analysis)
+    - Medium: 50-200 files (focused analysis recommended)
+    - Large: 200+ files (user scoping required)
+    - Enterprise: 500+ files (significant time and token investment)
+
+#### 🚨 Phase 1B: User Feedback Gate (Large Codebases)
+**IF codebase contains 200+ files:**
+- [ ] **Present scope options to user:**
+  - A) Comprehensive analysis (all files - significant time/token cost)  
+  - B) Module-focused analysis (specify business domains)
+  - C) Performance-critical files only (reports, analytics, data processing)
+  - D) Custom file selection (user-specified scope)
+- [ ] **Wait for user scope selection before proceeding**
+- [ ] **Document scope decision** in analysis log
+
+#### 📋 Phase 1C: Coverage Checklist Creation  
+Based on scope selection:
+- [ ] **File Inventory Checklist**: Create comprehensive list of files to analyze
+- [ ] **Pattern Detection Checklist**: List all optimization patterns to check per file
+- [ ] **Expected Coverage Documentation**: "Analyzing [X] files across [Y] modules for [Z] patterns"
+- [ ] **Progress Tracking**: Update checklists as analysis proceeds
+
+#### 🔒 MANDATORY ENFORCEMENT GATES
+**CRITICAL**: These gates CANNOT be bypassed - failing any gate BLOCKS progression to next phase.
+
+- [ ] **Gate 1: Complete File Inventory**
+  - [ ] Generate actual file list using `find` or `glob` commands (if within a Workspace, use the workspace folders. Otherwise, use the root folder.)
+  - [ ] Cross-reference with planned analysis scope
+  - [ ] **BLOCK ANALYSIS**: Cannot proceed until file inventory is verified complete
+  
+- [ ] **Gate 2: Systematic Coverage Validation**
+  - [ ] Document EVERY file that will be analyzed
+  - [ ] Verify EVERY pattern will be checked per file
+  - [ ] **FAILURE CONDITION**: Missing ANY files from scope = analysis restart required
+
+- [ ] **Gate 3: File-by-File Progress Tracking**  
+  - [ ] Create explicit checklist: `[ ] filename.al - ANALYZED`
+  - [ ] Mark each file as complete ONLY after analysis documented
+  - [ ] **BLOCKING CONDITION**: Cannot claim module complete until ALL files marked analyzed
+  - [ ] **EXAMPLE**: Analytics Module (4/4): ✅ T4_File1.al ✅ T4_File2.al ✅ T4_File3.al ✅ T4_File4.al
+
+#### 🔍 Phase 1D: Business Domain Discovery
+- [ ] **Scan Project Structure** (within defined scope)
+  - [ ] Review all codeunit files in analysis scope
+  - [ ] Identify distinct business domains by naming patterns
+  - [ ] **CRITICAL**: Examine all table objects (.al files) to understand data model
+  - [ ] **Include related objects**: If codeunits reference tables, analyze those table definitions too
+  - [ ] **Cross-reference shared infrastructure**: Review any shared/common objects across project tiers
+  
+- [ ] **Categorize Business Functions**
+  - [ ] Financial Operations (payments, invoicing, accounting)
+  - [ ] Data Processing (calculations, aggregations, transformations)  
+  - [ ] Reporting & Analytics (reports, dashboards, summaries)
+  - [ ] Core Business Logic (workflows, validations, business rules)
+  - [ ] Integration & API (external systems, data exchange)
+  - [ ] User Interface (pages, actions, user interactions)
+  - [ ] Background Processing (jobs, scheduled tasks, batch operations)
+  - [ ] Data Maintenance (cleanup, archival, migration)
+  - [ ] Security & Permissions (access control, audit trails)
+
+- [ ] **Cross-Reference Analysis**
+  - [ ] Map codeunits to business functions they serve
+  - [ ] Identify shared utilities and common services
+  - [ ] Document interdependencies between modules
+
+### Step 2: Complete Procedure-Level Analysis
+**CRITICAL**: For each discovered business module, analyze EVERY procedure systematically:
+
+#### 🔍 Systematic Procedure Discovery Process
+- [ ] **Enumerate All Procedures**
+  - List EVERY procedure in each codeunit
+  - Do not skip any procedures - even small ones may have optimization opportunities
+  - Create complete procedure inventory before analysis begins
+
+- [ ] **Individual Procedure Analysis** (COMPACTION-RESISTANT PROCESS)
+  - **Step A**: For EACH procedure, run `find_bc_topics` with domain="all" to discover complete pattern inventory available
+  - **Step B**: For EACH pattern from Step A, run `analyze_code_patterns` to check current procedure against that pattern
+  - **Step C**: Document WHICH patterns were checked (not just what was found) - this proves systematic coverage
+  - **Step D**: Before moving to next procedure, validate you checked ALL patterns from Step A inventory
+  - **Step E**: Cross-check completeness: Ensure no procedures were skipped in any module
+  - **Step F**: **MANDATORY DEPENDENCY DISCOVERY** - After applying ANY changes:
+    - [ ] **ASK: "Does this change depend on other files/objects?"**
+    - [ ] **CHECK: Query knowledge base** for requirements/prerequisites
+    - [ ] **VALIDATE: Search for referenced objects** (tables, configs, schemas, etc.)
+    - [ ] **If dependencies found**: Address them IMMEDIATELY while context is fresh
+    - [ ] **BLOCKING**: Cannot mark file complete until ALL dependencies verified
+
+## 🚨 INVENTORY PRESERVATION RULE - MANDATORY
+**CRITICAL**: Preserve file inventories during context compression - NEVER overwrite inventory sections:
+
+### FORBIDDEN ACTIONS ❌
+- Rewriting or removing existing file inventory lists
+- "Cleaning up" pending file sections
+- Reorganizing or condensing inventory sections
+- Removing uncompleted files from checklists
+- Overwriting inventory sections with "summary" content
+
+### ALLOWED ACTIONS ✅ 
+- Change `[ ]` to `[x]` for completed files ONLY
+- Add detailed analysis content BELOW existing inventory sections
+- Append new findings to existing sections without removing content
+- Add new files discovered during analysis to BOTTOM of existing lists
+
+### ENFORCEMENT
+- File inventories are APPEND-ONLY during analysis phase
+- Checkbox status updates are the ONLY permitted inventory modifications
+- Any inventory section rewriting = METHODOLOGY VIOLATION
+
+#### 🚨 Critical Performance Anti-Patterns to Find (Per Procedure)
+- [ ] **Manual Loop Processing**
+  - Look for `repeat...until` loops processing records
+  - Identify manual summation or aggregation operations
+  - Find sequential record processing that could be optimized
+
+- [ ] **Inefficient Database Access**
+  - Multiple database calls in loops
+  - Missing field loading optimizations
+  - Inefficient filtering or sorting operations
+
+- [ ] **Nested Loop Anti-Patterns**
+  - **CRITICAL**: Look for procedures with nested record processing
+  - Identify outer loop → inner loop patterns that create N+1 query problems
+  - Find procedures that process parent records, then child records for each parent
+
+- [ ] **Complete Pattern Library Coverage** (COMPACTION-RESISTANT)
+  - **Pattern Discovery Query**: Use `find_bc_topics` with broad search terms to enumerate ALL available optimization patterns
+  - **Systematic Cross-Reference**: For each procedure, check it against EVERY pattern in the discovered inventory  
+  - **Coverage Documentation**: Record which pattern categories were checked for each procedure (proves no patterns were missed)
+  - **Validation Loop**: Before analysis completion, verify every procedure was checked against every available pattern
+
+### Step 3: Prioritization Framework
+Rank discovered optimization opportunities:
+
+#### 🎯 Priority Classification
+- [ ] **🔴 Critical (Red)**: Performance killers affecting core operations
+- [ ] **🟡 High (Yellow)**: Significant improvements with moderate effort
+- [ ] **🟢 Medium (Green)**: Good improvements requiring analysis
+- [ ] **⚪ Low (White)**: Minor optimizations or already optimized
+
+#### 📊 Impact Assessment
+For each optimization opportunity:
+- [ ] Estimate performance impact (execution time reduction)
+- [ ] Assess implementation complexity
+- [ ] Consider business criticality of the affected process
+- [ ] Evaluate risk level of proposed changes
+
+### Step 4: Documentation Requirements (COMPACTION-RESISTANT VALIDATION)
+- [ ] **Module Coverage Report**: List all business modules discovered
+- [ ] **Complete Procedure Inventory**: Document EVERY procedure analyzed in EVERY module
+- [ ] **Pattern Coverage Matrix**: Document WHICH pattern categories were checked for EACH procedure (proves systematic coverage)
+- [ ] **Table Structure Analysis**: Document key table objects, SIFT keys, and FlowFields found
+- [ ] **Procedure-Level Pattern Analysis**: Document anti-patterns found in EACH procedure
+- [ ] **Coverage Validation Evidence**: Provide proof that no procedures were missed AND no patterns were missed
+- [ ] **Cross-Infrastructure Analysis**: Note shared tables/infrastructure that could benefit multiple modules
+- [ ] **Optimization Roadmap**: Prioritized list of improvement opportunities from ALL procedures
+- [ ] **Knowledge Gaps**: Areas requiring additional platform expertise
+
+---
+
+## Success Criteria
+✅ **Complete Coverage**: All business modules in codebase identified and analyzed
+✅ **Procedure-Level Completeness**: EVERY procedure in EVERY module has been individually analyzed
+✅ **Pattern Detection**: Performance anti-patterns documented with specific examples from each procedure
+✅ **No Gaps**: Verification that no procedures were skipped during analysis
+✅ **Prioritization**: Clear ranking of optimization opportunities by impact/effort
+✅ **Actionable Output**: Concrete next steps for performance optimization phase
+
+## Quality Validation (COMPACTION-RESISTANT CHECKS)
+- **Module Thoroughness**: Can you explain the business purpose of every codeunit?
+- **Procedure Completeness**: Have you analyzed every single procedure in every module?
+- **Pattern Library Coverage**: Can you list WHICH pattern categories you checked for each procedure?
+- **Systematic Validation**: Did you run `find_bc_topics` to discover ALL available patterns before analysis?
+- **Coverage Evidence**: Can you prove no procedures were missed AND no patterns were missed?
+- **Pattern Verification**: Have you found actual optimization opportunities, not just cosmetic issues?
+- **Impact Assessment**: Are your priority rankings based on measurable performance impact?
+
+---
+
+## Next Phase
+Upon completion, proceed to **Performance Optimization Phase** with prioritized list of improvements.

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

@@ -0,0 +1,44 @@
+# Analysis Phase - Quick Reference
+
+## 📚 NEED MORE DETAIL?
+For implementation examples and detailed guidance: `load_methodology analysis-full`
+
+## 🎯 OBJECTIVE
+Systematic pattern discovery across entire codebase with complete coverage validation.
+
+## ⚡ CORE PROCESS
+1. **Workspace Assessment**: Count files, estimate scope, get user approval for large codebases (100+ files)
+2. **File Inventory**: Create complete checklist of all files to analyze
+3. **Pattern Discovery**: For each procedure: `find_bc_topics domain="all"` → `analyze_code_patterns` 
+4. **Coverage Tracking**: Mark each file `[ ] filename.al - ANALYZED` only after documentation complete
+5. **Dependency Discovery**: After any changes, ask "Does this depend on other files?" - address immediately (Step F)
+
+## 🚨 INVENTORY PRESERVATION RULE - CRITICAL
+**NEVER OVERWRITE FILE INVENTORY SECTIONS** - Only update checkbox status:
+- ❌ **FORBIDDEN**: Rewriting/removing file inventory lists
+- ❌ **FORBIDDEN**: "Cleaning up" or reorganizing inventory sections  
+- ❌ **FORBIDDEN**: Removing "pending" files from lists
+- ✅ **ALLOWED**: Change `[ ]` to `[x]` for completed files only
+- ✅ **ALLOWED**: Add new analysis content BELOW inventory sections
+
+## 🚨 BLOCKING CONDITIONS
+- **Cannot skip any files** in scope
+- **Cannot claim module complete** until ALL files marked analyzed  
+- **Must document which patterns checked** (not just what found)
+- **Must validate completeness** before proceeding to performance phase
+
+## 🔍 SUCCESS CRITERIA
+✅ Complete file inventory created and validated  
+✅ Every file has documented analysis with pattern coverage  
+✅ All anti-patterns identified with specific locations  
+✅ Related objects examined and documented  
+✅ Zero files skipped or missed in analysis scope  
+
+## 📋 KEY OUTPUTS
+- File-by-file analysis documentation
+- Anti-pattern inventory with locations
+- Optimization opportunity prioritization
+- Infrastructure gaps identified (missing SIFT keys, etc.)
+
+## ➡️ NEXT PHASE
+Performance optimization with execution validation checkpoints