fix(submodule): close repositories owned by update operations

The Windows Python 3.15 CI job failed to remove submodule checkouts because
persistent `cat-file` processes still used them as working directories.
`Submodule.update()` relied on collection of its temporary `Repo`, but
captured log records retained a `Head` argument and therefore the repository
and its process. Recursive updates also opened an extra unbounded repository.

Close the owned repository after updates and on errors, and reuse it for
recursion with final cleanup. This preserves `keep_going` behavior while
releasing processes even when logs or callbacks retain repository objects.
The compatibility test now scopes its own repository and closes it before
removal; allocation tracing identified those separate caller-owned handles.

Four regressions retain real logging arguments and verify process cleanup
for normal, failing, recursive, and recursive `keep_going` updates. Both
previously failing tests pass with tracing asserting no live checkout
processes at each removal. Ruff, mypy, basedpyright, and `git diff --check`
pass locally. Native Windows validation will run in CI.

Author: codex

git/objects/submodule/base.py

@@ -1195,17 +1195,19 @@ def fetch_remotes(module_repo: "Repo") -> None:
                 )
             # END update to new commit only if needed
         except Exception as err:
+            if mrepo is not None:
+                mrepo.close()
             if not keep_going:
                 raise
             _logger.error(str(err))
         # END handle keep_going
 
         # HANDLE RECURSION
         ##################
-        if recursive:
+        try:
             # In dry_run mode, the module might not exist.
-            if mrepo is not None:
-                for submodule in self.iter_items(self.module()):
+            if recursive and mrepo is not None:
+                for submodule in self.iter_items(mrepo):
                     submodule.update(
                         recursive,
                         init,
@@ -1218,7 +1220,11 @@ def fetch_remotes(module_repo: "Repo") -> None:
                     )
                 # END handle recursive update
             # END handle dry run
-        # END for each submodule
+        finally:
+            # Log records and progress callbacks can retain refs to this repository.
+            # Its cat-file processes must not keep the checkout open on Windows.
+            if mrepo is not None:
+                mrepo.close()
 
         return self
 

test/test_submodule.py

@@ -658,6 +658,53 @@ def capture_process(self, command, *args, **kwargs):
             process.wait()
 
 
+@pytest.mark.parametrize("operation", ["update", "error", "recursive", "keep-going"])
+def test_update_closes_checkout_processes_retained_by_logging(movable_submodule, monkeypatch, caplog, operation):
+    sm = movable_submodule
+    recursive = operation in ("recursive", "keep-going")
+    with sm.module() as module:
+        module.head.reference.set_tracking_branch(None)
+        if recursive:
+            child = module.create_submodule("child", "child", sm.url)
+            module.index.commit("Add child")
+            sm.binsha = module.head.commit.binsha
+            with child.module() as nested:
+                nested.head.reference.set_tracking_branch(None)
+    if operation in ("error", "keep-going"):
+        sm.binsha = b"\x01" * len(sm.binsha)
+
+    checkout = Path(sm.abspath).resolve()
+    execute = Git.execute
+    processes = []
+
+    def capture_process(self, command, *args, **kwargs):
+        result = execute(self, command, *args, **kwargs)
+        if kwargs.get("as_process") and "cat-file" in command:
+            working_dir = Path(self.working_dir).resolve()
+            if working_dir == checkout or checkout in working_dir.parents:
+                processes.append(result.proc)
+        return result
+
+    monkeypatch.setattr(Git, "execute", capture_process)
+    try:
+        if operation == "error":
+            with pytest.raises(GitCommandError):
+                sm.update(to_latest_revision=True, no_fetch=True)
+        else:
+            sm.update(to_latest_revision=True, no_fetch=True, recursive=recursive, keep_going=operation == "keep-going")
+        # These records retain Head arguments and their internally opened Repos.
+        # Collection cannot release the processes while the records remain alive.
+        records = [record for record in caplog.records if "a tracking branch was not set" in record.msg]
+        assert len(records) == (2 if recursive else 1)
+        assert processes
+        assert all(process.poll() is not None for process in processes)
+    finally:
+        for process in processes:
+            if process.poll() is None:
+                process.terminate()
+            process.wait()
+
+
 @pytest.fixture
 def windows_directory_symlink_removal(monkeypatch):
     """Exercise Windows rmdir semantics on POSIX, where rmdir rejects symlinks."""
@@ -1927,13 +1974,14 @@ def assert_exists(sm, value=True):
         assert_exists(sm)
 
         # Add additional submodule level.
-        csm = sm.module().create_submodule(
-            "nested-submodule",
-            join_path_native("nested-submodule", "working-tree"),
-            url=self._small_repo_url(),
-        )
-        sm.module().index.commit("added nested submodule")
-        sm_head_commit = sm.module().commit()
+        with sm.module() as module:
+            csm = module.create_submodule(
+                "nested-submodule",
+                join_path_native("nested-submodule", "working-tree"),
+                url=self._small_repo_url(),
+            )
+            module.index.commit("added nested submodule")
+            sm_head_commit = module.commit()
         assert_exists(csm)
 
         # Fails because there are new commits, compared to the remote we cloned from.
@@ -1963,6 +2011,7 @@ def assert_exists(sm, value=True):
 
         # remove
         sm_module_path = sm.module().git_dir
+        csm.repo.close()
 
         for dry_run in (True, False):
             sm.remove(dry_run=dry_run, force=True)