fix(changelog): skip unreachable tags when picking previous release

`cz changelog <version>` resolves the previous-release tag by walking
the creatordate-sorted tag list. When a parallel maintenance branch
carries a tag whose creatordate sits between the current release and
the legitimate previous release, that branch's tag was wrongly
picked because it was reachable from some commit, just not from HEAD.

`get_tags()` already supports a `reachable_only` flag that appends
`git tag --merged`. Pass it from the changelog path so unreachable
parallel-line tags are filtered out before the sort, mirroring the
behaviour of `get_latest_tag_name()` which already uses
`git describe --abbrev=0 --tags` (ancestry-based) for the same
reason.

Fixes #2083

Author: abhinav-dvp

commitizen/commands/changelog.py

@@ -209,7 +209,9 @@ def __call__(self) -> None:
         if not self.file_name:
             raise NotAllowed("filename is required.")
 
-        tags = self.tag_rules.get_version_tags(git.get_tags(), warn=True)
+        tags = self.tag_rules.get_version_tags(
+            git.get_tags(reachable_only=True), warn=True
+        )
         changelog_meta = changelog.Metadata()
         if self.incremental:
             changelog_meta = self.changelog_format.get_metadata(self.file_name)

tests/commands/test_changelog_command.py

@@ -1693,3 +1693,106 @@ def test_changelog_template_incremental_variable(
     util.run_cli("changelog", "--file-name", target, "--incremental")
     out = Path(target).read_text(encoding="utf-8")
     file_regression.check(out, extension=".incremental.md")
+
+
+@pytest.mark.usefixtures("tmp_commitizen_project")
+@pytest.mark.freeze_time("2026-09-02")
+def test_changelog_previous_release_skips_unreachable_tags(
+    config_path: Path,
+    changelog_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    util: UtilFixture,
+):
+    """Regression test for #2083.
+
+    ``cz changelog`` resolves the previous-release tag by walking the
+    creatordate-sorted tag list. A parallel maintenance branch's tag must
+    be skipped if it is not an ancestor of HEAD — otherwise the rendered
+    range pulls in commits from a branch that is not part of the current
+    release line.
+    """
+    # Arrange — bare tag format, then a parallel v4 line and a main line.
+    with config_path.open("a", encoding="utf-8") as f:
+        f.write('tag_format = "$version"\n')
+
+    # The fixture resets GIT_COMMITTER_DATE on every ``tick``/
+    # ``patch_env``, so ``util.create_tag`` would clobber the date set
+    # here. Drive ``git tag -a`` directly via ``cmd.run`` to keep the
+    # creatordate stable, then restore the fixture-managed env so
+    # subsequent ``util.tick`` calls keep advancing frozen time as
+    # expected.
+    from commitizen import cmd as _cmd
+
+    def _tag_at(tag, iso_date):
+        """Create an annotated tag pinned to ``iso_date`` regardless of the
+        fixture's frozen time, then restore the fixture env.
+        """
+        monkeypatch.setenv("GIT_COMMITTER_DATE", iso_date)
+        result = _cmd.run(["git", "tag", "-a", tag, "-m", tag])
+        assert result.return_code == 0, result.err
+        util.patch_env()
+
+    # Main line: 5.3.1, then branch off to v4, then 5.4.0.
+    util.create_file_and_commit("feat: main feature a")
+    _tag_at("5.3.1", "2026-06-29T00:00:00")
+
+    util.create_branch("v4")
+    util.switch_branch("v4")
+    util.create_file_and_commit("feat: v4 feature a")
+
+    util.switch_branch("master")
+    util.create_file_and_commit("feat: main feature b")
+    _tag_at("5.4.0", "2026-09-02T00:00:00")
+
+    # v4 line ships 4.12.0 between 5.3.1 and 5.4.0 in time. 4.12.0's tag
+    # is NOT an ancestor of master — it sits on the v4 branch HEAD which
+    # is never merged back.
+    util.switch_branch("v4")
+    util.create_file_and_commit("feat: v4 feature b")
+    _tag_at("4.12.0", "2026-07-14T00:00:00")
+    util.switch_branch("master")
+
+    # Spy on git.get_tags so the test fails when the production call site
+    # drops ``reachable_only=True``. Without the spy, reverting the
+    # production fix would still pass because the test only checks
+    # render output.
+    from commitizen import git as cz_git
+
+    get_tags_calls: list[dict] = []
+
+    real_get_tags = cz_git.get_tags
+
+    def _tracked_get_tags(*args, **kwargs):
+        """Wrap the real ``git.get_tags`` to record every call.
+
+        The wrap must call through the imported ``real_get_tags`` rather
+        than the module attribute, which the test itself patches and so
+        would recurse forever.
+        """
+        get_tags_calls.append({"args": args, "kwargs": kwargs})
+        return real_get_tags(*args, **kwargs)
+
+    monkeypatch.setattr("commitizen.commands.changelog.git.get_tags", _tracked_get_tags)
+
+    # Act — single-version form goes through ``get_oldest_and_newest_rev``
+    # because ``rev_range`` carries the version string.
+    util.run_cli("changelog", "5.4.0", "--file-name", str(changelog_path))
+    out = changelog_path.read_text(encoding="utf-8")
+
+    # Assert — the production call site must ask git for reachable tags
+    # only. If a future change drops ``reachable_only=True`` from the
+    # call site the spy flags it.
+    assert get_tags_calls, "production call site never invoked git.get_tags"
+    assert all(
+        call["kwargs"].get("reachable_only") is True for call in get_tags_calls
+    ), f"git.get_tags called without reachable_only=True: {get_tags_calls!r}"
+
+    # And the rendered output must contain the 5.4.0 entry whose body
+    # only carries main-line commits; the v4-line commits must not leak
+    # in via the wrong previous-release tag (which would otherwise
+    # include the 4.12.0 commit on the v4 branch once the date-sorted
+    # tag list resolves to 4.12.0 as the previous tag).
+    assert "## 5.4.0" in out
+    assert "main feature b" in out
+    assert "v4 feature a" not in out
+    assert "v4 feature b" not in out