Track upstream discovery state

tests/test_cache.py

@@ -1,7 +1,6 @@
-"""Tests for cache loading and saving."""
+"""Tests for SQLite-backed cache and package state."""
 
-import json
-import pytest
+import datetime
 from pathlib import Path
 
 import debian_todo
@@ -10,29 +9,22 @@ import debian_todo
 class TestLoadCache:
     """Tests for load_cache function."""
 
-    def test_returns_none_when_file_missing(self, tmp_path, monkeypatch):
-        cache_file = tmp_path / "cache.json"
-        monkeypatch.setattr(debian_todo, "CACHE_PATH", cache_file)
-
-        result = debian_todo.load_cache([])
-        assert result is None
-
-    def test_returns_none_on_invalid_json(self, tmp_path, monkeypatch):
-        cache_file = tmp_path / "cache.json"
-        cache_file.write_text("not valid json")
-        monkeypatch.setattr(debian_todo, "CACHE_PATH", cache_file)
+    def test_returns_none_when_db_missing(self, tmp_path, monkeypatch):
+        monkeypatch.setattr(debian_todo, "CACHE_PATH", tmp_path / "cache.sqlite3")
 
         result = debian_todo.load_cache([])
         assert result is None
 
     def test_returns_none_on_version_mismatch(self, tmp_path, monkeypatch):
-        cache_file = tmp_path / "cache.json"
-        cache_file.write_text(json.dumps({
-            "cache_version": debian_todo.CACHE_VERSION - 1,
-            "sources_mtimes": {},
-            "vcs_by_source": {},
-        }))
-        monkeypatch.setattr(debian_todo, "CACHE_PATH", cache_file)
+        db_path = tmp_path / "cache.sqlite3"
+        monkeypatch.setattr(debian_todo, "CACHE_PATH", db_path)
+        conn = debian_todo.get_db_connection()
+        with conn:
+            conn.execute(
+                "INSERT INTO metadata (key, value) VALUES ('source_cache_version', ?)",
+                (str(debian_todo.CACHE_VERSION - 1),),
+            )
+        conn.close()
 
         result = debian_todo.load_cache([])
         assert result is None
@@ -40,13 +32,19 @@ class TestLoadCache:
     def test_returns_none_when_mtime_mismatch(self, tmp_path, monkeypatch):
         source_file = tmp_path / "Sources"
         source_file.write_text("dummy")
-        cache_file = tmp_path / "cache.json"
-        cache_file.write_text(json.dumps({
-            "cache_version": debian_todo.CACHE_VERSION,
-            "sources_mtimes": {str(source_file): 0.0},
-            "vcs_by_source": {},
-        }))
-        monkeypatch.setattr(debian_todo, "CACHE_PATH", cache_file)
+        db_path = tmp_path / "cache.sqlite3"
+        monkeypatch.setattr(debian_todo, "CACHE_PATH", db_path)
+        conn = debian_todo.get_db_connection()
+        with conn:
+            conn.execute(
+                "INSERT INTO metadata (key, value) VALUES ('source_cache_version', ?)",
+                (str(debian_todo.CACHE_VERSION),),
+            )
+            conn.execute(
+                "INSERT INTO source_file_mtimes (path, mtime) VALUES (?, ?)",
+                (str(source_file), 0.0),
+            )
+        conn.close()
 
         result = debian_todo.load_cache([str(source_file)])
         assert result is None
@@ -57,64 +55,396 @@ class TestLoadCache:
         source_file = tmp_path / "Sources"
         source_file.write_text("dummy")
         mtime = os.path.getmtime(str(source_file))
-
-        cache_file = tmp_path / "cache.json"
-        cache_file.write_text(json.dumps({
-            "cache_version": debian_todo.CACHE_VERSION,
-            "sources_mtimes": {str(source_file): mtime},
-            "vcs_by_source": {
-                "foo": {"vcs_git": "python-team", "uploaders": "John <j@e.com>"}
-            },
-        }))
-        monkeypatch.setattr(debian_todo, "CACHE_PATH", cache_file)
+        db_path = tmp_path / "cache.sqlite3"
+        monkeypatch.setattr(debian_todo, "CACHE_PATH", db_path)
+        conn = debian_todo.get_db_connection()
+        with conn:
+            conn.execute(
+                "INSERT INTO metadata (key, value) VALUES ('source_cache_version', ?)",
+                (str(debian_todo.CACHE_VERSION),),
+            )
+            conn.execute(
+                "INSERT INTO source_file_mtimes (path, mtime) VALUES (?, ?)",
+                (str(source_file), mtime),
+            )
+            conn.execute(
+                """
+                INSERT INTO source_info_cache (source, team, uploaders, vcs_git)
+                VALUES (?, ?, ?, ?)
+                """,
+                ("foo", "python-team", "John <j@e.com>", "https://example.invalid/foo"),
+            )
+        conn.close()
 
         result = debian_todo.load_cache([str(source_file)])
-        assert result == {"foo": {"vcs_git": "python-team", "uploaders": "John <j@e.com>"}}
-
-    def test_normalizes_legacy_string_format(self, tmp_path, monkeypatch):
-        import os
-
-        source_file = tmp_path / "Sources"
-        source_file.write_text("dummy")
-        mtime = os.path.getmtime(str(source_file))
-
-        cache_file = tmp_path / "cache.json"
-        cache_file.write_text(json.dumps({
-            "cache_version": debian_todo.CACHE_VERSION,
-            "sources_mtimes": {str(source_file): mtime},
-            "vcs_by_source": {"foo": "python-team"},  # legacy string format
-        }))
-        monkeypatch.setattr(debian_todo, "CACHE_PATH", cache_file)
-
-        result = debian_todo.load_cache([str(source_file)])
-        assert result == {"foo": {"vcs_git": "python-team", "uploaders": ""}}
+        assert result == {
+            "foo": {
+                "team": "python-team",
+                "uploaders": "John <j@e.com>",
+                "vcs_git": "https://example.invalid/foo",
+            }
+        }
 
 
 class TestSaveCache:
     """Tests for save_cache function."""
 
-    def test_saves_cache_file(self, tmp_path, monkeypatch):
-        import os
-
+    def test_saves_cache_to_sqlite(self, tmp_path, monkeypatch):
         source_file = tmp_path / "Sources"
         source_file.write_text("dummy")
-        cache_file = tmp_path / "cache.json"
-        monkeypatch.setattr(debian_todo, "CACHE_PATH", cache_file)
+        db_path = tmp_path / "cache.sqlite3"
+        monkeypatch.setattr(debian_todo, "CACHE_PATH", db_path)
 
-        vcs_by_source = {"foo": {"vcs_git": "python-team", "uploaders": ""}}
+        vcs_by_source = {
+            "foo": {
+                "team": "python-team",
+                "uploaders": "",
+                "vcs_git": "https://example.invalid/foo",
+            }
+        }
         debian_todo.save_cache([str(source_file)], vcs_by_source)
 
-        assert cache_file.exists()
-        data = json.loads(cache_file.read_text())
-        assert data["cache_version"] == debian_todo.CACHE_VERSION
-        assert data["vcs_by_source"] == vcs_by_source
-        assert str(source_file) in data["sources_mtimes"]
+        conn = debian_todo.get_db_connection()
+        row = conn.execute(
+            "SELECT value FROM metadata WHERE key = 'source_cache_version'"
+        ).fetchone()
+        cached = conn.execute(
+            "SELECT source, team, uploaders, vcs_git FROM source_info_cache"
+        ).fetchone()
+        conn.close()
+
+        assert row["value"] == str(debian_todo.CACHE_VERSION)
+        assert dict(cached) == {
+            "source": "foo",
+            "team": "python-team",
+            "uploaders": "",
+            "vcs_git": "https://example.invalid/foo",
+        }
 
     def test_handles_missing_source_file(self, tmp_path, monkeypatch):
-        cache_file = tmp_path / "cache.json"
-        monkeypatch.setattr(debian_todo, "CACHE_PATH", cache_file)
+        db_path = tmp_path / "cache.sqlite3"
+        monkeypatch.setattr(debian_todo, "CACHE_PATH", db_path)
 
         debian_todo.save_cache(["/nonexistent/file"], {})
 
-        # Should not create cache file if source file is missing
-        assert not cache_file.exists()
+        result = debian_todo.load_cache([])
+        assert result is None
+
+
+class TestPackageState:
+    """Tests for package discovery tracking."""
+
+    def test_sync_records_first_seen_upstream_version(self, tmp_path, monkeypatch):
+        db_path = tmp_path / "cache.sqlite3"
+        monkeypatch.setattr(debian_todo, "CACHE_PATH", db_path)
+        seen_at = datetime.datetime(2026, 5, 5, 12, 0, tzinfo=datetime.timezone.utc)
+
+        debian_todo.sync_package_state(
+            [
+                {
+                    ":source": "foo",
+                    ":shortname": "newupstream_foo",
+                    ":type": "New upstream",
+                    ":details": "1.2.3 (currently in unstable: 1.2.2-1)",
+                }
+            ],
+            seen_at=seen_at,
+        )
+
+        discovery_map = debian_todo.load_package_discovery_map()
+        assert discovery_map == {
+            "foo": ("1.2.3", "2026-05-05T12:00:00Z", True)
+        }
+
+    def test_sync_preserves_discovery_time_for_same_version(
+        self, tmp_path, monkeypatch
+    ):
+        db_path = tmp_path / "cache.sqlite3"
+        monkeypatch.setattr(debian_todo, "CACHE_PATH", db_path)
+
+        debian_todo.sync_package_state(
+            [
+                {
+                    ":source": "foo",
+                    ":shortname": "newupstream_foo",
+                    ":details": "1.2.3",
+                }
+            ],
+            seen_at=datetime.datetime(
+                2026, 5, 5, 12, 0, tzinfo=datetime.timezone.utc
+            ),
+        )
+        debian_todo.sync_package_state(
+            [
+                {
+                    ":source": "foo",
+                    ":shortname": "newupstream_foo",
+                    ":details": "1.2.3",
+                }
+            ],
+            seen_at=datetime.datetime(
+                2026, 5, 6, 12, 0, tzinfo=datetime.timezone.utc
+            ),
+        )
+
+        discovery_map = debian_todo.load_package_discovery_map()
+        assert discovery_map["foo"] == ("1.2.3", "2026-05-05T12:00:00Z", True)
+
+    def test_sync_updates_discovery_time_when_version_changes(
+        self, tmp_path, monkeypatch
+    ):
+        db_path = tmp_path / "cache.sqlite3"
+        monkeypatch.setattr(debian_todo, "CACHE_PATH", db_path)
+
+        debian_todo.sync_package_state(
+            [
+                {
+                    ":source": "foo",
+                    ":shortname": "newupstream_foo",
+                    ":details": "1.2.3",
+                }
+            ],
+            seen_at=datetime.datetime(
+                2026, 5, 5, 12, 0, tzinfo=datetime.timezone.utc
+            ),
+        )
+        debian_todo.sync_package_state(
+            [
+                {
+                    ":source": "foo",
+                    ":shortname": "newupstream_foo",
+                    ":details": "1.2.4",
+                }
+            ],
+            seen_at=datetime.datetime(
+                2026, 5, 7, 8, 30, tzinfo=datetime.timezone.utc
+            ),
+        )
+
+        discovery_map = debian_todo.load_package_discovery_map()
+        assert discovery_map["foo"] == ("1.2.4", "2026-05-07T08:30:00Z", True)
+
+    def test_sync_without_discovery_recording_leaves_timestamp_empty(
+        self, tmp_path, monkeypatch
+    ):
+        db_path = tmp_path / "cache.sqlite3"
+        monkeypatch.setattr(debian_todo, "CACHE_PATH", db_path)
+
+        debian_todo.sync_package_state(
+            [
+                {
+                    ":source": "foo",
+                    ":shortname": "newupstream_foo",
+                    ":details": "1.2.3",
+                }
+            ],
+            seen_at=datetime.datetime(
+                2026, 5, 5, 12, 0, tzinfo=datetime.timezone.utc
+            ),
+            record_discovery=False,
+        )
+
+        discovery_map = debian_todo.load_package_discovery_map()
+        assert discovery_map["foo"] == (None, None, False)
+
+    def test_sorts_by_oldest_discovery_date(self, tmp_path, monkeypatch):
+        db_path = tmp_path / "cache.sqlite3"
+        monkeypatch.setattr(debian_todo, "CACHE_PATH", db_path)
+        debian_todo.sync_package_state(
+            [
+                {
+                    ":source": "older",
+                    ":shortname": "newupstream_older",
+                    ":details": "1.0.0",
+                },
+            ],
+            seen_at=datetime.datetime(
+                2026, 5, 6, 12, 0, tzinfo=datetime.timezone.utc
+            ),
+        )
+        debian_todo.sync_package_state(
+            [
+                {
+                    ":source": "newer",
+                    ":shortname": "newupstream_newer",
+                    ":details": "2.0.0",
+                },
+                {
+                    ":source": "older",
+                    ":shortname": "newupstream_older",
+                    ":details": "1.0.0",
+                },
+            ],
+            seen_at=datetime.datetime(
+                2026, 5, 5, 12, 0, tzinfo=datetime.timezone.utc
+            ),
+        )
+
+        sorted_items = debian_todo.sort_todo_list_by_discovery(
+            [
+                {
+                    ":source": "newer",
+                    ":shortname": "newupstream_newer",
+                    ":details": "2.0.0",
+                },
+                {
+                    ":source": "older",
+                    ":shortname": "newupstream_older",
+                    ":details": "1.0.0",
+                },
+            ]
+        )
+
+        assert [item[":source"] for item in sorted_items] == ["newer", "older"]
+
+    def test_save_watch_snapshot(self, tmp_path, monkeypatch):
+        db_path = tmp_path / "cache.sqlite3"
+        monkeypatch.setattr(debian_todo, "CACHE_PATH", db_path)
+        repo_dir = tmp_path / "pkg"
+        debian_dir = repo_dir / "debian"
+        debian_dir.mkdir(parents=True)
+        (debian_dir / "watch").write_text("Version: 5\n")
+
+        debian_todo.save_watch_snapshot("mypkg", repo_dir)
+
+        conn = debian_todo.get_db_connection()
+        row = conn.execute(
+            "SELECT watch_content FROM package_state WHERE source = ?",
+            ("mypkg",),
+        ).fetchone()
+        conn.close()
+        assert row["watch_content"] == "Version: 5\n"
+
+
+class TestListOutput:
+    """Tests for list output using discovery timestamps."""
+
+    def test_list_shows_discovery_datetime(self, tmp_path, monkeypatch):
+        db_path = tmp_path / "cache.sqlite3"
+        todo_path = tmp_path / "todo.json"
+        monkeypatch.setattr(debian_todo, "CACHE_PATH", db_path)
+        monkeypatch.setattr(debian_todo, "TODO_PATH", todo_path)
+        monkeypatch.setattr(debian_todo, "load_source_info_map", lambda: {})
+        monkeypatch.setattr(debian_todo, "load_notes", lambda: {})
+
+        todo_list = [
+            {
+                ":source": "foo",
+                ":shortname": "newupstream_foo",
+                ":details": "1.2.3 (currently in unstable: 1.2.2-1)",
+            }
+        ]
+        debian_todo.save_todo_list(todo_list)
+        debian_todo.sync_package_state(
+            todo_list,
+            seen_at=datetime.datetime(
+                2026, 5, 5, 12, 0, tzinfo=datetime.timezone.utc
+            ),
+            record_discovery=True,
+        )
+
+        class FakeConsole:
+            def __init__(self) -> None:
+                self.width = 80
+                self.output: list[str] = []
+
+            def print(self, message) -> None:
+                self.output.append(str(message))
+
+        fake_console = FakeConsole()
+        monkeypatch.setattr(debian_todo, "Console", lambda: fake_console)
+
+        debian_todo.list_todos(include_prerelease=False)
+
+        assert any("D: 2026-05-05 12:00 UTC" in line for line in fake_console.output)
+
+    def test_list_hides_pre_cutoff_discovery_datetime(self, tmp_path, monkeypatch):
+        db_path = tmp_path / "cache.sqlite3"
+        todo_path = tmp_path / "todo.json"
+        monkeypatch.setattr(debian_todo, "CACHE_PATH", db_path)
+        monkeypatch.setattr(debian_todo, "TODO_PATH", todo_path)
+        monkeypatch.setattr(debian_todo, "load_source_info_map", lambda: {})
+        monkeypatch.setattr(debian_todo, "load_notes", lambda: {})
+
+        todo_list = [
+            {
+                ":source": "foo",
+                ":shortname": "newupstream_foo",
+                ":details": "1.2.3 (currently in unstable: 1.2.2-1)",
+            }
+        ]
+        debian_todo.save_todo_list(todo_list)
+        debian_todo.sync_package_state(
+            todo_list,
+            seen_at=datetime.datetime(
+                2026, 5, 5, 12, 0, tzinfo=datetime.timezone.utc
+            ),
+            record_discovery=False,
+        )
+
+        class FakeConsole:
+            def __init__(self) -> None:
+                self.width = 80
+                self.output: list[str] = []
+
+            def print(self, message) -> None:
+                self.output.append(str(message))
+
+        fake_console = FakeConsole()
+        monkeypatch.setattr(debian_todo, "Console", lambda: fake_console)
+
+        debian_todo.list_todos(include_prerelease=False)
+
+        assert any("D: -" in line for line in fake_console.output)
+
+    def test_list_shows_post_cutoff_discovery_datetime_even_without_flag(
+        self, tmp_path, monkeypatch
+    ):
+        db_path = tmp_path / "cache.sqlite3"
+        todo_path = tmp_path / "todo.json"
+        monkeypatch.setattr(debian_todo, "CACHE_PATH", db_path)
+        monkeypatch.setattr(debian_todo, "TODO_PATH", todo_path)
+        monkeypatch.setattr(debian_todo, "load_source_info_map", lambda: {})
+        monkeypatch.setattr(debian_todo, "load_notes", lambda: {})
+
+        todo_list = [
+            {
+                ":source": "foo",
+                ":shortname": "newupstream_foo",
+                ":details": "1.2.3 (currently in unstable: 1.2.2-1)",
+            }
+        ]
+        debian_todo.save_todo_list(todo_list)
+        debian_todo.sync_package_state(
+            todo_list,
+            seen_at=datetime.datetime(
+                2026, 5, 5, 12, 1, tzinfo=datetime.timezone.utc
+            ),
+            record_discovery=False,
+        )
+        conn = debian_todo.get_db_connection()
+        with conn:
+            conn.execute(
+                """
+                UPDATE package_state
+                SET discovered_version = ?, discovered_at = ?, discovered_by_refresh = 0
+                WHERE source = ?
+                """,
+                ("1.2.3", "2026-05-05T12:01:00Z", "foo"),
+            )
+        conn.close()
+
+        class FakeConsole:
+            def __init__(self) -> None:
+                self.width = 80
+                self.output: list[str] = []
+
+            def print(self, message) -> None:
+                self.output.append(str(message))
+
+        fake_console = FakeConsole()
+        monkeypatch.setattr(debian_todo, "Console", lambda: fake_console)
+
+        debian_todo.list_todos(include_prerelease=False)
+
+        assert any("D: 2026-05-05 12:01 UTC" in line for line in fake_console.output)

tests/test_update_pkg.py

@@ -296,10 +296,20 @@ class TestValidatePackageInfo:
         monkeypatch.setattr(
             debian_todo,
             "load_source_info_map",
-            lambda: {"mypkg": {"vcs_git": "python-team", "uploaders": ""}},
+            lambda: {
+                "mypkg": {
+                    "team": "python-team",
+                    "vcs_git": "https://salsa.debian.org/python-team/deps/mypkg.git",
+                    "uploaders": "",
+                }
+            },
         )
         result = debian_todo.validate_package_info("mypkg")
-        assert result == {"vcs_git": "python-team", "uploaders": ""}
+        assert result == {
+            "team": "python-team",
+            "vcs_git": "https://salsa.debian.org/python-team/deps/mypkg.git",
+            "uploaders": "",
+        }
 
     def test_package_not_found(self, monkeypatch):
         """Test package not in source info map."""
@@ -313,7 +323,7 @@ class TestValidatePackageInfo:
         monkeypatch.setattr(
             debian_todo,
             "load_source_info_map",
-            lambda: {"mypkg": {"vcs_git": "", "uploaders": ""}},
+            lambda: {"mypkg": {"team": "", "vcs_git": "", "uploaders": ""}},
         )
         with pytest.raises(debian_todo.PackageNotFoundError) as exc_info:
             debian_todo.validate_package_info("mypkg")
@@ -326,7 +336,11 @@ class TestResolvePackageDirectories:
     def test_python_team_package(self, tmp_path, monkeypatch):
         """Test resolving directories for python-team package."""
         monkeypatch.setattr(debian_todo, "DEBIAN_SRC_BASE", tmp_path)
-        source_info = {"vcs_git": "python-team", "uploaders": ""}
+        source_info = {
+            "team": "python-team",
+            "vcs_git": "https://salsa.debian.org/python-team/deps/mypkg.git",
+            "uploaders": "",
+        }
         team_dir, pkg_dir, repo_dir = debian_todo.resolve_package_directories(
             "mypkg", source_info
         )
@@ -337,7 +351,11 @@ class TestResolvePackageDirectories:
     def test_homeassistant_team_package(self, tmp_path, monkeypatch):
         """Test resolving directories for homeassistant-team package."""
         monkeypatch.setattr(debian_todo, "DEBIAN_SRC_BASE", tmp_path)
-        source_info = {"vcs_git": "homeassistant-team", "uploaders": ""}
+        source_info = {
+            "team": "homeassistant-team",
+            "vcs_git": "https://salsa.debian.org/homeassistant-team/deps/ha-pkg.git",
+            "uploaders": "",
+        }
         team_dir, pkg_dir, repo_dir = debian_todo.resolve_package_directories(
             "ha-pkg", source_info
         )
@@ -352,7 +370,11 @@ class TestEnsurePackageCheckout:
     def test_successful_checkout(self, tmp_path):
         """Test successful package checkout."""
         pkg_dir = tmp_path / "python" / "mypkg"
-        source_info = {"vcs_git": "python-team", "uploaders": ""}
+        source_info = {
+            "team": "python-team",
+            "vcs_git": "https://salsa.debian.org/python-team/deps/mypkg.git",
+            "uploaders": "",
+        }
 
         with patch("debian_todo.run_command") as mock_run:
             debian_todo.ensure_package_checkout("mypkg", source_info, pkg_dir)
@@ -367,7 +389,11 @@ class TestEnsurePackageCheckout:
         """Test checkout when parent directory already exists."""
         pkg_dir = tmp_path / "python" / "mypkg"
         pkg_dir.mkdir(parents=True)
-        source_info = {"vcs_git": "python-team", "uploaders": ""}
+        source_info = {
+            "team": "python-team",
+            "vcs_git": "https://salsa.debian.org/python-team/deps/mypkg.git",
+            "uploaders": "",
+        }
 
         with patch("debian_todo.run_command") as mock_run:
             debian_todo.ensure_package_checkout("mypkg", source_info, pkg_dir)
@@ -399,7 +425,10 @@ class TestRunGbpPqWorkflow:
         """Test successful gbp pq import and switch."""
         with patch("debian_todo.run_command") as mock_run:
             debian_todo.run_gbp_pq_workflow(tmp_path)
-            assert mock_run.call_count == 2
+            assert mock_run.call_count == 3
+            mock_run.assert_any_call(
+                ["gbp", "pq", "drop"], tmp_path, "Import patch queue"
+            )
             mock_run.assert_any_call(
                 ["gbp", "pq", "import"], tmp_path, "Import patch queue"
             )
@@ -446,16 +475,12 @@ class TestRunPackageUpdates:
     """Tests for run_package_updates function."""
 
     def test_runs_all_updates(self, tmp_path):
-        """Test that all update functions are called."""
-        with patch("debian_todo.update_debian_control") as mock_control:
-            with patch("debian_todo.update_debian_copyright_year") as mock_copyright:
-                with patch("debian_todo.update_debian_watch") as mock_watch:
-                    with patch("debian_todo.add_salsa_ci") as mock_salsa:
-                        debian_todo.run_package_updates(tmp_path)
-                        mock_control.assert_called_once_with(tmp_path)
-                        mock_copyright.assert_called_once_with(tmp_path)
-                        mock_watch.assert_called_once_with(tmp_path)
-                        mock_salsa.assert_called_once_with(tmp_path)
+        """Test that the external package update helper is called."""
+        with patch("debian_todo.subprocess.run") as mock_run:
+            debian_todo.run_package_updates(tmp_path)
+            mock_run.assert_called_once_with(
+                ["update-debian-package"], check=True, text=True, cwd=tmp_path
+            )
 
 
 class TestUpdateDebianControl:
@@ -491,14 +516,14 @@ class TestUpdateDebianControl:
 
         # Verify Standards-Version was updated
         content = control_path.read_text()
-        assert "Standards-Version: 4.7.3" in content
+        assert "Standards-Version: 4.7.4" in content
 
     def test_no_changes_needed(self, tmp_path):
         """Test when no changes are needed."""
         debian_dir = tmp_path / "debian"
         debian_dir.mkdir()
         control_path = debian_dir / "control"
-        control_path.write_text("Source: mypkg\nStandards-Version: 4.7.3\n")
+        control_path.write_text("Source: mypkg\nStandards-Version: 4.7.4\n")
 
         with patch("debian_todo.run_command") as mock_run:
             debian_todo.update_debian_control(tmp_path)
@@ -736,7 +761,13 @@ class TestUpdatePackage:
         monkeypatch.setattr(
             debian_todo,
             "load_source_info_map",
-            lambda: {"mypkg": {"vcs_git": "python-team", "uploaders": ""}},
+            lambda: {
+                "mypkg": {
+                    "team": "python-team",
+                    "vcs_git": "https://salsa.debian.org/python-team/deps/mypkg.git",
+                    "uploaders": "",
+                }
+            },
         )
         monkeypatch.setattr(debian_todo, "DEBIAN_SRC_BASE", tmp_path)
 
@@ -761,27 +792,36 @@ class TestUpdatePackage:
         monkeypatch.setattr(debian_todo.shutil, "which", lambda _: "/usr/bin/tool")
 
         # Mock the update functions to avoid needing debian/ directory
-        with patch("debian_todo.run_package_updates"):
+        with patch("debian_todo.run_package_updates"), patch(
+            "debian_todo.save_watch_snapshot"
+        ):
             debian_todo.update_package("mypkg")
 
         # Check salsa checkout was called
         assert subprocess_calls[0][0] == ["salsa", "checkout", "python-team/deps/mypkg"]
         # Check gbp pq commands were called
-        assert subprocess_calls[1][0] == ["gbp", "pq", "import"]
-        assert subprocess_calls[2][0] == ["gbp", "pq", "switch"]
+        assert subprocess_calls[1][0] == ["gbp", "pq", "drop"]
+        assert subprocess_calls[2][0] == ["gbp", "pq", "import"]
+        assert subprocess_calls[3][0] == ["gbp", "pq", "switch"]
         # Check gbp import-orig was called
-        assert subprocess_calls[3][0] == [
+        assert subprocess_calls[4][0] == [
             "gbp", "import-orig", "--uscan", "--pristine-tar", "--no-interactive"
         ]
         # Check dch was called
-        assert subprocess_calls[4][0][0] == "dch"
+        assert subprocess_calls[5][0][0] == "dch"
 
     def test_existing_checkout_clean(self, tmp_path, monkeypatch):
         """Test updating a package that's already checked out and clean."""
         monkeypatch.setattr(
             debian_todo,
             "load_source_info_map",
-            lambda: {"mypkg": {"vcs_git": "homeassistant-team", "uploaders": ""}},
+            lambda: {
+                "mypkg": {
+                    "team": "homeassistant-team",
+                    "vcs_git": "https://salsa.debian.org/homeassistant-team/deps/mypkg.git",
+                    "uploaders": "",
+                }
+            },
         )
         monkeypatch.setattr(debian_todo, "DEBIAN_SRC_BASE", tmp_path)
 
@@ -806,7 +846,9 @@ class TestUpdatePackage:
         monkeypatch.setattr(debian_todo.shutil, "which", lambda _: "/usr/bin/tool")
 
         # Mock the update functions to avoid needing debian/ directory
-        with patch("debian_todo.run_package_updates"):
+        with patch("debian_todo.run_package_updates"), patch(
+            "debian_todo.save_watch_snapshot"
+        ):
             debian_todo.update_package("mypkg")
 
         # Should not call salsa checkout
@@ -815,17 +857,24 @@ class TestUpdatePackage:
 
         # Should call git status, gbp pq, gbp import-orig, dch
         assert subprocess_calls[0][0] == ["git", "status", "--porcelain"]
-        assert subprocess_calls[1][0] == ["gbp", "pq", "import"]
-        assert subprocess_calls[2][0] == ["gbp", "pq", "switch"]
-        assert subprocess_calls[3][0][0] == "gbp"
-        assert subprocess_calls[4][0][0] == "dch"
+        assert subprocess_calls[1][0] == ["gbp", "pq", "drop"]
+        assert subprocess_calls[2][0] == ["gbp", "pq", "import"]
+        assert subprocess_calls[3][0] == ["gbp", "pq", "switch"]
+        assert subprocess_calls[4][0][0] == "gbp"
+        assert subprocess_calls[5][0][0] == "dch"
 
     def test_existing_checkout_dirty(self, tmp_path, monkeypatch):
         """Test that update aborts if there are uncommitted changes."""
         monkeypatch.setattr(
             debian_todo,
             "load_source_info_map",
-            lambda: {"mypkg": {"vcs_git": "python-team", "uploaders": ""}},
+            lambda: {
+                "mypkg": {
+                    "team": "python-team",
+                    "vcs_git": "https://salsa.debian.org/python-team/deps/mypkg.git",
+                    "uploaders": "",
+                }
+            },
         )
         monkeypatch.setattr(debian_todo, "DEBIAN_SRC_BASE", tmp_path)
 
@@ -851,7 +900,13 @@ class TestUpdatePackage:
         monkeypatch.setattr(
             debian_todo,
             "load_source_info_map",
-            lambda: {"mypkg": {"vcs_git": "python-team", "uploaders": ""}},
+            lambda: {
+                "mypkg": {
+                    "team": "python-team",
+                    "vcs_git": "https://salsa.debian.org/python-team/deps/mypkg.git",
+                    "uploaders": "",
+                }
+            },
         )
         monkeypatch.setattr(debian_todo, "DEBIAN_SRC_BASE", tmp_path)
 
@@ -873,7 +928,13 @@ class TestUpdatePackage:
         monkeypatch.setattr(
             debian_todo,
             "load_source_info_map",
-            lambda: {"mypkg": {"vcs_git": "python-team", "uploaders": ""}},
+            lambda: {
+                "mypkg": {
+                    "team": "python-team",
+                    "vcs_git": "https://salsa.debian.org/python-team/deps/mypkg.git",
+                    "uploaders": "",
+                }
+            },
         )
         monkeypatch.setattr(debian_todo, "DEBIAN_SRC_BASE", tmp_path)
 
@@ -906,7 +967,13 @@ class TestUpdatePackage:
         monkeypatch.setattr(
             debian_todo,
             "load_source_info_map",
-            lambda: {"mypkg": {"vcs_git": "python-team", "uploaders": ""}},
+            lambda: {
+                "mypkg": {
+                    "team": "python-team",
+                    "vcs_git": "https://salsa.debian.org/python-team/deps/mypkg.git",
+                    "uploaders": "",
+                }
+            },
         )
         monkeypatch.setattr(debian_todo, "DEBIAN_SRC_BASE", tmp_path)