attune-ai 2.1.4__py3-none-any.whl → 2.2.0__py3-none-any.whl

attune/cli/__init__.py

@@ -60,21 +60,9 @@ def main() -> int:
 
     register_all_parsers(subparsers)
 
-    # TODO: Import and register remaining commands from cli.py
-    # This is a partial refactoring - additional commands still in cli.py
-    # For now, if command not found in new structure, fall back to old cli.py
-    #
-    # NOTE: Temporarily disabled to avoid conflicts with extracted commands.
-    # Commands that have been extracted:
-    #   - help, tier, info, patterns, status (Phase 1)
-    #   - workflow, inspect (run, inspect, export, import) (Phase 2)
-    # Once all commands are extracted, the old cli.py will be removed entirely.
-    #
-    # try:
-    #     from attune import cli as old_cli
-    #     _register_legacy_commands(subparsers, old_cli)
-    # except ImportError:
-    #     pass  # Old cli.py not available or already moved
+    # NOTE: CLI refactoring is COMPLETE (v2.1.5)
+    # All 30 commands have been extracted from the monolithic cli_legacy.py
+    # to the new modular structure in cli/commands/ and cli/parsers/.
 
     # Parse arguments
     args = parser.parse_args()
@@ -107,46 +95,6 @@ def main() -> int:
     return 0
 
 
-def _register_legacy_commands(subparsers, old_cli):
-    """Temporarily register commands not yet extracted from old cli.py.
-
-    This function provides backward compatibility during the refactoring process.
-    As commands are extracted into the new structure, they should be removed
-    from this registration.
-
-    Args:
-        subparsers: ArgumentParser subparsers object
-        old_cli: Reference to old cli module
-
-    Note:
-        This is a TEMPORARY function that will be removed once all commands
-        are extracted from the monolithic cli.py file.
-    """
-    # Import command functions that haven't been extracted yet
-    try:
-        # Patterns commands
-        from attune.cli import cmd_patterns_export, cmd_patterns_list, cmd_patterns_resolve
-
-        patterns_parser = subparsers.add_parser("patterns", help="Pattern management")
-        patterns_sub = patterns_parser.add_subparsers(dest="patterns_command")
-
-        p_list = patterns_sub.add_parser("list", help="List patterns")
-        p_list.set_defaults(func=cmd_patterns_list)
-
-        p_export = patterns_sub.add_parser("export", help="Export patterns")
-        p_export.add_argument("output", help="Output file")
-        p_export.set_defaults(func=cmd_patterns_export)
-
-        p_resolve = patterns_sub.add_parser("resolve", help="Resolve pattern")
-        p_resolve.add_argument("pattern_id", help="Pattern ID")
-        p_resolve.set_defaults(func=cmd_patterns_resolve)
-    except (ImportError, AttributeError):
-        pass  # Commands not available
-
-    # Add other legacy commands as needed...
-    # This list will shrink as commands are extracted
-
-
 # Preserve backward compatibility
 if __name__ == "__main__":
     sys.exit(main())

attune/cli/commands/batch.py

@@ -184,12 +184,8 @@ def cmd_batch_results(args):
         print(f"   Total: {len(results)} results")
 
         # Summary
-        succeeded = sum(
-            1 for r in results if r.get("result", {}).get("type") == "succeeded"
-        )
-        errored = sum(
-            1 for r in results if r.get("result", {}).get("type") == "errored"
-        )
+        succeeded = sum(1 for r in results if r.get("result", {}).get("type") == "succeeded")
+        errored = sum(1 for r in results if r.get("result", {}).get("type") == "errored")
 
         print(f"   Succeeded: {succeeded}")
         print(f"   Errored: {errored}")
@@ -242,12 +238,8 @@ def cmd_batch_wait(args):
         print(f"   Total: {len(results)} results")
 
         # Summary
-        succeeded = sum(
-            1 for r in results if r.get("result", {}).get("type") == "succeeded"
-        )
-        errored = sum(
-            1 for r in results if r.get("result", {}).get("type") == "errored"
-        )
+        succeeded = sum(1 for r in results if r.get("result", {}).get("type") == "succeeded")
+        errored = sum(1 for r in results if r.get("result", {}).get("type") == "errored")
 
         print(f"   Succeeded: {succeeded}")
         print(f"   Errored: {errored}")

attune/cli/commands/cache.py

@@ -93,14 +93,10 @@ def _collect_cache_stats(days: int = 7) -> dict[str, Any]:
             for line in f:
                 # Try to extract timestamp
                 # Common format: 2026-01-27 21:30:45,123
-                timestamp_match = re.match(
-                    r"(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})", line
-                )
+                timestamp_match = re.match(r"(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})", line)
                 if timestamp_match:
                     try:
-                        log_time = datetime.strptime(
-                            timestamp_match.group(1), "%Y-%m-%d %H:%M:%S"
-                        )
+                        log_time = datetime.strptime(timestamp_match.group(1), "%Y-%m-%d %H:%M:%S")
                         if log_time < cutoff_date:
                             continue  # Skip old entries
                     except ValueError:
@@ -140,9 +136,7 @@ def _collect_cache_stats(days: int = 7) -> dict[str, Any]:
         }
 
     # Calculate metrics
-    cache_hit_rate = (
-        (cache_hits / total_requests * 100) if total_requests > 0 else 0.0
-    )
+    cache_hit_rate = (cache_hits / total_requests * 100) if total_requests > 0 else 0.0
 
     return {
         "days_analyzed": days,
@@ -154,9 +148,7 @@ def _collect_cache_stats(days: int = 7) -> dict[str, Any]:
         "total_cache_read_tokens": total_cache_read_tokens,
         "total_cache_write_tokens": total_cache_write_tokens,
         "total_savings": round(total_savings, 4),
-        "avg_savings_per_hit": (
-            round(total_savings / cache_hits, 4) if cache_hits > 0 else 0.0
-        ),
+        "avg_savings_per_hit": (round(total_savings / cache_hits, 4) if cache_hits > 0 else 0.0),
     }
 
 
@@ -193,7 +185,7 @@ def _display_cache_report(stats: dict[str, Any], verbose: bool = False):
     # Cost savings
     print("💰 Cost Savings:")
     print(f"  Total Saved: ${stats['total_savings']:.4f}")
-    if stats['cache_hits'] > 0:
+    if stats["cache_hits"] > 0:
         print(f"  Avg Savings per Hit: ${stats['avg_savings_per_hit']:.4f}")
     print()
 
@@ -205,7 +197,7 @@ def _display_cache_report(stats: dict[str, Any], verbose: bool = False):
         print()
 
     # Performance assessment
-    hit_rate = stats['cache_hit_rate']
+    hit_rate = stats["cache_hit_rate"]
     print("📈 Performance Assessment:")
     if hit_rate >= 50:
         print("  ✅ EXCELLENT - Cache is working effectively")
@@ -222,7 +214,7 @@ def _display_cache_report(stats: dict[str, Any], verbose: bool = False):
     print()
 
     # Recommendations
-    if stats['total_requests'] < 10:
+    if stats["total_requests"] < 10:
         print("ℹ️  Note: Limited data available. Run more workflows for accurate stats.")
     elif hit_rate < 30:
         print("💡 Recommendations:")

attune/cli/commands/provider.py

@@ -96,3 +96,20 @@ def cmd_provider_set(args):
 
     print(f"✓ Default provider set to: {provider}")
     print(f"  Saved to: {validated_workflows_path}")
+
+
+def cmd_provider_hybrid(args):
+    """Configure hybrid mode (DEPRECATED in v5.0.0).
+
+    Hybrid mode is no longer supported. This command now configures
+    Anthropic as the sole provider.
+
+    Args:
+        args: Namespace object from argparse (no additional attributes used).
+
+    Returns:
+        None: Launches interactive Anthropic configuration.
+    """
+    from attune.models.provider_config import configure_hybrid_interactive
+
+    configure_hybrid_interactive()

attune/cli/commands/routing.py

@@ -82,7 +82,9 @@ def cmd_routing_stats(args: Any) -> int:
         )
 
         print(f"  Best model: {best_model[0]}")
-        print(f"    ({best_model[1]['success_rate']:.1%} success, ${best_model[1]['avg_cost']:.4f}/call)")
+        print(
+            f"    ({best_model[1]['success_rate']:.1%} success, ${best_model[1]['avg_cost']:.4f}/call)"
+        )
 
         # Cost savings potential
         if len(stats["models_used"]) > 1:

attune/cli/commands/setup.py

@@ -94,3 +94,125 @@ def cmd_validate(args):
         logger.exception(f"Unexpected error validating configuration: {e}")
         logger.error(f"✗ Configuration invalid: {e}")
         sys.exit(1)
+
+
+def cmd_setup(args):
+    """Interactive setup workflow.
+
+    Guides user through initial framework configuration step by step.
+    Updated for Claude-native v5.0.0 (Anthropic-only).
+
+    Args:
+        args: Namespace object from argparse (no additional attributes used).
+
+    Returns:
+        None: Creates attune.config.yml with user's choices.
+    """
+    print("🧙 Attune AI Setup Workflow")
+    print("=" * 50)
+    print("\nI'll help you set up your Attune AI configuration.\n")
+
+    # Step 1: Use case
+    print("1. What's your primary use case?")
+    print("   [1] Software development")
+    print("   [2] Healthcare applications")
+    print("   [3] Customer support")
+    print("   [4] Other")
+
+    use_case_choice = input("\nYour choice (1-4): ").strip()
+    use_case_map = {
+        "1": "software_development",
+        "2": "healthcare",
+        "3": "customer_support",
+        "4": "general",
+    }
+    use_case = use_case_map.get(use_case_choice, "general")
+
+    # Step 2: Empathy level
+    print("\n2. What empathy level do you want to target?")
+    print("   [1] Level 1 - Reactive (basic Q&A)")
+    print("   [2] Level 2 - Guided (asks clarifying questions)")
+    print("   [3] Level 3 - Proactive (offers improvements)")
+    print("   [4] Level 4 - Anticipatory (predicts problems) ⭐ Recommended")
+    print("   [5] Level 5 - Transformative (reshapes workflows)")
+
+    level_choice = input("\nYour choice (1-5) [4]: ").strip() or "4"
+    target_level = int(level_choice) if level_choice in ["1", "2", "3", "4", "5"] else 4
+
+    # Step 3: LLM provider (Anthropic-only as of v5.0.0)
+    print("\n3. LLM Provider: Anthropic Claude")
+    print("   Attune AI is Claude-native and uses Anthropic exclusively.")
+
+    from attune.models.provider_config import ProviderConfig
+
+    config_detected = ProviderConfig.auto_detect()
+    if config_detected.available_providers:
+        print("   ✓ ANTHROPIC_API_KEY detected")
+    else:
+        print("   ⚠️  ANTHROPIC_API_KEY not detected")
+        print("   Set your API key: export ANTHROPIC_API_KEY='your-key-here'")
+        print("   Get key at: https://console.anthropic.com/settings/keys")
+
+    # Step 4: User ID
+    print("\n4. What user ID should we use?")
+    user_id = input("User ID [default_user]: ").strip() or "default_user"
+
+    # Generate configuration
+    config = {
+        "user_id": user_id,
+        "target_level": target_level,
+        "confidence_threshold": 0.75,
+        "persistence_enabled": True,
+        "persistence_backend": "sqlite",
+        "persistence_path": ".attune",
+        "metrics_enabled": True,
+        "use_case": use_case,
+        "llm_provider": "anthropic",
+    }
+
+    # Save configuration
+    output_file = "attune.config.yml"
+    print(f"\n5. Creating configuration file: {output_file}")
+
+    # Write YAML config
+    yaml_content = f"""# Attune AI Configuration
+# Generated by setup workflow
+
+# Core settings
+user_id: "{config["user_id"]}"
+target_level: {config["target_level"]}
+confidence_threshold: {config["confidence_threshold"]}
+
+# Use case
+use_case: "{config["use_case"]}"
+
+# Persistence
+persistence_enabled: {str(config["persistence_enabled"]).lower()}
+persistence_backend: "{config["persistence_backend"]}"
+persistence_path: "{config["persistence_path"]}"
+
+# Metrics
+metrics_enabled: {str(config["metrics_enabled"]).lower()}
+
+# LLM Provider (Claude-native v5.0.0)
+llm_provider: "anthropic"
+"""
+
+    validated_output = _validate_file_path(output_file)
+    with open(validated_output, "w") as f:
+        f.write(yaml_content)
+
+    print(f"  ✓ Created {validated_output}")
+
+    print("\n" + "=" * 50)
+    print("✅ Setup complete!")
+    print("\nNext steps:")
+    print(f"  1. Edit {output_file} to customize settings")
+
+    if not config_detected.available_providers:
+        print("  2. Set ANTHROPIC_API_KEY environment variable")
+        print("  3. Run: attune run --config attune.config.yml")
+    else:
+        print("  2. Run: attune run --config attune.config.yml")
+
+    print("\nHappy coding! 🧠✨\n")

attune/cli/commands/tier.py

@@ -109,9 +109,7 @@ def cmd_tier_stats(args):
 
     print("  BUG TYPE DISTRIBUTION")
     print("  " + "-" * 40)
-    sorted_types = sorted(
-        stats["bug_type_distribution"].items(), key=lambda x: x[1], reverse=True
-    )
+    sorted_types = sorted(stats["bug_type_distribution"].items(), key=lambda x: x[1], reverse=True)
     for bug_type, count in sorted_types[:10]:
         percent = (count / stats["total_patterns"]) * 100
         print(f"  {bug_type:20} {count:3} ({percent:5.1f}%)")

attune/cli/commands/workflow.py

@@ -14,6 +14,11 @@ from attune.logging_config import get_logger
 from attune.workflows import get_workflow
 from attune.workflows import list_workflows as get_workflow_list
 from attune.workflows.config import WorkflowConfig, create_example_config
+from attune.workflows.migration import (
+    WORKFLOW_ALIASES,
+    resolve_workflow_migration,
+    show_migration_tip,
+)
 
 logger = get_logger(__name__)
 
@@ -127,6 +132,13 @@ def cmd_workflow(args):
             return 1
 
         try:
+            # Check for workflow migration (describe still works with old names)
+            if name in WORKFLOW_ALIASES:
+                resolved_name, migration_kwargs, _ = resolve_workflow_migration(name)
+                if resolved_name and resolved_name != name:
+                    print(f"ℹ️  '{name}' is now '{resolved_name}'")
+                    name = resolved_name
+
             workflow_cls = get_workflow(name)
             provider = getattr(args, "provider", None)
             workflow = workflow_cls(provider=provider)
@@ -165,6 +177,16 @@ def cmd_workflow(args):
             return 1
 
         try:
+            # Check for workflow migration (environment-aware)
+            original_name = name
+            migration_kwargs = {}
+            was_migrated = False
+
+            if name in WORKFLOW_ALIASES:
+                name, migration_kwargs, was_migrated = resolve_workflow_migration(name)
+                if was_migrated:
+                    logger.info(f"Migrated '{original_name}' -> '{name}' with {migration_kwargs}")
+
             workflow_cls = get_workflow(name)
 
             # Get provider from CLI arg, or fall back to config's default_provider
@@ -197,6 +219,11 @@ def cmd_workflow(args):
                 health_score_threshold = getattr(args, "health_score_threshold", 100)
                 workflow_kwargs["health_score_threshold"] = health_score_threshold
 
+            # Merge migration kwargs (from workflow consolidation)
+            for key, value in migration_kwargs.items():
+                if not key.startswith("_") and key in init_params:
+                    workflow_kwargs[key] = value
+
             workflow = workflow_cls(**workflow_kwargs)
 
             # Parse input
@@ -367,6 +394,10 @@ def cmd_workflow(args):
                     error_msg = error_msg or "Unknown error"
                     print(f"\n✗ Workflow failed: {error_msg}\n")
 
+            # Show migration tip if workflow was migrated (helps users learn new syntax)
+            if was_migrated and original_name != name:
+                show_migration_tip(original_name, name, migration_kwargs)
+
         except KeyError:
             print(f"Error: Workflow '{name}' not found")
             print("\nRun 'empathy workflow list' to see available workflows")

attune/cli/parsers/cache.py

@@ -15,6 +15,7 @@ def register_parsers(subparsers):
         None: Adds cache subparser with stats and clear subcommands
     """
     from ..commands.cache import cmd_cache_clear, cmd_cache_stats
+
     # Main cache command
     cache_parser = subparsers.add_parser(
         "cache",

attune/cli/parsers/help.py

@@ -20,9 +20,7 @@ def register_parsers(subparsers):
     # cheatsheet command
     parser_cheatsheet = subparsers.add_parser("cheatsheet", help="Quick reference guide")
     parser_cheatsheet.add_argument("--category", help="Specific category to show")
-    parser_cheatsheet.add_argument(
-        "--compact", action="store_true", help="Show commands only"
-    )
+    parser_cheatsheet.add_argument("--compact", action="store_true", help="Show commands only")
     parser_cheatsheet.set_defaults(func=help_commands.cmd_cheatsheet)
 
     # onboard command

attune/cli/parsers/provider.py

@@ -38,3 +38,10 @@ def register_parsers(subparsers):
         help="Provider name (anthropic only)",
     )
     p_set.set_defaults(func=provider.cmd_provider_set)
+
+    # Provider hybrid command (deprecated)
+    p_hybrid = provider_sub.add_parser(
+        "hybrid",
+        help="Configure hybrid mode (DEPRECATED - now Anthropic only)",
+    )
+    p_hybrid.set_defaults(func=provider.cmd_provider_hybrid)

attune/cli/parsers/routing.py

@@ -28,9 +28,7 @@ def register_parsers(subparsers):
     )
 
     # Routing subcommands
-    routing_subparsers = routing_parser.add_subparsers(
-        dest="routing_command", required=True
-    )
+    routing_subparsers = routing_parser.add_subparsers(dest="routing_command", required=True)
 
     # routing stats command
     stats_parser = routing_subparsers.add_parser(

attune/cli/parsers/setup.py

@@ -40,3 +40,10 @@ def register_parsers(subparsers):
         help="Path to configuration file to validate",
     )
     parser_validate.set_defaults(func=setup.cmd_validate)
+
+    # Setup wizard command
+    parser_setup = subparsers.add_parser(
+        "setup",
+        help="Interactive setup workflow for first-time configuration",
+    )
+    parser_setup.set_defaults(func=setup.cmd_setup)

attune/cli/parsers/status.py

@@ -36,9 +36,7 @@ def register_parsers(subparsers):
     parser_health.add_argument("--deep", action="store_true", help="Run all checks")
     parser_health.add_argument("--fix", action="store_true", help="Auto-fix issues")
     parser_health.add_argument("--dry-run", action="store_true", help="Preview fixes only")
-    parser_health.add_argument(
-        "--interactive", action="store_true", help="Interactive fix mode"
-    )
+    parser_health.add_argument("--interactive", action="store_true", help="Interactive fix mode")
     parser_health.add_argument("--project-root", default=".", help="Project root")
     parser_health.add_argument("--details", action="store_true", help="Show details")
     parser_health.add_argument("--full", action="store_true", help="Show all details")

attune/cli/parsers/tier.py

@@ -18,9 +18,7 @@ def register_parsers(subparsers):
     tier_subparsers = tier_parser.add_subparsers(dest="tier_command")
 
     # tier recommend
-    parser_recommend = tier_subparsers.add_parser(
-        "recommend", help="Get tier recommendation"
-    )
+    parser_recommend = tier_subparsers.add_parser("recommend", help="Get tier recommendation")
     parser_recommend.add_argument("description", help="Bug or task description")
     parser_recommend.add_argument("--files", help="Comma-separated list of files")
     parser_recommend.add_argument(

attune/cli_minimal.py

@@ -5,29 +5,29 @@ IMPORTANT: This CLI is for automation only (git hooks, scripts, CI/CD).
 For interactive use, use Claude Code skills in VSCode or Claude Desktop.
 
 Automation commands:
-    empathy workflow list              List available workflows
-    empathy workflow run <name>        Execute a workflow
-    empathy workflow info <name>       Show workflow details
+    attune workflow list              List available workflows
+    attune workflow run <name>        Execute a workflow
+    attune workflow info <name>       Show workflow details
 
 Monitoring commands:
-    empathy dashboard start            Start agent coordination dashboard
-                                       (opens web UI at http://localhost:8000)
+    attune dashboard start            Start agent coordination dashboard
+                                      (opens web UI at http://localhost:8000)
 
 Utility commands:
-    empathy telemetry show             Display usage summary
-    empathy telemetry savings          Show cost savings
-    empathy telemetry export           Export to CSV/JSON
-    empathy telemetry routing-stats    Show adaptive routing statistics
-    empathy telemetry routing-check    Check for tier upgrade recommendations
-    empathy telemetry models           Show model performance by provider
-    empathy telemetry agents           Show active agents and their status
-    empathy telemetry signals          Show coordination signals for an agent
+    attune telemetry show             Display usage summary
+    attune telemetry savings          Show cost savings
+    attune telemetry export           Export to CSV/JSON
+    attune telemetry routing-stats    Show adaptive routing statistics
+    attune telemetry routing-check    Check for tier upgrade recommendations
+    attune telemetry models           Show model performance by provider
+    attune telemetry agents           Show active agents and their status
+    attune telemetry signals          Show coordination signals for an agent
 
-    empathy provider show              Show current provider config
-    empathy provider set <name>        Set provider (anthropic, openai, hybrid)
+    attune provider show              Show current provider config
+    attune provider set <name>        Set provider (anthropic, openai, hybrid)
 
-    empathy validate                   Validate configuration
-    empathy version                    Show version
+    attune validate                   Validate configuration
+    attune version                    Show version
 
 For interactive development, use Claude Code skills:
     /dev        Developer tools (commit, review, debug, refactor)
@@ -58,7 +58,7 @@ def get_version() -> str:
     try:
         from importlib.metadata import version
 
-        return version("empathy-framework")
+        return version("attune-ai")
     except Exception:  # noqa: BLE001
         # INTENTIONAL: Fallback for dev installs without metadata
         return "dev"
@@ -90,7 +90,7 @@ def cmd_workflow_list(args: Namespace) -> int:
 
     print("-" * 60)
     print(f"\nTotal: {len(workflows)} workflows")
-    print("\nRun a workflow: empathy workflow run <name>")
+    print("\nRun a workflow: attune workflow run <name>")
     return 0
 
 
@@ -429,7 +429,7 @@ def cmd_telemetry_routing_stats(args: Namespace) -> int:
 
     except ImportError as e:
         print(f"❌ Adaptive routing not available: {e}")
-        print("   Ensure empathy-framework is installed with telemetry support")
+        print("   Ensure attune-ai is installed with telemetry support")
         return 1
     except Exception as e:  # noqa: BLE001
         # INTENTIONAL: CLI commands should catch all errors and report gracefully
@@ -920,7 +920,7 @@ def cmd_validate(args: Namespace) -> int:
 def cmd_version(args: Namespace) -> int:
     """Show version information."""
     version = get_version()
-    print(f"empathy-framework {version}")
+    print(f"attune-ai {version}")
 
     if args.verbose:
         print(f"\nPython: {sys.version}")
@@ -930,7 +930,7 @@ def cmd_version(args: Namespace) -> int:
         try:
             from importlib.metadata import requires
 
-            reqs = requires("empathy-framework") or []
+            reqs = requires("attune-ai") or []
             print(f"\nDependencies: {len(reqs)}")
         except Exception:  # noqa: BLE001
             pass
@@ -1073,8 +1073,12 @@ Documentation: https://smartaimemory.com/framework-docs/
 
     # dashboard start
     start_parser = dashboard_sub.add_parser("start", help="Start dashboard web server")
-    start_parser.add_argument("--host", default="127.0.0.1", help="Host to bind to (default: 127.0.0.1)")
-    start_parser.add_argument("--port", type=int, default=8000, help="Port to bind to (default: 8000)")
+    start_parser.add_argument(
+        "--host", default="127.0.0.1", help="Host to bind to (default: 127.0.0.1)"
+    )
+    start_parser.add_argument(
+        "--port", type=int, default=8000, help="Port to bind to (default: 8000)"
+    )
 
     # --- Utility commands ---
     subparsers.add_parser("validate", help="Validate configuration")
@@ -1104,7 +1108,7 @@ def main(argv: list[str] | None = None) -> int:
         elif args.workflow_command == "run":
             return cmd_workflow_run(args)
         else:
-            print("Usage: empathy workflow {list|info|run}")
+            print("Usage: attune workflow {list|info|run}")
             return 1
 
     elif args.command == "telemetry":
@@ -1125,7 +1129,9 @@ def main(argv: list[str] | None = None) -> int:
         elif args.telemetry_command == "signals":
             return cmd_telemetry_signals(args)
         else:
-            print("Usage: empathy telemetry {show|savings|export|routing-stats|routing-check|models|agents|signals}")
+            print(
+                "Usage: attune telemetry {show|savings|export|routing-stats|routing-check|models|agents|signals}"
+            )
             return 1
 
     elif args.command == "provider":
@@ -1134,14 +1140,14 @@ def main(argv: list[str] | None = None) -> int:
         elif args.provider_command == "set":
             return cmd_provider_set(args)
         else:
-            print("Usage: empathy provider {show|set}")
+            print("Usage: attune provider {show|set}")
             return 1
 
     elif args.command == "dashboard":
         if args.dashboard_command == "start":
             return cmd_dashboard_start(args)
         else:
-            print("Usage: empathy dashboard start [--host HOST] [--port PORT]")
+            print("Usage: attune dashboard start [--host HOST] [--port PORT]")
             return 1
 
     elif args.command == "validate":