shrinkray 25.12.26__tar.gz → 25.12.26.1__tar.gz

{shrinkray-25.12.26/src/shrinkray.egg-info → shrinkray-25.12.26.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shrinkray
-Version: 25.12.26
+Version: 25.12.26.1
 Summary: Shrink Ray
 Author-email: "David R. MacIver" <david@drmaciver.com>
 License: MIT
@@ -89,15 +89,19 @@ Most test-case reducers only work well on a few formats. Shrink Ray is designed
 
 It's designed to be highly parallel, and work with a very wide variety of formats, through a mix of good generic algorithms and format-specific reduction passes.
 
-Currently shrink ray is a "prerelease" version in the sense that there is no official release yet and you're expected to just run off main (don't worry this is easy to do), as it's a bit experimental.
+## Versioning and Releases
 
-That being said this probably doesn't matter that much for the question of whether to use it. It's in the nature of test-case reduction that it doesn't matter all that much if it's bad, because it's still going to do a bunch of work that you didn't have to do by hand. Try it out, see if it works. If it doesn't, please tell me and I'll make it work better.
+Shrink Ray uses calendar versioning (calver) in the format YY.M.D.N (e.g., 25.12.26.0 for the first release on December 26, 2025, 25.12.26.1 for the second, etc.).
+
+New releases are published automatically when changes are pushed to main if there are any changes to the source code or pyproject.toml since the previous release.
+
+Shrinkray makes no particularly strong backwards compatibility guarantees. I aim to keep its behaviour relatively stable between releases, but for example will not be particularly shy about dropping old versions of Python or adding new dependencies. The basic workflow of running a simple reduction will rarely, if ever, change, but the UI is likely to be continuously evolving for some time.
 
 ## Installation
 
-Shrink Ray requires Python 3.11 or later, and can be installed using pip.
+Shrink Ray requires Python 3.12 or later, and can be installed using pip or uv like any other python package.
 
-Official releases for shrink ray are infrequent, and I recommend running off main. You can install it as follows:
+You can install the latest release from PyPI or run directly from the main branch:
 
 ```
 pipx install shrinkray
@@ -107,8 +111,8 @@ pipx install git+https://github.com/DRMacIver/shrinkray.git
 
 (if you don't have or want [pipx](https://pypa.github.io/pipx/) you could also do this with pip or `uv pip` and it would work fine)
 
-Shrink Ray requires Python 3.11 or later and won't work on earlier versions. If everything is working correctly, it should refuse to install
-on versions it's incompatible with. If you do not have Python 3.11 installed, I recommend [pyenv](https://github.com/pyenv/pyenv) for managing
+Shrink Ray requires Python 3.12 or later and won't work on earlier versions. If everything is working correctly, it should refuse to install
+on versions it's incompatible with. If you do not have Python 3.12 installed, I recommend [pyenv](https://github.com/pyenv/pyenv) for managing
 Python installs.
 
 If you want to use it from the git repo directly, you can do the following:

{shrinkray-25.12.26 → shrinkray-25.12.26.1}/README.md

@@ -50,15 +50,19 @@ Most test-case reducers only work well on a few formats. Shrink Ray is designed
 
 It's designed to be highly parallel, and work with a very wide variety of formats, through a mix of good generic algorithms and format-specific reduction passes.
 
-Currently shrink ray is a "prerelease" version in the sense that there is no official release yet and you're expected to just run off main (don't worry this is easy to do), as it's a bit experimental.
+## Versioning and Releases
 
-That being said this probably doesn't matter that much for the question of whether to use it. It's in the nature of test-case reduction that it doesn't matter all that much if it's bad, because it's still going to do a bunch of work that you didn't have to do by hand. Try it out, see if it works. If it doesn't, please tell me and I'll make it work better.
+Shrink Ray uses calendar versioning (calver) in the format YY.M.D.N (e.g., 25.12.26.0 for the first release on December 26, 2025, 25.12.26.1 for the second, etc.).
+
+New releases are published automatically when changes are pushed to main if there are any changes to the source code or pyproject.toml since the previous release.
+
+Shrinkray makes no particularly strong backwards compatibility guarantees. I aim to keep its behaviour relatively stable between releases, but for example will not be particularly shy about dropping old versions of Python or adding new dependencies. The basic workflow of running a simple reduction will rarely, if ever, change, but the UI is likely to be continuously evolving for some time.
 
 ## Installation
 
-Shrink Ray requires Python 3.11 or later, and can be installed using pip.
+Shrink Ray requires Python 3.12 or later, and can be installed using pip or uv like any other python package.
 
-Official releases for shrink ray are infrequent, and I recommend running off main. You can install it as follows:
+You can install the latest release from PyPI or run directly from the main branch:
 
 ```
 pipx install shrinkray
@@ -68,8 +72,8 @@ pipx install git+https://github.com/DRMacIver/shrinkray.git
 
 (if you don't have or want [pipx](https://pypa.github.io/pipx/) you could also do this with pip or `uv pip` and it would work fine)
 
-Shrink Ray requires Python 3.11 or later and won't work on earlier versions. If everything is working correctly, it should refuse to install
-on versions it's incompatible with. If you do not have Python 3.11 installed, I recommend [pyenv](https://github.com/pyenv/pyenv) for managing
+Shrink Ray requires Python 3.12 or later and won't work on earlier versions. If everything is working correctly, it should refuse to install
+on versions it's incompatible with. If you do not have Python 3.12 installed, I recommend [pyenv](https://github.com/pyenv/pyenv) for managing
 Python installs.
 
 If you want to use it from the git repo directly, you can do the following:

{shrinkray-25.12.26 → shrinkray-25.12.26.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "shrinkray"
-version = "25.12.26"
+version = "25.12.26.1"
 description = "Shrink Ray"
 authors = [
     {name = "David R. MacIver", email = "david@drmaciver.com"}

{shrinkray-25.12.26 → shrinkray-25.12.26.1}/src/shrinkray/problem.py

@@ -19,6 +19,7 @@ from datetime import timedelta
 from typing import (
     TYPE_CHECKING,
     Any,
+    Protocol,
     TypeVar,
     cast,
 )
@@ -38,6 +39,18 @@ S = TypeVar("S")
 T = TypeVar("T")
 
 
+class PassStatsProtocol(Protocol):
+    """Protocol for pass statistics tracking.
+
+    This allows problem.py to track stats without importing from reducer.py,
+    avoiding circular dependencies.
+    """
+
+    test_evaluations: int
+    successful_reductions: int
+    bytes_deleted: int
+
+
 def shortlex[SizedT: Sized](value: SizedT) -> tuple[int, SizedT]:
     """Return a comparison key for shortlex ordering.
 
@@ -162,6 +175,8 @@ class ReductionProblem[T](ABC):
     """
 
     work: WorkContext
+    # Track current pass stats for real-time updates (set by reducer)
+    current_pass_stats: PassStatsProtocol | None = None
 
     def __attrs_post_init__(self) -> None:
         # Cache of View objects for each Format, to avoid re-parsing
@@ -377,6 +392,11 @@ class BasicReductionProblem(ReductionProblem[T]):
         self.__is_interesting_cache[cache_key] = result
         self.stats.failed_reductions += 1
         self.stats.calls += 1
+
+        # Update current pass stats if a pass is running
+        if self.current_pass_stats is not None:
+            self.current_pass_stats.test_evaluations += 1
+
         if result:
             self.stats.interesting_calls += 1
             if self.sort_key(test_case) < self.sort_key(self.current_test_case):
@@ -384,6 +404,13 @@ class BasicReductionProblem(ReductionProblem[T]):
                 self.stats.failed_reductions -= 1
                 self.stats.reductions += 1
                 self.stats.time_of_last_reduction = time.time()
+
+                # Update current pass stats for reductions
+                if self.current_pass_stats is not None:
+                    self.current_pass_stats.successful_reductions += 1
+                    size_diff = self.size(self.current_test_case) - self.size(test_case)
+                    self.current_pass_stats.bytes_deleted += size_diff
+
                 self.stats.current_test_case_size = self.size(test_case)
                 self.__current = test_case
                 for f in self.__on_reduce_callbacks:

{shrinkray-25.12.26 → shrinkray-25.12.26.1}/src/shrinkray/reducer.py

@@ -56,6 +56,11 @@ from shrinkray.problem import ReductionProblem, ReductionStats, shortlex
 class Reducer[T](ABC):
     target: ReductionProblem[T]
 
+    # Optional pass statistics tracking (implemented by ShrinkRay)
+    pass_stats: "PassStatsTracker | None" = attrs.field(default=None, init=False)
+    # Optional current pass tracking (implemented by ShrinkRay)
+    current_reduction_pass: "ReductionPass[T] | None" = attrs.field(default=None, init=False)
+
     @contextmanager
     def backtrack(self, restart: T) -> Generator[None, None, None]:
         current = self.target
@@ -72,6 +77,20 @@ class Reducer[T](ABC):
     def status(self) -> str:
         return ""
 
+    @property
+    def disabled_passes(self) -> set[str]:
+        """Set of disabled pass names. Override in subclasses for pass control."""
+        return set()
+
+    def disable_pass(self, pass_name: str) -> None:  # noqa: B027
+        """Disable a pass by name. Override in subclasses for pass control."""
+
+    def enable_pass(self, pass_name: str) -> None:  # noqa: B027
+        """Enable a pass by name. Override in subclasses for pass control."""
+
+    def skip_current_pass(self) -> None:  # noqa: B027
+        """Skip the currently running pass. Override in subclasses for pass control."""
+
 
 @define
 class BasicReducer[T](Reducer[T]):
@@ -117,14 +136,88 @@ class RestartPass(Exception):
     pass
 
 
+@define
+class PassStats:
+    """Statistics for a single reduction pass."""
+
+    pass_name: str
+    bytes_deleted: int = 0
+    run_count: int = 0
+    test_evaluations: int = 0
+    successful_reductions: int = 0
+
+    @property
+    def success_rate(self) -> float:
+        """Percentage of test evaluations that led to a reduction."""
+        if self.test_evaluations == 0:
+            return 0.0
+        return (self.successful_reductions / self.test_evaluations) * 100.0
+
+
+@define
+class PassStatsTracker:
+    """Tracks statistics for all reduction passes.
+
+    Python 3.7+ dicts maintain insertion order, so stats are returned
+    in the order passes were first run.
+    """
+
+    _stats: dict[str, PassStats] = attrs.Factory(dict)
+
+    def get_or_create(self, pass_name: str) -> PassStats:
+        if pass_name not in self._stats:
+            self._stats[pass_name] = PassStats(pass_name=pass_name)
+        return self._stats[pass_name]
+
+    def get_stats_in_order(self) -> list[PassStats]:
+        """Get stats in the order passes were first run."""
+        return list(self._stats.values())
+
+
+class SkipPass(Exception):
+    """Raised to skip the current pass."""
+
+    pass
+
+
 @define
 class ShrinkRay(Reducer[bytes]):
     clang_delta: ClangDelta | None = None
 
-    current_reduction_pass: ReductionPass[bytes] | None = None
     current_pump: ReductionPump[bytes] | None = None
 
     unlocked_ok_passes: bool = False
+    pass_stats: PassStatsTracker | None = attrs.Factory(PassStatsTracker)
+
+    # Pass control: disabled passes and skip functionality
+    disabled_passes: set[str] = attrs.Factory(set)
+    _skip_requested: bool = attrs.field(default=False, init=False)
+    _current_pass_scope: "trio.CancelScope | None" = attrs.field(default=None, init=False)
+    _passes_were_skipped: bool = attrs.field(default=False, init=False)
+
+    def disable_pass(self, pass_name: str) -> None:
+        """Disable a pass by name. If it's currently running, skip it."""
+        self.disabled_passes.add(pass_name)
+        # If this pass is currently running, skip it
+        if (
+            self.current_reduction_pass is not None
+            and self.current_reduction_pass.__name__ == pass_name
+        ):
+            self.skip_current_pass()
+
+    def enable_pass(self, pass_name: str) -> None:
+        """Enable a previously disabled pass."""
+        self.disabled_passes.discard(pass_name)
+
+    def is_pass_disabled(self, pass_name: str) -> bool:
+        """Check if a pass is disabled."""
+        return pass_name in self.disabled_passes
+
+    def skip_current_pass(self) -> None:
+        """Request to skip the currently running pass."""
+        self._skip_requested = True
+        if self._current_pass_scope is not None:
+            self._current_pass_scope.cancel()
 
     initial_cuts: list[ReductionPass[bytes]] = attrs.Factory(
         lambda: [
@@ -222,12 +315,39 @@ class ShrinkRay(Reducer[bytes]):
                 return f"Running reduction pump {self.current_pump.__name__}"
 
     async def run_pass(self, rp: ReductionPass[bytes]) -> None:
+        pass_name = rp.__name__
+
+        # Skip if pass is disabled
+        if self.is_pass_disabled(pass_name):
+            return
+
         try:
             assert self.current_reduction_pass is None
             self.current_reduction_pass = rp
-            await rp(self.target)
+            self._skip_requested = False
+
+            # Get or create stats entry for this pass
+            assert self.pass_stats is not None  # Always set by Factory
+            stats_entry = self.pass_stats.get_or_create(pass_name)
+            stats_entry.run_count += 1
+
+            # Set current pass stats on the problem for real-time updates
+            self.target.current_pass_stats = stats_entry
+
+            # Run the pass with a cancel scope that can be externally cancelled
+            with trio.CancelScope() as scope:
+                self._current_pass_scope = scope
+                await rp(self.target)
+
+            # If the pass was cancelled/skipped, mark that passes were skipped
+            if scope.cancelled_caught:
+                self._passes_were_skipped = True
+
         finally:
             self.current_reduction_pass = None
+            self.target.current_pass_stats = None
+            self._current_pass_scope = None
+            self._skip_requested = False
 
     async def pump(self, rp: ReductionPump[bytes]) -> None:
         try:
@@ -357,6 +477,9 @@ class ShrinkRay(Reducer[bytes]):
         await self.initial_cut()
 
         while True:
+            # Reset skip tracking for this iteration
+            self._passes_were_skipped = False
+
             prev = self.target.current_test_case
             await self.run_some_passes()
             if self.target.current_test_case != prev:
@@ -364,7 +487,10 @@ class ShrinkRay(Reducer[bytes]):
             for pump in self.pumps:
                 await self.pump(pump)
             if self.target.current_test_case == prev:
-                break
+                # Only terminate if no passes were skipped
+                # If passes were skipped, we need another full run to be sure
+                if not self._passes_were_skipped:
+                    break
 
 
 class UpdateKeys(Patches[dict[str, bytes], dict[str, bytes]]):

{shrinkray-25.12.26 → shrinkray-25.12.26.1}/src/shrinkray/subprocess/client.py

@@ -2,6 +2,7 @@
 
 import asyncio
 import sys
+import traceback
 import uuid
 from collections.abc import AsyncIterator
 from typing import Any
@@ -58,6 +59,7 @@ class SubprocessClient:
                     if line:
                         await self._handle_message(line.decode("utf-8"))
             except Exception:
+                traceback.print_exc()
                 break
 
     async def _handle_message(self, line: str) -> None:
@@ -65,6 +67,7 @@ class SubprocessClient:
         try:
             msg = deserialize(line)
         except Exception:
+            traceback.print_exc()
             return
 
         if isinstance(msg, ProgressUpdate):
@@ -167,6 +170,36 @@ class SubprocessClient:
         except Exception:
             return Response(id="", result={"status": "cancelled"})
 
+    async def disable_pass(self, pass_name: str) -> Response:
+        """Disable a reduction pass by name."""
+        if self._completed:
+            return Response(id="", result={"status": "already_completed"})
+        try:
+            return await self.send_command("disable_pass", {"pass_name": pass_name})
+        except Exception:
+            traceback.print_exc()
+            return Response(id="", error="Failed to disable pass")
+
+    async def enable_pass(self, pass_name: str) -> Response:
+        """Enable a previously disabled reduction pass."""
+        if self._completed:
+            return Response(id="", result={"status": "already_completed"})
+        try:
+            return await self.send_command("enable_pass", {"pass_name": pass_name})
+        except Exception:
+            traceback.print_exc()
+            return Response(id="", error="Failed to enable pass")
+
+    async def skip_current_pass(self) -> Response:
+        """Skip the currently running pass."""
+        if self._completed:
+            return Response(id="", result={"status": "already_completed"})
+        try:
+            return await self.send_command("skip_pass")
+        except Exception:
+            traceback.print_exc()
+            return Response(id="", error="Failed to skip pass")
+
     async def get_progress_updates(self) -> AsyncIterator[ProgressUpdate]:
         """Yield progress updates as they arrive."""
         while not self._completed:
@@ -200,7 +233,7 @@ class SubprocessClient:
                 try:
                     self._process.stdin.close()
                 except Exception:
-                    pass
+                    traceback.print_exc()
             # Only terminate if still running
             if self._process.returncode is None:
                 try:

{shrinkray-25.12.26 → shrinkray-25.12.26.1}/src/shrinkray/subprocess/protocol.py

@@ -50,6 +50,24 @@ class ProgressUpdate:
     content_preview: str = ""
     # Whether content is hex mode
     hex_mode: bool = False
+    # Pass statistics (only passes with test evaluations)
+    pass_stats: list["PassStatsData"] = field(default_factory=list)
+    # Currently running pass name (for highlighting)
+    current_pass_name: str = ""
+    # List of disabled pass names
+    disabled_passes: list[str] = field(default_factory=list)
+
+
+@dataclass
+class PassStatsData:
+    """Statistics for a single pass (serializable)."""
+
+    pass_name: str
+    bytes_deleted: int
+    run_count: int
+    test_evaluations: int
+    successful_reductions: int
+    success_rate: float
 
 
 def serialize(msg: Request | Response | ProgressUpdate) -> str:
@@ -84,6 +102,19 @@ def serialize(msg: Request | Response | ProgressUpdate) -> str:
                 "time_since_last_reduction": msg.time_since_last_reduction,
                 "content_preview": msg.content_preview,
                 "hex_mode": msg.hex_mode,
+                "pass_stats": [
+                    {
+                        "pass_name": ps.pass_name,
+                        "bytes_deleted": ps.bytes_deleted,
+                        "run_count": ps.run_count,
+                        "test_evaluations": ps.test_evaluations,
+                        "successful_reductions": ps.successful_reductions,
+                        "success_rate": ps.success_rate,
+                    }
+                    for ps in msg.pass_stats
+                ],
+                "current_pass_name": msg.current_pass_name,
+                "disabled_passes": msg.disabled_passes,
             },
         }
     else:
@@ -98,6 +129,21 @@ def deserialize(line: str) -> Request | Response | ProgressUpdate:
     # Check for progress update (has "type" field)
     if data.get("type") == "progress":
         d = data["data"]
+
+        # Parse pass stats
+        pass_stats_data = []
+        for ps_dict in d.get("pass_stats", []):
+            pass_stats_data.append(
+                PassStatsData(
+                    pass_name=ps_dict["pass_name"],
+                    bytes_deleted=ps_dict["bytes_deleted"],
+                    run_count=ps_dict["run_count"],
+                    test_evaluations=ps_dict["test_evaluations"],
+                    successful_reductions=ps_dict["successful_reductions"],
+                    success_rate=ps_dict["success_rate"],
+                )
+            )
+
         return ProgressUpdate(
             status=d["status"],
             size=d["size"],
@@ -113,6 +159,9 @@ def deserialize(line: str) -> Request | Response | ProgressUpdate:
             time_since_last_reduction=d.get("time_since_last_reduction", 0.0),
             content_preview=d.get("content_preview", ""),
             hex_mode=d.get("hex_mode", False),
+            pass_stats=pass_stats_data,
+            current_pass_name=d.get("current_pass_name", ""),
+            disabled_passes=d.get("disabled_passes", []),
         )
 
     # Check for response (has "result" or "error" field)

{shrinkray-25.12.26 → shrinkray-25.12.26.1}/src/shrinkray/subprocess/worker.py

@@ -11,6 +11,7 @@ from binaryornot.helpers import is_binary_string
 
 from shrinkray.problem import InvalidInitialExample
 from shrinkray.subprocess.protocol import (
+    PassStatsData,
     ProgressUpdate,
     Request,
     Response,
@@ -104,21 +105,26 @@ class ReducerWorker:
             response = await self.handle_command(request)
             await self.emit(response)
         except Exception as e:
+            traceback.print_exc()
             await self.emit(Response(id="", error=str(e)))
 
     async def handle_command(self, request: Request) -> Response:
         """Handle a command request and return a response."""
-        command = request.command
-        params = request.params
-
-        if command == "start":
-            return await self._handle_start(request.id, params)
-        elif command == "status":
-            return self._handle_status(request.id)
-        elif command == "cancel":
-            return self._handle_cancel(request.id)
-        else:
-            return Response(id=request.id, error=f"Unknown command: {command}")
+        match request.command:
+            case "start":
+                return await self._handle_start(request.id, request.params)
+            case "status":
+                return self._handle_status(request.id)
+            case "cancel":
+                return self._handle_cancel(request.id)
+            case "disable_pass":
+                return self._handle_disable_pass(request.id, request.params)
+            case "enable_pass":
+                return self._handle_enable_pass(request.id, request.params)
+            case "skip_pass":
+                return self._handle_skip_pass(request.id)
+            case _:
+                return Response(id=request.id, error=f"Unknown command: {request.command}")
 
     async def _handle_start(self, request_id: str, params: dict) -> Response:
         """Start the reduction process."""
@@ -236,6 +242,55 @@ class ReducerWorker:
         self.running = False
         return Response(id=request_id, result={"status": "cancelled"})
 
+    def _get_known_pass_names(self) -> set[str]:
+        """Get the set of known pass names from pass stats."""
+        if self.reducer is None or self.reducer.pass_stats is None:
+            return set()
+        return set(self.reducer.pass_stats._stats.keys())
+
+    def _handle_disable_pass(self, request_id: str, params: dict) -> Response:
+        """Disable a reduction pass by name."""
+        pass_name = params.get("pass_name", "")
+        if not pass_name:
+            return Response(id=request_id, error="pass_name is required")
+
+        known_passes = self._get_known_pass_names()
+        if known_passes and pass_name not in known_passes:
+            return Response(
+                id=request_id,
+                error=f"Unknown pass '{pass_name}'. Known passes: {sorted(known_passes)}",
+            )
+
+        if self.reducer is not None and hasattr(self.reducer, "disable_pass"):
+            self.reducer.disable_pass(pass_name)
+            return Response(id=request_id, result={"status": "disabled", "pass_name": pass_name})
+        return Response(id=request_id, error="Reducer does not support pass control")
+
+    def _handle_enable_pass(self, request_id: str, params: dict) -> Response:
+        """Enable a previously disabled reduction pass."""
+        pass_name = params.get("pass_name", "")
+        if not pass_name:
+            return Response(id=request_id, error="pass_name is required")
+
+        known_passes = self._get_known_pass_names()
+        if known_passes and pass_name not in known_passes:
+            return Response(
+                id=request_id,
+                error=f"Unknown pass '{pass_name}'. Known passes: {sorted(known_passes)}",
+            )
+
+        if self.reducer is not None and hasattr(self.reducer, "enable_pass"):
+            self.reducer.enable_pass(pass_name)
+            return Response(id=request_id, result={"status": "enabled", "pass_name": pass_name})
+        return Response(id=request_id, error="Reducer does not support pass control")
+
+    def _handle_skip_pass(self, request_id: str) -> Response:
+        """Skip the currently running pass."""
+        if self.reducer is not None and hasattr(self.reducer, "skip_current_pass"):
+            self.reducer.skip_current_pass()
+            return Response(id=request_id, result={"status": "skipped"})
+        return Response(id=request_id, error="Reducer does not support pass control")
+
     def _get_content_preview(self) -> tuple[str, bool]:
         """Get a preview of the current test case content."""
         if self.problem is None:
@@ -304,6 +359,40 @@ class ReducerWorker:
             )
             effective_parallelism = average_parallelism * (1.0 - wasteage)
 
+        # Collect pass statistics in run order (only those with test evaluations)
+        pass_stats_list = []
+        current_pass_name = ""
+        if self.reducer is not None:
+            # Get the currently running pass name
+            current_pass = self.reducer.current_reduction_pass
+            if current_pass is not None:
+                current_pass_name = getattr(current_pass, "__name__", "")
+
+            # Get all stats in the order they were first run
+            pass_stats = self.reducer.pass_stats
+            if pass_stats is not None:
+                all_stats = pass_stats.get_stats_in_order()
+
+                # Only include passes that have made at least one test evaluation
+                pass_stats_list = [
+                    PassStatsData(
+                        pass_name=ps.pass_name,
+                        bytes_deleted=ps.bytes_deleted,
+                        run_count=ps.run_count,
+                        test_evaluations=ps.test_evaluations,
+                        successful_reductions=ps.successful_reductions,
+                        success_rate=ps.success_rate,
+                    )
+                    for ps in all_stats
+                    if ps.test_evaluations > 0
+                ]
+
+        # Get disabled passes
+        if self.reducer is not None and hasattr(self.reducer, "disabled_passes"):
+            disabled_passes = list(self.reducer.disabled_passes)
+        else:
+            disabled_passes = []
+
         return ProgressUpdate(
             status=self.reducer.status if self.reducer else "",
             size=stats.current_test_case_size,
@@ -319,6 +408,9 @@ class ReducerWorker:
             time_since_last_reduction=stats.time_since_last_reduction(),
             content_preview=content_preview,
             hex_mode=hex_mode,
+            pass_stats=pass_stats_list,
+            current_pass_name=current_pass_name,
+            disabled_passes=disabled_passes,
         )
 
     async def emit_progress_updates(self) -> None:
@@ -360,6 +452,7 @@ class ReducerWorker:
             await self.emit(Response(id="", error=error_message))
         except* Exception as e:
             # Catch any other exception during reduction and emit as error
+            traceback.print_exc()
             await self.emit(Response(id="", error=str(e.exceptions[0])))
         finally:
             self._cancel_scope = None