prompt-capability-optimizer 1.0.0

package/prompt_capability_optimizer/capabilities/extractor.py

@@ -0,0 +1,92 @@
+# Copyright (c) 2026 Mahmoud Abdelhameid (Develper.net@gmail.com). All rights reserved.
+# Licensed under the MIT License.
+
+"""
+Capability Extractor
+====================
+Extracts technical capability requirements from task descriptions using an
+engineering domain ontology.
+"""
+
+import re
+from typing import List, Set, Dict
+from ..models import Capability
+
+class CapabilityExtractor:
+    
+    # Domain ontology mappings: pattern -> (canonical_capability, domain, dependencies)
+    ONTOLOGY = {
+        # Backend & APIs
+        r"\bnestjs\b": ("nestjs-development", "backend", ["typescript", "api-design"]),
+        r"\brest\s+api\b": ("rest-api-design", "backend", ["http-protocol"]),
+        r"\bgraphql\b": ("graphql-api", "backend", ["schema-design"]),
+        r"\bgrpc\b": ("grpc-services", "backend", ["protobuf"]),
+        r"\bfastify\b": ("fastify-framework", "backend", ["nodejs"]),
+        r"\bexpress\b": ("express-framework", "backend", ["nodejs"]),
+        
+        # Frontend & UI
+        r"\breact\b": ("react-development", "frontend", ["javascript", "ui-component-design"]),
+        r"\bplaywright\b": ("playwright-testing", "testing", ["e2e-testing", "browser-automation"]),
+        r"\bvue\b": ("vue-development", "frontend", ["ui-component-design"]),
+        r"\bnext\.?js\b": ("nextjs-framework", "fullstack", ["react-development"]),
+        r"\btailwind\b": ("tailwind-css", "frontend", ["css-styling"]),
+        
+        # Security & Auth
+        r"\b(?:auth|authentication)\b": ("authentication-architecture", "security", ["credential-handling", "session-security"]),
+        r"\boauth(?:2(?:\.0)?)?\b": ("oauth-oidc-integration", "security", ["authentication-architecture", "token-management"]),
+        r"\bjwt\b": ("jwt-token-management", "security", ["cryptography", "token-security"]),
+        r"\brbac\b": ("role-based-access-control", "security", ["authorization-logic"]),
+        r"\brate\s+limit(?:ing)?\b": ("rate-limiting", "security", ["dos-prevention"]),
+        r"\b(?:audit|security\s+audit)\b": ("security-auditing", "security", ["vulnerability-assessment", "owasp-asvs"]),
+        r"\bargon2\b": ("argon2-password-hashing", "security", ["cryptographic-storage"]),
+        r"\bbcrypt\b": ("bcrypt-password-hashing", "security", ["cryptographic-storage"]),
+        
+        # Data & Storage
+        r"\bpostgres(?:ql)?\b": ("postgresql-database", "database", ["relational-modeling", "sql-optimization"]),
+        r"\bredis\b": ("redis-caching-streaming", "database", ["in-memory-caching"]),
+        r"\bprisma\b": ("prisma-orm", "database", ["database-migrations", "type-safe-querying"]),
+        r"\btypeorm\b": ("typeorm", "database", ["database-migrations"]),
+        r"\bmongo(?:db)?\b": ("mongodb-database", "database", ["document-modeling"]),
+        
+        # Testing & QA
+        r"\b(?:testing|tests?)\b": ("automated-testing", "quality", ["test-runner"]),
+        r"\bunit\s+tests?\b": ("unit-testing", "quality", ["mocking", "assertion-framework"]),
+        r"\be2e\s+tests?\b": ("e2e-testing", "quality", ["integration-testing"]),
+        r"\bjest\b": ("jest-framework", "quality", ["unit-testing"]),
+        r"\bpytest\b": ("pytest-framework", "quality", ["python-testing"]),
+        r"\bvitest\b": ("vitest-framework", "quality", ["unit-testing"]),
+        
+        # Architecture & Systems
+        r"\bmulti-tenant\b": ("multi-tenant-architecture", "architecture", ["data-isolation", "tenant-scoping"]),
+        r"\bsaas\b": ("saas-architecture", "architecture", ["billing-integration", "multi-tenant-architecture"]),
+        r"\brag\b": ("rag-architecture", "ai_ml", ["vector-search", "document-retrieval", "embeddings"]),
+        r"\bmemory\s+leak\b": ("memory-leak-diagnostics", "performance", ["heap-profiling", "v8-diagnostics"]),
+        r"\brefactor(?:ing)?\b": ("architectural-refactoring", "architecture", ["dependency-inversion", "code-smells"])
+    }
+
+    @classmethod
+    def extract_capabilities(cls, text: str) -> List[Capability]:
+        lower_text = text.lower()
+        extracted: Dict[str, Capability] = {}
+        
+        for pattern, (name, domain, deps) in cls.ONTOLOGY.items():
+            if re.search(pattern, lower_text):
+                extracted[name] = Capability(
+                    name=name,
+                    domain=domain,
+                    importance=0.9,
+                    dependencies=deps,
+                    description=f"Requires specialized knowledge in {name}"
+                )
+                
+        # If no domain capability matched, provide baseline software engineering capability
+        if not extracted:
+            extracted["software-engineering-fundamentals"] = Capability(
+                name="software-engineering-fundamentals",
+                domain="general",
+                importance=0.5,
+                dependencies=[],
+                description="Core software development and reasoning skills"
+            )
+            
+        return list(extracted.values())

package/prompt_capability_optimizer/capabilities/graph.py

@@ -0,0 +1,53 @@
+# Copyright (c) 2026 Mahmoud Abdelhameid (Develper.net@gmail.com). All rights reserved.
+# Licensed under the MIT License.
+
+"""
+Capability Graph & Dependency Resolver
+======================================
+Builds dependency trees from required capabilities and resolves prerequisite nodes.
+"""
+
+from typing import List, Dict, Set, Any
+from ..models import Capability
+
+class CapabilityGraph:
+    
+    def __init__(self, roots: List[Capability]):
+        self.nodes: Dict[str, Capability] = {c.name: c for c in roots}
+        self._expand_dependencies()
+        
+    def _expand_dependencies(self):
+        to_process = list(self.nodes.values())
+        while to_process:
+            current = to_process.pop(0)
+            for dep_name in current.dependencies:
+                if dep_name not in self.nodes:
+                    new_node = Capability(
+                        name=dep_name,
+                        domain=current.domain,
+                        importance=max(0.4, current.importance * 0.75),
+                        dependencies=[]
+                    )
+                    self.nodes[dep_name] = new_node
+                    to_process.append(new_node)
+                    
+    def get_all_capabilities(self) -> List[Capability]:
+        # Return sorted by importance descending
+        return sorted(self.nodes.values(), key=lambda c: c.importance, reverse=True)
+        
+    def get_capability_names(self) -> List[str]:
+        return [c.name for c in self.get_all_capabilities()]
+        
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "node_count": len(self.nodes),
+            "nodes": [
+                {
+                    "name": c.name,
+                    "domain": c.domain,
+                    "importance": c.importance,
+                    "dependencies": c.dependencies
+                }
+                for c in self.get_all_capabilities()
+            ]
+        }

package/prompt_capability_optimizer/classification/__init__.py

@@ -0,0 +1,6 @@
+# Copyright (c) 2026 Mahmoud Abdelhameid (Develper.net@gmail.com). All rights reserved.
+# Licensed under the MIT License.
+
+from .task_classifier import TaskClassifier
+
+__all__ = ["TaskClassifier"]

package/prompt_capability_optimizer/classification/task_classifier.py

@@ -0,0 +1,126 @@
+# Copyright (c) 2026 Mahmoud Abdelhameid (Develper.net@gmail.com). All rights reserved.
+# Licensed under the MIT License.
+
+"""
+Hybrid Task Classifier
+======================
+Combines structural signals, risk level, multi-system count, and architectural scope
+with an explainable confidence report.
+"""
+
+import re
+from typing import List, Dict, Any, Tuple
+from ..models import ClassificationReport
+
+class TaskClassifier:
+    
+    LEVEL_4_PATTERNS = [
+        r"\b(?:saas|multi-tenant|distributed|microservices|consensus|event-driven|cqrs|high-availability|rag\s+(?:architecture|evaluation|system)|enterprise\s+architecture)\b",
+        r"\b(?:multi-system|cross-service|data\s+pipeline|warehouse|lakehouse)\b"
+    ]
+    
+    LEVEL_3_PATTERNS = [
+        r"\b(?:auth|authentication|oauth|oidc|jwt|saml|sso|argon2|bcrypt|cryptography|session\s+management)\b",
+        r"\b(?:payment|stripe|billing|webhook\s+security|audit\s+log|penetration\s+test|vulnerability|owasp|asvs)\b",
+        r"\b(?:production|compliance|secret\s+management|rbac|abac|rate\s+limiting|ddos)\b"
+    ]
+    
+    LEVEL_2_PATTERNS = [
+        r"\b(?:rest\s+api|graphql|grpc|api|endpoint|crud|database\s+schema|migration|prisma|typeorm|drizzle|postgres|redis)\b",
+        r"\b(?:refactor|architecture|module|service|repository\s+pattern|clean\s+architecture|feature)\b",
+        r"\b(?:memory\s+leak|profiling|concurrency|race\s+condition|deadlock|performance\s+optimization)\b"
+    ]
+    
+    LEVEL_1_PATTERNS = [
+        r"\b(?:fix\s+bug|write\s+test|unit\s+test|add\s+method|function|format|lint|typecheck|single\s+file)\b",
+        r"\b(?:regex|helper|utility|script|component|button|form)\b"
+    ]
+    
+    LEVEL_0_PATTERNS = [
+        r"^(?:explain|what\s+is|how\s+does|why\s+does|describe|translate|summarize|definition\s+of)\b",
+        r"\b(?:explain\s+this|walkthrough|overview)\b"
+    ]
+
+    @classmethod
+    def classify(cls, prompt: str) -> ClassificationReport:
+        lower_prompt = prompt.lower().strip()
+        signals = []
+        
+        # Check Level 4 (Research / Multi-System / Enterprise SaaS)
+        l4_matches = [m.group(0) for pat in cls.LEVEL_4_PATTERNS for m in re.finditer(pat, lower_prompt)]
+        if l4_matches:
+            signals.extend(l4_matches)
+            return ClassificationReport(
+                level=4,
+                confidence=0.92,
+                signals=signals,
+                reasoning=f"Identified high-level multi-system architectural signals: {', '.join(set(signals))}"
+            )
+            
+        # Check Level 3 (Production / High-Risk / Security & Payment)
+        l3_matches = [m.group(0) for pat in cls.LEVEL_3_PATTERNS for m in re.finditer(pat, lower_prompt)]
+        if l3_matches:
+            signals.extend(l3_matches)
+            return ClassificationReport(
+                level=3,
+                confidence=0.88,
+                signals=signals,
+                reasoning=f"Identified security, financial, or high-risk production vectors: {', '.join(set(signals))}"
+            )
+            
+        # Check Level 2 (Complex / Multi-File Feature / API / Refactor)
+        l2_matches = [m.group(0) for pat in cls.LEVEL_2_PATTERNS for m in re.finditer(pat, lower_prompt)]
+        if l2_matches:
+            signals.extend(l2_matches)
+            return ClassificationReport(
+                level=2,
+                confidence=0.85,
+                signals=signals,
+                reasoning=f"Identified feature implementation, API design, or multi-file refactoring: {', '.join(set(signals))}"
+            )
+            
+        # Check Level 0 (Informational / Explanation)
+        l0_matches = [m.group(0) for pat in cls.LEVEL_0_PATTERNS for m in re.finditer(pat, lower_prompt)]
+        if l0_matches and len(lower_prompt.split()) <= 15:
+            signals.extend(l0_matches)
+            return ClassificationReport(
+                level=0,
+                confidence=0.95,
+                signals=signals,
+                reasoning=f"Identified brief informational or conceptual query: {', '.join(set(signals))}"
+            )
+            
+        # Check Level 1 (Moderate / Local Fix / Unit Test)
+        l1_matches = [m.group(0) for pat in cls.LEVEL_1_PATTERNS for m in re.finditer(pat, lower_prompt)]
+        if l1_matches:
+            signals.extend(l1_matches)
+            return ClassificationReport(
+                level=1,
+                confidence=0.80,
+                signals=signals,
+                reasoning=f"Identified single-module edit or standard unit task: {', '.join(set(signals))}"
+            )
+
+        # Fallback based on length and sentence structure
+        word_count = len(lower_prompt.split())
+        if word_count > 40:
+            return ClassificationReport(
+                level=2,
+                confidence=0.65,
+                signals=["long_prompt_heuristic"],
+                reasoning="Classified as Level 2 due to extensive prompt scope and specification density."
+            )
+        elif word_count < 8:
+            return ClassificationReport(
+                level=0,
+                confidence=0.70,
+                signals=["short_prompt_heuristic"],
+                reasoning="Classified as Level 0 due to concise informational phrasing."
+            )
+        else:
+            return ClassificationReport(
+                level=1,
+                confidence=0.60,
+                signals=["standard_task_default"],
+                reasoning="Classified as Level 1 standard engineering task by default."
+            )

package/prompt_capability_optimizer/cli.py

@@ -0,0 +1,85 @@
+"""
+Unified Command Line Interface
+==============================
+Provides standard CLI commands for prompt optimization, environment probing,
+and controlled Mode C execution governance.
+Usage:
+  python -m prompt_capability_optimizer optimize "Build a NestJS auth API" --mode B --json
+  python -m prompt_capability_optimizer optimize "Build a NestJS auth API" --mode C --confirm-execute
+  python -m prompt_capability_optimizer probe
+"""
+
+import sys
+import json
+import argparse
+from .engine import PromptOptimizerEngine
+from .discovery.local_discovery import LocalSkillDiscovery
+from .discovery.mcp_discovery import McpDiscovery
+from .adapters.host_adapter import detect_host_runtime
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="prompt-capability-optimizer",
+        description="Autonomous Capability Discovery & Two-Pass Prompt Engineering Engine",
+        epilog="Author: Mahmoud Abdelhameid (https://www.linkedin.com/in/mahmoud-abdelhameid-dev/ | Develper.net@gmail.com) | Copyright (c) 2026 Mahmoud Abdelhameid. All rights reserved."
+    )
+    parser.add_argument("--version", action="version", version="%(prog)s 1.0.0 by Mahmoud Abdelhameid <Develper.net@gmail.com>")
+    subparsers = parser.add_subparsers(dest="command", help="Available subcommands")
+    
+    # optimize subcommand
+    opt_parser = subparsers.add_parser("optimize", help="Optimize a raw prompt")
+    opt_parser.add_argument("prompt", type=str, help="The prompt text to optimize")
+    opt_parser.add_argument("--mode", type=str, choices=["A", "B", "C"], default="B", help="Output mode (A: optimize only, B: prepare, C: execute)")
+    opt_parser.add_argument("--confirm-execute", action="store_true", help="Explicit human authorization for Mode C execution side-effects")
+    opt_parser.add_argument("--json", action="store_true", help="Output machine-readable JSON")
+    
+    # probe subcommand
+    probe_parser = subparsers.add_parser("probe", help="Probe host capabilities and discovered skills")
+    probe_parser.add_argument("--json", action="store_true", help="Output machine-readable JSON")
+
+    args = parser.parse_args()
+    
+    if args.command == "optimize":
+        engine = PromptOptimizerEngine()
+        result = engine.optimize(
+            args.prompt,
+            mode=args.mode,
+            confirmed_execution=args.confirm_execute
+        )
+        if args.json:
+            print(json.dumps(result, indent=2))
+        else:
+            print(f"=== Prompt Capability Optimizer (Mode {result['mode']}) ===")
+            print(f"Classification Level: {result['classification']['level']} ({result['classification']['reasoning']})")
+            print(f"Discovered Capabilities: {', '.join(result['required_capabilities'])}")
+            print(f"Critique Pass: {result['critique']['passed']} (Score: {result['critique']['score']})")
+            if result.get("execution_status"):
+                print(f"Execution Governance: {result['execution_status']}\n")
+            print("--- OPTIMIZED PROMPT ---")
+            print(result["optimized_prompt"])
+            
+    elif args.command == "probe":
+        host_agent = detect_host_runtime()
+        skills = LocalSkillDiscovery.discover()
+        mcp_servers = McpDiscovery.discover()
+        
+        rep = {
+            "host_agent": host_agent,
+            "local_skills_count": len(skills),
+            "local_skills": [{"name": s.name, "source": s.source} for s in skills],
+            "mcp_servers_count": len(mcp_servers),
+            "mcp_servers": [
+                {
+                    "name": m.name,
+                    "status": m.metadata.get("status"),
+                    "tools": m.metadata.get("tools", [])
+                }
+                for m in mcp_servers
+            ]
+        }
+        print(json.dumps(rep, indent=2))
+    else:
+        parser.print_help()
+
+if __name__ == "__main__":
+    main()

package/prompt_capability_optimizer/config.py

@@ -0,0 +1,42 @@
+# Copyright (c) 2026 Mahmoud Abdelhameid (Develper.net@gmail.com). All rights reserved.
+# Licensed under the MIT License.
+
+"""
+Configuration & Threshold Settings
+==================================
+Central runtime parameters, utility thresholds, discovery limits, and risk tolerances.
+"""
+
+from dataclasses import dataclass, field
+from typing import List, Dict, Any
+
+@dataclass
+class OptimizerConfig:
+    # Utility thresholds from references/scoring_rubric.md
+    utility_auto_adopt_threshold: float = 7.0
+    utility_conditional_threshold: float = 5.0
+    
+    # Discovery limits
+    max_skills_per_prompt: int = 3
+    max_skills_level_4: int = 5
+    enable_web_discovery: bool = True
+    enable_find_skills_cli: bool = True
+    
+    # Security parameters
+    block_high_risk_skills: bool = True
+    max_acceptable_skill_risk: float = 6.0
+    redact_secrets: bool = True
+    
+    # Critique parameters
+    minimum_critique_pass_score: float = 0.80
+    max_correction_iterations: int = 2
+    
+    # Execution permissions
+    allowed_side_effects: List[str] = field(default_factory=lambda: ["NO_SIDE_EFFECT", "LOW_RISK"])
+    require_confirmation_for_external_side_effects: bool = True
+    
+    # Cache settings
+    enable_cache: bool = True
+    cache_ttl_seconds: int = 3600
+
+DEFAULT_CONFIG = OptimizerConfig()

package/prompt_capability_optimizer/critique/__init__.py

@@ -0,0 +1,6 @@
+# Copyright (c) 2026 Mahmoud Abdelhameid (Develper.net@gmail.com). All rights reserved.
+# Licensed under the MIT License.
+
+from .self_critique_engine import SelfCritiqueEngine
+
+__all__ = ["SelfCritiqueEngine"]

package/prompt_capability_optimizer/critique/self_critique_engine.py

@@ -0,0 +1,144 @@
+# Copyright (c) 2026 Mahmoud Abdelhameid (Develper.net@gmail.com). All rights reserved.
+# Licensed under the MIT License.
+
+"""
+Semantic Self-Critique & Quality Assurance Engine
+=================================================
+Performs deep qualitative and structural evaluation of prompt content.
+Detects superficial/vague objectives, evaluates constraint relevance, identifies
+contradictions, and outputs structured findings with actionable recommendations.
+"""
+
+import re
+from typing import Dict, Any, List
+from ..models import CritiqueReport, CritiqueFinding
+
+class SelfCritiqueEngine:
+    
+    # Patterns indicating underspecified or excessively vague requests
+    VAGUE_OBJECTIVE_PATTERNS = [
+        r"^(?:do\s+(?:something|coding|work)|write\s+code|fix\s+it|help\s+me|check\s+this)\b",
+        r"^(?:make\s+it\s+work|improve\s+stuff|test\s+everything)$"
+    ]
+
+    @classmethod
+    def evaluate(cls, prompt_text: str, depth: int = 1) -> CritiqueReport:
+        lower = prompt_text.lower()
+        findings: List[CritiqueFinding] = []
+        critical_issues: List[str] = []
+        recommendations: List[str] = []
+        
+        # 1. Objective Specificity & Vagueness Check
+        has_objective_header = bool(re.search(r"\bobjective:", lower))
+        # Extract objective text
+        obj_match = re.search(r"\bobjective:\s*([^\n\r]+)", prompt_text, re.IGNORECASE)
+        obj_text = (obj_match.group(1).strip().lower()) if obj_match else ""
+        
+        is_too_vague = any(re.search(pat, obj_text) for pat in cls.VAGUE_OBJECTIVE_PATTERNS) or (has_objective_header and len(obj_text.split()) < 3 and obj_text not in ["explain this javascript function."])
+        
+        obj_passed = has_objective_header and not is_too_vague
+        if is_too_vague:
+            critical_issues.append("Objective is excessively vague or superficial (e.g. 'do something')")
+            
+        findings.append(CritiqueFinding(
+            dimension="Objective Specificity",
+            passed=obj_passed,
+            score=1.0 if obj_passed else (0.2 if has_objective_header else 0.0),
+            finding="Specific, measurable objective" if obj_passed else "Objective is missing or excessively vague",
+            recommendation="State an unambiguous, concrete outcome rather than generic phrasing" if not obj_passed else ""
+        ))
+        
+        # 2. Appropriate Persona / Role
+        has_role = bool(re.search(r"\brole:", lower))
+        role_score = 1.0 if has_role else 0.0
+        findings.append(CritiqueFinding(
+            dimension="Role Persona",
+            passed=has_role,
+            score=role_score,
+            finding="Specialized engineering role specified" if has_role else "Missing explicit engineering role",
+            recommendation="Specify an appropriate engineering persona" if not has_role else ""
+        ))
+        
+        # 3. Explicit & Negative Constraints
+        has_constraints = bool(re.search(r"\bconstraints?(?:\s+&\s+non-negotiables)?:", lower))
+        has_negatives = bool(re.search(r"\b(?:do\s+not|never|avoid|without)\b", lower))
+        constraint_passed = has_constraints and has_negatives
+        findings.append(CritiqueFinding(
+            dimension="Constraint Completeness",
+            passed=constraint_passed,
+            score=1.0 if constraint_passed else (0.5 if has_constraints else 0.0),
+            finding="Both positive and negative constraints present" if constraint_passed else "Missing explicit boundaries or negative constraints",
+            recommendation="Include clear non-negotiables and explicit negative constraints" if not constraint_passed else ""
+        ))
+        
+        # 4. Tool & Capability Binding (Required for depth >= 2)
+        has_tools = bool(re.search(r"\b(?:required\s+capabilities|tools?\s+to\s+use|toolchain)\b.*?:", lower)) or (depth < 2)
+        findings.append(CritiqueFinding(
+            dimension="Capability & Tool Binding",
+            passed=has_tools,
+            score=1.0 if has_tools else 0.0,
+            finding="Capabilities and execution tools bound" if has_tools else "Complex task lacks explicit tool/capability bindings",
+            recommendation="Bind discovered skills, tools, or MCP servers explicitly" if not has_tools else ""
+        ))
+        
+        # 5. Verification & Testing Directives
+        has_verification = bool(re.search(r"\b(?:verification|testing|test\s+directives?)\b.*?:", lower)) and bool(re.search(r"\b(?:test|lint|typecheck|build|pytest|npm|cargo|go)\b", lower))
+        findings.append(CritiqueFinding(
+            dimension="Verification Quality",
+            passed=has_verification,
+            score=1.0 if has_verification else 0.0,
+            finding="Concrete verifiable test/inspection commands present" if has_verification else "Missing actionable test or verification commands",
+            recommendation="Add concrete testing commands (e.g. npm test, pytest, cargo test)" if not has_verification else ""
+        ))
+        
+        # 6. Completion Criteria & Baseline Regression Check
+        has_completion = bool(re.search(r"\bcompletion\s+criteria\b.*?:", lower))
+        findings.append(CritiqueFinding(
+            dimension="Completion Criteria",
+            passed=has_completion,
+            score=1.0 if has_completion else 0.0,
+            finding="Deterministic completion criteria specified" if has_completion else "Missing explicit completion conditions",
+            recommendation="Define objective completion conditions and regression bounds" if not has_completion else ""
+        ))
+        
+        # 7. Phased Execution for Complex Tasks
+        has_phases = bool(re.search(r"\b(?:phase\s+1|phased\s+execution)\b.*?:", lower)) or (depth < 2)
+        findings.append(CritiqueFinding(
+            dimension="Phased Execution",
+            passed=has_phases,
+            score=1.0 if has_phases else 0.0,
+            finding="Execution divided into sequential milestones" if has_phases else "Complex task lacks phased execution milestones",
+            recommendation="Structure complex workflows into sequential phases" if not has_phases else ""
+        ))
+        
+        # 8. Conversational Noise & Filler Absence
+        has_filler = bool(re.search(r"\b(?:sure(?:ly)?|as\s+an\s+ai|hello|hope\s+this\s+helps)\b", lower))
+        findings.append(CritiqueFinding(
+            dimension="Formatting & Signal-to-Noise",
+            passed=not has_filler,
+            score=1.0 if not has_filler else 0.4,
+            finding="High signal-to-noise ratio" if not has_filler else "Contains unnecessary conversational filler",
+            recommendation="Eliminate conversational pleasantries and filler text" if has_filler else ""
+        ))
+
+        # Composite score calculation
+        total_score = sum(f.score for f in findings) / float(len(findings))
+        composite_score = round(total_score, 2)
+        
+        # Stricter acceptance gate: No critical issues and score >= 0.80
+        all_passed = (composite_score >= 0.80) and (len(critical_issues) == 0) and obj_passed and has_constraints
+        
+        for f in findings:
+            if not f.passed and f.recommendation:
+                recommendations.append(f.recommendation)
+                
+        confidence = 0.95 if has_objective_header and has_constraints else 0.80
+        
+        return CritiqueReport(
+            passed=all_passed,
+            score=composite_score,
+            confidence=confidence,
+            findings=findings,
+            critical_issues=critical_issues,
+            recommendations=recommendations
+        )

package/prompt_capability_optimizer/discovery/__init__.py

@@ -0,0 +1,16 @@
+# Copyright (c) 2026 Mahmoud Abdelhameid (Develper.net@gmail.com). All rights reserved.
+# Licensed under the MIT License.
+
+from .registry import ResourceRegistry
+from .local_discovery import LocalSkillDiscovery
+from .find_skills_adapter import FindSkillsAdapter
+from .mcp_discovery import McpDiscovery
+from .web_discovery import WebDiscovery
+
+__all__ = [
+    "ResourceRegistry",
+    "LocalSkillDiscovery",
+    "FindSkillsAdapter",
+    "McpDiscovery",
+    "WebDiscovery"
+]