fix: surface resolved_channel_latest into dev version metadata

ImageDevelopmentVersionFromDependency set resolved_channel_latest during
version resolution but relied on the base as_image_version(), which never
copied it into ImageVersion.metadata. Only the channel subclass wrote
metadata["channel_latest"], so dependency dev builds pinned to an older
version (via version_override) still emitted the floating {{ Channel }}
tag, pointing it at the wrong build.

Surface resolved_channel_latest into metadata from the base
as_image_version() so the CHANNEL_LATEST tag filter suppresses floating
channel tags for older-than-head dependency builds. getattr keeps this
safe for any future subclass that does not track a channel.

Add regression tests for the dependency channel_latest metadata (head vs
version_override) and cover the previously-untested matrix {{ Channel }}
tag patterns.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: ianpittwood

posit-bakery/posit_bakery/config/image/dev_version/base.py

@@ -275,6 +275,13 @@ def as_image_version(self):
 
         version = self.get_version()
         metadata = {}
+        # Dev versions that track a channel head expose resolved_channel_latest (set during
+        # version resolution). Surface it so floating {{ Channel }} tags are suppressed when the
+        # build targets an older-than-head version. getattr keeps this safe for any future
+        # subclass that does not track a channel; absence defaults is_channel_latest to True.
+        resolved_channel_latest = getattr(self, "resolved_channel_latest", None)
+        if resolved_channel_latest is not None:
+            metadata["channel_latest"] = resolved_channel_latest
         release_channel = self.get_release_channel()
         if release_channel is not None:
             metadata["release_channel"] = release_channel

posit-bakery/test/config/image/dev_version/test_dependency.py

@@ -317,6 +317,36 @@ def test_release_channel_in_metadata_when_channel_set(self, patch_requests_get):
         iv = dev.as_image_version()
         assert iv.metadata["release_channel"] == "daily"
 
+    def test_channel_latest_true_in_metadata_when_resolving_head(self, patch_requests_get):
+        """Resolving the latest version marks channel_latest True so floating Channel tags emit."""
+        dev = ImageDevelopmentVersionFromDependency(
+            parent=_mock_parent(),
+            dependency="positron",
+            prerelease=True,
+            channel="daily",
+            os=[_UBUNTU_24_OS],
+        )
+        iv = dev.as_image_version()
+        assert iv.metadata["channel_latest"] is True
+
+    def test_channel_latest_false_in_metadata_with_version_override(self):
+        """A dev build pinned to an older version must mark channel_latest False so the floating
+        Channel tag is suppressed (it should keep pointing at the head, not the pinned build).
+
+        Regression test: resolved_channel_latest was previously never surfaced into metadata, so
+        is_channel_latest defaulted to True and the floating Channel tag emitted for older pins.
+        """
+        dev = ImageDevelopmentVersionFromDependency(
+            parent=_mock_parent(),
+            dependency="positron",
+            channel="daily",
+            os=[_UBUNTU_24_OS],
+        )
+        # version_override short-circuits resolution, so no network call is made.
+        dev.version_override = "2020.01.0-1"
+        iv = dev.as_image_version()
+        assert iv.metadata["channel_latest"] is False
+
     def test_os_preserved(self, patch_requests_get):
         dev = ImageDevelopmentVersionFromDependency(
             parent=_mock_parent(),

posit-bakery/test/config/test_tag.py

@@ -158,6 +158,54 @@ def test_default_matrix_tag_patterns_includes_strip_patch_under_latest_patch_fil
         )
 
 
+def test_default_matrix_tag_patterns_includes_channel_patterns():
+    """Matrix tag patterns include floating {{ Channel }} patterns gated by CHANNEL_LATEST.
+
+    These give matrix dev images channel-head tags (e.g. "daily", "daily-min") that the
+    CHANNEL_LATEST filter suppresses for builds targeting an older-than-head version.
+    """
+    patterns = default_matrix_tag_patterns()
+    channel_patterns = [p for p in patterns if any("{{ Channel }}" in pat for pat in p.patterns)]
+
+    # The composite "{{ Version }}" axis is dropped for channel tags, so only the primary-reduced
+    # variants are emitted to avoid collisions across matrix combinations.
+    expected = {
+        (("{{ Channel }}-{{ Variant }}",), (TagPatternFilter.CHANNEL_LATEST, TagPatternFilter.PRIMARY_OS)),
+        (("{{ Channel }}-{{ OS }}",), (TagPatternFilter.CHANNEL_LATEST, TagPatternFilter.PRIMARY_VARIANT)),
+        (
+            ("{{ Channel }}",),
+            (TagPatternFilter.CHANNEL_LATEST, TagPatternFilter.PRIMARY_OS, TagPatternFilter.PRIMARY_VARIANT),
+        ),
+    }
+    assert {(tuple(p.patterns), tuple(p.only)) for p in channel_patterns} == expected
+
+    # Every channel pattern must be gated by CHANNEL_LATEST so older-than-head builds suppress them.
+    for pattern in channel_patterns:
+        assert TagPatternFilter.CHANNEL_LATEST in pattern.only, (
+            f"Channel pattern must be gated by CHANNEL_LATEST: {pattern.patterns} only={pattern.only}"
+        )
+
+
+def test_default_matrix_channel_patterns_render_with_channel():
+    """Channel patterns render floating channel tags when a Channel value is supplied."""
+    patterns = [p for p in default_matrix_tag_patterns() if any("{{ Channel }}" in pat for pat in p.patterns)]
+    rendered = []
+    for pattern in patterns:
+        rendered.extend(pattern.render(Channel="daily", OS="ubuntu2404", Variant="min"))
+
+    assert set(rendered) == {"daily-min", "daily-ubuntu2404", "daily"}
+
+
+def test_default_matrix_channel_patterns_render_nothing_without_channel():
+    """Channel patterns produce no tags when no Channel value is supplied (non-channel images)."""
+    patterns = [p for p in default_matrix_tag_patterns() if any("{{ Channel }}" in pat for pat in p.patterns)]
+    rendered = []
+    for pattern in patterns:
+        rendered.extend(pattern.render(Version="R4.3.3-python3.11.15", OS="ubuntu2404", Variant="min"))
+
+    assert rendered == []
+
+
 def test_default_matrix_tag_patterns_strip_patch_renders_minor_tags():
     """stripPatch-filtered tag patterns produce minor-only tags from composite matrix versions."""
     patterns = [p for p in default_matrix_tag_patterns() if TagPatternFilter.LATEST_PATCH in p.only]