crackerjack 0.37.9__py3-none-any.whl → 0.45.2__py3-none-any.whl

crackerjack/core/phase_coordinator.py

@@ -1,52 +1,80 @@
-import logging
-import time
+from __future__ import annotations
+
+import re
 import typing as t
 from pathlib import Path
 
-from rich.console import Console
+from acb.console import Console
+from acb.depends import Inject, depends
+from acb.logger import Logger
+from rich import box
+from rich.panel import Panel
+from rich.progress import (
+    BarColumn,
+    MofNCompleteColumn,
+    Progress,
+    SpinnerColumn,
+    TextColumn,
+    TimeElapsedColumn,
+)
+from rich.table import Table
 
-from crackerjack.code_cleaner import CodeCleaner, PackageCleaningResult
+from crackerjack.cli.formatting import separator as make_separator
+from crackerjack.code_cleaner import CodeCleaner
+from crackerjack.config import get_console_width
 from crackerjack.core.autofix_coordinator import AutofixCoordinator
-from crackerjack.mixins import ErrorHandlingMixin
+from crackerjack.core.session_coordinator import SessionCoordinator
+from crackerjack.decorators import handle_errors
 from crackerjack.models.protocols import (
     ConfigMergeServiceProtocol,
     FileSystemInterface,
     GitInterface,
     HookManager,
+    MemoryOptimizerProtocol,
     OptionsProtocol,
     PublishManager,
     TestManagerProtocol,
 )
-from crackerjack.services.memory_optimizer import (
-    create_lazy_service,
-    get_memory_optimizer,
+from crackerjack.models.task import HookResult
+from crackerjack.services.memory_optimizer import create_lazy_service
+from crackerjack.services.monitoring.performance_cache import (
+    FileSystemCache,
+    GitOperationCache,
 )
 from crackerjack.services.parallel_executor import (
-    get_async_executor,
-    get_parallel_executor,
+    AsyncCommandExecutor,
+    ParallelHookExecutor,
 )
-from crackerjack.services.performance_cache import get_filesystem_cache, get_git_cache
 
-from .session_coordinator import SessionCoordinator
+if t.TYPE_CHECKING:
+    pass  # All imports moved to top-level for runtime availability
 
 
-class PhaseCoordinator(ErrorHandlingMixin):
+class PhaseCoordinator:
+    @depends.inject
     def __init__(
         self,
-        console: Console,
-        pkg_path: Path,
-        session: SessionCoordinator,
-        filesystem: FileSystemInterface,
-        git_service: GitInterface,
-        hook_manager: HookManager,
-        test_manager: TestManagerProtocol,
-        publish_manager: PublishManager,
-        config_merge_service: ConfigMergeServiceProtocol,
+        console: Inject[Console],
+        logger: Inject[Logger],
+        memory_optimizer: Inject[MemoryOptimizerProtocol],
+        parallel_executor: Inject[ParallelHookExecutor],
+        async_executor: Inject[AsyncCommandExecutor],
+        git_cache: Inject[GitOperationCache],
+        filesystem_cache: Inject[FileSystemCache],
+        pkg_path: Inject[Path],
+        session: Inject[SessionCoordinator],
+        filesystem: Inject[FileSystemInterface],
+        git_service: Inject[GitInterface],
+        hook_manager: Inject[HookManager],
+        test_manager: Inject[TestManagerProtocol],
+        publish_manager: Inject[PublishManager],
+        config_merge_service: Inject[ConfigMergeServiceProtocol],
     ) -> None:
         self.console = console
         self.pkg_path = pkg_path
         self.session = session
 
+        # Dependencies injected via ACB's depends.get() from WorkflowOrchestrator
         self.filesystem = filesystem
         self.git_service = git_service
         self.hook_manager = hook_manager
@@ -65,779 +93,1135 @@ class PhaseCoordinator(ErrorHandlingMixin):
             backup_service=None,
         )
 
-        from crackerjack.services.config import ConfigurationService
+        # Ensure logger is a proper instance, not an empty tuple, string, or other invalid value
+        if isinstance(logger, tuple) and len(logger) == 0:
+            # Log this issue for debugging
+            print(
+                "WARNING: PhaseCoordinator received empty tuple for logger dependency, creating fallback"
+            )
+            # Import and create a fallback logger if we got an empty tuple
+            from acb.logger import Logger as ACBLogger
+
+            self._logger = ACBLogger()
+        elif isinstance(logger, str):
+            # Log this issue for debugging
+            print(
+                f"WARNING: PhaseCoordinator received string for logger dependency: {logger!r}, creating fallback"
+            )
+            # Import and create a fallback logger if we got a string
+            from acb.logger import Logger as ACBLogger
 
-        self.config_service = ConfigurationService(console=console, pkg_path=pkg_path)
+            self._logger = ACBLogger()
+        else:
+            self._logger = logger
 
-        self.logger = logging.getLogger("crackerjack.phases")
+        # Services injected via ACB DI
+        self._memory_optimizer = memory_optimizer
+        self._parallel_executor = parallel_executor
+        self._async_executor = async_executor
+        self._git_cache = git_cache
+        self._filesystem_cache = filesystem_cache
 
-        self._memory_optimizer = get_memory_optimizer()
-        self._parallel_executor = get_parallel_executor()
-        self._async_executor = get_async_executor()
-        self._git_cache = get_git_cache()
-        self._filesystem_cache = get_filesystem_cache()
+        self._last_hook_summary: dict[str, t.Any] | None = None
+        self._last_hook_results: list[HookResult] = []
 
         self._lazy_autofix = create_lazy_service(
-            lambda: AutofixCoordinator(console=console, pkg_path=pkg_path),
+            lambda: AutofixCoordinator(pkg_path=pkg_path),
             "autofix_coordinator",
         )
+        self.console.print()
+
+        # Track if fast hooks have already started in this session to prevent duplicates
+        self._fast_hooks_started: bool = False
 
-        super().__init__()
+    @property
+    def logger(self) -> Logger:
+        """Safely access the logger instance, ensuring it's not an empty tuple or string."""
+        if hasattr(self, "_logger") and (
+            (isinstance(self._logger, tuple) and len(self._logger) == 0)
+            or isinstance(self._logger, str)
+        ):
+            from acb.logger import Logger as ACBLogger
+
+            print(
+                f"WARNING: PhaseCoordinator logger was invalid type ({type(self._logger).__name__}: {self._logger!r}), creating fresh logger instance"
+            )
+            self._logger = ACBLogger()
+        return self._logger
+
+    @logger.setter
+    def logger(self, value: Logger) -> None:
+        """Set the logger instance."""
+        self._logger = value
+
+    # --- Output/formatting helpers -------------------------------------------------
+    @staticmethod
+    def _strip_ansi(text: str) -> str:
+        """Remove ANSI escape sequences (SGR and cursor controls).
+
+        This is more comprehensive than stripping only color codes ending with 'm'.
+        """
+        ansi_re = re.compile(r"\x1b(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])")
+        return ansi_re.sub("", text)
+
+    def _is_plain_output(self) -> bool:
+        """Detect if we should avoid rich formatting entirely.
+
+        Leverages ACB Console's plain-mode flag when available and falls back
+        to Rich Console properties when not.
+        """
+        try:
+            if bool(getattr(self.console, "_plain_mode", False)):
+                return True
+            # Fallback on Rich Console capabilities
+            is_tty = bool(getattr(self.console, "is_terminal", True))
+            color_system = getattr(self.console, "color_system", None)
+            return (not is_tty) or (color_system in (None, "null"))
+        except Exception:
+            # Prefer plain in ambiguous environments
+            return True
 
+    @handle_errors
     def run_cleaning_phase(self, options: OptionsProtocol) -> bool:
         if not options.clean:
             return True
 
         self.session.track_task("cleaning", "Code cleaning")
-        try:
-            self._display_cleaning_header()
-            return self._execute_cleaning_process()
-        except Exception as e:
-            self.handle_subprocess_error(e, [], "Code cleaning", critical=False)
-            self.session.fail_task("cleaning", str(e))
-            return False
+        self._display_cleaning_header()
+        return self._execute_cleaning_process()
 
-    def _display_cleaning_header(self) -> None:
-        self.console.print("\n" + "-" * 40)
+    @handle_errors
+    def run_configuration_phase(self, options: OptionsProtocol) -> bool:
+        if options.no_config_updates:
+            return True
+        self.session.track_task("configuration", "Configuration updates")
         self.console.print(
-            "[bold bright_magenta]🛠️ SETUP[/bold bright_magenta] [bold bright_white]Initializing project structure[/bold bright_white]",
+            "[dim]⚙️ Configuration phase skipped (no automated updates defined).[/dim]"
         )
-        self.console.print("-" * 40 + "\n")
-        self.console.print("[yellow]🧹[/yellow] Starting code cleaning...")
-
-    def _display_version_bump_header(self, version_type: str) -> None:
-        self.console.print("\n" + "-" * 74)
-        self.console.print(
-            f"[bold bright_magenta]📦 BUMP VERSION[/bold bright_magenta] [bold bright_white]Updating package version ({version_type})[/bold bright_white]",
+        self.session.complete_task(
+            "configuration", "No configuration updates were required."
         )
-        self.console.print("-" * 74 + "\n")
+        return True
 
-    def _display_publish_header(self) -> None:
-        self.console.print("\n" + "-" * 74)
-        self.console.print(
-            "[bold bright_yellow]🚀 PUBLISH[/bold bright_yellow] [bold bright_white]Publishing to PyPI[/bold bright_white]",
-        )
-        self.console.print("-" * 74 + "\n")
+    @handle_errors
+    def run_hooks_phase(self, options: OptionsProtocol) -> bool:
+        if options.skip_hooks:
+            return True
 
-    def _display_git_staging_header(self) -> None:
-        self.console.print("\n" + "-" * 74)
-        self.console.print(
-            "[bold bright_cyan]🏷️ GIT OPERATIONS[/bold bright_cyan] [bold bright_white]Staging files and creating tags[/bold bright_white]",
-        )
-        self.console.print("-" * 74 + "\n")
+        if not self.run_fast_hooks_only(options):
+            return False
 
-    def _display_commit_push_header(self) -> None:
-        self.console.print("\n" + "-" * 74)
-        self.console.print(
-            "[bold bright_green]📤 COMMIT & PUSH[/bold bright_green] [bold bright_white]Committing and pushing changes[/bold bright_white]",
-        )
-        self.console.print("-" * 74 + "\n")
+        return self.run_comprehensive_hooks_only(options)
 
-    def _execute_cleaning_process(self) -> bool:
-        cleaning_result = self.code_cleaner.clean_files(self.pkg_path, use_backup=True)
+    def run_fast_hooks_only(self, options: OptionsProtocol) -> bool:
+        if options.skip_hooks:
+            self.console.print("[yellow]⚠️[/yellow] Skipping fast hooks (--skip-hooks)")
+            return True
 
-        if isinstance(cleaning_result, list):
-            cleaned_files = [str(r.file_path) for r in cleaning_result if r.success]
-            self._report_cleaning_results(cleaned_files)
-            return all(r.success for r in cleaning_result) if cleaning_result else True
-        else:
-            self._report_package_cleaning_results(cleaning_result)
-            return cleaning_result.overall_success
+        # Prevent multiple fast-hook runs in a single workflow session unless
+        # explicitly reset by post-cleaning sanity check.
+        if getattr(self, "_fast_hooks_started", False):
+            self.logger.debug("Duplicate fast hooks invocation detected; skipping")
+            return True
 
-    def _handle_no_files_to_clean(self) -> bool:
-        self.console.print("[yellow]⚠️[/ yellow] No Python files found to clean")
-        self.session.complete_task("cleaning", "No files to clean")
-        return True
+        # Mark fast hooks as started immediately to prevent duplicate calls in case of failures
+        self._fast_hooks_started = True
+        self.session.track_task("hooks_fast", "Fast quality checks")
 
-    def _report_cleaning_results(self, cleaned_files: list[str]) -> None:
-        if cleaned_files:
-            self.console.print(f"[green]✅[/ green] Cleaned {len(cleaned_files)} files")
-            self.session.complete_task(
-                "cleaning",
-                f"Cleaned {len(cleaned_files)} files",
-            )
-        else:
-            self.console.print("[green]✅[/ green] No cleaning needed")
-            self.session.complete_task("cleaning", "No cleaning needed")
+        # Fast hooks get 2 attempts (auto-fix on failure), comprehensive hooks run once
+        max_attempts = 2
+        attempt = 0
 
-    def _report_package_cleaning_results(self, result: PackageCleaningResult) -> None:
-        if result.overall_success:
-            self.console.print(
-                f"[green]✅[/ green] Package cleaning completed successfully! "
-                f"({result.successful_files}/{result.total_files} files cleaned)"
-            )
-            self.session.complete_task(
-                "cleaning",
-                f"Cleaned {result.successful_files}/{result.total_files} files with backup protection",
-            )
-        else:
-            self.console.print(
-                f"[red]❌[/ red] Package cleaning failed! "
-                f"({result.failed_files}/{result.total_files} files failed)"
-            )
-
-            if result.backup_restored:
-                self.console.print(
-                    "[yellow]⚠️[/ yellow] Files were automatically restored from backup"
-                )
-                self.session.complete_task(
-                    "cleaning", "Failed with automatic backup restoration"
-                )
-            else:
-                self.session.fail_task(
-                    "cleaning", f"Failed to clean {result.failed_files} files"
-                )
+        while attempt < max_attempts:
+            attempt += 1
 
-            if result.backup_metadata:
+            # Display stage header for each attempt
+            if attempt > 1:
                 self.console.print(
-                    f"[blue]📦[/ blue] Backup available at: {result.backup_metadata.backup_directory}"
+                    f"\n[yellow]♻️[/yellow]  Verification Retry {attempt}/{max_attempts}\n"
                 )
 
-    def run_configuration_phase(self, options: OptionsProtocol) -> bool:
-        if options.no_config_updates:
-            return True
-        self.session.track_task("configuration", "Configuration updates")
-        try:
-            success = self._execute_configuration_steps(options)
-            self._complete_configuration_task(success)
-            return success
-        except Exception as e:
-            self.handle_subprocess_error(e, [], "Configuration phase", critical=False)
-            self.session.fail_task("configuration", str(e))
-            return False
-
-    def _execute_configuration_steps(self, options: OptionsProtocol) -> bool:
-        success = True
+            self._display_hook_phase_header(
+                "FAST HOOKS",
+                "Formatters, import sorting, and quick static analysis",
+            )
 
-        success &= self._update_configuration_files(options)
+            # Run hooks (now configured to run in fix mode by default)
+            success = self._execute_hooks_once(
+                "fast", self.hook_manager.run_fast_hooks, options, attempt
+            )
 
-        return success
+            if success:
+                break
 
-    def _update_configuration_files(self, options: OptionsProtocol) -> bool:
-        success = True
-        if not self.config_service.update_precommit_config(options):
-            success = False
-        if not self.config_service.update_pyproject_config(options):
-            success = False
-        return success
+            # Fast iteration mode intentionally avoids retries
+            if getattr(options, "fast_iteration", False):
+                break
 
-    def _complete_configuration_task(self, success: bool) -> None:
-        message = (
-            "Configuration updated successfully"
-            if success
-            else "Some configuration updates failed"
-        )
-        self.session.complete_task("configuration", message)
+            # If we have more attempts, continue to retry to verify fixes worked
+            if attempt < max_attempts:
+                self._display_hook_failures("fast", self._last_hook_results, options)
 
-    def _is_crackerjack_project(self) -> bool:
-        pyproject_path = self.pkg_path / "pyproject.toml"
-        if not pyproject_path.exists():
-            return False
+        summary = self._last_hook_summary or {}
+        details = self._format_hook_summary(summary)
 
-        try:
-            import tomllib
+        if success:
+            self.session.complete_task("hooks_fast", details=details)
+        else:
+            self.session.fail_task("hooks_fast", "Fast hook failures detected")
 
-            with pyproject_path.open("rb") as f:
-                data = tomllib.load(f)
+        # Ensure fast hooks output is fully rendered before comprehensive hooks start
+        self.console.print()
 
-            project_name: str = data.get("project", {}).get("name", "")
-            return project_name == "crackerjack"
-        except Exception:
-            return False
+        return success
 
-    def run_hooks_phase(self, options: OptionsProtocol) -> bool:
+    def run_comprehensive_hooks_only(self, options: OptionsProtocol) -> bool:
         if options.skip_hooks:
+            self.console.print(
+                "[yellow]⚠️[/yellow] Skipping comprehensive hooks (--skip-hooks)"
+            )
             return True
 
-        temp_config = self.config_service.get_temp_config_path()
-        if temp_config:
-            self.hook_manager.set_config_path(temp_config)
-
-        if not self.run_fast_hooks_only(options):
-            return False
+        self.session.track_task("hooks_comprehensive", "Comprehensive quality checks")
+        self._display_hook_phase_header(
+            "COMPREHENSIVE HOOKS",
+            "Type, security, and complexity checking",
+        )
 
-        return self.run_comprehensive_hooks_only(options)
+        # Comprehensive hooks run once (no retry)
+        success = self._execute_hooks_once(
+            "comprehensive",
+            self.hook_manager.run_comprehensive_hooks,
+            options,
+            attempt=1,
+        )
 
-    def run_fast_hooks_only(self, options: OptionsProtocol) -> bool:
-        if options.skip_hooks:
-            return True
+        if not success:
+            self._display_hook_failures(
+                "comprehensive", self._last_hook_results, options
+            )
 
-        hook_results = self.hook_manager.run_fast_hooks()
-        return all(r.status == "passed" for r in hook_results)
+        summary = self._last_hook_summary or {}
+        details = self._format_hook_summary(summary)
 
-    def run_comprehensive_hooks_only(self, options: OptionsProtocol) -> bool:
-        if options.skip_hooks:
-            return True
+        if success:
+            self.session.complete_task("hooks_comprehensive", details=details)
+        else:
+            self.session.fail_task(
+                "hooks_comprehensive", "Comprehensive hook failures detected"
+            )
 
-        hook_results = self.hook_manager.run_comprehensive_hooks()
-        return all(r.status == "passed" for r in hook_results)
+        return success
 
+    @handle_errors
     def run_testing_phase(self, options: OptionsProtocol) -> bool:
         if not options.test:
             return True
         self.session.track_task("testing", "Test execution")
-        try:
-            self.console.print("\n" + "-" * 74)
-            self.console.print(
-                "[bold bright_blue]🧪 TESTS[/ bold bright_blue] [bold bright_white]Running test suite[/ bold bright_white]",
+        self.console.print("\n" + make_separator("-"))
+        self.console.print(
+            "[bold bright_blue]🧪 TESTS[/bold bright_blue] [bold bright_white]Running test suite[/bold bright_white]",
+        )
+        self.console.print(make_separator("-") + "\n")
+        if not self.test_manager.validate_test_environment():
+            self.session.fail_task("testing", "Test environment validation failed")
+            return False
+        test_success = self.test_manager.run_tests(options)
+        if test_success:
+            coverage_info = self.test_manager.get_coverage()
+            self.session.complete_task(
+                "testing",
+                f"Tests passed, coverage: {coverage_info.get('total_coverage', 0):.1f}%",
             )
-            self.console.print("-" * 74 + "\n")
-            if not self.test_manager.validate_test_environment():
-                self.session.fail_task("testing", "Test environment validation failed")
-                return False
-            test_success = self.test_manager.run_tests(options)
-            if test_success:
-                coverage_info = self.test_manager.get_coverage()
-                self.session.complete_task(
-                    "testing",
-                    f"Tests passed, coverage: {coverage_info.get('total_coverage', 0): .1f}%",
-                )
-            else:
-                self.session.fail_task("testing", "Tests failed")
+        else:
+            self.session.fail_task("testing", "Tests failed")
 
-            return test_success
-        except Exception as e:
-            self.console.print(f"Testing error: {e}")
-            self.session.fail_task("testing", str(e))
-            return False
+        return test_success
 
+    @handle_errors
     def run_publishing_phase(self, options: OptionsProtocol) -> bool:
         version_type = self._determine_version_type(options)
         if not version_type:
             return True
 
         self.session.track_task("publishing", f"Publishing ({version_type})")
-        try:
-            return self._execute_publishing_workflow(options, version_type)
-        except Exception as e:
-            self.console.print(f"[red]❌[/ red] Publishing failed: {e}")
-            self.session.fail_task("publishing", str(e))
-            return False
+        return self._execute_publishing_workflow(options, version_type)
 
-    def _determine_version_type(self, options: OptionsProtocol) -> str | None:
-        if options.publish:
-            publish_value: str | None = (
-                options.publish if isinstance(options.publish, str) else None
-            )
-            return publish_value
-        if options.all:
-            all_value: str | None = (
-                options.all if isinstance(options.all, str) else None
-            )
-            return all_value
-        if options.bump:
-            self._handle_version_bump_only(options.bump)
-            return None
-        return None
-
-    def _execute_publishing_workflow(
-        self,
-        options: OptionsProtocol,
-        version_type: str,
-    ) -> bool:
-        # Display version bump header
-        self._display_version_bump_header(version_type)
-        new_version = self.publish_manager.bump_version(version_type)
+    @handle_errors
+    def run_commit_phase(self, options: OptionsProtocol) -> bool:
+        if not options.commit:
+            return True
 
-        # Display git operations header for staging and tagging
-        self._display_git_staging_header()
-        self.console.print("[blue]📂[/ blue] Staging all changes for publishing...")
-        if not self.git_service.add_all_files():
+        # Skip if publishing phase already handled commits
+        # (Publishing phase handles both pre-publish and version-bump commits when -c is used)
+        version_type = self._determine_version_type(options)
+        if version_type:
+            # Publishing workflow already committed everything
             self.console.print(
-                "[yellow]⚠️[/ yellow] Failed to stage files, continuing with publish..."
+                "[dim]ℹ️ Commit phase skipped (handled by publish workflow)[/dim]"
             )
-
-        if not options.no_git_tags:
-            self.publish_manager.create_git_tag(new_version)
-
-        # Display publish header
-        self._display_publish_header()
-        if self.publish_manager.publish_package():
-            self._handle_successful_publish(options, new_version)
             return True
-        self.session.fail_task("publishing", "Package publishing failed")
-        return False
 
-    def _handle_successful_publish(
+        # Display commit & push header
+        self._display_commit_push_header()
+        self.session.track_task("commit", "Git commit and push")
+        changed_files = self.git_service.get_changed_files()
+        if not changed_files:
+            return self._handle_no_changes_to_commit()
+        commit_message = self._get_commit_message(changed_files, options)
+        return self._execute_commit_and_push(changed_files, commit_message)
+
+    def _execute_hooks_once(
         self,
+        suite_name: str,
+        hook_runner: t.Callable[[], list[HookResult]],
         options: OptionsProtocol,
-        new_version: str,
-    ) -> None:
-        self.console.print(f"[green]🚀[/ green] Successfully published {new_version}!")
-
-        if options.cleanup_pypi:
-            self.publish_manager.cleanup_old_releases(options.keep_releases)
+        attempt: int,
+    ) -> bool:
+        """Execute a hook suite once with progress bar (no retry logic - retry is handled at stage level)."""
+        self._last_hook_summary = None
+        self._last_hook_results = []
 
-        self.session.complete_task("publishing", f"Published {new_version}")
+        hook_count = self.hook_manager.get_hook_count(suite_name)
+        progress = self._create_progress_bar()
 
-    def run_commit_phase(self, options: OptionsProtocol) -> bool:
-        if not options.commit:
-            return True
+        callbacks = self._setup_progress_callbacks(progress)
+        elapsed_time = self._run_hooks_with_progress(
+            suite_name, hook_runner, progress, hook_count, attempt, callbacks
+        )
 
-        # Display commit & push header
-        self._display_commit_push_header()
-        self.session.track_task("commit", "Git commit and push")
-        try:
-            changed_files = self.git_service.get_changed_files()
-            if not changed_files:
-                return self._handle_no_changes_to_commit()
-            commit_message = self._get_commit_message(changed_files, options)
-            return self._execute_commit_and_push(changed_files, commit_message)
-        except Exception as e:
-            self.console.print(f"[red]❌[/ red] Commit failed: {e}")
-            self.session.fail_task("commit", str(e))
+        if elapsed_time is None:
             return False
 
-    def _handle_no_changes_to_commit(self) -> bool:
-        self.console.print("[yellow]ℹ️[/ yellow] No changes to commit")
-
-        from contextlib import suppress
+        return self._process_hook_results(suite_name, elapsed_time, attempt)
+
+    def _create_progress_bar(self) -> Progress:
+        """Create compact progress bar for hook execution."""
+        return Progress(
+            SpinnerColumn(spinner_name="dots"),
+            TextColumn("[cyan]{task.description}[/cyan]"),
+            BarColumn(bar_width=20),
+            MofNCompleteColumn(),
+            TimeElapsedColumn(),
+            console=self.console,
+            transient=True,
+        )
 
-        with suppress(ValueError, Exception):
-            commit_count = self.git_service.get_unpushed_commit_count()
-            if commit_count > 0:
-                self.console.print(
-                    f"[blue]📤[/ blue] Found {commit_count} unpushed commit(s), attempting push..."
-                )
-                if self.git_service.push():
-                    self.session.complete_task(
-                        "commit",
-                        f"No new changes, pushed {commit_count} existing commit(s)",
-                    )
-                    return True
-                else:
-                    self.console.print(
-                        "[yellow]⚠️[/ yellow] Push failed for existing commits"
-                    )
+    def _setup_progress_callbacks(
+        self, progress: Progress
+    ) -> dict[str, t.Callable[[int, int], None] | None | dict[str, t.Any]]:
+        """Setup progress callbacks and store originals for restoration."""
+        task_id_holder = {"task_id": None}
 
-        self.session.complete_task("commit", "No changes to commit")
-        return True
+        def update_progress(completed: int, total: int) -> None:
+            if task_id_holder["task_id"] is not None:
+                progress.update(task_id_holder["task_id"], completed=completed)
 
-    def _execute_commit_and_push(
-        self,
-        changed_files: list[str],
-        commit_message: str,
-    ) -> bool:
-        if not self.git_service.add_files(changed_files):
-            self.session.fail_task("commit", "Failed to stage files")
-            return False
+        def update_progress_started(started: int, total: int) -> None:
+            if task_id_holder["task_id"] is not None:
+                progress.update(task_id_holder["task_id"], completed=started)
 
-        if not self.git_service.commit(commit_message):
-            self.session.fail_task("commit", "Commit failed")
-            return False
+        original_callback = getattr(self.hook_manager, "_progress_callback", None)
+        original_start_callback = getattr(
+            self.hook_manager, "_progress_start_callback", None
+        )
 
-        return self._handle_push_result(commit_message)
+        self.hook_manager._progress_callback = update_progress
+        self.hook_manager._progress_start_callback = update_progress_started
 
-    def _handle_push_result(self, commit_message: str) -> bool:
-        if self.git_service.push():
-            self.console.print(
-                f"[green]🎉[/ green] Committed and pushed: {commit_message}",
-            )
-            self.session.complete_task(
-                "commit",
-                f"Committed and pushed: {commit_message}",
-            )
-        else:
-            self.console.print(
-                f"[yellow]⚠️[/ yellow] Committed but push failed: {commit_message}",
-            )
-            self.session.complete_task(
-                "commit",
-                f"Committed (push failed): {commit_message}",
-            )
-        return True
+        return {
+            "update": update_progress,
+            "update_started": update_progress_started,
+            "original": original_callback,
+            "original_started": original_start_callback,
+            "task_id_holder": task_id_holder,
+        }
 
-    def execute_hooks_with_retry(
+    def _run_hooks_with_progress(
         self,
-        hook_type: str,
-        hook_runner: t.Callable[[], list[t.Any]],
-        options: OptionsProtocol,
-    ) -> bool:
-        return self._execute_hooks_with_retry(hook_type, hook_runner, options)
-
-    def _handle_version_bump_only(self, bump_type: str) -> bool:
-        self.session.track_task("version_bump", f"Version bump ({bump_type})")
+        suite_name: str,
+        hook_runner: t.Callable[[], list[HookResult]],
+        progress: Progress,
+        hook_count: int,
+        attempt: int,
+        callbacks: dict[str, t.Any],
+    ) -> float | None:
+        """Run hooks with progress tracking, return elapsed time or None on error."""
         try:
-            # Display version bump header
-            self._display_version_bump_header(bump_type)
-            new_version = self.publish_manager.bump_version(bump_type)
-            self.console.print(f"[green]🎯[/ green] Version bumped to {new_version}")
-            self.session.complete_task("version_bump", f"Bumped to {new_version}")
-            return True
-        except Exception as e:
-            self.console.print(f"[red]❌[/ red] Version bump failed: {e}")
-            self.session.fail_task("version_bump", str(e))
-            return False
-
-    def _get_commit_message(
-        self,
-        changed_files: list[str],
-        options: OptionsProtocol,
-    ) -> str:
-        # Smart commit is now enabled by default for all commit operations
-        # Use basic commit messages only if explicitly disabled
-        use_smart_commit = getattr(options, "smart_commit", True)
-        disable_smart_commit = getattr(options, "basic_commit", False)
-
-        if use_smart_commit and not disable_smart_commit:
-            try:
-                from crackerjack.services.intelligent_commit import (
-                    CommitMessageGenerator,
+            with progress:
+                task_id = progress.add_task(
+                    f"Running {suite_name} hooks:",
+                    total=hook_count,
                 )
+                callbacks["task_id_holder"]["task_id"] = task_id
 
-                self.console.print(
-                    "[cyan]🤖[/cyan] Generating intelligent commit message..."
-                )
-                commit_generator = CommitMessageGenerator(
-                    console=self.console, git_service=self.git_service
-                )
+                import time
 
-                intelligent_message = commit_generator.generate_commit_message(
-                    include_body=False,
-                    conventional_commits=True,
-                )
+                start_time = time.time()
+                hook_results = hook_runner()
+                self._last_hook_results = hook_results
+                elapsed_time = time.time() - start_time
 
-                if not options.interactive:
-                    self.console.print(
-                        f"[green]✨[/green] Generated: {intelligent_message}"
-                    )
-                    return intelligent_message
+                return elapsed_time
 
-                # In interactive mode, offer the intelligent message plus fallback suggestions
-                suggestions = [intelligent_message]
-                fallback_suggestions = self.git_service.get_commit_message_suggestions(
-                    changed_files
-                )
-                suggestions.extend(
-                    fallback_suggestions[:3]
-                )  # Add up to 3 fallback options
+        except Exception as exc:
+            self._handle_hook_execution_error(suite_name, exc, attempt)
+            return None
+        finally:
+            self._restore_progress_callbacks(callbacks)
 
-                return self._interactive_commit_message_selection(suggestions)
+    def _handle_hook_execution_error(
+        self, suite_name: str, exc: Exception, attempt: int
+    ) -> None:
+        """Handle errors during hook execution."""
+        self.console.print(
+            f"[red]❌[/red] {suite_name.title()} hooks encountered an unexpected error: {exc}"
+        )
+        self.logger.exception(
+            "Hook execution raised exception",
+            extra={"suite": suite_name, "attempt": attempt},
+        )
 
-            except Exception as e:
-                self.console.print(
-                    f"[yellow]⚠️[/yellow] Intelligent commit generation failed: {e}"
-                )
-                # Fallback to original logic
+    def _restore_progress_callbacks(self, callbacks: dict[str, t.Any]) -> None:
+        """Restore original progress callbacks."""
+        self.hook_manager._progress_callback = callbacks["original"]
+        self.hook_manager._progress_start_callback = callbacks["original_started"]
 
-        # Original logic for non-smart commits
-        suggestions = self.git_service.get_commit_message_suggestions(changed_files)
+    def _process_hook_results(
+        self, suite_name: str, elapsed_time: float, attempt: int
+    ) -> bool:
+        """Process hook results and determine success."""
+        summary = self.hook_manager.get_hook_summary(
+            self._last_hook_results, elapsed_time=elapsed_time
+        )
+        self._last_hook_summary = summary
+        self._report_hook_results(suite_name, self._last_hook_results, summary, attempt)
 
-        if not suggestions:
-            return "Update project files"
+        if summary.get("failed", 0) == 0 == summary.get("errors", 0):
+            return True
 
-        if not options.interactive:
-            return suggestions[0]
+        self.logger.warning(
+            "Hook suite reported failures",
+            extra={
+                "suite": suite_name,
+                "attempt": attempt,
+                "failed": summary.get("failed", 0),
+                "errors": summary.get("errors", 0),
+            },
+        )
+        return False
 
-        return self._interactive_commit_message_selection(suggestions)
+    def _display_hook_phase_header(self, title: str, description: str) -> None:
+        sep = make_separator("-")
+        self.console.print("\n" + sep)
+        # Combine title and description into a single line with leading icon
+        pretty_title = title.title()
+        message = (
+            f"[bold bright_cyan]🔍 {pretty_title}[/bold bright_cyan][bold bright_white]"
+            f" - {description}[/bold bright_white]"
+        )
+        self.console.print(message)
+        self.console.print(sep + "\n")
 
-    def _interactive_commit_message_selection(self, suggestions: list[str]) -> str:
-        self._display_commit_suggestions(suggestions)
+    def _report_hook_results(
+        self,
+        suite_name: str,
+        results: list[HookResult],
+        summary: dict[str, t.Any],
+        attempt: int,
+    ) -> None:
+        total = summary.get("total", 0)
+        passed = summary.get("passed", 0)
+        failed = summary.get("failed", 0)
+        errors = summary.get("errors", 0)
+        duration = summary.get("total_duration", 0.0)
 
-        try:
-            choice = self.console.input(
-                f"\nSelect message (1-{len(suggestions)}) or enter custom: ",
+        if total == 0:
+            self.console.print(
+                f"[yellow]⚠️[/yellow] No {suite_name} hooks are configured for this project."
             )
-            return self._process_commit_choice(choice, suggestions)
-        except (KeyboardInterrupt, EOFError):
-            return suggestions[0]
+            return
 
-    def _display_commit_suggestions(self, suggestions: list[str]) -> None:
-        self.console.print("[cyan]📝[/ cyan] Commit message suggestions: ")
-        for i, suggestion in enumerate(suggestions, 1):
-            self.console.print(f" {i}. {suggestion}")
+        base_message = (
+            f"{suite_name.title()} hooks attempt {attempt}: "
+            f"{passed}/{total} passed in {duration:.2f}s"
+        )
 
-    def _process_commit_choice(self, choice: str, suggestions: list[str]) -> str:
-        if choice.isdigit() and 1 <= int(choice) <= len(suggestions):
-            return suggestions[int(choice) - 1]
-        return choice or suggestions[0]
+        if failed or errors:
+            self.console.print(f"\n[red]❌[/red] {base_message}\n")
+            # Always show a results table to aid debugging when there are failures
+            self._render_hook_results_table(suite_name, results)
+        else:
+            self.console.print(f"\n[green]✅[/green] {base_message}\n")
+            self._render_hook_results_table(suite_name, results)
 
-    def _execute_hooks_with_retry(
+    def _render_hook_results_table(
         self,
-        hook_type: str,
-        hook_runner: t.Callable[[], list[t.Any]],
-        options: OptionsProtocol,
-    ) -> bool:
-        self._initialize_hook_execution(hook_type)
-        max_retries = self._get_max_retries(hook_type)
-
-        for attempt in range(max_retries):
-            try:
-                execution_result = self._execute_single_hook_attempt(hook_runner)
-                if execution_result is None:
-                    return False
-
-                results, summary = execution_result
-                should_continue = self._process_hook_results(
-                    hook_type, options, summary, results, attempt, max_retries
-                )
+        suite_name: str,
+        results: list[HookResult],
+    ) -> None:
+        if not results:
+            return
 
-                if should_continue == "continue":
-                    continue
-                elif should_continue == "success":
-                    return True
-                else:
-                    return False
+        if self._is_plain_output():
+            self._render_plain_hook_results(suite_name, results)
+        else:
+            self._render_rich_hook_results(suite_name, results)
 
-            except Exception as e:
-                return self._handle_hook_exception(hook_type, e)
+    def _render_plain_hook_results(
+        self, suite_name: str, results: list[HookResult]
+    ) -> None:
+        """Render hook results in plain text format."""
+        self.console.print(f"{suite_name.title()} Hook Results:", highlight=False)
+
+        stats = self._calculate_hook_statistics(results)
+        hooks_to_show = stats["failed_hooks"] or results
+
+        for result in hooks_to_show:
+            self._print_plain_hook_result(result)
+
+        if not stats["failed_hooks"] and results:
+            self._print_plain_summary(stats)
+
+        self.console.print()
+
+    def _calculate_hook_statistics(self, results: list[HookResult]) -> dict[str, t.Any]:
+        """Calculate statistics from hook results."""
+        passed_hooks = [r for r in results if r.status.lower() in {"passed", "success"}]
+        failed_hooks = [
+            r for r in results if r.status.lower() in {"failed", "error", "timeout"}
+        ]
+        other_hooks = [
+            r
+            for r in results
+            if r.status.lower()
+            not in {"passed", "success", "failed", "error", "timeout"}
+        ]
+
+        # Calculate total issues using issues_count (which may be larger than len(issues_found))
+        # Passed hooks always contribute 0 issues
+        # Config errors (is_config_error=True) are counted separately
+        total_issues = 0
+        config_errors = 0
+        for r in results:
+            if r.status == "passed":
+                continue
+            # Count config errors separately - they're not code quality issues
+            if hasattr(r, "is_config_error") and r.is_config_error:
+                config_errors += 1
+                continue
+            # Use issues_count directly (don't fall back to len(issues_found))
+            # because issues_found may contain error detail lines, not actual issues
+            if hasattr(r, "issues_count"):
+                total_issues += r.issues_count
+            elif r.issues_found:
+                # Legacy fallback for old HookResults without issues_count
+                total_issues += len(r.issues_found)
+
+        return {
+            "total_hooks": len(results),
+            "passed_hooks": passed_hooks,
+            "failed_hooks": failed_hooks,
+            "other_hooks": other_hooks,
+            "total_passed": len(passed_hooks),
+            "total_failed": len(failed_hooks),
+            "total_other": len(other_hooks),
+            "total_issues_found": total_issues,
+            "config_errors": config_errors,
+        }
+
+    def _print_plain_hook_result(self, result: HookResult) -> None:
+        """Print a single hook result in plain format."""
+        name = self._strip_ansi(result.name)
+        status = result.status.upper()
+        duration = f"{result.duration:.2f}s"
+
+        # Determine issues display (matches Rich table logic)
+        if result.status == "passed":
+            issues = "0"
+        elif hasattr(result, "is_config_error") and result.is_config_error:
+            # Config/tool error - show simple symbol instead of misleading count
+            issues = "[yellow]![/yellow]"
+        else:
+            # For failed hooks with code violations, use issues_count
+            # Don't fall back to len(issues_found) - it may contain error detail lines
+            issues = str(result.issues_count if hasattr(result, "issues_count") else 0)
 
-        return False
+        self.console.print(
+            f"  - {name} :: {status} | {duration} | issues={issues}",
+        )
 
-    def _execute_single_hook_attempt(
-        self, hook_runner: t.Callable[[], list[t.Any]]
-    ) -> tuple[list[t.Any], dict[str, t.Any]] | None:
-        try:
-            results = hook_runner()
-            summary = self.hook_manager.get_hook_summary(results)
-            return results, summary
-        except Exception:
-            return None
+    def _print_plain_summary(self, stats: dict[str, t.Any]) -> None:
+        """Print summary statistics in plain format."""
+        issues_text = f"{stats['total_issues_found']} issues found"
+        if stats.get("config_errors", 0) > 0:
+            issues_text += f" ({stats['config_errors']} config)"
 
-    def _process_hook_results(
-        self,
-        hook_type: str,
-        options: OptionsProtocol,
-        summary: dict[str, t.Any],
-        results: list[t.Any],
-        attempt: int,
-        max_retries: int,
-    ) -> str:
-        if not self._has_hook_failures(summary):
-            self._handle_hook_success(hook_type, summary)
-            return "success"
+        self.console.print(
+            f"  Summary: {stats['total_passed']}/{stats['total_hooks']} hooks passed, {issues_text}",
+            highlight=False,
+        )
 
-        if self._should_retry_hooks(hook_type, attempt, max_retries, results):
-            return "continue"
+    def _render_rich_hook_results(
+        self, suite_name: str, results: list[HookResult]
+    ) -> None:
+        """Render hook results in Rich format."""
+        stats = self._calculate_hook_statistics(results)
+        summary_text = self._build_summary_text(stats)
+        table = self._build_results_table(results)
+        panel = self._build_results_panel(suite_name, table, summary_text)
 
-        self._handle_hook_failures(
-            hook_type, options, summary, results, attempt, max_retries
-        )
-        return "failure"
+        self.console.print(panel)
 
-    def _initialize_hook_execution(self, hook_type: str) -> None:
-        self.logger.info(f"Starting {hook_type} hooks execution")
-        self.session.track_task(
-            f"{hook_type}_hooks",
-            f"{hook_type.title()} hooks execution",
+        # Add legend if any config errors are present
+        has_config_errors = any(
+            hasattr(r, "is_config_error") and r.is_config_error for r in results
         )
+        if has_config_errors:
+            self.console.print(
+                "  [dim][yellow]![/yellow] = Configuration or tool error (not code "
+                "issues)[/dim]"
+            )
 
-    def _get_max_retries(self, hook_type: str) -> int:
-        return 2 if hook_type == "fast" else 1
+        self.console.print()
 
-    def _has_hook_failures(self, summary: dict[str, t.Any]) -> bool:
-        return summary["failed"] > 0 or summary["errors"] > 0
+    @staticmethod
+    def _build_summary_text(stats: dict[str, t.Any]) -> str:
+        """Build summary text for Rich display."""
+        summary_text = (
+            f"Total: [white]{stats['total_hooks']}[/white] | Passed:"
+            f" [green]{stats['total_passed']}[/green] | Failed: [red]{stats['total_failed']}[/red]"
+        )
+        if stats["total_other"] > 0:
+            summary_text += f" | Other: [yellow]{stats['total_other']}[/yellow]"
+
+        # Show issues found with config count in parentheses if present
+        issues_text = f"[white]{stats['total_issues_found']}[/white]"
+        if stats.get("config_errors", 0) > 0:
+            issues_text += f" [dim]({stats['config_errors']} config)[/dim]"
+        summary_text += f" | Issues found: {issues_text}"
+        return summary_text
+
+    def _build_results_table(self, results: list[HookResult]) -> Table:
+        """Build Rich table from hook results."""
+        table = Table(
+            box=box.SIMPLE,
+            header_style="bold bright_white",
+            expand=True,
+        )
+        table.add_column("Hook", style="cyan", overflow="fold", min_width=20)
+        table.add_column("Status", style="bright_white", min_width=8)
+        table.add_column("Duration", justify="right", style="magenta", min_width=10)
+        table.add_column("Issues", justify="right", style="bright_white", min_width=8)
 
-    def _should_retry_hooks(
-        self,
-        hook_type: str,
-        attempt: int,
-        max_retries: int,
-        results: list[t.Any],
-    ) -> bool:
-        if hook_type == "fast" and attempt < max_retries - 1:
-            if self._should_retry_fast_hooks(results):
-                self.console.print(
-                    "[yellow]🔄[/ yellow] Fast hooks modified files, retrying all fast hooks...",
+        for result in results:
+            status_style = self._status_style(result.status)
+            # Passed hooks always show 0 issues (files processed != issues found)
+            if result.status == "passed":
+                issues_display = "0"
+            elif hasattr(result, "is_config_error") and result.is_config_error:
+                # Config/tool error - show simple symbol instead of misleading count
+                # Using "!" instead of emoji to avoid width issues in terminal
+                issues_display = "[yellow]![/yellow]"
+            else:
+                # For failed hooks with code violations, use issues_count
+                # IMPORTANT: Use issues_count directly, don't fall back to len(issues_found)
+                # because issues_found may contain display messages that aren't actual issues
+                issues_display = str(
+                    result.issues_count if hasattr(result, "issues_count") else 0
                 )
-                return True
-        return False
+            table.add_row(
+                self._strip_ansi(result.name),
+                f"[{status_style}]{result.status.upper()}[/{status_style}]",
+                f"{result.duration:.2f}s",
+                issues_display,
+            )
 
-    def _attempt_autofix_for_fast_hooks(self, results: list[t.Any]) -> bool:
-        try:
-            self.logger.info("Attempting autofix for fast hook failures")
+        return table
+
+    def _format_issues(self, issues: list[str]) -> list[dict[str, str | int | None]]:
+        """Format hook issues into structured dictionaries."""
+
+        def _format_single_issue(issue):
+            if hasattr(issue, "file_path") and hasattr(issue, "line_number"):
+                return {
+                    "file": str(getattr(issue, "file_path", "unknown")),
+                    "line": getattr(issue, "line_number", 0),
+                    "message": getattr(issue, "message", str(issue)),
+                    "code": getattr(issue, "code", None),
+                    "severity": getattr(issue, "severity", "warning"),
+                    "suggestion": getattr(issue, "suggestion", None),
+                }
+
+            return {
+                "file": "unknown",
+                "line": 0,
+                "message": str(issue),
+                "code": None,
+                "severity": "warning",
+                "suggestion": None,
+            }
+
+        return [_format_single_issue(issue) for issue in issues]
+
+    def to_json(self, results: list[HookResult], suite_name: str = "") -> dict:
+        """Export hook results as structured JSON for automation.
+
+        Args:
+            results: List of HookResult objects to export
+            suite_name: Optional suite name (fast/comprehensive)
+
+        Returns:
+            Dictionary with structured results data
+
+        Example:
+            >>> json_data = coordinator.to_json(results, "comprehensive")
+            >>> print(json.dumps(json_data, indent=2))
+        """
+        return {
+            "suite": suite_name,
+            "summary": self._calculate_hook_statistics(results),
+            "hooks": [
+                {
+                    "name": result.name,
+                    "status": result.status,
+                    "duration": round(result.duration, 2),
+                    "issues_count": len(result.issues_found)
+                    if result.issues_found
+                    else 0,
+                    "issues": self._format_issues(result.issues_found)
+                    if result.issues_found
+                    else [],
+                }
+                for result in results
+            ],
+        }
+
+    def _build_results_panel(
+        self, suite_name: str, table: Table, summary_text: str
+    ) -> Panel:
+        """Build Rich panel containing results table."""
+        return Panel(
+            table,
+            title=f"[bold]{suite_name.title()} Hook Results[/bold]",
+            subtitle=summary_text,
+            border_style="cyan" if suite_name == "fast" else "magenta",
+            padding=(0, 1),
+            width=get_console_width(),
+            expand=True,
+        )
 
-            autofix_coordinator = self._lazy_autofix.get()
-            fix_result: bool = autofix_coordinator.apply_fast_stage_fixes()
-            return fix_result
-        except Exception as e:
-            self.logger.warning(f"Autofix attempt failed: {e}")
-            return False
+    def _format_failing_hooks(
+        self, suite_name: str, results: list[HookResult]
+    ) -> list[HookResult]:
+        """Get list of failing hooks and print header.
+
+        Returns:
+            List of failing hook results
+        """
+        failing = [
+            result
+            for result in results
+            if result.status.lower() in {"failed", "error", "timeout"}
+        ]
+
+        if failing:
+            self.console.print(
+                f"[red]Details for failing {suite_name} hooks:[/red]", highlight=False
+            )
+
+        return failing
 
-    def _handle_hook_failures(
+    def _display_issue_details(self, result: HookResult) -> None:
+        """Display specific issue details if found."""
+        if not result.issues_found:
+            return
+
+        for issue in result.issues_found:
+            self.console.print(f"      - {self._strip_ansi(issue)}", highlight=False)
+
+    def _display_timeout_info(self, result: HookResult) -> None:
+        """Display timeout information."""
+        if result.is_timeout:
+            self.console.print(
+                "      - Hook timed out during execution", highlight=False
+            )
+
+    def _display_exit_code_info(self, result: HookResult) -> None:
+        """Display exit code with helpful context."""
+        if result.exit_code is not None and result.exit_code != 0:
+            exit_msg = f"Exit code: {result.exit_code}"
+            # Add helpful context for common exit codes
+            if result.exit_code == 137:
+                exit_msg += " (killed - possibly timeout or out of memory)"
+            elif result.exit_code == 139:
+                exit_msg += " (segmentation fault)"
+            elif result.exit_code in {126, 127}:
+                exit_msg += " (command not found or not executable)"
+            self.console.print(f"      - {exit_msg}", highlight=False)
+
+    def _display_error_message(self, result: HookResult) -> None:
+        """Display error message preview."""
+        if result.error_message:
+            # Show first line or first 200 chars of error
+            error_preview = result.error_message.split("\n")[0][:200]
+            self.console.print(f"      - Error: {error_preview}", highlight=False)
+
+    def _display_generic_failure(self, result: HookResult) -> None:
+        """Display generic failure message if no specific details available."""
+        if not result.is_timeout and not result.exit_code and not result.error_message:
+            self.console.print(
+                "      - Hook failed with no detailed error information",
+                highlight=False,
+            )
+
+    def _display_hook_failures(
         self,
-        hook_type: str,
+        suite_name: str,
+        results: list[HookResult],
         options: OptionsProtocol,
-        summary: dict[str, t.Any],
-        results: list[t.Any],
-        attempt: int,
-        max_retries: int,
-    ) -> bool:
-        self.logger.debug(
-            f"{hook_type} hooks failed: {summary['failed']} failed, {summary['errors']} errors",
-        )
+    ) -> None:
+        # Show detailed failures if --verbose or --ai-debug flag is set
+        if not (options.verbose or getattr(options, "ai_debug", False)):
+            return
 
+        failing = self._format_failing_hooks(suite_name, results)
+        if not failing:
+            return
+
+        # Process each failing hook
+        for result in failing:
+            self._print_single_hook_failure(result)
+
+        self.console.print()
+
+    def _print_single_hook_failure(self, result: HookResult) -> None:
+        """Print details of a single hook failure."""
         self.console.print(
-            f"[red]❌[/ red] {hook_type.title()} hooks failed: {summary['failed']} failed, {summary['errors']} errors",
+            f"  - [red]{self._strip_ansi(result.name)}[/red] ({result.status})",
+            highlight=False,
         )
 
-        if hook_type == "fast" and attempt < max_retries - 1:
-            if self._attempt_autofix_for_fast_hooks(results):
-                self.console.print(
-                    "[yellow]🔧[/ yellow] Applied autofixes for fast hooks, retrying...",
-                )
-                return True
+        if result.issues_found:
+            self._print_hook_issues(result)
+        else:
+            self._display_failure_reasons(result)
+
+    def _print_hook_issues(self, result: HookResult) -> None:
+        """Print issues found for a hook."""
+        # Type assertion: issues_found is never None after __post_init__
+        assert result.issues_found is not None
+        for issue in result.issues_found:
+            # Show the issue with consistent formatting
+            self.console.print(f"      - {self._strip_ansi(issue)}", highlight=False)
+
+    def _display_failure_reasons(self, result: HookResult) -> None:
+        """Display reasons why a hook failed."""
+        self._display_timeout_info(result)
+        self._display_exit_code_info(result)
+        self._display_error_message(result)
+        self._display_generic_failure(result)
 
-        if getattr(options, "verbose", False):
-            self._display_verbose_hook_errors(results, hook_type)
+    def _display_cleaning_header(self) -> None:
+        sep = make_separator("-")
+        self.console.print("\n" + sep)
+        self.console.print("[bold bright_green]🧹 CLEANING[/bold bright_green]")
+        self.console.print(sep + "\n")
 
-        detailed_error_msg = self._build_detailed_hook_error_message(results, summary)
+    def _execute_cleaning_process(self) -> bool:
+        py_files = list(self.pkg_path.rglob("*.py"))
+        if not py_files:
+            return self._handle_no_files_to_clean()
 
-        self.session.fail_task(
-            f"{hook_type}_hooks",
-            detailed_error_msg,
-        )
-        return False
+        cleaned_files = self._clean_python_files(py_files)
+        self._report_cleaning_results(cleaned_files)
+        return True
 
-    def _display_verbose_hook_errors(
-        self, results: list[t.Any], hook_type: str
-    ) -> None:
-        self.console.print(
-            f"\n[bold yellow]📋 Detailed {hook_type} hook errors: [/bold yellow]"
-        )
+    def _handle_no_files_to_clean(self) -> bool:
+        self.console.print("No Python files found to clean")
+        self.session.complete_task("cleaning", "No files to clean")
+        return True
 
-        for result in results:
-            status = getattr(result, "status", "")
-            if status not in ("failed", "error", "timeout"):
-                continue
+    def _clean_python_files(self, files: list[Path]) -> list[str]:
+        cleaned_files = []
+        for file in files:
+            if self.code_cleaner.should_process_file(file):
+                result = self.code_cleaner.clean_file(file)
+                if result.success:
+                    cleaned_files.append(str(file))
+        return cleaned_files
+
+    def _report_cleaning_results(self, cleaned_files: list[str]) -> None:
+        if cleaned_files:
+            self.console.print(f"Cleaned {len(cleaned_files)} files")
+            self.session.complete_task(
+                "cleaning", f"Cleaned {len(cleaned_files)} files"
+            )
+        else:
+            self.console.print("No cleaning needed for any files")
+            self.session.complete_task("cleaning", "No cleaning needed")
 
-            hook_name = getattr(result, "name", "unknown")
-            issues = getattr(result, "issues_found", [])
+    @staticmethod
+    def _determine_version_type(options: OptionsProtocol) -> str | None:
+        return options.publish or options.all or options.bump
 
-            self.console.print(f"\n[red]❌ {hook_name}[/red]")
+    def _execute_publishing_workflow(
+        self, options: OptionsProtocol, version_type: str
+    ) -> bool:
+        # Store reference to current HEAD to allow rollback if needed
+        original_head = (
+            self.git_service.get_current_commit_hash()
+            if hasattr(self.git_service, "get_current_commit_hash")
+            else None
+        )
 
-            if issues:
-                for issue in issues:
-                    if isinstance(issue, str) and issue.strip():
-                        cleaned_issue = issue.strip()
-                        self.console.print(f" {cleaned_issue}")
-            else:
-                self.console.print(f" Hook failed with exit code (status: {status})")
+        # STAGE 0: Pre-publish commit if needed
+        if not self._handle_pre_publish_commit(options):
+            return False
 
-    def _build_detailed_hook_error_message(
-        self, results: list[t.Any], summary: dict[str, t.Any]
-    ) -> str:
-        error_parts = [f"{summary['failed']} failed, {summary['errors']} errors"]
+        # STAGE 1: Version bump
+        new_version = self._perform_version_bump(version_type)
+        if not new_version:
+            return False
 
-        failed_hooks = []
-        for result in results:
-            if hasattr(result, "failed") and result.failed:
-                hook_name = getattr(result, "hook_id", "") or getattr(
-                    result, "name", "unknown"
-                )
-                failed_hooks.append(hook_name.lower())
+        # STAGE 2: Commit, tag, and push changes
+        current_commit_hash = self._commit_version_changes(new_version)
+        if not current_commit_hash:
+            return False
 
-        if failed_hooks:
-            error_parts.append(f"Failed hooks: {', '.join(failed_hooks)}")
+        # STAGE 3: Publish to PyPI
+        if not self._publish_to_pypi(
+            options, new_version, original_head, current_commit_hash
+        ):
+            return False
 
-        return " | ".join(error_parts)
+        # Finalize publishing
+        self._finalize_publishing(options, new_version)
 
-    def _should_retry_fast_hooks(self, results: list[t.Any]) -> bool:
-        for result in results:
-            if hasattr(result, "failed") and result.failed:
-                return True
+        self.session.complete_task("publishing", f"Published version {new_version}")
+        return True
 
-            status = getattr(result, "status", "")
-            if status in ("failed", "error", "timeout"):
-                return True
-        return False
+    def _handle_pre_publish_commit(self, options: OptionsProtocol) -> bool:
+        """Handle committing existing changes before version bump if needed."""
+        if not options.commit:
+            return True
 
-    def _apply_retry_backoff(self, attempt: int) -> None:
-        if attempt > 0:
-            backoff_delay = 2 ** (attempt - 1)
-            self.logger.debug(f"Applying exponential backoff: {backoff_delay}s")
-            self.console.print(f"[dim]Waiting {backoff_delay}s before retry...[/ dim]")
-            time.sleep(backoff_delay)
+        existing_changes = self.git_service.get_changed_files()
+        if not existing_changes:
+            return True
 
-    def _handle_hook_success(self, hook_type: str, summary: dict[str, t.Any]) -> bool:
-        self.logger.info(
-            f"{hook_type} hooks passed: {summary['passed']} / {summary['total']}",
-        )
+        self._display_commit_push_header()
         self.console.print(
-            f"[green]✅[/ green] {hook_type.title()} hooks passed: {summary['passed']} / {summary['total']}",
+            "[cyan]ℹ️[/cyan] Committing existing changes before version bump..."
         )
-        self.session.complete_task(
-            f"{hook_type}_hooks",
-            f"{summary['passed']} / {summary['total']} passed",
+        commit_message = self._get_commit_message(existing_changes, options)
+        if not self._execute_commit_and_push(existing_changes, commit_message):
+            self.session.fail_task("publishing", "Failed to commit pre-publish changes")
+            return False
+        self.console.print(
+            "[green]✅[/green] Pre-publish changes committed and pushed\n"
         )
         return True
 
-    def _handle_hook_exception(self, hook_type: str, e: Exception) -> bool:
-        self.console.print(f"[red]❌[/ red] {hook_type.title()} hooks error: {e}")
-        self.session.fail_task(f"{hook_type}_hooks", str(e))
-        return False
+    def _perform_version_bump(self, version_type: str) -> str | None:
+        """Perform the version bump operation."""
+        self._display_version_bump_header()
 
-    async def _execute_hooks_with_parallel_support(
+        new_version = self.publish_manager.bump_version(version_type)
+        if not new_version:
+            self.session.fail_task("publishing", "Version bumping failed")
+            return None
+
+        self.console.print(f"[green]✅[/green] Version bumped to {new_version}")
+        self.console.print(
+            f"[green]✅[/green] Changelog updated for version {new_version}"
+        )
+        return new_version
+
+    def _commit_version_changes(self, new_version: str) -> str | None:
+        """Commit the version changes to git."""
+        self._display_commit_push_header()
+
+        # Stage changes
+        changed_files = self.git_service.get_changed_files()
+        if not changed_files:
+            self.console.print("[yellow]⚠️[/yellow] No changes to stage")
+            self.session.fail_task("publishing", "No changes to commit")
+            return None
+
+        if not self.git_service.add_files(changed_files):
+            self.session.fail_task("publishing", "Failed to stage files")
+            return None
+        self.console.print(f"[green]✅[/green] Staged {len(changed_files)} files")
+
+        # Commit
+        commit_message = f"chore: bump version to {new_version}"
+        if not self.git_service.commit(commit_message):
+            self.session.fail_task("publishing", "Failed to commit changes")
+            return None
+        current_commit_hash = (
+            self.git_service.get_current_commit_hash()
+            if hasattr(self.git_service, "get_current_commit_hash")
+            else None
+        )
+        return current_commit_hash
+
+    def _publish_to_pypi(
         self,
-        hook_type: str,
-        hook_runner: t.Callable[[], list[t.Any]],
         options: OptionsProtocol,
+        new_version: str,
+        original_head: str | None,
+        current_commit_hash: str | None,
     ) -> bool:
-        self._initialize_hook_execution(hook_type)
+        """Publish the package to PyPI."""
+        self._display_publish_header()
+
+        # Build and publish package
+        if not self.publish_manager.publish_package():
+            self.session.fail_task("publishing", "Package publishing failed")
+            # Attempt to rollback the version bump commit if publishing fails
+            if current_commit_hash and original_head:
+                self._attempt_rollback_version_bump(original_head, current_commit_hash)
+            return False
+        return True
+
+    def _finalize_publishing(self, options: OptionsProtocol, new_version: str) -> None:
+        """Finalize the publishing process after successful PyPI publishing."""
+        # Create git tag and push only after successful PyPI publishing
+        if not options.no_git_tags:
+            if not self.publish_manager.create_git_tag_local(new_version):
+                self.console.print(
+                    f"[yellow]⚠️[/yellow] Failed to create git tag v{new_version}"
+                )
+
+        # Push commit and tag together in single operation only after successful PyPI publishing
+        if not self.git_service.push_with_tags():
+            self.console.print("[yellow]⚠️[/yellow] Push failed. Please push manually")
+            # Not failing the whole workflow for a push failure
 
+    def _attempt_rollback_version_bump(
+        self, original_head: str, current_commit_hash: str
+    ) -> bool:
+        """Attempt to undo the version bump commit if publishing fails."""
         try:
-            return await self._process_parallel_hook_execution(
-                hook_type, hook_runner, options
+            self.console.print(
+                "[yellow]🔄 Attempting to rollback version bump commit...[/yellow]"
             )
 
+            # Reset to the original HEAD (before version bump commit)
+            result = self.git_service.reset_hard(original_head)
+
+            if result:
+                self.console.print(
+                    f"[green]✅ Version bump commit ({current_commit_hash[:8]}...) reverted[/green]"
+                )
+                return True
+            else:
+                self.console.print("[red]❌ Failed to revert version bump commit[/red]")
+                return False
         except Exception as e:
-            return self._handle_hook_exception(hook_type, e)
+            self.console.print(f"[red]❌ Error during version rollback: {e}[/red]")
+            return False
 
-    async def _process_parallel_hook_execution(
-        self,
-        hook_type: str,
-        hook_runner: t.Callable[[], list[t.Any]],
-        options: OptionsProtocol,
-    ) -> bool:
-        results = hook_runner()
-        summary = self.hook_manager.get_hook_summary(results)
+    def _display_version_bump_header(self) -> None:
+        sep = make_separator("-")
+        self.console.print("\n" + sep)
+        self.console.print("[bold bright_cyan]📝 VERSION BUMP[/bold bright_cyan]")
+        self.console.print(sep + "\n")
 
-        if not self._has_hook_failures(summary):
-            return self._handle_hook_success(hook_type, summary)
+    def _display_commit_push_header(self) -> None:
+        sep = make_separator("-")
+        self.console.print("\n" + sep)
+        self.console.print("[bold bright_blue]📦 COMMIT & PUSH[/bold bright_blue]")
+        self.console.print(sep + "\n")
 
-        return self._handle_parallel_hook_failures(
-            hook_type, hook_runner, options, results, summary
-        )
+    def _display_publish_header(self) -> None:
+        sep = make_separator("-")
+        self.console.print("\n" + sep)
+        self.console.print("[bold bright_green]🚀 PUBLISH TO PYPI[/bold bright_green]")
+        self.console.print(sep + "\n")
 
-    def _handle_parallel_hook_failures(
-        self,
-        hook_type: str,
-        hook_runner: t.Callable[[], list[t.Any]],
-        options: OptionsProtocol,
-        results: list[t.Any],
-        summary: dict[str, t.Any],
-    ) -> bool:
-        if hook_type != "fast":
-            return self._handle_hook_failures(
-                hook_type, options, summary, results, 0, 1
-            )
+    def _handle_no_changes_to_commit(self) -> bool:
+        self.console.print("No changes to commit")
+        self.session.complete_task("commit", "No changes to commit")
+        return True
 
-        if not self._attempt_autofix_for_fast_hooks(results):
-            return self._handle_hook_failures(
-                hook_type, options, summary, results, 0, 1
-            )
+    def _get_commit_message(
+        self, changed_files: list[str], options: OptionsProtocol
+    ) -> str:
+        suggestions = self.git_service.get_commit_message_suggestions(changed_files)
+        if not suggestions:
+            return "Update project files"
 
-        return self._retry_hooks_after_autofix(hook_type, hook_runner, options)
+        if not options.interactive:
+            return suggestions[0]
 
-    def _retry_hooks_after_autofix(
-        self,
-        hook_type: str,
-        hook_runner: t.Callable[[], list[t.Any]],
-        options: OptionsProtocol,
-    ) -> bool:
-        self.console.print(
-            "[yellow]🔧[/ yellow] Applied autofixes for fast hooks, retrying..."
-        )
+        return self._interactive_commit_message_selection(suggestions)
+
+    def _interactive_commit_message_selection(self, suggestions: list[str]) -> str:
+        self._display_commit_suggestions(suggestions)
+        choice = self.console.input(
+            "\nEnter number, custom message, or press Enter for default: "
+        ).strip()
+        return self._process_commit_choice(choice, suggestions)
 
-        results = hook_runner()
-        summary = self.hook_manager.get_hook_summary(results)
+    def _display_commit_suggestions(self, suggestions: list[str]) -> None:
+        self.console.print("\n[bold]Commit message suggestions:[/bold]")
+        for i, suggestion in enumerate(suggestions, 1):
+            self.console.print(f"  [cyan]{i}[/cyan]: {suggestion}")
 
-        if not self._has_hook_failures(summary):
-            return self._handle_hook_success(hook_type, summary)
+    @staticmethod
+    def _process_commit_choice(choice: str, suggestions: list[str]) -> str:
+        if not choice:
+            return suggestions[0]
+        if choice.isdigit() and 1 <= int(choice) <= len(suggestions):
+            return suggestions[int(choice) - 1]
+        return choice
 
-        return self._handle_hook_failures(hook_type, options, summary, results, 0, 1)
+    def _execute_commit_and_push(
+        self, changed_files: list[str], commit_message: str
+    ) -> bool:
+        if not self.git_service.add_files(changed_files):
+            self.session.fail_task("commit", "Failed to add files to git")
+            return False
+        if not self.git_service.commit(commit_message):
+            self.session.fail_task("commit", "Failed to commit files")
+            return False
+        if not self.git_service.push():
+            self.console.print("[yellow]⚠️[/yellow] Push failed. Please push manually")
+            # Not failing the whole workflow for a push failure
+        self.session.complete_task("commit", "Committed and pushed changes")
+        return True
 
-    @property
-    def autofix_coordinator(self) -> AutofixCoordinator:
-        coordinator: AutofixCoordinator = self._lazy_autofix.get()
-        return coordinator
+    @staticmethod
+    def _format_hook_summary(summary: dict[str, t.Any]) -> str:
+        if not summary:
+            return "No hooks executed"
+
+        total = summary.get("total", 0)
+        passed = summary.get("passed", 0)
+        failed = summary.get("failed", 0)
+        errors = summary.get("errors", 0)
+        duration = summary.get("total_duration", 0.0)
+
+        parts = [f"{passed}/{total} passed"]
+        if failed:
+            parts.append(f"{failed} failed")
+        if errors:
+            parts.append(f"{errors} errors")
+
+        summary_str = ", ".join(parts)
+        return f"{summary_str} in {duration:.2f}s"
+
+    @staticmethod
+    def _status_style(status: str) -> str:
+        normalized = status.lower()
+        if normalized == "passed":
+            return "green"
+        if normalized in {"failed", "error"}:
+            return "red"
+        if normalized == "timeout":
+            return "yellow"
+        return "bright_white"
+
+    # (All printing is handled by acb.console.Console which supports robust I/O.)