| name | edps-skill-navigator |
| description | Enhanced intelligent assistant that integrates with GitHub Copilot to provide natural language navigation and orchestration of EDPS skills with advanced prompt pattern recognition, confidence scoring, and session learning. |
| license | MIT |
EDPS Skill Navigator (Enhanced)
An intelligent assistant that seamlessly integrates with GitHub Copilot to provide natural language navigation, discovery, and orchestration of the Evolutionary Development Process System (EDPS) skills ecosystem with advanced prompt pattern recognition and workflow automation.
Intent
Translate natural language user intent into optimally sequenced EDPS skill invocations with ≥95% accuracy. Act as the single Copilot-facing entry point for the skill suite — discovering which skills to invoke, in what order, with what inputs — based on project context, available artifacts, and the canonical analysis-to-planning workflow sequence.
New in v2.0.0: Advanced prompt pattern recognition with confidence scoring, disambiguation flow, session learning, and automatic workflow archetype selection.
Enhanced Capabilities (T09)
1. Advanced Intent Classification
- High-Accuracy Recognition: Classifies user prompts against 30 skills + 3 workflow archetypes with ≥95% accuracy
- Confidence Scoring: Provides ranked results with confidence percentages
- Disambiguation Flow: Generates clarifying questions when confidence gap < 10%
- Multi-Step Detection: Identifies complex requests requiring full workflow archetypes
- Intent Explanation: Explains matched intent before execution
2. Session Learning
- Correction Capture: Learns from user corrections during conversation
- Adaptive Classification: Improves accuracy based on user feedback within session
- Pattern Memory: Retains learned patterns in project state object
- Confidence Adjustment: Dynamically adjusts thresholds based on user preferences
3. Workflow Orchestration Integration
- Seamless T07 Integration: Routes workflow requests to edps-workflow-orchestrator automatically
- Project State Awareness: Considers current workflow progress for context
- Gate Quality Integration: Uses T08 quality scores to inform next-step recommendations
- Archetype Selection: Intelligently suggests standard/rapid/compliance based on prompt analysis
Prompt Classification Engine
Intent Taxonomy
Single-Skill Intent Patterns
{
"requirements-ingest": {
"primary_patterns": [
"analyze requirements", "process requirements", "ingest requirements",
"normalize requirements", "structure requirements", "parse requirements"
],
"context_patterns": [
"requirements document", "user stories", "specification",
"functional requirements", "business requirements"
],
"action_patterns": [
"process", "analyze", "ingest", "normalize", "structure", "parse", "review"
],
"confidence_weight": 0.85
Workflow Archetype Patterns
{
"standard_workflow": {
"primary_patterns": [
"start EDPS project", "complete analysis", "full workflow",
"comprehensive analysis", "standard process", "complete project"
],
"context_patterns": [
"project", "workflow", "complete", "comprehensive",
"analysis", "through", "full process"
],
"multi_step_indicators": [
"and then", "followed by", "complete", "comprehensive",
"full", "entire", "through"
],
Classification Algorithm
function classifyUserPrompt(userPrompt, sessionCorrections = {}, projectState = {}) {
const normalizedPrompt = userPrompt.toLowerCase().trim();
const words = normalizedPrompt.split(/\s+/);
if (sessionCorrections[normalizedPrompt]) {
return {
correction_applied: true,
result: sessionCorrections[normalizedPrompt],
confidence: 0.98,
explanation: `Applied learned correction from this session`
};
}
let candidates = [];
for (const [skillName, patterns] of Object.entries(SKILL_PATTERNS)) {
let score = 0;
const primaryMatches = patterns.primary_patterns.filter(pattern =>
normalizedPrompt.includes(pattern.toLowerCase())
);
score += primaryMatches.length * 0.4;
const contextMatches = patterns.context_patterns.filter( =>
normalizedPrompt.(pattern.())
);
score += contextMatches. * ;
actionMatches = patterns..(
words.(pattern.())
);
score += actionMatches. * ;
score *= patterns.;
(projectState. && projectState..(skillName)) {
score *= ;
}
(score > ) {
candidates.({
: ,
: skillName,
: .(score, ),
: {
: primaryMatches,
: contextMatches,
: actionMatches
}
});
}
}
multiStepIndicators = [
, , , , , ,
, , , ,
];
isMultiStep = multiStepIndicators.(
normalizedPrompt.(indicator)
);
(isMultiStep || words. > ) {
( [archetype, patterns] .()) {
score = ;
primaryMatches = patterns..(
normalizedPrompt.(pattern.())
);
score += primaryMatches. * ;
contextMatches = patterns..(
normalizedPrompt.(pattern.())
);
score += contextMatches. * ;
multiStepMatches = patterns..(
normalizedPrompt.(indicator.())
);
score += multiStepMatches. * ;
score *= patterns.;
(score > ) {
candidates.({
: ,
: archetype,
: .(score, ),
: {
: primaryMatches,
: contextMatches,
: multiStepMatches
}
});
}
}
}
candidates.( b. - a.);
(candidates. === ) {
{
: ,
: ,
:
};
}
top = candidates[];
second = candidates[];
(top. >= ) {
{
: ,
: top,
: candidates.(, ),
: (top)
};
}
(second && .(top. - second.) <= ) {
{
: ,
: candidates.(, ),
: (candidates.(, )),
:
};
}
(top. >= ) {
{
: ,
: top,
: candidates.(, ),
: (top),
:
};
}
{
: ,
: candidates.(, ),
:
};
}
() {
explanations = {
: ,
: ,
: ,
: ,
: ,
: ,
: ,
: ,
: ,
:
};
explanations[match.] || ;
}
() {
(candidates. === ) {
first = candidates[];
second = candidates[];
;
}
(candidates. === ) {
;
}
;
}
Session Correction Learning
function processUserCorrection(originalPrompt, correctionChoice, candidates, projectState) {
if (!projectState.session_corrections) {
projectState.session_corrections = {};
}
const correctedResult = candidates[correctionChoice - 1];
projectState.session_corrections[originalPrompt.toLowerCase()] = correctedResult;
if (!projectState.pattern_adjustments) {
projectState.pattern_adjustments = {};
}
const adjustmentKey = correctedResult.name;
if (!projectState.pattern_adjustments[adjustmentKey]) {
projectState.pattern_adjustments[adjustmentKey] = 1.0;
}
projectState.pattern_adjustments[adjustmentKey] *= 1.1;
const incorrectChoice = candidates[0];
if (incorrectChoice.name !== correctedResult.name) {
const incorrectKey = incorrectChoice.name;
if (!projectState.pattern_adjustments[incorrectKey]) {
projectState.pattern_adjustments[incorrectKey] = 1.0;
}
projectState.pattern_adjustments[incorrectKey] *= 0.9;
}
return {
learned: ,
: ,
: correctedResult
};
}
##
- ** intent**: language request (e.., “help me process these requirements”, “decompose participant”, “generate a project plan”)
- ****: workspace (requirements files, collaboration diagrams, project folders) that provide context skill selection
##
- ** recommendations**: list skills to invoke rationale and dependency graph
- ** workflow**: multi-skill execution (references canonical pipeline)
- ** prompts**: -to-use prompt each recommended skill step
##
****: natural language requests into optimal skill invocation patterns and workflows
****: intent expressed natural language via
****: recommendations, orchestrated workflows, and guided execution paths
****: skill that understands user context and available skill capabilities
##
###
- ** **: user requests like or
- ** **: project stage, available artifacts, and previous work to recommend appropriate skills
- ** **: user intent to skill capabilities across the entire toolkit
###
- **- **: multiple skills complex (e.., requirements → domain analysis → collaboration diagrams)
- ** **: prerequisite skills are executed before dependent skills
- ** **: workflow completion and suggests next steps
###
- ** **: users to say instead remembering specific skill names
- ** **: conversation flow invoking skills behind the scenes
- ** **: real-time assistance and suggestions during skill execution
Enhanced Usage Patterns (T09)
Intelligent Classification Flow
User: "I need to analyze my requirements and create a domain model"
Navigator:
🎯 Intent Analysis: Multi-step workflow detected (confidence: 94%)
📋 Plan: Standard workflow archetype recommended
🔄 Routing to: edps-workflow-orchestrator
Explanation: I detected a multi-step request involving requirements analysis and domain modeling. I'll start the standard EDPS workflow which will handle this comprehensively.
[Routes to: edps-workflow-orchestrator start standard]
Disambiguation Flow
User: "Help me with my diagrams"
Navigator:
❓ I found multiple possible matches for your request:
1. I'll create new Mermaid collaboration diagrams showing system interactions and boundaries
2. I'll decompose control-type participants into hierarchical sub-processes
3. I'll auto-generate process documentation following EDPS hierarchy standards
Which best matches your intent? (1, 2, or 3)
User: "1"
Navigator:
✅ Thanks! I've learned that "help me with my diagrams" should map to diagram-generatecollaboration.
🎯 Executing: Creating collaboration diagrams...
[Invokes: diagram-generatecollaboration]
Session Learning Example
User: "I want to structure my requirements"
Navigator:
🎯 Intent Analysis: requirements-ingest (confidence: 87%)
💡 Explanation: I'll process and normalize your requirements into a structured format for analysis.
[Invokes: requirements-ingest]
User: "Actually, I wanted to derive tasks from them"
Navigator:
📝 Learning: Updating classification model...
✅ I've learned that "structure my requirements" means derive tasks in your context.
🎯 Executing: Converting requirements into actionable development tasks...
[Invokes: plan-derivetasks]
[Later in session]
User: "I need to structure these new requirements"
Navigator:
🎯 Intent Analysis: plan-derivetasks (confidence: 98% - learned from correction)
💡 Explanation: I'll convert your requirements into actionable development tasks.
[Invokes: plan-derivetasks]
Project Context Awareness
User: "What should I do next?"
Navigator:
📊 Project Analysis: Reviewing current state...
• Requirements processed ✅
• Goals extracted ✅
• Domain concepts: Not started ❌
🎯 Recommendation: Domain analysis is the logical next step
💡 Explanation: I'll analyze your requirements to identify key business entities and domain concepts.
🔄 Ready to execute: domain-extractconcepts
Would you like me to proceed with domain analysis? (Y/n)
Workflow Archive Integration
User: "Start a compliance review for audit"
Navigator:
🎯 Intent Analysis: compliance_workflow (confidence: 98%)
💡 Explanation: I'll conduct a comprehensive EDPS workflow with full documentation and audit trail.
🔄 Routing to: edps-workflow-orchestrator start compliance
[Routes to T07 orchestrator with compliance archetype]
Advanced Features (T09)
Evolutionary Development Principles
- Iterative Refinement: Guides users through iterative improvement cycles
- Continuous Integration: Ensures skills work together harmoniously
- Adaptive Planning: Adjusts recommendations based on project evolution
- Knowledge Accumulation: Builds understanding progressively through skill interactions
Process Awareness
- Stage Recognition: Identifies current development phase (discovery, analysis, design, implementation)
- Transition Guidance: Smoothly guides users between development stages
- Quality Gates: Ensures completeness before advancing to next phase
- Artifact Dependencies: Tracks and manages inter-skill dependencies
Copilot Integration Strategies
Natural Language Processing
# User Intent Recognition
"orchestrate workflow" → edps-workflow-orchestrator
"start edps workflow" → edps-workflow-orchestrator
"what should I do next" → edps-workflow-orchestrator
"resume my workflow" → edps-workflow-orchestrator
"show workflow progress" → edps-workflow-orchestrator
"analyze requirements" → requirements-ingest + goals-extract
"merge requirements" → requirements-merge
"understand domain" → domain-extractconcepts + domain-alignentities
"create diagrams" → diagram-generatecollaboration
"create hierarchical diagrams" → diagram-generatecollaboration (--mode hierarchical) + hierarchy-management
"add boundaries to diagrams" → diagram-generatecollaboration (--mode boundary-detection)
"plan project" → plan-derivetasks + plan-estimateeffort + plan-buildschedule
"estimate effort" → plan-estimateeffort
"create tasks" → plan-derivetasks
"build schedule" → plan-buildschedule
"track project" → project-planning-tracking + process-scopemin
"track changes" → change-management
"update organization model" → orgmodel-update
"integrate models" → model-integration
"update top requirements" → process-findtopandupdate
"test integration" → integration-testing
"validate workflows" → integration-testing
"decompose process" → hierarchy-management
"generate documentation" → documentation-automation
"validate hierarchy" → hierarchy-validation
"check compliance" → edps-compliance
"analyze change impact" → change-impact-analysis
"migrate diagrams" → hierarchy-management --op migrate
"upgrade legacy diagrams" → hierarchy-management --op migrate
"validate compliance" → hierarchy-validation + edps-compliance
"full hierarchy workflow" → diagram-generatecollaboration → hierarchy-management → documentation-automation → hierarchy-validation → edps-compliance
Conversational Flows
User: "I need to start working on requirements analysis"
Navigator:
1. "I'll help you with requirements analysis. First, let me set up your project structure..."
2. [Invokes project-document-management]
3. "Great! Now let's process your requirements. Please provide your requirements document..."
4. [Invokes requirements-ingest]
5. "Excellent! I've processed your requirements. Would you like me to extract goals and success criteria next?"
User: "I need to plan my project and estimate effort"
Navigator:
1. "I'll help you create a comprehensive project plan. Let me start by deriving tasks from your requirements..."
2. [Invokes plan-derivetasks]
3. "Perfect! I've identified the key tasks. Now let me estimate effort for each task..."
4. [Invokes plan-estimateeffort]
5. "Great estimates! Now I'll build a detailed schedule with dependencies..."
6. [Invokes plan-buildschedule]
7. "Your project plan is ready! Would you like me to integrate this with your organizational model?"
User: "I need to integrate new processes with our existing organizational model"
Navigator:
1. "I'll help you integrate your processes safely. Let me start by merging the process models..."
2. [Invokes process-merge]
3. "Process merge complete. Now I'll find and update top-level requirements that may be affected..."
4. [Invokes process-findtopandupdate]
5. "Updates identified. Now I'll integrate the changes into your organizational model..."
6. [Invokes model-integration]
7. "Integration complete! Let me update the organizational documentation..."
8. [Invokes orgmodel-update]
9. "Everything is updated. Would you like me to run integration tests to validate the changes?"
Context-Aware Assistance
- Progressive Disclosure: Reveals relevant skills as user progresses
- Intelligent Defaults: Pre-configures skills based on project context
- Error Recovery: Guides users when skills encounter issues
- Learning Loop: Improves recommendations based on user patterns
Skill Ecosystem Navigation
Available Skills Catalog
Requirements Processing:
├── requirements-ingest # Normalize and structure requirements
├── requirements-merge # Combine multiple requirement sources
├── goals-extract # Extract business goals and success criteria
└── process-w5h # Comprehensive requirements analysis
Domain Analysis:
├── domain-extractconcepts # Identify domain entities and relationships
├── domain-alignentities # Align concepts with organizational standards
└── domain-proposenewconcepts # Suggest domain extensions
Process & Planning:
├── process-merge # Integrate process models with organizational models
├── process-findtopandupdate # Update top-level requirements based on analysis
├── process-scopemin # Identify minimum viable scope
├── plan-derivetasks # Convert requirements into actionable tasks
├── plan-estimateeffort # Provide effort estimates for development tasks
├── plan-buildschedule # Generate project schedules with dependencies
├── project-planning-tracking # Plan and track project milestones
└── project-status-reporting # Generate status reports
Visualization & Documentation:
├── diagram-generatecollaboration # Create Mermaid collaboration diagrams with boundary support (authoritative VR-1–VR-4 source)
├── documentation-automation # Auto-generate main.md, process.md, collaboration.md, domain-model.md per hierarchy level
├── project-document-management # Manage project documentation structure
└── change-management # Track and document changes
Hierarchy Management:
├── hierarchy-management # Decompose control participants into sub-processes; manage folder structure, metadata, and cross-reference navigation; --op migrate absorbs migration-tools
└── migration-tools # DEPRECATED (retained for backward compatibility) — use hierarchy-management --op migrate instead
Compliance & Validation:
├── edps-compliance # Validate EDPS methodology compliance (VR-1–VR-4, HR-2/6, EP-1–EP-4); generates scored reports
├── hierarchy-validation # Validate hierarchy structural integrity (HV-1–HV-5, HX-1–HX-5, HN-1–HN-4); authoritative structural source
└── change-impact-analysis # Trace change propagation across hierarchy levels (CI-1–CI-5, CR-1–CR-3); risk classification
Model & Integration Management:
├── model-integration # Integrate new models into existing structures
├── orgmodel-update # Update organizational model documents (with EDPS-Hierarchy Guard)
└── integration-testing # Validate end-to-end skill workflows
Orchestration:
└── edps-workflow-orchestrator # End-to-end EDPS workflow lifecycle management; DAG prerequisite engine; persistent project state across sessions; completion event emitter for skill-completion-gates (T08)
Quality & Development:
└── skill-creator # Create new skills when needed
Workflow Templates
Complete Project Initiation:
project-document-management → requirements-ingest → goals-extract → process-w5h → domain-extractconcepts
Requirements Analysis Deep Dive:
requirements-ingest → goals-extract → process-w5h → process-scopemin → requirements-merge (if multiple sources)
Domain Modeling Workflow:
domain-extractconcepts → domain-alignentities → domain-proposenewconcepts → diagram-generatecollaboration
Project Planning Workflow:
goals-extract → process-scopemin → plan-derivetasks → plan-estimateeffort → plan-buildschedule
Process Integration Workflow:
process-merge → process-findtopandupdate → model-integration → orgmodel-update
Change Management Cycle:
change-management → change-impact-analysis → [affected skill execution] → orgmodel-update → project-status-reporting
End-to-End Organization Integration:
requirements-ingest → domain-extractconcepts → model-integration → orgmodel-update → integration-testing
Hierarchical Diagram Workflow (New — EDPS v2):
diagram-generatecollaboration (--mode hierarchical) →
hierarchy-management (decompose control participants) →
documentation-automation (generate level docs) →
hierarchy-validation (structural integrity check) →
edps-compliance (full methodology check)
Legacy Migration Workflow:
hierarchy-management --op migrate (--mode preview) → [human review of LOW-confidence participants] →
hierarchy-management --op migrate (--mode apply) →
hierarchy-management (optional: decompose enhanced diagrams) →
edps-compliance (validate migrated diagrams)
Change Impact Analysis Workflow:
change-impact-analysis (--mode what-if) → [review risk report] →
change-impact-analysis (--mode apply) → orgmodel-update → hierarchy-validation
Complete Development Lifecycle (with Hierarchy):
project-document-management → requirements-ingest → goals-extract → process-w5h →
domain-extractconcepts → plan-derivetasks → plan-estimateeffort → plan-buildschedule →
diagram-generatecollaboration → hierarchy-management → documentation-automation →
hierarchy-validation → edps-compliance → integration-testing
Implementation Guidelines
For Copilot Users
- Natural Interaction: Simply describe what you want to accomplish in plain language
- Trust the Navigator: Let it guide you through complex workflows
- Provide Context: Mention your project stage and available artifacts
- Iterate Safely: Use the navigator to experiment with different analysis approaches
For Skill Developers
- Register Skills: Ensure new skills are catalogued in the navigator's knowledge base
- Define Dependencies: Clearly specify what inputs your skill requires
- Provide Metadata: Include skill capabilities and use cases for intelligent matching
- Enable Chaining: Design skills to work well in orchestrated workflows
For System Administrators
- Monitor Usage: Track which skill combinations are most effective
- Optimize Patterns: Refine workflow templates based on user success
- Update Navigator: Keep skill catalog and capabilities current
- Performance Tuning: Ensure smooth orchestration without latency
1. Real-Time Classification Engine
- Sub-500ms Response: Classification completes in <500ms for single-skill prompts
- Confidence Scoring: All results include confidence percentages and reasoning
- Context Integration: Considers project state, completed skills, and available artifacts
- Pattern Learning: Adapts to user vocabulary and correction patterns within session
2. Quality-Driven Recommendations
- T08 Gate Integration: Uses completion gate quality scores to inform recommendations
- Workflow Progress: Considers T07 orchestrator state for context-aware suggestions
- Risk Assessment: Warns about prerequisite gaps or potential quality issues
- Success Metrics: Tracks and reports skill combination effectiveness
3. Adaptive Intelligence
- Correction Memory: Remembers user corrections throughout project session
- Pattern Adaptation: Adjusts classification weights based on user feedback
- Confidence Calibration: Dynamically adjusts thresholds for disambiguation
- Success Learning: Improves recommendations based on outcome quality
Enhanced Copilot Integration
Natural Language Classification
# Enhanced Intent Recognition with Confidence Scoring
# High Confidence (≥85%) - Direct Execution
"process my requirements" → requirements-ingest (92% confidence)
"create collaboration diagrams" → diagram-generatecollaboration (89% confidence)
"validate EDPS compliance" → edps-compliance (96% confidence)
"start full analysis workflow" → edps-workflow-orchestrator start standard (94% confidence)
# Medium Confidence (65-85%) - Execute with Warning
"help with my domain model" → domain-extractconcepts (78% confidence + alternatives)
"plan my project" → plan-derivetasks (72% confidence + alternatives)
# Disambiguation Required (top-2 within 10%)
"analyze my project" → [requirements-ingest 71%, domain-extractconcepts 68%] → disambiguation question
# Session Learning Applied
"structure requirements" → plan-derivetasks (98% confidence - learned from correction)
Workflow Archetype Detection
# Multi-Step Intent → Workflow Routing
"analyze requirements and create diagrams" → edps-workflow-orchestrator start standard
"quick domain analysis for MVP" → edps-workflow-orchestrator start rapid
"comprehensive analysis for audit" → edps-workflow-orchestrator start compliance
"validate hierarchy and check compliance" → edps-workflow-orchestrator (existing project state)
Enhanced Conversational Flows
User: "I need help with my requirements analysis"
Navigator:
🎯 Intent Classification (confidence: 87%): Requirements processing detected
💡 I'll process and normalize your requirements into a structured format for analysis.
🔄 Executing: requirements-ingest
→ [Skill execution begins]
→ [On completion] ✅ Requirements processed! Next recommended: goals-extract (extract business objectives)
User: "Actually I meant derive tasks from requirements"
Navigator:
📝 Correction Captured: "requirements analysis" → plan-derivetasks
✅ I've learned this preference and will remember it for our session
🎯 Executing: Converting requirements into actionable development tasks...
→ [Switches to plan-derivetasks]
User: "Now I need to analyze requirements for the next module"
Navigator:
🎯 Intent Classification (confidence: 96% - learned): Task derivation from requirements
💡 I'll convert your requirements into actionable development tasks.
🔄 Executing: plan-derivetasks
Context-Aware Project Guidance
User: "What's the next logical step?"
Navigator:
📊 Project State Analysis:
• Current workflow: Standard archetype (8/12 skills complete - 67%)
• Last completed: hierarchy-management ✅
• Available next: documentation-automation, hierarchy-validation
• Quality status: All gates passing (92% average quality score)
🎯 Recommendation (confidence: 94%): documentation-automation
💡 Generate process documentation for your completed hierarchy levels
🚀 This maintains workflow momentum and prepares for final validation
Execute documentation-automation? (Y/n)
EDPS Methodology Integration (Enhanced)
Evolutionary Development Principles (Enhanced)
- Iterative Refinement: Guides users through iterative improvement cycles with session learning
- Continuous Integration: Ensures skills work together harmoniously via T07 orchestrator integration
- Adaptive Planning: Adjusts recommendations based on project evolution and user corrections
- Knowledge Accumulation: Builds understanding progressively through skill interactions and quality feedback
Process Awareness (Enhanced)
- Stage Recognition: Identifies current development phase using T07 project state
- Transition Guidance: Smoothly guides users between development stages with confidence scoring
- Quality Gates: Ensures completeness using T08 gate results before advancing to next phase
- Artifact Dependencies: Tracks and manages inter-skill dependencies through orchestrator DAG
Enhanced Quality Integration
- T08 Gate Reporting: Incorporates completion gate results into next-step recommendations
- Quality Scoring: Uses aggregated workflow quality scores to suggest optimizations
- Risk Detection: Identifies potential quality issues before they cascade through workflow
- Success Metrics: Tracks classification accuracy and user satisfaction within project sessions
Version: 2.0.0 (T09 Enhanced)
Last Updated: March 17, 2026
Compatibility: GitHub Copilot, VS Code, EDPS v2.x (hierarchical boundary format)
Dependencies: T07 edps-workflow-orchestrator, T08 skill-completion-gates
Maintainer: EDPS Development Team
T09 Enhancements (March 17, 2026)
- Advanced Classification Engine: ≥95% accuracy with confidence scoring and disambiguation
- Session Learning: User correction capture with pattern adaptation
- Multi-Step Detection: Automatic workflow archetype selection for complex requests
- Quality Integration: T08 gate results inform recommendations and next-step guidance
- T07 Deep Integration: Seamless routing to orchestrator for workflow management
- Intent Explanation: Plain-language explanation of matched intent before execution
- Context Awareness: Project state and completion history influence classification
- Sub-500ms Performance: Real-time classification for responsive user experience
Skills Classification Support (All 32 Skills)
✅ Requirements Processing: requirements-ingest, requirements-merge, goals-extract, process-w5h
✅ Domain Analysis: domain-extractconcepts, domain-alignentities, domain-proposenewconcepts
✅ Visualization: diagram-generatecollaboration, documentation-automation
✅ Planning: plan-derivetasks, plan-estimateeffort, plan-buildschedule, project-planning-tracking, project-status-reporting
✅ Process Management: process-merge, process-findtopandupdate, process-scopemin
✅ Hierarchy: hierarchy-management, hierarchy-validation, migration-tools
✅ Compliance: edps-compliance, change-impact-analysis
✅ Integration: model-integration, orgmodel-update, integration-testing
✅ Change Management: change-management
✅ GitHub Integration: github-issue-create-update, github-issue-sync-status
✅ Meta: skill-creator
✅ Orchestration: edps-workflow-orchestrator, edps-skill-navigator (self-reference)
✅ Project Management: project-document-management
Workflow Archetype Classification
✅ Standard Workflow: Balanced quality and efficiency for typical EDPS projects
✅ Rapid Workflow: Streamlined execution optimized for MVP and fast iteration
✅ Compliance Workflow: Comprehensive analysis with full audit trail and documentation
