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.
Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.
A direct command skips the review prompt. Inspect the source before running it.
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
functionclassifyUserPrompt(userPrompt, sessionCorrections = {}, projectState = {}) {
// Normalize promptconst normalizedPrompt = userPrompt.toLowerCase().trim();
const words = normalizedPrompt.split(/\s+/);
// Apply session corrections firstif (sessionCorrections[normalizedPrompt]) {
return {
correction_applied: true,
result: sessionCorrections[normalizedPrompt],
confidence: 0.98,
explanation: `Applied learned correction from this session`
};
}
let candidates = [];
// Score single skillsfor (const [skillName, patterns] ofObject.entries(SKILL_PATTERNS)) {
let score = 0;
// Primary pattern matchingconst primaryMatches = patterns.primary_patterns.filter(pattern =>
normalizedPrompt.includes(pattern.toLowerCase())
);
score += primaryMatches.length * 0.4;
// Context pattern matching const contextMatches = patterns.context_patterns.filter(pattern =>
normalizedPrompt.includes(pattern.toLowerCase())
);
score += contextMatches.length * 0.3;
// Action pattern matchingconst actionMatches = patterns.action_patterns.filter(pattern =>
words.includes(pattern.toLowerCase())
);
score += actionMatches.length * 0.2;
// Apply confidence weight
score *= patterns.confidence_weight;
// Project context boostif (projectState.completed_skills && projectState.completed_skills.includes(skillName)) {
score *= 0.7; // Reduce likelihood of suggesting completed skills
}
if (score > 0.1) {
candidates.push({
type: 'skill',
name: skillName,
confidence: Math.min(score, 1.0),
matched_patterns: {
primary: primaryMatches,
context: contextMatches,
action: actionMatches
}
});
}
}
// Score workflow archetypesconst multiStepIndicators = [
'and then', 'followed by', 'complete', 'comprehensive', 'full', 'entire',
'through', 'workflow', 'process', 'analyze and', 'create and'
];
const isMultiStep = multiStepIndicators.some(indicator =>
normalizedPrompt.includes(indicator)
);
if (isMultiStep || words.length > 8) {
for (const [archetype, patterns] ofObject.entries(WORKFLOW_PATTERNS)) {
let score = 0;
const primaryMatches = patterns.primary_patterns.filter(pattern =>
normalizedPrompt.includes(pattern.toLowerCase())
);
score += primaryMatches.length * 0.5;
const contextMatches = patterns.context_patterns.filter(pattern =>
normalizedPrompt.includes(pattern.toLowerCase())
);
score += contextMatches.length * 0.3;
const multiStepMatches = patterns.multi_step_indicators.filter(indicator =>
normalizedPrompt.includes(indicator.toLowerCase())
);
score += multiStepMatches.length * 0.2;
score *= patterns.confidence_weight;
if (score > 0.2) {
candidates.push({
type: 'workflow',
name: archetype,
confidence: Math.min(score, 1.0),
matched_patterns: {
primary: primaryMatches,
context: contextMatches,
multi_step: multiStepMatches
}
});
}
}
}
// Sort by confidence
candidates.sort((a, b) => b.confidence - a.confidence);
// Classification logicif (candidates.length === 0) {
return {
status: 'no_match',
confidence: 0,
suggestion: 'Could you rephrase your request? Try mentioning specific EDPS concepts like "requirements", "domain model", or "workflow".'
};
}
const top = candidates[0];
const second = candidates[1];
// High confidence single matchif (top.confidence >= 0.85) {
return {
status: 'classified',
result: top,
alternatives: candidates.slice(1, 3),
explanation: generateIntentExplanation(top)
};
}
// Ambiguous - needs disambiguationif (second && Math.abs(top.confidence - second.confidence) <= 0.10) {
return {
status: 'disambiguation_needed',
candidates: candidates.slice(0, 3),
question: generateDisambiguationQuestion(candidates.slice(0, 3)),
explanation: `I found multiple possible matches for your request.`
};
}
// Medium confidenceif (top.confidence >= 0.65) {
return {
status: 'classified',
result: top,
alternatives: candidates.slice(1, 3),
explanation: generateIntentExplanation(top),
confidence_warning: 'This is my best guess - let me know if it\'s not what you intended.'
};
}
// Low confidencereturn {
status: 'low_confidence',
candidates: candidates.slice(0, 3),
explanation: 'I\'m not very confident about what you\'re looking for. Here are my best guesses:'
};
}
functiongenerateIntentExplanation(match) {
const explanations = {
'requirements-ingest': 'I\'ll process and normalize your requirements into a structured format for analysis.',
'domain-extractconcepts': 'I\'ll analyze your requirements to identify key business entities and domain concepts.',
'diagram-generatecollaboration': 'I\'ll create Mermaid collaboration diagrams showing system interactions and boundaries.',
'hierarchy-management': 'I\'ll decompose control-type participants into hierarchical sub-processes.',
'documentation-automation': 'I\'ll auto-generate process documentation following EDPS hierarchy standards.',
'plan-derivetasks': 'I\'ll convert your requirements and goals into actionable development tasks.',
'edps-compliance': 'I\'ll validate your project against EDPS methodology compliance rules.',
'standard_workflow': 'I\'ll guide you through the complete EDPS workflow with balanced quality and efficiency.',
'rapid_workflow': 'I\'ll execute a streamlined EDPS workflow optimized for speed and MVP delivery.',
'compliance_workflow': 'I\'ll conduct a comprehensive EDPS workflow with full documentation and audit trail.'
};
return explanations[match.name] || `I'll execute the ${match.name}${match.type}.`;
}
functiongenerateDisambiguationQuestion(candidates) {
if (candidates.length === 2) {
const first = candidates[0];
const second = candidates[1];
return`I see two possible options:\n1. ${generateIntentExplanation(first)}\n2. ${generateIntentExplanation(second)}\n\nWhich would you prefer? (1 or 2)`;
}
if (candidates.length === 3) {
return`I found several possible matches:\n${candidates.map((c, i) =>
`${i+1}. ${generateIntentExplanation(c)}`
).join('\n')}\n\nWhich best matches your intent? (1, 2, or 3)`;
}
return'Could you clarify what specific aspect you\'d like to work on?';
}
Session Correction Learning
functionprocessUserCorrection(originalPrompt, correctionChoice, candidates, projectState) {
// Store correction in session memoryif (!projectState.session_corrections) {
projectState.session_corrections = {};
}
const correctedResult = candidates[correctionChoice - 1];
projectState.session_corrections[originalPrompt.toLowerCase()] = correctedResult;
// Update confidence weights for future classificationsif (!projectState.pattern_adjustments) {
projectState.pattern_adjustments = {};
}
const adjustmentKey = correctedResult.name;
if (!projectState.pattern_adjustments[adjustmentKey]) {
projectState.pattern_adjustments[adjustmentKey] = 1.0;
}
// Boost confidence for corrected choice
projectState.pattern_adjustments[adjustmentKey] *= 1.1;
// Reduce confidence for top incorrect choiceconst 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: true,
message: `Thanks! I've learned that "${originalPrompt}" should map to ${correctedResult.name}. I'll remember this for the rest of our session.`,
updated_result: correctedResult
};
}
## Inputs
- **User intent**: Natural language request inCopilotchat (e.g., โhelp me process these requirementsโ, โdecompose this participantโ, โgenerate a project planโ)
- **Optional**: Existing workspace artifacts (requirements files, collaboration diagrams, project folders) that provide context for skill selection
## Outputs
- **Skill recommendations**: Ordered list of skills to invoke with rationale and dependency graph
- **Orchestrated workflow**: Sequenced multi-skill execution plan (references `workflow-templates.json` canonical pipeline)
- **Guided prompts**: Ready-to-use Copilot prompt for each recommended skill step
## CoreFunction
**Purpose**: Transform natural language requests into optimal skill invocation patterns and workflows
**Input**: User intent expressed in natural language via Copilot
**Output**: Skill recommendations, orchestrated workflows, and guided execution paths
**Integration**: NativeCopilot skill that understands user context and available skill capabilities
## CoreCapabilities
### 1.IntelligentSkillDiscovery
- **NaturalLanguageParsing**: Interprets user requests like "help me process requirements" or "analyze my domain model"
- **ContextAwareness**: Considers project stage, available artifacts, and previous work to recommend appropriate skills
- **CapabilityMapping**: Matches user intent to skill capabilities across the entire EDPS toolkit
### 2.WorkflowOrchestration
- **Multi-SkillCoordination**: Sequences multiple skills for complex workflows (e.g., requirements โ domain analysis โ collaboration diagrams)
- **DependencyManagement**: Ensures prerequisite skills are executed before dependent skills
- **ProgressTracking**: Monitors workflow completion and suggests next steps
### 3.CopilotIntegrationOptimization
- **NaturalInvocation**: Enables users to say "analyze requirements using EDPS" instead of remembering specific skill names
- **ContextPreservation**: Maintains conversation flow while invoking skills behind the scenes
- **InteractiveGuidance**: Provides 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
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 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
โ 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
