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,75 @@ 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.
+
+    ``commitizen.changelog.get_oldest_and_newest_rev`` picks the previous-
+    release tag by walking the creatordate-sorted tag list. When the
+    production call site feeds that function an unfiltered ``git.get_tags()``
+    result, a parallel maintenance branch's tag with a creatordate between
+    the current release and the legitimate previous release is wrongly
+    picked. The fix is to pass ``reachable_only=True`` so unreachable
+    parallel-line tags are filtered out before the sort.
+    """
+    # 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 we set. Drive git
+    # directly via ``commitizen.cmd.run`` and restore the fixture-managed
+    # env afterward so subsequent ``util.tick`` keeps working.
+    from commitizen import cmd as _cmd
+
+    def _tag_at(tag, iso_date):
+        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")
+
+    # Act — call ``get_oldest_and_newest_rev`` with ``reachable_only=True``
+    # (the production call site after the fix). With ``reachable_only``,
+    # 4.12.0 is filtered out before the sort, so the previous-release tag
+    # is 5.3.1. Without it, the previous-release tag is 4.12.0.
+    from commitizen import git as cz_git
+    from commitizen.changelog import TagRules, get_oldest_and_newest_rev
+
+    rules = TagRules()
+    start_rev, end_rev = get_oldest_and_newest_rev(
+        cz_git.get_tags(reachable_only=True), "5.4.0", rules
+    )
+
+    # Assert — the previous-release tag must be 5.3.1 (the most recent
+    # ancestor of HEAD before 5.4.0), not 4.12.0.
+    assert end_rev == "5.4.0"
+    assert start_rev == "5.3.1"