@@ -74,7 +74,7 @@ one to open.
 | Join processed windows back to the source's length | `dw/tasks/windows.py`: `join_windows`; `dw/task_domains.py`: `window_count`, `window_count_problem`, `join_windows_errors` | Output is exactly the source's frames, each once: later windows' first `overlap` frames blend over the previous window's last on the open ramp `dissolve_videos` uses. The window count is `window_count`'s `ceil(source_frames / stride)` and nothing else (it is also `window_video`'s last index plus one). Audio is the source's own track; shots are one per window with `overlap_frames` on each seam, their sample side laid over that track by `dw/shots.py`'s `remeasured_shots` (the same rounding as `frames_to_samples`, so the spans are cumulative). | `tests/test_join_windows.py::TestRoundTrip::test_unprocessed_windows_rejoin_to_the_source`, `tests/test_join_windows.py::TestShots::test_spans_partition_the_frames_and_tile_the_audio`, `tests/test_join_windows.py::TestUint8Output::test_matches_the_float32_accumulator_exactly` |
 | A `join_windows` list of the wrong length, before the run | `dw/window_count_errors.py`: `window_count_errors`, wired into `validation_errors` | Owned by the task, never a template: any `join_windows` step whose `source` is probeable header-only (`asset:`/`output:` or a readable literal path), with literal `num_frames`/`overlap` and an expanded `videos` list, is checked against `window_count_problem` - the same rule the run refuses with. Anything not knowable stays silent for the run. | `tests/test_window_count_errors.py` |
 | Fit to a model and restore | `dw/tasks/fit.py`: `fit_to_model`, `restore_to_source` | fit_to_model's record is the whole of what restore_to_source needs: the scale is inferred from the output's size and must be uniform, and restore returns the source's size times that scale and at most its frame count. | `tests/test_fit_to_model.py` |
-| Shared image ops | `dw/tasks/image_ops.py`: `LUMA_WEIGHTS`, `luma`, `split_alpha`, `join_alpha`, `per_frame` | `grade`, `finish` and `lut` take luma (float64 Rec. 709 weights, cast to the input's dtype) and alpha handling from `image_ops`, never from each other, so an RGBA input comes back RGBA with its alpha untouched; `lut.LUMA_WEIGHTS` is a re-export. An image command runs over a video or frame list only through `per_frame`. | `tests/test_image_ops.py::TestLuma::test_lut_re_exports_the_one_float64_weights`, `tests/test_image_ops.py::TestAlpha::test_rgba_round_trip_keeps_the_alpha_bytes`, `tests/test_image_ops.py::TestOutputsAreByteIdentical::test_every_command_matches_the_pre_refactor_bytes`, `tests/test_image_ops.py::TestPerFrame::test_a_video_comes_back_as_a_video_with_the_same_frames_and_audio` |
+| Shared image ops | `dw/tasks/image_ops.py`: `LUMA_WEIGHTS`, `luma`, `split_alpha`, `join_alpha`, `per_frame` | `grade`, `finish` and `lut` take luma (float64 Rec. 709 weights, cast to the input's dtype) and alpha handling from `image_ops`, never from each other, so an RGBA input comes back RGBA with its alpha untouched; `lut.LUMA_WEIGHTS` is a re-export. An image command runs over a video or frame list only through `per_frame`. A media file is read by `task._load_media` with `fetch_image(keep_alpha=True)`, so a file with transparency arrives RGBA; a pipeline input still flattens to RGB. | `tests/test_image_ops.py::TestLuma::test_lut_re_exports_the_one_float64_weights`, `tests/test_image_ops.py::TestAlpha::test_rgba_round_trip_keeps_the_alpha_bytes`, `tests/test_image_ops.py::TestOutputsAreByteIdentical::test_every_command_matches_the_pre_refactor_bytes`, `tests/test_image_ops.py::TestPerFrame::test_a_video_comes_back_as_a_video_with_the_same_frames_and_audio`, `tests/test_finish.py::TestRgbaFileKeepsAlpha::test_a_file_path_comes_back_rgba_with_its_alpha` |
 | Audio level of a deliverable | `dw/audio_qc.py`: `warn_without_headroom`, `warn_if_written_above_full_scale` | A muxed video keeps the pre-encode headroom prediction and falls back to it only when the post-write probe cannot measure the file. A result a later step resets the level of (`consumed_by_normalizer`, `dw/step_cache.py`) draws neither the post-write warning nor the fallback. | `tests/test_result.py::TestNoHeadroom::test_a_clean_video_mux_drops_the_stale_prediction`, `tests/test_result.py::TestNoHeadroom::test_an_unprobeable_video_mux_falls_back_to_the_prediction`, `tests/test_result.py::TestNoHeadroom::test_a_video_a_join_level_matches_draws_no_headroom_warning`, `tests/test_result.py::TestTheWrittenLevel::test_a_file_that_decodes_above_full_scale_warns` |
 | Template audio-level placement | `workflows/templates/minimax/music-video.json`, `workflows/templates/minimax/music.json` | `normalize_audio` (-3 dBFS) acts only on the track that goes into the final file, so the slices that condition the shots are untouched. `music-video` slices each shot `lead_frames` early and `trim_video` drops the run-up before the join. | — |
 
 
@@ -115,14 +115,26 @@ def _fetch_audio_video(video_spec, base_dir=None):
     return video_spec
 
 
-def fetch_image(img_spec, base_dir=None):
+def _rgb_keeping_alpha(image):
+    """RGBA when the file carries transparency (an alpha band, or a palette
+    or greyscale image's transparency key), plain RGB otherwise."""
+    if "A" in image.getbands() or "transparency" in image.info:
+        return image.convert("RGBA")
+    return image.convert("RGB")
+
+
+def fetch_image(img_spec, base_dir=None, keep_alpha=False):
     """
     Load image from file path or URL with security validation.
 
     Args:
         img_spec: Image specification (file path, URL, dict with 'location' key, PIL Image, or list of any of these)
         base_dir: Directory relative file paths are resolved against - the
             workflow file's directory. Defaults to the process working directory
+        keep_alpha: Load a file with transparency as RGBA instead of
+            flattening it to RGB. A pipeline input wants RGB; the finishing
+            commands (grade, sharpen, film_grain, apply_lut) put the alpha
+            back after their op, so a cutout stays a cutout (#775)
 
     Returns:
         Loaded PIL Image, list of PIL Images, or None if img_spec is None
@@ -137,7 +149,7 @@ def fetch_image(img_spec, base_dir=None):
     # Handle lists of images (recursively process each)
     if isinstance(img_spec, list):
         logger.debug(f"Loading list of {len(img_spec)} images")
-        return [fetch_image(img, base_dir) for img in img_spec]
+        return [fetch_image(img, base_dir, keep_alpha) for img in img_spec]
 
     # If already a PIL Image, return as-is (allows multiple realize_args calls)
     if hasattr(img_spec, "mode") and hasattr(img_spec, "size"):
@@ -161,6 +173,7 @@ def fetch_image(img_spec, base_dir=None):
         return img_spec
 
     logger.debug(f"Loading image from: {img_spec}")
+    convert_method = _rgb_keeping_alpha if keep_alpha else None
 
     try:
         # Check if it's a URL
@@ -171,7 +184,7 @@ def fetch_image(img_spec, base_dir=None):
             # without re-checking them; load_image still does the EXIF
             # transpose and RGB conversion on the decoded result
             response = safe_get(img_spec, "an image argument", timeout=60)
-            return load_image(Image.open(io.BytesIO(response.content)))
+            return load_image(Image.open(io.BytesIO(response.content)), convert_method)
         else:
             # Treat as file path, relative to the workflow file, and confined
             # to the directories this workflow may read (dw/locations.py)
@@ -185,7 +198,7 @@ def fetch_image(img_spec, base_dir=None):
                     f"Image file extension not allowed: {ext} - a video file "
                     "must go through video_frames first"
                 )
-            return load_image(validated_path)
+            return load_image(validated_path, convert_method)
 
     except SecurityError:
         raise
 
@@ -872,7 +872,8 @@ def _load_media(media):
     a video extension is read with its audio, anything else as an image. A
     value that is not a string - a PIL Image, an AudioVideo, a frame list -
     is already loaded and comes back as itself. Shared by the finishing
-    commands that take `media` (#603).
+    commands that take `media` (#603). An image file with transparency loads
+    as RGBA, so the command puts its alpha back after the op (#775).
     """
     if not isinstance(media, str):
         return media
@@ -885,7 +886,7 @@ def _load_media(media):
         return load_audio_video(media)
     from ..argument_media import fetch_image
 
-    return fetch_image(media)
+    return fetch_image(media, keep_alpha=True)
 
 
 @register_command(
 
@@ -403,3 +403,59 @@ def test_the_new_domains_are_described_with_their_range_text(self):
 
 if __name__ == "__main__":
     pytest.main([__file__, "-v"])
+
+
+class TestRgbaFileKeepsAlpha:
+    """An RGBA file on disk - an asset:/output: path once resolved - loads with
+    its alpha, so the finishing commands hand it back untouched (#775). The
+    pipeline-input loader still flattens to RGB."""
+
+    @staticmethod
+    def _cutout(tmp_path):
+        rgb = numpy.full((16, 16, 3), 200, dtype=numpy.uint8)
+        alpha = numpy.zeros((16, 16), dtype=numpy.uint8)
+        alpha[4:12, 4:12] = 255
+        image = Image.fromarray(rgb).convert("RGBA")
+        image.putalpha(Image.fromarray(alpha))
+        path = tmp_path / "cutout.png"
+        image.save(path)
+        return str(path), alpha
+
+    @pytest.mark.parametrize(
+        "command, arguments",
+        [
+            ("grade", {"exposure": 0.5, "saturation": 0.5}),
+            ("film_grain", {"amount": 0.3, "seed": 1}),
+            ("apply_lut", {"palette": ["#102030", "#e0c090"]}),
+            ("sharpen", {"amount": 1.0}),
+        ],
+    )
+    def test_a_file_path_comes_back_rgba_with_its_alpha(
+        self, tmp_path, command, arguments
+    ):
+        path, alpha = self._cutout(tmp_path)
+        result = _run(command, path, **arguments)
+        assert result.mode == "RGBA"
+        assert numpy.array_equal(_array(result.getchannel("A")), alpha)
+
+    def test_an_opaque_file_still_loads_rgb(self, tmp_path):
+        from dw.tasks.task import _load_media
+
+        path = tmp_path / "opaque.png"
+        Image.new("RGB", (8, 8), "red").save(path)
+        assert _load_media(str(path)).mode == "RGB"
+
+    def test_a_palette_file_with_transparency_loads_rgba(self, tmp_path):
+        from dw.tasks.task import _load_media
+
+        path = tmp_path / "palette.png"
+        image = Image.new("P", (8, 8), 0)
+        image.info["transparency"] = 0
+        image.save(path, transparency=0)
+        assert _load_media(str(path)).mode == "RGBA"
+
+    def test_a_pipeline_input_still_flattens_to_rgb(self, tmp_path):
+        from dw.argument_media import fetch_image
+
+        path, _ = self._cutout(tmp_path)
+        assert fetch_image(path).mode == "RGB"