attune-ai 2.1.1__py3-none-any.whl → 2.1.3__py3-none-any.whl

attune/socratic_router.py

@@ -0,0 +1,761 @@
+"""Socratic Router - Intent-based workflow discovery.
+
+Routes user's natural language goals to AskUserQuestion options.
+Used by the /attune command for Socratic discovery flow.
+
+Two modes:
+1. Quick routing: Simple intent classification → AskUserQuestion options → skill invocation
+2. Deep discovery: Full SocraticWorkflowBuilder session for complex agent generation
+
+Flow (Quick):
+1. User runs /attune
+2. Claude asks "What are you trying to accomplish?"
+3. User responds naturally
+4. classify_intent() detects category
+5. AskUserQuestion presents 2-4 relevant options
+6. User selects → routes to skill
+
+Flow (Deep):
+1. User needs complex workflow generation
+2. SocraticWorkflowBuilder creates multi-round Q&A session
+3. form_to_ask_user_question() converts Forms to AskUserQuestion
+4. Generates custom agent workflow
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from attune.socratic import Form, SocraticSession
+
+
+class IntentCategory(Enum):
+    """High-level categories of user intent."""
+
+    FIX = "fix"  # Debug, fix bugs, resolve errors
+    IMPROVE = "improve"  # Refactor, optimize, clean up
+    VALIDATE = "validate"  # Test, review, audit
+    SHIP = "ship"  # Commit, PR, release
+    UNDERSTAND = "understand"  # Explain, document, explore
+    UNKNOWN = "unknown"  # Needs clarification
+
+
+@dataclass
+class WorkflowOption:
+    """A workflow option for AskUserQuestion.
+
+    Attributes:
+        label: Short label for the option (1-5 words)
+        description: What this option does
+        skill: The skill to invoke
+        args: Arguments for the skill
+    """
+
+    label: str
+    description: str
+    skill: str
+    args: str = ""
+
+    def to_ask_user_option(self) -> dict[str, str]:
+        """Convert to AskUserQuestion option format."""
+        return {"label": self.label, "description": self.description}
+
+
+@dataclass
+class IntentClassification:
+    """Result of classifying user intent.
+
+    Attributes:
+        category: Primary intent category
+        confidence: Confidence score (0-1)
+        keywords_matched: Keywords that triggered this classification
+        suggested_question: Question to ask via AskUserQuestion
+        options: Workflow options to present
+    """
+
+    category: IntentCategory
+    confidence: float
+    keywords_matched: list[str]
+    suggested_question: str
+    options: list[WorkflowOption]
+
+
+# Intent detection patterns
+INTENT_PATTERNS: dict[IntentCategory, dict[str, Any]] = {
+    IntentCategory.FIX: {
+        "keywords": [
+            "fix",
+            "bug",
+            "error",
+            "broken",
+            "crash",
+            "fail",
+            "issue",
+            "problem",
+            "debug",
+            "wrong",
+            "doesn't work",
+            "not working",
+            "exception",
+            "traceback",
+        ],
+        "question": "What kind of issue are you dealing with?",
+        "options": [
+            WorkflowOption(
+                label="Debug an error",
+                description="Investigate exceptions, trace execution, find root cause",
+                skill="dev",
+                args="debug",
+            ),
+            WorkflowOption(
+                label="Fix failing tests",
+                description="Analyze test failures and fix the underlying code",
+                skill="testing",
+                args="run",
+            ),
+            WorkflowOption(
+                label="Review for bugs",
+                description="Code review focused on finding potential bugs",
+                skill="dev",
+                args="review",
+            ),
+            WorkflowOption(
+                label="Something else",
+                description="Describe your specific issue",
+                skill="attune",
+                args="",
+            ),
+        ],
+    },
+    IntentCategory.IMPROVE: {
+        "keywords": [
+            "refactor",
+            "improve",
+            "clean",
+            "optimize",
+            "simplify",
+            "better",
+            "performance",
+            "speed",
+            "faster",
+            "memory",
+            "too long",
+            "complex",
+            "messy",
+            "ugly",
+        ],
+        "question": "What would you like to improve?",
+        "options": [
+            WorkflowOption(
+                label="Refactor code",
+                description="Improve structure, extract functions, simplify logic",
+                skill="dev",
+                args="refactor",
+            ),
+            WorkflowOption(
+                label="Optimize performance",
+                description="Find bottlenecks, improve speed and memory usage",
+                skill="workflows",
+                args="run perf-audit",
+            ),
+            WorkflowOption(
+                label="Code review",
+                description="Get feedback on code quality and patterns",
+                skill="dev",
+                args="review",
+            ),
+            WorkflowOption(
+                label="Something else",
+                description="Describe what you want to improve",
+                skill="attune",
+                args="",
+            ),
+        ],
+    },
+    IntentCategory.VALIDATE: {
+        "keywords": [
+            "test",
+            "coverage",
+            "security",
+            "audit",
+            "check",
+            "verify",
+            "validate",
+            "review",
+            "safe",
+            "secure",
+            "vulnerability",
+        ],
+        "question": "What would you like to validate?",
+        "options": [
+            WorkflowOption(
+                label="Run tests",
+                description="Execute test suite and see results",
+                skill="testing",
+                args="run",
+            ),
+            WorkflowOption(
+                label="Check coverage",
+                description="Analyze test coverage and identify gaps",
+                skill="testing",
+                args="coverage",
+            ),
+            WorkflowOption(
+                label="Security audit",
+                description="Scan for vulnerabilities and security issues",
+                skill="workflows",
+                args="run security-audit",
+            ),
+            WorkflowOption(
+                label="Code review",
+                description="Quality and pattern analysis",
+                skill="dev",
+                args="review",
+            ),
+        ],
+    },
+    IntentCategory.SHIP: {
+        "keywords": [
+            "commit",
+            "push",
+            "pr",
+            "pull request",
+            "merge",
+            "release",
+            "deploy",
+            "ship",
+            "publish",
+            "done",
+            "ready",
+            "finished",
+        ],
+        "question": "What stage are you at?",
+        "options": [
+            WorkflowOption(
+                label="Create commit",
+                description="Stage changes and create a commit with message",
+                skill="dev",
+                args="commit",
+            ),
+            WorkflowOption(
+                label="Create PR",
+                description="Push branch and create pull request",
+                skill="dev",
+                args="pr",
+            ),
+            WorkflowOption(
+                label="Prepare release",
+                description="Version bump, changelog, security checks",
+                skill="release",
+                args="prep",
+            ),
+            WorkflowOption(
+                label="Just push",
+                description="Push current commits to remote",
+                skill="dev",
+                args="push",
+            ),
+        ],
+    },
+    IntentCategory.UNDERSTAND: {
+        "keywords": [
+            "explain",
+            "understand",
+            "how",
+            "what",
+            "why",
+            "document",
+            "docs",
+            "readme",
+            "learn",
+            "show",
+            "describe",
+            "overview",
+        ],
+        "question": "What would you like to understand?",
+        "options": [
+            WorkflowOption(
+                label="Explain code",
+                description="Understand how specific code works",
+                skill="docs",
+                args="explain",
+            ),
+            WorkflowOption(
+                label="Project overview",
+                description="High-level architecture and structure",
+                skill="docs",
+                args="overview",
+            ),
+            WorkflowOption(
+                label="Generate docs",
+                description="Create or update documentation",
+                skill="docs",
+                args="generate",
+            ),
+            WorkflowOption(
+                label="Something specific",
+                description="Ask about a specific part of the codebase",
+                skill="attune",
+                args="",
+            ),
+        ],
+    },
+}
+
+
+def classify_intent(user_response: str) -> IntentClassification:
+    """Classify user's natural language response into intent category.
+
+    Args:
+        user_response: User's answer to "What are you trying to accomplish?"
+
+    Returns:
+        IntentClassification with category, options, and metadata
+    """
+    response_lower = user_response.lower()
+
+    best_category = IntentCategory.UNKNOWN
+    best_score = 0
+    matched_keywords: list[str] = []
+
+    # Score each category based on keyword matches
+    for category, pattern in INTENT_PATTERNS.items():
+        keywords = pattern["keywords"]
+        score = 0
+        matches = []
+
+        for keyword in keywords:
+            if keyword in response_lower:
+                score += 1
+                matches.append(keyword)
+
+        if score > best_score:
+            best_score = score
+            best_category = category
+            matched_keywords = matches
+
+    # Calculate confidence
+    if best_score == 0:
+        confidence = 0.0
+    elif best_score >= 3:
+        confidence = 0.95
+    elif best_score >= 2:
+        confidence = 0.8
+    else:
+        confidence = 0.6
+
+    # Get options for the category
+    if best_category in INTENT_PATTERNS:
+        pattern = INTENT_PATTERNS[best_category]
+        return IntentClassification(
+            category=best_category,
+            confidence=confidence,
+            keywords_matched=matched_keywords,
+            suggested_question=pattern["question"],
+            options=pattern["options"],
+        )
+
+    # Unknown intent - ask for clarification
+    return IntentClassification(
+        category=IntentCategory.UNKNOWN,
+        confidence=0.0,
+        keywords_matched=[],
+        suggested_question="Could you tell me more about what you're trying to do?",
+        options=[
+            WorkflowOption(
+                label="Fix something",
+                description="Debug errors, fix bugs, resolve issues",
+                skill="dev",
+                args="debug",
+            ),
+            WorkflowOption(
+                label="Improve code",
+                description="Refactor, optimize, clean up",
+                skill="dev",
+                args="refactor",
+            ),
+            WorkflowOption(
+                label="Validate work",
+                description="Test, review, audit for security",
+                skill="testing",
+                args="run",
+            ),
+            WorkflowOption(
+                label="Ship changes",
+                description="Commit, create PR, release",
+                skill="dev",
+                args="commit",
+            ),
+        ],
+    )
+
+
+def get_ask_user_question_format(classification: IntentClassification) -> dict[str, Any]:
+    """Convert classification to AskUserQuestion tool format.
+
+    Args:
+        classification: Result from classify_intent()
+
+    Returns:
+        Dict ready to pass to AskUserQuestion tool
+    """
+    return {
+        "questions": [
+            {
+                "question": classification.suggested_question,
+                "header": classification.category.value.title(),
+                "options": [opt.to_ask_user_option() for opt in classification.options],
+                "multiSelect": False,
+            }
+        ]
+    }
+
+
+def get_skill_for_selection(
+    classification: IntentClassification, selected_label: str
+) -> tuple[str, str]:
+    """Get skill and args for user's selection.
+
+    Args:
+        classification: The classification that was shown to user
+        selected_label: The label the user selected
+
+    Returns:
+        Tuple of (skill, args) to invoke
+    """
+    for option in classification.options:
+        if option.label == selected_label:
+            return option.skill, option.args
+
+    # Fallback to first option if not found
+    if classification.options:
+        return classification.options[0].skill, classification.options[0].args
+
+    return "attune", ""
+
+
+# Convenience function for the /attune command
+def process_socratic_response(user_response: str) -> dict[str, Any]:
+    """Process user's response to Socratic question.
+
+    This is the main entry point for the /attune command after
+    asking "What are you trying to accomplish?"
+
+    Args:
+        user_response: User's natural language response
+
+    Returns:
+        Dict with:
+            - classification: IntentClassification object
+            - ask_user_format: Ready-to-use AskUserQuestion format
+            - confidence: How confident we are in the classification
+    """
+    classification = classify_intent(user_response)
+
+    return {
+        "classification": classification,
+        "ask_user_format": get_ask_user_question_format(classification),
+        "confidence": classification.confidence,
+        "category": classification.category.value,
+    }
+
+
+# =============================================================================
+# DEEP DISCOVERY - SocraticWorkflowBuilder Integration
+# =============================================================================
+
+
+def form_to_ask_user_question(form: Form) -> dict[str, Any]:
+    """Convert a SocraticWorkflowBuilder Form to AskUserQuestion format.
+
+    This bridges the Socratic system's Form objects with Claude Code's
+    AskUserQuestion tool.
+
+    Args:
+        form: Form from SocraticWorkflowBuilder.get_next_questions()
+
+    Returns:
+        Dict ready to pass to AskUserQuestion tool
+
+    Example:
+        >>> from attune.socratic import SocraticWorkflowBuilder
+        >>> builder = SocraticWorkflowBuilder()
+        >>> session = builder.start_session("automate code reviews")
+        >>> form = builder.get_next_questions(session)
+        >>> ask_user_format = form_to_ask_user_question(form)
+    """
+    from attune.socratic.forms import FieldType
+
+    questions = []
+
+    for field in form.fields:
+        # Convert field to question format
+        question_data = {
+            "question": field.label,
+            "header": field.category.title() if field.category else "Question",
+            "multiSelect": field.field_type == FieldType.MULTI_SELECT,
+            "options": [],
+        }
+
+        # Convert options
+        if field.options:
+            for opt in field.options[:4]:  # AskUserQuestion max 4 options
+                option_data = {"label": opt.value, "description": opt.description or opt.label}
+                if opt.recommended:
+                    option_data["label"] += " (Recommended)"
+                question_data["options"].append(option_data)
+        else:
+            # Text field - provide generic options
+            question_data["options"] = [
+                {"label": "Continue", "description": "Proceed with current settings"},
+                {"label": "Customize", "description": "I want to specify details"},
+            ]
+
+        questions.append(question_data)
+
+    # Limit to 4 questions per AskUserQuestion call
+    return {"questions": questions[:4]}
+
+
+def should_use_deep_discovery(user_response: str, classification: IntentClassification) -> bool:
+    """Determine if we should use full SocraticWorkflowBuilder.
+
+    Use deep discovery when:
+    - Low confidence classification
+    - User wants to create custom agents/workflows
+    - Complex multi-step requirements
+
+    Args:
+        user_response: User's natural language response
+        classification: Result from classify_intent()
+
+    Returns:
+        True if should use SocraticWorkflowBuilder, False for quick routing
+    """
+    # Low confidence - need more clarification
+    if classification.confidence < 0.5:
+        return True
+
+    # Explicit agent/workflow creation keywords
+    deep_keywords = [
+        "create agent",
+        "custom workflow",
+        "build workflow",
+        "automate",
+        "automation",
+        "generate agents",
+        "multi-step",
+        "pipeline",
+    ]
+
+    response_lower = user_response.lower()
+    for keyword in deep_keywords:
+        if keyword in response_lower:
+            return True
+
+    return False
+
+
+def start_deep_discovery(goal: str) -> tuple[SocraticSession, dict[str, Any]]:
+    """Start a full SocraticWorkflowBuilder session.
+
+    Args:
+        goal: User's goal statement
+
+    Returns:
+        Tuple of (session, ask_user_format)
+
+    Example:
+        >>> session, questions = start_deep_discovery("automate security reviews")
+        >>> # Use questions with AskUserQuestion tool
+        >>> # Then call continue_deep_discovery(session, answers)
+    """
+    from attune.socratic import SocraticWorkflowBuilder
+
+    builder = SocraticWorkflowBuilder()
+    session = builder.start_session(goal)
+    form = builder.get_next_questions(session)
+
+    if form:
+        ask_user_format = form_to_ask_user_question(form)
+    else:
+        # Session ready to generate
+        ask_user_format = {
+            "questions": [
+                {
+                    "question": "Ready to generate your workflow. Proceed?",
+                    "header": "Generate",
+                    "options": [
+                        {"label": "Generate", "description": "Create the workflow now"},
+                        {"label": "Add details", "description": "I want to specify more"},
+                    ],
+                    "multiSelect": False,
+                }
+            ]
+        }
+
+    return session, ask_user_format
+
+
+def continue_deep_discovery(
+    session: SocraticSession, answers: dict[str, Any]
+) -> tuple[SocraticSession, dict[str, Any] | None]:
+    """Continue a SocraticWorkflowBuilder session with answers.
+
+    Args:
+        session: Active session from start_deep_discovery
+        answers: User's answers to previous questions
+
+    Returns:
+        Tuple of (updated_session, next_questions_or_None)
+    """
+    from attune.socratic import SocraticWorkflowBuilder
+
+    builder = SocraticWorkflowBuilder()
+    builder._sessions[session.session_id] = session
+
+    session = builder.submit_answers(session, answers)
+
+    if builder.is_ready_to_generate(session):
+        return session, None
+
+    form = builder.get_next_questions(session)
+    if form:
+        return session, form_to_ask_user_question(form)
+
+    return session, None
+
+
+# =============================================================================
+# UNIFIED ENTRY POINT
+# =============================================================================
+
+
+class AttuneRouter:
+    """Unified router for /attune command.
+
+    Handles both quick routing and deep discovery modes.
+
+    Example (Claude Code /attune command):
+        >>> router = AttuneRouter()
+        >>>
+        >>> # User says: "I need to fix a bug"
+        >>> result = router.process("I need to fix a bug")
+        >>>
+        >>> if result["mode"] == "quick":
+        >>>     # Use AskUserQuestion with result["ask_user_format"]
+        >>>     # Then call router.route_selection(result, user_selection)
+        >>>
+        >>> elif result["mode"] == "deep":
+        >>>     # Multi-round discovery session
+        >>>     # Use AskUserQuestion, then router.continue_session(...)
+    """
+
+    def __init__(self):
+        """Initialize the router."""
+        self._sessions: dict[str, SocraticSession] = {}
+
+    def process(self, user_response: str) -> dict[str, Any]:
+        """Process user's response and determine routing mode.
+
+        Args:
+            user_response: User's answer to "What are you trying to accomplish?"
+
+        Returns:
+            Dict with:
+                - mode: "quick" or "deep"
+                - ask_user_format: Ready for AskUserQuestion tool
+                - classification: (quick mode) IntentClassification
+                - session: (deep mode) SocraticSession
+        """
+        classification = classify_intent(user_response)
+
+        if should_use_deep_discovery(user_response, classification):
+            session, ask_user_format = start_deep_discovery(user_response)
+            self._sessions[session.session_id] = session
+
+            return {
+                "mode": "deep",
+                "session_id": session.session_id,
+                "ask_user_format": ask_user_format,
+                "classification": classification,
+            }
+        else:
+            return {
+                "mode": "quick",
+                "ask_user_format": get_ask_user_question_format(classification),
+                "classification": classification,
+                "category": classification.category.value,
+            }
+
+    def route_selection(
+        self, process_result: dict[str, Any], selected_label: str
+    ) -> dict[str, Any]:
+        """Route user's selection to skill invocation.
+
+        Args:
+            process_result: Result from process()
+            selected_label: Label user selected in AskUserQuestion
+
+        Returns:
+            Dict with skill and args to invoke
+        """
+        classification = process_result.get("classification")
+
+        if classification:
+            skill, args = get_skill_for_selection(classification, selected_label)
+        else:
+            skill, args = "attune", ""
+
+        return {
+            "skill": skill,
+            "args": args,
+            "instruction": f"Use Skill tool with skill='{skill}'"
+            + (f", args='{args}'" if args else ""),
+        }
+
+    def continue_session(
+        self, session_id: str, answers: dict[str, Any]
+    ) -> dict[str, Any]:
+        """Continue a deep discovery session.
+
+        Args:
+            session_id: Session ID from process() result
+            answers: User's answers to questions
+
+        Returns:
+            Dict with next questions or generated workflow
+        """
+        session = self._sessions.get(session_id)
+        if not session:
+            return {"error": "Session not found"}
+
+        session, next_questions = continue_deep_discovery(session, answers)
+        self._sessions[session_id] = session
+
+        if next_questions:
+            return {
+                "mode": "deep",
+                "session_id": session_id,
+                "ask_user_format": next_questions,
+            }
+        else:
+            # Ready to generate
+            from attune.socratic import SocraticWorkflowBuilder
+
+            builder = SocraticWorkflowBuilder()
+            builder._sessions[session_id] = session
+            workflow = builder.generate_workflow(session)
+
+            return {
+                "mode": "complete",
+                "session_id": session_id,
+                "workflow": workflow,
+                "summary": builder.get_session_summary(session),
+            }

attune/vscode_bridge.py

@@ -43,10 +43,13 @@ class CodeReviewResult:
 
 
 def get_empathy_dir() -> Path:
-    """Get the .empathy directory, creating if needed."""
-    empathy_dir = Path(".empathy")
-    empathy_dir.mkdir(exist_ok=True)
-    return empathy_dir
+    """Get the .attune directory, creating if needed.
+
+    Note: Function retains 'empathy' name for backward compatibility.
+    """
+    attune_dir = Path(".attune")
+    attune_dir.mkdir(exist_ok=True)
+    return attune_dir
 
 
 def write_code_review_results(

{attune_ai-2.1.1.dist-info → attune_ai-2.1.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: attune-ai
-Version: 2.1.1
+Version: 2.1.3
 Summary: AI collaboration framework with real LLM agent execution, AskUserQuestion tool integration, Socratic agent generation, progressive tier escalation (70-85% cost savings), meta-orchestration, dynamic agent composition (10 patterns including Anthropic-inspired), intelligent caching (85% hit rate), semantic workflow discovery, visual workflow editor, MCP integration for Claude Code, and multi-agent orchestration.
 Author-email: Patrick Roebuck <admin@smartaimemory.com>
 Maintainer-email: Smart-AI-Memory <admin@smartaimemory.com>
@@ -421,11 +421,11 @@ Requires-Dist: aiohttp<4.0.0,>=3.10.0; extra == "all"
 Requires-Dist: filelock<4.0.0,>=3.16.0; extra == "all"
 Dynamic: license-file
 
-# attune-ai
+# Attune AI
 
-**AI-powered developer workflows with Socratic discovery.**
+**AI-powered developer workflows with cost optimization and intelligent routing.**
 
-Run code review, debugging, testing, and release workflows from Claude Code. One command guides you to the right workflow.
+Run code review, debugging, testing, and release workflows from your terminal or Claude Code. Smart tier routing saves 34-86% on LLM costs.
 
 [![PyPI](https://img.shields.io/pypi/v/attune-ai?color=blue)](https://pypi.org/project/attune-ai/)
 [![Tests](https://img.shields.io/badge/tests-7%2C168%20passing%20(99.9%25)-brightgreen)](https://github.com/Smart-AI-Memory/attune-ai/actions)
@@ -438,26 +438,38 @@ pip install attune-ai[developer]
 
 ---
 
-## What's New in v2.1.0
+## Key Features
 
-**🎯 Unified `/attune` Command** - One entry point for all workflows:
+### Claude-Native Architecture
 
-```bash
-/attune                    # Start Socratic discovery
-/attune "fix a bug"        # Natural language
-/attune debug              # Direct shortcut
-```
+Attune AI is built exclusively for Anthropic/Claude, unlocking features impossible with multi-provider abstraction:
+
+- **Prompt Caching** - 90% cost reduction on repeated prompts
+- **Flexible Context** - 200K via subscription, up to 1M via API for large codebases
+- **Extended Thinking** - Access Claude's internal reasoning process
+- **Advanced Tool Use** - Optimized for agentic workflows
+
+### Multi-Agent Orchestration
+
+Full support for custom agents and Anthropic LLM agents:
 
-**Socratic Discovery** - Ask what you're trying to accomplish, not which tool to use:
+- **Agent Coordination Dashboard** - Real-time monitoring with 6 coordination patterns
+- **Custom Agents** - Build specialized agents for your workflow needs
+- **Inter-Agent Communication** - Heartbeats, signals, events, and approval gates
 
-- 🔧 **Fix or improve** → Debug, review, refactor
-- ✅ **Validate work** → Tests, coverage, security audit
-- 🚀 **Ship changes** → Commit, PR, release
-- 📚 **Understand** → Explain code, generate docs
+### Intelligent Cost Optimization
 
-**Performance Audit Improvements** - Removed false positive detection for intentional patterns like `dirs[:]` and defensive list copies.
+- **$0 in Claude Code** - Workflows run as skills through Claude's Task tool
+- **Smart Tier Routing** - Automatically selects the right model for each task
+- **Authentication Strategy** - Routes between subscription and API based on codebase size
 
-[See Full Changelog](CHANGELOG.md)
+### Socratic Workflows
+
+Workflows guide you through discovery instead of requiring upfront configuration:
+
+- **Interactive Discovery** - Asks targeted questions to understand your needs
+- **Context Gathering** - Collects relevant code, errors, and constraints
+- **Dynamic Agent Creation** - Assembles the right team based on your answers
 
 ---
 
@@ -475,74 +487,31 @@ pip install attune-ai[developer]
 # Auto-detect API keys
 python -m attune.models.cli provider
 
-# Or set explicitly
-python -m attune.models.cli provider --set anthropic
+# Or configure authentication strategy
+python -m attune.models.auth_cli setup
 ```
 
-### 3. Use
-
-**In Claude Code:**
+### 3. Use in Claude Code
 
 ```bash
 /dev           # Developer tools (debug, commit, PR, review)
-/testing       # Run tests, coverage, benchmarks
+/testing       # Run tests, coverage analysis, benchmarks
 /workflows     # Automated analysis (security, bugs, perf)
-/plan          # Planning, TDD, code review
+/plan          # Planning, TDD, code review, refactoring
 /docs          # Documentation generation
 /release       # Release preparation
 
 # Natural language support:
 /workflows "find security issues"
 /plan "review my code"
-
-# Direct tool access via MCP (v5.1.1+):
-# Claude Code automatically discovers Empathy tools through the MCP server
-# Just describe what you need in natural language:
-"Run a security audit on src/"          → Invokes security_audit tool
-"Generate tests for config.py"          → Invokes test_generation tool
-"Check my auth configuration"           → Invokes auth_status tool
-"Analyze performance bottlenecks"       → Invokes performance_audit tool
 ```
 
-**MCP Server Integration (v5.1.1+):**
-
-Empathy Framework now includes a Model Context Protocol (MCP) server that exposes all workflows as native Claude Code tools:
-
-- **10 Tools Available:** security_audit, bug_predict, code_review, test_generation, performance_audit, release_prep, auth_status, auth_recommend, telemetry_stats, dashboard_status
-- **Automatic Discovery:** No manual configuration needed - Claude Code finds tools via `.claude/mcp.json`
-- **Natural Language Access:** Describe your need and Claude invokes the appropriate tool
-- **Verification Hooks:** Automatic validation of Python/JSON files and workflow outputs
-
-To verify MCP integration:
+### 4. Use via CLI
 
 ```bash
-# Check server is running
-echo '{"method":"tools/list","params":{}}' | PYTHONPATH=./src python -m attune.mcp.server
-
-# Restart Claude Code to load the MCP server
-# Tools will appear in Claude's tool list automatically
-```
-
-See [.claude/MCP_TEST_RESULTS.md](.claude/MCP_TEST_RESULTS.md) for full integration details.
-
-**CLI:**
-
-```bash
-empathy workflow run security-audit --path ./src
-empathy workflow run test-coverage --target 90
-empathy telemetry show  # View cost savings
-```
-
-**Python:**
-
-```python
-from attune import EmpathyOS
-
-async with EmpathyOS() as empathy:
-    result = await empathy.level_2_guided(
-        "Review this code for security issues"
-    )
-    print(result["response"])
+attune workflow run security-audit --path ./src
+attune workflow run test-coverage --target 90
+attune telemetry show  # View cost savings
 ```
 
 ---
@@ -559,67 +528,14 @@ Workflows are organized into hubs for easy discovery:
 | **Release**       | `/release`    | Release prep, security scan, publishing      |
 | **Workflows**     | `/workflows`  | Automated analysis (security, bugs, perf)    |
 | **Plan**          | `/plan`       | Planning, TDD, code review, refactoring      |
-| **Utilities**     | `/utilities`  | Project init, dependencies, profiling        |
-| **Learning**      | `/learning`   | Pattern learning and session evaluation      |
-| **Context**       | `/context`    | State management and memory                  |
 | **Agent**         | `/agent`      | Create and manage custom agents              |
 
-**Natural Language Support:**
+**Natural Language Routing:**
 
 ```bash
-# Use plain English - intelligent routing matches your intent
 /workflows "find security vulnerabilities"  # → security-audit
 /workflows "check code performance"         # → perf-audit
-/workflows "predict bugs"                   # → bug-predict
 /plan "review my code"                      # → code-review
-/plan "help me plan this feature"           # → planning
-
-# Or use traditional workflow names
-/workflows security-audit
-/plan code-review
-```
-
-**Interactive menus:**
-
-```bash
-/dev                    # Show interactive menu
-/dev "debug auth error" # Jump directly to debugging
-/testing "run coverage" # Run coverage analysis
-/release                # Start release preparation
-```
-
----
-
-## Socratic Method
-
-Workflows guide you through discovery instead of requiring upfront configuration:
-
-```text
-You: /dev
-
-Claude: What development task do you need?
-  1. Debug issue
-  2. Create commit
-  3. PR workflow
-  4. Quality check
-
-You: 1
-
-Claude: What error or unexpected behavior are you seeing?
-```
-
-**How it works:**
-
-1. **Discovery** - Workflow asks targeted questions to understand your needs
-2. **Context gathering** - Collects relevant code, errors, and constraints
-3. **Dynamic agent creation** - Assembles the right team based on your answers
-4. **Execution** - Runs with appropriate tier selection
-
-**Create custom agents with Socratic guidance:**
-
-```bash
-/agent create    # Guided agent creation
-/agent team      # Build multi-agent teams interactively
 ```
 
 ---
@@ -634,120 +550,93 @@ When using Claude Code, workflows run as skills through the Task tool - **no API
 /dev           # $0 - uses your Claude subscription
 /testing       # $0
 /release       # $0
-/agent create  # $0
 ```
 
 ### API Mode (CI/CD, Automation)
 
 For programmatic use, smart tier routing saves 34-86%:
 
-| Tier    | Model               | Use Case                    | Cost        |
-| ------- | ------------------- | --------------------------- | ----------- |
-| CHEAP   | Haiku / GPT-4o-mini | Formatting, simple tasks    | ~$0.005     |
-| CAPABLE | Sonnet / GPT-4o     | Bug fixes, code review      | ~$0.08      |
-| PREMIUM | Opus / o1           | Architecture, complex design | ~$0.45      |
+| Tier    | Model         | Use Case                     | Cost    |
+| ------- | ------------- | ---------------------------- | ------- |
+| CHEAP   | Haiku         | Formatting, simple tasks     | ~$0.005 |
+| CAPABLE | Sonnet        | Bug fixes, code review       | ~$0.08  |
+| PREMIUM | Opus          | Architecture, complex design | ~$0.45  |
 
 ```bash
 # Track API usage and savings
-empathy telemetry savings --days 30
+attune telemetry savings --days 30
 ```
 
 ---
 
-## Key Features
-
-### Multi-Agent Workflows
-
-```bash
-# 4 parallel agents check release readiness
-empathy orchestrate release-prep
-
-# Sequential coverage improvement
-empathy orchestrate test-coverage --target 90
-```
+## MCP Server Integration
 
-### Response Caching
+Attune AI includes a Model Context Protocol (MCP) server that exposes all workflows as native Claude Code tools:
 
-Up to 57% cache hit rate on similar prompts. Zero config needed.
+- **10 Tools Available** - security_audit, bug_predict, code_review, test_generation, performance_audit, release_prep, and more
+- **Automatic Discovery** - Claude Code finds tools via `.claude/mcp.json`
+- **Natural Language Access** - Describe your need and Claude invokes the appropriate tool
 
-```python
-from attune.workflows import SecurityAuditWorkflow
-
-workflow = SecurityAuditWorkflow(enable_cache=True)
-result = await workflow.execute(target_path="./src")
-print(f"Cache hit rate: {result.cost_report.cache_hit_rate:.1f}%")
+```bash
+# Verify MCP integration
+echo '{"method":"tools/list","params":{}}' | PYTHONPATH=./src python -m attune.mcp.server
 ```
 
-### Pattern Learning
-
-Workflows learn from outcomes and improve over time:
+---
 
-```python
-from attune.orchestration.config_store import ConfigurationStore
+## Agent Coordination Dashboard
 
-store = ConfigurationStore()
-best = store.get_best_for_task("release_prep")
-print(f"Success rate: {best.success_rate:.1%}")
-```
+Real-time monitoring with 6 coordination patterns:
 
-### Multi-Provider Support
+- Agent heartbeats and status tracking
+- Inter-agent coordination signals
+- Event streaming across agent workflows
+- Approval gates for human-in-the-loop
+- Quality feedback and performance metrics
+- Demo mode with test data generation
 
-```python
-from attune_llm.providers import (
-    AnthropicProvider,  # Claude
-    OpenAIProvider,     # GPT-4
-    GeminiProvider,     # Gemini
-    LocalProvider,      # Ollama, LM Studio
-)
+```bash
+# Launch dashboard (requires Redis)
+python examples/dashboard_demo.py
+# Open http://localhost:8000
 ```
 
 ---
 
-## CLI Reference
+## Authentication Strategy
+
+Intelligent routing between Claude subscription and Anthropic API:
 
 ```bash
-# Provider configuration
-python -m attune.models.cli provider
-python -m attune.models.cli provider --set hybrid
+# Interactive setup
+python -m attune.models.auth_cli setup
 
-# Workflows
-empathy workflow list
-empathy workflow run <workflow-name>
+# View current configuration
+python -m attune.models.auth_cli status
 
-# Cost tracking
-empathy telemetry show
-empathy telemetry savings --days 30
-empathy telemetry export --format csv
+# Get recommendation for a file
+python -m attune.models.auth_cli recommend src/module.py
+```
 
-# Orchestration
-empathy orchestrate release-prep
-empathy orchestrate test-coverage --target 90
+**Automatic routing:**
 
-# Meta-workflows
-empathy meta-workflow list
-empathy meta-workflow run release-prep --real
-```
+- Small/medium modules (<2000 LOC) → Claude subscription (free)
+- Large modules (>2000 LOC) → Anthropic API (pay for what you need)
 
 ---
 
-## Install Options
+## Installation Options
 
 ```bash
 # Individual developers (recommended)
 pip install attune-ai[developer]
 
-# All LLM providers
-pip install attune-ai[llm]
-
 # With caching (semantic similarity)
 pip install attune-ai[cache]
 
 # Enterprise (auth, rate limiting)
 pip install attune-ai[enterprise]
 
-# Healthcare (HIPAA compliance)
-pip install attune-ai[healthcare]
-
 # Development
 git clone https://github.com/Smart-AI-Memory/attune-ai.git
 cd attune-ai && pip install -e .[dev]
@@ -758,74 +647,38 @@ cd attune-ai && pip install -e .[dev]
 ## Environment Setup
 
 ```bash
-# At least one provider required
+# Required: Anthropic API key
 export ANTHROPIC_API_KEY="sk-ant-..."
-export OPENAI_API_KEY="sk-..."
-export GOOGLE_API_KEY="..."
 
-# Optional (but required for Agent Dashboard): Redis for memory
+# Optional: Redis for Agent Dashboard and memory
 export REDIS_URL="redis://localhost:6379"
 ```
 
 ---
 
-## VSCode Extension
-
-Install the Empathy VSCode extension for:
-
-- **Dashboard** - Health score, costs, patterns
-- **One-Click Workflows** - Run from command palette
-- **Memory Panel** - Manage Redis and patterns
-- **Cost Tracking** - Real-time savings display
-
----
-
-## Documentation
-
-- [Quick Start Guide](docs/quickstart.md)
-- [CLI Reference](docs/cli-reference.md)
-- [Testing Guide](docs/testing-guide.md)
-- [Keyboard Shortcuts](docs/keyboard-shortcuts.md)
-- [Full Documentation](https://smartaimemory.com/framework-docs/)
-
----
-
 ## Security
 
 - Path traversal protection on all file operations
 - JWT authentication with rate limiting
 - PII scrubbing in telemetry
 - HIPAA/GDPR compliance options
-- **Automated security scanning** with 82% accuracy (Phase 3 AST-based detection)
-
-See [SECURITY.md](SECURITY.md) for vulnerability reporting.
-
-### Security Scanning
-
-**Automated security scanning in CI/CD** - 82% accuracy, blocks critical issues:
+- Automated security scanning with 82% accuracy
 
 ```bash
-# Run security audit locally
-empathy workflow run security-audit
-
-# Scan specific directory
-empathy workflow run security-audit --input '{"path":"./src"}'
+# Run security audit
+attune workflow run security-audit --path ./src
 ```
 
-**Documentation:**
+See [SECURITY.md](SECURITY.md) for vulnerability reporting.
 
-- **[Developer Workflow Guide](docs/DEVELOPER_SECURITY_WORKFLOW.md)** - Quick reference for handling security findings (all developers)
-- **[CI/CD Integration Guide](docs/CI_SECURITY_SCANNING.md)** - Complete setup and troubleshooting (DevOps, developers)
-- **[Scanner Architecture](docs/SECURITY_SCANNER_ARCHITECTURE.md)** - Technical implementation details (engineers, architects)
-- **[Remediation Process](docs/SECURITY_REMEDIATION_PROCESS.md)** - 3-phase methodology for improving scanners (security teams, leadership)
-- **[API Reference](docs/api-reference/security-scanner.md)** - Complete API documentation (developers extending scanner)
+---
 
-**Key achievements:**
+## Documentation
 
-- 82.3% reduction in false positives (350 → 62 findings)
-- 16x improvement in scanner accuracy
-- <15 minute average fix time for critical issues
-- Zero critical vulnerabilities in production code
+- [Quick Start Guide](docs/quickstart.md)
+- [CLI Reference](docs/cli-reference.md)
+- [Authentication Strategy Guide](docs/AUTH_STRATEGY_GUIDE.md)
+- [Full Documentation](https://smartaimemory.com/framework-docs/)
 
 ---
 
@@ -837,27 +690,20 @@ See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
 
 ## License
 
-**Apache License 2.0** - Free and open source for everyone. Use it, modify it, build commercial products with it. [Details →](LICENSE)
+**Apache License 2.0** - Free and open source. Use it, modify it, build commercial products with it. [Details →](LICENSE)
 
 ---
 
 ## Acknowledgements
 
-This project stands on the shoulders of giants. We are deeply grateful to the open source community and all the amazing projects that make this framework possible.
-
-**[View Full Acknowledgements →](ACKNOWLEDGEMENTS.md)**
-
 Special thanks to:
 
 - **[Anthropic](https://www.anthropic.com/)** - For Claude AI and the Model Context Protocol
-- **[LangChain](https://github.com/langchain-ai/langchain)** - Agent framework powering our meta-orchestration
+- **[LangChain](https://github.com/langchain-ai/langchain)** - Agent framework powering our orchestration
 - **[FastAPI](https://github.com/tiangolo/fastapi)** - Modern Python web framework
-- **[pytest](https://github.com/pytest-dev/pytest)** - Testing framework making quality assurance effortless
-
-And to all 50+ open source projects we depend on. [See the complete list →](ACKNOWLEDGEMENTS.md)
 
-Want to contribute? See [CONTRIBUTORS.md](CONTRIBUTORS.md)
+[View Full Acknowledgements →](ACKNOWLEDGEMENTS.md)
 
 ---
 
-**Built by [Smart AI Memory](https://smartaimemory.com)** · [Docs](https://smartaimemory.com/framework-docs/) · [Examples](examples/) · [Issues](https://github.com/Smart-AI-Memory/attune-ai/issues)
+**Built by [Smart AI Memory](https://smartaimemory.com)** · [Docs](https://smartaimemory.com/framework-docs/) · [Issues](https://github.com/Smart-AI-Memory/attune-ai/issues)

{attune_ai-2.1.1.dist-info → attune_ai-2.1.3.dist-info}/RECORD

@@ -23,11 +23,12 @@ attune/persistence.py,sha256=wsEJtHdjpEfIQ3-O5PaxAGiZXacON0Pft4gqt7Ui3z8,17714
 attune/platform_utils.py,sha256=NsvAOOA2QgdWLd_44AY1UdQLYuclaOC7SPK-koFyi1A,7384
 attune/redis_config.py,sha256=jDpnKXxBoAo6Cy2oBX9imbRtsUAyPKOIH6jvSlWdcbU,9742
 attune/redis_memory.py,sha256=MYhW_M41AoWhxxh8YggWUHxZaUoQZ7XxqeBB2qDqyww,23347
+attune/socratic_router.py,sha256=sHEPYDC88n6OaGBtnC7JquyctldBp3tSCQdrphV0BHo,23601
 attune/templates.py,sha256=EbZmiHqS_jFZg_-lScK0fUUnw7_KpE5J3ZFTWXEKx-Q,17187
 attune/tier_recommender.py,sha256=rBuAgGkNlX9wWcJ1QFi0ASGuZSR9RGl6PEBElxcAzMk,14297
 attune/tools.py,sha256=YCfHTm9Es6wwh7oESt4q0mDz7AV8ecvMAB_1_0516r4,6225
 attune/trust_building.py,sha256=z2ZsQWK5QjX6d7pxFWrFD54J1keUguTog6YztZJVPKI,19180
-attune/vscode_bridge.py,sha256=ToUx4QvfRXQeSmh10sz7gzzEYMBymOTqJ6Zt4RE9YK4,4963
+attune/vscode_bridge.py,sha256=XBKF6-YiQIRvyOtkp-4kmBrWhs5Uflo7TLUBj4ejPLU,5034
 attune/workflow_commands.py,sha256=9Gdy3iI6LA9y7NtYBieNS3-rbOrrLRavhlbl_2yWVgU,25465
 attune/adaptive/__init__.py,sha256=9LRWvrkitzasuGAqANEpKQMvrj5pPNtulSxz49E-Ke4,338
 attune/adaptive/task_complexity.py,sha256=XhQgubrTxqV2V6CBD4kKZ_0kPCjchzg94HaUFIY6Q3c,3783
@@ -346,8 +347,8 @@ attune/workflows/test_gen/data_models.py,sha256=wXfef60ptiG6AvygayTxWqlL5FVOss19
 attune/workflows/test_gen/report_formatter.py,sha256=RaxbDp6-9iQRfJmVwrrIReVkOkrnb668NgHrNaS-SPY,10705
 attune/workflows/test_gen/test_templates.py,sha256=4ywqGYYaSoZxOU6Y1_E-27KEgMI5-v2a1ndia406E9c,13180
 attune/workflows/test_gen/workflow.py,sha256=U0dhAcCKmlltPIvCSXUeFzt_Q4TodQI4tXtR6cz19MQ,25729
-attune_ai-2.1.1.dist-info/licenses/LICENSE,sha256=kqe3EeGatNB79lUTHxjLnxDe7VJr0iYetThOr4_Fx7A,11348
-attune_ai-2.1.1.dist-info/licenses/LICENSE_CHANGE_ANNOUNCEMENT.md,sha256=JH9yAQGv_lQej5YlztI_kawbVQ2H8uVLhPGlrWnR_34,3844
+attune_ai-2.1.3.dist-info/licenses/LICENSE,sha256=kqe3EeGatNB79lUTHxjLnxDe7VJr0iYetThOr4_Fx7A,11348
+attune_ai-2.1.3.dist-info/licenses/LICENSE_CHANGE_ANNOUNCEMENT.md,sha256=JH9yAQGv_lQej5YlztI_kawbVQ2H8uVLhPGlrWnR_34,3844
 attune_healthcare/__init__.py,sha256=4NioL1_86UXzkd-QNkQZUSZ8rKTQGSP0TC9VXP32kQs,295
 attune_healthcare/monitors/__init__.py,sha256=Udp8qfZR504QAq5_eQjvtIaE7v06Yguc7nuF40KllQc,196
 attune_healthcare/monitors/clinical_protocol_monitor.py,sha256=MWE5t8tW9HWZn_SNo-inx8-0nhdTNGhbcB8ZeDWyXa0,11648
@@ -449,8 +450,8 @@ workflow_scaffolding/__init__.py,sha256=UpX5vjjjPjIaAKyIV1D4GxJzLUZy5DzdzgSkePYM
 workflow_scaffolding/__main__.py,sha256=0qspuNoadTDqyskXTlT8Sahqau-XIxN35NHTSGVW6z4,236
 workflow_scaffolding/cli.py,sha256=RUVqU9SeAgm7YkM0YNd-quh8u6BNzmX8xM2y9K_p68Y,6759
 workflow_scaffolding/generator.py,sha256=2WC02A10lzF2NQgOn66ksV17Oe72kKlU2qCQs39LIlw,8861
-attune_ai-2.1.1.dist-info/METADATA,sha256=EI1tND_AQuj_XW98SejMJ2p0UFRnfrjDQu1KL26jK3k,38450
-attune_ai-2.1.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-attune_ai-2.1.1.dist-info/entry_points.txt,sha256=GVlb04zFlpkaPtaL7X3JCZI8R0AEOZRsZjJ-wIDQvdo,1458
-attune_ai-2.1.1.dist-info/top_level.txt,sha256=iLyjKpuOzWtwmIOZqzeBh8_SVztY2vFvhHcyo1WPtTY,73
-attune_ai-2.1.1.dist-info/RECORD,,
+attune_ai-2.1.3.dist-info/METADATA,sha256=sCt_8yu13CtsXc3fhY4aqyBNZgiWLVO8GtQ4yF-rXM0,33764
+attune_ai-2.1.3.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+attune_ai-2.1.3.dist-info/entry_points.txt,sha256=GVlb04zFlpkaPtaL7X3JCZI8R0AEOZRsZjJ-wIDQvdo,1458
+attune_ai-2.1.3.dist-info/top_level.txt,sha256=iLyjKpuOzWtwmIOZqzeBh8_SVztY2vFvhHcyo1WPtTY,73
+attune_ai-2.1.3.dist-info/RECORD,,