@@ -42,6 +42,7 @@
 from typing import Iterable, Optional, Sequence
 
 import edgtest
+import edgutil
 
 from edgacknowledg.forge import Forge, PullRequestInfo
 from edgacknowledg.forge.runner.roles import BUILD_STAGING_DIR, REVIEWS_DIR
@@ -75,6 +76,9 @@
 # reads all of that directory into memory, before we can count.
 MAX_ARTIFACT_ENTRIES = 100_000
 MAX_CENTRAL_DIRECTORY_BYTES = 16 * 1024 * 1024
+# Seconds a git process being stopped has to clean up (e.g. remove its lock
+# files) before it is killed; well within docker stop's default 10.
+_TERMINATE_ALLOWANCE = 5.0
 
 
 class WorkspaceError(Exception):
@@ -678,7 +682,9 @@ async def collect_garbage(self, repository: str, open_count: int) -> None:
 async def _communicate_bounded(process: asyncio.subprocess.Process,
                                limit: int) -> Optional[tuple[bytes, bytes]]:
   '''``process``'s output (stdout, stderr), once it exits; ``None``, having
-  killed it, should its stdout be over ``limit`` bytes.
+  stopped it, should its stdout be over ``limit`` bytes. Should this be
+  cancelled (or fail), it is stopped too, rather than left writing to a
+  pipe no one reads.
   '''
   assert process.stdout is not None and process.stderr is not None
   errors = asyncio.create_task(process.stderr.read())
@@ -688,13 +694,17 @@ async def _communicate_bounded(process: asyncio.subprocess.Process,
     while chunk := await process.stdout.read(64 * 1024):
       size += len(chunk)
       if size > limit:
-        process.kill()
+        await edgutil.async_terminate_within(process, _TERMINATE_ALLOWANCE)
         return None
       chunks.append(chunk)
-    return b''.join(chunks), await errors
+    output = b''.join(chunks), await errors
+    await process.wait()
+    return output
+  except BaseException:
+    await edgutil.async_terminate_within(process, _TERMINATE_ALLOWANCE)
+    raise
   finally:
     errors.cancel()
-    await process.wait()
 
 
 def basic_auth_header(user: str, password: str) -> str:
 
@@ -4,6 +4,7 @@
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
 import asyncio
+import contextlib
 import difflib
 import functools
 import json
@@ -470,6 +471,24 @@ async def run_task_consumer() -> Any:
     asyncio.shield(loop.create_task(run_task_consumer()))
   )
 
+async def async_terminate_within(process: asyncio.subprocess.Process,
+                                 allowance: float) -> int:
+  '''Terminate ``process`` (SIGTERM, so it may clean up, e.g. remove its
+  lock files), killing it should it not exit within ``allowance`` seconds;
+  return its exit status once it has exited.  A process that has already
+  exited is left alone.
+  '''
+  if process.returncode is None:
+    # Raised should asyncio already be done with it (its transport closed).
+    with contextlib.suppress(ProcessLookupError):
+      process.terminate()
+    try:
+      await asyncio.wait_for(process.wait(), allowance)
+    except asyncio.TimeoutError:
+      with contextlib.suppress(ProcessLookupError):
+        process.kill()
+  return await process.wait()
+
 def handle_proc_cancel(proc: Optional[asyncio.subprocess.Process]) -> bool:
   '''Terminate the given process prematurely.
 
 
@@ -8,6 +8,7 @@
 import asyncio
 import io
 import os
+import signal
 import stat
 import tarfile
 import zipfile
@@ -270,8 +271,29 @@ async def run(*argv: str, limit: int) -> object:
 
   assert await run('sh', '-c', 'printf out; printf err >&2',
                    limit = 3) == (b'out', b'err')
-  # One that would never stop is stopped.
-  assert await run('yes', limit = 1024 * 1024) is None
+  # One that would never stop is stopped (letting it clean up).
+  process = await asyncio.create_subprocess_exec(
+    'yes',
+    stdout = asyncio.subprocess.PIPE,
+    stderr = asyncio.subprocess.PIPE
+  )
+  assert await _communicate_bounded(process, 1024 * 1024) is None
+  assert process.returncode == -signal.SIGTERM
+
+
+async def test_cancelled_git_output_reads_stop_git() -> None:
+  # As when the service stops while git still has output to write: left
+  # writing to a pipe no one reads, it would never exit.
+  process = await asyncio.create_subprocess_exec(
+    'yes',
+    stdout = asyncio.subprocess.PIPE,
+    stderr = asyncio.subprocess.PIPE
+  )
+  reading = asyncio.create_task(_communicate_bounded(process, 1 << 40))
+  await asyncio.sleep(0.2)
+  reading.cancel()
+  await asyncio.wait_for(asyncio.gather(reading, return_exceptions = True), 10)
+  assert process.returncode == -signal.SIGTERM
 
 
 def test_ci_reads_are_capped(tmp_path: Path,
 
@@ -0,0 +1,46 @@
+# Part of the EDG Compiler Project, under the Apache License v2.0 with LLVM
+# Exceptions.
+# See https://edgcpp.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+'''Tests for edgutil.async_terminate_within.
+
+Run with: python3 -m unittest discover -s dev_tools/tests
+(with dev_tools/pylibs on PYTHONPATH).
+'''
+
+import asyncio
+import signal
+import time
+import unittest
+
+import edgutil
+
+class TerminateWithinTests(unittest.IsolatedAsyncioTestCase):
+  async def test_terminates(self) -> None:
+    process = await asyncio.create_subprocess_exec('sleep', '30')
+    started = time.monotonic()
+    status = await edgutil.async_terminate_within(process, 5)
+    self.assertEqual(status, -signal.SIGTERM)
+    self.assertLess(time.monotonic() - started, 2)
+
+  async def test_kills_what_outlasts_its_allowance(self) -> None:
+    # It ignores SIGTERM (as exec keeps ignored signals ignored).
+    process = await asyncio.create_subprocess_exec(
+      'sh', '-c', 'trap "" TERM; echo ready; exec sleep 30',
+      stdout = asyncio.subprocess.PIPE
+    )
+    assert process.stdout is not None
+    self.assertEqual(await process.stdout.readline(), b'ready\n')
+    started = time.monotonic()
+    status = await edgutil.async_terminate_within(process, 0.5)
+    self.assertEqual(status, -signal.SIGKILL)
+    self.assertGreaterEqual(time.monotonic() - started, 0.5)
+
+  async def test_leaves_what_has_exited(self) -> None:
+    process = await asyncio.create_subprocess_exec('true')
+    await process.wait()
+    self.assertEqual(await edgutil.async_terminate_within(process, 5), 0)
+
+if __name__ == '__main__':
+  unittest.main()