attune-ai 2.1.1__py3-none-any.whl → 2.1.2__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.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: attune-ai
-Version: 2.1.1
+Version: 2.1.2
 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,16 +421,17 @@ 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
+# Empathy Framework
 
-**AI-powered developer workflows with Socratic discovery.**
+**AI-powered developer workflows with cost optimization and pattern learning.**
 
-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)
 [![Python](https://img.shields.io/badge/python-3.10+-blue)](https://www.python.org)
 [![License](https://img.shields.io/badge/license-Apache%202.0-blue)](LICENSE)
+[![Performance](https://img.shields.io/badge/performance-18x%20faster-success)](https://github.com/Smart-AI-Memory/attune-ai/blob/main/CHANGELOG.md)
 
 ```bash
 pip install attune-ai[developer]
@@ -438,26 +439,188 @@ pip install attune-ai[developer]
 
 ---
 
-## What's New in v2.1.0
+## 🎯 Transitioning to Claude-Native Architecture
 
-**🎯 Unified `/attune` Command** - One entry point for all workflows:
+**Empathy Framework is evolving to focus exclusively on Anthropic/Claude** to unlock features impossible with multi-provider abstraction:
+
+- **📦 Prompt Caching:** 90% cost reduction on repeated prompts
+- **📖 Flexible Context:** 200K via subscription for most tasks, up to 1M via API for large codebases
+- **🧠 Extended Thinking:** See Claude's internal reasoning process
+- **🔧 Advanced Tool Use:** Optimized for agentic workflows
+
+**Timeline:**
+
+- ✅ **v4.8.0 (Jan 2026):** Deprecation warnings for OpenAI/Google/Ollama providers
+- ✅ **v5.0.0 (Jan 26, 2026):** Non-Anthropic providers removed (BREAKING - COMPLETE)
+- ✅ **v5.0.2 (Jan 28, 2026):** Cost optimization suite with batch processing and caching monitoring
+
+**Migration Guide:** [docs/CLAUDE_NATIVE.md](docs/CLAUDE_NATIVE.md)
+
+---
+
+## What's New in v5.3.0
+
+**🎨 Dashboard Enhancements** - Improved usability and clarity:
+
+- **Agent Display Names** - Human-readable labels for agents in dashboard (e.g., "Code Analyzer" instead of UUID)
+- **Comprehensive Help Panel** - 5-section accordion explaining dashboard features, use cases, and Redis setup
+- **UX Improvements** - "Source Agent:" label clarity, "Redis Requires Enabling" status message
+- **Browser Cache Busting** - Date-based versioning ensures updates appear immediately
+
+**📚 Documentation Improvements**:
+
+- Clarified flexible context strategy (200K subscription + 1M API routing)
+- Added Redis requirement documentation for dashboard
+- Root directory cleanup (8 archived files)
+
+**🧪 Test Infrastructure**:
+
+- Sequential test execution to fix import timing issues
+- All agent tracking tests passing (19/19)
+
+[See Full Changelog](CHANGELOG.md#530---2026-01-31)
+
+---
+
+## What's New in v5.1.0
+
+**🤖 Multi-Agent Orchestration** - Full support for custom agents and Anthropic LLM agents:
+
+- **Agent Coordination Dashboard** - Real-time monitoring with 6 coordination patterns:
+  - 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
+
+- **Custom Agents** - Build specialized agents for your workflow needs
+- **LLM Agents from Anthropic** - Leverage Claude's advanced capabilities
+- Dashboard accessible at `http://localhost:8000` with `python examples/dashboard_demo.py` **(Requires Redis)**
+
+**🔐 Authentication Strategy System** - Intelligent routing between Claude subscriptions and Anthropic API:
 
 ```bash
-/attune                    # Start Socratic discovery
-/attune "fix a bug"        # Natural language
-/attune debug              # Direct shortcut
+# Interactive setup
+python -m attune.models.auth_cli setup
+
+# View current configuration
+python -m attune.models.auth_cli status
+
+# Get recommendation for a file
+python -m attune.models.auth_cli recommend src/module.py
 ```
 
-**Socratic Discovery** - Ask what you're trying to accomplish, not which tool to use:
+**💰 Automatic Cost Optimization** - Workflows choose the best auth method:
+
+- Small/medium modules (<2000 LOC) → Claude subscription (free)
+- Large modules (>2000 LOC) → Anthropic API (pay for what you need)
+- 7 workflows integrated: document-gen, test-gen, code-review, bug-predict, security-audit, perf-audit, release-prep
+- Auth mode tracking in all workflow outputs for telemetry
+
+**🧪 Comprehensive Testing** - 7 new integration tests for auth strategy:
+
+- All workflows tested with auth enabled/disabled
+- API and subscription mode verification
+- Cost tracking validation
+
+**📖 Documentation** - 950+ lines across 3 guides:
+
+- [AUTH_STRATEGY_GUIDE.md](docs/AUTH_STRATEGY_GUIDE.md) - User guide for configuration
+- [AUTH_CLI_IMPLEMENTATION.md](docs/AUTH_CLI_IMPLEMENTATION.md) - CLI command reference
+- [AUTH_WORKFLOW_INTEGRATIONS.md](docs/AUTH_WORKFLOW_INTEGRATIONS.md) - Integration patterns
+
+[See Full Changelog](CHANGELOG.md#510---2026-01-29)
+
+---
+
+## What's New in v5.0.2
+
+**💰 50% Cost Savings with Batch API** - Process non-urgent tasks asynchronously:
+
+```bash
+empathy batch submit batch_requests.json  # Submit batch job
+empathy batch status msgbatch_abc123      # Check progress
+empathy batch results msgbatch_abc123 output.json  # Download results
+```
+
+Perfect for: log analysis, report generation, bulk classification, test generation
+
+**📊 Precise Token Counting** - >98% accurate cost tracking:
+
+- Integrated Anthropic's `count_tokens()` API for billing-accurate measurements
+- 3-tier fallback: API → tiktoken (local) → heuristic
+- Cache-aware cost calculation (25% write markup, 90% read discount)
+
+**📈 Cache Performance Monitoring** - Track your 20-30% caching savings:
+
+```bash
+empathy cache stats           # Show hit rates and cost savings
+empathy cache stats --verbose # Detailed token metrics
+empathy cache stats --format json  # Machine-readable output
+```
+
+**🧭 Adaptive Routing Analytics** - Intelligent tier recommendations:
+
+```bash
+empathy routing stats <workflow>    # Performance metrics
+empathy routing check --all         # Tier upgrade recommendations
+empathy routing models --provider anthropic  # Compare models
+```
+
+**🔧 Dashboard Fixes** - All 6 agent coordination patterns now operational:
+- Agent heartbeats displaying correctly
+- Event streaming functional
+- Coordination signals working
+- Approval gates operational
+
+[See Full Changelog](CHANGELOG.md#502---2026-01-28) | [Batch API Guide](docs/BATCH_API_GUIDE.md) | [User API Docs](docs/USER_API_DOCUMENTATION.md)
+
+---
+
+## What's New in v4.9.0
+
+**⚡ 18x Faster Performance** - Massive performance gains through Phase 2 optimizations:
+
+- **Redis Two-Tier Caching:** 2x faster memory operations (37,000x for cached keys)
+- **Generator Expressions:** 99.9% memory reduction across 27 optimizations
+- **Parallel Scanning:** Multi-core processing enabled by default (2-4x faster)
+- **Incremental Scanning:** Git diff-based updates (10x faster)
+
+**🧭 Natural Language Workflows** - Use plain English instead of workflow names:
+
+```bash
+/workflows "find security vulnerabilities"  # → security-audit
+/workflows "check code performance"         # → perf-audit
+/workflows "predict bugs"                   # → bug-predict
+/plan "review my code"                      # → code-review
+```
+
+**📊 Real-World Performance:**
+
+- Combined workflow: 3.59s → 0.2s (**18x faster**)
+- Full scan: 3,472 files in 0.98s (was 3.59s)
+- Redis cached operations: 37ms → 0.001ms
+
+**🎯 Improved Navigation:**
+
+- Split `/workflow` into `/workflows` (automated analysis) and `/plan` (planning/review)
+- Clearer hub organization with better categorization
+- Natural language routing matches intent to workflow
+
+[See CHANGELOG.md](CHANGELOG.md) | [Performance Docs](docs/REDIS_OPTIMIZATION_SUMMARY.md)
+
+---
+
+## What's New in v4.7.0
+
+**$0 Workflows via Skills** - Multi-agent workflows run through Claude Code's Task tool instead of API calls. No additional cost with your Claude subscription.
 
-- 🔧 **Fix or improve** → Debug, review, refactor
-- ✅ **Validate work** → Tests, coverage, security audit
-- 🚀 **Ship changes** → Commit, PR, release
-- 📚 **Understand** → Explain code, generate docs
+**Socratic Workflows** - Interactive discovery through guided questions. Workflows ask what you need rather than requiring upfront configuration.
 
-**Performance Audit Improvements** - Removed false positive detection for intentional patterns like `dirs[:]` and defensive list copies.
+**Security Hardened** - Fixed critical vulnerabilities (path traversal, JWT, SSRF).
 
-[See Full Changelog](CHANGELOG.md)
+**Hub-Based Commands** - Organized workflows into intuitive command hubs.
 
 ---
 

{attune_ai-2.1.1.dist-info → attune_ai-2.1.2.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.2.dist-info/licenses/LICENSE,sha256=kqe3EeGatNB79lUTHxjLnxDe7VJr0iYetThOr4_Fx7A,11348
+attune_ai-2.1.2.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.2.dist-info/METADATA,sha256=4aE_g9pNuVToXXW4Zwf9ck-CJUcMG_e8MZ7jMukCkFE,45033
+attune_ai-2.1.2.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+attune_ai-2.1.2.dist-info/entry_points.txt,sha256=GVlb04zFlpkaPtaL7X3JCZI8R0AEOZRsZjJ-wIDQvdo,1458
+attune_ai-2.1.2.dist-info/top_level.txt,sha256=iLyjKpuOzWtwmIOZqzeBh8_SVztY2vFvhHcyo1WPtTY,73
+attune_ai-2.1.2.dist-info/RECORD,,