From adbad124782a17db42449e5ccb164e855d231b98 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Mon, 11 Aug 2025 22:21:49 +0200
Subject: [PATCH 1/8] github templates: fix typos and grammar

---
 .github/ISSUE_TEMPLATE.md     | 36 +++++++++++++++++------------------
 .github/PULL_REQUEST_TEMPLATE | 10 +++++-----
 2 files changed, 22 insertions(+), 24 deletions(-)

diff --git a/.github/ISSUE_TEMPLATE.md b/.github/ISSUE_TEMPLATE.md
index 455c8535bc..1e55fc065f 100644
--- a/.github/ISSUE_TEMPLATE.md
+++ b/.github/ISSUE_TEMPLATE.md
@@ -1,56 +1,54 @@
 <!--
 Thank you for reporting an issue.
 
-*IMPORTANT* -  *before* creating a new issue please look around:
- - Borgbackup documentation: http://borgbackup.readthedocs.io/en/stable/index.html
+*IMPORTANT* – Before creating a new issue, please look around:
+ - BorgBackup documentation: https://borgbackup.readthedocs.io/en/stable/index.html
  - FAQ: https://borgbackup.readthedocs.io/en/stable/faq.html
- and
- - open issues in GitHub tracker: https://github.com/borgbackup/borg/issues
-  
+ - Open issues in the GitHub tracker: https://github.com/borgbackup/borg/issues
+
 If you cannot find a similar problem, then create a new issue.
 
 Please fill in as much of the template as possible.
 -->
 
-## Have you checked borgbackup docs, FAQ, and open GitHub issues?
+## Have you checked the BorgBackup docs, FAQ, and open GitHub issues?
 
 No
 
-## Is this a BUG / ISSUE report or a QUESTION?
+## Is this a bug/issue report or a question?
 
-Invalid
+Bug/Issue/Question
 
-## System information. For client/server mode post info for both machines.
+## System information. For client/server mode, post info for both machines.
 
-#### Your borg version (borg -V).
+#### Your Borg version (borg -V).
 
 #### Operating system (distribution) and version.
 
-#### Hardware / network configuration, and filesystems used.
+#### Hardware/network configuration and filesystems used.
 
-#### How much data is handled by borg?
+#### How much data is handled by Borg?
 
-#### Full borg commandline that lead to the problem (leave away excludes and passwords)
+#### Full Borg command line that led to the problem (leave out excludes and passwords).
 
 
 ## Describe the problem you're observing.
 
 #### Can you reproduce the problem? If so, describe how. If not, describe troubleshooting steps you took before opening the issue.
 
-#### Include any warning/errors/backtraces from the system logs
+#### Include any warnings/errors/backtraces from the system logs
 
 <!--
 
-If this complaint relates to borg performance, please include CRUD benchmark
+If this complaint relates to Borg performance, please include CRUD benchmark
 results and any steps you took to troubleshoot.
-How to run benchmark: http://borgbackup.readthedocs.io/en/stable/usage/benchmark.html
+How to run the benchmark: https://borgbackup.readthedocs.io/en/stable/usage/benchmark.html
 
-*IMPORTANT* - Please mark logs and text output from terminal commands 
-or else GitHub will not display them correctly. 
+*IMPORTANT* – Please mark logs and terminal command output, otherwise GitHub will not display them correctly.
 An example is provided below.
 
 Example:
 ```
-this is an example how log text should be marked (wrap it with ```)
+this is an example of how log text should be marked (wrap it with ```)
 ```
 -->
diff --git a/.github/PULL_REQUEST_TEMPLATE b/.github/PULL_REQUEST_TEMPLATE
index f01ff53c61..d940a67be2 100644
--- a/.github/PULL_REQUEST_TEMPLATE
+++ b/.github/PULL_REQUEST_TEMPLATE
@@ -1,8 +1,8 @@
-Thank you for contributing code to Borg, your help is appreciated!
+Thank you for contributing code to Borg; your help is appreciated!
 
-Please, before you submit a pull request, make sure it complies with the
-guidelines given in our documentation:
+Before you submit a pull request, please make sure it complies with the
+guidelines in our documentation:
 
-https://borgbackup.readthedocs.io/en/latest/development.html#contributions
+https://borgbackup.readthedocs.io/en/stable/development.html#contributions
 
-**Please remove all above text before submitting your pull request.**
+**Please remove the text above before submitting your pull request.**

From f9ec04ddf6414c1c5de242d029b418a134c3083a Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Tue, 12 Aug 2025 11:15:11 +0200
Subject: [PATCH 2/8] github workflows: fix typos and grammar

---
 .github/workflows/black.yaml          |  2 +-
 .github/workflows/ci.yml              | 24 ++++++++++++------------
 .github/workflows/codeql-analysis.yml |  2 +-
 3 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/.github/workflows/black.yaml b/.github/workflows/black.yaml
index 6d473e0af3..da37981fef 100644
--- a/.github/workflows/black.yaml
+++ b/.github/workflows/black.yaml
@@ -1,5 +1,5 @@
 # https://black.readthedocs.io/en/stable/integrations/github_actions.html#usage
-# see also what we use locally, requirements.d/codestyle.txt - should be the same version here.
+# See also what we use locally in requirements.d/codestyle.txt — this should be the same version here.
 
 name: Lint
 
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 9fd6680e7d..869daa0e78 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -1,4 +1,4 @@
-# badge: https://github.com/borgbackup/borg/workflows/CI/badge.svg?branch=master
+# badge: https://github.com/borgbackup/borg/workflows/CI/badge.svg?branch=1.4-maint
 
 name: CI
 
@@ -97,7 +97,7 @@ jobs:
     steps:
     - uses: actions/checkout@v4
       with:
-        # just fetching 1 commit is not enough for setuptools-scm, so we fetch all
+        # Just fetching one commit is not enough for setuptools-scm, so we fetch all.
         fetch-depth: 0
     - name: Set up Python ${{ matrix.python-version }}
       uses: actions/setup-python@v5
@@ -206,7 +206,7 @@ jobs:
         include:
             - os: macos-14
               python-version: '3.11'
-              toxenv: py311-none  # note: no fuse testing, due to #6099, see also #6196.
+              toxenv: py311-none  # Note: no FUSE testing due to #6099; see also #6196.
 
     env:
       # Configure pkg-config to use OpenSSL from Homebrew
@@ -219,7 +219,7 @@ jobs:
     steps:
     - uses: actions/checkout@v4
       with:
-        # just fetching 1 commit is not enough for setuptools-scm, so we fetch all
+        # Just fetching one commit is not enough for setuptools-scm, so we fetch all
         fetch-depth: 0
     - name: Set up Python ${{ matrix.python-version }}
       uses: actions/setup-python@v5
@@ -243,21 +243,21 @@ jobs:
       run: |
         python -m pip install --upgrade pip setuptools wheel
         pip install -r requirements.d/development.txt
-    - name: Install borgbackup
+    - name: Install BorgBackup
       env:
-        # we already have that in the global env, but something is broken and overwrites that.
-        # so, set it here, again.
+        # We already have this in the global environment, but something overrides it.
+        # So set it here again.
         PKG_CONFIG_PATH: "/opt/homebrew/opt/openssl@3.0/lib/pkgconfig:$PKG_CONFIG_PATH"
       run: |
         pip install -ve .
-    - name: run tox env
+    - name: Run pytest via tox
       env:
-        # we already have that in the global env, but something is broken and overwrites that.
-        # so, set it here, again.
+        # We already have this in the global environment, but something overrides it.
+        # So set it here again.
         PKG_CONFIG_PATH: "/opt/homebrew/opt/openssl@3.0/lib/pkgconfig:$PKG_CONFIG_PATH"
         XDISTN: "6"
       run: |
-        # do not use fakeroot, but run as root. avoids the dreaded EISDIR sporadic failures. see #2482.
+        # Do not use fakeroot; run as root. Avoids the dreaded sporadic EISDIR failures; see #2482.
         #sudo -E bash -c "tox -e py"
         tox --skip-missing-interpreters
     - name: Upload coverage to Codecov
@@ -271,7 +271,7 @@ jobs:
 
   windows:
 
-    if: false  # can be used to temporary disable build
+    if: false  # can be used to temporarily disable the build
     runs-on: windows-latest
     timeout-minutes: 120
     needs: linux
diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml
index 2a7745259c..b760d85fd7 100644
--- a/.github/workflows/codeql-analysis.yml
+++ b/.github/workflows/codeql-analysis.yml
@@ -31,7 +31,7 @@ jobs:
     - name: Checkout repository
       uses: actions/checkout@v4
       with:
-        # just fetching 1 commit is not enough for setuptools-scm, so we fetch all
+        # Just fetching one commit is not enough for setuptools-scm, so we fetch all.
         fetch-depth: 0
     - name: Set up Python
       uses: actions/setup-python@v5

From ed73aa19d257cd60a5550c50ad294da91c461d71 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Tue, 12 Aug 2025 11:21:50 +0200
Subject: [PATCH 3/8] README: fix typos and grammar

---
 README.rst | 50 +++++++++++++++++++++++++-------------------------
 1 file changed, 25 insertions(+), 25 deletions(-)

diff --git a/README.rst b/README.rst
index a100c1c587..ee3859aa50 100644
--- a/README.rst
+++ b/README.rst
@@ -3,7 +3,7 @@ This is borg2!
 
 Please note that this is the README for borg2 / master branch.
 
-For the stable version's docs, please see there:
+For the stable version's docs, please see here:
 
 https://borgbackup.readthedocs.io/en/stable/
 
@@ -14,7 +14,7 @@ next-beta upgrade code, so you will have to delete and re-create repos).
 Thus, **DO NOT USE BORG2 FOR YOUR PRODUCTION BACKUPS!** Please help with
 testing it, but set it up *additionally* to your production backups.
 
-TODO: the screencasts need a remake using borg2, see there:
+TODO: the screencasts need a remake using borg2, see here:
 
 https://github.com/borgbackup/borg/issues/6303
 
@@ -35,7 +35,7 @@ See the `installation manual`_ or, if you have already
 downloaded Borg, ``docs/installation.rst`` to get started with Borg.
 There is also an `offline documentation`_ available, in multiple formats.
 
-.. _installation manual: https://borgbackup.readthedocs.org/en/stable/installation.html
+.. _installation manual: https://borgbackup.readthedocs.io/en/master/installation.html
 .. _offline documentation: https://readthedocs.org/projects/borgbackup/downloads
 
 Main features
@@ -78,7 +78,7 @@ Main features
     authenticity.
 
 **Obfuscation**
-    Optionally, borg can actively obfuscate e.g. the size of files / chunks to
+    Optionally, Borg can actively obfuscate, e.g., the size of files/chunks to
     make fingerprinting attacks more difficult.
 
 **Compression**
@@ -91,13 +91,13 @@ Main features
     * lzma (low speed, high compression)
 
 **Off-site backups**
-    Borg can store data on any remote host accessible over SSH.  If Borg is
-    installed on the remote host, big performance gains can be achieved
-    compared to using a network filesystem (sshfs, nfs, ...).
+    Borg can store data on any remote host accessible over SSH. If Borg is
+    installed on the remote host, significant performance gains can be achieved
+    compared to using a network file system (sshfs, NFS, ...).
 
-**Backups mountable as filesystems**
-    Backup archives are mountable as userspace filesystems for easy interactive
-    backup examination and restores (e.g. by using a regular file manager).
+**Backups mountable as file systems**
+    Backup archives are mountable as user-space file systems for easy interactive
+    backup examination and restores (e.g., by using a regular file manager).
 
 **Easy installation on multiple platforms**
     We offer single-file binaries that do not require installing anything -
@@ -108,7 +108,7 @@ Main features
     * FreeBSD
     * OpenBSD and NetBSD (no xattrs/ACLs support or binaries yet)
     * Cygwin (experimental, no binaries yet)
-    * Linux Subsystem of Windows 10 (experimental)
+    * Windows Subsystem for Linux (WSL) on Windows 10/11 (experimental)
 
 **Free and Open Source Software**
   * security and functionality can be audited independently
@@ -130,7 +130,7 @@ Create a new backup archive::
 
     $ borg create Monday1 ~/Documents
 
-Now doing another backup, just to show off the great deduplication::
+Now do another backup, just to show off the great deduplication::
 
     $ borg create -v --stats Monday2 ~/Documents
     Repository: /path/to/repo
@@ -144,31 +144,31 @@ Now doing another backup, just to show off the great deduplication::
     Deduplicated size: 520 B
 
 
-Helping, Donations and Bounties, becoming a Patron
+Helping, donations and bounties, becoming a Patron
 --------------------------------------------------
 
 Your help is always welcome!
 
 Spread the word, give feedback, help with documentation, testing or development.
 
-You can also give monetary support to the project, see there for details:
+You can also give monetary support to the project, see here for details:
 
 https://www.borgbackup.org/support/fund.html
 
 Links
 -----
 
-* `Main Web Site <https://borgbackup.readthedocs.org/>`_
+* `Main website <https://borgbackup.readthedocs.io/>`_
 * `Releases <https://github.com/borgbackup/borg/releases>`_,
   `PyPI packages <https://pypi.python.org/pypi/borgbackup>`_ and
-  `ChangeLog <https://github.com/borgbackup/borg/blob/master/docs/changes.rst>`_
-* `Offline Documentation <https://readthedocs.org/projects/borgbackup/downloads>`_
+  `Changelog <https://github.com/borgbackup/borg/blob/master/docs/changes.rst>`_
+* `Offline documentation <https://readthedocs.org/projects/borgbackup/downloads>`_
 * `GitHub <https://github.com/borgbackup/borg>`_ and
-  `Issue Tracker <https://github.com/borgbackup/borg/issues>`_.
-* `Web-Chat (IRC) <https://web.libera.chat/#borgbackup>`_ and
-  `Mailing List <https://mail.python.org/mailman/listinfo/borgbackup>`_
-* `License <https://borgbackup.readthedocs.org/en/stable/authors.html#license>`_
-* `Security contact <https://borgbackup.readthedocs.io/en/latest/support.html#security-contact>`_
+  `Issue tracker <https://github.com/borgbackup/borg/issues>`_.
+* `Web chat (IRC) <https://web.libera.chat/#borgbackup>`_ and
+  `Mailing list <https://mail.python.org/mailman/listinfo/borgbackup>`_
+* `License <https://borgbackup.readthedocs.io/en/master/authors.html#license>`_
+* `Security contact <https://borgbackup.readthedocs.io/en/master/support.html#security-contact>`_
 
 Compatibility notes
 -------------------
@@ -178,7 +178,7 @@ CHANGES (like when going from 0.x.y to 1.0.0 or from 1.x.y to 2.0.0).
 
 NOT RELEASED DEVELOPMENT VERSIONS HAVE UNKNOWN COMPATIBILITY PROPERTIES.
 
-THIS IS SOFTWARE IN DEVELOPMENT, DECIDE YOURSELF WHETHER IT FITS YOUR NEEDS.
+THIS IS SOFTWARE IN DEVELOPMENT, DECIDE FOR YOURSELF WHETHER IT FITS YOUR NEEDS.
 
 Security issues should be reported to the `Security contact`_ (or
 see ``docs/support.rst`` in the source distribution).
@@ -187,9 +187,9 @@ see ``docs/support.rst`` in the source distribution).
 
 |doc| |build| |coverage| |bestpractices|
 
-.. |doc| image:: https://readthedocs.org/projects/borgbackup/badge/?version=stable
+.. |doc| image:: https://readthedocs.org/projects/borgbackup/badge/?version=master
         :alt: Documentation
-        :target: https://borgbackup.readthedocs.org/en/stable/
+        :target: https://borgbackup.readthedocs.io/en/master/
 
 .. |build| image:: https://github.com/borgbackup/borg/workflows/CI/badge.svg?branch=master
         :alt: Build Status (master)

From dd06c0778926d9c140592317cf61a04e25a2bc51 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Tue, 12 Aug 2025 16:56:00 +0200
Subject: [PATCH 4/8] paperkey.html: fix typos, grammar, html structure
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The original markup included a paragraph element wrapping a block-level pre element, which is invalid per HTML’s content model (a p can only contain phrasing content; pre is flow content).

The fix separated text and pre blocks into valid sibling elements, ensuring no pre is nested inside a p.
---
 src/borg/paperkey.html | 37 +++++++++++++++++++------------------
 1 file changed, 19 insertions(+), 18 deletions(-)

diff --git a/src/borg/paperkey.html b/src/borg/paperkey.html
index 8dd818cbd0..4143bc7cd7 100644
--- a/src/borg/paperkey.html
+++ b/src/borg/paperkey.html
@@ -2,21 +2,21 @@
 <html moznomarginboxes mozdisallowselectionprint>
 <!--
     Notes:
-        This may never cause external network connections. Everything needs to included in this file.
-        No minified libraries. Everything needs to be auditable and in preferred form of modification.
+        This may never cause external network connections. Everything needs to be included in this file.
+        No minified libraries. Everything needs to be auditable and in the preferred form for modification.
 
         This file includes two libraries inline:
             Kazuhiko Arase's qrcode-generator library (unpatched)
             Chris Veness's sha256 implementation (locally modified to utf8Encode)
         Both are MIT licensed.
-        As this script doesn’t interact with any untrusted parties / components it should be safe to
-        use local embedded copies of these libraries.
+        As this script doesn’t interact with any untrusted parties or components, it should be safe to
+        use locally embedded copies of these libraries.
 -->
 
 
 <head>
 <title>BorgBackup Printable Key Template</title>
-<meta http-equiv="Content-Type" content="text/html; charset=Utf-8">
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 <script>
 // https://github.com/kazuhikoarase/qrcode-generator/blob/master/js/qrcode.js
 //---------------------------------------------------------------------
@@ -30,7 +30,7 @@
 // Licensed under the MIT license:
 //  http://www.opensource.org/licenses/mit-license.php
 //
-// The word 'QR Code' is registered trademark of
+// The word 'QR Code' is a registered trademark of
 // DENSO WAVE INCORPORATED
 //  https://www.denso-wave.com/qrcode/faqpatent-e.html
 //
@@ -2181,17 +2181,18 @@
 <body>
     <div id="settings">
         <div class="instructions">
-           <p>To create a printable key, either paste the contents of your keyfile or a key export in the text field
+           <p>To create a printable key, either paste the contents of your keyfile or a key export into the text field
            below, or select a key export file.</p>
-           <p>To create a key export use <pre>borg key export /path/to/repository exportfile.txt</pre></p>
-           <p>If you are using keyfile mode, keyfiles are usually stored in $HOME/.config/borg/keys/</p>
-           <p>You can edit the parts with light blue border in the print preview below by click into them.</p>
-           <p>Key security: This print template will never send anything to remote servers. But keep in mind, that printing
-              might involve computers that can store the printed image, for example with cloud printing services, or
-              networked printers.<p>
+           <p>To create a key export, use:</p>
+           <pre>borg key export /path/to/repository exportfile.txt</pre>
+           <p>If you are using keyfile mode, keyfiles are usually stored in $HOME/.config/borg/keys/.</p>
+           <p>You can edit the parts with a light blue border in the print preview below by clicking into them.</p>
+           <p>Key security: This print template will never send anything to remote servers. Keep in mind that printing
+              might involve computers that can store the printed image, such as cloud printing services or
+              networked printers.</p>
         </div>
         <div class="block">
-            <div id="keyfile_expander" style="display:none;"><a href="#" onclick="document.getElementById('keyfile').style.display='inline';document.getElementById('keyfile_expander').style.display='none';">show keyfile</a></div>
+            <div id="keyfile_expander" style="display:none;"><a href="#" onclick="document.getElementById('keyfile').style.display='inline';document.getElementById('keyfile_expander').style.display='none';">Show keyfile</a></div>
             <textarea id="keyfile" rows="10" cols="73"></textarea>
         </div>
         <div class="block">
@@ -2213,17 +2214,17 @@
         </div>
         <div>
             <input type="file" id="fileinput"/>
-            <input type="button" value="update" onclick="update()"/>
+            <input type="button" value="Update" onclick="update()"/>
         </div>
     </div>
 
     <div id="printout">
         <div id="title" contenteditable>BorgBackup Printable Key Backup</div>
-        <div contenteditable>To restore either scan the QR code below, decode it and import it using
+        <div contenteditable>To restore, either scan the QR code below, decode it, and import it using
 <pre>borg key import /path/to/repo scannedfile</pre>
 
-Or run
-<pre>borg key import --paper /path/to/repo</pre> and type in the text below.<br><br></div>
+Alternatively, run
+<pre>borg key import --paper /path/to/repo</pre> and type the text below.<br><br></div>
         <div id="typein"></div>
         <div id="spacer"></div>
         <div id="qr"></div>

From ff7f2ab2ab0850e4f7bda54a1adb5deca54f2ac8 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Tue, 12 Aug 2025 17:04:46 +0200
Subject: [PATCH 5/8] binary readme: fix typos and grammar

---
 docs/binaries/00_README.txt | 36 ++++++++++++++++++------------------
 1 file changed, 18 insertions(+), 18 deletions(-)

diff --git a/docs/binaries/00_README.txt b/docs/binaries/00_README.txt
index 7a3e25599c..56160e73d2 100644
--- a/docs/binaries/00_README.txt
+++ b/docs/binaries/00_README.txt
@@ -8,28 +8,28 @@ any dependencies.
 Download the correct files
 --------------------------
 
-amd64 / x86_64 architecture
+AMD64/x86_64 architecture
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 borg-linux-glibc241 Linux (built on Debian 13 "Trixie" with glibc 2.41)
 borg-linux-glibc236 Linux (built on Debian 12 "Bookworm" with glibc 2.36)
 borg-linux-glibc231 Linux (built on Debian 11 "Bullseye" with glibc 2.31)
-                    Note: you can also try them on other Linuxes with other glibc
-                    versions - as long as the glibc is compatible, they will work.
-                    If it doesn't work, try a borg 1.4.x or 1.2.x binary.
+                    Note: You can also try them on other Linux distributions with different glibc
+                    versions - as long as glibc is compatible, they will work.
+                    If it does not work, try a Borg 1.4.x or 1.2.x binary.
 
-borg-macos1012      macOS (built on macOS Sierra 10.12 with latest macFUSE from brew)
-                    To avoid signing issues download the file via command line OR
+borg-macos1012      macOS (built on macOS Sierra 10.12 with the latest macFUSE from Homebrew)
+                    To avoid signing issues, download the file via the command line or
                     remove the "quarantine" attribute after downloading:
-                    $ xattr -dr com.apple.quarantine borg-macos.tgz
+                    $ xattr -dr com.apple.quarantine borg-macos1012.tgz
 
 borg-freebsd14      FreeBSD (built on FreeBSD 14)
 
-*.tgz               similar to above, but built as a directory with files,
-                    not as a single self-extracting binary. using the directory
-                    build is faster and doesn't need as much space in the temp
+*.tgz               Similar to the above, but built as a directory with files,
+                    not as a single self-extracting binary. Using the directory
+                    build is faster and does not require as much space in the temporary
                     directory as the one-file build.
-*.asc               GnuPG signatures for *
+*.asc               GnuPG signatures for the files
 
 
 Verifying your download
@@ -39,7 +39,7 @@ Please check the GPG signature to make sure you received the binary as I have
 built it.
 
 To check the GPG signature, download both the binary and the corresponding
-*.asc file and then (on the shell) type, e.g.:
+*.asc file and then (on the shell) type, for example:
 
     gpg --recv-keys 9F88FB52FAF7B393
     gpg --verify borg-freebsd14.asc borg-freebsd14
@@ -49,18 +49,18 @@ The files are signed by:
 Thomas Waldmann <tw@waldmann-edv.de>
 GPG key fingerprint: 6D5B EF9A DD20 7580 5747 B70F 9F88 FB52 FAF7 B393
 
-My fingerprint is also in the footer of all my borgbackup mailing list posts.
+My fingerprint is also in the footer of all my BorgBackup mailing list posts.
 
 
 Installing
 ----------
 
 It is suggested that you rename or symlink the binary to just "borg".
-If you need "borgfs", just also symlink it to the same binary, it will
+If you need "borgfs", just also symlink it to the same binary; it will
 detect internally under which name it was invoked.
 
 On UNIX-like platforms, /usr/local/bin/ or ~/bin/ is a nice place for it,
-but you can invoke it from every place by giving a full path to it.
+but you can invoke it from anywhere by providing the full path to it.
 
 Make sure the file is readable and executable (chmod +rx borg on UNIX-like
 platforms).
@@ -69,7 +69,7 @@ platforms).
 Reporting issues
 ----------------
 
-Please first check the FAQ and whether a github issue already exists.
+Please first check the FAQ and whether a GitHub issue already exists.
 
 If you find a NEW issue, please open a ticket on our issue tracker:
 
@@ -81,6 +81,6 @@ There, please give:
 - a good description of what the issue is
 - a good description of how to reproduce your issue
 - a traceback with system info (if you have one)
-- your precise platform (CPU, 32/64bit?), OS, distribution, release
-- your python and (g)libc version
+- your precise platform (CPU, 32/64-bit?), OS, distribution, release
+- your Python and (g)libc versions
 

From 3120f9cd1c9abbaf4abd4d7a2f8185da3637aa54 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Sun, 24 Aug 2025 00:21:57 +0200
Subject: [PATCH 6/8] fixed typos and grammar (AI)

this was done by Junie AI.
---
 AUTHORS                                       |  4 +-
 Brewfile                                      |  4 +-
 MANIFEST.in                                   |  4 +-
 SECURITY.md                                   |  4 +-
 Vagrantfile                                   |  2 +-
 docs/3rd_party/README                         |  6 +-
 docs/Makefile                                 |  2 +-
 docs/_templates/globaltoc.html                |  2 +-
 docs/_templates/layout.html                   | 12 ++--
 docs/book.rst                                 |  4 +-
 docs/changes.rst                              | 30 ++++----
 docs/changes_0.x.rst                          | 20 +++---
 docs/changes_1.x.rst                          |  2 +-
 docs/conf.py                                  | 10 +--
 docs/deployment/automated-local.rst           | 54 +++++++-------
 docs/deployment/central-backup-server.rst     | 44 ++++++------
 docs/deployment/hosting-repositories.rst      | 16 ++---
 docs/deployment/image-backup.rst              | 22 +++---
 docs/deployment/non-root-user.rst             | 36 +++++-----
 docs/deployment/pull-backup.rst               | 38 +++++-----
 docs/development.rst                          | 10 +--
 docs/faq.rst                                  | 50 ++++++-------
 docs/index.rst                                |  2 +-
 docs/installation.rst                         |  8 +--
 docs/internals.rst                            |  8 +--
 docs/internals/data-structures.rst            | 16 ++---
 docs/internals/frontends.rst                  |  4 +-
 docs/internals/security.rst                   |  6 +-
 docs/introduction.rst                         |  6 +-
 docs/man_intro.rst                            |  4 +-
 docs/misc/benchmark-crud.txt                  |  4 +-
 docs/misc/create_chunker-params.txt           | 34 ++++-----
 docs/misc/internals-picture.txt               |  2 +-
 docs/misc/prune-example.txt                   | 18 ++---
 docs/quickstart.rst                           | 12 ++--
 docs/quickstart_example.rst.inc               | 16 ++---
 docs/usage.rst                                |  6 +-
 docs/usage/common-options.rst.inc             |  4 +-
 docs/usage/compact.rst                        |  2 +-
 docs/usage/create.rst                         | 16 ++---
 docs/usage/debug.rst                          |  6 +-
 docs/usage/delete.rst                         | 12 ++--
 docs/usage/general.rst                        | 12 ++--
 docs/usage/general/date-time.rst.inc          | 10 +--
 docs/usage/general/environment.rst.inc        | 22 +++---
 docs/usage/general/file-metadata.rst.inc      | 24 +++----
 docs/usage/general/file-systems.rst.inc       | 24 +++----
 docs/usage/general/logging.rst.inc            | 37 +++++-----
 .../general/positional-arguments.rst.inc      |  2 +-
 .../general/repository-locations.rst.inc      | 12 ++--
 docs/usage/general/repository-urls.rst.inc    | 38 +++++-----
 docs/usage/general/resources.rst.inc          | 72 +++++++++----------
 docs/usage/general/return-codes.rst.inc       | 10 +--
 docs/usage/mount.rst                          |  2 +-
 docs/usage/notes.rst                          | 44 ++++++------
 docs/usage/prune.rst                          | 24 +++----
 docs/usage/recreate.rst                       | 10 +--
 docs/usage/repo-compress.rst                  |  4 +-
 docs/usage/repo-create.rst                    | 10 +--
 docs/usage/serve.rst                          | 20 +++---
 docs/usage/tar.rst                            | 16 ++---
 docs/usage/transfer.rst                       | 18 ++---
 pyproject.toml                                | 10 +--
 scripts/borg.exe.spec                         | 10 +--
 scripts/errorlist.py                          |  2 +-
 scripts/glibc_check.py                        | 10 +--
 .../make-testdata/test_transfer_upgrade.sh    |  6 +-
 scripts/shell_completions/bash/borg           |  6 +-
 scripts/shell_completions/fish/borg.fish      | 12 ++--
 scripts/shell_completions/zsh/_borg           |  4 +-
 setup.py                                      | 12 ++--
 src/borg/__init__.py                          |  6 +-
 src/borg/__main__.py                          | 12 ++--
 src/borg/archive.py                           |  4 +-
 src/borg/archiver/__init__.py                 |  6 +-
 src/borg/archiver/_common.py                  | 20 +++---
 src/borg/archiver/analyze_cmd.py              | 24 +++----
 src/borg/archiver/benchmark_cmd.py            | 14 ++--
 src/borg/archiver/check_cmd.py                | 40 +++++------
 src/borg/archiver/compact_cmd.py              | 34 ++++-----
 src/borg/archiver/create_cmd.py               | 32 ++++-----
 src/borg/archiver/debug_cmd.py                | 34 ++++-----
 src/borg/archiver/delete_cmd.py               | 16 +++--
 src/borg/archiver/diff_cmd.py                 | 10 +--
 src/borg/archiver/extract_cmd.py              | 49 ++++++-------
 src/borg/archiver/help_cmd.py                 | 22 +++---
 src/borg/archiver/info_cmd.py                 |  4 +-
 src/borg/archiver/key_cmds.py                 | 30 ++++----
 src/borg/archiver/list_cmd.py                 | 12 ++--
 src/borg/archiver/lock_cmds.py                | 26 +++----
 src/borg/archiver/mount_cmds.py               | 58 +++++++--------
 src/borg/archiver/prune_cmd.py                | 10 +--
 src/borg/archiver/recreate_cmd.py             | 16 ++---
 src/borg/archiver/rename_cmd.py               |  8 ++-
 src/borg/archiver/repo_compress_cmd.py        |  6 +-
 src/borg/archiver/repo_create_cmd.py          | 46 ++++++------
 src/borg/archiver/repo_delete_cmd.py          | 16 +++--
 src/borg/archiver/repo_info_cmd.py            |  4 +-
 src/borg/archiver/repo_list_cmd.py            |  4 +-
 src/borg/archiver/repo_space_cmd.py           | 27 ++++---
 src/borg/archiver/serve_cmd.py                | 52 +++++++-------
 src/borg/archiver/tag_cmd.py                  | 12 ++--
 src/borg/archiver/tar_cmds.py                 |  7 +-
 src/borg/archiver/transfer_cmd.py             | 34 ++++-----
 src/borg/archiver/undelete_cmd.py             | 23 +++---
 src/borg/archiver/version_cmd.py              | 20 +++---
 src/borg/cache.py                             | 22 +++---
 src/borg/checksums.pyx                        |  4 +-
 src/borg/chunkers/__init__.py                 |  2 +-
 src/borg/chunkers/failing.py                  |  8 +--
 src/borg/chunkers/fixed.py                    |  4 +-
 src/borg/chunkers/reader.pyx                  | 17 +++--
 src/borg/compress.pyx                         |  2 +-
 src/borg/constants.py                         | 30 ++++----
 src/borg/crypto/file_integrity.py             |  8 +--
 src/borg/crypto/key.py                        |  2 +-
 src/borg/crypto/keymanager.py                 |  2 +-
 src/borg/crypto/low_level.pyx                 |  8 +--
 src/borg/fslocking.py                         |  8 +--
 src/borg/fuse.py                              |  4 +-
 src/borg/fuse_impl.py                         |  4 +-
 src/borg/hashindex.pyx                        | 16 ++---
 src/borg/helpers/__init__.py                  | 23 +++---
 src/borg/helpers/checks.py                    |  2 +-
 src/borg/helpers/datastruct.py                | 40 +++++------
 src/borg/helpers/errors.py                    |  8 +--
 src/borg/helpers/fs.py                        | 26 +++----
 src/borg/helpers/lrucache.py                  |  8 +--
 src/borg/helpers/misc.py                      | 20 +++---
 src/borg/helpers/msgpack.py                   | 37 +++++-----
 src/borg/helpers/nanorst.py                   |  8 +--
 src/borg/helpers/parseformat.py               | 10 +--
 src/borg/helpers/passphrase.py                | 12 ++--
 src/borg/helpers/process.py                   | 38 +++++-----
 src/borg/helpers/progress.py                  | 18 ++---
 src/borg/helpers/shellpattern.py              | 22 +++---
 src/borg/helpers/time.py                      | 23 +++---
 src/borg/helpers/yes_no.py                    | 36 +++++-----
 src/borg/item.pyx                             | 22 +++---
 src/borg/legacyremote.py                      |  8 +--
 src/borg/legacyrepository.py                  | 14 ++--
 src/borg/logger.py                            | 72 +++++++++----------
 src/borg/manifest.py                          |  2 +-
 src/borg/patterns.py                          |  6 +-
 src/borg/platform/__init__.py                 |  6 +-
 src/borg/platform/base.py                     | 56 +++++++--------
 src/borg/platform/darwin.pyx                  |  3 +-
 src/borg/platform/freebsd.pyx                 | 20 +++---
 src/borg/platform/linux.pyx                   |  4 +-
 src/borg/platform/posix.pyx                   | 13 ++--
 src/borg/platform/syncfilerange.pyx           |  2 +-
 src/borg/platform/windows.pyx                 |  4 +-
 src/borg/platform/xattr.py                    | 16 ++---
 src/borg/platformflags.py                     |  4 +-
 src/borg/repoobj.py                           |  4 +-
 src/borg/repository.py                        | 10 +--
 src/borg/selftest.py                          | 27 ++++---
 src/borg/storelocking.py                      | 29 ++++----
 src/borg/testsuite/__init__.py                |  4 +-
 src/borg/testsuite/archive_test.py            | 14 ++--
 src/borg/testsuite/archiver/__init__.py       | 28 ++++----
 .../testsuite/archiver/argparsing_test.py     |  2 +-
 src/borg/testsuite/archiver/check_cmd_test.py |  2 +-
 .../testsuite/archiver/corruption_test.py     |  2 +-
 .../testsuite/archiver/create_cmd_test.py     | 16 ++---
 .../testsuite/archiver/debug_cmds_test.py     |  2 +-
 src/borg/testsuite/archiver/disk_full_test.py | 20 +++---
 .../testsuite/archiver/extract_cmd_test.py    | 18 ++---
 src/borg/testsuite/archiver/info_cmd_test.py  |  2 +-
 src/borg/testsuite/archiver/key_cmds_test.py  |  2 +-
 src/borg/testsuite/archiver/lock_cmds_test.py |  6 +-
 src/borg/testsuite/archiver/prune_cmd_test.py | 14 ++--
 .../archiver/repo_compress_cmd_test.py        |  4 +-
 .../archiver/repo_delete_cmd_test.py          |  2 +-
 .../testsuite/archiver/repo_list_cmd_test.py  |  2 +-
 .../testsuite/archiver/repo_space_cmd_test.py | 12 ++--
 .../archiver/restricted_permissions_test.py   |  6 +-
 src/borg/testsuite/archiver/serve_cmd_test.py | 10 +--
 src/borg/testsuite/archiver/tar_cmds_test.py  |  4 +-
 .../testsuite/archiver/transfer_cmd_test.py   |  2 +-
 .../testsuite/archiver/undelete_cmd_test.py   |  4 +-
 src/borg/testsuite/benchmark_test.py          |  4 +-
 src/borg/testsuite/chunkers/__init__.py       | 12 ++--
 .../testsuite/chunkers/buzhash64_self_test.py |  4 +-
 src/borg/testsuite/chunkers/buzhash64_test.py |  4 +-
 .../testsuite/chunkers/buzhash_self_test.py   |  4 +-
 src/borg/testsuite/chunkers/buzhash_test.py   |  6 +-
 .../testsuite/chunkers/fixed_self_test.py     |  8 +--
 src/borg/testsuite/chunkers/fixed_test.py     |  2 +-
 src/borg/testsuite/chunkers/reader_test.py    |  2 +-
 src/borg/testsuite/compress_test.py           |  4 +-
 src/borg/testsuite/fslocking_test.py          |  8 +--
 src/borg/testsuite/hashindex_test.py          |  6 +-
 src/borg/testsuite/helpers/__init__test.py    |  4 +-
 src/borg/testsuite/helpers/datastruct_test.py | 16 ++---
 src/borg/testsuite/helpers/fs_test.py         |  4 +-
 src/borg/testsuite/helpers/misc_test.py       |  8 +--
 src/borg/testsuite/helpers/msgpack_test.py    | 12 ++--
 .../testsuite/helpers/parseformat_test.py     | 26 +++----
 src/borg/testsuite/helpers/process_test.py    |  2 +-
 .../testsuite/helpers/shellpattern_test.py    | 14 ++--
 src/borg/testsuite/helpers/time_test.py       | 14 ++--
 src/borg/testsuite/item_test.py               | 14 ++--
 src/borg/testsuite/legacyrepository_test.py   | 12 ++--
 src/borg/testsuite/logger_test.py             |  2 +-
 src/borg/testsuite/platform/darwin_test.py    |  2 +-
 src/borg/testsuite/platform/linux_test.py     |  6 +-
 src/borg/testsuite/platform/platform_test.py  |  8 +--
 src/borg/testsuite/remote_test.py             | 18 ++---
 src/borg/testsuite/repoobj_test.py            | 40 +++++------
 src/borg/testsuite/repository_test.py         | 10 +--
 src/borg/testsuite/shell_completions_test.py  | 24 +++----
 src/borg/testsuite/storelocking_test.py       |  8 +--
 src/borg/testsuite/version_test.py            | 10 +--
 src/borg/testsuite/xattr_test.py              | 12 ++--
 src/borg/upgrade.py                           |  2 +-
 src/borg/version.py                           |  4 +-
 src/borg/xattr.py                             | 14 ++--
 218 files changed, 1553 insertions(+), 1552 deletions(-)

diff --git a/AUTHORS b/AUTHORS
index 5378b3b6c0..a4094a2d24 100644
--- a/AUTHORS
+++ b/AUTHORS
@@ -1,5 +1,5 @@
-E-mail addresses listed here are not intended for support, please see
-the `support section`_ instead.
+Email addresses listed here are not intended for support.
+Please see the `support section`_ instead.
 
 .. _support section: https://borgbackup.readthedocs.io/en/stable/support.html
 
diff --git a/Brewfile b/Brewfile
index c04f5f9b40..ef0b6e1df5 100644
--- a/Brewfile
+++ b/Brewfile
@@ -5,8 +5,8 @@ brew 'xxhash'
 brew 'openssl@3.0'
 
 # osxfuse (aka macFUSE) is only required for "borg mount",
-# but won't work on github actions' workers.
-# it requires installing a kernel extension, so some users
+# but won't work on GitHub Actions' workers.
+# It requires installing a kernel extension, so some users
 # may want it and some won't.
 
 #cask 'osxfuse'
diff --git a/MANIFEST.in b/MANIFEST.in
index caf027ad90..4dff279ede 100644
--- a/MANIFEST.in
+++ b/MANIFEST.in
@@ -1,6 +1,6 @@
-# stuff we need to include into the sdist is handled automatically by
+# The files we need to include in the sdist are handled automatically by
 # setuptools_scm - it includes all git-committed files.
-# but we want to exclude some committed files/dirs not needed in the sdist:
+# But we want to exclude some committed files/directories not needed in the sdist:
 exclude .editorconfig .gitattributes .gitignore .mailmap Vagrantfile
 prune .github
 include src/borg/platform/darwin.c src/borg/platform/freebsd.c src/borg/platform/linux.c src/borg/platform/posix.c
diff --git a/SECURITY.md b/SECURITY.md
index b8ef827556..08a78b9329 100644
--- a/SECURITY.md
+++ b/SECURITY.md
@@ -2,7 +2,7 @@
 
 ## Supported Versions
 
-These borg releases are currently supported with security updates.
+These Borg releases are currently supported with security updates.
 
 | Version | Supported          |
 |---------|--------------------|
@@ -14,6 +14,6 @@ These borg releases are currently supported with security updates.
 
 ## Reporting a Vulnerability
 
-See there:
+See here:
 
 https://borgbackup.readthedocs.io/en/latest/support.html#security-contact
diff --git a/Vagrantfile b/Vagrantfile
index 4000b87926..300ea93158 100644
--- a/Vagrantfile
+++ b/Vagrantfile
@@ -1,7 +1,7 @@
 # -*- mode: ruby -*-
 # vi: set ft=ruby :
 
-# Automated creation of testing environments / binaries on misc. platforms
+# Automated creation of testing environments/binaries on miscellaneous platforms
 
 $cpus = Integer(ENV.fetch('VMCPUS', '8'))  # create VMs with that many cpus
 $xdistn = Integer(ENV.fetch('XDISTN', '8'))  # dispatch tests to that many pytest workers
diff --git a/docs/3rd_party/README b/docs/3rd_party/README
index 1f7b9b6ad9..de89008f32 100644
--- a/docs/3rd_party/README
+++ b/docs/3rd_party/README
@@ -1,5 +1,5 @@
-Here we store 3rd party documentation, licenses, etc.
+Here we store third-party documentation, licenses, etc.
 
-Please note that all files inside the "borg" package directory (except the
-stuff excluded in setup.py) will be INSTALLED, so don't keep docs or licenses
+Please note that all files inside the "borg" package directory (except those
+excluded in setup.py) will be installed, so do not keep docs or licenses
 there.
diff --git a/docs/Makefile b/docs/Makefile
index 09be16fcbc..283f9be71f 100644
--- a/docs/Makefile
+++ b/docs/Makefile
@@ -21,7 +21,7 @@ help:
 	@echo "  singlehtml to make a single large HTML file"
 	@echo "  pickle     to make pickle files"
 	@echo "  json       to make JSON files"
-	@echo "  htmlhelp   to make HTML files and a HTML help project"
+	@echo "  htmlhelp   to make HTML files and an HTML help project"
 	@echo "  qthelp     to make HTML files and a qthelp project"
 	@echo "  devhelp    to make HTML files and a Devhelp project"
 	@echo "  epub       to make an epub"
diff --git a/docs/_templates/globaltoc.html b/docs/_templates/globaltoc.html
index d10f5f77f4..663dfa5633 100644
--- a/docs/_templates/globaltoc.html
+++ b/docs/_templates/globaltoc.html
@@ -1,6 +1,6 @@
 <div class="sidebar-block">
   <div class="sidebar-toc">
-    {# Restrict the sidebar toc depth to two levels while generating command usage pages.
+    {# Restrict the sidebar ToC depth to two levels while generating command usage pages.
        This avoids superfluous entries for each "Description" and "Examples" heading. #}
     {% if pagename.startswith("usage/") and pagename not in (
       "usage/general", "usage/help", "usage/debug", "usage/notes",
diff --git a/docs/_templates/layout.html b/docs/_templates/layout.html
index 72a08de36f..15e9b98fe3 100644
--- a/docs/_templates/layout.html
+++ b/docs/_templates/layout.html
@@ -1,6 +1,6 @@
 {%- extends "basic/layout.html" %}
 
-{# Do this so that bootstrap is included before the main css file #}
+{# Do this so that Bootstrap is included before the main CSS file. #}
 {%- block htmltitle %}
   {% set script_files = script_files + ["_static/myscript.js"] %}
   <!-- Licensed under the Apache 2.0 License -->
@@ -20,7 +20,7 @@
   {{ super() }}
 {% endblock %}
 
-{# Displays the URL for the homepage if it's set or the master_doc if it is not #}
+{# Displays the URL for the homepage if it's set, or the master_doc if it is not. #}
 {% macro homepage() -%}
   {%- if theme_homepage %}
     {%- if hasdoc(theme_homepage) %}
@@ -33,7 +33,7 @@
   {%- endif %}
 {%- endmacro %}
 
-{# Displays the URL for the tospage if it's set or falls back to homepage macro #}
+{# Displays the URL for the tospage if it's set, or falls back to the homepage macro. #}
 {% macro tospage() -%}
   {%- if theme_tospage %}
     {%- if hasdoc(theme_tospage) %}
@@ -46,7 +46,7 @@
   {%- endif %}
 {%- endmacro %}
 
-{# Displays the URL for the projectpage if it's set or falls back to homepage macro #}
+{# Displays the URL for the projectpage if it's set, or falls back to the homepage macro. #}
 {% macro projectlink() -%}
   {%- if theme_projectlink %}
     {%- if hasdoc(theme_projectlink) %}
@@ -59,7 +59,7 @@
   {%- endif %}
 {%- endmacro %}
 
-{# Displays the next and previous links both before and after content #}
+{# Displays the next and previous links both before and after the content. #}
 {% macro render_relations() -%}
   {% if prev or next %}
   <div class="footer-relations">
@@ -82,7 +82,7 @@
   <div id="left-column">
     <div class="sphinxsidebar">
       {%- if sidebars != None %}
-        {#- new style sidebar: explicitly include/exclude templates #}
+        {#- New-style sidebar: explicitly include/exclude templates. #}
         {%- for sidebartemplate in sidebars %}
         {%- include sidebartemplate %}
         {%- endfor %}
diff --git a/docs/book.rst b/docs/book.rst
index 56b724b26d..1ac10b99ff 100644
--- a/docs/book.rst
+++ b/docs/book.rst
@@ -5,8 +5,8 @@
 Borg documentation
 ==================
 
-.. when you add an element here, do not forget to add it to index.rst
-.. Note: Some things are in appendices (see latex_appendices in conf.py)
+.. When you add an element here, do not forget to add it to index.rst.
+.. Note: Some things are in appendices (see latex_appendices in conf.py).
 
 .. toctree::
     :maxdepth: 2
diff --git a/docs/changes.rst b/docs/changes.rst
index e0410ce78c..0f0833fde0 100644
--- a/docs/changes.rst
+++ b/docs/changes.rst
@@ -17,7 +17,7 @@ borg 1.2.x/1.4.x to borg 2.0
 
 Compatibility notes:
 
-- this is a major "breaking" release that is not compatible with existing repos.
+- This is a major "breaking" release that is not compatible with existing repositories.
 
   We tried to put all the necessary "breaking" changes into this release, so we
   hopefully do not need another breaking release in the near future. The changes
@@ -33,24 +33,24 @@ Compatibility notes:
   you must have followed the upgrade instructions at top of the change log
   relating to manifest and archive TAMs (borg2 just requires these TAMs now).
 
-- command line syntax was changed, scripts and wrappers will need changes:
+- Command-line syntax was changed; scripts and wrappers will need changes:
 
-  - you will usually either export BORG_REPO=<MYREPO> into your environment or
+  - You will usually either export BORG_REPO=<MYREPO> into your environment or
     call borg like: "borg -r <MYREPO> <COMMAND>".
-    in the docs, we usually omit "-r ..." for brevity.
-  - the scp-style REPO syntax was removed, please use ssh://..., #6697
-  - ssh:// URLs: removed support for /~otheruser/, /~/ and /./, #6855.
+    In the docs, we usually omit "-r ..." for brevity.
+  - The scp-style REPO syntax was removed; please use ssh://..., #6697
+  - ssh:// URLs: Removed support for /~otheruser/, /~/ and /./, #6855.
     New format:
 
     - ssh://user@host:port/relative/path
     - ssh://user@host:port//absolute/path
-  - -P / --prefix option was removed, please use the similar -a / --match-archives.
-  - archive names don't need to be unique anymore. to the contrary:
-    it is now strongly recommended to use the identical name for borg create
+  - -P / --prefix option was removed; please use the similar -a / --match-archives.
+  - Archive names don't need to be unique anymore. To the contrary:
+    It is now strongly recommended to use the identical name for borg create
     within the same series of archives to make borg work more efficiently.
-    the name now identifies a series of archive, to identify a single archive
-    please use aid:<archive-hash-prefix>, e.g.: borg delete aid:d34db33f
-  - in case you do NOT want to adopt the "series name" way of naming archives
+    The name now identifies a series of archives; to identify a single archive,
+    please use aid:<archive-hash-prefix>, e.g., borg delete aid:d34db33f
+  - In case you do NOT want to adopt the "series name" way of naming archives
     (like "myarchive") as we recommend, but keep using always-changing names
     (like "myserver-myarchive-20241231"), you can do that, but then you must
     make use of BORG_FILES_CACHE_SUFFIX and either set it to a constant suffix
@@ -60,9 +60,9 @@ Compatibility notes:
     greater than the count of different archives series you write to that repo.
     Usually borg uses a different files cache suffix per archive (series) name
     and defaults to BORG_FILES_CACHE_TTL=2 because that is sufficient for that.
-  - the archive id is always given separately from the repository
-    (differently than with borg 1.x you must not give repo::archive).
-  - the series name or archive id is either given as a positional parameter,
+  - The archive ID is always given separately from the repository.
+    Unlike in borg 1.x, you must not give repo::archive.
+  - The series name or archive ID is either given as a positional parameter,
     like:
 
     - borg create documents ~/Documents
diff --git a/docs/changes_0.x.rst b/docs/changes_0.x.rst
index 39290a1105..ecf6c0c775 100644
--- a/docs/changes_0.x.rst
+++ b/docs/changes_0.x.rst
@@ -11,9 +11,9 @@ Compatibility notes:
 - The new default logging level is WARNING. Previously, it was INFO, which was
   more verbose. Use -v (or --info) to show once again log level INFO messages.
   See the "general" section in the usage docs.
-- for borg create, you need --list (additionally to -v) to see the long file
+- For borg create, you need --list (in addition to -v) to see the long file
   list (was needed so you can have e.g. --stats alone without the long list)
-- see below about BORG_DELETE_I_KNOW_WHAT_I_AM_DOING (was:
+- See below about BORG_DELETE_I_KNOW_WHAT_I_AM_DOING (was:
   BORG_CHECK_I_KNOW_WHAT_I_AM_DOING)
 
 Bug fixes:
@@ -48,7 +48,7 @@ New features:
 - update progress indication more often (e.g. for borg create within big
   files or for borg check repo), #500
 - finer chunker granularity for items metadata stream, #547, #487
-- borg create --list now used (additionally to -v) to enable the verbose
+- borg create --list is now used (in addition to -v) to enable the verbose
   file list output
 - display borg version below tracebacks, #532
 
@@ -86,17 +86,17 @@ Version 0.29.0 (2015-12-13)
 
 Compatibility notes:
 
-- when upgrading to 0.29.0 you need to upgrade client as well as server
-  installations due to the locking and commandline interface changes otherwise
-  you'll get an error msg about a RPC protocol mismatch or a wrong commandline
+- When upgrading to 0.29.0, you need to upgrade client as well as server
+  installations due to the locking and command-line interface changes; otherwise
+  you'll get an error message about an RPC protocol mismatch or a wrong command-line
   option.
-  if you run a server that needs to support both old and new clients, it is
+  If you run a server that needs to support both old and new clients, it is
   suggested that you have a "borg-0.28.2" and a "borg-0.29.0" command.
   clients then can choose via e.g. "borg --remote-path=borg-0.29.0 ...".
-- the default waiting time for a lock changed from infinity to 1 second for a
-  better interactive user experience. if the repo you want to access is
+- The default waiting time for a lock changed from infinity to 1 second for a
+  better interactive user experience. If the repo you want to access is
   currently locked, borg will now terminate after 1s with an error message.
-  if you have scripts that shall wait for the lock for a longer time, use
+  If you have scripts that should wait for the lock for a longer time, use
   --lock-wait N (with N being the maximum wait time in seconds).
 
 Bug fixes:
diff --git a/docs/changes_1.x.rst b/docs/changes_1.x.rst
index 714726c1c4..d4cc7be886 100644
--- a/docs/changes_1.x.rst
+++ b/docs/changes_1.x.rst
@@ -73,7 +73,7 @@ no matter what encryption mode they use, including "none"):
    for normal production operations - it is only needed once to get the archives in a
    repository into a good state. All archives have a valid TAM now.
 
-Vulnerability time line:
+Vulnerability timeline:
 
 * 2023-06-13: Vulnerability discovered during code review by Thomas Waldmann
 * 2023-06-13...: Work on fixing the issue, upgrade procedure, docs.
diff --git a/docs/conf.py b/docs/conf.py
index 8e97b31a5f..218d8dd2d3 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -1,7 +1,7 @@
-# documentation build configuration file, created by
+# Documentation build configuration file, created by
 # sphinx-quickstart on Sat Sep 10 18:18:25 2011.
 #
-# This file is execfile()d with the current directory set to its containing dir.
+# This file is execfile()d with the current directory set to its containing directory.
 #
 # Note that not all possible configuration values are present in this
 # autogenerated file.
@@ -74,7 +74,7 @@
 # default_role = None
 
 # The Borg docs contain no or very little Python docs.
-# Thus, the primary domain is rst.
+# Thus, the primary domain is RST.
 primary_domain = "rst"
 
 # If true, '()' will be appended to :func: etc. cross-reference text.
@@ -97,8 +97,8 @@
 
 # -- Options for HTML output ---------------------------------------------------
 
-# The theme to use for HTML and HTML Help pages.  See the documentation for
-# a list of builtin themes.
+# The theme to use for HTML and HTML Help pages. See the documentation for
+# a list of built-in themes.
 import guzzle_sphinx_theme
 
 html_theme_path = guzzle_sphinx_theme.html_theme_path()
diff --git a/docs/deployment/automated-local.rst b/docs/deployment/automated-local.rst
index 38febbed0b..137b513772 100644
--- a/docs/deployment/automated-local.rst
+++ b/docs/deployment/automated-local.rst
@@ -14,13 +14,13 @@ systemd and udev.
 Overview
 --------
 
-An udev rule is created to trigger on the addition of block devices. The rule contains a tag
-that triggers systemd to start a oneshot service. The oneshot service executes a script in
+A udev rule is created to trigger on the addition of block devices. The rule contains a tag
+that triggers systemd to start a one-shot service. The one-shot service executes a script in
 the standard systemd service environment, which automatically captures stdout/stderr and
 logs it to the journal.
 
-The script mounts the added block device, if it is a registered backup drive, and creates
-backups on it. When done, it optionally unmounts the file system and spins the drive down,
+The script mounts the added block device if it is a registered backup drive and creates
+backups on it. When done, it optionally unmounts the filesystem and spins the drive down,
 so that it may be physically disconnected.
 
 Configuring the system
@@ -29,7 +29,8 @@ Configuring the system
 First, create the ``/etc/backups`` directory (as root).
 All configuration goes into this directory.
 
-Find out the ID of the partition table of your backup disk (here assumed to be /dev/sdz):
+Find out the ID of the partition table of your backup disk (here assumed to be /dev/sdz)::
+
     lsblk --fs -o +PTUUID /dev/sdz
 
 Then, create ``/etc/backups/80-backup.rules`` with the following content (all on one line)::
@@ -46,8 +47,8 @@ launch the "automatic-backup" service, which we will create next, as the
     Type=oneshot
     ExecStart=/etc/backups/run.sh
 
-Now, create the main backup script, ``/etc/backups/run.sh``. Below is a template,
-modify it to suit your needs (e.g. more backup sets, dumping databases etc.).
+Now, create the main backup script, ``/etc/backups/run.sh``. Below is a template;
+modify it to suit your needs (e.g., more backup sets, dumping databases, etc.).
 
 .. code-block:: bash
 
@@ -93,8 +94,8 @@ modify it to suit your needs (e.g. more backup sets, dumping databases etc.).
 
     echo "Disk $uuid is a backup disk"
     partition_path=/dev/disk/by-uuid/$uuid
-    # Mount file system if not already done. This assumes that if something is already
-    # mounted at $MOUNTPOINT, it is the backup drive. It won't find the drive if
+    # Mount filesystem if not already done. This assumes that if something is already
+    # mounted at $MOUNTPOINT, it is the backup drive. It will not find the drive if
     # it was mounted somewhere else.
     findmnt $MOUNTPOINT >/dev/null || mount $partition_path $MOUNTPOINT
     drive=$(lsblk --inverse --noheadings --list --paths --output name $partition_path | head --lines 1)
@@ -110,8 +111,8 @@ modify it to suit your needs (e.g. more backup sets, dumping databases etc.).
     # Set BORG_PASSPHRASE or BORG_PASSCOMMAND somewhere around here, using export,
     # if encryption is used.
 
-    # No one can answer if Borg asks these questions, it is better to just fail quickly
-    # instead of hanging.
+    # Because no one can answer these questions non-interactively, it is better to
+    # fail quickly instead of hanging.
     export BORG_RELOCATED_REPO_ACCESS_IS_OK=no
     export BORG_UNKNOWN_UNENCRYPTED_REPO_ACCESS_IS_OK=no
 
@@ -127,8 +128,8 @@ modify it to suit your needs (e.g. more backup sets, dumping databases etc.).
       $TARGET::$DATE-$$-system \
       / /boot
 
-    # /home is often a separate partition / file system.
-    # Even if it isn't (add --exclude /home above), it probably makes sense
+    # /home is often a separate partition/filesystem.
+    # Even if it is not (add --exclude /home above), it probably makes sense
     # to have /home in a separate archive.
     borg create $BORG_OPTS \
       --exclude 'sh:home/*/.cache' \
@@ -150,17 +151,16 @@ modify it to suit your needs (e.g. more backup sets, dumping databases etc.).
     fi
 
 Create the ``/etc/backups/autoeject`` file to have the script automatically eject the drive
-after creating the backup. Rename the file to something else (e.g. ``/etc/backups/autoeject-no``)
-when you want to do something with the drive after creating backups (e.g running check).
+after creating the backup. Rename the file to something else (e.g., ``/etc/backups/autoeject-no``)
+when you want to do something with the drive after creating backups (e.g., running checks).
 
 Create the ``/etc/backups/backup-suspend`` file if the machine should suspend after completing
 the backup. Don't forget to disconnect the device physically before resuming,
 otherwise you'll enter a cycle. You can also add an option to power down instead.
 
-Create an empty ``/etc/backups/backup.disks`` file, you'll register your backup drives
-there.
+Create an empty ``/etc/backups/backup.disks`` file, in which you will register your backup drives.
 
-The last part is actually to enable the udev rules and services:
+Finally, enable the udev rules and services:
 
 .. code-block:: bash
 
@@ -173,13 +173,13 @@ Adding backup hard drives
 -------------------------
 
 Connect your backup hard drive. Format it, if not done already.
-Find the UUID of the file system that backups should be stored on::
+Find the UUID of the filesystem on which backups should be stored::
 
     lsblk -o+uuid,label
 
-Note the UUID into the ``/etc/backups/backup.disks`` file.
+Record the UUID in the ``/etc/backups/backup.disks`` file.
 
-Mount the drive to /mnt/backup.
+Mount the drive at /mnt/backup.
 
 Initialize a Borg repository at the location indicated by ``TARGET``::
 
@@ -197,14 +197,14 @@ See backup logs using journalctl::
 Security considerations
 -----------------------
 
-The script as shown above will mount any file system with an UUID listed in
-``/etc/backups/backup.disks``. The UUID check is a safety / annoyance-reduction
+The script as shown above will mount any filesystem with a UUID listed in
+``/etc/backups/backup.disks``. The UUID check is a safety/annoyance-reduction
 mechanism to keep the script from blowing up whenever a random USB thumb drive is connected.
-It is not meant as a security mechanism. Mounting file systems and reading repository
-data exposes additional attack surfaces (kernel file system drivers,
-possibly user space services and Borg itself). On the other hand, someone
+It is not meant as a security mechanism. Mounting filesystems and reading repository
+data exposes additional attack surfaces (kernel filesystem drivers,
+possibly userspace services, and Borg itself). On the other hand, someone
 standing right next to your computer can attempt a lot of attacks, most of which
-are easier to do than e.g. exploiting file systems (installing a physical key logger,
+are easier to do than, e.g., exploiting filesystems (installing a physical keylogger,
 DMA attacks, stealing the machine, ...).
 
 Borg ensures that backups are not created on random drives that "just happen"
diff --git a/docs/deployment/central-backup-server.rst b/docs/deployment/central-backup-server.rst
index afb8c86fc4..d697cce927 100644
--- a/docs/deployment/central-backup-server.rst
+++ b/docs/deployment/central-backup-server.rst
@@ -5,44 +5,44 @@
 Central repository server with Ansible or Salt
 ==============================================
 
-This section will give an example how to set up a borg repository server for multiple
+This section gives an example of how to set up a Borg repository server for multiple
 clients.
 
 Machines
 --------
 
-There are multiple machines used in this section and will further be named by their
-respective fully qualified domain name (fqdn).
+This section uses multiple machines, referred to by their
+respective fully qualified domain names (FQDNs).
 
 * The backup server: `backup01.srv.local`
 * The clients:
 
   - John Doe's desktop: `johndoe.clnt.local`
-  - Webserver 01: `web01.srv.local`
+  - Web server 01: `web01.srv.local`
   - Application server 01: `app01.srv.local`
 
 User and group
 --------------
 
-The repository server needs to have only one UNIX user for all the clients.
+The repository server should have a single UNIX user for all the clients.
 Recommended user and group with additional settings:
 
 * User: `backup`
 * Group: `backup`
-* Shell: `/bin/bash` (or other capable to run the `borg serve` command)
+* Shell: `/bin/bash` (or another shell capable of running the `borg serve` command)
 * Home: `/home/backup`
 
-Most clients shall initiate a backup from the root user to catch all
-users, groups and permissions (e.g. when backing up `/home`).
+Most clients should initiate a backup as the root user to capture all
+users, groups, and permissions (e.g., when backing up `/home`).
 
 Folders
 -------
 
-The following folder tree layout is suggested on the repository server:
+The following directory layout is suggested on the repository server:
 
 * User home directory, /home/backup
 * Repositories path (storage pool): /home/backup/repos
-* Clients restricted paths (`/home/backup/repos/<client fqdn>`):
+* Clients’ restricted paths (`/home/backup/repos/<client fqdn>`):
 
   - johndoe.clnt.local: `/home/backup/repos/johndoe.clnt.local`
   - web01.srv.local: `/home/backup/repos/web01.srv.local`
@@ -60,10 +60,10 @@ but no other directories. You can allow a client to access several separate dire
 which could make sense if multiple machines belong to one person which should then have access to all the
 backups of their machines.
 
-There is only one ssh key per client allowed. Keys are added for ``johndoe.clnt.local``, ``web01.srv.local`` and
-``app01.srv.local``. But they will access the backup under only one UNIX user account as:
+Only one SSH key per client is allowed. Keys are added for ``johndoe.clnt.local``, ``web01.srv.local`` and
+``app01.srv.local``. They will access the backup under a single UNIX user account as
 ``backup@backup01.srv.local``. Every key in ``$HOME/.ssh/authorized_keys`` has a
-forced command and restrictions applied as shown below:
+forced command and restrictions applied, as shown below:
 
 ::
 
@@ -73,19 +73,19 @@ forced command and restrictions applied as shown below:
 
 .. note:: The text shown above needs to be written on a single line!
 
-The options which are added to the key will perform the following:
+The options added to the key perform the following:
 
 1. Change working directory
 2. Run ``borg serve`` restricted to the client base path
 3. Restrict ssh and do not allow stuff which imposes a security risk
 
-Due to the ``cd`` command we use, the server automatically changes the current
-working directory. Then client doesn't need to have knowledge of the absolute
+Because of the ``cd`` command, the server automatically changes the current
+working directory. The client then does not need to know the absolute
 or relative remote repository path and can directly access the repositories at
 ``ssh://<user>@<host>/./<repo>``.
 
-.. note:: The setup above ignores all client given commandline parameters
-          which are normally appended to the `borg serve` command.
+.. note:: The setup above ignores all client-given command line parameters
+          that are normally appended to the `borg serve` command.
 
 Client
 ------
@@ -96,15 +96,15 @@ The client needs to initialize the `pictures` repository like this:
 
  borg init ssh://backup@backup01.srv.local/./pictures
 
-Or with the full path (should actually never be used, as only for demonstration purposes).
-The server should automatically change the current working directory to the `<client fqdn>` folder.
+Or with the full path (this should not be used in practice; it is only for demonstration purposes).
+The server automatically changes the current working directory to the `<client fqdn>` directory.
 
 ::
 
   borg init ssh://backup@backup01.srv.local/home/backup/repos/johndoe.clnt.local/pictures
 
-When `johndoe.clnt.local` tries to access a not restricted path the following error is raised.
-John Doe tries to back up into the Web 01 path:
+When `johndoe.clnt.local` tries to access a path outside its restriction, the following error is raised.
+John Doe tries to back up into the web01 path:
 
 ::
 
diff --git a/docs/deployment/hosting-repositories.rst b/docs/deployment/hosting-repositories.rst
index 2f55aed2db..f225f0dc72 100644
--- a/docs/deployment/hosting-repositories.rst
+++ b/docs/deployment/hosting-repositories.rst
@@ -5,21 +5,21 @@
 Hosting repositories
 ====================
 
-This sections shows how to provide repository storage securely for users.
+This section shows how to provide repository storage securely for users.
 
 Repositories are accessed through SSH. Each user of the service should
-have her own login which is only able to access the user's files.
-Technically it would be possible to have multiple users share one login,
+have their own login, which is only able to access that user's files.
+Technically, it is possible to have multiple users share one login;
 however, separating them is better. Separate logins increase isolation
-and are thus an additional layer of security and safety for both the
+and provide an additional layer of security and safety for both the
 provider and the users.
 
-For example, if a user manages to breach ``borg serve`` then she can
-only damage her own data (assuming that the system does not have further
+For example, if a user manages to breach ``borg serve``, they can
+only damage their own data (assuming that the system does not have further
 vulnerabilities).
 
 Use the standard directory structure of the operating system. Each user
-is assigned a home directory and repositories of the user reside in her
+is assigned a home directory, and that user's repositories reside in their
 home directory.
 
 The following ``~user/.ssh/authorized_keys`` file is the most important
@@ -47,7 +47,7 @@ and X11 forwarding, as well as disabling PTY allocation and execution of ~/.ssh/
 If any future restriction capabilities are added to authorized_keys
 files they will be included in this set.
 
-The ``command`` keyword forces execution of the specified command line
+The ``command`` keyword forces execution of the specified command
 upon login. This must be ``borg serve``. The ``--restrict-to-repository``
 option permits access to exactly **one** repository. It can be given
 multiple times to permit access to more than one repository.
diff --git a/docs/deployment/image-backup.rst b/docs/deployment/image-backup.rst
index 9a979c4a29..7a0c56330c 100644
--- a/docs/deployment/image-backup.rst
+++ b/docs/deployment/image-backup.rst
@@ -6,10 +6,10 @@ Backing up entire disk images
 
 Backing up disk images can still be efficient with Borg because its `deduplication`_
 technique makes sure only the modified parts of the file are stored. Borg also has
-optional simple sparse file support for extract.
+optional simple sparse file support for extraction.
 
-It is of utmost importancy to pin down the disk you want to backup.
-You need to use the SERIAL for that.
+It is of utmost importance to pin down the disk you want to back up.
+Use the disk's SERIAL for that.
 Use:
 
 .. code-block:: bash
@@ -25,10 +25,10 @@ Use:
     echo "${PARTITIONS[@]}"
     echo "Disk Identifier: $DISK_ID"
 
-    # Use the following line to perform a borg backup for the full disk:
+    # Use the following line to perform a Borg backup for the full disk:
     # borg create --read-special disk-backup "$DISK_ID"
 
-    # Use the following to perform a borg backup for all partitions of the disk
+    # Use the following to perform a Borg backup for all partitions of the disk
     # borg create --read-special partitions-backup "${PARTITIONS[@]}"
 
     # Example output:
@@ -47,7 +47,7 @@ Decreasing the size of image backups
 ------------------------------------
 
 Disk images are as large as the full disk when uncompressed and might not get much
-smaller post-deduplication after heavy use because virtually all file systems don't
+smaller post-deduplication after heavy use because virtually all filesystems do not
 actually delete file data on disk but instead delete the filesystem entries referencing
 the data. Therefore, if a disk nears capacity and files are deleted again, the change
 will barely decrease the space it takes up when compressed and deduplicated. Depending
@@ -115,8 +115,8 @@ Because the partitions were zeroed in place, restoration is only one command::
           mounted, is simply to ``dd`` from ``/dev/zero`` to a temporary file and delete
           it. This is ill-advised for the reasons mentioned in the ``zerofree`` man page:
 
-          - it is slow
-          - it makes the disk image (temporarily) grow to its maximal extent
+          - it is slow.
+          - it makes the disk image (temporarily) grow to its maximal extent.
           - it (temporarily) uses all free space on the disk, so other concurrent write actions may fail.
 
 Virtual machines
@@ -129,7 +129,7 @@ regular file to Borg with the same issues as regular files when it comes to conc
 reading and writing from the same file.
 
 For backing up live VMs use filesystem snapshots on the VM host, which establishes
-crash-consistency for the VM images. This means that with most file systems (that
+crash-consistency for the VM images. This means that with most filesystems (that
 are journaling) the FS will always be fine in the backup (but may need a journal
 replay to become accessible).
 
@@ -145,10 +145,10 @@ to reach application-consistency; it's a broad and complex issue that cannot be
 in entirety here.
 
 Hypervisor snapshots capturing most of the VM's state can also be used for backups and
-can be a better alternative to pure file system based snapshots of the VM's disk, since
+can be a better alternative to pure filesystem-based snapshots of the VM's disk, since
 no state is lost. Depending on the application this can be the easiest and most reliable
 way to create application-consistent backups.
 
-Borg doesn't intend to address these issues due to their huge complexity and
+Borg does not intend to address these issues due to their huge complexity and
 platform/software dependency. Combining Borg with the mechanisms provided by the platform
 (snapshots, hypervisor features) will be the best approach to start tackling them.
diff --git a/docs/deployment/non-root-user.rst b/docs/deployment/non-root-user.rst
index a3d6dad449..465e2e434f 100644
--- a/docs/deployment/non-root-user.rst
+++ b/docs/deployment/non-root-user.rst
@@ -6,29 +6,29 @@
 Backing up using a non-root user
 ================================
 
-This section describes how to run borg as a non-root user and still be able to
-backup every file on the system.
+This section describes how to run Borg as a non-root user and still be able to
+back up every file on the system.
 
-Normally borg is run as the root user to bypass all filesystem permissions and
-be able to read all files. But in theory this also allows borg to modify or
-delete files on your system, in case of a bug for example.
+Normally, Borg is run as the root user to bypass all filesystem permissions and
+be able to read all files. However, in theory this also allows Borg to modify or
+delete files on your system (for example, in case of a bug).
 
-To eliminate this possibility, we can run borg as a non-root user and give it read-only
+To eliminate this possibility, we can run Borg as a non-root user and give it read-only
 permissions to all files on the system.
 
 
 Using Linux capabilities inside a systemd service
 =================================================
 
-One way to do so, is to use linux `capabilities
+One way to do so is to use Linux `capabilities
 <https://man7.org/linux/man-pages/man7/capabilities.7.html>`_ within a systemd
 service.
 
-Linux capabilities allow us to give parts of the privileges the root user has to
-a non-root user. This works on a per-thread level and does not give the permission
+Linux capabilities allow us to grant parts of the root user’s privileges to
+a non-root user. This works on a per-thread level and does not grant permissions
 to the non-root user as a whole.
 
-For this we need to run our backup script from a systemd service and use the `AmbientCapabilities
+For this, we need to run the backup script from a systemd service and use the `AmbientCapabilities
 <https://www.freedesktop.org/software/systemd/man/latest/systemd.exec.html#AmbientCapabilities=>`_
 option added in systemd 229.
 
@@ -46,21 +46,21 @@ A very basic unit file would look like this:
 
     AmbientCapabilities=CAP_DAC_READ_SEARCH
 
-The ``CAP_DAC_READ_SEARCH`` capability gives borg read-only access to all files and directories on the system.
+The ``CAP_DAC_READ_SEARCH`` capability gives Borg read-only access to all files and directories on the system.
 
 This service can then be started manually using ``systemctl start``, a systemd timer or other methods.
 
 Restore considerations
 ======================
 
-When restoring files, the root user should be used. When using the non-root user, borg extract will
-change all files to be owned by the non-root user. Using borg mount will not allow the non-root user
-to access files that it would not have access to on the system itself.
+Use the root user when restoring files. If you use the non-root user, ``borg extract`` will
+change ownership of all restored files to the non-root user. Using ``borg mount`` will not allow the
+non-root user to access files it would not be able to access on the system itself.
 
-Other than that, the same restore process, that would be used when running the backup as root, can be used.
+Other than that, you can use the same restore process you would use when running the backup as root.
 
 .. warning::
 
-    When using a local repo and running borg commands as root, make sure to only use commands that do not
-    modify the repo itself, like extract or mount. Modifying the repo using the root user will break
-    the repo for the non-root user, since some files inside the repo will now be owned by root.
+    When using a local repository and running Borg commands as root, make sure to use only commands that do not
+    modify the repository itself, such as extract or mount. Modifying the repository as root will break it for the
+    non-root user, since some files inside the repository will then be owned by root.
diff --git a/docs/deployment/pull-backup.rst b/docs/deployment/pull-backup.rst
index 0809f8c834..0bc352906e 100644
--- a/docs/deployment/pull-backup.rst
+++ b/docs/deployment/pull-backup.rst
@@ -6,12 +6,12 @@
 Backing up in pull mode
 =======================
 
-Typically the borg client connects to a backup server using SSH as a transport
+Typically the Borg client connects to a backup server using SSH as a transport
 when initiating a backup. This is referred to as push mode.
 
-If you however require the backup server to initiate the connection or prefer
+However, if you require the backup server to initiate the connection, or prefer
 it to initiate the backup run, one of the following workarounds is required to
-allow such a pull mode setup.
+allow such a pull-mode setup.
 
 A common use case for pull mode is to back up a remote server to a local personal
 computer.
@@ -19,38 +19,38 @@ computer.
 SSHFS
 =====
 
-Assuming you have a pull backup system set up with borg, where a backup server
-pulls the data from the target via SSHFS. In this mode, the backup client's file
-system is mounted remotely on the backup server. Pull mode is even possible if
+Assume you have a pull backup system set up with Borg, where a backup server
+pulls data from the target via SSHFS. In this mode, the backup client's filesystem
+is mounted remotely on the backup server. Pull mode is even possible if
 the SSH connection must be established by the client via a remote tunnel. Other
 network file systems like NFS or SMB could be used as well, but SSHFS is very
 simple to set up and probably the most secure one.
 
 There are some restrictions caused by SSHFS. For example, unless you define UID
 and GID mappings when mounting via ``sshfs``, owners and groups of the mounted
-file system will probably change, and you may not have access to those files if
-BorgBackup is not run with root privileges.
+filesystem will probably change, and you may not have access to those files if
+Borg is not run with root privileges.
 
-SSHFS is a FUSE file system and uses the SFTP protocol, so there may be also
-other unsupported features that the actual implementations of sshfs, libfuse and
-sftp on the backup server do not support, like file name encodings, ACLs, xattrs
-or flags. So there is no guarantee that you are able to restore a system
+SSHFS is a FUSE filesystem and uses the SFTP protocol, so there may also be
+unsupported features that the actual implementations of SSHFS, libfuse, and
+SFTP on the backup server do not support, like filename encodings, ACLs, xattrs,
+or flags. Therefore, there is no guarantee that you can restore a system
 completely in every aspect from such a backup.
 
 .. warning::
 
-    To mount the client's root file system you will need root access to the
-    client. This contradicts to the usual threat model of BorgBackup, where
-    clients don't need to trust the backup server (data is encrypted). In pull
+    To mount the client's root filesystem you will need root access to the
+    client. This contradicts the usual threat model of Borg, where
+    clients do not need to trust the backup server (data is encrypted). In pull
     mode the server (when logged in as root) could cause unlimited damage to the
-    client. Therefore, pull mode should be used only from servers you do fully
+    client. Therefore, pull mode should be used only with servers you fully
     trust!
 
 .. warning::
 
-    Additionally, while being chrooted into the client's root file system,
-    code from the client will be executed. Thus, you should only do that when
-    fully trusting the client.
+    Additionally, while chrooted into the client's root filesystem,
+    code from the client will be executed. Therefore, you should do this only when
+    you fully trust the client.
 
 .. warning::
 
diff --git a/docs/development.rst b/docs/development.rst
index b9d01484e1..7845bf81f2 100644
--- a/docs/development.rst
+++ b/docs/development.rst
@@ -8,7 +8,7 @@ Development
 This chapter will get you started with Borg development.
 
 Borg is written in Python (with a little bit of Cython and C for
-the performance critical parts).
+the performance-critical parts).
 
 Contributions
 -------------
@@ -52,14 +52,14 @@ Borg development happens on the ``master`` branch and uses GitHub pull
 requests (if you don't have GitHub or don't want to use it you can
 send smaller patches via the borgbackup mailing list to the maintainers).
 
-Stable releases are maintained on maintenance branches named ``x.y-maint``, eg.
+Stable releases are maintained on maintenance branches named ``x.y-maint``, e.g.,
 the maintenance branch of the 1.4.x series is ``1.4-maint``.
 
 Most PRs should be filed against the ``master`` branch. Only if an
 issue affects **only** a particular maintenance branch a PR should be
 filed against it directly.
 
-While discussing / reviewing a PR it will be decided whether the
+While discussing/reviewing a PR it will be decided whether the
 change should be applied to maintenance branches. Each maintenance
 branch has a corresponding *backport/x.y-maint* label, which will then
 be applied.
@@ -105,8 +105,8 @@ were collected:
 
 Previously (until release 1.0.10) Borg used a `"merge upwards"
 <https://git-scm.com/docs/gitworkflows#_merging_upwards>`_ model where
-most minor changes and fixes where committed to a maintenance branch
-(eg. 1.0-maint), and the maintenance branch(es) were regularly merged
+most minor changes and fixes were committed to a maintenance branch
+(e.g. 1.0-maint), and the maintenance branch(es) were regularly merged
 back into the main development branch. This became more and more
 troublesome due to merges growing more conflict-heavy and error-prone.
 
diff --git a/docs/faq.rst b/docs/faq.rst
index 53017b06b2..5c4c561f85 100644
--- a/docs/faq.rst
+++ b/docs/faq.rst
@@ -8,19 +8,19 @@ Frequently asked questions
 Usage & Limitations
 ###################
 
-What is the difference between a repo on an external hard drive vs. repo on a server?
--------------------------------------------------------------------------------------
+What is the difference between a repository on an external hard drive and a repository on a server?
+---------------------------------------------------------------------------------------------------
 
 If Borg is running in client/server mode, the client uses SSH as a transport to
-talk to the remote agent, which is another Borg process (Borg is installed on
-the server, too) started automatically by the client. The Borg server is doing
-storage-related low-level repo operations (list, load and store objects),
+talk to a remote agent, which is another Borg process (Borg is also installed on
+the server) started automatically by the client. The Borg server performs
+storage-related, low-level repository operations (list, load, and store objects),
 while the Borg client does the high-level stuff: deduplication, encryption,
 compression, dealing with archives, backups, restores, etc., which reduces the
 amount of data that goes over the network.
 
-When Borg is writing to a repo on a locally mounted remote file system, e.g.
-SSHFS, the Borg client only can do file system operations and has no agent
+When Borg is writing to a repo on a locally mounted remote filesystem, e.g.
+SSHFS, the Borg client can only perform filesystem operations and has no agent
 running on the remote side, so *every* operation needs to go over the network,
 which is slower.
 
@@ -29,7 +29,7 @@ Can I back up from multiple servers into a single repository?
 
 Yes, you can! Even simultaneously.
 
-Can I back up to multiple, swapped backup targets?
+Can I back up to multiple swapped backup targets?
 --------------------------------------------------
 
 It is possible to swap your backup disks if each backup medium is assigned its
@@ -43,41 +43,41 @@ locations), the recommended way to do that is like this:
 
 - ``borg repo-create repo1 --encryption=X``
 - ``borg repo-create repo2 --encryption=X --other-repo=repo1``
-- maybe do a snapshot to have stable and same input data for both borg create.
+- Optionally, create a snapshot to have stable and identical input data for both borg create runs.
 - client machine ---borg create---> repo1
 - client machine ---borg create---> repo2
 
-This will create distinct (different repo ID), but related repositories.
+This will create distinct (different repository ID) but related repositories.
 Related means using the same chunker secret and the same id_key, thus producing
-the same chunks / the same chunk ids if the input data is the same.
+the same chunks/the same chunk IDs if the input data is the same.
 
-The 2 independent borg create invocations mean that there is no error propagation
+The two independent borg create invocations mean there is no error propagation
 from repo1 to repo2 when done like that.
 
-An alternative way would be to use ``borg transfer`` to copy backup archives
-from repo1 to repo2. Likely a bit more efficient and the archives would be identical,
-but suffering from potential error propagation.
+An alternative is to use ``borg transfer`` to copy backup archives
+from repo1 to repo2. This is likely a bit more efficient and the archives would be identical,
+but it may suffer from potential error propagation.
 
-Warning: using borg with multiple repositories with identical repository ID (like when
-creating 1:1 repository copies) is not supported and can lead to all sorts of issues,
-like e.g. cache coherency issues, malfunction, data corruption.
+Warning: Using Borg with multiple repositories that have identical repository IDs (such as
+creating 1:1 repository copies) is not supported and can lead to various issues,
+for example cache coherency issues, malfunction, or data corruption.
 
 "this is either an attack or unsafe" warning
 --------------------------------------------
 
 About the warning:
 
-  Cache, or information obtained from the security directory is newer than
-  repository - this is either an attack or unsafe (multiple repos with same ID)
+  Cache or information obtained from the security directory is newer than the
+  repository — this is either an attack or unsafe (multiple repositories with the same ID)
 
 "unsafe": If not following the advice from the previous section, you can easily
 run into this by yourself by restoring an older copy of your repository.
 
-"attack": maybe an attacker has replaced your repo by an older copy, trying to
-trick you into AES counter reuse, trying to break your repo encryption.
+"attack": An attacker may have replaced your repo with an older copy, trying to
+trigger AES counter reuse and break your repo encryption.
 
-Borg users have also reported that fs issues (like hw issues / I/O errors causing
-the fs to become read-only) can cause this warning, see :issue:`7853`.
+Borg users have also reported that file system (fs) issues (e.g., hardware issues or I/O errors causing
+the file system to become read-only) can cause this warning, see :issue:`7853`.
 
 If you decide to ignore this and accept unsafe operation for this repository,
 you could delete the manifest-timestamp and the local cache:
@@ -88,7 +88,7 @@ you could delete the manifest-timestamp and the local cache:
   rm ~/.config/borg/security/REPO_ID/manifest-timestamp
   borg repo-delete --cache-only
 
-This is an unsafe and unsupported way to use borg, you have been warned.
+This is an unsafe and unsupported way to use Borg. You have been warned.
 
 Which file types, attributes, etc. are *not* preserved?
 -------------------------------------------------------
diff --git a/docs/index.rst b/docs/index.rst
index 6fc3bb6a52..8d6ae6a153 100644
--- a/docs/index.rst
+++ b/docs/index.rst
@@ -6,7 +6,7 @@ Borg Documentation
 
 .. include:: ../README.rst
 
-.. when you add an element here, do not forget to add it to book.rst
+.. When you add an element here, do not forget to add it to book.rst.
 
 .. toctree::
    :maxdepth: 2
diff --git a/docs/installation.rst b/docs/installation.rst
index cf762e2466..674a0f9708 100644
--- a/docs/installation.rst
+++ b/docs/installation.rst
@@ -82,9 +82,9 @@ Ubuntu       `Ubuntu packages`_, `Ubuntu PPA`_             ``apt install borgbac
 .. _Ubuntu packages: https://launchpad.net/ubuntu/+source/borgbackup
 .. _Ubuntu PPA: https://launchpad.net/~costamagnagianfranco/+archive/ubuntu/borgbackup
 
-Please ask package maintainers to build a package or, if you can package /
+Please ask package maintainers to build a package or, if you can package/
 submit it yourself, please help us with that! See :issue:`105` on
-github to followup on packaging efforts.
+GitHub to follow up on packaging efforts.
 
 **Current status of package in the repositories**
 
@@ -106,12 +106,12 @@ Standalone Binary
 .. note:: Releases are signed with an OpenPGP key, see
           :ref:`security-contact` for more instructions.
 
-Borg x86/x64 amd/intel compatible binaries (generated with `pyinstaller`_)
+Borg x86/x64 AMD/Intel compatible binaries (generated with `pyinstaller`_)
 are available on the releases_ page for the following platforms:
 
 * **Linux**: glibc >= 2.28 (ok for most supported Linux releases).
   Older glibc releases are untested and may not work.
-* **MacOS**: 10.12 or newer (To avoid signing issues download the file via
+* **macOS**: 10.12 or newer (To avoid signing issues, download the file via
   command line **or** remove the ``quarantine`` attribute after downloading:
   ``$ xattr -dr com.apple.quarantine borg-macosx64.tgz``)
 * **FreeBSD**: 12.1 (unknown whether it works for older releases)
diff --git a/docs/internals.rst b/docs/internals.rst
index 3c6645c19f..7bbb3f0095 100644
--- a/docs/internals.rst
+++ b/docs/internals.rst
@@ -4,7 +4,7 @@
 Internals
 =========
 
-The internals chapter describes and analyses most of the inner workings
+The internals chapter describes and analyzes most of the inner workings
 of Borg.
 
 Borg uses a low-level, key-value store, the :ref:`repository`, and
@@ -20,17 +20,17 @@ Deduplication is performed globally across all data in the repository
 (multiple backups and even multiple hosts), both on data and file
 metadata, using :ref:`chunks` created by the chunker using the
 Buzhash_ algorithm ("buzhash" and "buzhash64" chunker) or a simpler
-fixed blocksize algorithm ("fixed" chunker).
+fixed block size algorithm ("fixed" chunker).
 
 To perform the repository-wide deduplication, a hash of each
 chunk is checked against the :ref:`chunks cache <cache>`, which is a
-hash-table of all chunks that already exist.
+hash table of all chunks that already exist.
 
 .. figure:: internals/structure.png
     :figwidth: 100%
     :width: 100%
 
-    Layers in Borg. On the very top commands are implemented, using
+    Layers in Borg. At the very top, commands are implemented, using
     a data access layer provided by the Archive and Item classes.
     The "key" object provides both compression and authenticated
     encryption used by the data access layer. The "key" object represents
diff --git a/docs/internals/data-structures.rst b/docs/internals/data-structures.rst
index b7ffccc368..f621def4e2 100644
--- a/docs/internals/data-structures.rst
+++ b/docs/internals/data-structures.rst
@@ -63,7 +63,7 @@ Keys
 ~~~~
 
 Repository object IDs (which are used as key into the key-value store) are
-byte-strings of fixed length (256bit, 32 bytes), computed like this::
+byte strings of fixed length (256-bit, 32 bytes), computed like this::
 
   key = id = id_hash(plaintext_data)  # plain = not encrypted, not compressed, not obfuscated
 
@@ -79,10 +79,10 @@ Each repository object is stored separately, under its ID into data/xx/yy/xxyy..
 
 A repo object has a structure like this:
 
-* 32bit meta size
-* 32bit data size
-* 64bit xxh64(meta)
-* 64bit xxh64(data)
+* 32-bit meta size
+* 32-bit data size
+* 64-bit xxh64(meta)
+* 64-bit xxh64(data)
 * meta
 * data
 
@@ -90,8 +90,8 @@ The size and xxh64 hashes can be used for server-side corruption checks without
 needing to decrypt anything (which would require the borg key).
 
 The overall size of repository objects varies from very small (a small source
-file will be stored as a single repo object) to medium (big source files will
-be cut into medium sized chunks of some MB).
+file will be stored as a single repository object) to medium (big source files will
+be cut into medium-sized chunks of some MB).
 
 Metadata and data are separately encrypted and authenticated (depending on
 the user's choices).
@@ -102,7 +102,7 @@ encryption.
 Repo object metadata
 ~~~~~~~~~~~~~~~~~~~~
 
-Metadata is a msgpacked (and encrypted/authenticated) dict with:
+Metadata is a MessagePack-encoded (and encrypted/authenticated) dict with:
 
 - ctype (compression type 0..255)
 - clevel (compression level 0..255)
diff --git a/docs/internals/frontends.rst b/docs/internals/frontends.rst
index 2e36426a9d..699adf166b 100644
--- a/docs/internals/frontends.rst
+++ b/docs/internals/frontends.rst
@@ -11,8 +11,8 @@ but does mean that there are no release-to-release guarantees on what you might
 even for point releases (1.1.x), and there is no documentation beyond the code and the internals documents.
 
 Borg does on the other hand provide an API on a command-line level. In other words, a frontend should
-(for example) create a backup archive just invoke :ref:`borg_create`, give commandline parameters/options
-as needed and parse JSON output from borg.
+(for example) create a backup archive by invoking :ref:`borg_create`, provide command-line parameters/options
+as needed, and parse JSON output from Borg.
 
 Important: JSON output is expected to be UTF-8, but currently borg depends on the locale being configured
 for that (must be a UTF-8 locale and *not* "C" or "ascii"), so that Python will choose to encode to UTF-8.
diff --git a/docs/internals/security.rst b/docs/internals/security.rst
index bcddbb2e8c..f5bb5ef08f 100644
--- a/docs/internals/security.rst
+++ b/docs/internals/security.rst
@@ -24,7 +24,7 @@ The attack model of Borg is that the environment of the client process
 attacker has any and all access to the repository, including interactive
 manipulation (man-in-the-middle) for remote repositories.
 
-Furthermore the client environment is assumed to be persistent across
+Furthermore, the client environment is assumed to be persistent across
 attacks (practically this means that the security database cannot be
 deleted between attacks).
 
@@ -37,8 +37,8 @@ Under these circumstances Borg guarantees that the attacker cannot
    structural information such as the object graph (which archives
    refer to what chunks)
 
-The attacker can always impose a denial of service per definition (he could
-forbid connections to the repository, or delete it partly or entirely).
+The attacker can always impose a denial of service by definition (they could
+block connections to the repository, or delete it partly or entirely).
 
 
 .. _security_structural_auth:
diff --git a/docs/introduction.rst b/docs/introduction.rst
index ab8bd32c47..e26630f0dc 100644
--- a/docs/introduction.rst
+++ b/docs/introduction.rst
@@ -1,8 +1,8 @@
 Introduction
 ============
 
-.. this shim is here to fix the structure in the PDF
-   rendering. without this stub, the elements in the toctree of
-   index.rst show up a level below the README file included
+.. This shim is here to fix the structure in the PDF
+   rendering. Without this stub, the elements in the toctree of
+   index.rst show up a level below the README file included.
 
 .. include:: ../README.rst
diff --git a/docs/man_intro.rst b/docs/man_intro.rst
index 79480c9184..ec3ede1b1d 100644
--- a/docs/man_intro.rst
+++ b/docs/man_intro.rst
@@ -13,7 +13,7 @@ DESCRIPTION
 BorgBackup (short: Borg) is a deduplicating backup program.
 Optionally, it supports compression and authenticated encryption.
 
-The main goal of Borg is to provide an efficient and secure way to back data up.
+The main goal of Borg is to provide an efficient and secure way to back up data.
 The data deduplication technique used makes Borg suitable for daily backups
 since only changes are stored.
 The authenticated encryption technique makes it suitable for backups to targets not
@@ -22,7 +22,7 @@ fully trusted.
 Borg stores a set of files in an *archive*. A *repository* is a collection
 of *archives*. The format of repositories is Borg-specific. Borg does not
 distinguish archives from each other in any way other than their name,
-it does not matter when or where archives were created (e.g. different hosts).
+it does not matter when or where archives were created (e.g., different hosts).
 
 EXAMPLES
 --------
diff --git a/docs/misc/benchmark-crud.txt b/docs/misc/benchmark-crud.txt
index f4ca363b9b..d7d60b99dd 100644
--- a/docs/misc/benchmark-crud.txt
+++ b/docs/misc/benchmark-crud.txt
@@ -1,9 +1,9 @@
 borg benchmark crud
 ===================
 
-Here is some example of borg benchmark crud output.
+Here is an example of borg benchmark crud output.
 
-I ran it on my laptop, Core i5-4200u, 8GB RAM, SATA SSD, Linux, ext4 fs.
+I ran it on my laptop: Core i5-4200U, 8 GB RAM, SATA SSD, Linux, ext4 filesystem.
 "src" as well as repo is local, on this SSD.
 
 $ BORG_PASSPHRASE=secret borg init --encryption repokey-blake2 repo
diff --git a/docs/misc/create_chunker-params.txt b/docs/misc/create_chunker-params.txt
index f498ff03f4..45e4a771e3 100644
--- a/docs/misc/create_chunker-params.txt
+++ b/docs/misc/create_chunker-params.txt
@@ -3,53 +3,53 @@ About borg create --chunker-params
 
 --chunker-params CHUNK_MIN_EXP,CHUNK_MAX_EXP,HASH_MASK_BITS,HASH_WINDOW_SIZE
 
-CHUNK_MIN_EXP and CHUNK_MAX_EXP give the exponent N of the 2^N minimum and
-maximum chunk size. Required: CHUNK_MIN_EXP < CHUNK_MAX_EXP.
+CHUNK_MIN_EXP and CHUNK_MAX_EXP provide the exponent N for the 2^N minimum and
+maximum chunk sizes. Required: CHUNK_MIN_EXP < CHUNK_MAX_EXP.
 
 Defaults: 19 (2^19 == 512KiB) minimum, 23 (2^23 == 8MiB) maximum.
-Currently it is not supported to give more than 23 as maximum.
+Currently, specifying a maximum greater than 23 is not supported.
 
 HASH_MASK_BITS is the number of least-significant bits of the rolling hash
 that need to be zero to trigger a chunk cut.
 Recommended: CHUNK_MIN_EXP + X <= HASH_MASK_BITS <= CHUNK_MAX_EXP - X, X >= 2
 (this allows the rolling hash some freedom to make its cut at a place
-determined by the windows contents rather than the min/max. chunk size).
+determined by the window's contents rather than the minimum/maximum chunk size).
 
-Default: 21 (statistically, chunks will be about 2^21 == 2MiB in size)
+Default: 21 (statistically, chunks will be about 2^21 == 2MiB in size).
 
 HASH_WINDOW_SIZE: the size of the window used for the rolling hash computation.
-Must be an odd number. Default: 4095B
+Must be an odd number. Default: 4095B.
 
 
 Trying it out
 =============
 
 I backed up a VM directory to demonstrate how different chunker parameters
-influence repo size, index size / chunk count, compression, deduplication.
+affect repository size, index size/chunk count, compression, and deduplication.
 
-repo-sm: ~64kiB chunks (16 bits chunk mask), min chunk size 1kiB (2^10B)
-         (these are attic / borg 0.23 internal defaults)
+repo-sm: ~64 KiB chunks (16 bits chunk mask), min chunk size 1 KiB (2^10B)
+         (these are Attic/Borg 0.23 internal defaults)
 
-repo-lg: ~1MiB chunks (20 bits chunk mask), min chunk size 64kiB (2^16B)
+repo-lg: ~1MiB chunks (20 bits chunk mask), min chunk size 64 KiB (2^16B)
 
-repo-xl: 8MiB chunks (2^23B max chunk size), min chunk size 64kiB (2^16B).
-         The chunk mask bits was set to 31, so it (almost) never triggers.
+repo-xl: 8MiB chunks (2^23B max chunk size), min chunk size 64 KiB (2^16B).
+         The chunk mask bits were set to 31, so it (almost) never triggers.
          This degrades the rolling hash based dedup to a fixed-offset dedup
          as the cutting point is now (almost) always the end of the buffer
          (at 2^23B == 8MiB).
 
 The repo index size is an indicator for the RAM needs of Borg.
 In this special case, the total RAM needs are about 2.1x the repo index size.
-You see index size of repo-sm is 16x larger than of repo-lg, which corresponds
+You see the index size of repo-sm is 16x larger than that of repo-lg, which corresponds
 to the ratio of the different target chunk sizes.
 
 Note: RAM needs were not a problem in this specific case (37GB data size).
-      But just imagine, you have 37TB of such data and much less than 42GB RAM,
-      then you should use the "lg" chunker params so you only need
-      2.6GB RAM. Or even bigger chunks than shown for "lg" (see "xl").
+      But imagine you have 37TB of such data and much less than 42GB RAM,
+      then you should use the "lg" chunker parameters so you need only
+      2.6GB RAM. Or even larger chunks than shown for "lg" (see "xl").
 
 You also see compression works better for larger chunks, as expected.
-Duplication works worse for larger chunks, also as expected.
+Deduplication works worse for larger chunks, also as expected.
 
 small chunks
 ============
diff --git a/docs/misc/internals-picture.txt b/docs/misc/internals-picture.txt
index 01351a7bc9..60da0865f4 100644
--- a/docs/misc/internals-picture.txt
+++ b/docs/misc/internals-picture.txt
@@ -1,4 +1,4 @@
-BorgBackup from 10.000m
+BorgBackup from 10,000 m
 =======================
 
 +--------+ +--------+     +--------+
diff --git a/docs/misc/prune-example.txt b/docs/misc/prune-example.txt
index af749e16f6..d77451a858 100644
--- a/docs/misc/prune-example.txt
+++ b/docs/misc/prune-example.txt
@@ -1,9 +1,9 @@
 borg prune visualized
 =====================
 
-Assume it is 2016-01-01, today's backup has not yet been made, you have
+Assume it is 2016-01-01. Today's backup has not yet been made. You have
 created at least one backup on each day in 2015 except on 2015-12-19 (no
-backup made on that day), and you started backing up with borg on
+backup was made on that day), and you started backing up with Borg on
 2015-01-01.
 
 This is what borg prune --keep-daily 14 --keep-monthly 6 --keep-yearly 1
@@ -91,17 +91,17 @@ The --keep-monthly 6 rule keeps Nov, Oct, Sep, Aug, Jul and Jun. December is
 not considered for this rule, because that backup was already kept because of
 the daily rule.
 
-2015-12-17 is kept to satisfy the --keep-daily 14 rule - because no backup was
+2015-12-17 is kept to satisfy the --keep-daily 14 rule, because no backup was
 made on 2015-12-19. If a backup had been made on that day, it would not keep
 the one from 2015-12-17.
 
-We did not include weekly, hourly, minutely or secondly rules to keep this
+We did not include weekly, hourly, minutely, or secondly rules to keep this
 example simple. They all work in basically the same way.
 
 The weekly rule is easy to understand roughly, but hard to understand in all
-details. If interested, read "ISO 8601:2000 standard week-based year".
+details. If you are interested, read "ISO 8601:2000 standard week-based year".
 
-The 13weekly and 3monthly rules are two different strategies for keeping one
+The 13weekly and 3monthly rules are two different strategies for keeping one backup
 every quarter of a year. There are `multiple ways` to define a quarter-year;
 borg prune recognizes two:
 
@@ -113,12 +113,12 @@ borg prune recognizes two:
   March 31, April 1st to June 30th, July 1st to September 30th, and October 1st
   to December 31st form the quarters.
 
-If the subtleties of the definition of a quarter year don't matter to you, a
+If the subtleties of the definition of a quarter-year don't matter to you, a
 short summary of behavior is:
 
-* --keep-13weekly favors keeping backups at the beginning of Jan, Apr, July,
+* --keep-13weekly favors keeping backups at the beginning of Jan, Apr, Jul,
   and Oct.
-* --keep-3monthly favors keeping backups at the end of Dec, Mar, Jun, and Sept.
+* --keep-3monthly favors keeping backups at the end of Dec, Mar, Jun, and Sep.
 * Both strategies will have some overlap in which backups are kept.
 * The differences are negligible unless backups considered for deletion were
   created weekly or more frequently.
diff --git a/docs/quickstart.rst b/docs/quickstart.rst
index 667065fa8f..03ea01f84f 100644
--- a/docs/quickstart.rst
+++ b/docs/quickstart.rst
@@ -7,7 +7,7 @@ Quick Start
 
 This chapter will get you started with Borg and covers various use cases.
 
-A step by step example
+A step-by-step example
 ----------------------
 
 .. include:: quickstart_example.rst.inc
@@ -20,10 +20,10 @@ stores a snapshot of the data of the files "inside" it. One can later extract or
 mount an archive to restore from a backup.
 
 *Repositories* are filesystem directories acting as self-contained stores of archives.
-Repositories can be accessed locally via path or remotely via ssh. Under the hood,
+Repositories can be accessed locally via path or remotely via SSH. Under the hood,
 repositories contain data blocks and a manifest that tracks which blocks are in each
 archive. If some data hasn't changed between backups, Borg simply
-references an already uploaded data chunk (deduplication).
+references an already-uploaded data chunk (deduplication).
 
 .. _about_free_space:
 
@@ -43,7 +43,7 @@ in your backup log files (you check them regularly anyway, right?).
 
 Also helpful:
 
-- use `borg repo-space` to reserve some disk space that can be freed when the fs
+- use `borg repo-space` to reserve some disk space that can be freed when the filesystem
   does not have free space any more.
 - if you use LVM: use a LV + a filesystem that you can resize later and have
   some unallocated PEs you can add to the LV.
@@ -64,8 +64,8 @@ If you only back up your own files, run it as your normal user (i.e. not root).
 
 For a local repository always use the same user to invoke borg.
 
-For a remote repository: always use e.g. ssh://borg@remote_host. You can use this
-from different local users, the remote user running borg and accessing the
+For a remote repository: always use e.g., ssh://borg@remote_host. You can use this
+from different local users; the remote user running borg and accessing the
 repo will always be `borg`.
 
 If you need to access a local repository from different users, you can use the
diff --git a/docs/quickstart_example.rst.inc b/docs/quickstart_example.rst.inc
index 15c40a50ed..44bb58dffd 100644
--- a/docs/quickstart_example.rst.inc
+++ b/docs/quickstart_example.rst.inc
@@ -7,12 +7,12 @@
 
     $ borg -r /path/to/repo create docs ~/src ~/Documents
 
-3. The next day create a new archive using the same archive name::
+3. The next day, create a new archive using the same archive name::
 
     $ borg -r /path/to/repo create --stats docs ~/src ~/Documents
 
-   This backup will be a lot quicker and a lot smaller since only new, never
-   before seen data is stored. The ``--stats`` option causes Borg to
+   This backup will be much quicker and much smaller, since only new,
+   never-before-seen data is stored. The ``--stats`` option causes Borg to
    output statistics about the newly created archive such as the deduplicated
    size (the amount of unique data not shared with other archives)::
 
@@ -22,7 +22,7 @@
     Time (start): Sat, 2022-06-25 20:21:43
     Time (end):   Sat, 2022-06-25 20:21:43
     Duration: 0.07 seconds
-    Utilization of max. archive size: 0%
+    Utilization of maximum archive size: 0%
     Number of files: 699
     Original size: 31.14 MB
     Deduplicated size: 502 B
@@ -44,14 +44,14 @@
 
     $ borg -r /path/to/repo extract aid:b80e24d2
 
-7. Delete the first archive (please note that this does **not** free repo disk space)::
+7. Delete the first archive (please note that this does **not** immediately free repository disk space)::
 
     $ borg -r /path/to/repo delete aid:b80e24d2
 
-   Be careful if you use an archive NAME (and not an archive ID), that might match multiple archives!
-   Always first use with ``--dry-run`` and ``--list``!
+   Be careful if you use an archive NAME (and not an archive ID), as it might match multiple archives.
+   Always use ``--dry-run`` and ``--list`` first!
 
-8. Recover disk space by compacting the segment files in the repo::
+8. Recover disk space by compacting the segment files in the repository::
 
     $ borg -r /path/to/repo compact -v
 
diff --git a/docs/usage.rst b/docs/usage.rst
index 6e11655e17..a07b3165b5 100644
--- a/docs/usage.rst
+++ b/docs/usage.rst
@@ -9,11 +9,11 @@ Usage
    Redirecting...
 
    <script type="text/javascript">
-   // Fixes old links which were just anchors
+   // Fixes old links that were just anchor fragments
    var hash = window.location.hash.substring(1);
 
-   // usage.html is empty, no content. Purely serves to implement a "correct" toctree
-   // due to rST/Sphinx limitations. Refer to https://github.com/sphinx-doc/sphinx/pull/3622
+   // usage.html is empty; it contains no content. It purely serves to implement a "correct" toctree
+   // due to reST/Sphinx limitations. Refer to https://github.com/sphinx-doc/sphinx/pull/3622
 
    // Redirect to general docs
    if(hash == "") {
diff --git a/docs/usage/common-options.rst.inc b/docs/usage/common-options.rst.inc
index 31a9df8657..b3aa1b7592 100644
--- a/docs/usage/common-options.rst.inc
+++ b/docs/usage/common-options.rst.inc
@@ -13,9 +13,9 @@
 --show-rc                show/log the return code (rc)
 --umask M                set umask to M (local only, default: 0077)
 --remote-path PATH       use PATH as borg executable on the remote (default: "borg")
---upload-ratelimit RATE    set network upload rate limit in kiByte/s (default: 0=unlimited)
+--upload-ratelimit RATE    set network upload rate limit in KiB/s (default: 0=unlimited)
 --upload-buffer UPLOAD_BUFFER    set network upload buffer size in MiB. (default: 0=no buffer)
 --debug-profile FILE     Write execution profile in Borg format into FILE. For local use a Python-compatible file can be generated by suffixing FILE with ".pyprof".
 --rsh RSH                Use this command to connect to the 'borg serve' process (default: 'ssh')
---socket PATH            Use UNIX DOMAIN (IPC) socket at PATH for client/server communication with socket: protocol.
+--socket PATH            Use UNIX domain (IPC) socket at PATH for client/server communication with the socket: protocol.
 -r REPO, --repo REPO     repository to use
diff --git a/docs/usage/compact.rst b/docs/usage/compact.rst
index 3a1389a675..9f28b964b5 100644
--- a/docs/usage/compact.rst
+++ b/docs/usage/compact.rst
@@ -4,6 +4,6 @@ Examples
 ~~~~~~~~
 ::
 
-    # compact segments and free repo disk space
+    # Compact segments and free repository disk space
     $ borg compact
 
diff --git a/docs/usage/create.rst b/docs/usage/create.rst
index 6f13a4a123..cf6b5dc816 100644
--- a/docs/usage/create.rst
+++ b/docs/usage/create.rst
@@ -23,14 +23,14 @@ Examples
     # /home/<one directory>/.thumbnails is excluded, not /home/*/*/.thumbnails etc.)
     $ borg create my-files /home --exclude 'sh:home/*/.thumbnails'
 
-    # Backup the root filesystem into an archive named "root-archive"
-    # use zlib compression (good, but slow) - default is lz4 (fast, low compression ratio)
+    # Back up the root filesystem into an archive named "root-archive"
+    # Use zlib compression (good, but slow) — default is LZ4 (fast, low compression ratio)
     $ borg create -C zlib,6 --one-file-system root-archive /
 
     # Backup into an archive name like FQDN-root
     $ borg create '{fqdn}-root' /
 
-    # Backup a remote host locally ("pull" style) using sshfs
+    # Back up a remote host locally ("pull" style) using SSHFS
     $ mkdir sshfs-mount
     $ sshfs root@example.com:/ sshfs-mount
     $ cd sshfs-mount
@@ -38,8 +38,8 @@ Examples
     $ cd ..
     $ fusermount -u sshfs-mount
 
-    # Make a big effort in fine granular deduplication (big chunk management
-    # overhead, needs a lot of RAM and disk space, see formula in internals docs):
+    # Make a big effort in fine-grained deduplication (big chunk management
+    # overhead, needs a lot of RAM and disk space; see the formula in the internals docs):
     $ borg create --chunker-params buzhash,10,23,16,4095 small /smallstuff
 
     # Backup a raw device (must not be active/in use/mounted at that time)
@@ -63,16 +63,16 @@ Examples
     # Only compress compressible data with lzma,N (N = 0..9)
     $ borg create --compression auto,lzma,N arch ~
 
-    # Use short hostname and user name as archive name
+    # Use the short hostname and username as the archive name
     $ borg create '{hostname}-{user}' ~
 
-    # Backing up relative paths by moving into the correct directory first
+    # Back up relative paths by moving into the correct directory first
     $ cd /home/user/Documents
     # The root directory of the archive will be "projectA"
     $ borg create 'daily-projectA' projectA
 
     # Use external command to determine files to archive
-    # Use --paths-from-stdin with find to back up only files less than 1MB in size
+    # Use --paths-from-stdin with find to back up only files less than 1 MB in size
     $ find ~ -size -1000k | borg create --paths-from-stdin small-files-only
     # Use --paths-from-command with find to back up files from only a given user
     $ borg create --paths-from-command joes-files -- find /srv/samba/shared -user joe
diff --git a/docs/usage/debug.rst b/docs/usage/debug.rst
index 0dc54ae392..4420f173fb 100644
--- a/docs/usage/debug.rst
+++ b/docs/usage/debug.rst
@@ -5,7 +5,7 @@ There is a ``borg debug`` command that has some subcommands which are all
 **not intended for normal use** and **potentially very dangerous** if used incorrectly.
 
 For example, ``borg debug put-obj`` and ``borg debug delete-obj`` will only do
-what their name suggests: put objects into repo / delete objects from repo.
+what their name suggests: put objects into the repository / delete objects from the repository.
 
 Please note:
 
@@ -30,5 +30,5 @@ or unauthenticated source.").
 The ``borg debug profile-convert`` command can be used to take a Borg profile and convert
 it to a profile file that is compatible with the Python tools.
 
-Additionally, if the filename specified for ``--debug-profile`` ends with ".pyprof" a
-Python compatible profile is generated. This is only intended for local use by developers.
+Additionally, if the filename specified for ``--debug-profile`` ends with ".pyprof", a
+Python-compatible profile is generated. This is only intended for local use by developers.
diff --git a/docs/usage/delete.rst b/docs/usage/delete.rst
index 8d35fe3a39..35f1dfa784 100644
--- a/docs/usage/delete.rst
+++ b/docs/usage/delete.rst
@@ -4,20 +4,20 @@ Examples
 ~~~~~~~~
 ::
 
-    # delete all backup archives named "kenny-files":
+    # Delete all backup archives named "kenny-files":
     $ borg delete -a kenny-files
-    # actually free disk space:
+    # Actually free disk space:
     $ borg compact
 
-    # delete a specific backup archive using its unique archive ID prefix
+    # Delete a specific backup archive using its unique archive ID prefix
     $ borg delete aid:d34db33f
 
-    # delete all archives whose names begin with the machine's hostname followed by "-"
+    # Delete all archives whose names begin with the machine's hostname followed by "-"
     $ borg delete -a 'sh:{hostname}-*'
 
-    # delete all archives whose names contain "-2012-"
+    # Delete all archives whose names contain "-2012-"
     $ borg delete -a 'sh:*-2012-*'
 
-    # see what would be deleted if delete was run without --dry-run
+    # See what would be deleted if delete was run without --dry-run
     $ borg delete --list --dry-run -a 'sh:*-May-*'
 
diff --git a/docs/usage/general.rst b/docs/usage/general.rst
index 8d9e559f1f..3b9c266481 100644
--- a/docs/usage/general.rst
+++ b/docs/usage/general.rst
@@ -5,9 +5,9 @@ Borg consists of a number of commands. Each command accepts
 a number of arguments and options and interprets various environment variables.
 The following sections will describe each command in detail.
 
-Commands, options, parameters, paths and such are ``set in fixed-width``.
-Option values are `underlined`. Borg has few options accepting a fixed set
-of values (e.g. ``--encryption`` of :ref:`borg_repo-create`).
+Commands, options, parameters, paths, and similar elements are shown in fixed-width.
+Option values are underlined. Borg has a few options that accept a fixed set
+of values (e.g., ``--encryption`` of :ref:`borg_repo-create`).
 
 .. container:: experimental
 
@@ -18,7 +18,7 @@ of values (e.g. ``--encryption`` of :ref:`borg_repo-create`).
 
 .. include:: usage_general.rst.inc
 
-In case you are interested in more details (like formulas), please see
+If you are interested in more details (such as formulas), see
 :ref:`internals`. For details on the available JSON output, refer to
 :ref:`json_output`.
 
@@ -32,8 +32,8 @@ All Borg commands share these options:
 .. include:: common-options.rst.inc
 
 Option ``--help`` when used as a command works as expected on subcommands (e.g., ``borg help compact``).
-But it does not work when the help command is being used on sub-sub-commands (e.g., ``borg help key export``).
-The workaround for this to use the help command as a flag (e.g., ``borg key export --help``).
+But it does not work when the help command is used on sub-sub-commands (e.g., ``borg help key export``).
+The workaround for this is to use the help command as a flag (e.g., ``borg key export --help``).
 
 Examples
 ~~~~~~~~
diff --git a/docs/usage/general/date-time.rst.inc b/docs/usage/general/date-time.rst.inc
index 62a6d5c463..92cebd8bce 100644
--- a/docs/usage/general/date-time.rst.inc
+++ b/docs/usage/general/date-time.rst.inc
@@ -1,10 +1,10 @@
 Date and Time
 ~~~~~~~~~~~~~
 
-We format date and time conforming to ISO-8601, that is: YYYY-MM-DD and
-HH:MM:SS (24h clock).
+We format date and time in accordance with ISO 8601, that is: YYYY-MM-DD and
+HH:MM:SS (24-hour clock).
 
-For more information about that, see: https://xkcd.com/1179/
+For more information, see: https://xkcd.com/1179/
 
 Unless otherwise noted, we display local date and time.
 Internally, we store and process date and time as UTC.
@@ -14,5 +14,5 @@ Internally, we store and process date and time as UTC.
 
 Some options accept a TIMESPAN parameter, which can be given as a number of
 years (e.g. ``2y``), months (e.g. ``12m``), weeks (e.g. ``2w``),
-days (e.g.  ``7d``), hours (e.g. ``8H``), minutes (e.g. ``30M``),
-or seconds (e.g. ``150S``).
+days (e.g. ``7d``), hours (e.g. ``8h``), minutes (e.g. ``30m``),
+or seconds (e.g. ``150s``).
diff --git a/docs/usage/general/environment.rst.inc b/docs/usage/general/environment.rst.inc
index 593f5ac949..424c89f023 100644
--- a/docs/usage/general/environment.rst.inc
+++ b/docs/usage/general/environment.rst.inc
@@ -33,7 +33,7 @@ General:
         When set, use the value to answer the passphrase question when a **new** passphrase is asked for.
         This variable is checked first. If it is not set, BORG_PASSPHRASE and BORG_PASSCOMMAND will also
         be checked.
-        Main usecase for this is to automate fully ``borg change-passphrase``.
+        Main use case for this is to fully automate ``borg change-passphrase``.
     BORG_DISPLAY_PASSPHRASE
         When set, use the value to answer the "display the passphrase for verification" question when defining a new passphrase for encrypted repositories.
     BORG_DEBUG_PASSPHRASE
@@ -46,22 +46,22 @@ General:
         Borg usually computes a host id from the FQDN plus the results of ``uuid.getnode()`` (which usually returns
         a unique id based on the MAC address of the network interface. Except if that MAC happens to be all-zero - in
         that case it returns a random value, which is not what we want (because it kills automatic stale lock removal).
-        So, if you have a all-zero MAC address or other reasons to control better externally the host id, just set this
+        So, if you have an all-zero MAC address or other reasons to better control the host id externally, just set this
         environment variable to a unique value. If all your FQDNs are unique, you can just use the FQDN. If not,
-        use fqdn@uniqueid.
+        use FQDN@uniqueid.
     BORG_LOCK_WAIT
         You can set the default value for the ``--lock-wait`` option with this, so
-        you do not need to give it as a commandline option.
+        you do not need to give it as a command line option.
     BORG_LOGGING_CONF
         When set, use the given filename as INI_-style logging configuration.
         A basic example conf can be found at ``docs/misc/logging.conf``.
     BORG_RSH
         When set, use this command instead of ``ssh``. This can be used to specify ssh options, such as
         a custom identity file ``ssh -i /path/to/private/key``. See ``man ssh`` for other options. Using
-        the ``--rsh CMD`` commandline option overrides the environment variable.
+        the ``--rsh CMD`` command line option overrides the environment variable.
     BORG_REMOTE_PATH
         When set, use the given path as borg executable on the remote (defaults to "borg" if unset).
-        Using ``--remote-path PATH`` commandline option overrides the environment variable.
+        Using the ``--remote-path PATH`` command line option overrides the environment variable.
     BORG_REPO_PERMISSIONS
         Set repository permissions, see also: :ref:`borg_serve`
     BORG_FILES_CACHE_SUFFIX
@@ -79,7 +79,7 @@ General:
         exceptions is not shown.
         Please only use for good reasons as it makes issues harder to analyze.
     BORG_FUSE_IMPL
-        Choose the lowlevel FUSE implementation borg shall use for ``borg mount``.
+        Choose the low-level FUSE implementation borg shall use for ``borg mount``.
         This is a comma-separated list of implementation names, they are tried in the
         given order, e.g.:
 
@@ -89,15 +89,15 @@ General:
         - ``llfuse``: only try to load llfuse
         - ``none``: do not try to load an implementation
     BORG_SELFTEST
-        This can be used to influence borg's builtin self-tests. The default is to execute the tests
+        This can be used to influence borg's built-in self-tests. The default is to execute the tests
         at the beginning of each borg command invocation.
 
         BORG_SELFTEST=disabled can be used to switch off the tests and rather save some time.
         Disabling is not recommended for normal borg users, but large scale borg storage providers can
         use this to optimize production servers after at least doing a one-time test borg (with
-        selftests not disabled) when installing or upgrading machines / OS / borg.
+        self-tests not disabled) when installing or upgrading machines/OS/Borg.
     BORG_WORKAROUNDS
-        A list of comma separated strings that trigger workarounds in borg,
+        A list of comma-separated strings that trigger workarounds in borg,
         e.g. to work around bugs in other software.
 
         Currently known strings are:
@@ -107,7 +107,7 @@ General:
             You might need this to run borg on WSL (Windows Subsystem for Linux) or
             in systemd.nspawn containers on some architectures (e.g. ARM).
             Using this does not affect data safety, but might result in a more bursty
-            write to disk behaviour (not continuously streaming to disk).
+            write-to-disk behavior (not continuously streaming to disk).
 
         retry_erofs
             Retry opening a file without O_NOATIME if opening a file with O_NOATIME
diff --git a/docs/usage/general/file-metadata.rst.inc b/docs/usage/general/file-metadata.rst.inc
index c2921819e8..a01d72d3b6 100644
--- a/docs/usage/general/file-metadata.rst.inc
+++ b/docs/usage/general/file-metadata.rst.inc
@@ -3,15 +3,15 @@ Support for file metadata
 
 Besides regular file and directory structures, Borg can preserve
 
-* symlinks (stored as symlink, the symlink is not followed)
+* symlinks (stored as a symlink; the symlink is not followed)
 * special files:
 
-  * character and block device files (restored via mknod)
+  * character and block device files (restored via mknod(2))
   * FIFOs ("named pipes")
   * special file *contents* can be backed up in ``--read-special`` mode.
-    By default the metadata to create them with mknod(2), mkfifo(2) etc. is stored.
-* hardlinked regular files, devices, symlinks, FIFOs (considering all items in the same archive)
-* timestamps in nanosecond precision: mtime, atime, ctime
+    By default, the metadata to create them with mknod(2), mkfifo(2), etc. is stored.
+* hard-linked regular files, devices, symlinks, FIFOs (considering all items in the same archive)
+* timestamps with nanosecond precision: mtime, atime, ctime
 * other timestamps: birthtime (on platforms supporting it)
 * permissions:
 
@@ -42,10 +42,10 @@ On some platforms additional features are supported:
 | Windows (cygwin)        | No [4]_  | No        | No         |
 +-------------------------+----------+-----------+------------+
 
-Other Unix-like operating systems may work as well, but have not been tested at all.
+Other Unix-like operating systems may work as well, but have not been tested yet.
 
-Note that most of the platform-dependent features also depend on the file system.
-For example, ntfs-3g on Linux isn't able to convey NTFS ACLs.
+Note that most platform-dependent features also depend on the filesystem.
+For example, ntfs-3g on Linux is not able to convey NTFS ACLs.
 
 .. [1] Only "nodump", "immutable", "compressed" and "append" are supported.
     Feature request :issue:`618` for more flags.
@@ -54,8 +54,8 @@ For example, ntfs-3g on Linux isn't able to convey NTFS ACLs.
 .. [4] Cygwin tries to map NTFS ACLs to permissions with varying degrees of success.
 
 .. [#acls] The native access control list mechanism of the OS. This normally limits access to
-    non-native ACLs. For example, NTFS ACLs aren't completely accessible on Linux with ntfs-3g.
-.. [#xattr] extended attributes; key-value pairs attached to a file, mainly used by the OS.
-    This includes resource forks on Mac OS X.
-.. [#flags] aka *BSD flags*. The Linux set of flags [1]_ is portable across platforms.
+    non-native ACLs. For example, NTFS ACLs are not completely accessible on Linux with ntfs-3g.
+.. [#xattr] Extended attributes; key-value pairs attached to a file, mainly used by the OS.
+    This includes resource forks on macOS.
+.. [#flags] Also known as *BSD flags*. The Linux set of flags [1]_ is portable across platforms.
     The BSDs define additional flags.
diff --git a/docs/usage/general/file-systems.rst.inc b/docs/usage/general/file-systems.rst.inc
index 35dd1ef75e..5c3ec25c7e 100644
--- a/docs/usage/general/file-systems.rst.inc
+++ b/docs/usage/general/file-systems.rst.inc
@@ -2,36 +2,36 @@ File systems
 ~~~~~~~~~~~~
 
 We recommend using a reliable, scalable journaling filesystem for the
-repository, e.g. zfs, btrfs, ext4, apfs.
+repository, e.g., zfs, btrfs, ext4, apfs.
 
 Borg now uses the ``borgstore`` package to implement the key/value store it
 uses for the repository.
 
-It currently uses the ``file:`` Store (posixfs backend) either with a local
-directory or via ssh and a remote ``borg serve`` agent using borgstore on the
+It currently uses the ``file:`` store (posixfs backend) either with a local
+directory or via SSH and a remote ``borg serve`` agent using borgstore on the
 remote side.
 
 This means that it will store each chunk into a separate filesystem file
 (for more details, see the ``borgstore`` project).
 
-This has some pros and cons (compared to legacy borg 1.x's segment files):
+This has some pros and cons (compared to legacy Borg 1.x segment files):
 
 Pros:
 
-- Simplicity and better maintainability of the borg code.
-- Sometimes faster, less I/O, better scalability: e.g. borg compact can just
+- Simplicity and better maintainability of the Borg code.
+- Sometimes faster, less I/O, better scalability: e.g., borg compact can just
   remove unused chunks by deleting a single file and does not need to read
-  and re-write segment files to free space.
-- In future, easier to adapt to other kinds of storage:
+  and rewrite segment files to free space.
+- In the future, easier to adapt to other kinds of storage:
   borgstore's backends are quite simple to implement.
   ``sftp:`` and ``rclone:`` backends already exist, others might be easy to add.
 - Parallel repository access with less locking is easier to implement.
 
 Cons:
 
-- The repository filesystem will have to deal with a big amount of files (there
+- The repository filesystem will have to deal with a large number of files (there
   are provisions in borgstore against having too many files in a single directory
   by using a nested directory structure).
-- Bigger fs space usage overhead (will depend on allocation block size - modern
-  filesystems like zfs are rather clever here using a variable block size).
-- Sometimes slower, due to less sequential / more random access operations.
+- Greater filesystem space overhead (depends on the allocation block size — modern
+  filesystems like zfs are rather clever here, using a variable block size).
+- Sometimes slower, due to less sequential and more random access operations.
diff --git a/docs/usage/general/logging.rst.inc b/docs/usage/general/logging.rst.inc
index f13532fab0..2b556c7aeb 100644
--- a/docs/usage/general/logging.rst.inc
+++ b/docs/usage/general/logging.rst.inc
@@ -1,10 +1,9 @@
 Logging
 ~~~~~~~
 
-Borg writes all log output to stderr by default. But please note that something
-showing up on stderr does *not* indicate an error condition just because it is
-on stderr. Please check the log levels of the messages and the return code of
-borg for determining error, warning or success conditions.
+Borg writes all log output to stderr by default. However, output on stderr does
+not necessarily indicate an error. Check the log levels of the messages and the
+return code of borg to determine error, warning, or success conditions.
 
 If you want to capture the log output to a file, just redirect it:
 
@@ -15,30 +14,30 @@ If you want to capture the log output to a file, just redirect it:
 
 Custom logging configurations can be implemented via BORG_LOGGING_CONF.
 
-The log level of the builtin logging configuration defaults to WARNING.
+The log level of the built-in logging configuration defaults to WARNING.
 This is because we want Borg to be mostly silent and only output
-warnings, errors and critical messages, unless output has been requested
-by supplying an option that implies output (e.g. ``--list`` or ``--progress``).
+warnings, errors, and critical messages unless output has been requested
+by supplying an option that implies output (e.g., ``--list`` or ``--progress``).
 
 Log levels: DEBUG < INFO < WARNING < ERROR < CRITICAL
 
-Use ``--debug`` to set DEBUG log level -
-to get debug, info, warning, error and critical level output.
+Use ``--debug`` to set the DEBUG log level —
+this prints debug, info, warning, error, and critical messages.
 
-Use ``--info`` (or ``-v`` or ``--verbose``) to set INFO log level -
-to get info, warning, error and critical level output.
+Use ``--info`` (or ``-v`` or ``--verbose``) to set the INFO log level —
+this prints info, warning, error, and critical messages.
 
-Use ``--warning`` (default) to set WARNING log level -
-to get warning, error and critical level output.
+Use ``--warning`` (default) to set the WARNING log level —
+this prints warning, error, and critical messages.
 
-Use ``--error`` to set ERROR log level -
-to get error and critical level output.
+Use ``--error`` to set the ERROR log level —
+this prints error and critical messages.
 
-Use ``--critical`` to set CRITICAL log level -
-to get critical level output.
+Use ``--critical`` to set the CRITICAL log level —
+this prints only critical messages.
 
-While you can set misc. log levels, do not expect that every command will
-give different output on different log levels - it's just a possibility.
+While you can set miscellaneous log levels, do not expect every command to
+produce different output at different log levels — it's merely a possibility.
 
 .. warning:: Options ``--critical`` and ``--error`` are provided for completeness,
              their usage is not recommended as you might miss important information.
diff --git a/docs/usage/general/positional-arguments.rst.inc b/docs/usage/general/positional-arguments.rst.inc
index f397237ee4..625e8ad76b 100644
--- a/docs/usage/general/positional-arguments.rst.inc
+++ b/docs/usage/general/positional-arguments.rst.inc
@@ -2,7 +2,7 @@ Positional Arguments and Options: Order matters
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Borg only supports taking options (``-s`` and ``--progress`` in the example)
-to the left or right of all positional arguments (``repo::archive`` and ``path``
+either to the left or to the right of all positional arguments (``repo::archive`` and ``path``
 in the example), but not in between them:
 
 ::
diff --git a/docs/usage/general/repository-locations.rst.inc b/docs/usage/general/repository-locations.rst.inc
index b8baa62c35..9d5cc19792 100644
--- a/docs/usage/general/repository-locations.rst.inc
+++ b/docs/usage/general/repository-locations.rst.inc
@@ -1,14 +1,14 @@
-Repository Locations / Archive names
+Repository Locations / Archive Names
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-Many commands need to know the repository location, give it via ``-r`` / ``--repo``
+Many commands need to know the repository location; specify it via ``-r``/``--repo``
 or use the ``BORG_REPO`` environment variable.
 
-Commands needing one or two archive names usually get them as positional argument.
+Commands that need one or two archive names usually take them as positional arguments.
 
-Commands working with an arbitrary amount of archives, usually take ``-a ARCH_GLOB``.
+Commands that work with an arbitrary number of archives usually accept ``-a ARCH_GLOB``.
 
 Archive names must not contain the ``/`` (slash) character. For simplicity,
-maybe also avoid blanks or other characters that have special meaning on the
-shell or in a filesystem (borg mount will use the archive name as directory
+also avoid spaces or other characters that have special meaning to the
+shell or in a filesystem (Borg mount uses the archive name as a directory
 name).
diff --git a/docs/usage/general/repository-urls.rst.inc b/docs/usage/general/repository-urls.rst.inc
index f7209c7700..5cda0aaa26 100644
--- a/docs/usage/general/repository-urls.rst.inc
+++ b/docs/usage/general/repository-urls.rst.inc
@@ -3,48 +3,48 @@ Repository URLs
 
 **Local filesystem** (or locally mounted network filesystem):
 
-``/path/to/repo`` - filesystem path to repo directory, absolute path
+``/path/to/repo`` — filesystem path to the repository directory (absolute path)
 
-``path/to/repo`` - filesystem path to repo directory, relative path
+``path/to/repo`` — filesystem path to the repository directory (relative path)
 
-Also, stuff like ``~/path/to/repo`` or ``~other/path/to/repo`` works (this is
+Also, paths like ``~/path/to/repo`` or ``~other/path/to/repo`` work (this is
 expanded by your shell).
 
-Note: you may also prepend a ``file://`` to a filesystem path to get URL style.
+Note: You may also prepend ``file://`` to a filesystem path to use URL style.
 
-**Remote repositories** accessed via ssh user@host:
+**Remote repositories** accessed via SSH user@host:
 
-``ssh://user@host:port//abs/path/to/repo`` - absolute path
+``ssh://user@host:port//abs/path/to/repo`` — absolute path
 
-``ssh://user@host:port/rel/path/to/repo`` - path relative to current directory
+``ssh://user@host:port/rel/path/to/repo`` — path relative to the current directory
 
-**Remote repositories** accessed via sftp:
+**Remote repositories** accessed via SFTP:
 
-``sftp://user@host:port//abs/path/to/repo`` - absolute path
+``sftp://user@host:port//abs/path/to/repo`` — absolute path
 
-``sftp://user@host:port/rel/path/to/repo`` - path relative to current directory
+``sftp://user@host:port/rel/path/to/repo`` — path relative to the current directory
 
-For ssh and sftp URLs, the ``user@`` and ``:port`` parts are optional.
+For SSH and SFTP URLs, the ``user@`` and ``:port`` parts are optional.
 
 **Remote repositories** accessed via rclone:
 
-``rclone:remote:path`` - see the rclone docs for more details about remote:path.
+``rclone:remote:path`` — see the rclone docs for more details about ``remote:path``.
 
 **Remote repositories** accessed via S3:
 
-``(s3|b2):[profile|(access_key_id:access_key_secret)@][schema://hostname[:port]]/bucket/path`` - see the boto3 docs for more details about the credentials.
+``(s3|b2):[profile|(access_key_id:access_key_secret)@][schema://hostname[:port]]/bucket/path`` — see the boto3 docs for more details about credentials.
 
-If you're connecting to AWS S3, ``[schema://hostname[:port]]`` is optional, but ``bucket`` and ``path`` are always required.
+If you are connecting to AWS S3, ``[schema://hostname[:port]]`` is optional, but ``bucket`` and ``path`` are always required.
 
-Note: There is a known issue with some S3-compatible services, e.g., Backblaze B2. If you encounter problems, try using ``b2:`` instead of ``s3:`` in the url.
+Note: There is a known issue with some S3-compatible services, e.g., Backblaze B2. If you encounter problems, try using ``b2:`` instead of ``s3:`` in the URL.
 
 
-If you frequently need the same repo URL, it is a good idea to set the
-``BORG_REPO`` environment variable to set a default for the repo URL:
+If you frequently need the same repository URL, it is a good idea to set the
+``BORG_REPO`` environment variable to set a default repository URL:
 
 ::
 
     export BORG_REPO='ssh://user@host:port/rel/path/to/repo'
 
-Then just leave away the ``--repo`` option if you want
-to use the default - it will be read from BORG_REPO then.
+Then simply omit the ``--repo`` option when you want
+to use the default — it will be read from BORG_REPO.
diff --git a/docs/usage/general/resources.rst.inc b/docs/usage/general/resources.rst.inc
index d8ce1b24e4..344ac237f1 100644
--- a/docs/usage/general/resources.rst.inc
+++ b/docs/usage/general/resources.rst.inc
@@ -1,31 +1,31 @@
 Resource Usage
 ~~~~~~~~~~~~~~
 
-Borg might use a lot of resources depending on the size of the data set it is dealing with.
+Borg might use significant resources depending on the size of the data set it is dealing with.
 
-If one uses Borg in a client/server way (with a ssh: repository),
-the resource usage occurs in part on the client and in another part on the
+If you use Borg in a client/server way (with an SSH repository),
+the resource usage occurs partly on the client and partly on the
 server.
 
-If one uses Borg as a single process (with a filesystem repo),
-all the resource usage occurs in that one process, so just add up client +
+If you use Borg as a single process (with a filesystem repository),
+all resource usage occurs in that one process, so add up client and
 server to get the approximate resource usage.
 
 CPU client:
-    - **borg create:** does chunking, hashing, compression, crypto (high CPU usage)
-    - **chunks cache sync:** quite heavy on CPU, doing lots of hashtable operations.
-    - **borg extract:** crypto, decompression (medium to high CPU usage)
-    - **borg check:** similar to extract, but depends on options given.
-    - **borg prune / borg delete archive:** low to medium CPU usage
+    - **borg create:** chunking, hashing, compression, encryption (high CPU usage)
+    - **chunks cache sync:** quite heavy on CPU, doing lots of hash table operations
+    - **borg extract:** decryption, decompression (medium to high CPU usage)
+    - **borg check:** similar to extract, but depends on options given
+    - **borg prune/borg delete archive:** low to medium CPU usage
     - **borg delete repo:** done on the server
 
-    It won't go beyond 100% of 1 core as the code is currently single-threaded.
+    It will not use more than 100% of one CPU core as the code is currently single-threaded.
     Especially higher zlib and lzma compression levels use significant amounts
-    of CPU cycles. Crypto might be cheap on the CPU (if hardware accelerated) or
+    of CPU cycles. Crypto might be cheap on the CPU (if hardware-accelerated) or
     expensive (if not).
 
 CPU server:
-    It usually doesn't need much CPU, it just deals with the key/value store
+    It usually does not need much CPU; it just deals with the key/value store
     (repository) and uses the repository index for that.
 
     borg check: the repository check computes the checksums of all chunks
@@ -33,15 +33,15 @@ CPU server:
     borg delete repo: low CPU usage
 
 CPU (only for client/server operation):
-    When using borg in a client/server way with a ssh:-type repo, the ssh
+    When using Borg in a client/server way with an ssh-type repository, the SSH
     processes used for the transport layer will need some CPU on the client and
-    on the server due to the crypto they are doing - esp. if you are pumping
-    big amounts of data.
+    on the server due to the crypto they are doing—especially if you are pumping
+    large amounts of data.
 
 Memory (RAM) client:
     The chunks index and the files index are read into memory for performance
-    reasons. Might need big amounts of memory (see below).
-    Compression, esp. lzma compression with high levels might need substantial
+    reasons. Might need large amounts of memory (see below).
+    Compression, especially lzma compression with high levels, might need substantial
     amounts of memory.
 
 Memory (RAM) server:
@@ -49,47 +49,47 @@ Memory (RAM) server:
     considerable amounts of memory, but less than on the client (see below).
 
 Chunks index (client only):
-    Proportional to the amount of data chunks in your repo. Lots of chunks
+    Proportional to the number of data chunks in your repo. Lots of chunks
     in your repo imply a big chunks index.
-    It is possible to tweak the chunker params (see create options).
+    It is possible to tweak the chunker parameters (see create options).
 
 Files index (client only):
-    Proportional to the amount of files in your last backups. Can be switched
-    off (see create options), but next backup might be much slower if you do.
+    Proportional to the number of files in your last backups. Can be switched
+    off (see create options), but the next backup might be much slower if you do.
     The speed benefit of using the files cache is proportional to file size.
 
 Repository index (server only):
-    Proportional to the amount of data chunks in your repo. Lots of chunks
+    Proportional to the number of data chunks in your repo. Lots of chunks
     in your repo imply a big repository index.
-    It is possible to tweak the chunker params (see create options) to
-    influence the amount of chunks being created.
+    It is possible to tweak the chunker parameters (see create options) to
+    influence the number of chunks created.
 
 Temporary files (client):
-    Reading data and metadata from a FUSE mounted repository will consume up to
+    Reading data and metadata from a FUSE-mounted repository will consume up to
     the size of all deduplicated, small chunks in the repository. Big chunks
-    won't be locally cached.
+    will not be locally cached.
 
 Temporary files (server):
-    A non-trivial amount of data will be stored on the remote temp directory
+    A non-trivial amount of data will be stored in the remote temporary directory
     for each client that connects to it. For some remotes, this can fill the
-    default temporary directory at /tmp. This can be remediated by ensuring the
+    default temporary directory in /tmp. This can be mitigated by ensuring the
     $TMPDIR, $TEMP, or $TMP environment variable is properly set for the sshd
     process.
-    For some OSes, this can be done just by setting the correct value in the
-    .bashrc (or equivalent login config file for other shells), however in
+    For some OSes, this can be done by setting the correct value in the
+    .bashrc (or equivalent login config file for other shells); however, in
     other cases it may be necessary to first enable ``PermitUserEnvironment yes``
     in your ``sshd_config`` file, then add ``environment="TMPDIR=/my/big/tmpdir"``
-    at the start of the public key to be used in the ``authorized_hosts`` file.
+    at the start of the public key to be used in the ``authorized_keys`` file.
 
 Cache files (client only):
     Contains the chunks index and files index (plus a collection of single-
-    archive chunk indexes which might need huge amounts of disk space,
-    depending on archive count and size - see FAQ about how to reduce).
+    archive chunk indexes), which might need huge amounts of disk space
+    depending on archive count and size — see the FAQ for how to reduce this.
 
 Network (only for client/server operation):
     If your repository is remote, all deduplicated (and optionally compressed/
-    encrypted) data of course has to go over the connection (``ssh://`` repo url).
-    If you use a locally mounted network filesystem, additionally some copy
+    encrypted) data has to go over the connection (``ssh://`` repository URL).
+    If you use a locally mounted network filesystem, some additional copy
     operations used for transaction support also go over the connection. If
     you back up multiple sources to one target repository, additional traffic
     happens for cache resynchronization.
diff --git a/docs/usage/general/return-codes.rst.inc b/docs/usage/general/return-codes.rst.inc
index b4547b62bb..266757b56c 100644
--- a/docs/usage/general/return-codes.rst.inc
+++ b/docs/usage/general/return-codes.rst.inc
@@ -7,10 +7,10 @@ Borg can exit with the following return codes (rc):
 Return code Meaning
 =========== =======
 0           success (logged as INFO)
-1           generic warning (operation reached its normal end, but there were warnings --
-            you should check the log, logged as WARNING)
-2           generic error (like a fatal error, a local or remote exception, the operation
-            did not reach its normal end, logged as ERROR)
+1           generic warning (operation reached its normal end, but there were warnings —
+            you should check the log; logged as WARNING)
+2           generic error (like a fatal error or a local/remote exception; the operation
+            did not reach its normal end; logged as ERROR)
 3..99       specific error (enabled by BORG_EXIT_CODES=modern)
 100..127    specific warning (enabled by BORG_EXIT_CODES=modern)
 128+N       killed by signal N (e.g. 137 == kill -9)
@@ -19,4 +19,4 @@ Return code Meaning
 If you use ``--show-rc``, the return code is also logged at the indicated
 level as the last log entry.
 
-The modern exit codes (return codes, "rc") are documented there: :ref:`msgid`
+The modern exit codes (return codes, "rc") are documented here: see :ref:`msgid`.
diff --git a/docs/usage/mount.rst b/docs/usage/mount.rst
index 53deef570c..42272a6fbe 100644
--- a/docs/usage/mount.rst
+++ b/docs/usage/mount.rst
@@ -43,7 +43,7 @@ borgfs
     $ echo '/mnt/backup /tmp/myrepo fuse.borgfs defaults,noauto 0 0' >> /etc/fstab
     $ mount /tmp/myrepo
     $ ls /tmp/myrepo
-    root-2016-02-01 root-2016-02-2015
+    root-2016-02-01 root-2016-02-15
 
 .. Note::
 
diff --git a/docs/usage/notes.rst b/docs/usage/notes.rst
index 98fd5a785a..b40666ebb3 100644
--- a/docs/usage/notes.rst
+++ b/docs/usage/notes.rst
@@ -1,41 +1,41 @@
 Additional Notes
 ----------------
 
-Here are misc. notes about topics that are maybe not covered in enough detail in the usage section.
+Here are miscellaneous notes about topics that may not be covered in enough detail in the usage section.
 
 .. _chunker-params:
 
 ``--chunker-params``
 ~~~~~~~~~~~~~~~~~~~~
 
-The chunker params influence how input files are cut into pieces (chunks)
+The chunker parameters influence how input files are cut into pieces (chunks)
 which are then considered for deduplication. They also have a big impact on
 resource usage (RAM and disk space) as the amount of resources needed is
-(also) determined by the total amount of chunks in the repository (see
+(also) determined by the total number of chunks in the repository (see
 :ref:`cache-memory-usage` for details).
 
 ``--chunker-params=buzhash,10,23,16,4095`` results in a fine-grained deduplication|
-and creates a big amount of chunks and thus uses a lot of resources to manage
+and creates a large number of chunks and thus uses a lot of resources to manage
 them. This is good for relatively small data volumes and if the machine has a
 good amount of free RAM and disk space.
 
 ``--chunker-params=buzhash,19,23,21,4095`` (default) results in a coarse-grained
-deduplication and creates a much smaller amount of chunks and thus uses less
+deduplication and creates a much smaller number of chunks and thus uses less
 resources. This is good for relatively big data volumes and if the machine has
 a relatively low amount of free RAM and disk space.
 
-``--chunker-params=fixed,4194304`` results in fixed 4MiB sized block
-deduplication and is more efficient than the previous example when used for
+``--chunker-params=fixed,4194304`` results in fixed 4 MiB-sized block
+deduplication and is more efficient than the previous example when used with
 for block devices (like disks, partitions, LVM LVs) or raw disk image files.
 
-``--chunker-params=fixed,4096,512`` results in fixed 4kiB sized blocks,
+``--chunker-params=fixed,4096,512`` results in fixed 4 KiB-sized blocks,
 but the first header block will only be 512B long. This might be useful to
 dedup files with 1 header + N fixed size data blocks. Be careful not to
-produce a too big amount of chunks (like using small block size for huge
+produce too many chunks (for example, using a small block size for huge
 files).
 
-If you already have made some archives in a repository and you then change
-chunker params, this of course impacts deduplication as the chunks will be
+If you have already created some archives in a repository and then change
+chunker parameters, this of course impacts deduplication as the chunks will be
 cut differently.
 
 In the worst case (all files are big and were touched in between backups), this
@@ -45,17 +45,17 @@ Usually, it is not that bad though:
 
 - usually most files are not touched, so it will just re-use the old chunks
   it already has in the repo
-- files smaller than the (both old and new) minimum chunksize result in only
-  one chunk anyway, so the resulting chunks are same and deduplication will apply
+- files smaller than the (both old and new) minimum chunk size result in only
+  one chunk anyway, so the resulting chunks are the same and deduplication will apply
 
-If you switch chunker params to save resources for an existing repo that
+If you switch chunker parameters to save resources for an existing repository that
 already has some backup archives, you will see an increasing effect over time,
 when more and more files have been touched and stored again using the bigger
-chunksize **and** all references to the smaller older chunks have been removed
+chunk size **and** all references to the smaller, older chunks have been removed
 (by deleting / pruning archives).
 
-If you want to see an immediate big effect on resource usage, you better start
-a new repository when changing chunker params.
+If you want to see an immediate, significant effect on resource usage, you should start
+a new repository when changing chunker parameters.
 
 For more details, see :ref:`chunker_details`.
 
@@ -63,19 +63,19 @@ For more details, see :ref:`chunker_details`.
 ``--noatime / --noctime``
 ~~~~~~~~~~~~~~~~~~~~~~~~~
 
-You can use these ``borg create`` options not to store the respective timestamp
+You can use these ``borg create`` options to not store the respective timestamp
 into the archive, in case you do not really need it.
 
-Besides saving a little space for the not archived timestamp, it might also
+Besides saving a little space by omitting the timestamp, it might also
 affect metadata stream deduplication: if only this timestamp changes between
 backups and is stored into the metadata stream, the metadata stream chunks
-won't deduplicate just because of that.
+will not deduplicate just because of that.
 
 ``--nobsdflags / --noflags``
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-You can use this not to query and store (or not extract and set) flags - in case
-you don't need them or if they are broken somehow for your fs.
+You can use this to avoid querying and storing (or extracting and setting) flags — in case
+you don't need them or if they are broken for your filesystem.
 
 On Linux, dealing with the flags needs some additional syscalls. Especially when
 dealing with lots of small files, this causes a noticeable overhead, so you can
diff --git a/docs/usage/prune.rst b/docs/usage/prune.rst
index 4784982631..74aeed49eb 100644
--- a/docs/usage/prune.rst
+++ b/docs/usage/prune.rst
@@ -3,25 +3,25 @@
 Examples
 ~~~~~~~~
 
-Be careful, prune is a potentially dangerous command, it will remove backup
+Be careful: prune is a potentially dangerous command that removes backup
 archives.
 
-The default of prune is to apply to **all archives in the repository** unless
-you restrict its operation to a subset of the archives.
+By default, prune applies to **all archives in the repository** unless you
+restrict its operation to a subset of the archives.
 
 The recommended way to name archives (with ``borg create``) is to use the
 identical archive name within a series of archives. Then you can simply give
-that name to prune also, so it operates just on that series of archives.
+that name to prune as well, so it operates only on that series of archives.
 
-Alternatively, you can use ``-a`` / ``--match-archives`` to do a match on the
-archive names to select some of them.
-When using ``-a``, be careful to choose a good pattern - e.g. do not use a
+Alternatively, you can use ``-a``/``--match-archives`` to match archive names
+and select a subset of them.
+When using ``-a``, be careful to choose a good pattern — for example, do not use a
 prefix "foo" if you do not also want to match "foobar".
 
 It is strongly recommended to always run ``prune -v --list --dry-run ...``
-first so you will see what it would do without it actually doing anything.
+first, so you will see what it would do without it actually doing anything.
 
-Don't forget to run ``borg compact -v`` after prune to actually free disk space.
+Do not forget to run ``borg compact -v`` after prune to actually free disk space.
 
 ::
 
@@ -29,11 +29,11 @@ Don't forget to run ``borg compact -v`` after prune to actually free disk space.
     # Do a dry-run without actually deleting anything.
     $ borg prune -v --list --dry-run --keep-daily=7 --keep-weekly=4
 
-    # Similar as above but only apply to the archive series named '{hostname}':
+    # Similar to the above, but only apply to the archive series named '{hostname}':
     $ borg prune -v --list --keep-daily=7 --keep-weekly=4 '{hostname}'
 
-    # Similar as above but apply to archive names starting with the hostname
-    # of the machine followed by a "-" character:
+    # Similar to the above, but apply to archive names starting with the hostname
+    # of the machine followed by a '-' character:
     $ borg prune -v --list --keep-daily=7 --keep-weekly=4 -a 'sh:{hostname}-*'
 
     # Keep 7 end of day, 4 additional end of week archives,
diff --git a/docs/usage/recreate.rst b/docs/usage/recreate.rst
index c10df4ae59..89c5b257fb 100644
--- a/docs/usage/recreate.rst
+++ b/docs/usage/recreate.rst
@@ -4,17 +4,17 @@ Examples
 ~~~~~~~~
 ::
 
-    # Create a backup with little but fast compression
+    # Create a backup with fast, low compression
     $ borg create archive /some/files --compression lz4
-    # Then compress it - this might take longer, but the backup has already completed,
-    # so no inconsistencies from a long-running backup job.
+    # Then recompress it — this might take longer, but the backup has already completed,
+    # so there are no inconsistencies from a long-running backup job.
     $ borg recreate -a archive --recompress --compression zlib,9
 
     # Remove unwanted files from all archives in a repository.
-    # Note the relative path for the --exclude option - archives only contain relative paths.
+    # Note the relative path for the --exclude option — archives only contain relative paths.
     $ borg recreate --exclude home/icke/Pictures/drunk_photos
 
-    # Change archive comment
+    # Change the archive comment
     $ borg create --comment "This is a comment" archivename ~
     $ borg info -a archivename
     Name: archivename
diff --git a/docs/usage/repo-compress.rst b/docs/usage/repo-compress.rst
index aff6adc30b..813db94191 100644
--- a/docs/usage/repo-compress.rst
+++ b/docs/usage/repo-compress.rst
@@ -5,8 +5,8 @@ Examples
 
 ::
 
-    # recompress repo contents
+    # Recompress repository contents
     $ borg repo-compress --progress --compression=zstd,3
 
-    # recompress and obfuscate repo contents
+    # Recompress and obfuscate repository contents
     $ borg repo-compress --progress --compression=obfuscate,1,zstd,3
diff --git a/docs/usage/repo-create.rst b/docs/usage/repo-create.rst
index 87fc1c24f0..2a61f27440 100644
--- a/docs/usage/repo-create.rst
+++ b/docs/usage/repo-create.rst
@@ -8,20 +8,20 @@ Examples
 
     # Local repository
     $ export BORG_REPO=/path/to/repo
-    # recommended repokey AEAD crypto modes
+    # Recommended repokey AEAD cryptographic modes
     $ borg repo-create --encryption=repokey-aes-ocb
     $ borg repo-create --encryption=repokey-chacha20-poly1305
     $ borg repo-create --encryption=repokey-blake2-aes-ocb
     $ borg repo-create --encryption=repokey-blake2-chacha20-poly1305
-    # no encryption, not recommended
+    # No encryption (not recommended)
     $ borg repo-create --encryption=authenticated
     $ borg repo-create --encryption=authenticated-blake2
     $ borg repo-create --encryption=none
 
-    # Remote repository (accesses a remote borg via ssh)
+    # Remote repository (accesses a remote Borg via SSH)
     $ export BORG_REPO=ssh://user@hostname/~/backup
-    # repokey: stores the (encrypted) key into <REPO_DIR>/config
+    # repokey: stores the encrypted key in <REPO_DIR>/config
     $ borg repo-create --encryption=repokey-aes-ocb
-    # keyfile: stores the (encrypted) key into ~/.config/borg/keys/
+    # keyfile: stores the encrypted key in ~/.config/borg/keys/
     $ borg repo-create --encryption=keyfile-aes-ocb
 
diff --git a/docs/usage/serve.rst b/docs/usage/serve.rst
index d54aad1b5d..e9838796b5 100644
--- a/docs/usage/serve.rst
+++ b/docs/usage/serve.rst
@@ -38,12 +38,12 @@ locations like ``/etc/environment`` or in the forced command itself (example bel
 .. note::
     The examples above use the ``restrict`` directive and assume a POSIX
     compliant shell set as the user's login shell.
-    This does automatically block potential dangerous ssh features, even when
+    This automatically blocks potentially dangerous SSH features, even when
     they are added in a future update. Thus, this option should be preferred.
 
-    If you're using openssh-server < 7.2, however, you have to specify explicitly
-    the ssh features to restrict and cannot simply use the restrict option as it
-    has been introduced in v7.2. We recommend to use
+    If you are using OpenSSH server < 7.2, however, you must explicitly
+    specify the SSH features to restrict and cannot simply use the ``restrict`` option, as it
+    was introduced in v7.2. We recommend using
     ``no-port-forwarding,no-X11-forwarding,no-pty,no-agent-forwarding,no-user-rc``
     in this case.
 
@@ -56,9 +56,9 @@ SSH Configuration
 
 ``borg serve``'s pipes (``stdin``/``stdout``/``stderr``) are connected to the ``sshd`` process on the server side. In the event that the SSH connection between ``borg serve`` and the client is disconnected or stuck abnormally (for example, due to a network outage), it can take a long time for ``sshd`` to notice the client is disconnected. In the meantime, ``sshd`` continues running, and as a result so does the ``borg serve`` process holding the lock on the repository. This can cause subsequent ``borg`` operations on the remote repository to fail with the error: ``Failed to create/acquire the lock``.
 
-In order to avoid this, it is recommended to perform the following additional SSH configuration:
+To avoid this, it is recommended to perform the following additional SSH configuration:
 
-Either in the client side's ``~/.ssh/config`` file, or in the client's ``/etc/ssh/ssh_config`` file:
+Either in the client-side ``~/.ssh/config`` file or in the client's ``/etc/ssh/ssh_config`` file:
 ::
 
     Host backupserver
@@ -67,15 +67,15 @@ Either in the client side's ``~/.ssh/config`` file, or in the client's ``/etc/ss
 
 Replacing ``backupserver`` with the hostname, FQDN or IP address of the borg server.
 
-This will cause the client to send a keepalive to the server every 10 seconds. If 30 consecutive keepalives are sent without a response (a time of 300 seconds), the ssh client process will be terminated, causing the borg process to terminate gracefully.
+This will cause the client to send a keepalive to the server every 10 seconds. If 30 consecutive keepalives are sent without a response (a time of 300 seconds), the SSH client process will be terminated, causing the borg process to terminate gracefully.
 
-On the server side's ``sshd`` configuration file (typically ``/etc/ssh/sshd_config``):
+In the server-side ``sshd`` configuration file (typically ``/etc/ssh/sshd_config``):
 ::
 
     ClientAliveInterval 10
     ClientAliveCountMax 30
 
-This will cause the server to send a keep alive to the client every 10 seconds. If 30 consecutive keepalives are sent without a response (a time of 300 seconds), the server's sshd process will be terminated, causing the ``borg serve`` process to terminate gracefully and release the lock on the repository.
+This will cause the server to send a keepalive to the client every 10 seconds. If 30 consecutive keepalives are sent without a response (a time of 300 seconds), the server's sshd process will be terminated, causing the ``borg serve`` process to terminate gracefully and release the lock on the repository.
 
 If you then run borg commands with ``--lock-wait 600``, this gives sufficient time for the borg serve processes to terminate after the SSH connection is torn down after the 300 second wait for the keepalives to fail.
 
@@ -87,7 +87,7 @@ not be such a simple implementation)::
 
   chsh -s /bin/sh BORGUSER
 
-Because the configured shell is used by `openssh <https://www.openssh.com/>`_
+Because the configured shell is used by `OpenSSH <https://www.openssh.com/>`_
 to execute the command configured through the ``authorized_keys`` file
 using ``"$SHELL" -c "$COMMAND"``,
 setting a minimal shell implementation reduces the attack surface
diff --git a/docs/usage/tar.rst b/docs/usage/tar.rst
index ee5c0a3469..f20ea8c673 100644
--- a/docs/usage/tar.rst
+++ b/docs/usage/tar.rst
@@ -6,25 +6,25 @@ Examples
 ~~~~~~~~
 ::
 
-    # export as uncompressed tar
+    # Export as an uncompressed tar archive
     $ borg export-tar Monday Monday.tar
 
-    # import an uncompressed tar
+    # Import an uncompressed tar archive
     $ borg import-tar Monday Monday.tar
 
-    # exclude some file types, compress using gzip
+    # Exclude some file types and compress using gzip
     $ borg export-tar Monday Monday.tar.gz --exclude '*.so'
 
-    # use higher compression level with gzip
+    # Use a higher compression level with gzip
     $ borg export-tar --tar-filter="gzip -9" Monday Monday.tar.gz
 
-    # copy an archive from repoA to repoB
+    # Copy an archive from repoA to repoB
     $ borg -r repoA export-tar --tar-format=BORG archive - | borg -r repoB import-tar archive -
 
-    # export a tar, but instead of storing it on disk, upload it to remote site using curl
+    # Export a tar, but instead of storing it on disk, upload it to a remote site using curl
     $ borg export-tar Monday - | curl --data-binary @- https://somewhere/to/POST
 
-    # remote extraction via "tarpipe"
+    # Remote extraction via 'tarpipe'
     $ borg export-tar Monday - | ssh somewhere "cd extracted; tar x"
 
 Archives transfer script
@@ -46,7 +46,7 @@ Kept:
 
 Lost:
 
-- some archive metadata (like the original commandline, execution time, etc.)
+- some archive metadata (like the original command line, execution time, etc.)
 
 Please note:
 
diff --git a/docs/usage/transfer.rst b/docs/usage/transfer.rst
index 6d519e3d0b..ad719313f5 100644
--- a/docs/usage/transfer.rst
+++ b/docs/usage/transfer.rst
@@ -4,17 +4,17 @@ Examples
 ~~~~~~~~
 ::
 
-    # 0. Have borg 2.0 installed on client AND server, have a b12 repo copy for testing.
+    # 0. Have Borg 2.0 installed on the client AND server; have a b12 repository copy for testing.
 
     # 1. Create a new "related" repository:
-    # here, the existing borg 1.2 repo used repokey-blake2 (and aes-ctr mode),
-    # thus we use repokey-blake2-aes-ocb for the new borg 2.0 repo.
-    # staying with the same chunk id algorithm (blake2) and with the same
+    # Here, the existing Borg 1.2 repository used repokey-blake2 (and AES-CTR mode),
+    # thus we use repokey-blake2-aes-ocb for the new Borg 2.0 repository.
+    # Staying with the same chunk ID algorithm (BLAKE2) and with the same
     # key material (via --other-repo <oldrepo>) will make deduplication work
     # between old archives (copied with borg transfer) and future ones.
-    # the AEAD cipher does not matter (everything must be re-encrypted and
-    # re-authenticated anyway), you could also choose repokey-blake2-chacha20-poly1305.
-    # in case your old borg repo did not use blake2, just remove the "-blake2".
+    # The AEAD cipher does not matter (everything must be re-encrypted and
+    # re-authenticated anyway); you could also choose repokey-blake2-chacha20-poly1305.
+    # In case your old Borg repository did not use BLAKE2, just remove the "-blake2".
     $ borg --repo       ssh://borg2@borgbackup/./tests/b20 repo-create \
            --other-repo ssh://borg2@borgbackup/./tests/b12 -e repokey-blake2-aes-ocb
 
@@ -22,11 +22,11 @@ Examples
     $ borg --repo       ssh://borg2@borgbackup/./tests/b20 transfer --upgrader=From12To20 \
            --other-repo ssh://borg2@borgbackup/./tests/b12 --dry-run
 
-    # 3. Transfer (copy) archives from old repo into new repo (takes time and space!):
+    # 3. Transfer (copy) archives from the old repository into the new repository (takes time and space!):
     $ borg --repo       ssh://borg2@borgbackup/./tests/b20 transfer --upgrader=From12To20 \
            --other-repo ssh://borg2@borgbackup/./tests/b12
 
-    # 4. Check if we have everything (same as 2.):
+    # 4. Check whether we have everything (same as step 2):
     $ borg --repo       ssh://borg2@borgbackup/./tests/b20 transfer --upgrader=From12To20 \
            --other-repo ssh://borg2@borgbackup/./tests/b12 --dry-run
 
diff --git a/pyproject.toml b/pyproject.toml
index 14ada71a46..29f1d98bcb 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -5,7 +5,7 @@ authors = [{name="The Borg Collective (see AUTHORS file)"}]
 maintainers = [
     {name="Thomas Waldmann", email="tw@waldmann-edv.de"},
 ]
-description = "Deduplicated, encrypted, authenticated and compressed backups"
+description = "Deduplicated, encrypted, authenticated, and compressed backups"
 requires-python = ">=3.10"
 keywords = ["backup", "borgbackup"]
 classifiers = [
@@ -34,7 +34,7 @@ dependencies = [
   "borgstore ~= 0.3.0",
   "msgpack >=1.0.3, <=1.1.1",
   "packaging",
-  "platformdirs >=3.0.0, <5.0.0; sys_platform == 'darwin'",  # for macOS: breaking changes in 3.0.0,
+  "platformdirs >=3.0.0, <5.0.0; sys_platform == 'darwin'",  # for macOS: breaking changes in 3.0.0.
   "platformdirs >=2.6.0, <5.0.0; sys_platform != 'darwin'",  # for others: 2.6+ works consistently.
   "argon2-cffi",
 ]
@@ -74,7 +74,7 @@ requires = ["setuptools>=77.0.0", "wheel", "pkgconfig", "Cython>=3.0.3", "setupt
 build-backend = "setuptools.build_meta"
 
 [tool.setuptools_scm]
-# make sure we have the same versioning scheme with all setuptools_scm versions, to avoid different autogenerated files
+# Make sure we have the same versioning scheme with all setuptools_scm versions, to avoid different autogenerated files.
 # https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=1015052
 # https://github.com/borgbackup/borg/issues/6875
 write_to = "src/borg/_version.py"
@@ -99,10 +99,10 @@ select = ["E", "F"]
 #   F811 redef of unused var
 
 # borg code style guidelines:
-# Ignoring E203 due to https://github.com/PyCQA/pycodestyle/issues/373
+# Ignoring E203 due to https://github.com/PyCQA/pycodestyle/issues/373.
 ignore = ["E203", "F405", "E402"]
 
-# Allow autofix for all enabled rules (when `--fix`) is provided.
+# Allow autofix for all enabled rules (when `--fix` is provided).
 fixable = ["A", "B", "C", "D", "E", "F", "G", "I", "N", "Q", "S", "T", "W", "ANN", "ARG", "BLE", "COM", "DJ", "DTZ", "EM", "ERA", "EXE", "FBT", "ICN", "INP", "ISC", "NPY", "PD", "PGH", "PIE", "PL", "PT", "PTH", "PYI", "RET", "RSE", "RUF", "SIM", "SLF", "TCH", "TID", "TRY", "UP", "YTT"]
 unfixable = []
 
diff --git a/scripts/borg.exe.spec b/scripts/borg.exe.spec
index aa39ca7e9f..4e2e717dfc 100644
--- a/scripts/borg.exe.spec
+++ b/scripts/borg.exe.spec
@@ -1,5 +1,5 @@
 # -*- mode: python -*-
-# this pyinstaller spec file is used to build borg binaries on posix platforms and Windows
+# This PyInstaller spec file is used to build Borg binaries on POSIX platforms and Windows.
 
 import os, sys
 
@@ -53,10 +53,10 @@ exe = EXE(pyz,
           icon='NONE')
 
 # Build a directory-based binary in addition to a packed
-# single file. This allows one to look at all included
-# files easily (e.g. without having to strace or halt the built binary
-# and introspect /tmp). Also avoids unpacking all libs when
-# running the app, which is better for app signing on various OS.
+# single-file binary. This allows you to look at all included
+# files easily (e.g., without having to strace or halt the built binary
+# and introspect /tmp). It also avoids unpacking all libraries when
+# running the app, which is better for application signing on various OSes.
 slim_exe = EXE(pyz,
             a.scripts,
             exclude_binaries=True,
diff --git a/scripts/errorlist.py b/scripts/errorlist.py
index 28d1bba639..cd2c2374bb 100755
--- a/scripts/errorlist.py
+++ b/scripts/errorlist.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# this script automatically generates the error list for the docs by
+# This script automatically generates the error list for the documentation by
 # looking at the "Error" class and its subclasses.
 
 from textwrap import indent
diff --git a/scripts/glibc_check.py b/scripts/glibc_check.py
index a70645ebf5..c567cb57f3 100755
--- a/scripts/glibc_check.py
+++ b/scripts/glibc_check.py
@@ -1,10 +1,10 @@
 #!/usr/bin/env python3
 """
-Check if all given binaries work with the given glibc version.
+Check whether all given binaries work with the specified glibc version.
 
-glibc_check.py 2.11 bin [bin ...]
+Usage: glibc_check.py 2.11 BIN [BIN ...]
 
-rc = 0 means "yes", rc = 1 means "no".
+Exit code 0 means "yes"; exit code 1 means "no".
 """
 
 import re
@@ -40,7 +40,7 @@ def main():
                 print(f"{filename} {format_version(requires_glibc)}")
         except subprocess.CalledProcessError:
             if verbose:
-                print("%s errored." % filename)
+                print("%s failed." % filename)
 
     wanted = max(overall_versions)
     ok = given >= wanted
@@ -51,7 +51,7 @@ def main():
         else:
             print(
                 "The binaries do not work with the given glibc %s. "
-                "Minimum is: %s" % (format_version(given), format_version(wanted))
+                "Minimum required is %s." % (format_version(given), format_version(wanted))
             )
     return ok
 
diff --git a/scripts/make-testdata/test_transfer_upgrade.sh b/scripts/make-testdata/test_transfer_upgrade.sh
index 42c3adb838..88c0ad5cf4 100755
--- a/scripts/make-testdata/test_transfer_upgrade.sh
+++ b/scripts/make-testdata/test_transfer_upgrade.sh
@@ -1,6 +1,6 @@
-# this scripts uses borg 1.2 to generate test data for "borg transfer --upgrader=From12To20"
+# This script uses Borg 1.2 to generate test data for "borg transfer --upgrader=From12To20".
 BORG=./borg-1.2.2
-# on macOS, gnu tar is available as gtar
+# On macOS, GNU tar is available as gtar.
 TAR=gtar
 SRC=/tmp/borgtest
 ARCHIVE=`pwd`/src/borg/testsuite/archiver/repo12.tar.gz
@@ -55,7 +55,7 @@ pushd $SRC >/dev/null
 sudo mkdir root_stuff
 sudo mknod root_stuff/bdev_12_34 b 12 34
 sudo mknod root_stuff/cdev_34_56 c 34 56
-sudo touch root_stuff/strange_uid_gid  # no user name, no group name for this uid/gid!
+sudo touch root_stuff/strange_uid_gid  # No user name or group name exists for this UID/GID!
 sudo chown 54321:54321 root_stuff/strange_uid_gid
 
 popd >/dev/null
diff --git a/scripts/shell_completions/bash/borg b/scripts/shell_completions/bash/borg
index 6acd63d40b..77a5b353a2 100644
--- a/scripts/shell_completions/bash/borg
+++ b/scripts/shell_completions/bash/borg
@@ -1,9 +1,9 @@
-# Completions for borg
+# Bash completions for Borg
 # https://www.borgbackup.org/
 # Note:
-# Listing archives works on password protected repositories only if $BORG_PASSPHRASE is set.
+# Listing archives works on password-protected repositories only if $BORG_PASSPHRASE is set.
 # Install:
-# Copy this file to /usr/share/bash-completion/completions/ or /etc/bash_completion.d/
+# Copy this file to /usr/share/bash-completion/completions/ or /etc/bash_completion.d/.
 
 _borg()
 {
diff --git a/scripts/shell_completions/fish/borg.fish b/scripts/shell_completions/fish/borg.fish
index 1ef08e0dcd..159c93adbd 100644
--- a/scripts/shell_completions/fish/borg.fish
+++ b/scripts/shell_completions/fish/borg.fish
@@ -1,7 +1,7 @@
 # Completions for borg
 # https://www.borgbackup.org/
 # Note:
-# Listing archives works on password protected repositories only if $BORG_PASSPHRASE is set.
+# Listing archives works on password-protected repositories only if $BORG_PASSPHRASE is set.
 # Install:
 # Copy this file to /usr/share/fish/vendor_completions.d/
 
@@ -19,7 +19,7 @@ complete -c borg -f -n __fish_is_first_token -a 'prune' -d 'Prune repository arc
 complete -c borg -f -n __fish_is_first_token -a 'compact' -d 'Free repository space'
 complete -c borg -f -n __fish_is_first_token -a 'info' -d 'Show archive details'
 complete -c borg -f -n __fish_is_first_token -a 'mount' -d 'Mount archive or a repository'
-complete -c borg -f -n __fish_is_first_token -a 'umount' -d 'Un-mount the mounted archive'
+complete -c borg -f -n __fish_is_first_token -a 'umount' -d 'Unmount the mounted archive'
 complete -c borg -f -n __fish_is_first_token -a 'repo-compress' -d 'Repository (re-)compression'
 complete -c borg -f -n __fish_is_first_token -a 'repo-create' -d 'Create a new, empty repository'
 complete -c borg -f -n __fish_is_first_token -a 'repo-delete' -d 'Delete a repository'
@@ -29,7 +29,7 @@ complete -c borg -f -n __fish_is_first_token -a 'repo-space' -d 'Manage reserved
 complete -c borg -f -n __fish_is_first_token -a 'tag' -d 'Tag archives'
 complete -c borg -f -n __fish_is_first_token -a 'transfer' -d 'Transfer of archives from another repository'
 complete -c borg -f -n __fish_is_first_token -a 'undelete' -d 'Undelete archives'
-complete -c borg -f -n __fish_is_first_token -a 'version' -d 'Display borg client version / borg server version'
+complete -c borg -f -n __fish_is_first_token -a 'version' -d 'Display Borg client version / Borg server version'
 
 function __fish_borg_seen_key
     if __fish_seen_subcommand_from key
@@ -46,7 +46,7 @@ complete -c borg -f -n __fish_borg_seen_key  -a 'change-passphrase' -d 'Change k
 complete -c borg -f -n __fish_is_first_token -a 'serve' -d 'Start in server mode'
 complete -c borg -f -n __fish_is_first_token -a 'recreate' -d 'Recreate contents of existing archives'
 complete -c borg -f -n __fish_is_first_token -a 'export-tar' -d 'Create tarball from an archive'
-complete -c borg -f -n __fish_is_first_token -a 'with-lock' -d 'Run a command while repository lock held'
+complete -c borg -f -n __fish_is_first_token -a 'with-lock' -d 'Run a command while the repository lock is held'
 complete -c borg -f -n __fish_is_first_token -a 'break-lock' -d 'Break the repository lock'
 
 function __fish_borg_seen_benchmark
@@ -89,11 +89,11 @@ complete -c borg -f      -l 'show-version'          -d 'Log version information'
 complete -c borg -f      -l 'show-rc'               -d 'Log the return code'
 complete -c borg -f      -l 'umask'                 -d 'Set umask to M [0077]'
 complete -c borg         -l 'remote-path'           -d 'Use PATH as remote borg executable'
-complete -c borg -f      -l 'upload-ratelimit'      -d 'Set network upload rate limit in kiByte/s'
+complete -c borg -f      -l 'upload-ratelimit'      -d 'Set network upload rate limit in KiB/s'
 complete -c borg -f      -l 'upload-buffer'         -d 'Set network upload buffer size in MiB'
 complete -c borg         -l 'debug-profile'         -d 'Write execution profile into FILE'
 complete -c borg         -l 'rsh'                   -d 'Use COMMAND instead of ssh'
-complete -c borg         -l 'socket'                -d 'Use UNIX DOMAIN socket at PATH'
+complete -c borg         -l 'socket'                -d 'Use UNIX domain socket at PATH'
 
 # borg analyze options
 complete -c borg -f -s a -l 'match-archives'        -d 'Only archive names matching PATTERN'        -n "__fish_seen_subcommand_from analyze"
diff --git a/scripts/shell_completions/zsh/_borg b/scripts/shell_completions/zsh/_borg
index 7b71daf331..5c52297379 100644
--- a/scripts/shell_completions/zsh/_borg
+++ b/scripts/shell_completions/zsh/_borg
@@ -55,10 +55,10 @@ _borg_commands() {
     'serve:start in server mode'
     'tag:tag archives'
     'transfer:transfer of archives from another repository'
-    'umount:un-mount the FUSE filesystem'
+    'umount:unmount the FUSE filesystem'
     'undelete:undelete archive'
     'version:display borg client version / borg server version'
-    'with-lock:run a user specified command with the repository lock held'
+    'with-lock:run a user-specified command with the repository lock held'
   )
   _describe -t commands 'borg commands' commands_
 }
diff --git a/setup.py b/setup.py
index 29ae6ce5c2..6217cac00d 100644
--- a/setup.py
+++ b/setup.py
@@ -30,7 +30,7 @@
 is_win32 = sys.platform.startswith("win32")
 is_openbsd = sys.platform.startswith("openbsd")
 
-# Number of threads to use for cythonize, not used on windows
+# Number of threads to use for cythonize, not used on Windows
 cpu_threads = multiprocessing.cpu_count() if multiprocessing and multiprocessing.get_start_method() != "spawn" else None
 
 # How the build process finds the system libs:
@@ -91,8 +91,8 @@ def __init__(self, *args, **kwargs):
     cython_c_files = [fn.replace(".pyx", ".c") for fn in cython_sources]
     if not on_rtd and not all(os.path.exists(path) for path in cython_c_files):
         raise ImportError(
-            "The GIT version of Borg needs a working Cython. "
-            + "Install or fix Cython or use a released borg version. "
+            "The Git version of Borg needs a working Cython. "
+            + "Install or fix Cython or use a released Borg version. "
             + "Importing cythonize failed with: "
             + cythonize_import_error_msg
         )
@@ -115,7 +115,7 @@ def members_appended(*ds):
     try:
         import pkgconfig as pc
     except ImportError:
-        print("Warning: can not import pkgconfig python package.")
+        print("Warning: cannot import pkgconfig Python package.")
         pc = None
 
     def lib_ext_kwargs(pc, prefix_env_var, lib_name, lib_pkg_name, pc_version, lib_subdir="lib"):
@@ -139,7 +139,7 @@ def lib_ext_kwargs(pc, prefix_env_var, lib_name, lib_pkg_name, pc_version, lib_s
     if is_win32:
         crypto_ext_lib = lib_ext_kwargs(pc, "BORG_OPENSSL_PREFIX", "libcrypto", "libcrypto", ">=1.1.1", lib_subdir="")
     elif is_openbsd:
-        # Use openssl (not libressl) because we need AES-OCB via EVP api. Link
+        # Use OpenSSL (not LibreSSL) because we need AES-OCB via the EVP API. Link
         # it statically to avoid conflicting with shared libcrypto from the base
         # OS pulled in via dependencies.
         openssl_prefix = os.environ.get("BORG_OPENSSL_PREFIX", "/usr/local")
@@ -225,7 +225,7 @@ def lib_ext_kwargs(pc, prefix_env_var, lib_name, lib_pkg_name, pc_version, lib_s
         # we only set this to avoid the related FutureWarning from Cython3.
         cython_opts = dict(compiler_directives={"language_level": "3str"})
         if not is_win32:
-            # compile .pyx extensions to .c in parallel, does not work on windows
+            # Compile .pyx extensions to .c in parallel; does not work on Windows
             cython_opts["nthreads"] = cpu_threads
 
         # generate C code from Cython for ALL supported platforms, so we have them in the sdist.
diff --git a/src/borg/__init__.py b/src/borg/__init__.py
index e1f7702901..58d49af03a 100644
--- a/src/borg/__init__.py
+++ b/src/borg/__init__.py
@@ -11,10 +11,10 @@
 # and setuptools_scm determines a 0.1.dev... version
 assert all(isinstance(v, int) for v in __version_tuple__), (
     """\
-broken borgbackup version metadata: %r
+Broken BorgBackup version metadata: %r
 
-version metadata is obtained dynamically on installation via setuptools_scm,
-please ensure your git repo has the correct tags or you provide the version
+Version metadata is obtained dynamically during installation via setuptools_scm;
+please ensure your Git repository has the correct tags, or provide the version
 using SETUPTOOLS_SCM_PRETEND_VERSION in your build script.
 """
     % __version__
diff --git a/src/borg/__main__.py b/src/borg/__main__.py
index a561b79b02..59fe53dc5b 100644
--- a/src/borg/__main__.py
+++ b/src/borg/__main__.py
@@ -1,17 +1,17 @@
 import sys
 import os
 
-# On windows loading the bundled libcrypto dll fails if the folder
-# containing the dll is not in the search path. The dll is shipped
-# with python in the "DLLs" folder, so let's add this folder
-# to the path. The folder is always in sys.path, get it from there.
+# On Windows, loading the bundled libcrypto DLL fails if the folder
+# containing the DLL is not in the search path. The DLL is shipped
+# with Python in the "DLLs" folder, so we add this folder
+# to the PATH. The folder is always present in sys.path; get it from there.
 if sys.platform.startswith("win32"):
-    # Keep it an iterable to support multiple folder which contain "DLLs".
+    # Keep it an iterable to support multiple folders that contain "DLLs".
     dll_path = (p for p in sys.path if "DLLs" in os.path.normpath(p).split(os.path.sep))
     os.environ["PATH"] = os.pathsep.join(dll_path) + os.pathsep + os.environ["PATH"]
 
 
-# note: absolute import from "borg", it seems pyinstaller binaries do not work without this.
+# Note: absolute import from "borg"; PyInstaller binaries do not work without this.
 from borg.archiver import main
 
 main()
diff --git a/src/borg/archive.py b/src/borg/archive.py
index d78130de6c..7ef7e00a9b 100644
--- a/src/borg/archive.py
+++ b/src/borg/archive.py
@@ -767,11 +767,11 @@ def extract_item(
         :param sparse: write sparse files (chunk-granularity, independent of the original being sparse)
         :param hlm: maps hlid to link_target for extracting subtrees with hardlinks correctly
         :param pi: ProgressIndicatorPercent (or similar) for file extraction progress (in bytes)
-        :param continue_extraction: continue a previously interrupted extraction of same archive
+        :param continue_extraction: continue a previously interrupted extraction of the same archive
         """
 
         def same_item(item, st):
-            """is the archived item the same as the fs item at same path with stat st?"""
+            """Is the archived item the same as the filesystem item at the same path with stat st?"""
             if not stat.S_ISREG(st.st_mode):
                 # we only "optimize" for regular files.
                 # other file types are less frequent and have no content extraction we could "optimize away".
diff --git a/src/borg/archiver/__init__.py b/src/borg/archiver/__init__.py
index c78ab7704b..0a7c013cd9 100644
--- a/src/borg/archiver/__init__.py
+++ b/src/borg/archiver/__init__.py
@@ -382,7 +382,7 @@ def build_parser(self):
         return parser
 
     def get_args(self, argv, cmd):
-        """usually, just returns argv, except if we deal with a ssh forced command for borg serve."""
+        """Usually just returns argv, except when dealing with an SSH forced command for borg serve."""
         result = self.parse_args(argv[1:])
         if cmd is not None and result.func == self.do_serve:
             # borg serve case:
@@ -457,7 +457,7 @@ def prerun_checks(self, logger, is_serve):
         selftest(logger)
 
     def _setup_implied_logging(self, args):
-        """turn on INFO level logging for args that imply that they will produce output"""
+        """Turn on INFO-level logging for arguments that imply they will produce output."""
         # map of option name to name of logger for that option
         option_logger = {
             "show_version": "borg.output.show-version",
@@ -544,7 +544,7 @@ def run(self, args):
 
 
 def sig_info_handler(sig_no, stack):  # pragma: no cover
-    """search the stack for infos about the currently processed file and print them"""
+    """Search the stack for information about the currently processed file and print it."""
     with signal_handler(sig_no, signal.SIG_IGN):
         for frame in inspect.getouterframes(stack):
             func, loc = frame[3], frame[0].f_locals
diff --git a/src/borg/archiver/_common.py b/src/borg/archiver/_common.py
index 8e9d95a699..b072fd03b8 100644
--- a/src/borg/archiver/_common.py
+++ b/src/borg/archiver/_common.py
@@ -243,7 +243,7 @@ def wrapper(self, args, repository, manifest, **kwargs):
 # e.g. through "borg ... --help", define a substitution for the reference here.
 # It will replace the entire :ref:`foo` verbatim.
 rst_plain_text_references = {
-    "a_status_oddity": '"I am seeing ‘A’ (added) status for a unchanged file!?"',
+    "a_status_oddity": '"I am seeing ‘A’ (added) status for an unchanged file!?"',
     "separate_compaction": '"Separate compaction"',
     "list_item_flags": '"Item flags"',
     "borg_patterns": '"borg help patterns"',
@@ -306,14 +306,14 @@ def define_exclude_and_patterns(add_option, *, tag_files=False, strip_components
             dest="exclude_if_present",
             action="append",
             type=str,
-            help="exclude directories that are tagged by containing a filesystem object with " "the given NAME",
+            help="exclude directories that are tagged by containing a filesystem object with the given NAME",
         )
         add_option(
             "--keep-exclude-tags",
             dest="keep_exclude_tags",
             action="store_true",
             help="if tag objects are specified with ``--exclude-if-present``, "
-            "don't omit the tag objects themselves from the backup archive",
+            "do not omit the tag objects themselves from the backup archive",
         )
 
     if strip_components:
@@ -348,7 +348,7 @@ def define_archive_filters_group(
         metavar="PATTERN",
         dest="match_archives",
         action="append",
-        help='only consider archives matching all patterns. see "borg help match-archives".',
+        help='only consider archives matching all patterns. See "borg help match-archives".',
     )
 
     if sort_by:
@@ -374,7 +374,7 @@ def define_archive_filters_group(
             type=positive_int_validator,
             default=0,
             action=Highlander,
-            help="consider first N archives after other filters were applied",
+            help="consider the first N archives after other filters are applied",
         )
         group.add_argument(
             "--last",
@@ -383,7 +383,7 @@ def define_archive_filters_group(
             type=positive_int_validator,
             default=0,
             action=Highlander,
-            help="consider last N archives after other filters were applied",
+            help="consider the last N archives after other filters are applied",
         )
 
     if oldest_newest:
@@ -394,7 +394,7 @@ def define_archive_filters_group(
             dest="oldest",
             type=relative_time_marker_validator,
             action=Highlander,
-            help="consider archives between the oldest archive's timestamp and (oldest + TIMESPAN), e.g. 7d or 12m.",
+            help="consider archives between the oldest archive's timestamp and (oldest + TIMESPAN), e.g., 7d or 12m.",
         )
         group.add_argument(
             "--newest",
@@ -402,7 +402,7 @@ def define_archive_filters_group(
             dest="newest",
             type=relative_time_marker_validator,
             action=Highlander,
-            help="consider archives between the newest archive's timestamp and (newest - TIMESPAN), e.g. 7d or 12m.",
+            help="consider archives between the newest archive's timestamp and (newest - TIMESPAN), e.g., 7d or 12m.",
         )
 
     if older_newer:
@@ -413,7 +413,7 @@ def define_archive_filters_group(
             dest="older",
             type=relative_time_marker_validator,
             action=Highlander,
-            help="consider archives older than (now - TIMESPAN), e.g. 7d or 12m.",
+            help="consider archives older than (now - TIMESPAN), e.g., 7d or 12m.",
         )
         group.add_argument(
             "--newer",
@@ -421,7 +421,7 @@ def define_archive_filters_group(
             dest="newer",
             type=relative_time_marker_validator,
             action=Highlander,
-            help="consider archives newer than (now - TIMESPAN), e.g. 7d or 12m.",
+            help="consider archives newer than (now - TIMESPAN), e.g., 7d or 12m.",
         )
 
     if deleted:
diff --git a/src/borg/archiver/analyze_cmd.py b/src/borg/archiver/analyze_cmd.py
index 7b661d10db..0b7abd9742 100644
--- a/src/borg/archiver/analyze_cmd.py
+++ b/src/borg/archiver/analyze_cmd.py
@@ -99,7 +99,7 @@ def report(self):
 class AnalyzeMixIn:
     @with_repository(compatibility=(Manifest.Operation.READ,))
     def do_analyze(self, args, repository, manifest):
-        """Analyze archives"""
+        """Analyzes archives."""
         ArchiveAnalyzer(args, repository, manifest).analyze()
 
     def build_parser_analyze(self, subparsers, common_parser, mid_common_parser):
@@ -109,21 +109,21 @@ def build_parser_analyze(self, subparsers, common_parser, mid_common_parser):
             """
             Analyze archives to find "hot spots".
 
-            Borg analyze relies on the usual archive matching options to select the
+            ``borg analyze`` relies on the usual archive matching options to select the
             archives that should be considered for analysis (e.g. ``-a series_name``).
-            Then it iterates over all matching archives, over all contained files and
-            collects information about chunks stored in all directories it encountered.
+            Then it iterates over all matching archives, over all contained files, and
+            collects information about chunks stored in all directories it encounters.
 
-            It considers chunk IDs and their plaintext sizes (we don't have the compressed
-            size in the repository easily available) and adds up added/removed chunks'
-            sizes per direct parent directory and outputs a list of "directory: size".
+            It considers chunk IDs and their plaintext sizes (we do not have the compressed
+            size in the repository easily available) and adds up the sizes of added and removed
+            chunks per direct parent directory, and outputs a list of "directory: size".
 
-            You can use that list to find directories with a lot of "activity" - maybe
-            some of these are temporary or cache directories you did forget to exclude.
+            You can use that list to find directories with a lot of "activity" — maybe
+            some of these are temporary or cache directories you forgot to exclude.
 
-            To not have these unwanted directories in your backups, you could carefully
-            exclude these in ``borg create`` (for future backups) or use ``borg recreate``
-            to re-create existing archives without these.
+            To avoid including these unwanted directories in your backups, you can carefully
+            exclude them in ``borg create`` (for future backups) or use ``borg recreate``
+            to recreate existing archives without them.
             """
         )
         subparser = subparsers.add_parser(
diff --git a/src/borg/archiver/benchmark_cmd.py b/src/borg/archiver/benchmark_cmd.py
index 8e290ad73c..b1b241c4a3 100644
--- a/src/borg/archiver/benchmark_cmd.py
+++ b/src/borg/archiver/benchmark_cmd.py
@@ -125,7 +125,7 @@ def test_files(path, count, size, random):
             print(fmt % ("D", msg, total_size_MB / dt_delete, count, file_size_formatted, content, dt_delete))
 
     def do_benchmark_cpu(self, args):
-        """Benchmark CPU bound operations."""
+        """Benchmark CPU-bound operations."""
         from timeit import timeit
 
         random_10M = os.urandom(10 * 1000 * 1000)
@@ -272,11 +272,11 @@ def build_parser_benchmarks(self, subparsers, common_parser, mid_common_parser):
             """
         This command benchmarks borg CRUD (create, read, update, delete) operations.
 
-        It creates input data below the given PATH and backups this data into the given REPO.
+        It creates input data below the given PATH and backs up this data into the given REPO.
         The REPO must already exist (it could be a fresh empty repo or an existing repo, the
         command will create / read / update / delete some archives named borg-benchmark-crud\\* there.
 
-        Make sure you have free space there, you'll need about 1GB each (+ overhead).
+        Make sure you have free space there; you will need about 1 GB each (+ overhead).
 
         If your repository is encrypted and borg needs a passphrase to unlock the key, use::
 
@@ -316,15 +316,15 @@ def build_parser_benchmarks(self, subparsers, common_parser, mid_common_parser):
             description=self.do_benchmark_crud.__doc__,
             epilog=bench_crud_epilog,
             formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="benchmarks borg CRUD (create, extract, update, delete).",
+            help="benchmarks Borg CRUD (create, extract, update, delete).",
         )
         subparser.set_defaults(func=self.do_benchmark_crud)
 
-        subparser.add_argument("path", metavar="PATH", help="path were to create benchmark input data")
+        subparser.add_argument("path", metavar="PATH", help="path where to create benchmark input data")
 
         bench_cpu_epilog = process_epilog(
             """
-        This command benchmarks misc. CPU bound borg operations.
+        This command benchmarks miscellaneous CPU-bound Borg operations.
 
         It creates input data in memory, runs the operation and then displays throughput.
         To reduce outside influence on the timings, please make sure to run this with:
@@ -340,6 +340,6 @@ def build_parser_benchmarks(self, subparsers, common_parser, mid_common_parser):
             description=self.do_benchmark_cpu.__doc__,
             epilog=bench_cpu_epilog,
             formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="benchmarks borg CPU bound operations.",
+            help="benchmarks Borg CPU-bound operations.",
         )
         subparser.set_defaults(func=self.do_benchmark_cpu)
diff --git a/src/borg/archiver/check_cmd.py b/src/borg/archiver/check_cmd.py
index 233065ab74..e78aef563f 100644
--- a/src/borg/archiver/check_cmd.py
+++ b/src/borg/archiver/check_cmd.py
@@ -13,7 +13,7 @@
 class CheckMixIn:
     @with_repository(exclusive=True, manifest=False)
     def do_check(self, args, repository):
-        """Check repository consistency"""
+        """Checks repository consistency."""
         if args.repair:
             msg = (
                 "This is a potentially dangerous function.\n"
@@ -85,7 +85,7 @@ def build_parser_check(self, subparsers, common_parser, mid_common_parser):
            the repository. The read data is checked by size and hash. Bit rot and other
            types of accidental damage can be detected this way. Running the repository
            check can be split into multiple partial checks using ``--max-duration``.
-           When checking a ssh:// remote repository, please note that the checks run on
+           When checking an ssh:// remote repository, please note that the checks run on
            the server and do not cause significant network traffic.
 
         2. Checking consistency and correctness of the archive metadata and optionally
@@ -94,9 +94,9 @@ def build_parser_check(self, subparsers, common_parser, mid_common_parser):
            all chunks referencing files (items) in the archive exist. This requires
            reading archive and file metadata, but not data. To scan for archives whose
            entries were lost from the archive directory, pass ``--find-lost-archives``.
-           It requires reading all data and is hence very time consuming.
+           It requires reading all data and is hence very time-consuming.
            To additionally cryptographically verify the file (content) data integrity,
-           pass ``--verify-data``, which is even more time consuming.
+           pass ``--verify-data``, which is even more time-consuming.
 
            When checking archives of a remote repository, archive checks run on the client
            machine because they require decrypting data and therefore the encryption key.
@@ -106,7 +106,7 @@ def build_parser_check(self, subparsers, common_parser, mid_common_parser):
         only.
 
         The ``--max-duration`` option can be used to split a long-running repository
-        check into multiple partial checks. After the given number of seconds the check
+        check into multiple partial checks. After the given number of seconds, the check
         is interrupted. The next partial check will continue where the previous one
         stopped, until the full repository has been checked. Assuming a complete check
         would take 7 hours, then running a daily check with ``--max-duration=3600``
@@ -117,33 +117,33 @@ def build_parser_check(self, subparsers, common_parser, mid_common_parser):
         ``--max-duration`` you must also pass ``--repository-only``, and must not pass
         ``--archives-only``, nor ``--repair``.
 
-        **Warning:** Please note that partial repository checks (i.e. running it with
+        **Warning:** Please note that partial repository checks (i.e., running with
         ``--max-duration``) can only perform non-cryptographic checksum checks on the
-        repository files. Enabling partial repository checks excepts archive checks
-        for the same reason. Therefore partial checks may be useful with very large
-        repositories only where a full check would take too long.
+        repository files. Enabling partial repository checks excludes archive checks
+        for the same reason. Therefore, partial checks may be useful only with very large
+        repositories where a full check would take too long.
 
         The ``--verify-data`` option will perform a full integrity verification (as
         opposed to checking just the xxh64) of data, which means reading the
         data from the repository, decrypting and decompressing it. It is a complete
-        cryptographic verification and hence very time consuming, but will detect any
+        cryptographic verification and hence very time-consuming, but will detect any
         accidental and malicious corruption. Tamper-resistance is only guaranteed for
-        encrypted repositories against attackers without access to the keys. You can
-        not use ``--verify-data`` with ``--repository-only``.
+        encrypted repositories against attackers without access to the keys. You cannot
+        use ``--verify-data`` with ``--repository-only``.
 
         The ``--find-lost-archives`` option will also scan the whole repository, but
         tells Borg to search for lost archive metadata. If Borg encounters any archive
-        metadata that doesn't match with an archive directory entry (including
+        metadata that does not match an archive directory entry (including
         soft-deleted archives), it means that an entry was lost.
         Unless ``borg compact`` is called, these archives can be fully restored with
         ``--repair``. Please note that ``--find-lost-archives`` must read a lot of
-        data from the repository and is thus very time consuming. You can not use
+        data from the repository and is thus very time-consuming. You cannot use
         ``--find-lost-archives`` with ``--repository-only``.
 
         About repair mode
         +++++++++++++++++
 
-        The check command is a readonly task by default. If any corruption is found,
+        The check command is a read-only task by default. If any corruption is found,
         Borg will report the issue and proceed with checking. To actually repair the
         issues found, pass ``--repair``.
 
@@ -163,7 +163,7 @@ def build_parser_check(self, subparsers, common_parser, mid_common_parser):
         in repair mode (i.e. running it with ``--repair``).
 
         Repair mode will attempt to fix any corruptions found. Fixing corruptions does
-        not mean recovering lost data: Borg can not magically restore data lost due to
+        not mean recovering lost data: Borg cannot magically restore data lost due to
         e.g. a hardware failure. Repairing a repository means sacrificing some data
         for the sake of the repository as a whole and the remaining data. Hence it is,
         by definition, a potentially lossy task.
@@ -189,20 +189,20 @@ def build_parser_check(self, subparsers, common_parser, mid_common_parser):
             description=self.do_check.__doc__,
             epilog=check_epilog,
             formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="verify repository",
+            help="verify the repository",
         )
         subparser.set_defaults(func=self.do_check)
         subparser.add_argument(
             "--repository-only", dest="repo_only", action="store_true", help="only perform repository checks"
         )
         subparser.add_argument(
-            "--archives-only", dest="archives_only", action="store_true", help="only perform archives checks"
+            "--archives-only", dest="archives_only", action="store_true", help="only perform archive checks"
         )
         subparser.add_argument(
             "--verify-data",
             dest="verify_data",
             action="store_true",
-            help="perform cryptographic archive data integrity verification " "(conflicts with ``--repository-only``)",
+            help="perform cryptographic archive data integrity verification (conflicts with ``--repository-only``)",
         )
         subparser.add_argument(
             "--repair", dest="repair", action="store_true", help="attempt to repair any inconsistencies found"
@@ -217,6 +217,6 @@ def build_parser_check(self, subparsers, common_parser, mid_common_parser):
             type=int,
             default=0,
             action=Highlander,
-            help="do only a partial repo check for max. SECONDS seconds (Default: unlimited)",
+            help="perform only a partial repository check for at most SECONDS seconds (default: unlimited)",
         )
         define_archive_filters_group(subparser)
diff --git a/src/borg/archiver/compact_cmd.py b/src/borg/archiver/compact_cmd.py
index ad0bb231dc..1cd07a0ba9 100644
--- a/src/borg/archiver/compact_cmd.py
+++ b/src/borg/archiver/compact_cmd.py
@@ -208,7 +208,7 @@ def report_and_delete(self):
 class CompactMixIn:
     @with_repository(exclusive=True, compatibility=(Manifest.Operation.DELETE,))
     def do_compact(self, args, repository, manifest):
-        """Collect garbage in repository"""
+        """Collects garbage in the repository."""
         if not args.dry_run:  # support --dry-run to simplify scripting
             ArchiveGarbageCollector(repository, manifest, stats=args.stats, iec=args.iec).garbage_collect()
 
@@ -219,44 +219,42 @@ def build_parser_compact(self, subparsers, common_parser, mid_common_parser):
             """
             Free repository space by deleting unused chunks.
 
-            borg compact analyzes all existing archives to find out which repository
+            ``borg compact`` analyzes all existing archives to determine which repository
             objects are actually used (referenced). It then deletes all unused objects
             from the repository to free space.
 
             Unused objects may result from:
 
-            - borg delete or prune usage
-            - interrupted backups (maybe retry the backup first before running compact)
-            - backup of source files that had an I/O error in the middle of their contents
-              and that were skipped due to this
-            - corruption of the repository (e.g. the archives directory having lost
-              entries, see notes below)
+            - use of ``borg delete`` or ``borg prune``
+            - interrupted backups (consider retrying the backup before running compact)
+            - backups of source files that encountered an I/O error mid-transfer and were skipped
+            - corruption of the repository (e.g., the archives directory lost entries; see notes below)
 
-            You usually don't want to run ``borg compact`` after every write operation, but
-            either regularly (e.g. once a month, possibly together with ``borg check``) or
+            You usually do not want to run ``borg compact`` after every write operation, but
+            either regularly (e.g., once a month, possibly together with ``borg check``) or
             when disk space needs to be freed.
 
             **Important:**
 
-            After compacting it is no longer possible to use ``borg undelete`` to recover
+            After compacting, it is no longer possible to use ``borg undelete`` to recover
             previously soft-deleted archives.
 
             ``borg compact`` might also delete data from archives that were "lost" due to
             archives directory corruption. Such archives could potentially be restored with
             ``borg check --find-lost-archives [--repair]``, which is slow. You therefore
-            might not want to do that unless there are signs of lost archives (e.g. when
+            might not want to do that unless there are signs of lost archives (e.g., when
             seeing fatal errors when creating backups or when archives are missing in
             ``borg repo-list``).
 
-            When giving the ``--stats`` option, borg will internally list all repository
-            objects to determine their existence AND stored size. It will build a fresh
+            When using the ``--stats`` option, borg will internally list all repository
+            objects to determine their existence and stored size. It will build a fresh
             chunks index from that information and cache it in the repository. For some
             types of repositories, this might be very slow. It will tell you the sum of
             stored object sizes, before and after compaction.
 
             Without ``--stats``, borg will rely on the cached chunks index to determine
             existing object IDs (but there is no stored size information in the index,
-            thus it can't compute before/after compaction size statistics).
+            thus it cannot compute before/after compaction size statistics).
             """
         )
         subparser = subparsers.add_parser(
@@ -266,10 +264,12 @@ def build_parser_compact(self, subparsers, common_parser, mid_common_parser):
             description=self.do_compact.__doc__,
             epilog=compact_epilog,
             formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="compact repository",
+            help="compact the repository",
         )
         subparser.set_defaults(func=self.do_compact)
-        subparser.add_argument("-n", "--dry-run", dest="dry_run", action="store_true", help="do nothing")
+        subparser.add_argument(
+            "-n", "--dry-run", dest="dry_run", action="store_true", help="do not change the repository"
+        )
         subparser.add_argument(
             "-s", "--stats", dest="stats", action="store_true", help="print statistics (might be much slower)"
         )
diff --git a/src/borg/archiver/create_cmd.py b/src/borg/archiver/create_cmd.py
index 9345264df3..1301c0ccb2 100644
--- a/src/borg/archiver/create_cmd.py
+++ b/src/borg/archiver/create_cmd.py
@@ -42,7 +42,7 @@
 class CreateMixIn:
     @with_repository(compatibility=(Manifest.Operation.WRITE,))
     def do_create(self, args, repository, manifest):
-        """Create new archive"""
+        """Creates a new archive."""
         key = manifest.key
         matcher = PatternMatcher(fallback=True)
         matcher.add_inclexcl(args.patterns)
@@ -552,8 +552,8 @@ def build_parser_create(self, subparsers, common_parser, mid_common_parser):
         create_epilog = process_epilog(
             """
         This command creates a backup archive containing all files found while recursively
-        traversing all paths specified. Paths are added to the archive as they are given,
-        that means if relative paths are desired, the command has to be run from the correct
+        traversing all specified paths. Paths are added to the archive as they are given,
+        which means that if relative paths are desired, the command must be run from the correct
         directory.
 
         The slashdot hack in paths (recursion roots) is triggered by using ``/./``:
@@ -561,23 +561,23 @@ def build_parser_create(self, subparsers, common_parser, mid_common_parser):
         strip the prefix on the left side of ``./`` from the archived items (in this case,
         ``this/gets/archived`` will be the path in the archived item).
 
-        When giving '-' as path, borg will read data from standard input and create a
-        file 'stdin' in the created archive from that data. In some cases it's more
-        appropriate to use --content-from-command, however. See section *Reading from
-        stdin* below for details.
+        When specifying '-' as a path, borg will read data from standard input and create a
+        file named 'stdin' in the created archive from that data. In some cases, it is more
+        appropriate to use --content-from-command. See the section *Reading from stdin*
+        below for details.
 
         The archive will consume almost no disk space for files or parts of files that
         have already been stored in other archives.
 
-        The archive name does NOT need to be unique, you can and should use the same
-        name for a series of archives. The unique archive identifier is its ID (hash)
+        The archive name does not need to be unique; you can and should use the same
+        name for a series of archives. The unique archive identifier is its ID (hash),
         and you can abbreviate the ID as long as it is unique.
 
         In the archive name, you may use the following placeholders:
         {now}, {utcnow}, {fqdn}, {hostname}, {user} and some others.
 
         Backup speed is increased by not reprocessing files that are already part of
-        existing archives and weren't modified. The detection of unmodified files is
+        existing archives and were not modified. The detection of unmodified files is
         done by comparing multiple file metadata values with previous values kept in
         the files cache.
 
@@ -603,14 +603,14 @@ def build_parser_create(self, subparsers, common_parser, mid_common_parser):
         ctime vs. mtime: safety vs. speed
 
         - ctime is a rather safe way to detect changes to a file (metadata and contents)
-          as it can not be set from userspace. But, a metadata-only change will already
+          as it cannot be set from userspace. But a metadata-only change will already
           update the ctime, so there might be some unnecessary chunking/hashing even
           without content changes. Some filesystems do not support ctime (change time).
           E.g. doing a chown or chmod to a file will change its ctime.
         - mtime usually works and only updates if file contents were changed. But mtime
-          can be arbitrarily set from userspace, e.g. to set mtime back to the same value
+          can be arbitrarily set from userspace, e.g., to set mtime back to the same value
           it had before a content change happened. This can be used maliciously as well as
-          well-meant, but in both cases mtime based cache modes can be problematic.
+          well-meant, but in both cases mtime-based cache modes can be problematic.
 
         The ``--files-changed`` option controls how Borg detects if a file has changed during backup:
          - ctime (default): Use ctime to detect changes. This is the safest option.
@@ -764,7 +764,7 @@ def build_parser_create(self, subparsers, common_parser, mid_common_parser):
             description=self.do_create.__doc__,
             epilog=create_epilog,
             formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="create backup",
+            help="create a backup",
         )
         subparser.set_defaults(func=self.do_create)
 
@@ -778,7 +778,7 @@ def build_parser_create(self, subparsers, common_parser, mid_common_parser):
         )
 
         subparser.add_argument(
-            "--list", dest="output_list", action="store_true", help="output verbose list of items (files, dirs, ...)"
+            "--list", dest="output_list", action="store_true", help="output a verbose list of items (files, dirs, ...)"
         )
         subparser.add_argument(
             "--filter",
@@ -824,7 +824,7 @@ def build_parser_create(self, subparsers, common_parser, mid_common_parser):
         subparser.add_argument(
             "--content-from-command",
             action="store_true",
-            help="interpret PATH as command and store its stdout. See also section Reading from" " stdin below.",
+            help="interpret PATH as a command and store its stdout. See also the section 'Reading from stdin' below.",
         )
         subparser.add_argument(
             "--paths-from-stdin",
diff --git a/src/borg/archiver/debug_cmd.py b/src/borg/archiver/debug_cmd.py
index 517008fb85..860bc7ae7e 100644
--- a/src/borg/archiver/debug_cmd.py
+++ b/src/borg/archiver/debug_cmd.py
@@ -24,13 +24,13 @@
 
 class DebugMixIn:
     def do_debug_info(self, args):
-        """display system information for debugging / bug reports"""
+        """Displays system information for debugging and bug reports."""
         print(sysinfo())
         print("Process ID:", get_process_id())
 
     @with_repository(compatibility=Manifest.NO_OPERATION_CHECK)
     def do_debug_dump_archive_items(self, args, repository, manifest):
-        """dump (decrypted, decompressed) archive items metadata (not: data)"""
+        """Dumps (decrypted, decompressed) archive item metadata (not data)."""
         repo_objs = manifest.repo_objs
         archive_info = manifest.archives.get_one([args.name])
         archive = Archive(manifest, archive_info.id)
@@ -44,7 +44,7 @@ def do_debug_dump_archive_items(self, args, repository, manifest):
 
     @with_repository(compatibility=Manifest.NO_OPERATION_CHECK)
     def do_debug_dump_archive(self, args, repository, manifest):
-        """dump decoded archive metadata (not: data)"""
+        """Dumps decoded archive metadata (not data)."""
         archive_info = manifest.archives.get_one([args.name])
         repo_objs = manifest.repo_objs
         try:
@@ -99,7 +99,7 @@ def output(fd):
 
     @with_repository(compatibility=Manifest.NO_OPERATION_CHECK)
     def do_debug_dump_manifest(self, args, repository, manifest):
-        """dump decoded repository manifest"""
+        """Dumps decoded repository manifest."""
         repo_objs = manifest.repo_objs
         cdata = repository.get_manifest()
         _, data = repo_objs.parse(manifest.MANIFEST_ID, cdata, ro_type=ROBJ_MANIFEST)
@@ -111,7 +111,7 @@ def do_debug_dump_manifest(self, args, repository, manifest):
 
     @with_repository(manifest=False)
     def do_debug_dump_repo_objs(self, args, repository):
-        """dump (decrypted, decompressed) repo objects"""
+        """Dumps (decrypted, decompressed) repository objects."""
         from ..crypto.key import key_factory
 
         def decrypt_dump(id, cdata):
@@ -137,7 +137,7 @@ def decrypt_dump(id, cdata):
 
     @with_repository(manifest=False)
     def do_debug_search_repo_objs(self, args, repository):
-        """search for byte sequences in repo objects, repo index MUST be current/correct"""
+        """Searches for byte sequences in repository objects; the repository index MUST be current/correct."""
         context = 32
 
         def print_finding(info, wanted, data, offset):
@@ -201,7 +201,7 @@ def print_finding(info, wanted, data, offset):
 
     @with_repository(manifest=False)
     def do_debug_get_obj(self, args, repository):
-        """get object contents from the repository and write it into file"""
+        """Gets object contents from the repository and writes them to a file."""
         hex_id = args.id
         try:
             id = hex_to_bin(hex_id, length=32)
@@ -217,7 +217,7 @@ def do_debug_get_obj(self, args, repository):
 
     @with_repository(compatibility=Manifest.NO_OPERATION_CHECK)
     def do_debug_id_hash(self, args, repository, manifest):
-        """compute id-hash for file contents"""
+        """Computes id-hash for file contents."""
         with open(args.path, "rb") as f:
             data = f.read()
         key = manifest.key
@@ -226,7 +226,7 @@ def do_debug_id_hash(self, args, repository, manifest):
 
     @with_repository(compatibility=Manifest.NO_OPERATION_CHECK)
     def do_debug_parse_obj(self, args, repository, manifest):
-        """parse borg object file into meta dict and data (decrypting, decompressing)"""
+        """Parses a Borg object file into a metadata dict and data (decrypting, decompressing)."""
 
         # get the object from id
         hex_id = args.id
@@ -249,7 +249,7 @@ def do_debug_parse_obj(self, args, repository, manifest):
 
     @with_repository(compatibility=Manifest.NO_OPERATION_CHECK)
     def do_debug_format_obj(self, args, repository, manifest):
-        """format file and metadata into borg object file"""
+        """Formats file and metadata into a Borg object file."""
 
         # get the object from id
         hex_id = args.id
@@ -273,7 +273,7 @@ def do_debug_format_obj(self, args, repository, manifest):
 
     @with_repository(manifest=False)
     def do_debug_put_obj(self, args, repository):
-        """put file contents into the repository"""
+        """Puts file contents into the repository."""
         with open(args.path, "rb") as f:
             data = f.read()
         hex_id = args.id
@@ -287,7 +287,7 @@ def do_debug_put_obj(self, args, repository):
 
     @with_repository(manifest=False, exclusive=True)
     def do_debug_delete_obj(self, args, repository):
-        """delete the objects with the given IDs from the repo"""
+        """Deletes the objects with the given IDs from the repository."""
         for hex_id in args.ids:
             try:
                 id = hex_to_bin(hex_id, length=32)
@@ -302,7 +302,7 @@ def do_debug_delete_obj(self, args, repository):
         print("Done.")
 
     def do_debug_convert_profile(self, args):
-        """convert Borg profile to Python profile"""
+        """Converts a Borg profile to a Python profile."""
         import marshal
 
         with open(args.output, "wb") as wfd, open(args.input, "rb") as rfd:
@@ -489,7 +489,7 @@ def build_parser_debug(self, subparsers, common_parser, mid_common_parser):
         # format_obj
         debug_format_obj_epilog = process_epilog(
             """
-                This command formats the file and metadata into objectfile.
+                This command formats the file and metadata into a Borg object file.
                 """
         )
         subparser = debug_parsers.add_parser(
@@ -499,12 +499,12 @@ def build_parser_debug(self, subparsers, common_parser, mid_common_parser):
             description=self.do_debug_format_obj.__doc__,
             epilog=debug_format_obj_epilog,
             formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="format file and metadata into borg objectfile",
+            help="format file and metadata into a Borg object file",
         )
         subparser.set_defaults(func=self.do_debug_format_obj)
         subparser.add_argument("id", metavar="ID", type=str, help="hex object ID to get from the repo")
         subparser.add_argument(
-            "binary_path", metavar="BINARY_PATH", type=str, help="path of the file to convert into objectfile"
+            "binary_path", metavar="BINARY_PATH", type=str, help="path of the file to convert into an object file"
         )
         subparser.add_argument(
             "json_path", metavar="JSON_PATH", type=str, help="path of the json file to read metadata from"
@@ -523,7 +523,7 @@ def build_parser_debug(self, subparsers, common_parser, mid_common_parser):
             "object_path",
             metavar="OBJECT_PATH",
             type=str,
-            help="path of the objectfile to write compressed encrypted data into",
+            help="path of the object file to write compressed encrypted data into",
         )
 
         debug_get_obj_epilog = process_epilog(
diff --git a/src/borg/archiver/delete_cmd.py b/src/borg/archiver/delete_cmd.py
index 36e412e53f..742b151443 100644
--- a/src/borg/archiver/delete_cmd.py
+++ b/src/borg/archiver/delete_cmd.py
@@ -14,7 +14,7 @@
 class DeleteMixIn:
     @with_repository(manifest=False)
     def do_delete(self, args, repository):
-        """Delete archives"""
+        """Deletes archives."""
         self.output_list = args.output_list
         dry_run = args.dry_run
         manifest = Manifest.load(repository, (Manifest.Operation.DELETE,))
@@ -73,9 +73,9 @@ def build_parser_delete(self, subparsers, common_parser, mid_common_parser):
 
         When in doubt, use ``--dry-run --list`` to see what would be deleted.
 
-        You can delete multiple archives by specifying a matching pattern,
-        using the ``--match-archives PATTERN`` option (for more info on these patterns,
-        see :ref:`borg_patterns`).
+        You can delete multiple archives by specifying a match pattern using
+        the ``--match-archives PATTERN`` option (for more information on these
+        patterns, see :ref:`borg_patterns`).
         """
         )
         subparser = subparsers.add_parser(
@@ -85,12 +85,14 @@ def build_parser_delete(self, subparsers, common_parser, mid_common_parser):
             description=self.do_delete.__doc__,
             epilog=delete_epilog,
             formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="delete archive",
+            help="delete archives",
         )
         subparser.set_defaults(func=self.do_delete)
-        subparser.add_argument("-n", "--dry-run", dest="dry_run", action="store_true", help="do not change repository")
         subparser.add_argument(
-            "--list", dest="output_list", action="store_true", help="output verbose list of archives"
+            "-n", "--dry-run", dest="dry_run", action="store_true", help="do not change the repository"
+        )
+        subparser.add_argument(
+            "--list", dest="output_list", action="store_true", help="output a verbose list of archives"
         )
         define_archive_filters_group(subparser)
         subparser.add_argument(
diff --git a/src/borg/archiver/diff_cmd.py b/src/borg/archiver/diff_cmd.py
index 6081d75d20..eb0a10d289 100644
--- a/src/borg/archiver/diff_cmd.py
+++ b/src/borg/archiver/diff_cmd.py
@@ -17,7 +17,7 @@
 class DiffMixIn:
     @with_repository(compatibility=(Manifest.Operation.READ,))
     def do_diff(self, args, repository, manifest):
-        """Diff contents of two archives"""
+        """Finds differences between two archives."""
 
         def actual_change(j):
             j = j.to_dict()
@@ -119,7 +119,7 @@ def build_parser_diff(self, subparsers, common_parser, mid_common_parser):
         The FORMAT specifier syntax
         +++++++++++++++++++++++++++
 
-        The ``--format`` option uses python's `format string syntax
+        The ``--format`` option uses Python's `format string syntax
         <https://docs.python.org/3.9/library/string.html#formatstrings>`_.
 
         Examples:
@@ -170,7 +170,7 @@ def build_parser_diff(self, subparsers, common_parser, mid_common_parser):
             "--same-chunker-params",
             dest="same_chunker_params",
             action="store_true",
-            help="Override check of chunker parameters.",
+            help="override the check of chunker parameters",
         )
         subparser.add_argument("--sort", dest="sort", action="store_true", help="Sort the output lines by file path.")
         subparser.add_argument(
@@ -180,7 +180,7 @@ def build_parser_diff(self, subparsers, common_parser, mid_common_parser):
             action=Highlander,
             help='specify format for differences between archives (default: "{change} {path}{NL}")',
         )
-        subparser.add_argument("--json-lines", action="store_true", help="Format output as JSON Lines. ")
+        subparser.add_argument("--json-lines", action="store_true", help="Format output as JSON Lines.")
         subparser.add_argument(
             "--content-only",
             action="store_true",
@@ -193,6 +193,6 @@ def build_parser_diff(self, subparsers, common_parser, mid_common_parser):
             metavar="PATH",
             nargs="*",
             type=PathSpec,
-            help="paths of items inside the archives to compare; patterns are supported",
+            help="paths of items inside the archives to compare; patterns are supported.",
         )
         define_exclusion_group(subparser)
diff --git a/src/borg/archiver/extract_cmd.py b/src/borg/archiver/extract_cmd.py
index c7fc4b08c7..35f0733922 100644
--- a/src/borg/archiver/extract_cmd.py
+++ b/src/borg/archiver/extract_cmd.py
@@ -24,15 +24,14 @@ class ExtractMixIn:
     @with_repository(compatibility=(Manifest.Operation.READ,))
     @with_archive
     def do_extract(self, args, repository, manifest, archive):
-        """Extract archive contents"""
+        """Extracts archive contents."""
         # be restrictive when restoring files, restore permissions later
         if sys.getfilesystemencoding() == "ascii":
-            logger.warning(
-                'Warning: File system encoding is "ascii", extracting non-ascii filenames will not be supported.'
-            )
+            logger.warning('Warning: Filesystem encoding is "ascii"; extracting non-ASCII filenames is not supported.')
             if sys.platform.startswith(("linux", "freebsd", "netbsd", "openbsd", "darwin")):
                 logger.warning(
-                    "Hint: You likely need to fix your locale setup. E.g. install locales and use: LANG=en_US.UTF-8"
+                    "Hint: You likely need to fix your locale setup. "
+                    "For example, install locales and use: LANG=en_US.UTF-8"
                 )
 
         matcher = build_matcher(args.patterns, args.paths)
@@ -50,7 +49,9 @@ def do_extract(self, args, repository, manifest, archive):
         filter = build_filter(matcher, strip_components)
         if progress:
             pi = ProgressIndicatorPercent(msg="%5.1f%% Extracting: %s", step=0.1, msgid="extract")
-            pi.output("Calculating total archive size for the progress indicator (might take long for large archives)")
+            pi.output(
+                "Calculating total archive size for the progress indicator (might take a long time for large archives)"
+            )
             extracted_size = sum(item.get_size() for item in archive.iter_items(filter))
             pi.total = extracted_size
         else:
@@ -126,16 +127,16 @@ def build_parser_extract(self, subparsers, common_parser, mid_common_parser):
 
         extract_epilog = process_epilog(
             """
-        This command extracts the contents of an archive. By default the entire
-        archive is extracted but a subset of files and directories can be selected
-        by passing a list of ``PATHs`` as arguments. The file selection can further
-        be restricted by using the ``--exclude`` option.
+        This command extracts the contents of an archive. By default, the entire
+        archive is extracted, but a subset of files and directories can be selected
+        by passing a list of ``PATH`` arguments. The file selection can be further
+        restricted by using the ``--exclude`` option.
 
         For more help on include/exclude patterns, see the :ref:`borg_patterns` command output.
 
         By using ``--dry-run``, you can do all extraction steps except actually writing the
-        output data: reading metadata and data chunks from the repo, checking the hash/hmac,
-        decrypting, decompressing.
+        output data: reading metadata and data chunks from the repository, checking the hash/HMAC,
+        decrypting, and decompressing.
 
         ``--progress`` can be slower than no progress display, since it makes one additional
         pass over the archive metadata.
@@ -146,8 +147,8 @@ def build_parser_extract(self, subparsers, common_parser, mid_common_parser):
             so make sure you ``cd`` to the right place before calling ``borg extract``.
 
             When parent directories are not extracted (because of using file/directory selection
-            or any other reason), borg can not restore parent directories' metadata, e.g. owner,
-            group, permission, etc.
+            or any other reason), Borg cannot restore parent directories' metadata, e.g., owner,
+            group, permissions, etc.
         """
         )
         subparser = subparsers.add_parser(
@@ -161,22 +162,22 @@ def build_parser_extract(self, subparsers, common_parser, mid_common_parser):
         )
         subparser.set_defaults(func=self.do_extract)
         subparser.add_argument(
-            "--list", dest="output_list", action="store_true", help="output verbose list of items (files, dirs, ...)"
+            "--list", dest="output_list", action="store_true", help="output a verbose list of items (files, dirs, ...)"
         )
         subparser.add_argument(
             "-n", "--dry-run", dest="dry_run", action="store_true", help="do not actually change any files"
         )
         subparser.add_argument(
-            "--numeric-ids",
-            dest="numeric_ids",
-            action="store_true",
-            help="only obey numeric user and group identifiers",
+            "--numeric-ids", dest="numeric_ids", action="store_true", help="only use numeric user and group identifiers"
         )
         subparser.add_argument(
-            "--noflags", dest="noflags", action="store_true", help="do not extract/set flags (e.g. NODUMP, IMMUTABLE)"
+            "--noflags",
+            dest="noflags",
+            action="store_true",
+            help="do not extract or set flags (e.g. NODUMP, IMMUTABLE)",
         )
-        subparser.add_argument("--noacls", dest="noacls", action="store_true", help="do not extract/set ACLs")
-        subparser.add_argument("--noxattrs", dest="noxattrs", action="store_true", help="do not extract/set xattrs")
+        subparser.add_argument("--noacls", dest="noacls", action="store_true", help="do not extract or set ACLs")
+        subparser.add_argument("--noxattrs", dest="noxattrs", action="store_true", help="do not extract or set xattrs")
         subparser.add_argument(
             "--stdout", dest="stdout", action="store_true", help="write all extracted data to stdout"
         )
@@ -184,13 +185,13 @@ def build_parser_extract(self, subparsers, common_parser, mid_common_parser):
             "--sparse",
             dest="sparse",
             action="store_true",
-            help="create holes in output sparse file from all-zero chunks",
+            help="create holes in the output sparse file from all-zero chunks",
         )
         subparser.add_argument(
             "--continue",
             dest="continue_extraction",
             action="store_true",
-            help="continue a previously interrupted extraction of same archive",
+            help="continue a previously interrupted extraction of the same archive",
         )
         subparser.add_argument("name", metavar="NAME", type=archivename_validator, help="specify the archive name")
         subparser.add_argument(
diff --git a/src/borg/archiver/help_cmd.py b/src/borg/archiver/help_cmd.py
index 16f2e69eaf..cf202e7858 100644
--- a/src/borg/archiver/help_cmd.py
+++ b/src/borg/archiver/help_cmd.py
@@ -68,13 +68,13 @@ class HelpMixIn:
             always normalized to a forward slash '/' before applying a pattern.
 
         Path prefix, selector ``pp:``
-            This pattern style is useful to match whole sub-directories. The pattern
+            This pattern style is useful to match whole subdirectories. The pattern
             ``pp:root/somedir`` matches ``root/somedir`` and everything therein.
             A leading path separator is always removed.
 
         Path full-match, selector ``pf:``
             This pattern style is (only) useful to match full paths.
-            This is kind of a pseudo pattern as it can not have any variable or
+            This is kind of a pseudo pattern as it cannot have any variable or
             unspecified parts - the full path must be given. ``pf:root/file.ext``
             matches ``root/file.ext`` only. A leading path separator is always
             removed.
@@ -101,15 +101,15 @@ class HelpMixIn:
         from within a shell, the patterns should be quoted to protect them from
         expansion.
 
-        Patterns matching special characters, e.g. white space, within a shell may 
+        Patterns matching special characters, e.g. whitespace, within a shell may
         require adjustments, such as putting quotation marks around the arguments.
-        Example: 
+        Example:
         Using bash, the following command line option would match and exclude "item name":
         ``--pattern='-path/item name'``
-        Note that when patterns are used within a pattern file directly read by borg,  
-        e.g. when using ``--exclude-from`` or ``--patterns-from``, there is no shell 
+        Note that when patterns are used within a pattern file directly read by borg,
+        e.g. when using ``--exclude-from`` or ``--patterns-from``, there is no shell
         involved and thus no quotation marks are required.
-        
+
         The ``--exclude-from`` option permits loading exclusion patterns from a text
         file with one pattern per line. Lines empty or starting with the hash sign
         '#' after removing whitespace on both ends are ignored. The optional style
@@ -216,7 +216,7 @@ class HelpMixIn:
 
         .. note::
 
-            It's possible that a sub-directory/file is matched while parent
+            It is possible that a subdirectory or file is matched while its parent
             directories are not. In that case, parent directories are not backed
             up and thus their user, group, permission, etc. cannot be restored.
 
@@ -382,14 +382,14 @@ class HelpMixIn:
     )
     helptext["compression"] = textwrap.dedent(
         """
-        It is no problem to mix different compression methods in one repo,
+        It is no problem to mix different compression methods in one repository,
         deduplication is done on the source data chunks (not on the compressed
         or encrypted data).
 
-        If some specific chunk was once compressed and stored into the repo, creating
+        If some specific chunk was once compressed and stored into the repository, creating
         another backup that also uses this chunk will not change the stored chunk.
         So if you use different compression specs for the backups, whichever stores a
-        chunk first determines its compression. See also borg recreate.
+        chunk first determines its compression. See also ``borg recreate``.
 
         Compression is lz4 by default. If you want something else, you have to specify what you want.
 
diff --git a/src/borg/archiver/info_cmd.py b/src/borg/archiver/info_cmd.py
index 0d3ca05819..30b823bf65 100644
--- a/src/borg/archiver/info_cmd.py
+++ b/src/borg/archiver/info_cmd.py
@@ -68,11 +68,11 @@ def build_parser_info(self, subparsers, common_parser, mid_common_parser):
 
         Please note that the deduplicated sizes of the individual archives do not add
         up to the deduplicated size of the repository ("all archives"), because the two
-        are meaning different things:
+        mean different things:
 
         This archive / deduplicated size = amount of data stored ONLY for this archive
         = unique chunks of this archive.
-        All archives / deduplicated size = amount of data stored in the repo
+        All archives / deduplicated size = amount of data stored in the repository
         = all chunks in the repository.
         """
         )
diff --git a/src/borg/archiver/key_cmds.py b/src/borg/archiver/key_cmds.py
index 50e0315b4d..99cffbafef 100644
--- a/src/borg/archiver/key_cmds.py
+++ b/src/borg/archiver/key_cmds.py
@@ -19,7 +19,7 @@
 class KeysMixIn:
     @with_repository(compatibility=(Manifest.Operation.CHECK,))
     def do_change_passphrase(self, args, repository, manifest):
-        """Change repository key file passphrase"""
+        """Changes the repository key file passphrase."""
         key = manifest.key
         if not hasattr(key, "change_passphrase"):
             raise CommandError("This repository is not encrypted, cannot change the passphrase.")
@@ -31,7 +31,7 @@ def do_change_passphrase(self, args, repository, manifest):
 
     @with_repository(exclusive=True, manifest=True, cache=True, compatibility=(Manifest.Operation.CHECK,))
     def do_change_location(self, args, repository, manifest, cache):
-        """Change repository key location"""
+        """Changes the repository key location."""
         key = manifest.key
         if not hasattr(key, "change_passphrase"):
             raise CommandError("This repository is not encrypted, cannot change the key location.")
@@ -85,7 +85,7 @@ def do_change_location(self, args, repository, manifest, cache):
 
     @with_repository(lock=False, manifest=False, cache=False)
     def do_key_export(self, args, repository):
-        """Export the repository key for backup"""
+        """Exports the repository key for backup."""
         manager = KeyManager(repository)
         manager.load_keyblob()
         try:
@@ -104,15 +104,15 @@ def do_key_export(self, args, repository):
 
     @with_repository(lock=False, manifest=False, cache=False)
     def do_key_import(self, args, repository):
-        """Import the repository key from backup"""
+        """Imports the repository key from backup."""
         manager = KeyManager(repository)
         if args.paper:
             if args.path:
-                raise CommandError("with --paper import from file is not supported")
+                raise CommandError("with --paper, import from file is not supported")
             manager.import_paperkey(args)
         else:
             if not args.path:
-                raise CommandError("expected input file to import key from")
+                raise CommandError("expected input file to import the key from")
             if args.path != "-" and not os.path.exists(args.path):
                 raise CommandError(f"input file does not exist: {args.path}")
             manager.import_keyfile(args)
@@ -124,10 +124,10 @@ def build_parser_keys(self, subparsers, common_parser, mid_common_parser):
             "key",
             parents=[mid_common_parser],
             add_help=False,
-            description="Manage a keyfile or repokey of a repository",
+            description="Manage the keyfile or repokey of a repository",
             epilog="",
             formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="manage repository key",
+            help="manage the repository key",
         )
 
         key_parsers = subparser.add_subparsers(title="required arguments", metavar="<command>")
@@ -165,7 +165,7 @@ def build_parser_keys(self, subparsers, common_parser, mid_common_parser):
             description=self.do_key_export.__doc__,
             epilog=key_export_epilog,
             formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="export repository key for backup",
+            help="export the repository key for backup",
         )
         subparser.set_defaults(func=self.do_key_export)
         subparser.add_argument("path", metavar="PATH", nargs="?", type=PathSpec, help="where to store the backup")
@@ -179,7 +179,7 @@ def build_parser_keys(self, subparsers, common_parser, mid_common_parser):
             "--qr-html",
             dest="qr",
             action="store_true",
-            help="Create an html file suitable for printing and later type-in or qr scan",
+            help="Create an HTML file suitable for printing and later type-in or QR scan",
         )
 
         key_import_epilog = process_epilog(
@@ -207,7 +207,7 @@ def build_parser_keys(self, subparsers, common_parser, mid_common_parser):
             description=self.do_key_import.__doc__,
             epilog=key_import_epilog,
             formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="import repository key from backup",
+            help="import the repository key from backup",
         )
         subparser.set_defaults(func=self.do_key_import)
         subparser.add_argument(
@@ -238,16 +238,16 @@ def build_parser_keys(self, subparsers, common_parser, mid_common_parser):
             description=self.do_change_passphrase.__doc__,
             epilog=change_passphrase_epilog,
             formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="change repository passphrase",
+            help="change the repository passphrase",
         )
         subparser.set_defaults(func=self.do_change_passphrase)
 
         change_location_epilog = process_epilog(
             """
-        Change the location of a borg key. The key can be stored at different locations:
+        Change the location of a Borg key. The key can be stored at different locations:
 
         - keyfile: locally, usually in the home directory
-        - repokey: inside the repo (in the repo config)
+        - repokey: inside the repository (in the repository config)
 
         Please note:
 
@@ -262,7 +262,7 @@ def build_parser_keys(self, subparsers, common_parser, mid_common_parser):
             description=self.do_change_location.__doc__,
             epilog=change_location_epilog,
             formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="change key location",
+            help="change the key location",
         )
         subparser.set_defaults(func=self.do_change_location)
         subparser.add_argument(
diff --git a/src/borg/archiver/list_cmd.py b/src/borg/archiver/list_cmd.py
index 7e13d94fdf..0d1c800ead 100644
--- a/src/borg/archiver/list_cmd.py
+++ b/src/borg/archiver/list_cmd.py
@@ -18,7 +18,7 @@
 class ListMixIn:
     @with_repository(compatibility=(Manifest.Operation.READ,))
     def do_list(self, args, repository, manifest):
-        """List archive contents"""
+        """List archive contents."""
         matcher = build_matcher(args.patterns, args.paths)
         if args.format is not None:
             format = args.format
@@ -64,14 +64,14 @@ def build_parser_list(self, subparsers, common_parser, mid_common_parser):
                 """
         This command lists the contents of an archive.
 
-        For more help on include/exclude patterns, see the :ref:`borg_patterns` command output.
+        For more help on include/exclude patterns, see the output of :ref:`borg_patterns`.
 
         .. man NOTES
 
         The FORMAT specifier syntax
         +++++++++++++++++++++++++++
 
-        The ``--format`` option uses python's `format string syntax
+        The ``--format`` option uses Python's `format string syntax
         <https://docs.python.org/3.9/library/string.html#formatstrings>`_.
 
         Examples:
@@ -132,11 +132,7 @@ def build_parser_list(self, subparsers, common_parser, mid_common_parser):
             "Some keys are always present. Note: JSON can only represent text.",
         )
         subparser.add_argument(
-            "--depth",
-            metavar="N",
-            dest="depth",
-            type=int,
-            help="only list files up to the specified directory level depth",
+            "--depth", metavar="N", dest="depth", type=int, help="only list files up to the specified directory depth"
         )
         subparser.add_argument("name", metavar="NAME", type=archivename_validator, help="specify the archive name")
         subparser.add_argument(
diff --git a/src/borg/archiver/lock_cmds.py b/src/borg/archiver/lock_cmds.py
index dadfe039ac..1739da6df3 100644
--- a/src/borg/archiver/lock_cmds.py
+++ b/src/borg/archiver/lock_cmds.py
@@ -14,7 +14,7 @@
 class LocksMixIn:
     @with_repository(manifest=False, exclusive=True)
     def do_with_lock(self, args, repository):
-        """run a user specified command with the repository lock held"""
+        """Runs a user-specified command with the repository lock held."""
         # the repository lock needs to get refreshed regularly, or it will be killed as stale.
         # refreshing the lock is not part of the repository API, so we do it indirectly via repository.info.
         lock_refreshing_thread = ThreadRunner(sleep_interval=60, target=repository.info)
@@ -25,13 +25,13 @@ def do_with_lock(self, args, repository):
             rc = subprocess.call([args.command] + args.args, env=env)  # nosec B603
             set_ec(rc)
         except (FileNotFoundError, OSError, ValueError) as e:
-            raise CommandError(f"Error while trying to run '{args.command}': {e}")
+            raise CommandError(f"Failed to execute command: {e}")
         finally:
             lock_refreshing_thread.terminate()
 
     @with_repository(lock=False, manifest=False)
     def do_break_lock(self, args, repository):
-        """Break the repository lock (e.g. in case it was left by a dead borg."""
+        """Breaks the repository lock (for example, if it was left by a dead Borg process)."""
         repository.break_lock()
         Cache.break_lock(repository)
 
@@ -41,8 +41,8 @@ def build_parser_locks(self, subparsers, common_parser, mid_common_parser):
         break_lock_epilog = process_epilog(
             """
         This command breaks the repository and cache locks.
-        Please use carefully and only while no borg process (on any machine) is
-        trying to access the Cache or the Repository.
+        Use with care and only when no Borg process (on any machine) is
+        trying to access the cache or the repository.
         """
         )
         subparser = subparsers.add_parser(
@@ -52,7 +52,7 @@ def build_parser_locks(self, subparsers, common_parser, mid_common_parser):
             description=self.do_break_lock.__doc__,
             epilog=break_lock_epilog,
             formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="break repository and cache locks",
+            help="break the repository and cache locks",
         )
         subparser.set_defaults(func=self.do_break_lock)
 
@@ -64,16 +64,16 @@ def build_parser_locks(self, subparsers, common_parser, mid_common_parser):
 
             $ BORG_REPO=/mnt/borgrepo borg with-lock rsync -av /mnt/borgrepo /somewhere/else/borgrepo
 
-        It will first try to acquire the lock (make sure that no other operation is
-        running in the repo), then execute the given command as a subprocess and wait
-        for its termination, release the lock and return the user command's return
-        code as borg's return code.
+        It first tries to acquire the lock (make sure that no other operation is
+        running in the repository), then executes the given command as a subprocess and waits
+        for its termination, releases the lock, and returns the user command's return
+        code as Borg's return code.
 
         .. note::
 
             If you copy a repository with the lock held, the lock will be present in
-            the copy. Thus, before using borg on the copy from a different host,
-            you need to use "borg break-lock" on the copied repository, because
+            the copy. Before using Borg on the copy from a different host,
+            you need to run ``borg break-lock`` on the copied repository, because
             Borg is cautious and does not automatically remove stale locks made by a different host.
         """
         )
@@ -84,7 +84,7 @@ def build_parser_locks(self, subparsers, common_parser, mid_common_parser):
             description=self.do_with_lock.__doc__,
             epilog=with_lock_epilog,
             formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="run user command with lock held",
+            help="run a user command with the lock held",
         )
         subparser.set_defaults(func=self.do_with_lock)
         subparser.add_argument("command", metavar="COMMAND", help="command to run")
diff --git a/src/borg/archiver/mount_cmds.py b/src/borg/archiver/mount_cmds.py
index 7dcb2eda43..303fde767c 100644
--- a/src/borg/archiver/mount_cmds.py
+++ b/src/borg/archiver/mount_cmds.py
@@ -16,7 +16,7 @@
 
 class MountMixIn:
     def do_mount(self, args):
-        """Mount archive or an entire repository as a FUSE filesystem"""
+        """Mounts an archive or an entire repository as a FUSE filesystem."""
         # Perform these checks before opening the repository and asking for a passphrase.
 
         from ..fuse_impl import llfuse, BORG_FUSE_IMPL
@@ -46,7 +46,7 @@ def _do_mount(self, args, repository, manifest):
                 raise RTError("FUSE mount failed")
 
     def do_umount(self, args):
-        """un-mount the FUSE filesystem"""
+        """Unmounts the FUSE filesystem."""
         umount(args.mountpoint)
 
     def build_parser_mount_umount(self, subparsers, common_parser, mid_common_parser):
@@ -64,15 +64,15 @@ def build_parser_mount_umount(self, subparsers, common_parser, mid_common_parser
         archives and the directory structure below these will be loaded on-demand from
         the repository when entering these directories, so expect some delay.
 
-        Unless the ``--foreground`` option is given the command will run in the
-        background until the filesystem is ``umounted``.
+        Unless the ``--foreground`` option is given, the command will run in the
+        background until the filesystem is ``unmounted``.
 
         Performance tips:
 
-        - when doing a "whole repository" mount:
-          do not enter archive dirs if not needed, this avoids on-demand loading.
-        - only mount a specific archive, not the whole repository.
-        - only mount specific paths in a specific archive, not the complete archive.
+        - When doing a "whole repository" mount:
+          do not enter archive directories if not needed; this avoids on-demand loading.
+        - Only mount a specific archive, not the whole repository.
+        - Only mount specific paths in a specific archive, not the complete archive.
 
         The command ``borgfs`` provides a wrapper for ``borg mount``. This can also be
         used in fstab entries:
@@ -84,35 +84,35 @@ def build_parser_mount_umount(self, subparsers, common_parser, mid_common_parser
         For FUSE configuration and mount options, see the mount.fuse(8) manual page.
 
         Borg's default behavior is to use the archived user and group names of each
-        file and map them to the system's respective user and group ids.
+        file and map them to the system's respective user and group IDs.
         Alternatively, using ``numeric-ids`` will instead use the archived user and
-        group ids without any mapping.
+        group IDs without any mapping.
 
         The ``uid`` and ``gid`` mount options (implemented by Borg) can be used to
-        override the user and group ids of all files (i.e., ``borg mount -o
+        override the user and group IDs of all files (i.e., ``borg mount -o
         uid=1000,gid=1000``).
 
         The man page references ``user_id`` and ``group_id`` mount options
-        (implemented by fuse) which specify the user and group id of the mount owner
-        (aka, the user who does the mounting). It is set automatically by libfuse (or
+        (implemented by FUSE) which specify the user and group ID of the mount owner
+        (also known as the user who does the mounting). It is set automatically by libfuse (or
         the filesystem if libfuse is not used). However, you should not specify these
-        manually. Unlike the ``uid`` and ``gid`` mount options which affect all files,
-        ``user_id`` and ``group_id`` affect the user and group id of the mounted
+        manually. Unlike the ``uid`` and ``gid`` mount options, which affect all files,
+        ``user_id`` and ``group_id`` affect the user and group ID of the mounted
         (base) directory.
 
-        Additional mount options supported by borg:
+        Additional mount options supported by Borg:
 
         - ``versions``: when used with a repository mount, this gives a merged, versioned
-          view of the files in the archives. EXPERIMENTAL, layout may change in future.
-        - ``allow_damaged_files``: by default damaged files (where chunks are missing)
+          view of the files in the archives. EXPERIMENTAL; layout may change in the future.
+        - ``allow_damaged_files``: by default, damaged files (where chunks are missing)
           will return EIO (I/O error) when trying to read the related parts of the file.
           Set this option to replace the missing parts with all-zero bytes.
         - ``ignore_permissions``: for security reasons the ``default_permissions`` mount
-          option is internally enforced by borg. ``ignore_permissions`` can be given to
+          option is internally enforced by Borg. ``ignore_permissions`` can be given to
           not enforce ``default_permissions``.
 
-        The BORG_MOUNT_DATA_CACHE_ENTRIES environment variable is meant for advanced users
-        to tweak the performance. It sets the number of cached data chunks; additional
+        The BORG_MOUNT_DATA_CACHE_ENTRIES environment variable is intended for advanced users
+        to tweak performance. It sets the number of cached data chunks; additional
         memory usage can be up to ~8 MiB times this number. The default is the number
         of CPU cores.
 
@@ -131,13 +131,13 @@ def build_parser_mount_umount(self, subparsers, common_parser, mid_common_parser
             description=self.do_mount.__doc__,
             epilog=mount_epilog,
             formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="mount repository",
+            help="mount a repository",
         )
         self._define_borg_mount(subparser)
 
         umount_epilog = process_epilog(
             """
-        This command un-mounts a FUSE filesystem that was mounted with ``borg mount``.
+        This command unmounts a FUSE filesystem that was mounted with ``borg mount``.
 
         This is a convenience wrapper that just calls the platform-specific shell
         command - usually this is either umount or fusermount -u.
@@ -150,11 +150,11 @@ def build_parser_mount_umount(self, subparsers, common_parser, mid_common_parser
             description=self.do_umount.__doc__,
             epilog=umount_epilog,
             formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="umount repository",
+            help="unmount a repository",
         )
         subparser.set_defaults(func=self.do_umount)
         subparser.add_argument(
-            "mountpoint", metavar="MOUNTPOINT", type=str, help="mountpoint of the filesystem to umount"
+            "mountpoint", metavar="MOUNTPOINT", type=str, help="mountpoint of the filesystem to unmount"
         )
 
     def build_parser_borgfs(self, parser):
@@ -162,7 +162,7 @@ def build_parser_borgfs(self, parser):
         parser.description = self.do_mount.__doc__
         parser.epilog = "For more information, see borg mount --help."
         parser.formatter_class = argparse.RawDescriptionHelpFormatter
-        parser.help = "mount repository"
+        parser.help = "mount a repository"
         self._define_borg_mount(parser)
         return parser
 
@@ -170,16 +170,16 @@ def _define_borg_mount(self, parser):
         from ._common import define_exclusion_group, define_archive_filters_group
 
         parser.set_defaults(func=self.do_mount)
-        parser.add_argument("mountpoint", metavar="MOUNTPOINT", type=str, help="where to mount filesystem")
+        parser.add_argument("mountpoint", metavar="MOUNTPOINT", type=str, help="where to mount the filesystem")
         parser.add_argument(
             "-f", "--foreground", dest="foreground", action="store_true", help="stay in foreground, do not daemonize"
         )
-        parser.add_argument("-o", dest="options", type=str, action=Highlander, help="Extra mount options")
+        parser.add_argument("-o", dest="options", type=str, action=Highlander, help="extra mount options")
         parser.add_argument(
             "--numeric-ids",
             dest="numeric_ids",
             action="store_true",
-            help="use numeric user and group identifiers from archive(s)",
+            help="use numeric user and group identifiers from archives",
         )
         define_archive_filters_group(parser)
         parser.add_argument(
diff --git a/src/borg/archiver/prune_cmd.py b/src/borg/archiver/prune_cmd.py
index a4922b46a0..05eb7867b8 100644
--- a/src/borg/archiver/prune_cmd.py
+++ b/src/borg/archiver/prune_cmd.py
@@ -119,7 +119,7 @@ def prune_split(archives, rule, n, kept_because=None):
 class PruneMixIn:
     @with_repository(compatibility=(Manifest.Operation.DELETE,))
     def do_prune(self, args, repository, manifest):
-        """Prune repository archives according to specified rules"""
+        """Prune repository archives according to specified rules."""
         if not any(
             (
                 args.secondly,
@@ -280,12 +280,14 @@ def build_parser_prune(self, subparsers, common_parser, mid_common_parser):
             description=self.do_prune.__doc__,
             epilog=prune_epilog,
             formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="prune archives",
+            help="prune repository archives",
         )
         subparser.set_defaults(func=self.do_prune)
-        subparser.add_argument("-n", "--dry-run", dest="dry_run", action="store_true", help="do not change repository")
         subparser.add_argument(
-            "--list", dest="output_list", action="store_true", help="output verbose list of archives it keeps/prunes"
+            "-n", "--dry-run", dest="dry_run", action="store_true", help="do not change the repository"
+        )
+        subparser.add_argument(
+            "--list", dest="output_list", action="store_true", help="output a verbose list of archives it keeps/prunes"
         )
         subparser.add_argument("--short", dest="short", action="store_true", help="use a less wide archive part format")
         subparser.add_argument(
diff --git a/src/borg/archiver/recreate_cmd.py b/src/borg/archiver/recreate_cmd.py
index c528d9018c..4ab928e251 100644
--- a/src/borg/archiver/recreate_cmd.py
+++ b/src/borg/archiver/recreate_cmd.py
@@ -17,7 +17,7 @@
 class RecreateMixIn:
     @with_repository(cache=True, compatibility=(Manifest.Operation.CHECK,))
     def do_recreate(self, args, repository, manifest, cache):
-        """Re-create archives"""
+        """Recreate archives."""
         matcher = build_matcher(args.patterns, args.paths)
         self.output_list = args.output_list
         self.output_filter = args.output_filter
@@ -63,15 +63,15 @@ def build_parser_recreate(self, subparsers, common_parser, mid_common_parser):
             """
         Recreate the contents of existing archives.
 
-        recreate is a potentially dangerous function and might lead to data loss
+        Recreate is a potentially dangerous function and might lead to data loss
         (if used wrongly). BE VERY CAREFUL!
 
         Important: Repository disk space is **not** freed until you run ``borg compact``.
 
         ``--exclude``, ``--exclude-from``, ``--exclude-if-present``, ``--keep-exclude-tags``
         and PATH have the exact same semantics as in "borg create", but they only check
-        for files in the archives and not in the local file system. If PATHs are specified,
-        the resulting archives will only contain files from these PATHs.
+        files in the archives and not in the local filesystem. If paths are specified,
+        the resulting archives will contain only files from those paths.
 
         Note that all paths in an archive are relative, therefore absolute patterns/paths
         will *not* match (``--exclude``, ``--exclude-from``, PATHs).
@@ -80,9 +80,9 @@ def build_parser_recreate(self, subparsers, common_parser, mid_common_parser):
         used to have upgraded Borg 0.xx archives deduplicate with Borg 1.x archives.
 
         **USE WITH CAUTION.**
-        Depending on the PATHs and patterns given, recreate can be used to
+        Depending on the paths and patterns given, recreate can be used to
         delete files from archives permanently.
-        When in doubt, use ``--dry-run --verbose --list`` to see how patterns/PATHS are
+        When in doubt, use ``--dry-run --verbose --list`` to see how patterns/paths are
         interpreted. See :ref:`list_item_flags` in ``borg create`` for details.
 
         The archive being recreated is only removed after the operation completes. The
@@ -97,8 +97,8 @@ def build_parser_recreate(self, subparsers, common_parser, mid_common_parser):
 
         If your most recent borg check found missing chunks, please first run another
         backup for the same data, before doing any rechunking. If you are lucky, that
-        will re-create the missing chunks. Optionally, do another borg check, to see
-        if the chunks are still missing).
+        will recreate the missing chunks. Optionally, do another borg check to see
+        if the chunks are still missing.
         """
         )
         subparser = subparsers.add_parser(
diff --git a/src/borg/archiver/rename_cmd.py b/src/borg/archiver/rename_cmd.py
index ba94a0691e..bdb338843f 100644
--- a/src/borg/archiver/rename_cmd.py
+++ b/src/borg/archiver/rename_cmd.py
@@ -14,7 +14,7 @@ class RenameMixIn:
     @with_repository(cache=True, compatibility=(Manifest.Operation.CHECK,))
     @with_archive
     def do_rename(self, args, repository, manifest, cache, archive):
-        """Rename an existing archive"""
+        """Rename an existing archive."""
         archive.rename(args.newname)
         manifest.write()
 
@@ -35,10 +35,12 @@ def build_parser_rename(self, subparsers, common_parser, mid_common_parser):
             description=self.do_rename.__doc__,
             epilog=rename_epilog,
             formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="rename archive",
+            help="rename an archive",
         )
         subparser.set_defaults(func=self.do_rename)
-        subparser.add_argument("name", metavar="OLDNAME", type=archivename_validator, help="specify the archive name")
+        subparser.add_argument(
+            "name", metavar="OLDNAME", type=archivename_validator, help="specify the current archive name"
+        )
         subparser.add_argument(
             "newname", metavar="NEWNAME", type=archivename_validator, help="specify the new archive name"
         )
diff --git a/src/borg/archiver/repo_compress_cmd.py b/src/borg/archiver/repo_compress_cmd.py
index f67e1b045e..a5aeb9a545 100644
--- a/src/borg/archiver/repo_compress_cmd.py
+++ b/src/borg/archiver/repo_compress_cmd.py
@@ -16,7 +16,7 @@
 
 
 def find_chunks(repository, repo_objs, cache, stats, ctype, clevel, olevel):
-    """find and flag chunks that need processing (usually: recompression)."""
+    """Find and flag chunks that need processing (usually: recompression)."""
     compr_keys = stats["compr_keys"] = set()
     compr_wanted = ctype, clevel, olevel
     recompress_count = 0
@@ -35,7 +35,7 @@ def find_chunks(repository, repo_objs, cache, stats, ctype, clevel, olevel):
 
 
 def process_chunks(repository, repo_objs, stats, recompress_ids, olevel):
-    """process some chunks (usually: recompress)"""
+    """Process some chunks (usually: recompress)."""
     compr_keys = stats["compr_keys"]
     if compr_keys == 0:  # work around defaultdict(int)
         compr_keys = stats["compr_keys"] = set()
@@ -87,7 +87,7 @@ def format_compression_spec(ctype, clevel, olevel):
 class RepoCompressMixIn:
     @with_repository(cache=True, manifest=True, compatibility=(Manifest.Operation.CHECK,))
     def do_repo_compress(self, args, repository, manifest, cache):
-        """Repository (re-)compression"""
+        """Repository (re-)compression."""
 
         def get_csettings(c):
             if isinstance(c, Auto):
diff --git a/src/borg/archiver/repo_create_cmd.py b/src/borg/archiver/repo_create_cmd.py
index 132be033c5..ded3b0918c 100644
--- a/src/borg/archiver/repo_create_cmd.py
+++ b/src/borg/archiver/repo_create_cmd.py
@@ -17,7 +17,7 @@ class RepoCreateMixIn:
     @with_repository(create=True, exclusive=True, manifest=False)
     @with_other_repository(manifest=True, compatibility=(Manifest.Operation.READ,))
     def do_repo_create(self, args, repository, *, other_repository=None, other_manifest=None):
-        """Create a new, empty repository"""
+        """Creates a new, empty repository."""
         other_key = other_manifest.key if other_manifest is not None else None
         path = args.location.canonical_path()
         logger.info('Initializing repository at "%s"' % path)
@@ -36,18 +36,18 @@ def do_repo_create(self, args, repository, *, other_repository=None, other_manif
         if key.NAME != "plaintext":
             logger.warning(
                 "\n"
-                "IMPORTANT: you will need both KEY AND PASSPHRASE to access this repo!\n"
+                "IMPORTANT: you will need both KEY AND PASSPHRASE to access this repository!\n"
                 "\n"
                 "Key storage location depends on the mode:\n"
                 "- repokey modes: key is stored in the repository directory.\n"
                 "- keyfile modes: key is stored in the home directory of this user.\n"
                 "\n"
                 "For any mode, you should:\n"
-                "1. Export the borg key and store the result at a safe place:\n"
+                "1. Export the Borg key and store the result in a safe place:\n"
                 "   borg key export -r REPOSITORY           encrypted-key-backup\n"
                 "   borg key export -r REPOSITORY --paper   encrypted-key-backup.txt\n"
                 "   borg key export -r REPOSITORY --qr-html encrypted-key-backup.html\n"
-                "2. Write down the borg key passphrase and store it at safe place."
+                "2. Write down the Borg key passphrase and store it in a safe place."
             )
         logger.warning(
             "\n"
@@ -68,7 +68,7 @@ def build_parser_repo_create(self, subparsers, common_parser, mid_common_parser)
         this is due to borgstore pre-creating all directories needed, making usage of the
         store faster.
 
-        Encryption mode TLDR
+        Encryption mode TL;DR
         ++++++++++++++++++++
 
         The encryption mode can only be configured when creating a new repository - you can
@@ -94,7 +94,7 @@ def build_parser_repo_create(self, subparsers, common_parser, mid_common_parser)
            "leaving your keys inside your car" (see :ref:`borg_key_export`).
            The encryption is done locally - if you use a remote repository, the remote machine
            never sees your passphrase, your unencrypted key or your unencrypted files.
-           Chunking and id generation are also based on your key to improve
+           Chunking and ID generation are also based on your key to improve
            your privacy.
         7. Use the key when extracting files to decrypt them and to verify that the contents of
            the backups have not been accidentally or maliciously altered.
@@ -104,27 +104,27 @@ def build_parser_repo_create(self, subparsers, common_parser, mid_common_parser)
 
         Make sure you use a good passphrase. Not too short, not too simple. The real
         encryption / decryption key is encrypted with / locked by your passphrase.
-        If an attacker gets your key, he can't unlock and use it without knowing the
+        If an attacker gets your key, they cannot unlock and use it without knowing the
         passphrase.
 
-        Be careful with special or non-ascii characters in your passphrase:
+        Be careful with special or non-ASCII characters in your passphrase:
 
-        - Borg processes the passphrase as unicode (and encodes it as utf-8),
+        - Borg processes the passphrase as Unicode (and encodes it as UTF-8),
           so it does not have problems dealing with even the strangest characters.
-        - BUT: that does not necessarily apply to your OS / VM / keyboard configuration.
+        - BUT: that does not necessarily apply to your OS/VM/keyboard configuration.
 
-        So better use a long passphrase made from simple ascii chars than one that
-        includes non-ascii stuff or characters that are hard/impossible to enter on
+        So better use a long passphrase made from simple ASCII characters than one that
+        includes non-ASCII stuff or characters that are hard or impossible to enter on
         a different keyboard layout.
 
-        You can change your passphrase for existing repos at any time, it won't affect
+        You can change your passphrase for existing repositories at any time; it will not affect
         the encryption/decryption key or other secrets.
 
         Choosing an encryption mode
         +++++++++++++++++++++++++++
 
         Depending on your hardware, hashing and crypto performance may vary widely.
-        The easiest way to find out about what's fastest is to run ``borg benchmark cpu``.
+        The easiest way to find out what is fastest is to run ``borg benchmark cpu``.
 
         `repokey` modes: if you want ease-of-use and "passphrase" security is good enough -
         the key will be stored in the repository (in ``repo_dir/config``).
@@ -157,14 +157,14 @@ def build_parser_repo_create(self, subparsers, common_parser, mid_common_parser)
 
         .. nanorst: inline-replace
 
-        `none` mode uses no encryption and no authentication. You're advised NOT to use this mode
+        `none` mode uses no encryption and no authentication. You are advised NOT to use this mode
         as it would expose you to all sorts of issues (DoS, confidentiality, tampering, ...) in
         case of malicious activity in the repository.
 
         If you do **not** want to encrypt the contents of your backups, but still want to detect
-        malicious tampering use an `authenticated` mode. It's like `repokey` minus encryption.
-        To normally work with ``authenticated`` repos, you will need the passphrase, but
-        there is an emergency workaround, see ``BORG_WORKAROUNDS=authenticated_no_key`` docs.
+        malicious tampering, use an `authenticated` mode. It is like `repokey` minus encryption.
+        To normally work with ``authenticated`` repositories, you will need the passphrase, but
+        there is an emergency workaround; see ``BORG_WORKAROUNDS=authenticated_no_key`` docs.
 
         Creating a related repository
         +++++++++++++++++++++++++++++
@@ -176,12 +176,12 @@ def build_parser_repo_create(self, subparsers, common_parser, mid_common_parser)
         for deduplication) and the AE crypto keys will be newly generated random keys.
 
         Optionally, if you use ``--copy-crypt-key`` you can also keep the same crypt_key
-        (used for authenticated encryption). Might be desired e.g. if you want to have less
+        (used for authenticated encryption). This might be desired, for example, if you want to have fewer
         keys to manage.
 
-        Creating related repositories is useful e.g. if you want to use ``borg transfer`` later.
+        Creating related repositories is useful, for example, if you want to use ``borg transfer`` later.
 
-        Creating a related repository for data migration from borg 1.2 or 1.4
+        Creating a related repository for data migration from Borg 1.2 or 1.4
         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
         You can use ``borg repo-create --other-repo ORIG_REPO --from-borg1 ...`` to create a related
@@ -210,7 +210,7 @@ def build_parser_repo_create(self, subparsers, common_parser, mid_common_parser)
             help="reuse the key material from the other repository",
         )
         subparser.add_argument(
-            "--from-borg1", dest="v1_or_v2", action="store_true", help="other repository is borg 1.x"
+            "--from-borg1", dest="v1_or_v2", action="store_true", help="other repository is Borg 1.x"
         )
         subparser.add_argument(
             "-e",
@@ -226,6 +226,6 @@ def build_parser_repo_create(self, subparsers, common_parser, mid_common_parser)
             "--copy-crypt-key",
             dest="copy_crypt_key",
             action="store_true",
-            help="copy the crypt_key (used for authenticated encryption) from the key of the other repo "
+            help="copy the crypt_key (used for authenticated encryption) from the key of the other repository "
             "(default: new random key).",
         )
diff --git a/src/borg/archiver/repo_delete_cmd.py b/src/borg/archiver/repo_delete_cmd.py
index 216b33624b..c4fade0abd 100644
--- a/src/borg/archiver/repo_delete_cmd.py
+++ b/src/borg/archiver/repo_delete_cmd.py
@@ -17,7 +17,7 @@
 class RepoDeleteMixIn:
     @with_repository(exclusive=True, manifest=False)
     def do_repo_delete(self, args, repository):
-        """Delete a repository"""
+        """Deletes the repository."""
         self.output_list = args.output_list
         dry_run = args.dry_run
         keep_security_info = args.keep_security_info
@@ -54,10 +54,10 @@ def do_repo_delete(self, args, repository):
                             for archive_info in manifest.archives.list(sort_by=["ts"]):
                                 msg.append(format_archive(archive_info))
                         else:
-                            msg.append("This repository seems not to have any archives.")
+                            msg.append("This repository does not appear to have any archives.")
                     else:
                         msg.append(
-                            "This repository seems to have no manifest, so we can't "
+                            "This repository seems to have no manifest, so we cannot "
                             "tell anything about its contents."
                         )
 
@@ -109,19 +109,21 @@ def build_parser_repo_delete(self, subparsers, common_parser, mid_common_parser)
             description=self.do_repo_delete.__doc__,
             epilog=repo_delete_epilog,
             formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="delete repository",
+            help="delete the repository",
         )
         subparser.set_defaults(func=self.do_repo_delete)
-        subparser.add_argument("-n", "--dry-run", dest="dry_run", action="store_true", help="do not change repository")
         subparser.add_argument(
-            "--list", dest="output_list", action="store_true", help="output verbose list of archives"
+            "-n", "--dry-run", dest="dry_run", action="store_true", help="do not change the repository"
+        )
+        subparser.add_argument(
+            "--list", dest="output_list", action="store_true", help="output a verbose list of archives"
         )
         subparser.add_argument(
             "--force",
             dest="forced",
             action="count",
             default=0,
-            help="force deletion of corrupted archives, " "use ``--force --force`` in case ``--force`` does not work.",
+            help="force deletion of corrupted archives; use ``--force --force`` if a single ``--force`` does not work.",
         )
         subparser.add_argument(
             "--cache-only",
diff --git a/src/borg/archiver/repo_info_cmd.py b/src/borg/archiver/repo_info_cmd.py
index 28d0a5357c..0b11ed6e8a 100644
--- a/src/borg/archiver/repo_info_cmd.py
+++ b/src/borg/archiver/repo_info_cmd.py
@@ -14,7 +14,7 @@
 class RepoInfoMixIn:
     @with_repository(cache=True, compatibility=(Manifest.Operation.READ,))
     def do_repo_info(self, args, repository, manifest, cache):
-        """Show repository infos"""
+        """Show repository information."""
         key = manifest.key
         info = basic_json_data(manifest, cache=cache, extra={"security_dir": cache.security_manager.dir})
 
@@ -37,7 +37,7 @@ def do_repo_info(self, args, repository, manifest, cache):
             Location: {location}
             Repository version: {version}
             {encryption}
-            Security dir: {security_dir}
+            Security directory: {security_dir}
             """
                 )
                 .strip()
diff --git a/src/borg/archiver/repo_list_cmd.py b/src/borg/archiver/repo_list_cmd.py
index fbdb327d34..c6c8480ee3 100644
--- a/src/borg/archiver/repo_list_cmd.py
+++ b/src/borg/archiver/repo_list_cmd.py
@@ -16,7 +16,7 @@
 class RepoListMixIn:
     @with_repository(compatibility=(Manifest.Operation.READ,))
     def do_repo_list(self, args, repository, manifest):
-        """List the archives contained in a repository"""
+        """List the archives contained in a repository."""
         if args.format is not None:
             format = args.format
         elif args.short:
@@ -52,7 +52,7 @@ def build_parser_repo_list(self, subparsers, common_parser, mid_common_parser):
         The FORMAT specifier syntax
         +++++++++++++++++++++++++++
 
-        The ``--format`` option uses python's `format string syntax
+        The ``--format`` option uses Python's `format string syntax
         <https://docs.python.org/3.9/library/string.html#formatstrings>`_.
 
         Examples:
diff --git a/src/borg/archiver/repo_space_cmd.py b/src/borg/archiver/repo_space_cmd.py
index 919ab49014..45c1646a28 100644
--- a/src/borg/archiver/repo_space_cmd.py
+++ b/src/borg/archiver/repo_space_cmd.py
@@ -16,7 +16,7 @@
 class RepoSpaceMixIn:
     @with_repository(lock=False, manifest=False)
     def do_repo_space(self, args, repository):
-        """Manage reserved space in repository"""
+        """Manages reserved space in the repository."""
         # we work without locking here because locks don't work with full disk.
         if args.reserve_space > 0:
             storage_space_reserve_object_size = 64 * 2**20  # 64 MiB per object
@@ -35,7 +35,7 @@ def do_repo_space(self, args, repository):
                 if info.name.startswith("space-reserve."):
                     size += info.size
                     repository.store_delete(f"config/{info.name}")
-            print(f"Freed {format_file_size(size, iec=False)} in repository.")
+            print(f"Freed {format_file_size(size, iec=False)} in the repository.")
             print("Now run borg prune or borg delete plus borg compact to free more space.")
             print("After that, do not forget to reserve space again for next time!")
         else:  # print amount currently reserved
@@ -56,24 +56,23 @@ def build_parser_repo_space(self, subparsers, common_parser, mid_common_parser):
             """
         This command manages reserved space in a repository.
 
-        Borg can not work in disk-full conditions (can not lock a repo and thus can
-        not run prune/delete or compact operations to free disk space).
+        Borg cannot work in disk-full conditions (it cannot lock a repository and thus cannot
+        run prune/delete or compact operations to free disk space).
 
-        To avoid running into dead-end situations like that, you can put some objects
-        into a repository that take up some disk space. If you ever run into a
-        disk-full situation, you can free that space and then borg will be able to
-        run normally, so you can free more disk space by using prune/delete/compact.
-        After that, don't forget to reserve space again, in case you run into that
-        situation again at a later time.
+        To avoid running into such dead-end situations, you can put some objects into a
+        repository that take up disk space. If you ever run into a disk-full situation, you
+        can free that space, and then Borg will be able to run normally so you can free more
+        disk space by using ``borg prune``/``borg delete``/``borg compact``. After that, do
+        not forget to reserve space again, in case you run into that situation again later.
 
         Examples::
 
             # Create a new repository:
             $ borg repo-create ...
-            # Reserve approx. 1GB of space for emergencies:
+            # Reserve approx. 1 GiB of space for emergencies:
             $ borg repo-space --reserve 1G
 
-            # Check amount of reserved space in the repository:
+            # Check the amount of reserved space in the repository:
             $ borg repo-space
 
             # EMERGENCY! Free all reserved space to get things back to normal:
@@ -84,7 +83,7 @@ def build_parser_repo_space(self, subparsers, common_parser, mid_common_parser):
             $ borg repo-space --reserve 1G  # reserve space again for next time
 
 
-        Reserved space is always rounded up to use full reservation blocks of 64MiB.
+        Reserved space is always rounded up to full reservation blocks of 64 MiB.
         """
         )
         subparser = subparsers.add_parser(
@@ -110,5 +109,5 @@ def build_parser_repo_space(self, subparsers, common_parser, mid_common_parser):
             "--free",
             dest="free_space",
             action="store_true",
-            help="Free all reserved space. Don't forget to reserve space later again.",
+            help="Free all reserved space. Do not forget to reserve space again later.",
         )
diff --git a/src/borg/archiver/serve_cmd.py b/src/borg/archiver/serve_cmd.py
index 5b2cb76a8d..f8c1700676 100644
--- a/src/borg/archiver/serve_cmd.py
+++ b/src/borg/archiver/serve_cmd.py
@@ -10,7 +10,7 @@
 
 class ServeMixIn:
     def do_serve(self, args):
-        """Start in server mode. This command is usually not used manually."""
+        """Starts in server mode. This command is usually not used manually."""
         RepositoryServer(
             restrict_to_paths=args.restrict_to_paths,
             restrict_to_repositories=args.restrict_to_repositories,
@@ -25,30 +25,30 @@ def build_parser_serve(self, subparsers, common_parser, mid_common_parser):
             """
         This command starts a repository server process.
 
-        borg serve can currently support:
+        `borg serve` currently supports:
 
-        - Getting automatically started via ssh when the borg client uses a ssh://...
-          remote repository. In this mode, `borg serve` will live until that ssh connection
-          gets terminated.
+        - Being automatically started via SSH when the borg client uses an ssh://...
+          remote repository. In this mode, `borg serve` will run until that SSH connection
+          is terminated.
 
-        - Getting started by some other means (not by the borg client) as a long-running socket
+        - Being started by some other means (not by the borg client) as a long-running socket
           server to be used for borg clients using a socket://... repository (see the `--socket`
-          option if you do not want to use the default path for the socket and pid file).
+          option if you do not want to use the default path for the socket and PID file).
 
-        Please note that `borg serve` does not support giving a specific repository via the
-        `--repo` option or `BORG_REPO` environment variable. It is always the borg client which
-        specifies the repo to use when talking to `borg serve`.
+        Please note that `borg serve` does not support providing a specific repository via the
+        `--repo` option or the `BORG_REPO` environment variable. It is always the borg client that
+        specifies the repository to use when communicating with `borg serve`.
 
-        The --permissions option allows enforcing repository permissions:
+        The --permissions option enforces repository permissions:
 
-        - `all`: All permissions are granted (default, permissions system is not used)
-        - `no-delete`: Allow reading and writing, disallow deleting and overwriting data.
-          New archives can be created, existing archives can not be deleted. New chunks can
-          be added, existing chunks can not be deleted or overwritten.
-        - `write-only`: Allow writing, disallow reading data.
-          New archives can be created, existing archives can not be read.
-          New chunks can be added, existing chunks can not be read, deleted or overwritten.
-        - `read-only`: Allow reading, disallow writing or deleting data.
+        - `all`: All permissions are granted. (Default; the permissions system is not used.)
+        - `no-delete`: Allow reading and writing; disallow deleting and overwriting data.
+          New archives can be created; existing archives cannot be deleted. New chunks can
+          be added; existing chunks cannot be deleted or overwritten.
+        - `write-only`: Allow writing; disallow reading data.
+          New archives can be created; existing archives cannot be read.
+          New chunks can be added; existing chunks cannot be read, deleted, or overwritten.
+        - `read-only`: Allow reading; disallow writing or deleting data.
           Existing archives can be read, but no archives can be created or deleted.
         """
         )
@@ -59,7 +59,7 @@ def build_parser_serve(self, subparsers, common_parser, mid_common_parser):
             description=self.do_serve.__doc__,
             epilog=serve_epilog,
             formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="start repository server process",
+            help="start the repository server process",
         )
         subparser.set_defaults(func=self.do_serve)
         subparser.add_argument(
@@ -67,20 +67,20 @@ def build_parser_serve(self, subparsers, common_parser, mid_common_parser):
             metavar="PATH",
             dest="restrict_to_paths",
             action="append",
-            help="restrict repository access to PATH. "
+            help="Restrict repository access to PATH. "
             "Can be specified multiple times to allow the client access to several directories. "
-            "Access to all sub-directories is granted implicitly; PATH doesn't need to point directly to a repository.",
+            "Access to all subdirectories is granted implicitly; PATH does not need to point directly to a repository.",
         )
         subparser.add_argument(
             "--restrict-to-repository",
             metavar="PATH",
             dest="restrict_to_repositories",
             action="append",
-            help="restrict repository access. Only the repository located at PATH "
-            "(no sub-directories are considered) is accessible. "
+            help="Restrict repository access. Only the repository located at PATH "
+            "(no subdirectories are considered) is accessible. "
             "Can be specified multiple times to allow the client access to several repositories. "
-            "Unlike ``--restrict-to-path`` sub-directories are not accessible; "
-            "PATH needs to point directly at a repository location. "
+            "Unlike ``--restrict-to-path``, subdirectories are not accessible; "
+            "PATH must point directly to a repository location. "
             "PATH may be an empty directory or the last element of PATH may not exist, in which case "
             "the client may initialize a repository there.",
         )
diff --git a/src/borg/archiver/tag_cmd.py b/src/borg/archiver/tag_cmd.py
index b3eabbc560..3dffbd8030 100644
--- a/src/borg/archiver/tag_cmd.py
+++ b/src/borg/archiver/tag_cmd.py
@@ -14,10 +14,10 @@
 class TagMixIn:
     @with_repository(cache=True, compatibility=(Manifest.Operation.WRITE,))
     def do_tag(self, args, repository, manifest, cache):
-        """Manage tags"""
+        """Manage tags."""
 
         def tags_set(tags):
-            """return a set of tags, removing empty tags"""
+            """Return a set of tags, removing empty tags."""
             return {tag for tag in tags if tag}
 
         if args.name:
@@ -29,7 +29,7 @@ def check_special(tags):
             if tags:
                 special = {tag for tag in tags_set(tags) if tag.startswith("@")}
                 if not special.issubset(SPECIAL_TAGS):
-                    raise Error("unknown special tags given.")
+                    raise Error("Unknown special tags given.")
 
         check_special(args.set_tags)
         check_special(args.add_tags)
@@ -70,13 +70,13 @@ def build_parser_tag(self, subparsers, common_parser, mid_common_parser):
             You can set the tags to a specific set of tags or you can add or remove
             tags from the current set of tags.
 
-            User defined tags must not start with `@` because such tags are considered
+            User-defined tags must not start with `@` because such tags are considered
             special and users are only allowed to use known special tags:
 
             ``@PROT``: protects archives against archive deletion or pruning.
 
-            Pre-existing special tags can not be removed via ``--set``. You can still use
-            ``--set``, but you must give pre-existing special tags also (so they won't be
+            Pre-existing special tags cannot be removed via ``--set``. You can still use
+            ``--set``, but you must also give pre-existing special tags (so they won't be
             removed).
             """
         )
diff --git a/src/borg/archiver/tar_cmds.py b/src/borg/archiver/tar_cmds.py
index 9371b99ee8..77b432c4c9 100644
--- a/src/borg/archiver/tar_cmds.py
+++ b/src/borg/archiver/tar_cmds.py
@@ -62,7 +62,7 @@ def do_export_tar(self, args, repository, manifest, archive):
 
         # A quick note about the general design of tar_filter and tarfile;
         # The tarfile module of Python can provide some compression mechanisms
-        # by itself, using the builtin gzip, bz2 and lzma modules (and "tarmodes"
+        # by itself, using the built-in gzip, bz2, and lzma modules (and "tar modes"
         # such as "w:xz").
         #
         # Doing so would have three major drawbacks:
@@ -250,9 +250,6 @@ def item_to_paxheaders(format, item):
         # This does not close the fileobj (tarstream) we passed to it -- a side effect of the | mode.
         tar.close()
 
-        for pattern in matcher.get_unmatched_include_patterns():
-            self.print_warning_instance(IncludePatternNeverMatchedWarning(pattern))
-
     @with_repository(cache=True, compatibility=(Manifest.Operation.WRITE,))
     def do_import_tar(self, args, repository, manifest, cache):
         """Create a backup archive from a tarball"""
@@ -360,7 +357,7 @@ def build_parser_tar(self, subparsers, common_parser, mid_common_parser):
         read the uncompressed tar stream from stdin and write a compressed/filtered
         tar stream to stdout.
 
-        Depending on the ``-tar-format`` option, these formats are created:
+        Depending on the ``--tar-format`` option, these formats are created:
 
         +--------------+---------------------------+----------------------------+
         | --tar-format | Specification             | Metadata                   |
diff --git a/src/borg/archiver/transfer_cmd.py b/src/borg/archiver/transfer_cmd.py
index 4ada0b8482..8ae6d3bd95 100644
--- a/src/borg/archiver/transfer_cmd.py
+++ b/src/borg/archiver/transfer_cmd.py
@@ -72,14 +72,14 @@ def transfer_chunks(
                     try:
                         cdata = other_repository.get(chunk_id)
                     except (Repository.ObjectNotFound, LegacyRepository.ObjectNotFound):
-                        # missing correct chunk in other_repository (source) will result in
+                        # A missing correct chunk in other_repository (source) will result in
                         # a missing chunk in repository (destination).
-                        # we do NOT want to transfer all-zero replacement chunks from borg1 repos.
+                        # We do NOT want to transfer all-zero replacement chunks from Borg 1 repositories.
                         pass
                     else:
                         if recompress == "never":
-                            # keep compressed payload same, verify via assert_id (that will
-                            # decompress, but avoid needing to compress it again):
+                            # Keep the compressed payload the same; verify via assert_id (that will
+                            # decompress, but avoids needing to compress it again):
                             meta, data = other_manifest.repo_objs.parse(
                                 chunk_id, cdata, decompress=True, want_compressed=True, ro_type=ROBJ_FILE_STREAM
                             )
@@ -182,18 +182,18 @@ def do_transfer(self, args, *, repository, manifest, cache, other_repository=Non
             id_hex, ts_str = bin_to_hex(id), ts.isoformat()
             transfer_size = 0
             present_size = 0
-            # at least for borg 1.x -> borg2 transfers, we can not use the id to check for
-            # already transferred archives (due to upgrade of metadata stream, id will be
-            # different anyway). so we use archive name and timestamp.
-            # the name alone might be sufficient for borg 1.x -> 2 transfers, but isn't
-            # for 2 -> 2 transfers, because borg2 allows duplicate names ("series" feature).
-            # so, best is to check for both name/ts and name/id.
+            # At least for Borg 1.x -> Borg 2 transfers, we cannot use the ID to check for
+            # already transferred archives (due to upgrade of the metadata stream, the ID will be
+            # different anyway). So we use the archive name and timestamp.
+            # The name alone might be sufficient for Borg 1.x -> 2 transfers, but it isn't
+            # for 2 -> 2 transfers, because Borg 2 allows duplicate names ("series" feature).
+            # So, the best is to check for both name/ts and name/id.
             if not dry_run and manifest.archives.exists_name_and_ts(name, archive_info.ts):
-                # useful for borg 1.x -> 2 transfers, we have unique names in borg 1.x.
-                # also useful for borg 2 -> 2 transfers with metadata changes (id changes).
+                # Useful for Borg 1.x -> 2 transfers; we have unique names in Borg 1.x.
+                # Also useful for Borg 2 -> 2 transfers with metadata changes (ID changes).
                 print(f"{name} {ts_str}: archive is already present in destination repo, skipping.")
             elif not dry_run and manifest.archives.exists_name_and_id(name, id):
-                # useful for borg 2 -> 2 transfers without changes (id stays the same)
+                # Useful for Borg 2 -> 2 transfers without changes (ID stays the same)
                 print(f"{name} {id_hex}: archive is already present in destination repo, skipping.")
             else:
                 if not dry_run:
@@ -206,11 +206,11 @@ def do_transfer(self, args, *, repository, manifest, cache, other_repository=Non
                 for item in other_archive.iter_items():
                     is_part = bool(item.get("part", False))
                     if is_part:
-                        # borg 1.x created part files while checkpointing (in addition to the full
+                        # Borg 1.x created part files while checkpointing (in addition to the full
                         # file in the final archive), like <filename>.borg_part_<part> with item.part >= 1.
-                        # borg2 archives do not have such special part items anymore.
-                        # so let's remove them from old archives also, considering there is no
-                        # code any more that deals with them in special ways (e.g. to get stats right).
+                        # Borg 2 archives do not have such special part items anymore.
+                        # So let's remove them from old archives also, considering there is no
+                        # code anymore that deals with them in special ways (e.g., to get stats right).
                         continue
                     if "chunks_healthy" in item:  # legacy
                         other_chunks = item.chunks_healthy  # chunks_healthy has the CORRECT chunks list, if present.
diff --git a/src/borg/archiver/undelete_cmd.py b/src/borg/archiver/undelete_cmd.py
index a4008cdeb1..a0455518f2 100644
--- a/src/borg/archiver/undelete_cmd.py
+++ b/src/borg/archiver/undelete_cmd.py
@@ -14,7 +14,7 @@
 class UnDeleteMixIn:
     @with_repository(manifest=False)
     def do_undelete(self, args, repository):
-        """Undelete archives"""
+        """Undeletes archives."""
         self.output_list = args.output_list
         dry_run = args.dry_run
         manifest = Manifest.load(repository, (Manifest.Operation.DELETE,))
@@ -61,14 +61,15 @@ def build_parser_undelete(self, subparsers, common_parser, mid_common_parser):
 
         Important: Undeleting archives is only possible before compacting.
         Once ``borg compact`` has run, all disk space occupied only by the
-        soft-deleted archives will be freed and undelete is not possible
-        anymore.
+        soft-deleted archives will be freed, and undeleting is no longer
+        possible.
 
-        When in doubt, use ``--dry-run --list`` to see what would be undeleted.
+        When in doubt, use ``--dry-run --list`` to see what would be
+        undeleted.
 
-        You can undelete multiple archives by specifying a matching pattern,
-        using the ``--match-archives PATTERN`` option (for more info on these patterns,
-        see :ref:`borg_patterns`).
+        You can undelete multiple archives by specifying a match pattern using
+        the ``--match-archives PATTERN`` option (for more information on these
+        patterns, see :ref:`borg_patterns`).
         """
         )
         subparser = subparsers.add_parser(
@@ -78,12 +79,14 @@ def build_parser_undelete(self, subparsers, common_parser, mid_common_parser):
             description=self.do_undelete.__doc__,
             epilog=undelete_epilog,
             formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="undelete archive",
+            help="undelete archives",
         )
         subparser.set_defaults(func=self.do_undelete)
-        subparser.add_argument("-n", "--dry-run", dest="dry_run", action="store_true", help="do not change repository")
         subparser.add_argument(
-            "--list", dest="output_list", action="store_true", help="output verbose list of archives"
+            "-n", "--dry-run", dest="dry_run", action="store_true", help="do not change the repository"
+        )
+        subparser.add_argument(
+            "--list", dest="output_list", action="store_true", help="output a verbose list of archives"
         )
         define_archive_filters_group(subparser)
         subparser.add_argument(
diff --git a/src/borg/archiver/version_cmd.py b/src/borg/archiver/version_cmd.py
index 75593cbfb4..36c52a9975 100644
--- a/src/borg/archiver/version_cmd.py
+++ b/src/borg/archiver/version_cmd.py
@@ -11,7 +11,7 @@
 
 class VersionMixIn:
     def do_version(self, args):
-        """Display the borg client / borg server version"""
+        """Displays the Borg client and server versions."""
         from borg.version import parse_version, format_version
 
         client_version = parse_version(__version__)
@@ -27,28 +27,28 @@ def build_parser_version(self, subparsers, common_parser, mid_common_parser):
 
         version_epilog = process_epilog(
             """
-        This command displays the borg client version / borg server version.
+        This command displays the Borg client and server versions.
 
-        If a local repo is given, the client code directly accesses the repository,
-        thus we show the client version also as the server version.
+        If a local repository is given, the client code directly accesses the repository,
+        so the client version is also shown as the server version.
 
-        If a remote repo is given (e.g. ssh:), the remote borg is queried and
+        If a remote repository is given (e.g., ssh:), the remote Borg is queried, and
         its version is displayed as the server version.
 
         Examples::
 
-            # local repo (client uses 1.4.0 alpha version)
+            # local repository (client uses 1.4.0 alpha version)
             $ borg version /mnt/backup
             1.4.0a / 1.4.0a
 
-            # remote repo (client uses 1.4.0 alpha, server uses 1.2.7 release)
+            # remote repository (client uses 1.4.0 alpha, server uses 1.2.7 release)
             $ borg version ssh://borg@borgbackup:repo
             1.4.0a / 1.2.7
 
-        Due to the version tuple format used in borg client/server negotiation, only
+        Due to the version tuple format used in Borg client/server negotiation, only
         a simplified version is displayed (as provided by borg.version.format_version).
 
-        There is also borg --version to display a potentially more precise client version.
+        You can also use ``borg --version`` to display a potentially more precise client version.
         """
         )
         subparser = subparsers.add_parser(
@@ -58,6 +58,6 @@ def build_parser_version(self, subparsers, common_parser, mid_common_parser):
             description=self.do_version.__doc__,
             epilog=version_epilog,
             formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="display borg client version / borg server version",
+            help="display the Borg client and server versions",
         )
         subparser.set_defaults(func=self.do_version)
diff --git a/src/borg/cache.py b/src/borg/cache.py
index 904a7e8817..777c5514b8 100644
--- a/src/borg/cache.py
+++ b/src/borg/cache.py
@@ -74,21 +74,21 @@ def discover_files_cache_names(path, files_cache_name="files"):
 class SecurityManager:
     """
     Tracks repositories. Ensures that nothing bad happens (repository swaps,
-    replay attacks, unknown repositories etc.).
+    replay attacks, unknown repositories, etc.).
 
-    This is complicated by the Cache being initially used for this, while
-    only some commands actually use the Cache, which meant that other commands
+    This is complicated by the cache being initially used for this, while
+    only some commands actually use the cache, which meant that other commands
     did not perform these checks.
 
-    Further complications were created by the Cache being a cache, so it
-    could be legitimately deleted, which is annoying because Borg didn't
+    Further complications were created by the cache being a cache, so it
+    could be legitimately deleted, which is annoying because Borg did not
     recognize repositories after that.
 
-    Therefore a second location, the security database (see get_security_dir),
-    was introduced which stores this information. However, this means that
-    the code has to deal with a cache existing but no security DB entry,
-    or inconsistencies between the security DB and the cache which have to
-    be reconciled, and also with no cache existing but a security DB entry.
+    Therefore, a second location, the security database (see get_security_dir),
+    was introduced, which stores this information. However, this means that
+    the code has to deal with a cache existing but no security database entry,
+    or inconsistencies between the security database and the cache which have to
+    be reconciled, and also with no cache existing but a security database entry.
     """
 
     def __init__(self, repository):
@@ -100,7 +100,7 @@ def __init__(self, repository):
 
     @staticmethod
     def destroy(repository, path=None):
-        """destroy the security dir for ``repository`` or at ``path``"""
+        """Destroys the security directory for ``repository`` or at ``path``."""
         path = path or get_security_dir(repository.id_str, legacy=(repository.version == 1))
         if Path(path).exists():
             shutil.rmtree(path)
diff --git a/src/borg/checksums.pyx b/src/borg/checksums.pyx
index 32a21770b5..9d938c61e1 100644
--- a/src/borg/checksums.pyx
+++ b/src/borg/checksums.pyx
@@ -39,8 +39,8 @@ cdef Py_buffer ro_buffer(object data) except *:
     return view
 
 
-# borg 2.0's new repos do not compute crc32 over big amounts of data,
-# so speed does not matter much any more and we can just use zlib.crc32.
+# Borg 2.0 repositories do not compute CRC32 over large amounts of data,
+# so speed does not matter much anymore, and we can just use zlib.crc32.
 crc32 = zlib.crc32
 
 
diff --git a/src/borg/chunkers/__init__.py b/src/borg/chunkers/__init__.py
index 5712c2ee84..5e3094d034 100644
--- a/src/borg/chunkers/__init__.py
+++ b/src/borg/chunkers/__init__.py
@@ -10,7 +10,7 @@
 def get_chunker(algo, *params, **kw):
     key = kw.get("key", None)
     sparse = kw.get("sparse", False)
-    # key.chunk_seed only has 32bits
+    # key.chunk_seed only has 32 bits
     seed = key.chunk_seed if key is not None else 0
     # for buzhash64, we want a much longer key, so we derive it from the id key
     bh64_key = (
diff --git a/src/borg/chunkers/failing.py b/src/borg/chunkers/failing.py
index 623182c201..49b9966af4 100644
--- a/src/borg/chunkers/failing.py
+++ b/src/borg/chunkers/failing.py
@@ -18,7 +18,7 @@ class ChunkerFailing:
     def __init__(self, block_size: int, map: str) -> None:
         self.block_size = block_size
         # one char per block: r/R = successful read, e/E = I/O Error, e.g.: "rrrrErrrEEr"
-        # blocks beyond the map will have same behaviour as the last map char indicates.
+        # blocks beyond the map will have the same behavior as the last map char indicates.
         map = map.upper()
         if not set(map).issubset({"R", "E"}):
             raise ValueError("unsupported map character")
@@ -41,12 +41,12 @@ def chunkify(self, fd: BinaryIO = None, fh: int = -1) -> Iterator:
             got = len(data)
             if got > 0:
                 idx = self.count if self.count < len(self.map) else -1
-                behaviour = self.map[idx]
-                if behaviour == "E":
+                behavior = self.map[idx]
+                if behavior == "E":
                     self.count += 1
                     fname = None if use_fh else getattr(fd, "name", None)
                     raise OSError(errno.EIO, "simulated I/O error", fname)
-                elif behaviour == "R":
+                elif behavior == "R":
                     self.count += 1
                     yield Chunk(data, size=got, allocation=CH_DATA)
                 else:
diff --git a/src/borg/chunkers/fixed.py b/src/borg/chunkers/fixed.py
index c8d8586e5c..03096e45c4 100644
--- a/src/borg/chunkers/fixed.py
+++ b/src/borg/chunkers/fixed.py
@@ -9,8 +9,8 @@
 
 class ChunkerFixed:
     """
-    This is a simple chunker for input data with data usually staying at same
-    offset and / or with known block/record sizes:
+    This is a simple chunker for input data with data usually staying at the same
+    offset and/or with known block/record sizes:
 
     - raw disk images
     - block devices
diff --git a/src/borg/chunkers/reader.pyx b/src/borg/chunkers/reader.pyx
index 9bd4e81e9f..26258914b9 100644
--- a/src/borg/chunkers/reader.pyx
+++ b/src/borg/chunkers/reader.pyx
@@ -68,14 +68,13 @@ def dpos_curr_end(fd=None, fh=-1):
 
 def sparsemap(fd=None, fh=-1):
     """
-    generator yielding a (start, length, is_data) tuple for each range.
-    is_data is indicating data ranges (True) or hole ranges (False).
-
-    note:
-    the map is generated starting from the current seek position (it
-    is not required to be 0 / to be at the start of the file) and
-    work from there up to the end of the file.
-    when the generator is finished, the file pointer position will be
+    Generator yielding (start, length, is_data) tuples for each range.
+    is_data indicates data ranges (True) or hole ranges (False).
+
+    Note:
+    The map is generated starting from the current seek position (it
+    is not required to be 0, i.e., the start of the file) and works from there up to the end of the file.
+    When the generator is finished, the file pointer position will be
     reset to where it was before calling this function.
     """
     curr, file_len = dpos_curr_end(fd, fh)
@@ -188,7 +187,7 @@ class FileFMAPReader:
                     range_size -= got
                     yield Chunk(data, size=got, allocation=allocation)
                 if got < wanted:
-                    # we did not get enough data, looks like EOF.
+                    # We did not get enough data; looks like EOF.
                     return
 
 
diff --git a/src/borg/compress.pyx b/src/borg/compress.pyx
index c0f93c2daf..d7c4f5f36f 100644
--- a/src/borg/compress.pyx
+++ b/src/borg/compress.pyx
@@ -55,7 +55,7 @@ cdef class CompressorBase:
     """
     base class for all (de)compression classes,
     also handles compression format auto detection and
-    adding/stripping the ID header (which enable auto detection).
+    adding/stripping the ID header (which enables auto-detection).
     """
     ID = 0xFF  # reserved and not used
                # overwrite with a unique 1-byte bytestring in child classes
diff --git a/src/borg/constants.py b/src/borg/constants.py
index 31d810628f..092ca771f9 100644
--- a/src/borg/constants.py
+++ b/src/borg/constants.py
@@ -48,38 +48,38 @@
 MAX_DATA_SIZE = 20971479
 
 # MAX_OBJECT_SIZE = MAX_DATA_SIZE + len(PUT2 header)
-# note: for borg >= 1.3, this makes the MAX_OBJECT_SIZE grow slightly over the precise 20MiB used by
+# note: for borg >= 1.3, this makes the MAX_OBJECT_SIZE grow slightly over the precise 20 MiB used by
 # borg < 1.3, but this is not expected to cause any issues.
 MAX_OBJECT_SIZE = MAX_DATA_SIZE + 41 + 8  # see assertion at end of repository module
 
-# How many segment files borg puts into a single directory by default.
+# How many segment files Borg puts into a single directory by default.
 DEFAULT_SEGMENTS_PER_DIR = 1000
 
-# A large, but not unreasonably large segment size. Always less than 2 GiB (for legacy file systems). We choose
-# 500 MiB which means that no indirection from the inode is needed for typical Linux file systems.
-# Note that this is a soft-limit and can be exceeded (worst case) by a full maximum chunk size and some metadata
+# A large, but not unreasonably large segment size. Always less than 2 GiB (for legacy filesystems). We choose
+# 500 MiB, which means that no indirection from the inode is needed for typical Linux filesystems.
+# Note that this is a soft limit and can be exceeded (worst case) by a full maximum chunk size and some metadata
 # bytes. That's why it's 500 MiB instead of 512 MiB.
 DEFAULT_MAX_SEGMENT_SIZE = 500 * 1024 * 1024
 
 # repo config max_segment_size value must be below this limit to stay within uint32 offsets:
 MAX_SEGMENT_SIZE_LIMIT = 2**32 - MAX_OBJECT_SIZE
 
-# how many metadata stream chunk ids do we store into a "pointer chunk" of the ArchiveItem.item_ptrs list?
+# How many metadata stream chunk IDs do we store in a "pointer chunk" of the ArchiveItem.item_ptrs list?
 IDS_PER_CHUNK = MAX_DATA_SIZE // 40
 
 # have one all-zero bytes object
-# we use it at all places where we need to detect or create all-zero buffers
+# we use it in all places where we need to detect or create all-zero buffers
 zeros = bytes(MAX_DATA_SIZE)
 
 # borg.remote read() buffer size
 BUFSIZE = 10 * 1024 * 1024
 
-# to use a safe, limited unpacker, we need to set a upper limit to the archive count in the manifest.
+# To use a safe, limited unpacker, we need to set an upper limit to the archive count in the manifest.
 # this does not mean that you can always really reach that number, because it also needs to be less than
 # MAX_DATA_SIZE or it will trigger the check for that.
 MAX_ARCHIVES = 400000
 
-# repo.list() result count limit the borg client uses
+# repo.list() result count limit used by the Borg client
 LIST_SCAN_LIMIT = 100000
 
 FD_MAX_AGE = 4 * 60  # 4 minutes
@@ -97,10 +97,10 @@
 CH_FAIL = "fail"
 
 # buzhash chunker params
-CHUNK_MIN_EXP = 19  # 2**19 == 512kiB
-CHUNK_MAX_EXP = 23  # 2**23 == 8MiB
-HASH_WINDOW_SIZE = 0xFFF  # 4095B
-HASH_MASK_BITS = 21  # results in ~2MiB chunks statistically
+CHUNK_MIN_EXP = 19  # 2**19 == 512 KiB
+CHUNK_MAX_EXP = 23  # 2**23 == 8 MiB
+HASH_WINDOW_SIZE = 0xFFF  # 4095 B
+HASH_MASK_BITS = 21  # results in ~2 MiB chunks statistically
 
 # defaults, use --chunker-params to override
 CHUNKER_PARAMS = (CH_BUZHASH, CHUNK_MIN_EXP, CHUNK_MAX_EXP, HASH_MASK_BITS, HASH_WINDOW_SIZE)
@@ -129,10 +129,10 @@
 SCHILY_ACL_DEFAULT = "SCHILY.acl.default"  # POSIX default ACL in tar PAX headers
 
 # special tags
-# @PROT protects archives against accidential deletion or modification by delete, prune or recreate.
+# @PROT protects archives against accidental deletion or modification by delete, prune, or recreate.
 SPECIAL_TAGS = frozenset(["@PROT"])
 
-# return codes returned by borg command
+# return codes returned by Borg command
 EXIT_SUCCESS = 0  # everything done, no problems
 EXIT_WARNING = 1  # reached normal end of operation, but there were issues (generic warning)
 EXIT_ERROR = 2  # terminated abruptly, did not reach end of operation (generic error)
diff --git a/src/borg/crypto/file_integrity.py b/src/borg/crypto/file_integrity.py
index b3295c0671..fbce69b5f9 100644
--- a/src/borg/crypto/file_integrity.py
+++ b/src/borg/crypto/file_integrity.py
@@ -47,9 +47,9 @@ class FileHashingWrapper(FileLikeWrapper):
     Wrapper for file-like objects that computes a hash on-the-fly while reading/writing.
 
     WARNING: Seeks should only be used to query the size of the file, not
-    to skip data, because skipped data isn't read and not hashed into the digest.
+    to skip data, because skipped data is not read and not hashed into the digest.
 
-    Similarly skipping while writing to create sparse files is also not supported.
+    Similarly, skipping while writing to create sparse files is not supported.
 
     Data has to be read/written in a symmetric fashion, otherwise different
     digests will be generated.
@@ -89,9 +89,9 @@ def read(self, n=None):
 
     def hexdigest(self):
         """
-        Return current digest bytes as hex-string.
+        Return current digest bytes as a hex string.
 
-        Note: this can be called multiple times.
+        Note: This can be called multiple times.
         """
         return self.hash.hexdigest()
 
diff --git a/src/borg/crypto/key.py b/src/borg/crypto/key.py
index 08cb284c22..1b8e000447 100644
--- a/src/borg/crypto/key.py
+++ b/src/borg/crypto/key.py
@@ -73,7 +73,7 @@ class RepoKeyNotFoundError(Error):
 
 
 class UnsupportedKeyFormatError(Error):
-    """Your borg key is stored in an unsupported format. Try using a newer version of borg."""
+    """Your Borg key is stored in an unsupported format. Try using a newer version of Borg."""
 
     exit_mcode = 49
 
diff --git a/src/borg/crypto/keymanager.py b/src/borg/crypto/keymanager.py
index 60bc5bc9da..2559a7ca87 100644
--- a/src/borg/crypto/keymanager.py
+++ b/src/borg/crypto/keymanager.py
@@ -11,7 +11,7 @@
 
 
 class NotABorgKeyFile(Error):
-    """This file is not a borg key backup, aborting."""
+    """This file is not a Borg key backup, aborting."""
 
     exit_mcode = 43
 
diff --git a/src/borg/crypto/low_level.pyx b/src/borg/crypto/low_level.pyx
index 4fd7f2f498..f723cde52b 100644
--- a/src/borg/crypto/low_level.pyx
+++ b/src/borg/crypto/low_level.pyx
@@ -1,4 +1,4 @@
-"""An AEAD style OpenSSL wrapper
+"""An AEAD-style OpenSSL wrapper
 
 API:
 
@@ -15,11 +15,11 @@ Envelope layout:
 |------------- #header_len ------>|
 
 S means a cryptographic signature function (like HMAC or GMAC).
-E means a encryption function (like AES).
+E means an encryption function (like AES).
 iv is the initialization vector / nonce, if needed.
 
-The split of header into not authenticated data and aad (additional authenticated
-data) is done to support the legacy envelope layout as used in attic and early borg
+The split of header into not-authenticated data and AAD (additional authenticated
+data) is done to support the legacy envelope layout as used in Attic and early Borg
 (where the TYPE byte was not authenticated) and avoid unneeded memcpy and string
 garbage.
 
diff --git a/src/borg/fslocking.py b/src/borg/fslocking.py
index 701b0e2bd5..104ab2a4ee 100644
--- a/src/borg/fslocking.py
+++ b/src/borg/fslocking.py
@@ -17,7 +17,7 @@
 
 class TimeoutTimer:
     """
-    A timer for timeout checks (can also deal with "never timeout").
+    A timer for timeout checks (can also deal with "never time out").
     It can also compute and optionally execute a reasonable sleep time (e.g. to avoid
     polling too often or to support thread/process rescheduling).
     """
@@ -26,7 +26,7 @@ def __init__(self, timeout=None, sleep=None):
         """
         Initialize a timer.
 
-        :param timeout: time out interval [s] or None (never timeout, wait forever) [default]
+        :param timeout: timeout interval [s] or None (never time out, wait forever) [default]
         :param sleep: sleep interval [s] (>= 0: do sleep call, <0: don't call sleep)
                       or None (autocompute: use 10% of timeout [but not more than 60s],
                       or 1s for "never timeout" mode)
@@ -106,9 +106,9 @@ class NotMyLock(LockErrorT):
 
 
 class ExclusiveLock:
-    """An exclusive Lock based on mkdir fs operation being atomic.
+    """An exclusive lock based on mkdir filesystem operation being atomic.
 
-    If possible, try to use the contextmanager here like::
+    If possible, try to use the context manager here like::
 
         with ExclusiveLock(...) as lock:
             ...
diff --git a/src/borg/fuse.py b/src/borg/fuse.py
index f3fc0cef78..811d85defa 100644
--- a/src/borg/fuse.py
+++ b/src/borg/fuse.py
@@ -73,9 +73,9 @@ def fuse_main():
 
 class ItemCache:
     """
-    This is the "meat" of the file system's metadata storage.
+    This is the "meat" of the filesystem's metadata storage.
 
-    This class generates inode numbers that efficiently index items in archives,
+    This class generates inode numbers that efficiently index items in archives
     and retrieves items from these inode numbers.
     """
 
diff --git a/src/borg/fuse_impl.py b/src/borg/fuse_impl.py
index bf8bda6c28..9f525f82ad 100644
--- a/src/borg/fuse_impl.py
+++ b/src/borg/fuse_impl.py
@@ -1,5 +1,5 @@
 """
-load library for lowlevel FUSE implementation
+Loads the library for the low-level FUSE implementation.
 """
 
 import os
@@ -29,7 +29,7 @@
     elif FUSE_IMPL == "none":
         pass
     else:
-        raise RuntimeError("unknown fuse implementation in BORG_FUSE_IMPL: '%s'" % BORG_FUSE_IMPL)
+        raise RuntimeError("Unknown FUSE implementation in BORG_FUSE_IMPL: '%s'." % BORG_FUSE_IMPL)
 else:
     llfuse = None  # noqa
     has_llfuse = False
diff --git a/src/borg/hashindex.pyx b/src/borg/hashindex.pyx
index 511a395b13..b2c466e157 100644
--- a/src/borg/hashindex.pyx
+++ b/src/borg/hashindex.pyx
@@ -67,7 +67,7 @@ class ChunkIndex(HTProxyMixin, MutableMapping):
         return value._replace(flags=user_flags)
 
     def iteritems(self, *, only_new=False):
-        """iterate items (optionally only new items), hide system flags."""
+        """Iterates items (optionally only new items); hides system flags."""
         for key, value in self.ht.items():
             if not only_new or (value.flags & self.F_NEW):
                 yield key, self.hide_system_flags(value)
@@ -82,12 +82,12 @@ class ChunkIndex(HTProxyMixin, MutableMapping):
         self[key] = ChunkIndexEntry(flags=flags, size=size)
 
     def __getitem__(self, key):
-        """specialized __getitem__ that hides system flags."""
+        """Specialized __getitem__ that hides system flags."""
         value = self.ht[key]
         return self.hide_system_flags(value)
 
     def __setitem__(self, key, value):
-        """specialized __setitem__ that protects system flags, manages F_NEW flag."""
+        """Specialized __setitem__ that protects system flags and manages the F_NEW flag."""
         try:
             prev = self.ht[key]
         except KeyError:
@@ -105,7 +105,7 @@ class ChunkIndex(HTProxyMixin, MutableMapping):
         self.ht[key] = value._replace(flags=system_flags | user_flags)
 
     def clear_new(self):
-        """clear F_NEW flag of all items"""
+        """Clears the F_NEW flag of all items."""
         for key, value in self.ht.items():
             if value.flags & self.F_NEW:
                 flags = value.flags & ~self.F_NEW
@@ -152,7 +152,7 @@ NSIndex1EntryFormat = NSIndex1EntryFormatT(segment="I", offset="I")
 
 class NSIndex1(HTProxyMixin, MutableMapping):
     """
-    Mapping from key256 to (segment32, offset32), as used by legacy repo index of borg 1.x.
+    Mapping from key256 to (segment32, offset32), as used by the legacy repository index of Borg 1.x.
     """
     MAX_VALUE = 2**32 - 1  # borghash has the full uint32_t range
     MAGIC = b"BORG_IDX"  # borg 1.x
@@ -217,21 +217,21 @@ class NSIndex1(HTProxyMixin, MutableMapping):
         header_size = struct.calcsize(self.HEADER_FMT)
         header_bytes = fd.read(header_size)
         if len(header_bytes) < header_size:
-            raise ValueError(f"Invalid file, file is too short (header).")
+            raise ValueError(f"Invalid file: file is too short (header).")
         # verify the header as a separate integrity-hash part if supported
         hash_part = getattr(fd, "hash_part", None)
         if hash_part:
             hash_part("HashHeader")
         magic, entries, buckets, ksize, vsize = struct.unpack(self.HEADER_FMT, header_bytes)
         if magic != self.MAGIC:
-            raise ValueError(f"Invalid file, magic {self.MAGIC.decode()} not found.")
+            raise ValueError(f"Invalid file: magic {self.MAGIC.decode()} not found.")
         assert ksize == self.KEY_SIZE, "invalid key size"
         assert vsize == self.VALUE_SIZE, "invalid value size"
         buckets_size = buckets * (ksize + vsize)
         current_pos = fd.tell()
         end_of_file = fd.seek(0, os.SEEK_END)
         if current_pos + buckets_size != end_of_file:
-            raise ValueError(f"Invalid file, file size does not match (buckets).")
+            raise ValueError(f"Invalid file: file size does not match (buckets).")
         fd.seek(current_pos)
         for i in range(buckets):
             key = fd.read(ksize)
diff --git a/src/borg/helpers/__init__.py b/src/borg/helpers/__init__.py
index 6473f7dc69..cbd73e8de3 100644
--- a/src/borg/helpers/__init__.py
+++ b/src/borg/helpers/__init__.py
@@ -1,9 +1,8 @@
 """
-This package contains all sorts of small helper / utility functionality,
-that did not fit better elsewhere.
+This package contains helper and utility functionality that did not fit elsewhere.
 
-Code used to be in borg/helpers.py but was split into the modules in this
-package, which are imported into here for compatibility.
+Code used to be in borg/helpers.py but was split into modules in this
+package, which are imported here for compatibility.
 """
 
 import os
@@ -65,7 +64,7 @@
 warning_info = namedtuple("warning_info", "wc,msg,args,wt")
 
 """
-The global warnings_list variable is used to collect warning_info elements while borg is running.
+The global warnings_list variable is used to collect warning_info elements while Borg is running.
 """
 _warnings_list: list[warning_info] = []
 
@@ -80,8 +79,8 @@ def add_warning(msg, *args, **kwargs):
 
 
 """
-The global exit_code variable is used so that modules other than archiver can increase the program exit code if a
-warning or error occurred during their operation.
+The global exit_code variable allows modules other than archiver to increase the program's exit code if a
+warning or error occurs during their operation.
 """
 _exit_code = EXIT_SUCCESS
 
@@ -102,7 +101,7 @@ def classify_ec(ec):
 
 
 def max_ec(ec1, ec2):
-    """return the more severe error code of ec1 and ec2"""
+    """Return the more severe error code of ec1 and ec2."""
     # note: usually, there can be only 1 error-class ec, the other ec is then either success or warning.
     ec1_class = classify_ec(ec1)
     ec2_class = classify_ec(ec2)
@@ -124,7 +123,7 @@ def max_ec(ec1, ec2):
 
 def set_ec(ec):
     """
-    Sets the exit code of the program to ec IF ec is more severe than the current exit code.
+    Set the exit code of the program to ec if ec is more severe than the current exit code.
     """
     global _exit_code
     _exit_code = max_ec(_exit_code, ec)
@@ -132,7 +131,7 @@ def set_ec(ec):
 
 def init_ec_warnings(ec=EXIT_SUCCESS, warnings=None):
     """
-    (Re-)Init the globals for the exit code and the warnings list.
+    (Re-)initialize the globals for the exit code and the warnings list.
     """
     global _exit_code, _warnings_list
     _exit_code = ec
@@ -143,7 +142,7 @@ def init_ec_warnings(ec=EXIT_SUCCESS, warnings=None):
 
 def get_ec(ec=None):
     """
-    compute the final return code of the borg process
+    Compute the final return code of the Borg process.
     """
     if ec is not None:
         set_ec(ec)
@@ -169,7 +168,7 @@ def get_ec(ec=None):
 
 
 def get_reset_ec(ec=None):
-    """Like get_ec, but re-initialize ec/warnings afterwards."""
+    """Like get_ec, but reinitialize ec/warnings afterwards."""
     rc = get_ec(ec)
     init_ec_warnings()
     return rc
diff --git a/src/borg/helpers/checks.py b/src/borg/helpers/checks.py
index 7c235371fa..b11f2230cf 100644
--- a/src/borg/helpers/checks.py
+++ b/src/borg/helpers/checks.py
@@ -10,7 +10,7 @@ def check_python():
     else:
         required_funcs = {os.stat, os.utime, os.chown}
     if not os.supports_follow_symlinks.issuperset(required_funcs):
-        raise RTError("""FATAL: this Python was compiled for a too old (g)libc and misses required functionality.""")
+        raise RTError("""FATAL: This Python was compiled for a too old (g)libc and lacks required functionality.""")
 
 
 def check_extension_modules():
diff --git a/src/borg/helpers/datastruct.py b/src/borg/helpers/datastruct.py
index f647beb14d..44983f1dab 100644
--- a/src/borg/helpers/datastruct.py
+++ b/src/borg/helpers/datastruct.py
@@ -2,7 +2,7 @@
 
 
 class StableDict(dict):
-    """A dict subclass with stable items() ordering"""
+    """A dict subclass with stable items() ordering."""
 
     def items(self):
         return sorted(super().items())
@@ -18,8 +18,8 @@ class MemoryLimitExceeded(Error, OSError):
 
     def __init__(self, allocator, size=4096, limit=None):
         """
-        Initialize the buffer: use allocator(size) call to allocate a buffer.
-        Optionally, set the upper <limit> for the buffer size.
+        Initialize the buffer by using allocator(size) to allocate a buffer.
+        Optionally, set an upper limit for the buffer size.
         """
         assert callable(allocator), "must give alloc(size) function as first param"
         assert limit is None or size <= limit, "initial size must be <= limit"
@@ -32,9 +32,9 @@ def __len__(self):
 
     def resize(self, size, init=False):
         """
-        resize the buffer - to avoid frequent reallocation, we usually always grow (if needed).
-        giving init=True it is possible to first-time initialize or shrink the buffer.
-        if a buffer size beyond the limit is requested, raise Buffer.MemoryLimitExceeded (OSError).
+        Resize the buffer. To avoid frequent reallocation, we usually grow (if needed).
+        By giving init=True it is possible to initialize for the first time or shrink the buffer.
+        If a buffer size beyond the limit is requested, raise Buffer.MemoryLimitExceeded (OSError).
         """
         size = int(size)
         if self.limit is not None and size > self.limit:
@@ -44,7 +44,7 @@ def resize(self, size, init=False):
 
     def get(self, size=None, init=False):
         """
-        return a buffer of at least the requested size (None: any current size).
+        Return a buffer of at least the requested size (None: any current size).
         init=True can be given to trigger shrinking of the buffer to the given size.
         """
         if size is not None:
@@ -58,13 +58,13 @@ class EfficientCollectionQueue:
     """
 
     class SizeUnderflow(Error):
-        """Could not pop_front first {} elements, collection only has {} elements.."""
+        """Could not pop the first {} elements; collection only has {} elements."""
 
     def __init__(self, split_size, member_type):
         """
-        Initializes empty queue.
-        Requires split_size to define maximum chunk size.
-        Requires member_type to be type defining what base collection looks like.
+        Initialize an empty queue.
+        split_size defines the maximum chunk size.
+        member_type is the type that defines what the base collection looks like.
         """
         self.buffers = []
         self.size = 0
@@ -73,9 +73,9 @@ def __init__(self, split_size, member_type):
 
     def peek_front(self):
         """
-        Returns first chunk from queue without removing it.
-        Returned collection will have between 1 and split_size length.
-        Returns empty collection when nothing is queued.
+        Return the first chunk from the queue without removing it.
+        The returned collection will have between 1 and split_size elements.
+        Returns an empty collection when nothing is queued.
         """
         if not self.buffers:
             return self.member_type()
@@ -84,8 +84,8 @@ def peek_front(self):
 
     def pop_front(self, size):
         """
-        Removes first size elements from queue.
-        Throws if requested removal size is larger than whole queue.
+        Remove the first `size` elements from the queue.
+        Raises an error if the requested removal size is larger than the entire queue.
         """
         if size > self.size:
             raise EfficientCollectionQueue.SizeUnderflow(size, self.size)
@@ -102,8 +102,8 @@ def pop_front(self, size):
 
     def push_back(self, data):
         """
-        Adds data at end of queue.
-        Takes care to chunk data into split_size sized elements.
+        Add data at the end of the queue.
+        Chunks data into elements of size up to split_size.
         """
         if not self.buffers:
             self.buffers = [self.member_type()]
@@ -121,12 +121,12 @@ def push_back(self, data):
 
     def __len__(self):
         """
-        Current queue length for all elements in all chunks.
+        Return the current queue length for all elements across all chunks.
         """
         return self.size
 
     def __bool__(self):
         """
-        Returns true if queue isn't empty.
+        Return True if the queue is not empty.
         """
         return self.size != 0
diff --git a/src/borg/helpers/errors.py b/src/borg/helpers/errors.py
index e24694bd34..71f2022e24 100644
--- a/src/borg/helpers/errors.py
+++ b/src/borg/helpers/errors.py
@@ -67,11 +67,11 @@ class CancelledByUser(Error):
 
 
 class RTError(Error):
-    """Runtime Error: {}"""
+    """Runtime error: {}"""
 
 
 class CommandError(Error):
-    """Command Error: {}"""
+    """Command error: {}"""
 
     exit_mcode = 4
 
@@ -101,7 +101,7 @@ def exit_code(self):
 
 
 class FileChangedWarning(BorgWarning):
-    """{}: file changed while we backed it up"""
+    """{}: file changed while we backed it up."""
 
     exit_mcode = 100
 
@@ -185,4 +185,4 @@ class BackupFileNotFoundError(BackupOSError):
 
 
 class BackupItemExcluded(Exception):
-    """used internally to skip an item from processing, when it is excluded."""
+    """Used internally to skip an item from processing when it is excluded."""
diff --git a/src/borg/helpers/fs.py b/src/borg/helpers/fs.py
index b9fbdfcee7..bbee196040 100644
--- a/src/borg/helpers/fs.py
+++ b/src/borg/helpers/fs.py
@@ -25,14 +25,16 @@
 
 def ensure_dir(path, mode=stat.S_IRWXU | stat.S_IRWXG | stat.S_IRWXO, pretty_deadly=True):
     """
-    Ensures that the dir exists with the right permissions.
-    1) Make sure the directory exists in a race-free operation
-    2) If mode is not None and the directory has been created, give the right
-    permissions to the leaf directory. The current umask value is masked out first.
-    3) If pretty_deadly is True, catch exceptions, reraise them with a pretty
-    message.
-    Returns if the directory has been created and has the right permissions,
-    An exception otherwise. If a deadly exception happened it is reraised.
+    Ensure that the directory exists with the correct permissions.
+
+    1) Create the directory in a race-free manner.
+    2) If mode is not None and the directory was created, set the correct
+       permissions on the leaf directory (masking out the current umask first).
+    3) If pretty_deadly is True, catch exceptions and re-raise them with a clearer
+       message.
+
+    Returns normally if the directory exists (with correct permissions) or was created.
+    Raises an exception otherwise. If a fatal exception occurs, it is re-raised.
     """
     try:
         Path(path).mkdir(mode=mode, parents=True, exist_ok=True)
@@ -44,7 +46,7 @@ def ensure_dir(path, mode=stat.S_IRWXU | stat.S_IRWXG | stat.S_IRWXO, pretty_dea
 
 
 def get_base_dir(*, legacy=False):
-    """Get home directory / base directory for borg:
+    """Get home directory / base directory for Borg:
 
     - BORG_BASE_DIR, if set
     - HOME, if set
@@ -73,7 +75,7 @@ def join_base_dir(*paths, **kw):
 
 
 def get_keys_dir(*, legacy=False, create=True):
-    """Determine where to repository keys and cache"""
+    """Determine where to store repository keys."""
     keys_dir = os.environ.get("BORG_KEYS_DIR")
     if keys_dir is None:
         # note: do not just give this as default to the environment.get(), see issue #5979.
@@ -124,7 +126,7 @@ def get_socket_filename():
 
 
 def get_cache_dir(*, legacy=False, create=True):
-    """Determine where to repository keys and cache"""
+    """Determine where to store Borg cache data"""
 
     if legacy:
         # Get cache home path
@@ -160,7 +162,7 @@ def get_cache_dir(*, legacy=False, create=True):
 
 
 def get_config_dir(*, legacy=False, create=True):
-    """Determine where to store whole config"""
+    """Determine where to store the configuration"""
 
     # Get config home path
     if legacy:
diff --git a/src/borg/helpers/lrucache.py b/src/borg/helpers/lrucache.py
index bdc538c733..402332b7e0 100644
--- a/src/borg/helpers/lrucache.py
+++ b/src/borg/helpers/lrucache.py
@@ -25,9 +25,9 @@ def __init__(self, capacity: int, dispose: Callable[[V], None] = lambda _: None)
         self._dispose = dispose
 
     def __setitem__(self, key: K, value: V) -> None:
-        assert key not in self._cache, (
-            "Unexpected attempt to replace a cached item," " without first deleting the old item."
-        )
+        assert (
+            key not in self._cache
+        ), "Unexpected attempt to replace a cached item without first deleting the old item."
         while len(self._cache) >= self._capacity:
             self._dispose(self._cache.popitem(last=False)[1])
         self._cache[key] = value
@@ -47,7 +47,7 @@ def __len__(self) -> int:
         return len(self._cache)
 
     def replace(self, key: K, value: V) -> None:
-        """Replace an item which is already present, not disposing it in the process"""
+        """Replace an item that is already present, not disposing it in the process."""
         # this method complements __setitem__ which should be used for the normal use case.
         assert key in self._cache, "Unexpected attempt to update a non-existing item."
         self._cache[key] = value
diff --git a/src/borg/helpers/misc.py b/src/borg/helpers/misc.py
index 98c2c50cbb..4418671b5b 100644
--- a/src/borg/helpers/misc.py
+++ b/src/borg/helpers/misc.py
@@ -60,9 +60,9 @@ def sysinfo():
 
 def log_multi(*msgs, level=logging.INFO, logger=logger):
     """
-    log multiple lines of text, each line by a separate logging call for cosmetic reasons
+    Log multiple lines of text, emitting each line via a separate logging call for cosmetic reasons.
 
-    each positional argument may be a single or multiple lines (separated by newlines) of text.
+    Each positional argument may be a single or multiple lines (separated by newlines) of text.
     """
     lines = []
     for msg in msgs:
@@ -72,16 +72,16 @@ def log_multi(*msgs, level=logging.INFO, logger=logger):
 
 
 class ChunkIteratorFileWrapper:
-    """File-like wrapper for chunk iterators"""
+    """File-like wrapper for chunk iterators."""
 
     def __init__(self, chunk_iterator, read_callback=None):
         """
         *chunk_iterator* should be an iterator yielding bytes. These will be buffered
         internally as necessary to satisfy .read() calls.
 
-        *read_callback* will be called with one argument, some byte string that has
-        just been read and will be subsequently returned to a caller of .read().
-        It can be used to update a progress display.
+        *read_callback* will be called with one argument, a byte string that has
+        just been read and will subsequently be returned to a caller of .read().
+        The callback can be used to update a progress display.
         """
         self.chunk_iterator = chunk_iterator
         self.chunk_offset = 0
@@ -129,9 +129,9 @@ def open_item(archive, item):
 
 def chunkit(it, size):
     """
-    Chunk an iterator <it> into pieces of <size>.
+    Chunk an iterator into pieces of the given size.
 
-    >>> list(chunker('ABCDEFG', 3))
+    >>> list(chunkit('ABCDEFG', 3))
     [['A', 'B', 'C'], ['D', 'E', 'F'], ['G']]
     """
     iterable = iter(it)
@@ -139,7 +139,7 @@ def chunkit(it, size):
 
 
 def consume(iterator, n=None):
-    """Advance the iterator n-steps ahead. If n is none, consume entirely."""
+    """Advance the iterator n steps. If n is None, consume it entirely."""
     # Use functions that consume iterators at C speed.
     if n is None:
         # feed the entire iterator into a zero-length deque
@@ -174,7 +174,7 @@ def write(self, s):
 
 
 def iter_separated(fd, sep=None, read_size=4096):
-    """Iter over chunks of open file ``fd`` delimited by ``sep``. Doesn't trim."""
+    """Iterate over chunks of the open file ``fd`` delimited by ``sep``. Does not trim."""
     buf = fd.read(read_size)
     is_str = isinstance(buf, str)
     part = "" if is_str else b""
diff --git a/src/borg/helpers/msgpack.py b/src/borg/helpers/msgpack.py
index e669e9014d..cb52fac928 100644
--- a/src/borg/helpers/msgpack.py
+++ b/src/borg/helpers/msgpack.py
@@ -1,47 +1,48 @@
 """
-wrapping msgpack
+Wrapping MessagePack
 ================
 
-We wrap msgpack here the way we need it - to avoid having lots of clutter in the calling code.
+We wrap MessagePack here as needed to avoid clutter in the calling code.
 
 Packing
 -------
-- use_bin_type = True (used by borg since borg 2.0)
+- use_bin_type = True (used by Borg since Borg 2.0)
   This is used to generate output according to new msgpack 2.0 spec.
   This cleanly keeps bytes and str types apart.
 
-- use_bin_type = False (used by borg < 1.3)
+- use_bin_type = False (used by Borg < 1.3)
   This creates output according to the older msgpack spec.
   BAD: str and bytes were packed into same "raw" representation.
 
 - unicode_errors = 'surrogateescape'
-  Guess backup applications are one of the rare cases when this needs to be used.
-  It is needed because borg also needs to deal with data that does not cleanly encode/decode using utf-8.
-  There's a lot of crap out there, e.g. in filenames and as a backup tool, we must keep them as good as possible.
+  Backup applications are one of the rare cases where this is necessary.
+  It is needed because Borg also needs to deal with data that does not cleanly encode or decode using UTF-8.
+  There is a lot of problematic data out there (e.g., in filenames), and as a backup tool,
+  we must preserve them as faithfully as possible.
 
 Unpacking
 ---------
-- raw = False (used by borg since borg 2.0)
+- raw = False (used by Borg since Borg 2.0)
   We already can use this with borg 2.0 due to the type conversion to the desired type in item.py update_internal
   methods. This type conversion code can be removed in future, when we do not have to deal with data any more
   that was packed the old way.
   It will then unpack according to the msgpack 2.0 spec format and directly output bytes or str.
 
-- raw = True (the old way, used by borg < 1.3)
+- raw = True (the old way, used by Borg < 1.3)
 
 - unicode_errors = 'surrogateescape' -> see description above (will be used when raw is False).
 
-As of borg 2.0, we have fixed most of the msgpack str/bytes mess, #968.
-Borg now still needs to **read** old repos, archives, keys, ... so we can not yet fix it completely.
-But from now on, borg only **writes** new data according to the new msgpack 2.0 spec,
-thus we can remove some legacy support in a later borg release (some places are marked with "legacy").
+As of Borg 2.0, we have fixed most of the MessagePack str/bytes issues (#968).
+Borg still needs to read old repositories, archives, keys, etc., so we cannot yet fix it completely.
+From now on, Borg only writes new data according to the MessagePack 2.0 spec,
+thus we can remove some legacy support in a later Borg release (some places are marked with "legacy").
 
-current way in msgpack terms
+Current behavior in MessagePack terms
 ----------------------------
 
-- pack with use_bin_type=True (according to msgpack 2.0 spec)
+- pack with use_bin_type=True (according to the MessagePack 2.0 spec)
 - packs str -> raw and bytes -> bin
-- unpack with raw=False (according to msgpack 2.0 spec, using unicode_errors='surrogateescape')
+- unpack with raw=False (according to the MessagePack 2.0 spec, using unicode_errors='surrogateescape')
 - unpacks bin to bytes and raw to str (thus we need to convert to desired type if we want bytes from "raw")
 """
 
@@ -68,11 +69,11 @@
 
 
 class PackException(Exception):
-    """Exception while msgpack packing"""
+    """Exception during MessagePack packing."""
 
 
 class UnpackException(Exception):
-    """Exception while msgpack unpacking"""
+    """Exception during MessagePack unpacking."""
 
 
 class Packer(mp_Packer):
diff --git a/src/borg/helpers/nanorst.py b/src/borg/helpers/nanorst.py
index 25896723b5..dc2f6d1a72 100644
--- a/src/borg/helpers/nanorst.py
+++ b/src/borg/helpers/nanorst.py
@@ -50,11 +50,11 @@ def process_directive(directive, arguments, out, state_hook):
 
 def rst_to_text(text, state_hook=None, references=None):
     """
-    Convert rST to a more human text form.
+    Convert rST to a more human-friendly text form.
 
     This is a very loose conversion. No advanced rST features are supported.
-    The generated output directly depends on the input (e.g. indentation of
-    admonitions).
+    The generated output depends directly on the input (for example, the
+    indentation of admonitions).
     """
     state_hook = state_hook or (lambda old_state, new_state, out: None)
     references = references or {}
@@ -206,7 +206,7 @@ def rst_to_terminal(rst, references=None, destination=sys.stdout):
     Convert *rst* to a lazy string.
 
     If *destination* is a file-like object connected to a terminal,
-    enrich text with suitable ANSI escapes. Otherwise return plain text.
+    enrich the text with suitable ANSI escapes. Otherwise, return plain text.
     """
     if is_terminal(destination):
         rst_state_hook = ansi_escapes
diff --git a/src/borg/helpers/parseformat.py b/src/borg/helpers/parseformat.py
index 61f52a4b0a..d0011785df 100644
--- a/src/borg/helpers/parseformat.py
+++ b/src/borg/helpers/parseformat.py
@@ -49,21 +49,21 @@ def hex_to_bin(hex, length=None):
 
 
 def safe_decode(s, coding="utf-8", errors="surrogateescape"):
-    """decode bytes to str, with round-tripping "invalid" bytes"""
+    """Decode bytes to str, with round-tripping of "invalid" bytes."""
     if s is None:
         return None
     return s.decode(coding, errors)
 
 
 def safe_encode(s, coding="utf-8", errors="surrogateescape"):
-    """encode str to bytes, with round-tripping "invalid" bytes"""
+    """Encode str to bytes, with round-tripping of "invalid" bytes."""
     if s is None:
         return None
     return s.encode(coding, errors)
 
 
 def remove_surrogates(s, errors="replace"):
-    """Replace surrogates generated by fsdecode with '?'"""
+    """Replace surrogates generated by fsdecode with '?'."""
     return s.encode("utf-8", errors).decode("utf-8")
 
 
@@ -107,7 +107,7 @@ def join_cmd(argv, rs=False):
 
 
 def eval_escapes(s):
-    """Evaluate literal escape sequences in a string (eg `\\n` -> `\n`)."""
+    """Evaluate literal escape sequences in a string (e.g. `\\n` -> `\n`)."""
     return s.encode("ascii", "backslashreplace").decode("unicode-escape")
 
 
@@ -119,7 +119,7 @@ def decode_dict(d, keys, encoding="utf-8", errors="surrogateescape"):
 
 
 def positive_int_validator(value):
-    """argparse type for positive integers"""
+    """Argparse type for positive integers."""
     int_value = int(value)
     if int_value <= 0:
         raise argparse.ArgumentTypeError("A positive integer is required: %s" % value)
diff --git a/src/borg/helpers/passphrase.py b/src/borg/helpers/passphrase.py
index 59b5f65c40..8ee2778cf9 100644
--- a/src/borg/helpers/passphrase.py
+++ b/src/borg/helpers/passphrase.py
@@ -16,25 +16,25 @@
 
 
 class NoPassphraseFailure(Error):
-    """can not acquire a passphrase: {}"""
+    """Cannot acquire a passphrase: {}."""
 
     exit_mcode = 50
 
 
 class PasscommandFailure(Error):
-    """passcommand supplied in BORG_PASSCOMMAND failed: {}"""
+    """Passcommand supplied in BORG_PASSCOMMAND failed: {}."""
 
     exit_mcode = 51
 
 
 class PassphraseWrong(Error):
-    """passphrase supplied in BORG_PASSPHRASE, by BORG_PASSCOMMAND or via BORG_PASSPHRASE_FD is incorrect."""
+    """Passphrase supplied in BORG_PASSPHRASE, by BORG_PASSCOMMAND, or via BORG_PASSPHRASE_FD is incorrect."""
 
     exit_mcode = 52
 
 
 class PasswordRetriesExceeded(Error):
-    """exceeded the maximum password retries"""
+    """Exceeded the maximum password retries."""
 
     exit_mcode = 53
 
@@ -118,8 +118,8 @@ def verification(cls, passphrase):
             Your passphrase (between double-quotes): "{passphrase}"
             Make sure the passphrase displayed above is exactly what you wanted.
             Your passphrase (UTF-8 encoding in hex): {bin_to_hex(passphrase.encode("utf-8"))}
-            It is recommended to keep the UTF-8 encoding in hex together with the passphrase at a safe place.
-            In case you should ever run into passphrase issues, it could sometimes help debugging them.
+            It is recommended to keep the UTF-8 encoding in hex together with the passphrase in a safe place.
+            In case you should ever run into passphrase issues, it could sometimes help debug them.
             """
             )
             print(pw_msg, file=sys.stderr)
diff --git a/src/borg/helpers/process.py b/src/borg/helpers/process.py
index f2d6da7abe..27ffcaaefc 100644
--- a/src/borg/helpers/process.py
+++ b/src/borg/helpers/process.py
@@ -54,9 +54,9 @@ def _daemonize():
 
 
 def daemonize():
-    """Detach process from controlling terminal and run in background
+    """Detach the process from the controlling terminal and run in the background.
 
-    Returns: old and new get_process_id tuples
+    Returns: old and new get_process_id tuples.
     """
     with _daemonize() as (old_id, new_id):
         return old_id, new_id
@@ -64,7 +64,7 @@ def daemonize():
 
 @contextlib.contextmanager
 def daemonizing(*, timeout=5):
-    """Like daemonize(), but as context manager.
+    """Like daemonize(), but as a context manager.
 
     The with-body is executed in the background process,
     while the foreground process survives until the body is left
@@ -146,28 +146,28 @@ def __init__(self, exit_code):
 
 
 class SignalException(BaseException):
-    """base class for all signal-based exceptions"""
+    """Base class for all signal-based exceptions."""
 
 
 class SigHup(SignalException):
-    """raised on SIGHUP signal"""
+    """Raised on SIGHUP signal."""
 
 
 class SigTerm(SignalException):
-    """raised on SIGTERM signal"""
+    """Raised on SIGTERM signal."""
 
 
 @contextlib.contextmanager
 def signal_handler(sig, handler):
     """
-    when entering context, set up signal handler <handler> for signal <sig>.
-    when leaving context, restore original signal handler.
+    When entering the context, set up signal handler <handler> for signal <sig>.
+    When leaving the context, restore the original signal handler.
 
-    <sig> can bei either a str when giving a signal.SIGXXX attribute name (it
-    won't crash if the attribute name does not exist as some names are platform
-    specific) or a int, when giving a signal number.
+    <sig> can be either a str (the name of a signal.SIGXXX attribute; it
+    will not crash if the attribute name does not exist, as some names are platform
+    specific) or an int (a signal number).
 
-    <handler> is any handler value as accepted by the signal.signal(sig, handler).
+    <handler> is any handler value accepted by signal.signal(sig, handler).
     """
     if isinstance(sig, str):
         sig = getattr(signal, sig, None)
@@ -252,13 +252,13 @@ def __exit__(self, exception_type, exception_value, traceback):
 
 def ignore_sigint():
     """
-    Ignore SIGINT, see also issue #6912.
+    Ignore SIGINT (see also issue #6912).
 
     Ctrl-C will send a SIGINT to both the main process (borg) and subprocesses
-    (e.g. ssh for remote ssh:// repos), but often we do not want the subprocess
-    getting killed (e.g. because it is still needed to shut down borg cleanly).
+    (e.g., ssh for remote ssh:// repositories), but often we do not want the subprocess
+    to be killed (e.g., because it is still needed to shut down borg cleanly).
 
-    To avoid that: Popen(..., preexec_fn=ignore_sigint)
+    To avoid this, use: Popen(..., preexec_fn=ignore_sigint)
     """
     signal.signal(signal.SIGINT, signal.SIG_IGN)
 
@@ -303,9 +303,9 @@ def prepare_subprocess_env(system, env=None):
     Prepare the environment for a subprocess we are going to create.
 
     :param system: True for preparing to invoke system-installed binaries,
-                   False for stuff inside the pyinstaller environment (like borg, python).
-    :param env: optionally give a environment dict here. if not given, default to os.environ.
-    :return: a modified copy of the environment
+                   False for stuff inside the PyInstaller environment (like borg, python).
+    :param env: optionally provide an environment dict here. If not given, defaults to os.environ.
+    :return: a modified copy of the environment.
     """
     env = dict(env if env is not None else os.environ)
     if system:
diff --git a/src/borg/helpers/progress.py b/src/borg/helpers/progress.py
index 8d6f8caff0..3055891bf2 100644
--- a/src/borg/helpers/progress.py
+++ b/src/borg/helpers/progress.py
@@ -48,12 +48,12 @@ class ProgressIndicatorPercent(ProgressIndicatorBase):
 
     def __init__(self, total=0, step=5, start=0, msg="%3.0f%%", msgid=None):
         """
-        Percentage-based progress indicator
+        Percentage-based progress indicator.
 
-        :param total: total amount of items
-        :param step: step size in percent
-        :param start: at which percent value to start
-        :param msg: output message, must contain one %f placeholder for the percentage
+        :param total: total amount of items.
+        :param step: step size in percent.
+        :param start: at which percent value to start.
+        :param msg: output message; must contain one %f placeholder for the percentage.
         """
         self.counter = 0  # 0 .. (total-1)
         self.total = total
@@ -74,11 +74,11 @@ def progress(self, current=None, increase=1):
 
     def show(self, current=None, increase=1, info=None):
         """
-        Show and output the progress message
+        Show and output the progress message.
 
-        :param current: set the current percentage [None]
-        :param increase: increase the current percentage [None]
-        :param info: array of strings to be formatted with msg [None]
+        :param current: Set the current percentage. [None]
+        :param increase: Increase the current percentage. [None]
+        :param info: Array of strings to be formatted with msg. [None]
         """
         pct = self.progress(current, increase)
         if pct is not None:
diff --git a/src/borg/helpers/shellpattern.py b/src/borg/helpers/shellpattern.py
index 12b0bba2f7..00e9237bdd 100644
--- a/src/borg/helpers/shellpattern.py
+++ b/src/borg/helpers/shellpattern.py
@@ -8,10 +8,10 @@ def translate(pat, match_end=r"\Z"):
 
     The pattern may include ``**<sep>`` (<sep> stands for the platform-specific path separator; "/" on POSIX systems)
     for matching zero or more directory levels and "*" for matching zero or more arbitrary characters except any path
-    separator. Wrap meta-characters in brackets for a literal match (i.e. "[?]" to match the literal character "?").
+    separator. Wrap meta-characters in brackets for a literal match (i.e., "[?]" to match the literal character "?").
 
-    Using match_end=regex one can give a regular expression that is used to match after the regex that is generated from
-    the pattern. The default is to match the end of the string.
+    Using ``match_end=REGEX`` you can provide a regular expression that is appended after the pattern-derived
+    expression. The default is to match the end of the string.
 
     This function is derived from the "fnmatch" module distributed with the Python standard library.
 
@@ -69,18 +69,18 @@ def translate(pat, match_end=r"\Z"):
 
 
 def _parse_braces(pat):
-    """Returns the index values of paired braces in `pat` as a list of tuples.
+    """Return the index pairs of matched braces in `pat` as a list of tuples.
 
-    The dict's keys are the indexes corresponding to opening braces. Initially,
+    The dictionary's keys are the indices corresponding to opening braces. Initially,
     they are set to a value of `None`. Once a corresponding closing brace is found,
-    the value is updated. All dict keys with a positive int value are valid pairs.
+    the value is updated. All dictionary keys with a positive integer value are valid pairs.
 
-    Cannot rely on re.match("[^\\(\\\\)*]?{.*[^\\(\\\\)*]}") because, while it
-    does handle unpaired braces and nested pairs of braces, it misses sequences
-    of paired braces. E.g.: "{foo,bar}{bar,baz}" would translate, incorrectly, to
-    "(foo|bar\\}\\{bar|baz)" instead of, correctly, to "(foo|bar)(bar|baz)"
+    We cannot rely on re.match("[^\\(\\\\)*]?{.*[^\\(\\\\)*]}") because, while it
+    handles unpaired braces and nested pairs of braces, it misses sequences
+    of paired braces. For example: "{foo,bar}{bar,baz}" would translate, incorrectly, to
+    "(foo|bar\\}\\{bar|baz)" instead of, correctly, to "(foo|bar)(bar|baz)".
 
-    So this function parses in a left-to-right fashion, tracking pairs with a LIFO
+    Therefore, this function parses left-to-right, tracking pairs with a LIFO
     queue: pushing opening braces on and popping them off when finding a closing
     brace.
     """
diff --git a/src/borg/helpers/time.py b/src/borg/helpers/time.py
index 98a6c6f5a6..7dfe0d38c4 100644
--- a/src/borg/helpers/time.py
+++ b/src/borg/helpers/time.py
@@ -4,9 +4,9 @@
 
 
 def parse_timestamp(timestamp, tzinfo=timezone.utc):
-    """Parse a ISO 8601 timestamp string.
+    """Parse an ISO 8601 timestamp string.
 
-    For naive/unaware dt, assume it is in tzinfo timezone (default: UTC).
+    For naive/unaware datetime objects, assume they are in the tzinfo timezone (default: UTC).
     """
     dt = datetime.fromisoformat(timestamp)
     if dt.tzinfo is None:
@@ -15,10 +15,10 @@ def parse_timestamp(timestamp, tzinfo=timezone.utc):
 
 
 def parse_local_timestamp(timestamp, tzinfo=None):
-    """Parse a ISO 8601 timestamp string.
+    """Parse an ISO 8601 timestamp string.
 
-    For naive/unaware dt, assume it is in local timezone.
-    Convert to tzinfo timezone (the default None means: local timezone).
+    For naive/unaware datetime objects, assume the local timezone.
+    Convert to the tzinfo timezone (the default None means: local timezone).
     """
     dt = datetime.fromisoformat(timestamp)
     if dt.tzinfo is None:
@@ -27,13 +27,13 @@ def parse_local_timestamp(timestamp, tzinfo=None):
 
 
 def timestamp(s):
-    """Convert a --timestamp=s argument to a datetime object"""
+    """Convert a --timestamp=s argument to a datetime object."""
     try:
         # is it pointing to a file / directory?
         ts = safe_s(os.stat(s).st_mtime)
         return datetime.fromtimestamp(ts, tz=timezone.utc)
     except OSError:
-        # didn't work, try parsing as a ISO timestamp. if no TZ is given, we assume local timezone.
+        # didn't work, try parsing as an ISO timestamp. if no TZ is given, we assume local timezone.
         return parse_local_timestamp(s)
 
 
@@ -95,7 +95,7 @@ def format_time(ts: datetime, format_spec=""):
 
 
 def format_timedelta(td):
-    """Format timedelta in a human friendly format"""
+    """Format a timedelta in a human-friendly format."""
     ts = td.total_seconds()
     s = ts % 60
     m = int(ts / 60) % 60
@@ -112,8 +112,9 @@ def format_timedelta(td):
 
 def calculate_relative_offset(format_string, from_ts, earlier=False):
     """
-    Calculates offset based on a relative marker. 7d (7 days), 8m (8 months)
-    earlier: whether offset should be calculated to an earlier time.
+    Calculate an offset based on a relative marker (e.g., 7d for 7 days, 8m for 8 months).
+
+    earlier indicates whether the offset should be applied towards an earlier time.
     """
     if from_ts is None:
         from_ts = archive_ts_now()
@@ -173,7 +174,7 @@ def __format__(self, format_spec):
         return format_time(self.ts.astimezone(), format_spec=format_spec)
 
     def __str__(self):
-        return f"{self}"
+        return self.isoformat()
 
     def isoformat(self):
         # we want to output a timestamp in the user's local timezone
diff --git a/src/borg/helpers/yes_no.py b/src/borg/helpers/yes_no.py
index 305b8c0c8f..632c1f5683 100644
--- a/src/borg/helpers/yes_no.py
+++ b/src/borg/helpers/yes_no.py
@@ -31,30 +31,30 @@ def yes(
     prompt=True,
     msgid=None,
 ):
-    """Output <msg> (usually a question) and let user input an answer.
-    Qualifies the answer according to falsish, truish and defaultish as True, False or <default>.
-    If it didn't qualify and retry is False (no retries wanted), return the default [which
-    defaults to False]. If retry is True let user retry answering until answer is qualified.
+    """Output msg (usually a question) and let the user input an answer.
+    Classify the answer according to falsish, truish, and defaultish as True, False, or the default.
+    If it did not qualify and retry is False (no retries wanted), return the default (which
+    defaults to False). If retry is True, let the user retry answering until the answer is qualified.
 
-    If env_var_override is given and this var is present in the environment, do not ask
-    the user, but just use the env var contents as answer as if it was typed in.
-    Otherwise read input from stdin and proceed as normal.
-    If EOF is received instead an input or an invalid input without retry possibility,
-    return default.
+    If env_var_override is given and this variable is present in the environment, do not ask
+    the user, but use the environment variable's contents as the answer as if it was typed in.
+    Otherwise, read input from stdin and proceed as normal.
+    If EOF is received instead of input, or an invalid input without a retry possibility,
+    return the default.
 
-    :param msg: introducing message to output on ofile, no \n is added [None]
-    :param retry_msg: retry message to output on ofile, no \n is added [None]
+    :param msg: introductory message to output on ofile; no \n is added [None]
+    :param retry_msg: retry message to output on ofile; no \n is added [None]
     :param false_msg: message to output before returning False [None]
     :param true_msg: message to output before returning True [None]
-    :param default_msg: message to output before returning a <default> [None]
-    :param invalid_msg: message to output after a invalid answer was given [None]
+    :param default_msg: message to output before returning the default [None]
+    :param invalid_msg: message to output after an invalid answer is given [None]
     :param env_msg: message to output when using input from env_var_override ['{} (from {})'],
-           needs to have 2 placeholders for answer and env var name
+           must have two placeholders for the answer and the environment variable name
     :param falsish: sequence of answers qualifying as False
     :param truish: sequence of answers qualifying as True
-    :param defaultish: sequence of answers qualifying as <default>
+    :param defaultish: sequence of answers qualifying as the default
     :param default: default return value (defaultish answer was given or no-answer condition) [False]
-    :param retry: if True and input is incorrect, retry. Otherwise return default. [True]
+    :param retry: if True and input is incorrect, retry; otherwise return the default [True]
     :param env_var_override: environment variable name [None]
     :param ofile: output stream [sys.stderr]
     :param input: input function [input from builtins]
@@ -73,8 +73,8 @@ def output(msg, msg_type, is_prompt=False, **kwargs):
                 print(msg, file=ofile)
 
     msgid = msgid or env_var_override
-    # note: we do not assign sys.stderr as default above, so it is
-    # really evaluated NOW,  not at function definition time.
+    # note: we do not assign sys.stderr as the default above, so it is
+    # really evaluated NOW, not at function definition time.
     if ofile is None:
         ofile = sys.stderr
     if default not in (True, False):
diff --git a/src/borg/item.pyx b/src/borg/item.pyx
index b139f55e26..3dcabefc28 100644
--- a/src/borg/item.pyx
+++ b/src/borg/item.pyx
@@ -21,7 +21,7 @@ API_VERSION = '1.2_01'
 
 
 def fix_key(data, key, *, errors='strict'):
-    """if k is a bytes-typed key, migrate key/value to a str-typed key in dict data"""
+    """If the key is bytes-typed, migrate the key/value to a str-typed key in the data dict."""
     if isinstance(key, bytes):
         value = data.pop(key)
         key = key.decode('utf-8', errors=errors)
@@ -31,7 +31,7 @@ def fix_key(data, key, *, errors='strict'):
 
 
 def fix_str_value(data, key, errors='surrogateescape'):
-    """makes sure that data[key] is a str (decode if it is bytes)"""
+    """Ensure that data[key] is a str (decode if it is bytes)."""
     assert isinstance(key, str)  # fix_key must be called first
     value = data[key]
     value = want_str(value, errors=errors)
@@ -40,7 +40,7 @@ def fix_str_value(data, key, errors='surrogateescape'):
 
 
 def fix_bytes_value(data, key):
-    """makes sure that data[key] is bytes (encode if it is str)"""
+    """Ensure that data[key] is bytes (encode if it is str)."""
     assert isinstance(key, str)  # fix_key must be called first
     value = data[key]
     value = want_bytes(value)
@@ -49,19 +49,19 @@ def fix_bytes_value(data, key):
 
 
 def fix_list_of_str(v):
-    """make sure we have a list of str"""
+    """Ensure that we have a list of str."""
     assert isinstance(v, (tuple, list))
     return [want_str(e) for e in v]
 
 
 def fix_list_of_bytes(v):
-    """make sure we have a list of bytes"""
+    """Ensure that we have a list of bytes."""
     assert isinstance(v, (tuple, list))
     return [want_bytes(e) for e in v]
 
 
 def fix_list_of_chunkentries(v):
-    """make sure we have a list of correct chunkentries"""
+    """Ensure that we have a list of valid chunk entries."""
     assert isinstance(v, (tuple, list))
     chunks = []
     for ce in v:
@@ -75,13 +75,13 @@ def fix_list_of_chunkentries(v):
 
 
 def fix_tuple_of_str(v):
-    """make sure we have a tuple of str"""
+    """Ensure that we have a tuple of str."""
     assert isinstance(v, (tuple, list))
     return tuple(want_str(e) for e in v)
 
 
 def fix_tuple_of_str_and_int(v):
-    """make sure we have a tuple of str or int"""
+    """Ensure that we have a tuple of str or int."""
     assert isinstance(v, (tuple, list))
     t = tuple(e.decode() if isinstance(e, bytes) else e for e in v)
     assert all(isinstance(e, (str, int)) for e in t), repr(t)
@@ -89,7 +89,7 @@ def fix_tuple_of_str_and_int(v):
 
 
 def fix_timestamp(v):
-    """make sure v is a Timestamp"""
+    """Ensure that v is a Timestamp."""
     if isinstance(v, Timestamp):
         return v
     # legacy support
@@ -100,7 +100,7 @@ def fix_timestamp(v):
 
 
 def want_bytes(v, *, errors='surrogateescape'):
-    """we know that we want bytes and the value should be bytes"""
+    """Ensure that the value is bytes (encode if necessary)."""
     # legacy support: it being str can be caused by msgpack unpack decoding old data that was packed with use_bin_type=False
     if isinstance(v, str):
         v = v.encode('utf-8', errors=errors)
@@ -109,7 +109,7 @@ def want_bytes(v, *, errors='surrogateescape'):
 
 
 def want_str(v, *, errors='surrogateescape'):
-    """we know that we want str and the value should be str"""
+    """Ensure that the value is str (decode if necessary)."""
     if isinstance(v, bytes):
         v = v.decode('utf-8', errors=errors)
     assert isinstance(v, str), f'not a str object, but {v!r}'
diff --git a/src/borg/legacyremote.py b/src/borg/legacyremote.py
index 8e412af663..40b4e6a63a 100644
--- a/src/borg/legacyremote.py
+++ b/src/borg/legacyremote.py
@@ -44,7 +44,7 @@
 
 
 class ConnectionClosed(Error):
-    """Connection closed by remote host"""
+    """Connection closed by remote host."""
 
     exit_mcode = 80
 
@@ -56,13 +56,13 @@ class ConnectionClosedWithHint(ConnectionClosed):
 
 
 class PathNotAllowed(Error):
-    """Repository path not allowed: {}"""
+    """Repository path not allowed: {}."""
 
     exit_mcode = 83
 
 
 class InvalidRPCMethod(Error):
-    """RPC method {} is not valid"""
+    """RPC method {} is not valid."""
 
     exit_mcode = 82
 
@@ -95,7 +95,7 @@ class ConnectionBrokenWithHint(Error):
 
 
 # Protocol compatibility:
-# In general the server is responsible for rejecting too old clients and the client it responsible for rejecting
+# In general the server is responsible for rejecting too old clients and the client is responsible for rejecting
 # too old servers. This ensures that the knowledge what is compatible is always held by the newer component.
 #
 # For the client the return of the negotiate method is a dict which includes the server version.
diff --git a/src/borg/legacyrepository.py b/src/borg/legacyrepository.py
index 18a3389e95..b74a41b826 100644
--- a/src/borg/legacyrepository.py
+++ b/src/borg/legacyrepository.py
@@ -65,14 +65,14 @@ def header_size(tag):
 
 class LegacyRepository:
     """
-    Filesystem based transactional key value store
+    Filesystem-based transactional key-value store.
 
     Transactionality is achieved by using a log (aka journal) to record changes. The log is a series of numbered files
     called segments. Each segment is a series of log entries. The segment number together with the offset of each
     entry relative to its segment start establishes an ordering of the log entries. This is the "definition" of
     time for the purposes of the log.
 
-    Log entries are either PUT, DELETE or COMMIT.
+    Log entries are either PUT, DELETE, or COMMIT.
 
     A COMMIT is always the final log entry in a segment and marks all data from the beginning of the log until the
     segment ending with the COMMIT as committed and consistent. The segment number of a segment ending with a COMMIT
@@ -82,11 +82,11 @@ class LegacyRepository:
     all segments after the last committed segment are deleted; they contain log entries whose consistency is not
     established by a COMMIT.
 
-    Note that the COMMIT can't establish consistency by itself, but only manages to do so with proper support from
+    Note that the COMMIT cannot establish consistency by itself, but only manages to do so with proper support from
     the platform (including the hardware). See platform.base.SyncFile for details.
 
     A PUT inserts a key-value pair. The value is stored in the log entry, hence the repository implements
-    full data logging, meaning that all data is consistent, not just metadata (which is common in file systems).
+    full data logging, meaning that all data is consistent, not just metadata (which is common in filesystems).
 
     A DELETE marks a key as deleted.
 
@@ -98,9 +98,9 @@ class LegacyRepository:
     such obsolete entries is called sparse, while a segment containing no such entries is called compact.
 
     Sparse segments can be compacted and thereby disk space freed. This destroys the transaction for which the
-    superseded entries where current.
+    superseded entries were current.
 
-    On disk layout:
+    On-disk layout:
 
     dir/README
     dir/config
@@ -108,7 +108,7 @@ class LegacyRepository:
     dir/index.X
     dir/hints.X
 
-    File system interaction
+    Filesystem interaction
     -----------------------
 
     LoggedIO generally tries to rely on common behaviours across transactional file systems.
diff --git a/src/borg/logger.py b/src/borg/logger.py
index f10e41affe..6a31459f5d 100644
--- a/src/borg/logger.py
+++ b/src/borg/logger.py
@@ -1,51 +1,51 @@
-"""logging facilities
+"""Logging facilities.
 
-The way to use this is as follows:
+Usage:
 
-* each module declares its own logger, using:
+- Each module declares its own logger using:
 
-    from .logger import create_logger
-    logger = create_logger()
+      from .logger import create_logger
+      logger = create_logger()
 
-* then each module uses logger.info/warning/debug/etc according to the
-  level it believes is appropriate:
+- Then each module uses logger.info/warning/debug/etc. according to the
+  appropriate level:
 
-    logger.debug('debugging info for developers or power users')
-    logger.info('normal, informational output')
-    logger.warning('warn about a non-fatal error or sth else')
-    logger.error('a fatal error')
+      logger.debug('debugging info for developers or power users')
+      logger.info('normal, informational output')
+      logger.warning('warn about a non-fatal error or something else')
+      logger.error('a fatal error')
 
-  ... and so on. see the `logging documentation
+  See the `logging documentation
   <https://docs.python.org/3/howto/logging.html#when-to-use-logging>`_
-  for more information
+  for more information.
 
-* console interaction happens on stderr, that includes interactive
-  reporting functions like `help`, `info` and `list`
+- Console interaction happens on stderr; that includes interactive
+  reporting functions like `help`, `info`, and `list`.
 
-* ...except ``input()`` is special, because we can't control the
-  stream it is using, unfortunately. we assume that it won't clutter
-  stdout, because interaction would be broken then anyways
+- ``input()`` is special because we cannot control the stream it uses.
+  We assume it will not clutter stdout, because interaction would be broken
+  otherwise.
 
-* what is output on INFO level is additionally controlled by commandline
-  flags
+- What is output at INFO level is additionally controlled by command-line
+  flags.
 
-Logging setup is a bit complicated in borg, as it needs to work under misc. conditions:
-- purely local, not client/server (easy)
-- client/server: RemoteRepository ("borg serve" process) writes log records into a global
-  queue, which is then sent to the client side by the main serve loop (via the RPC protocol,
-  either over ssh stdout, more directly via process stdout without ssh [used in the tests]
-  or via a socket. On the client side, the log records are fed into the clientside logging
-  system. When remote_repo.close() is called, server side must send all queued log records
+Logging setup in Borg needs to work under various conditions:
+- Purely local, not client/server (easy).
+- Client/server: RemoteRepository ("borg serve" process) writes log records into a global
+  queue, which is then sent to the client side by the main serve loop (via the RPC protocol),
+  either over SSH stdout, more directly via process stdout without SSH (used in tests),
+  or via a socket. On the client side, the log records are fed into the client-side logging
+  system. When remote_repo.close() is called, the server side must send all queued log records
   via the RPC channel before returning the close() call's return value (as the client will
   then shut down the connection).
-- progress output is always given as json to the logger (including the plain text inside
-  the json), but then formatted by the logging system's formatter as either plain text or
-  json depending on the cli args given (--log-json?).
-- tests: potentially running in parallel via pytest-xdist, capturing borg output into a
+- Progress output is always given as JSON to the logger (including the plain text inside
+  the JSON), but then formatted by the logging system's formatter as either plain text or
+  JSON depending on the CLI args given (--log-json?).
+- Tests: potentially running in parallel via pytest-xdist, capturing Borg output into a
   given stream.
-- logging might be short-lived (e.g. when invoking a single borg command via the cli)
-  or long-lived (e.g. borg serve --socket or when running the tests)
-- logging is global and exists only once per process.
+- Logging might be short-lived (e.g., when invoking a single Borg command via the CLI)
+  or long-lived (e.g., borg serve --socket or when running the tests).
+- Logging is global and exists only once per process.
 """
 
 import inspect
@@ -60,14 +60,14 @@
 import warnings
 from pathlib import Path
 
-logging_debugging_path: Path | None = None  # if set, write borg.logger debugging log to thatpath/borg-*.log
+logging_debugging_path: Path | None = None  # if set, write borg.logger debugging log to that path/borg-*.log
 
 configured = False
 borg_serve_log_queue: queue.SimpleQueue = queue.SimpleQueue()
 
 
 class BorgQueueHandler(logging.handlers.QueueHandler):
-    """borg serve writes log record dicts to a borg_serve_log_queue"""
+    """Borg serve writes log record dicts to a borg_serve_log_queue."""
 
     def prepare(self, record: logging.LogRecord) -> dict:
         return dict(
diff --git a/src/borg/manifest.py b/src/borg/manifest.py
index 58029b625d..c6535878f3 100644
--- a/src/borg/manifest.py
+++ b/src/borg/manifest.py
@@ -22,7 +22,7 @@
 
 
 class MandatoryFeatureUnsupported(Error):
-    """Unsupported repository feature(s) {}. A newer version of borg is required to access this repository."""
+    """Unsupported repository feature(s) {}. A newer version of Borg is required to access this repository."""
 
     exit_mcode = 25
 
diff --git a/src/borg/patterns.py b/src/borg/patterns.py
index 74c6ad8314..c7e5ad225b 100644
--- a/src/borg/patterns.py
+++ b/src/borg/patterns.py
@@ -118,15 +118,15 @@ def add(self, patterns, cmd):
             self._add(pattern, cmd)
 
     def add_includepaths(self, include_paths):
-        """Used to add inclusion-paths from args.paths (from commandline)."""
+        """Used to add inclusion-paths from args.paths (from the command line)."""
         include_patterns = [parse_pattern(p, PathPrefixPattern) for p in include_paths]
         self.add(include_patterns, IECommand.Include)
         self.fallback = not include_patterns
         self.include_patterns = include_patterns
 
     def get_unmatched_include_patterns(self):
-        """Note that this only returns patterns added via *add_includepaths* and it
-        won't return PathFullPattern patterns as we do not match_count for them.
+        """Note that this only returns patterns added via *add_includepaths*, and it
+        won't return PathFullPattern patterns, as we do not maintain match_count for them.
         """
         return [p for p in self.include_patterns if p.match_count == 0 and not isinstance(p, PathFullPattern)]
 
diff --git a/src/borg/platform/__init__.py b/src/borg/platform/__init__.py
index 34b31c5e58..abb9f429f8 100644
--- a/src/borg/platform/__init__.py
+++ b/src/borg/platform/__init__.py
@@ -42,7 +42,7 @@
     from .posix import get_errno
     from .posix import uid2user, user2uid, gid2group, group2gid, getosusername
 elif not is_win32:  # pragma: posix only
-    # generic stuff for all other posix OSes
+    # Generic code for all other POSIX OSes
     OS_API_VERSION = API_VERSION
     from .base import listxattr, getxattr, setxattr
     from .base import acl_get, acl_set
@@ -53,7 +53,7 @@
     from .posix import get_errno
     from .posix import uid2user, user2uid, gid2group, group2gid, getosusername
 else:  # pragma: win32 only
-    # win32 specific stuff
+    # Win32-specific stuff
     OS_API_VERSION = API_VERSION
     from .base import listxattr, getxattr, setxattr
     from .base import acl_get, acl_set
@@ -66,7 +66,7 @@
 
 def get_birthtime_ns(st, path, fd=None):
     if hasattr(st, "st_birthtime_ns"):
-        # added in Python 3.12 but not always available.
+        # Added in Python 3.12, but not always available.
         return st.st_birthtime_ns
     elif is_darwin and is_darwin_feature_64_bit_inode:
         return _get_birthtime_ns(fd or path, follow_symlinks=False)
diff --git a/src/borg/platform/base.py b/src/borg/platform/base.py
index 7056da0609..5798607b5d 100644
--- a/src/borg/platform/base.py
+++ b/src/borg/platform/base.py
@@ -14,8 +14,8 @@
 Contains platform API implementations based on what Python itself provides. More specific
 APIs are stubs in this module.
 
-When functions in this module use platform APIs themselves they access the public
-platform API: that way platform APIs provided by the platform-specific support module
+When functions in this module use platform APIs themselves, they access the public
+platform API; in this way, platform APIs provided by the platform-specific support module
 are correctly composed into the base functionality.
 """
 
@@ -47,17 +47,17 @@ def getxattr(path, name, *, follow_symlinks=False):
     *follow_symlinks* indicates whether symlinks should be followed
     and only applies when *path* is not an open file descriptor.
     """
-    # as this base dummy implementation returns [] from listxattr,
+    # As this base dummy implementation returns [] from listxattr,
     # it must raise here for any given name:
     raise OSError(ENOATTR, os.strerror(ENOATTR), path)
 
 
 def setxattr(path, name, value, *, follow_symlinks=False):
     """
-    Write xattr on *path*.
+    Write an xattr on *path*.
 
     *path* can either be a path (bytes) or an open file descriptor (int).
-    *name* is the name of the xattr to read (bytes).
+    *name* is the name of the xattr to write (bytes).
     *value* is the value to write (bytes).
     *follow_symlinks* indicates whether symlinks should be followed
     and only applies when *path* is not an open file descriptor.
@@ -66,18 +66,17 @@ def setxattr(path, name, value, *, follow_symlinks=False):
 
 def acl_get(path, item, st, numeric_ids=False, fd=None):
     """
-    Saves ACL Entries
+    Save ACL entries.
 
-    If `numeric_ids` is True the user/group field is not preserved only uid/gid
+    If `numeric_ids` is True, the user/group field is not preserved; only uid/gid are stored.
     """
 
 
 def acl_set(path, item, numeric_ids=False, fd=None):
     """
-    Restore ACL Entries
+    Restore ACL entries.
 
-    If `numeric_ids` is True the stored uid/gid is used instead
-    of the user/group names
+    If `numeric_ids` is True, the stored uid/gid is used instead of the user/group names.
     """
 
 
@@ -100,8 +99,8 @@ def get_flags(path, st, fd=None):
 
 def sync_dir(path):
     if is_win32:
-        # Opening directories is not supported on windows.
-        # TODO: do we need to handle this in some other way?
+        # Opening directories is not supported on Windows.
+        # TODO: Do we need to handle this in some other way?
         return
     fd = os.open(str(path), os.O_RDONLY)
     try:
@@ -119,17 +118,16 @@ def safe_fadvise(fd, offset, len, advice):
     if has_posix_fadvise:
         advice = getattr(os, "POSIX_FADV_" + advice)
         try:
-            # UNIX only and, in case of block sizes that are not a multiple of the system's page size,
-            # better be used with a bug fixed linux kernel > 4.6.0, see borgbackup issue #907.
+            # UNIX only; and, in the case of block sizes that are not a multiple of the system's page size,
+            # this is better used with a bug-fixed Linux kernel > 4.6.0; see Borg issue #907.
             os.posix_fadvise(fd, offset, len, advice)
         except OSError:
-            # usually, posix_fadvise can't fail for us, but there seem to
-            # be failures when running borg under docker on ARM, likely due
-            # to a bug outside of borg.
-            # also, there is a python wrapper bug, always giving errno = 0.
+            # Usually, posix_fadvise does not fail for us, but there seem to be failures
+            # when running Borg under Docker on ARM, likely due to a bug outside of Borg.
+            # Also, there is a Python wrapper bug always giving errno = 0.
             # https://github.com/borgbackup/borg/issues/2095
-            # as this call is not critical for correct function (just to
-            # optimize cache usage), we ignore these errors.
+            # As this call is not critical for correct function (it just helps optimize cache usage),
+            # we ignore these errors.
             pass
 
 
@@ -137,19 +135,19 @@ class SyncFile:
     """
     A file class that is supposed to enable write ordering (one way or another) and data durability after close().
 
-    The degree to which either is possible varies with operating system, file system and hardware.
+    The degree to which either is possible varies with operating system, filesystem, and hardware.
 
     This fallback implements a naive and slow way of doing this. On some operating systems it can't actually
     guarantee any of the above, since fsync() doesn't guarantee it. Furthermore it may not be possible at all
     to satisfy the above guarantees on some hardware or operating systems. In these cases we hope that the thorough
     checksumming implemented catches any corrupted data due to misordered, delayed or partial writes.
 
-    Note that POSIX doesn't specify *anything* about power failures (or similar failures). A system that
-    routinely loses files or corrupts file on power loss is POSIX compliant.
+    Note that POSIX doesn't specify anything about power failures (or similar failures). A system that
+    routinely loses files or corrupts files on power loss is POSIX-compliant.
 
-    Calling SyncFile(path) for an existing path will raise FileExistsError, see comment in __init__.
+    Calling SyncFile(path) for an existing path will raise FileExistsError. See the comment in __init__.
 
-    TODO: Use F_FULLSYNC on OSX.
+    TODO: Use F_FULLSYNC on macOS.
     TODO: A Windows implementation should use CreateFile with FILE_FLAG_WRITE_THROUGH.
     """
 
@@ -165,7 +163,7 @@ def __init__(self, path, *, fd=None, binary=False):
         mode = "xb" if binary else "x"  # x -> raise FileExists exception in open() if file exists already
         self.path = path
         if fd is None:
-            self.f = open(str(path), mode=mode)  # python file object
+            self.f = open(str(path), mode=mode)  # Python file object
         else:
             self.f = os.fdopen(fd, mode=mode)
         self.fd = self.f.fileno()  # OS-level fd
@@ -212,11 +210,11 @@ class SaveFile:
 
     Must be used as a context manager (defining the scope of the transaction).
 
-    On a journaling file system the file contents are always updated
+    On a journaling filesystem the file contents are always updated
     atomically and won't become corrupted, even on power failures or
     crashes (for caveats see SyncFile).
 
-    SaveFile can safely by used in parallel (e.g. by multiple processes) to write
+    SaveFile can safely be used in parallel (e.g., by multiple processes) to write
     to the same target path. Whatever writer finishes last (executes the os.replace
     last) "wins" and has successfully written its content to the target path.
     Internally used temporary files are created in the target directory and are
@@ -231,7 +229,7 @@ def __init__(self, path, binary=False):
         self.tmp_prefix = path_obj.name + "-"
         self.tmp_fd = None  # OS-level fd
         self.tmp_fname = None  # full path/filename corresponding to self.tmp_fd
-        self.f = None  # python-file-like SyncFile
+        self.f = None  # Python file-like SyncFile
 
     def __enter__(self):
         from .. import platform
diff --git a/src/borg/platform/darwin.pyx b/src/borg/platform/darwin.pyx
index fe3385038e..0181a19280 100644
--- a/src/borg/platform/darwin.pyx
+++ b/src/borg/platform/darwin.pyx
@@ -101,8 +101,7 @@ def setxattr(path, name, value, *, follow_symlinks=False):
 
 
 def _remove_numeric_id_if_possible(acl):
-    """Replace the user/group field with the local uid/gid if possible
-    """
+    """Replace the user/group field with the local uid/gid, if possible."""
     assert isinstance(acl, bytes)
     entries = []
     for entry in safe_decode(acl).split('\n'):
diff --git a/src/borg/platform/freebsd.pyx b/src/borg/platform/freebsd.pyx
index 3eabe6267a..7e9460ce93 100644
--- a/src/borg/platform/freebsd.pyx
+++ b/src/borg/platform/freebsd.pyx
@@ -51,24 +51,24 @@ cdef extern from "unistd.h":
     int _PC_ACL_EXTENDED
 
 
-# On FreeBSD, borg currently only deals with the USER namespace as it is unclear
-# whether (and if so, how exactly) it should deal with the SYSTEM namespace.
+# On FreeBSD, Borg currently only deals with the USER namespace, as it is unclear
+# whether (and, if so, how exactly) it should deal with the SYSTEM namespace.
 NS_ID_MAP = {b"user": EXTATTR_NAMESPACE_USER, }
 
 
 def split_ns(ns_name, default_ns):
-    # split ns_name (which is in the form of b"namespace.name") into namespace and name.
-    # if there is no namespace given in ns_name, default to default_ns.
-    # note:
-    # borg < 1.1.10 on FreeBSD did not prefix the namespace to the names, see #3952.
-    # we also need to deal with "unexpected" namespaces here, they could come
-    # from borg archives made on other operating systems.
+    # Split ns_name (which is in the form b"namespace.name") into namespace and name.
+    # If there is no namespace given in ns_name, default to default_ns.
+    # Note:
+    # Borg < 1.1.10 on FreeBSD did not prefix the namespace to the names; see #3952.
+    # We also need to deal with "unexpected" namespaces here — they could come
+    # from Borg archives made on other operating systems.
     ns_name_tuple = ns_name.split(b".", 1)
     if len(ns_name_tuple) == 2:
-        # we have a namespace prefix in the given name
+        # We have a namespace prefix in the given name.
         ns, name = ns_name_tuple
     else:
-        # no namespace given in ns_name (== no dot found), maybe data coming from an old borg archive.
+        # No namespace given in ns_name (no dot found); maybe data from an old Borg archive.
         ns, name = default_ns, ns_name
     return ns, name
 
diff --git a/src/borg/platform/linux.pyx b/src/borg/platform/linux.pyx
index 178b184ba5..b307d44f9c 100644
--- a/src/borg/platform/linux.pyx
+++ b/src/borg/platform/linux.pyx
@@ -153,8 +153,8 @@ def set_flags(path, bsd_flags, fd=None):
 
 def get_flags(path, st, fd=None):
     if stat.S_ISBLK(st.st_mode) or stat.S_ISCHR(st.st_mode) or stat.S_ISLNK(st.st_mode):
-        # avoid opening devices files - trying to open non-present devices can be rather slow.
-        # avoid opening symlinks, O_NOFOLLOW would make the open() fail anyway.
+        # Avoid opening device files—trying to open non-present devices can be rather slow.
+        # Avoid opening symlinks; O_NOFOLLOW would make the open() fail anyway.
         return 0
     cdef int linux_flags
     open_fd = fd is None
diff --git a/src/borg/platform/posix.pyx b/src/borg/platform/posix.pyx
index 84c413701e..6ffa6e78ee 100644
--- a/src/borg/platform/posix.pyx
+++ b/src/borg/platform/posix.pyx
@@ -39,7 +39,7 @@ def process_alive(host, pid, thread):
     Check whether the (host, pid, thread_id) combination corresponds to a process potentially alive.
 
     If the process is local, then this will be accurate. If the process is not local, then this
-    returns always True, since there is no real way to check.
+    always returns True, since there is no real way to check.
     """
     from . import local_pid_alive
     from . import hostid
@@ -53,8 +53,8 @@ def process_alive(host, pid, thread):
         return True
 
     if thread != 0:
-        # Currently thread is always 0, if we ever decide to set this to a non-zero value,
-        # this code needs to be revisited, too, to do a sensible thing
+        # Currently, thread is always 0; if we ever decide to set this to a non-zero value,
+        # this code needs to be revisited to do a sensible thing.
         return True
 
     return local_pid_alive(pid)
@@ -73,7 +73,7 @@ def local_pid_alive(pid):
         if err.errno == errno.ESRCH:
             # ESRCH = no such process
             return False
-        # Any other error (eg. permissions) means that the process ID refers to a live process.
+        # Any other error (e.g., permissions) means that the process ID refers to a live process.
         return True
 
 
@@ -114,8 +114,7 @@ def group2gid(group, default=None):
 
 
 def posix_acl_use_stored_uid_gid(acl):
-    """Replace the user/group field with the stored uid/gid
-    """
+    """Replace the user/group field with the stored uid/gid."""
     assert isinstance(acl, bytes)
     from ..helpers import safe_decode, safe_encode
     entries = []
@@ -130,6 +129,6 @@ def posix_acl_use_stored_uid_gid(acl):
 
 
 def getosusername():
-    """Return the os user name."""
+    """Return the OS username."""
     uid = os.getuid()
     return uid2user(uid, uid)
diff --git a/src/borg/platform/syncfilerange.pyx b/src/borg/platform/syncfilerange.pyx
index f3c57ef318..6854d0d7e6 100644
--- a/src/borg/platform/syncfilerange.pyx
+++ b/src/borg/platform/syncfilerange.pyx
@@ -4,7 +4,7 @@ from libc.stdint cimport int64_t
 # Some Linux systems (like Termux on Android 7 or earlier) do not have access
 # to sync_file_range. By isolating the access to sync_file_range in this
 # separate extension, it can be imported dynamically from linux.pyx only when
-# available and systems without support can otherwise use the rest of
+# available, and systems without support can otherwise use the rest of
 # linux.pyx.
 cdef extern from "fcntl.h":
     int sync_file_range(int fd, int64_t offset, int64_t nbytes, unsigned int flags)
diff --git a/src/borg/platform/windows.pyx b/src/borg/platform/windows.pyx
index 16b3f15425..74ed8a343c 100644
--- a/src/borg/platform/windows.pyx
+++ b/src/borg/platform/windows.pyx
@@ -41,7 +41,7 @@ def group2gid(group, default=None):
 
 
 def getosusername():
-    """Return the os user name."""
+    """Return the OS username."""
     return os.getlogin()
 
 
@@ -50,7 +50,7 @@ def process_alive(host, pid, thread):
     Check whether the (host, pid, thread_id) combination corresponds to a process potentially alive.
     """
     if host.split('@')[0].lower() != platform.node().lower():
-        # Not running on the same node, assume running.
+        # If not running on the same node, assume the process is running.
         return True
 
     # If the process can be opened, the process is alive.
diff --git a/src/borg/platform/xattr.py b/src/borg/platform/xattr.py
index dae0ae6d9d..fe679bca91 100644
--- a/src/borg/platform/xattr.py
+++ b/src/borg/platform/xattr.py
@@ -15,14 +15,14 @@
 
 
 def split_string0(buf):
-    """split a list of zero-terminated strings into python not-zero-terminated bytes"""
+    """Split a list of zero-terminated byte strings into Python bytes (without zero termination)."""
     if isinstance(buf, bytearray):
-        buf = bytes(buf)  # use a bytes object, so we return a list of bytes objects
+        buf = bytes(buf)  # Use a bytes object so we return a list of bytes objects.
     return buf.split(b"\0")[:-1]
 
 
 def split_lstring(buf):
-    """split a list of length-prefixed strings into python not-length-prefixed bytes"""
+    """Split a list of length-prefixed strings into Python bytes (without length prefixes)."""
     result = []
     mv = memoryview(buf)
     while mv:
@@ -33,7 +33,7 @@ def split_lstring(buf):
 
 
 class BufferTooSmallError(Exception):
-    """the buffer given to a xattr function was too small for the result."""
+    """The buffer given to an xattr function was too small for the result."""
 
 
 def _check(rv, path=None, detect_buffer_too_small=False):
@@ -43,7 +43,7 @@ def _check(rv, path=None, detect_buffer_too_small=False):
         e = get_errno()
         if detect_buffer_too_small and e == errno.ERANGE:
             # listxattr and getxattr signal with ERANGE that they need a bigger result buffer.
-            # setxattr signals this way that e.g. a xattr key name is too long / inacceptable.
+            # setxattr signals this when, e.g., an xattr key name is too long or unacceptable.
             raise BufferTooSmallError
         else:
             try:
@@ -54,9 +54,9 @@ def _check(rv, path=None, detect_buffer_too_small=False):
                 path = "<FD %d>" % path
             raise OSError(e, msg, path)
     if detect_buffer_too_small and rv >= len(buffer):
-        # freebsd does not error with ERANGE if the buffer is too small,
-        # it just fills the buffer, truncates and returns.
-        # so, we play safe and just assume that result is truncated if
+        # FreeBSD does not error with ERANGE if the buffer is too small;
+        # it just fills the buffer, truncates, and returns.
+        # So, we play it safe and assume the result is truncated if
         # it happens to be a full buffer.
         raise BufferTooSmallError
     return rv
diff --git a/src/borg/platformflags.py b/src/borg/platformflags.py
index a4dd6d6e3f..da4e5f6feb 100644
--- a/src/borg/platformflags.py
+++ b/src/borg/platformflags.py
@@ -1,7 +1,7 @@
 """
-Flags for Platform-specific APIs.
+Flags for platform-specific APIs.
 
-Use these Flags instead of sys.platform.startswith('<OS>') or try/except.
+Use these flags instead of sys.platform.startswith('<os>') or try/except.
 """
 
 import sys
diff --git a/src/borg/repoobj.py b/src/borg/repoobj.py
index 64c054325f..4a17e8ab46 100644
--- a/src/borg/repoobj.py
+++ b/src/borg/repoobj.py
@@ -7,12 +7,12 @@
 from .helpers.errors import IntegrityError
 from .compress import Compressor, LZ4_COMPRESSOR, get_compressor
 
-# workaround for lost passphrase or key in "authenticated" or "authenticated-blake2" mode
+# Workaround for lost passphrase or key in "authenticated" or "authenticated-blake2" mode
 AUTHENTICATED_NO_KEY = "authenticated_no_key" in workarounds
 
 
 class RepoObj:
-    # Object header format includes size infos for parsing the object into meta and data,
+    # Object header format includes size information for parsing the object into meta and data,
     # as well as hashes to enable checking consistency without having the borg key.
     obj_header = Struct("<II8s8s")  # meta size (32b), data size (32b), meta hash (64b), data hash (64b)
     ObjHeader = namedtuple("ObjHeader", "meta_size data_size meta_hash data_hash")
diff --git a/src/borg/repository.py b/src/borg/repository.py
index 5f9c7cf18c..073cdfa500 100644
--- a/src/borg/repository.py
+++ b/src/borg/repository.py
@@ -33,7 +33,7 @@ def repo_lister(repository, *, limit=None):
 
 
 class Repository:
-    """borgstore based key value store"""
+    """BorgStore-based key-value store."""
 
     class AlreadyExists(Error):
         """A repository already exists at {}."""
@@ -51,17 +51,17 @@ class DoesNotExist(Error):
         exit_mcode = 13
 
     class InsufficientFreeSpaceError(Error):
-        """Insufficient free space to complete transaction (required: {}, available: {})."""
+        """Insufficient free space to complete the transaction (required: {}, available: {})."""
 
         exit_mcode = 14
 
     class InvalidRepository(Error):
-        """{} is not a valid repository. Check repo config."""
+        """{} is not a valid repository. Check the repository configuration."""
 
         exit_mcode = 15
 
     class InvalidRepositoryConfig(Error):
-        """{} does not have a valid configuration. Check repo config [{}]."""
+        """{} does not have a valid configuration. Check the repository configuration [{}]."""
 
         exit_mcode = 16
 
@@ -76,7 +76,7 @@ def __init__(self, id, repo):
             super().__init__(id, repo)
 
     class ParentPathDoesNotExist(Error):
-        """The parent path of the repo directory [{}] does not exist."""
+        """The parent path of the repository directory [{}] does not exist."""
 
         exit_mcode = 18
 
diff --git a/src/borg/selftest.py b/src/borg/selftest.py
index 3a08d5be87..72f3926d25 100644
--- a/src/borg/selftest.py
+++ b/src/borg/selftest.py
@@ -2,18 +2,17 @@
 #       See borg.selftest for details. If you add/remove test methods, update SELFTEST_COUNT
 
 """
-Self testing module
+Self-testing module
 ===================
 
 The selftest() function runs a small test suite of relatively fast tests that are meant to discover issues
-with the way Borg was compiled or packaged and also bugs in Borg itself.
+with how Borg was compiled or packaged, as well as bugs in Borg itself.
 
-These tests are a subset of the borg/testsuite and are run with Pythons built-in unittest, hence none of
-the tests used for this can or should be ported to py.test currently.
+These tests are a subset of borg/testsuite and are run with Python's built-in unittest; therefore none of
+these tests can or should be ported to pytest at this time.
 
-To assert that self test discovery works correctly the number of tests is kept in the SELFTEST_COUNT
-variable. SELFTEST_COUNT must be updated if new tests are added or removed to or from any of the tests
-used here.
+To ensure that self-test discovery works correctly, the expected number of tests is stored in
+SELFTEST_COUNT. Update SELFTEST_COUNT whenever tests used here are added or removed.
 """
 
 import os
@@ -44,9 +43,9 @@ def test_name(self, test):
 
     def log_results(self, logger):
         for test, failure in self.errors + self.failures + self.unexpectedSuccesses:
-            logger.error("self test %s FAILED:\n%s", self.test_name(test), failure)
+            logger.error("self-test %s FAILED:\n%s", self.test_name(test), failure)
         for test, reason in self.skipped:
-            logger.warning("self test %s skipped: %s", self.test_name(test), reason)
+            logger.warning("self-test %s skipped: %s", self.test_name(test), reason)
 
     def successful_test_count(self):
         return len(self.successes)
@@ -54,7 +53,7 @@ def successful_test_count(self):
 
 def selftest(logger):
     if os.environ.get("BORG_SELFTEST") == "disabled":
-        logger.debug("borg selftest disabled via BORG_SELFTEST env variable")
+        logger.debug("Borg self-test disabled via BORG_SELFTEST environment variable")
         return
     selftest_started = time.perf_counter()
     result = SelfTestResult()
@@ -72,17 +71,17 @@ def selftest(logger):
     if result.wasSuccessful() and count_mismatch:
         # only print this if all tests succeeded
         logger.error(
-            "self test count (%d != %d) mismatch, either test discovery is broken or a test was added "
+            "Self-test count (%d != %d) mismatch; either test discovery is broken, or a test was added "
             "without updating borg.selftest",
             successful_tests,
             SELFTEST_COUNT,
         )
     if not result.wasSuccessful() or count_mismatch:
         logger.error(
-            "self test failed\n"
-            "Could be a bug either in Borg, the package / distribution you use, your OS or your hardware."
+            "Self-test failed.\n"
+            "This could be a bug in Borg, the package/distribution you use, your OS, or your hardware."
         )
         sys.exit(2)
         assert False, "sanity assertion failed: ran beyond sys.exit()"
     selftest_elapsed = time.perf_counter() - selftest_started
-    logger.debug("%d self tests completed in %.2f seconds", successful_tests, selftest_elapsed)
+    logger.debug("%d self-tests completed in %.2f seconds", successful_tests, selftest_elapsed)
diff --git a/src/borg/storelocking.py b/src/borg/storelocking.py
index af48e82ab8..850e438539 100644
--- a/src/borg/storelocking.py
+++ b/src/borg/storelocking.py
@@ -51,18 +51,19 @@ class NotMyLock(LockErrorT):
 
 class Lock:
     """
-    A Lock for a resource that can be accessed in a shared or exclusive way.
-    Typically, write access to a resource needs an exclusive lock (1 writer,
-    no one is allowed reading) and read access to a resource needs a shared
-    lock (multiple readers are allowed).
+    A lock for a resource that can be accessed in a shared or exclusive way.
 
-    If possible, try to use the contextmanager here like::
+    Typically, write access to a resource needs an exclusive lock (one writer,
+    no readers allowed), and read access to a resource needs a shared lock
+    (multiple readers are allowed).
+
+    If possible, use the context manager form::
 
         with Lock(...) as lock:
             ...
 
-    This makes sure the lock is released again if the block is left, no
-    matter how (e.g. if an exception occurred).
+    This ensures the lock is released when the block is exited, no matter how
+    (e.g., if an exception occurs).
     """
 
     def __init__(self, store, exclusive=False, sleep=None, timeout=1.0, stale=30 * 60, id=None):
@@ -79,7 +80,7 @@ def __init__(self, store, exclusive=False, sleep=None, timeout=1.0, stale=30 * 6
         self.last_refresh_dt = None
         self.id = id or platform.get_process_id()
         assert len(self.id) == 3
-        logger.debug(f"LOCK-INIT: initialising. store: {store}, stale: {stale}s, refresh: {stale // 2}s.")
+        logger.debug(f"LOCK-INIT: initializing. store: {store}, stale: {stale}s, refresh: {stale // 2}s.")
 
     def __enter__(self):
         return self.acquire()
@@ -103,7 +104,7 @@ def _create_lock(self, *, exclusive=None, update_last_refresh=False):
         logger.debug(f"LOCK-CREATE: creating lock in store. key: {key}, lock: {lock}.")
         self.store.store(f"locks/{key}", value)
         if update_last_refresh:
-            # we parse the timestamp str to get *precisely* the datetime in the lock:
+            # we parse the timestamp string to get *precisely* the datetime in the lock:
             self.last_refresh_dt = datetime.datetime.fromisoformat(timestamp)
         return key
 
@@ -127,7 +128,7 @@ def _is_stale_lock(self, lock):
             logger.debug(f"LOCK-STALE: lock is too old, it was not refreshed. lock: {lock}.")
             return True
         if not platform.process_alive(lock["hostid"], lock["processid"], lock["threadid"]):
-            logger.debug(f"LOCK-STALE: we KNOW that the lock owning process is dead. lock: {lock}.")
+            logger.debug(f"LOCK-STALE: we KNOW that the lock-owning process is dead. lock: {lock}.")
             return True
         return False
 
@@ -212,7 +213,7 @@ def release(self, *, ignore_not_found=False):
         locks = self._find_locks(only_mine=True)
         if not locks:
             if ignore_not_found:
-                logger.debug("LOCK-RELEASE: trying to release lock, but none was found.")
+                logger.debug("LOCK-RELEASE: trying to release a lock, but none was found.")
                 return
             else:
                 raise NotLocked(str(self.store))
@@ -226,7 +227,7 @@ def got_exclusive_lock(self):
         return len(locks) == 1
 
     def break_lock(self):
-        """break ALL locks (not just ours)"""
+        """Breaks all locks (not just ours)."""
         logger.debug("LOCK-BREAK: break_lock() was called - deleting ALL locks!")
         locks = self._get_locks()
         for key in locks:
@@ -234,7 +235,7 @@ def break_lock(self):
         self.last_refresh_dt = None
 
     def migrate_lock(self, old_id, new_id):
-        """migrate the lock ownership from old_id to new_id"""
+        """Migrates the lock ownership from old_id to new_id."""
         logger.debug(f"LOCK-MIGRATE: {old_id} -> {new_id}.")
         assert self.id == old_id
         assert len(new_id) == 3
@@ -245,7 +246,7 @@ def migrate_lock(self, old_id, new_id):
         self._delete_lock(old_locks[0]["key"], update_last_refresh=False)
 
     def refresh(self):
-        """refresh the lock - call this frequently, but not later than every <stale> seconds"""
+        """Refreshes the lock—call this frequently, but not later than every <stale> seconds."""
         now = datetime.datetime.now(datetime.timezone.utc)
         if self.last_refresh_dt is not None and now > self.last_refresh_dt + self.refresh_td:
             old_locks = self._find_locks(only_mine=True)
diff --git a/src/borg/testsuite/__init__.py b/src/borg/testsuite/__init__.py
index 7e7d476002..4cc27f0f27 100644
--- a/src/borg/testsuite/__init__.py
+++ b/src/borg/testsuite/__init__.py
@@ -46,7 +46,7 @@
 
 
 def same_ts_ns(ts_ns1, ts_ns2):
-    """compare 2 timestamps (both in nanoseconds) whether they are (roughly) equal"""
+    """Compare two timestamps (both in nanoseconds) to determine whether they are (roughly) equal."""
     diff_ts = int(abs(ts_ns1 - ts_ns2))
     diff_max = 10 ** (-st_mtime_ns_round)
     return diff_ts <= diff_max
@@ -85,7 +85,7 @@ def changedir(dir):
 
 
 def is_root():
-    """return True if running with high privileges, like as root"""
+    """Return True if running with high privileges (e.g., as root)."""
     if is_win32:
         return False  # TODO
     else:
diff --git a/src/borg/testsuite/archive_test.py b/src/borg/testsuite/archive_test.py
index 1157994d7d..a44d26f5ea 100644
--- a/src/borg/testsuite/archive_test.py
+++ b/src/borg/testsuite/archive_test.py
@@ -247,7 +247,7 @@ def test_invalid_msgpacked_item(packed, item_keys_serialized):
     assert not valid_msgpacked_dict(packed, item_keys_serialized)
 
 
-# pytest-xdist requires always same order for the keys and dicts:
+# pytest-xdist requires the same order for the keys and dicts:
 IK = sorted(list(ITEM_KEYS))
 
 
@@ -309,7 +309,7 @@ def test_get_item_uid_gid():
         puid, pgid = 0, 0
     puser, pgroup = uid2user(puid), gid2group(pgid)
 
-    # this is intentionally a "strange" item, with not matching ids/names.
+    # This is intentionally a "strange" item, with non-matching IDs/names.
     item = Item(path="filename", uid=1, gid=2, user=puser, group=pgroup)
 
     uid, gid = get_item_uid_gid(item, numeric=False)
@@ -354,8 +354,8 @@ def test_get_item_uid_gid():
     assert gid == 8
 
     if not is_win32:
-        # due to the hack in borg.platform.windows user2uid / group2gid, these always return 0
-        # (no matter which username we ask for) and they never raise a KeyError (like e.g. for
+        # Due to the hack in borg.platform.windows, user2uid/group2gid always return 0
+        # (no matter which username we ask for), and they never raise a KeyError (e.g., for
         # a non-existing user/group name). Thus, these tests can currently not succeed on win32.
 
         # item metadata has valid uid/gid, but non-existing user/group names.
@@ -375,7 +375,7 @@ def test_get_item_uid_gid():
     item = Item(path="filename", uid=13, gid=14)
 
     uid, gid = get_item_uid_gid(item, numeric=False)
-    # it'll check user/group first, but as there is nothing in the item, falls back to uid/gid.
+    # It will check user/group first, but as there is nothing in the item, it falls back to uid/gid.
     assert uid == 13
     assert gid == 14
 
@@ -388,12 +388,12 @@ def test_get_item_uid_gid():
     item = Item(path="filename")
 
     uid, gid = get_item_uid_gid(item, numeric=False, uid_default=15)
-    # as there is nothing, it'll fall back to uid_default/gid_default.
+    # As there is nothing, it will fall back to uid_default/gid_default.
     assert uid == 15
     assert gid == 0
 
     uid, gid = get_item_uid_gid(item, numeric=True, gid_default=16)
-    # as there is nothing, it'll fall back to uid_default/gid_default.
+    # As there is nothing, it will fall back to uid_default/gid_default.
     assert uid == 0
     assert gid == 16
 
diff --git a/src/borg/testsuite/archiver/__init__.py b/src/borg/testsuite/archiver/__init__.py
index 0a5073f9e1..02dbd2a49d 100644
--- a/src/borg/testsuite/archiver/__init__.py
+++ b/src/borg/testsuite/archiver/__init__.py
@@ -35,7 +35,7 @@
 RK_ENCRYPTION = "--encryption=repokey-aes-ocb"
 KF_ENCRYPTION = "--encryption=keyfile-chacha20-poly1305"
 
-# this points to src/borg/archiver directory (which is small and has only a few files)
+# This points to src/borg/archiver (small, with only a few files).
 src_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "archiver"))
 src_file = "archiver/__init__.py"  # relative path of one file in src_dir
 
@@ -77,9 +77,9 @@ def exec_cmd(*args, archiver=None, fork=False, exe=None, input=b"", binary_outpu
             init_ec_warnings()
             try:
                 args = archiver.parse_args(list(args))
-                # argparse parsing may raise SystemExit when the command line is bad or
-                # actions that abort early (eg. --help) where given. Catch this and return
-                # the error code as-if we invoked a Borg binary.
+                # argparse may raise SystemExit when the command line is bad or
+                # actions that abort early (e.g., --help) were given. Catch this and return
+                # the error code as if we invoked a Borg binary.
             except SystemExit as e:
                 output_text.flush()
                 return e.code, output.getvalue() if binary_output else output.getvalue().decode()
@@ -93,7 +93,7 @@ def exec_cmd(*args, archiver=None, fork=False, exe=None, input=b"", binary_outpu
             sys.stdin, sys.stdout, sys.stderr = stdin, stdout, stderr
 
 
-# check if the binary "borg.exe" is available (for local testing a symlink to virtualenv/bin/borg should do)
+# Check whether the binary "borg.exe" is available (for local testing, a symlink to virtualenv/bin/borg will do).
 try:
     exec_cmd("help", exe="borg.exe", fork=True)
     BORG_EXES = ["python", "binary"]
@@ -108,7 +108,7 @@ def cmd_fixture(request):
     elif request.param == "binary":
         exe = "borg.exe"
     else:
-        raise ValueError("param must be 'python' or 'binary'")
+        raise ValueError("Parameter must be 'python' or 'binary'.")
 
     def exec_fn(*args, **kw):
         return exec_cmd(*args, exe=exe, fork=True, **kw)
@@ -134,7 +134,7 @@ def generate_archiver_tests(metafunc, kinds: str):
 
 
 def checkts(ts):
-    # check if the timestamp is in the expected format
+    # Check whether the timestamp is in the expected format
     assert datetime.strptime(ts, ISO_FORMAT + "%z")  # must not raise
 
 
@@ -210,18 +210,18 @@ def create_test_files(input_path, create_hardlinks=True):
     create_regular_file(input_path, "fusexattr", size=1)
     if not xattr.XATTR_FAKEROOT and xattr.is_enabled(input_path):
         fn = os.fsencode(os.path.join(input_path, "fusexattr"))
-        # ironically, due to the way how fakeroot works, comparing FUSE file xattrs to orig file xattrs
+        # Ironically, due to how fakeroot works, comparing FUSE file xattrs to original file xattrs
         # will FAIL if fakeroot supports xattrs, thus we only set the xattr if XATTR_FAKEROOT is False.
         # This is because fakeroot with xattr-support does not propagate xattrs of the underlying file
         # into "fakeroot space". Because the xattrs exposed by borgfs are these of an underlying file
-        # (from fakeroots point of view) they are invisible to the test process inside the fakeroot.
+        # (from fakeroot's point of view) they are invisible to the test process inside fakeroot.
         xattr.setxattr(fn, b"user.foo", b"bar")
         xattr.setxattr(fn, b"user.empty", b"")
         # XXX this always fails for me
         # ubuntu 14.04, on a TMP dir filesystem with user_xattr, using fakeroot
         # same for newer ubuntu and centos.
-        # if this is supported just on specific platform, platform should be checked first,
-        # so that the test setup for all tests using it does not fail here always for others.
+        # If this is supported only on specific platforms, the platform should be checked first,
+        # so that the test setup for all tests using it does not always fail for others.
     # FIFO node
     if are_fifos_supported():
         os.mkfifo(os.path.join(input_path, "fifo1"))
@@ -392,8 +392,8 @@ def _assert_dirs_equal_cmp(diff, ignore_flags=False, ignore_xattrs=False, ignore
             d1[4] = None
         if not stat.S_ISCHR(s2.st_mode) and not stat.S_ISBLK(s2.st_mode):
             d2[4] = None
-        # If utime isn't fully supported, borg can't set mtime.
-        # Therefore, we shouldn't test it in that case.
+        # If utime is not fully supported, Borg cannot set mtime.
+        # Therefore, we should not test it in that case.
         if is_utime_fully_supported():
             # Older versions of llfuse do not support ns precision properly
             if ignore_ns:
@@ -473,7 +473,7 @@ def fuse_mount(archiver, mountpoint=None, *options, fork=True, os_fork=False, **
     # `FORK_DEFAULT`. However, leaving the possibility to run
     # the command with `fork = False` is still necessary for
     # testing for mount failures, for example attempting to
-    # mount a read-only repo.
+    # mount a read-only repository.
     #    `os_fork = True` is needed for testing (the absence of)
     # a race condition of the Lock during lock migration when
     # borg mount (local repo) is daemonizing (#4953). This is another
diff --git a/src/borg/testsuite/archiver/argparsing_test.py b/src/borg/testsuite/archiver/argparsing_test.py
index 3a3c5780e1..974becf332 100644
--- a/src/borg/testsuite/archiver/argparsing_test.py
+++ b/src/borg/testsuite/archiver/argparsing_test.py
@@ -15,7 +15,7 @@ def test_highlander(archiver):
     cmd(archiver, "create", "--comment", "comment 1", "test-1", __file__)
     error_msg = "There can be only one"
     # Default umask value is 0077
-    # Test that it works with a one time specified default or custom value
+    # Test that it works with a one-time specified default or custom value
     output_default = cmd(archiver, "--umask", "0077", "repo-list")
     assert error_msg not in output_default
     output_custom = cmd(archiver, "--umask", "0007", "repo-list")
diff --git a/src/borg/testsuite/archiver/check_cmd_test.py b/src/borg/testsuite/archiver/check_cmd_test.py
index bf851ecf9e..3554a14165 100644
--- a/src/borg/testsuite/archiver/check_cmd_test.py
+++ b/src/borg/testsuite/archiver/check_cmd_test.py
@@ -133,7 +133,7 @@ def test_date_matching(archivers, request):
     assert "archive-2022-12-18" in output
     assert "archive-now" not in output
 
-    # check for output when timespan older than the earliest archive is given. Issue #1711
+    # Check for output when a time span older than the earliest archive is given. Issue #1711
     output = cmd(archiver, "check", "-v", "--archives-only", "--older=9999m", exit_code=0)
     for archive in ("archive1", "archive2", "archive3"):
         assert archive not in output
diff --git a/src/borg/testsuite/archiver/corruption_test.py b/src/borg/testsuite/archiver/corruption_test.py
index 37d2745e54..bb093a42b3 100644
--- a/src/borg/testsuite/archiver/corruption_test.py
+++ b/src/borg/testsuite/archiver/corruption_test.py
@@ -18,7 +18,7 @@ def corrupt_archiver(archiver):
 def test_old_version_interfered(archiver):
     corrupt_archiver(archiver)
     if archiver.cache_path is None:
-        pytest.skip("no cache path for this kind of Cache implementation")
+        pytest.skip("No cache path for this kind of cache implementation.")
 
     # Modify the main manifest ID without touching the manifest ID in the integrity section.
     # This happens if a version without integrity checking modifies the cache.
diff --git a/src/borg/testsuite/archiver/create_cmd_test.py b/src/borg/testsuite/archiver/create_cmd_test.py
index ee7e08ec3c..0bda3810f5 100644
--- a/src/borg/testsuite/archiver/create_cmd_test.py
+++ b/src/borg/testsuite/archiver/create_cmd_test.py
@@ -52,7 +52,7 @@ def test_basic_functionality(archivers, request):
     if archiver.EXE:
         pytest.skip("test_basic_functionality seems incompatible with fakeroot and/or the binary.")
     have_root = create_test_files(archiver.input_path)
-    # fork required to test show-rc output
+    # Fork required to test --show-rc output.
     output = cmd(archiver, "repo-create", RK_ENCRYPTION, "--show-version", "--show-rc", fork=True)
     assert "borgbackup version" in output
     assert "terminating with success status, rc 0" in output
@@ -85,7 +85,7 @@ def test_basic_functionality(archivers, request):
     if are_hardlinks_supported():
         expected.append("input/hardlink")
     if not have_root:
-        # we could not create these device files without (fake)root
+        # We could not create these device files without (fake) root.
         expected.remove("input/bdev")
         expected.remove("input/cdev")
     if has_lchflags:
@@ -105,7 +105,7 @@ def test_basic_functionality(archivers, request):
     info_output2 = cmd(archiver, "info", "-a", "test")
 
     def filter(output):
-        # filter for interesting "info" output, ignore cache rebuilding related stuff
+        # Filter for interesting 'info' output; ignore cache-rebuilding related messages.
         prefixes = ["Name:", "Fingerprint:", "Number of files:", "This archive:", "All archives:", "Chunk index:"]
         result = []
         for line in output.splitlines():
@@ -114,15 +114,15 @@ def filter(output):
                     result.append(line)
         return "\n".join(result)
 
-    # the interesting parts of info_output2 and info_output should be same
+    # The interesting parts of info_output2 and info_output should be the same.
     assert filter(info_output) == filter(info_output2)
 
 
 def test_archived_paths(archivers, request):
-    # As borg comes from the POSIX (Linux, UNIX) world, a lot of stuff assumes path separators
-    # to be slashes "/", e.g.: in archived items, for pattern matching.
-    # To make our lives easier and to support cross-platform extraction we always use slashes.
-    # Similarly, archived paths are expected to be full, but relative (have no leading slash).
+    # As Borg comes from the POSIX (Linux/UNIX) world, much assumes path separators
+    # to be slashes "/", e.g., in archived items or for pattern matching.
+    # To make our lives easier and to support cross-platform extraction, we always use slashes.
+    # Similarly, archived paths are expected to be full but relative (have no leading slash).
     archiver = request.getfixturevalue(archivers)
     full_path = os.path.abspath(os.path.join(archiver.input_path, "test"))
     # remove windows drive letter, if any:
diff --git a/src/borg/testsuite/archiver/debug_cmds_test.py b/src/borg/testsuite/archiver/debug_cmds_test.py
index dcb9acfaaa..811970f567 100644
--- a/src/borg/testsuite/archiver/debug_cmds_test.py
+++ b/src/borg/testsuite/archiver/debug_cmds_test.py
@@ -79,7 +79,7 @@ def test_debug_put_get_delete_obj(archivers, request):
 
 
 def test_debug_id_hash_format_put_get_parse_obj(archivers, request):
-    """Test format-obj and parse-obj commands"""
+    """Test format-obj and parse-obj commands."""
     archiver = request.getfixturevalue(archivers)
     cmd(archiver, "repo-create", RK_ENCRYPTION)
     data = b"some data" * 100
diff --git a/src/borg/testsuite/archiver/disk_full_test.py b/src/borg/testsuite/archiver/disk_full_test.py
index dd37edc3ff..f03695b94d 100644
--- a/src/borg/testsuite/archiver/disk_full_test.py
+++ b/src/borg/testsuite/archiver/disk_full_test.py
@@ -1,18 +1,18 @@
 """
-test_disk_full is very slow and not recommended to be included in daily testing.
-for this test, an empty, writable 700MB filesystem mounted on DF_MOUNT is required.
-for speed and other reasons, it is recommended that the underlying block device is
+Test "disk full" is very slow and not recommended for daily test runs.
+For this test, an empty, writable 700 MB filesystem mounted on DF_MOUNT is required.
+For speed and other reasons, it is recommended that the underlying block device is
 in RAM, not a magnetic or flash disk.
 
-assuming /dev/shm is a tmpfs (in memory filesystem), one can use this:
+Assuming /dev/shm is a tmpfs (in-memory filesystem), one can use this:
 
-dd if=/dev/zero of=/dev/shm/borg-disk bs=1M count=700
-mkfs.ext4 /dev/shm/borg-disk
-mkdir /tmp/borg-mount
-sudo mount /dev/shm/borg-disk /tmp/borg-mount
-sudo chown myuser /tmp/borg-mount/
+    dd if=/dev/zero of=/dev/shm/borg-disk bs=1M count=700
+    mkfs.ext4 /dev/shm/borg-disk
+    mkdir /tmp/borg-mount
+    sudo mount /dev/shm/borg-disk /tmp/borg-mount
+    sudo chown myuser /tmp/borg-mount/
 
-if the directory does not exist, the test will be skipped.
+If the directory does not exist, the test will be skipped.
 """
 
 import errno
diff --git a/src/borg/testsuite/archiver/extract_cmd_test.py b/src/borg/testsuite/archiver/extract_cmd_test.py
index 1505d88606..0ae3dd94af 100644
--- a/src/borg/testsuite/archiver/extract_cmd_test.py
+++ b/src/borg/testsuite/archiver/extract_cmd_test.py
@@ -76,13 +76,13 @@ def test_directory_timestamps1(archivers, request):
     archiver = request.getfixturevalue(archivers)
     create_test_files(archiver.input_path)
     cmd(archiver, "repo-create", RK_ENCRYPTION)
-    # default file archiving order (internal recursion)
+    # Default file archiving order (internal recursion)
     cmd(archiver, "create", "test", "input")
     with changedir("output"):
         cmd(archiver, "extract", "test")
-    # extracting a file inside a directory touches the directory mtime
+    # Extracting a file inside a directory touches the directory mtime
     assert os.path.exists("output/input/dir2/file2")
-    # make sure borg fixes the directory mtime after touching it
+    # Make sure Borg fixes the directory mtime after touching it
     sti = os.stat("input/dir2")
     sto = os.stat("output/input/dir2")
     assert same_ts_ns(sti.st_mtime_ns, sto.st_mtime_ns)
@@ -93,14 +93,14 @@ def test_directory_timestamps2(archivers, request):
     archiver = request.getfixturevalue(archivers)
     create_test_files(archiver.input_path)
     cmd(archiver, "repo-create", RK_ENCRYPTION)
-    # given order, dir first, file second
+    # Given order, directory first, file second
     flist_dir_first = b"input/dir2\ninput/dir2/file2\n"
     cmd(archiver, "create", "--paths-from-stdin", "test", input=flist_dir_first)
     with changedir("output"):
         cmd(archiver, "extract", "test")
-    # extracting a file inside a directory touches the directory mtime
+    # Extracting a file inside a directory touches the directory mtime
     assert os.path.exists("output/input/dir2/file2")
-    # make sure borg fixes the directory mtime after touching it
+    # Make sure Borg fixes the directory mtime after touching it
     sti = os.stat("input/dir2")
     sto = os.stat("output/input/dir2")
     assert same_ts_ns(sti.st_mtime_ns, sto.st_mtime_ns)
@@ -111,14 +111,14 @@ def test_directory_timestamps3(archivers, request):
     archiver = request.getfixturevalue(archivers)
     create_test_files(archiver.input_path)
     cmd(archiver, "repo-create", RK_ENCRYPTION)
-    # given order, file first, dir second
+    # Given order, file first, directory second
     flist_file_first = b"input/dir2/file2\ninput/dir2\n"
     cmd(archiver, "create", "--paths-from-stdin", "test", input=flist_file_first)
     with changedir("output"):
         cmd(archiver, "extract", "test")
-    # extracting a file inside a directory touches the directory mtime
+    # Extracting a file inside a directory touches the directory mtime
     assert os.path.exists("output/input/dir2/file2")
-    # make sure borg fixes the directory mtime after touching it
+    # Make sure Borg fixes the directory mtime after touching it
     sti = os.stat("input/dir2")
     sto = os.stat("output/input/dir2")
     assert same_ts_ns(sti.st_mtime_ns, sto.st_mtime_ns)
diff --git a/src/borg/testsuite/archiver/info_cmd_test.py b/src/borg/testsuite/archiver/info_cmd_test.py
index d41f801c6e..550bd8d71b 100644
--- a/src/borg/testsuite/archiver/info_cmd_test.py
+++ b/src/borg/testsuite/archiver/info_cmd_test.py
@@ -39,7 +39,7 @@ def test_info_json(archivers, request):
 
 
 def test_info_json_of_empty_archive(archivers, request):
-    """See https://github.com/borgbackup/borg/issues/6120"""
+    """See https://github.com/borgbackup/borg/issues/6120."""
     archiver = request.getfixturevalue(archivers)
     cmd(archiver, "repo-create", RK_ENCRYPTION)
     info_repo = json.loads(cmd(archiver, "info", "--json", "--first=1"))
diff --git a/src/borg/testsuite/archiver/key_cmds_test.py b/src/borg/testsuite/archiver/key_cmds_test.py
index 173d92a1f7..72f45fb60d 100644
--- a/src/borg/testsuite/archiver/key_cmds_test.py
+++ b/src/borg/testsuite/archiver/key_cmds_test.py
@@ -20,7 +20,7 @@ def test_change_passphrase(archivers, request):
     archiver = request.getfixturevalue(archivers)
     cmd(archiver, "repo-create", RK_ENCRYPTION)
     os.environ["BORG_NEW_PASSPHRASE"] = "newpassphrase"
-    # here we have both BORG_PASSPHRASE and BORG_NEW_PASSPHRASE set:
+    # Here we have both BORG_PASSPHRASE and BORG_NEW_PASSPHRASE set:
     cmd(archiver, "key", "change-passphrase")
     os.environ["BORG_PASSPHRASE"] = "newpassphrase"
     cmd(archiver, "repo-list")
diff --git a/src/borg/testsuite/archiver/lock_cmds_test.py b/src/borg/testsuite/archiver/lock_cmds_test.py
index f42c089af3..139fb0770c 100644
--- a/src/borg/testsuite/archiver/lock_cmds_test.py
+++ b/src/borg/testsuite/archiver/lock_cmds_test.py
@@ -20,7 +20,7 @@ def test_with_lock(tmp_path):
     env = os.environ.copy()
     env["BORG_REPO"] = "file://" + str(repo_path)
     command0 = "python3", "-m", "borg", "repo-create", "--encryption=none"
-    # timings must be adjusted so that command1 keeps running while command2 tries to get the lock,
+    # Timings must be adjusted so that command1 keeps running while command2 tries to get the lock,
     # so that lock acquisition for command2 fails as the test expects it.
     lock_wait, execution_time, startup_wait = 2, 4, 1
     assert lock_wait < execution_time - startup_wait
@@ -31,8 +31,8 @@ def test_with_lock(tmp_path):
     subprocess.run(command0, env=env, check=True, text=True, capture_output=True)
     assert repo_path.exists()
     with subprocess.Popen([*borgwl, *command1], **popen_options) as p1:
-        time.sleep(startup_wait)  # wait until p1 is running
-        # now try to get another lock on the same repository:
+        time.sleep(startup_wait)  # Wait until p1 is running
+        # Now try to acquire another lock on the same repository:
         with subprocess.Popen([*borgwl, *command2], **popen_options) as p2:
             out, err_out = p2.communicate()
             assert "second command" not in out  # command2 is "locked out"
diff --git a/src/borg/testsuite/archiver/prune_cmd_test.py b/src/borg/testsuite/archiver/prune_cmd_test.py
index 9dda19a0b5..a18212c85e 100644
--- a/src/borg/testsuite/archiver/prune_cmd_test.py
+++ b/src/borg/testsuite/archiver/prune_cmd_test.py
@@ -29,7 +29,7 @@ def test_prune_repository(archivers, request):
     cmd(archiver, "create", "test2", src_dir)
     output = cmd(archiver, "prune", "--list", "--dry-run", "--keep-daily=1")
     assert re.search(r"Would prune:\s+test1", output)
-    # must keep the latest archive:
+    # Must keep the latest archive:
     assert re.search(r"Keeping archive \(rule: daily #1\):\s+test2", output)
     output = cmd(archiver, "repo-list")
     assert "test1" in output
@@ -37,7 +37,7 @@ def test_prune_repository(archivers, request):
     cmd(archiver, "prune", "--keep-daily=1")
     output = cmd(archiver, "repo-list")
     assert "test1" not in output
-    # the latest archive must be still there:
+    # The latest archive must still be there:
     assert "test2" in output
 
 
@@ -105,13 +105,13 @@ def test_prune_repository_example(archivers, request):
 
 
 def test_prune_quarterly(archivers, request):
-    # Example worked through by hand when developing quarterly
-    # strategy, based upon existing backups where quarterly strategy
-    # is desired. Weekly/monthly backups that don't affect results were
+    # Example worked through by hand when developing the quarterly
+    # strategy, based on existing backups where the quarterly strategy
+    # is desired. Weekly/monthly backups that do not affect results were
     # trimmed to speed up the test.
     #
-    # Week number is shown in comment for every row in the below list.
-    # Year is also shown when it doesn't match the year given in the
+    # The ISO week number is shown in a comment for each row in the list below.
+    # The year is also shown when it does not match the year given in the
     # date tuple.
     archiver = request.getfixturevalue(archivers)
     test_dates = [
diff --git a/src/borg/testsuite/archiver/repo_compress_cmd_test.py b/src/borg/testsuite/archiver/repo_compress_cmd_test.py
index b18763b41a..67a34ef55d 100644
--- a/src/borg/testsuite/archiver/repo_compress_cmd_test.py
+++ b/src/borg/testsuite/archiver/repo_compress_cmd_test.py
@@ -11,7 +11,7 @@
 
 def test_repo_compress(archiver):
     def check_compression(ctype, clevel, olevel):
-        """check if all the chunks in the repo are compressed/obfuscated like expected"""
+        """Check that all chunks in the repo are compressed/obfuscated as expected."""
         repository = Repository(archiver.repository_path, exclusive=True)
         with repository:
             manifest = Manifest.load(repository, Manifest.NO_OPERATION_CHECK)
@@ -26,7 +26,7 @@ def check_compression(ctype, clevel, olevel):
                 # this is not as easy as one thinks due to the DecidingCompressor choosing the smallest of
                 # (desired compressed, lz4 compressed, not compressed).
                 assert meta["ctype"] in (ctype, LZ4.ID, CNONE.ID)
-                assert meta["clevel"] in (clevel, 255)  # LZ4 and CNONE has level 255
+                assert meta["clevel"] in (clevel, 255)  # LZ4 and CNONE have level 255
                 if olevel != -1:  # we expect obfuscation
                     assert "psize" in meta
                     assert m_olevel == olevel
diff --git a/src/borg/testsuite/archiver/repo_delete_cmd_test.py b/src/borg/testsuite/archiver/repo_delete_cmd_test.py
index 539e268f83..1a3d1ffb72 100644
--- a/src/borg/testsuite/archiver/repo_delete_cmd_test.py
+++ b/src/borg/testsuite/archiver/repo_delete_cmd_test.py
@@ -26,5 +26,5 @@ def test_delete_repo(archivers, request):
     assert os.path.exists(archiver.repository_path)
     os.environ["BORG_DELETE_I_KNOW_WHAT_I_AM_DOING"] = "YES"
     cmd(archiver, "repo-delete")
-    # Make sure the repo is gone
+    # Make sure the repository is gone
     assert not os.path.exists(archiver.repository_path)
diff --git a/src/borg/testsuite/archiver/repo_list_cmd_test.py b/src/borg/testsuite/archiver/repo_list_cmd_test.py
index 6f8d02565f..04071abff0 100644
--- a/src/borg/testsuite/archiver/repo_list_cmd_test.py
+++ b/src/borg/testsuite/archiver/repo_list_cmd_test.py
@@ -51,7 +51,7 @@ def test_size_nfiles(archivers, request):
     o_t = output.split()
     assert o_t[0] == "test"
     assert int(o_t[1]) == 2
-    assert 123456 <= int(o_t[2]) < 123999  # there is some metadata overhead
+    assert 123456 <= int(o_t[2]) < 123999  # There is some metadata overhead
 
 
 def test_date_matching(archivers, request):
diff --git a/src/borg/testsuite/archiver/repo_space_cmd_test.py b/src/borg/testsuite/archiver/repo_space_cmd_test.py
index 83498cb887..d92069a1aa 100644
--- a/src/borg/testsuite/archiver/repo_space_cmd_test.py
+++ b/src/borg/testsuite/archiver/repo_space_cmd_test.py
@@ -15,8 +15,8 @@ def test_repo_space_basics(archivers, request):
 
     # Test reserving some space.
     output = cmd(archiver, "repo-space", "--reserve", "100M")
-    # The actual size will be rounded up to a multiple of 64MiB blocks.
-    # For 100MB, it should be 128MiB (2 blocks) == 134.22MB.
+    # The actual size will be rounded up to a multiple of 64 MiB blocks.
+    # For 100 MB, it should be 128 MiB (2 blocks) == 134.22 MB.
     assert "There is 134.22 MB reserved space in this repository now." in output
 
     # Check that space is reserved.
@@ -25,7 +25,7 @@ def test_repo_space_basics(archivers, request):
 
     # Test freeing the space.
     output = cmd(archiver, "repo-space", "--free")
-    assert "Freed 134.22 MB in repository." in output
+    assert "Freed 134.22 MB in the repository." in output
 
     # Check that no space is reserved.
     output = cmd(archiver, "repo-space")
@@ -52,9 +52,9 @@ def test_repo_space_modify_reservation(archivers, request):
     output = cmd(archiver, "repo-space")
     assert "There is 134.22 MB reserved space in this repository." in output
 
-    # note: --reserve can only INCREASE the amount of reserved space.
+    # Note: --reserve can only INCREASE the amount of reserved space.
 
-    cmd(archiver, "repo-space", "--free")  # save space on TMPDIR
+    cmd(archiver, "repo-space", "--free")  # save space in TMPDIR
 
 
 def test_repo_space_edge_cases(archivers, request):
@@ -70,7 +70,7 @@ def test_repo_space_edge_cases(archivers, request):
 
     # Test freeing when no space is reserved.
     output = cmd(archiver, "repo-space", "--free")
-    assert "Freed 0 B in repository." in output
+    assert "Freed 0 B in the repository." in output
 
     # Test reserving a very small amount of space (1KB).
     # This should round up to at least one 64MiB block.
diff --git a/src/borg/testsuite/archiver/restricted_permissions_test.py b/src/borg/testsuite/archiver/restricted_permissions_test.py
index b3eb4121df..1ce8c3c87c 100644
--- a/src/borg/testsuite/archiver/restricted_permissions_test.py
+++ b/src/borg/testsuite/archiver/restricted_permissions_test.py
@@ -11,7 +11,7 @@
 
 
 def test_repository_permissions_all(archivers, request, monkeypatch):
-    """Test repository with 'all' permissions setting"""
+    """Test repository with 'all' permissions setting."""
     archiver = request.getfixturevalue(archivers)
 
     # Create a repository with unrestricted permissions.
@@ -35,7 +35,7 @@ def test_repository_permissions_all(archivers, request, monkeypatch):
 
 
 def test_repository_permissions_no_delete(archivers, request, monkeypatch):
-    """Test repository with 'no-delete' permissions setting"""
+    """Test repository with 'no-delete' permissions setting."""
     archiver = request.getfixturevalue(archivers)
     create_test_files(archiver.input_path)
 
@@ -93,7 +93,7 @@ def test_repository_permissions_no_delete(archivers, request, monkeypatch):
 
 
 def test_repository_permissions_read_only(archivers, request, monkeypatch):
-    """Test repository with 'read-only' permissions setting"""
+    """Test repository with 'read-only' permissions setting."""
     archiver = request.getfixturevalue(archivers)
 
     # Create a repository first (need unrestricted permissions for that).
diff --git a/src/borg/testsuite/archiver/serve_cmd_test.py b/src/borg/testsuite/archiver/serve_cmd_test.py
index ec73fe112c..420399af5f 100644
--- a/src/borg/testsuite/archiver/serve_cmd_test.py
+++ b/src/borg/testsuite/archiver/serve_cmd_test.py
@@ -12,20 +12,20 @@
 
 
 def have_a_short_runtime_dir(mp):
-    # under pytest, we use BORG_BASE_DIR to keep stuff away from the user's normal borg dirs.
-    # this leads to a very long get_runtime_dir() path - too long for a socket file!
-    # thus, we override that again via BORG_RUNTIME_DIR to get a shorter path.
+    # Under pytest, we use BORG_BASE_DIR to keep stuff away from the user's normal Borg directories.
+    # This leads to a very long get_runtime_dir() path — too long for a socket file!
+    # Thus, we override that again via BORG_RUNTIME_DIR to get a shorter path.
     mp.setenv("BORG_RUNTIME_DIR", os.path.join(platformdirs.user_runtime_dir(), "pytest"))
 
 
 @pytest.fixture
 def serve_socket(monkeypatch):
     have_a_short_runtime_dir(monkeypatch)
-    # use a random unique socket filename, so tests can run in parallel.
+    # Use a random unique socket filename, so tests can run in parallel.
     socket_file = tempfile.mktemp(suffix=".sock", prefix="borg-", dir=get_runtime_dir())
     with subprocess.Popen(["borg", "serve", f"--socket={socket_file}"]) as p:
         while not os.path.exists(socket_file):
-            time.sleep(0.01)  # wait until socket server has started
+            time.sleep(0.01)  # wait until the socket server has started
         yield socket_file
         p.terminate()
 
diff --git a/src/borg/testsuite/archiver/tar_cmds_test.py b/src/borg/testsuite/archiver/tar_cmds_test.py
index c3037654fd..10f8311ac7 100644
--- a/src/borg/testsuite/archiver/tar_cmds_test.py
+++ b/src/borg/testsuite/archiver/tar_cmds_test.py
@@ -37,7 +37,7 @@ def test_export_tar(archivers, request):
     cmd(archiver, "create", "test", "input")
     cmd(archiver, "export-tar", "test", "simple.tar", "--progress", "--tar-format=GNU")
     with changedir("output"):
-        # This probably assumes GNU tar. Note -p switch to extract permissions regardless of umask.
+        # This probably assumes GNU tar. Note: use the -p switch to extract permissions regardless of umask.
         subprocess.check_call(["tar", "xpf", "../simple.tar", "--warning=no-timestamp"])
     assert_dirs_equal("input", "output/input", ignore_flags=True, ignore_xattrs=True, ignore_ns=True)
 
@@ -67,7 +67,7 @@ def test_export_tar_strip_components(archivers, request):
     cmd(archiver, "repo-create", RK_ENCRYPTION)
     cmd(archiver, "create", "test", "input")
     test_list = cmd(archiver, "export-tar", "test", "simple.tar", "--strip-components=1", "--list", "--tar-format=GNU")
-    # --list's path are those before processing with --strip-components
+    # --list's paths are those before processing with --strip-components
     assert "input/file1\n" in test_list
     assert "input/dir2\n" in test_list
     with changedir("output"):
diff --git a/src/borg/testsuite/archiver/transfer_cmd_test.py b/src/borg/testsuite/archiver/transfer_cmd_test.py
index 034651c36b..25ec66726d 100644
--- a/src/borg/testsuite/archiver/transfer_cmd_test.py
+++ b/src/borg/testsuite/archiver/transfer_cmd_test.py
@@ -103,7 +103,7 @@ def convert_tz(local_naive, tzoffset, tzinfo):
             # borg 2 parseformat uses .get("bsdflags"), so the json has either an int
             # (if the archived item has bsdflags) or None (if the item has no bsdflags).
             if e["flags"] == 0 and g["flags"] is None:
-                # this is expected behaviour, fix the expectation
+                # this is expected behavior, fix the expectation
                 e["flags"] = None
 
             # borg2 parseformat falls back to str(item.uid) if it does not have item.user,
diff --git a/src/borg/testsuite/archiver/undelete_cmd_test.py b/src/borg/testsuite/archiver/undelete_cmd_test.py
index 8cbc18a932..b398878c39 100644
--- a/src/borg/testsuite/archiver/undelete_cmd_test.py
+++ b/src/borg/testsuite/archiver/undelete_cmd_test.py
@@ -38,7 +38,7 @@ def test_undelete_multiple_dryrun(archivers, request):
     assert "normal" not in output  # not a candidate for undeletion
     assert "deleted1" in output  # candidate for undeletion
     assert "deleted2" in output  # candidate for undeletion
-    output = cmd(archiver, "repo-list")  # nothing change, it was a dry-run
+    output = cmd(archiver, "repo-list")  # nothing changed; it was a dry-run
     assert "normal" in output
     assert "deleted1" not in output
     assert "deleted2" not in output
@@ -61,7 +61,7 @@ def test_undelete_multiple_run(archivers, request):
     assert "normal" not in output  # not undeleted
     assert "deleted1" in output  # undeleted
     assert "deleted2" in output  # undeleted
-    output = cmd(archiver, "repo-list")  # nothing change, it was a dry-run
+    output = cmd(archiver, "repo-list")  # nothing changed; it was a dry-run
     assert "normal" in output
     assert "deleted1" in output
     assert "deleted2" in output
diff --git a/src/borg/testsuite/benchmark_test.py b/src/borg/testsuite/benchmark_test.py
index 2fb137dc7f..5d49d1e757 100644
--- a/src/borg/testsuite/benchmark_test.py
+++ b/src/borg/testsuite/benchmark_test.py
@@ -1,5 +1,5 @@
 """
-Do benchmarks using pytest-benchmark.
+Run benchmarks using pytest-benchmark.
 
 Usage:
 
@@ -40,7 +40,7 @@ def testdata(request, tmpdir_factory):
     p = tmpdir_factory.mktemp("data")
     data_type = request.param
     if data_type == "zeros":
-        # do not use a binary zero (\0) to avoid sparse detection
+        # Do not use a binary zero (\\0) to avoid sparse detection.
         def data(size):
             return memoryview(zeros)[:size]
 
diff --git a/src/borg/testsuite/chunkers/__init__.py b/src/borg/testsuite/chunkers/__init__.py
index 26714517aa..82d2689e64 100644
--- a/src/borg/testsuite/chunkers/__init__.py
+++ b/src/borg/testsuite/chunkers/__init__.py
@@ -7,13 +7,13 @@
 
 
 def cf(chunks):
-    """chunk filter"""
+    """Chunk filter."""
 
-    # this is to simplify testing: either return the data piece (bytes) or the hole length (int).
+    # This is to simplify testing: either return the data piece (bytes) or the hole length (int).
     def _cf(chunk):
         if chunk.meta["allocation"] == CH_DATA:
             assert len(chunk.data) == chunk.meta["size"]
-            return bytes(chunk.data)  # make sure we have bytes, not memoryview
+            return bytes(chunk.data)  # Make sure we have bytes, not a memoryview
         if chunk.meta["allocation"] in (CH_HOLE, CH_ALLOC):
             assert chunk.data is None
             return chunk.meta["size"]
@@ -64,14 +64,14 @@ def fs_supports_sparse():
                 offset_hole = f.seek(0, os.SEEK_HOLE)
                 offset_data = f.seek(0, os.SEEK_DATA)
             except OSError:
-                # no sparse support if these seeks do not work
+                # No sparse support if these seeks do not work
                 return False
         return offset_hole == 0 and offset_data == BS
 
 
-BS = 4096  # fs block size
+BS = 4096  # filesystem block size
 
-# some sparse files. X = content blocks, _ = sparse blocks.
+# Some sparse files. X = content blocks, _ = sparse blocks.
 # X__XXX____
 map_sparse1 = [(0 * BS, 1 * BS, True), (1 * BS, 2 * BS, False), (3 * BS, 3 * BS, True), (6 * BS, 4 * BS, False)]
 
diff --git a/src/borg/testsuite/chunkers/buzhash64_self_test.py b/src/borg/testsuite/chunkers/buzhash64_self_test.py
index 03b5a8bfac..234d203ca7 100644
--- a/src/borg/testsuite/chunkers/buzhash64_self_test.py
+++ b/src/borg/testsuite/chunkers/buzhash64_self_test.py
@@ -1,5 +1,5 @@
-# Note: these tests are part of the self test, do not use or import pytest functionality here.
-#       See borg.selftest for details. If you add/remove test methods, update SELFTEST_COUNT
+# Note: these tests are part of the self-test; do not use or import pytest functionality here.
+#       See borg.selftest for details. If you add/remove test methods, update SELFTEST_COUNT.
 
 from io import BytesIO
 
diff --git a/src/borg/testsuite/chunkers/buzhash64_test.py b/src/borg/testsuite/chunkers/buzhash64_test.py
index 1aafdbf70f..41e0b06f69 100644
--- a/src/borg/testsuite/chunkers/buzhash64_test.py
+++ b/src/borg/testsuite/chunkers/buzhash64_test.py
@@ -43,7 +43,7 @@ def twist(size):
                         runs.append(H(b"".join(chunks)))
 
     # The "correct" hash below matches the existing chunker behavior.
-    # Future chunker optimisations must not change this, or existing repos will bloat.
+    # Future chunker optimizations must not change this, or existing repos will bloat.
     overall_hash = H(b"".join(runs))
     print(overall_hash.hex())
     assert overall_hash == hex_to_bin("676676133fb3621ada0f6cc1b18002c3e37016c9469217d18f8e382fadaf23fd")
@@ -51,7 +51,7 @@ def twist(size):
 
 def test_buzhash64_chunksize_distribution():
     data = os.urandom(1048576)
-    min_exp, max_exp, mask = 10, 16, 14  # chunk size target 16kiB, clip at 1kiB and 64kiB
+    min_exp, max_exp, mask = 10, 16, 14  # chunk size target 16 KiB, clip at 1 KiB and 64 KiB
     chunker = ChunkerBuzHash64(key0, min_exp, max_exp, mask, 4095)
     f = BytesIO(data)
     chunks = cf(chunker.chunkify(f))
diff --git a/src/borg/testsuite/chunkers/buzhash_self_test.py b/src/borg/testsuite/chunkers/buzhash_self_test.py
index 9baf862f35..8d7c1dddae 100644
--- a/src/borg/testsuite/chunkers/buzhash_self_test.py
+++ b/src/borg/testsuite/chunkers/buzhash_self_test.py
@@ -1,5 +1,5 @@
-# Note: these tests are part of the self test, do not use or import pytest functionality here.
-#       See borg.selftest for details. If you add/remove test methods, update SELFTEST_COUNT
+# Note: these tests are part of the self-test; do not use or import pytest functionality here.
+#       See borg.selftest for details. If you add/remove test methods, update SELFTEST_COUNT.
 
 from io import BytesIO
 
diff --git a/src/borg/testsuite/chunkers/buzhash_test.py b/src/borg/testsuite/chunkers/buzhash_test.py
index 3b33a1cc9b..4434d54862 100644
--- a/src/borg/testsuite/chunkers/buzhash_test.py
+++ b/src/borg/testsuite/chunkers/buzhash_test.py
@@ -37,14 +37,14 @@ def twist(size):
                         runs.append(H(b"".join(chunks)))
 
     # The "correct" hash below matches the existing chunker behavior.
-    # Future chunker optimisations must not change this, or existing repos will bloat.
+    # Future chunker optimizations must not change this, or existing repos will bloat.
     overall_hash = H(b"".join(runs))
     assert overall_hash == hex_to_bin("a43d0ecb3ae24f38852fcc433a83dacd28fe0748d09cc73fc11b69cf3f1a7299")
 
 
 def test_buzhash_chunksize_distribution():
     data = os.urandom(1048576)
-    min_exp, max_exp, mask = 10, 16, 14  # chunk size target 16kiB, clip at 1kiB and 64kiB
+    min_exp, max_exp, mask = 10, 16, 14  # chunk size target 16 KiB, clip at 1 KiB and 64 KiB
     chunker = Chunker(0, min_exp, max_exp, mask, 4095)
     f = BytesIO(data)
     chunks = cf(chunker.chunkify(f))
@@ -59,7 +59,7 @@ def test_buzhash_chunksize_distribution():
         f"count: {chunks_count} min: {min_chunksize_observed} max: {max_chunksize_observed} "
         f"min count: {min_count} max count: {max_count}"
     )
-    # usually there will about 64 chunks
+    # usually there will be about 64 chunks
     assert 32 < chunks_count < 128
     # chunks always must be between min and max (clipping must work):
     assert min_chunksize_observed >= 2**min_exp
diff --git a/src/borg/testsuite/chunkers/fixed_self_test.py b/src/borg/testsuite/chunkers/fixed_self_test.py
index db999ee608..9d871f19a9 100644
--- a/src/borg/testsuite/chunkers/fixed_self_test.py
+++ b/src/borg/testsuite/chunkers/fixed_self_test.py
@@ -1,5 +1,5 @@
-# Note: these tests are part of the self test, do not use or import pytest functionality here.
-#       See borg.selftest for details. If you add/remove test methods, update SELFTEST_COUNT
+# Note: these tests are part of the self-test; do not use or import pytest functionality here.
+#       See borg.selftest for details. If you add/remove test methods, update SELFTEST_COUNT.
 
 from io import BytesIO
 
@@ -45,7 +45,7 @@ def test_chunkify_header_and_blocks_fmap_zeros(self):
         chunker = ChunkerFixed(4096, 123)
         fmap = [(0, 123, True), (123, 4096, False), (123 + 4096, 4096, True), (123 + 8192, 4096, False)]
         parts = cf(chunker.chunkify(BytesIO(data), fmap=fmap))
-        # because we marked the '_' ranges as holes, we will get hole ranges instead!
+        # Because we marked the '_' ranges as holes, we will get hole ranges instead!
         self.assert_equal(parts, [data[0:123], 4096, data[123 + 4096 : 123 + 8192], 4096])
 
     def test_chunkify_header_and_blocks_fmap_partial(self):
@@ -58,5 +58,5 @@ def test_chunkify_header_and_blocks_fmap_partial(self):
             # (123+8192, 4096, False),
         ]
         parts = cf(chunker.chunkify(BytesIO(data), fmap=fmap))
-        # because we left out the '_' ranges from the fmap, we will not get them at all!
+        # Because we left out the '_' ranges from the fmap, we will not get them at all!
         self.assert_equal(parts, [data[0:123], data[123 + 4096 : 123 + 8192]])
diff --git a/src/borg/testsuite/chunkers/fixed_test.py b/src/borg/testsuite/chunkers/fixed_test.py
index 2ab5faf484..2d4971866e 100644
--- a/src/borg/testsuite/chunkers/fixed_test.py
+++ b/src/borg/testsuite/chunkers/fixed_test.py
@@ -6,7 +6,7 @@
 from ...constants import *  # NOQA
 
 
-@pytest.mark.skipif(not fs_supports_sparse(), reason="fs does not support sparse files")
+@pytest.mark.skipif(not fs_supports_sparse(), reason="filesystem does not support sparse files")
 @pytest.mark.parametrize(
     "fname, sparse_map, header_size, sparse",
     [
diff --git a/src/borg/testsuite/chunkers/reader_test.py b/src/borg/testsuite/chunkers/reader_test.py
index f2e50b6d82..ff56350ee1 100644
--- a/src/borg/testsuite/chunkers/reader_test.py
+++ b/src/borg/testsuite/chunkers/reader_test.py
@@ -9,7 +9,7 @@
 from ...constants import *  # NOQA
 
 
-@pytest.mark.skipif(not fs_supports_sparse(), reason="fs does not support sparse files")
+@pytest.mark.skipif(not fs_supports_sparse(), reason="filesystem does not support sparse files")
 @pytest.mark.parametrize(
     "fname, sparse_map",
     [("sparse1", map_sparse1), ("sparse2", map_sparse2), ("onlysparse", map_onlysparse), ("notsparse", map_notsparse)],
diff --git a/src/borg/testsuite/compress_test.py b/src/borg/testsuite/compress_test.py
index 32b8338e4c..99b7f6b6b8 100644
--- a/src/borg/testsuite/compress_test.py
+++ b/src/borg/testsuite/compress_test.py
@@ -55,8 +55,8 @@ def test_autodetect_invalid(invalid_cdata):
 
 
 def test_zlib_legacy_compat():
-    # for compatibility reasons, we do not add an extra header for zlib,
-    # nor do we expect one when decompressing / auto-detecting
+    # For compatibility reasons, we do not add an extra header for zlib,
+    # nor do we expect one when decompressing or auto-detecting
     for level in range(10):
         c = get_compressor(name="zlib_legacy", level=level, legacy_mode=True)
         meta1, cdata1 = c.compress({}, DATA)
diff --git a/src/borg/testsuite/fslocking_test.py b/src/borg/testsuite/fslocking_test.py
index 9a50087aaf..80d78de489 100644
--- a/src/borg/testsuite/fslocking_test.py
+++ b/src/borg/testsuite/fslocking_test.py
@@ -29,7 +29,7 @@
 
 @pytest.fixture()
 def free_pid():
-    """Return a free PID not used by any process (naturally this is racy)"""
+    """Return a free PID not used by any process (naturally this is racy)."""
     host, pid, tid = get_process_id()
     while True:
         # PIDs are often restricted to a small range. On Linux the range >32k is by default not used.
@@ -96,14 +96,14 @@ def test_migrate_lock(self, lockpath):
         old_id, new_id = ID1, ID2
         assert old_id[1] != new_id[1]  # different PIDs (like when doing daemonize())
         lock = ExclusiveLock(lockpath, id=old_id).acquire()
-        assert lock.id == old_id  # lock is for old id / PID
+        assert lock.id == old_id  # Lock is for the old ID/PID.
         old_unique_name = lock.unique_name
         assert lock.by_me()  # we have the lock
         lock.migrate_lock(old_id, new_id)  # fix the lock
-        assert lock.id == new_id  # lock corresponds to the new id / PID
+        assert lock.id == new_id  # Lock corresponds to the new ID/PID.
         new_unique_name = lock.unique_name
         assert lock.by_me()  # we still have the lock
-        assert old_unique_name != new_unique_name  # locking filename is different now
+        assert old_unique_name != new_unique_name  # Locking filename is different now.
 
     def test_race_condition(self, lockpath):
         class SynchronizedCounter:
diff --git a/src/borg/testsuite/hashindex_test.py b/src/borg/testsuite/hashindex_test.py
index e9a244ae89..2425921aec 100644
--- a/src/borg/testsuite/hashindex_test.py
+++ b/src/borg/testsuite/hashindex_test.py
@@ -7,12 +7,12 @@
 
 
 def H(x):
-    # make some 32byte long thing that depends on x
+    # Make a 32-byte value that depends on x
     return bytes("%-0.32d" % x, "ascii")
 
 
 def H2(x):
-    # like H(x), but with pseudo-random distribution of the output value
+    # Like H(x), but with a pseudo-random distribution of the output value
     return hashlib.sha256(H(x)).digest()
 
 
@@ -45,7 +45,7 @@ def new_chunks():
     chunks = ChunkIndex()
     key1, value1a = H2(1), ChunkIndexEntry(flags=ChunkIndex.F_USED, size=23)
     key2, value2a = H2(2), ChunkIndexEntry(flags=ChunkIndex.F_USED, size=42)
-    # tracking of new entries
+    # Tracking of new entries
     assert new_chunks() == []
     chunks[key1] = value1a
     assert new_chunks() == [(key1, value1a)]
diff --git a/src/borg/testsuite/helpers/__init__test.py b/src/borg/testsuite/helpers/__init__test.py
index 7eee4ddf54..4c01179293 100644
--- a/src/borg/testsuite/helpers/__init__test.py
+++ b/src/borg/testsuite/helpers/__init__test.py
@@ -7,7 +7,7 @@
 @pytest.mark.parametrize(
     "ec_range,ec_class",
     (
-        # inclusive range start, exclusive range end
+        # Inclusive range start; exclusive range end.
         ((0, 1), "success"),
         ((1, 2), "warning"),
         ((2, 3), "error"),
@@ -33,7 +33,7 @@ def test_ec_invalid():
 @pytest.mark.parametrize(
     "ec1,ec2,ec_max",
     (
-        # same for modern / legacy
+        # Same for modern/legacy.
         (EXIT_SUCCESS, EXIT_SUCCESS, EXIT_SUCCESS),
         (EXIT_SUCCESS, EXIT_SIGNAL_BASE, EXIT_SIGNAL_BASE),
         # legacy exit codes
diff --git a/src/borg/testsuite/helpers/datastruct_test.py b/src/borg/testsuite/helpers/datastruct_test.py
index b5403e5a23..d9035b6da5 100644
--- a/src/borg/testsuite/helpers/datastruct_test.py
+++ b/src/borg/testsuite/helpers/datastruct_test.py
@@ -15,7 +15,7 @@ class TestBuffer:
     def test_type(self):
         buffer = Buffer(bytearray)
         assert isinstance(buffer.get(), bytearray)
-        buffer = Buffer(bytes)  # don't do that in practice
+        buffer = Buffer(bytes)  # Do not do that in practice.
         assert isinstance(buffer.get(), bytes)
 
     def test_len(self):
@@ -33,15 +33,15 @@ def test_resize(self):
         buffer.resize(200)
         assert len(buffer) == 200
         b2 = buffer.get()
-        assert b2 is not b1  # new, bigger buffer
+        assert b2 is not b1  # New, bigger buffer.
         buffer.resize(100)
         assert len(buffer) >= 100
         b3 = buffer.get()
-        assert b3 is b2  # still same buffer (200)
+        assert b3 is b2  # Still the same buffer (200).
         buffer.resize(100, init=True)
-        assert len(buffer) == 100  # except on init
+        assert len(buffer) == 100  # Except on init.
         b4 = buffer.get()
-        assert b4 is not b3  # new, smaller buffer
+        assert b4 is not b3  # New, smaller buffer.
 
     def test_limit(self):
         buffer = Buffer(bytearray, size=100, limit=200)
@@ -57,10 +57,10 @@ def test_get(self):
         assert len(b1) >= 50  # == 100
         b2 = buffer.get(100)
         assert len(b2) >= 100  # == 100
-        assert b2 is b1  # did not need resizing yet
+        assert b2 is b1  # Did not need resizing yet.
         b3 = buffer.get(200)
         assert len(b3) == 200
-        assert b3 is not b2  # new, resized buffer
+        assert b3 is not b2  # New, resized buffer.
         with pytest.raises(Buffer.MemoryLimitExceeded):
-            buffer.get(201)  # beyond limit
+            buffer.get(201)  # Beyond limit.
         assert len(buffer) == 200
diff --git a/src/borg/testsuite/helpers/fs_test.py b/src/borg/testsuite/helpers/fs_test.py
index 49a6cf5e47..70acc42a08 100644
--- a/src/borg/testsuite/helpers/fs_test.py
+++ b/src/borg/testsuite/helpers/fs_test.py
@@ -237,7 +237,7 @@ def test_dash_open():
     assert dash_open("-", "wb") is sys.stdout.buffer
 
 
-@pytest.mark.skipif(not are_hardlinks_supported(), reason="hardlinks not supported")
+@pytest.mark.skipif(not are_hardlinks_supported(), reason="hard links not supported")
 def test_safe_unlink_is_safe(tmpdir):
     contents = b"Hello, world\n"
     victim = tmpdir / "victim"
@@ -250,7 +250,7 @@ def test_safe_unlink_is_safe(tmpdir):
     assert victim.read_binary() == contents
 
 
-@pytest.mark.skipif(not are_hardlinks_supported(), reason="hardlinks not supported")
+@pytest.mark.skipif(not are_hardlinks_supported(), reason="hard links not supported")
 def test_safe_unlink_is_safe_ENOSPC(tmpdir, monkeypatch):
     contents = b"Hello, world\n"
     victim = tmpdir / "victim"
diff --git a/src/borg/testsuite/helpers/misc_test.py b/src/borg/testsuite/helpers/misc_test.py
index 7fa28a6ffe..0d41ccd523 100644
--- a/src/borg/testsuite/helpers/misc_test.py
+++ b/src/borg/testsuite/helpers/misc_test.py
@@ -34,19 +34,19 @@ def test_chunkit():
 
 
 def test_iter_separated():
-    # newline and utf-8
+    # Newline and UTF-8
     sep, items = "\n", ["foo", "bar/baz", "αáčő"]
     fd = StringIO(sep.join(items))
     assert list(iter_separated(fd)) == items
-    # null and bogus ending
+    # NUL and bogus ending
     sep, items = "\0", ["foo/bar", "baz", "spam"]
     fd = StringIO(sep.join(items) + "\0")
     assert list(iter_separated(fd, sep=sep)) == ["foo/bar", "baz", "spam"]
-    # multichar
+    # Multi-character
     sep, items = "SEP", ["foo/bar", "baz", "spam"]
     fd = StringIO(sep.join(items))
     assert list(iter_separated(fd, sep=sep)) == items
-    # bytes
+    # Bytes
     sep, items = b"\n", [b"foo", b"blop\t", b"gr\xe4ezi"]
     fd = BytesIO(sep.join(items))
     assert list(iter_separated(fd)) == items
diff --git a/src/borg/testsuite/helpers/msgpack_test.py b/src/borg/testsuite/helpers/msgpack_test.py
index fe14a3a58d..41960da784 100644
--- a/src/borg/testsuite/helpers/msgpack_test.py
+++ b/src/borg/testsuite/helpers/msgpack_test.py
@@ -6,17 +6,17 @@
 
 
 def expected_py_mp_slow_combination():
-    """do we expect msgpack to be slow in this environment?"""
-    # we need to import upstream msgpack package here, not helpers.msgpack:
+    """Do we expect msgpack to be slow in this environment?"""
+    # We need to import the upstream msgpack package here, not helpers.msgpack:
     import msgpack
 
-    # msgpack is slow on cygwin
+    # msgpack is slow on Cygwin
     if is_cygwin:
         return True
-    # msgpack < 1.0.6 did not have py312 wheels
+    # msgpack < 1.0.6 did not have Python 3.12 wheels
     if sys.version_info[:2] == (3, 12) and msgpack.version < (1, 0, 6):
         return True
-    # otherwise we expect msgpack to be fast!
+    # Otherwise, we expect msgpack to be fast!
     return False
 
 
@@ -32,5 +32,5 @@ def test_is_slow_msgpack():
         assert is_slow_msgpack()
     finally:
         msgpack.Packer = saved_packer
-    # this tests that we have fast msgpack on test platform:
+    # This tests that we have fast msgpack on the test platform:
     assert not is_slow_msgpack()
diff --git a/src/borg/testsuite/helpers/parseformat_test.py b/src/borg/testsuite/helpers/parseformat_test.py
index 61a710cead..85600c819e 100644
--- a/src/borg/testsuite/helpers/parseformat_test.py
+++ b/src/borg/testsuite/helpers/parseformat_test.py
@@ -59,13 +59,13 @@ def test_text_to_json(key, value, strict):
     d = text_to_json(key, value)
     value_b = value.encode("utf-8", errors="surrogateescape")
     if strict:
-        # no surrogate-escapes, just unicode text
+        # No surrogate escapes; just Unicode text.
         assert key in d
         assert d[key] == value_b.decode("utf-8", errors="strict")
         assert d[key].encode("utf-8", errors="strict") == value_b
-        assert key_b64 not in d  # not needed. pure valid unicode.
+        assert key_b64 not in d  # Not needed; pure valid Unicode.
     else:
-        # requiring surrogate-escapes. text has replacement chars, base64 representation is present.
+        # Requires surrogate escapes. The text has replacement characters; Base64 representation is present.
         assert key in d
         assert d[key] == value.encode("utf-8", errors="replace").decode("utf-8", errors="strict")
         assert d[key].encode("utf-8", errors="strict") == value.encode("utf-8", errors="replace")
@@ -245,7 +245,7 @@ def test_abspath(self, monkeypatch, keys_dir):
 
     def test_relpath(self, monkeypatch, keys_dir):
         monkeypatch.delenv("BORG_REPO", raising=False)
-        # for a local path, borg creates a Location instance with an absolute path
+        # For a local path, Borg creates a Location instance with an absolute path.
         rel_path = "relative/path"
         abs_path = os.path.abspath(rel_path)
         assert (
@@ -299,7 +299,7 @@ def test_canonical_path(self, monkeypatch):
 
     def test_bad_syntax(self):
         with pytest.raises(ValueError):
-            # this is invalid due to the 2nd colon, correct: 'ssh://user@host/path'
+            # This is invalid due to the second colon. Correct: 'ssh://user@host/path'.
             Location("ssh://user@host:/path")
 
 
@@ -307,7 +307,7 @@ def test_bad_syntax(self):
     "name",
     [
         "foobar",
-        # placeholders
+        # Placeholders
         "foobar-{now}",
     ],
 )
@@ -320,7 +320,7 @@ def test_archivename_ok(name):
     [
         "",  # too short
         "x" * 201,  # too long
-        # invalid chars:
+        # Invalid characters:
         "foo/bar",
         "foo\\bar",
         ">foo",
@@ -331,10 +331,10 @@ def test_archivename_ok(name):
         "*bar",
         "foo\nbar",
         "foo\0bar",
-        # leading/trailing blanks
+        # Leading/trailing blanks
         " foo",
         "bar  ",
-        # contains surrogate-escapes
+        # Contains surrogate escapes
         "foo\udc80bar",
         "foo\udcffbar",
     ],
@@ -353,9 +353,9 @@ def test_text_ok(text):
     "text",
     [
         "x" * 101,  # too long
-        # invalid chars:
+        # Invalid characters:
         "foo\0bar",
-        # contains surrogate-escapes
+        # Contains surrogate escapes
         "foo\udc80bar",
         "foo\udcffbar",
     ],
@@ -417,7 +417,7 @@ def test_parse_timestamp():
 @pytest.mark.parametrize(
     "size, fmt",
     [
-        (0, "0 B"),  # no rounding necessary for those
+        (0, "0 B"),  # No rounding necessary for these.
         (1, "1 B"),
         (142, "142 B"),
         (999, "999 B"),
@@ -428,7 +428,7 @@ def test_parse_timestamp():
         (1010, "1.01 kB"),  # rounded down as well
         (999990000, "999.99 MB"),  # rounded down
         (999990001, "999.99 MB"),  # rounded down
-        (999995000, "1.00 GB"),  # rounded up to next unit
+        (999995000, "1.00 GB"),  # Rounded up to the next unit.
         (10**6, "1.00 MB"),  # and all the remaining units, megabytes
         (10**9, "1.00 GB"),  # gigabytes
         (10**12, "1.00 TB"),  # terabytes
diff --git a/src/borg/testsuite/helpers/process_test.py b/src/borg/testsuite/helpers/process_test.py
index ebfa72f7c8..7a9ff637c9 100644
--- a/src/borg/testsuite/helpers/process_test.py
+++ b/src/borg/testsuite/helpers/process_test.py
@@ -5,7 +5,7 @@
 
 
 class TestPopenWithErrorHandling:
-    @pytest.mark.skipif(not shutil.which("test"), reason='"test" binary is needed')
+    @pytest.mark.skipif(not shutil.which("test"), reason='"test" binary is required')
     def test_simple(self):
         proc = popen_with_error_handling("test 1")
         assert proc.wait() == 0
diff --git a/src/borg/testsuite/helpers/shellpattern_test.py b/src/borg/testsuite/helpers/shellpattern_test.py
index 4598340a54..123116ffff 100644
--- a/src/borg/testsuite/helpers/shellpattern_test.py
+++ b/src/borg/testsuite/helpers/shellpattern_test.py
@@ -45,7 +45,7 @@ def check(path, pattern):
         ("foo/bar", ["fo*/bar"]),
         ("foo/bar", ["f*/bar"]),
         ("foo/bar", ["*/bar"]),
-        # Double asterisk (matches 0..n directory layers)
+        # Double asterisk (matches 0 to n directory layers)
         ("foo/bar", ["foo/**/bar"]),
         ("foo/1/bar", ["foo/**/bar"]),
         ("foo/1/22/333/bar", ["foo/**/bar"]),
@@ -90,9 +90,9 @@ def test_match(path, patterns):
         ("foo", ["foo?"]),
         ("foo", ["?foo"]),
         ("foo", ["f?oo"]),
-        # do not match path separator
+        # Do not match the path separator.
         ("foo/ar", ["foo?ar"]),
-        # do not match/cross over os.path.sep
+        # Do not match or cross the path separator (os.path.sep).
         ("foo/bar", ["*"]),
         ("foo/bar", ["foo*bar"]),
         ("foo/bar", ["foo*ar"]),
@@ -100,9 +100,9 @@ def test_match(path, patterns):
         ("foo/bar", ["fo*ar"]),
         # Double asterisk
         ("foobar", ["foo/**/bar"]),
-        # Two asterisks without slash do not match directory separator
+        # Two asterisks without a slash do not match the directory separator.
         ("foo/bar", ["**"]),
-        # Double asterisk not matching filename
+        # Double asterisk does not match a filename.
         ("foo/bar", ["**/"]),
         # Set
         ("foo3", ["foo[12]"]),
@@ -122,11 +122,11 @@ def test_mismatch(path, patterns):
 
 
 def test_match_end():
-    regex = shellpattern.translate("*-home")  # default is match_end == string end
+    regex = shellpattern.translate("*-home")  # The default is match_end == end of string.
     assert re.match(regex, "2017-07-03-home")
     assert not re.match(regex, "2017-07-03-home.xxx")
 
-    match_end = r"(\.xxx)?\Z"  # with/without .xxx ending
+    match_end = r"(\.xxx)?\Z"  # With or without a .xxx suffix.
     regex = shellpattern.translate("*-home", match_end=match_end)
     assert re.match(regex, "2017-07-03-home")
     assert re.match(regex, "2017-07-03-home.xxx")
diff --git a/src/borg/testsuite/helpers/time_test.py b/src/borg/testsuite/helpers/time_test.py
index f2f4d6ea7e..1fbd4cad8e 100644
--- a/src/borg/testsuite/helpers/time_test.py
+++ b/src/borg/testsuite/helpers/time_test.py
@@ -5,32 +5,32 @@
 
 
 def utcfromtimestamp(timestamp):
-    """Returns a naive datetime instance representing the timestamp in the UTC timezone"""
+    """Return a naive datetime instance representing the timestamp in the UTC time zone."""
     return datetime.fromtimestamp(timestamp, timezone.utc).replace(tzinfo=None)
 
 
 def test_safe_timestamps():
     if SUPPORT_32BIT_PLATFORMS:
-        # ns fit into int64
+        # Nanoseconds fit into int64.
         assert safe_ns(2**64) <= 2**63 - 1
         assert safe_ns(-1) == 0
-        # s fit into int32
+        # Seconds fit into int32.
         assert safe_s(2**64) <= 2**31 - 1
         assert safe_s(-1) == 0
-        # datetime won't fall over its y10k problem
+        # datetime will not stumble over the Y10K problem.
         beyond_y10k = 2**100
         with pytest.raises(OverflowError):
             utcfromtimestamp(beyond_y10k)
         assert utcfromtimestamp(safe_s(beyond_y10k)) > datetime(2038, 1, 1)
         assert utcfromtimestamp(safe_ns(beyond_y10k) / 1000000000) > datetime(2038, 1, 1)
     else:
-        # ns fit into int64
+        # Nanoseconds fit into int64.
         assert safe_ns(2**64) <= 2**63 - 1
         assert safe_ns(-1) == 0
-        # s are so that their ns conversion fits into int64
+        # Seconds are limited so that their ns conversion fits into int64.
         assert safe_s(2**64) * 1000000000 <= 2**63 - 1
         assert safe_s(-1) == 0
-        # datetime won't fall over its y10k problem
+        # datetime will not stumble over the Y10K problem.
         beyond_y10k = 2**100
         with pytest.raises(OverflowError):
             utcfromtimestamp(beyond_y10k)
diff --git a/src/borg/testsuite/item_test.py b/src/borg/testsuite/item_test.py
index 34fb8fe4ce..9c6a5b796c 100644
--- a/src/borg/testsuite/item_test.py
+++ b/src/borg/testsuite/item_test.py
@@ -37,7 +37,7 @@ def test_item_empty():
 
 @pytest.mark.parametrize(
     "item_dict, path, mode",
-    [  # does not matter whether we get str or bytes keys
+    [  # It does not matter whether we get str or bytes keys
         ({b"path": "a/b/c", b"mode": 0o666}, "a/b/c", 0o666),
         ({"path": "a/b/c", "mode": 0o666}, "a/b/c", 0o666),
     ],
@@ -89,7 +89,7 @@ def test_item_mptimestamp_property(atime):
 
 
 def test_item_se_str_property():
-    # start simple
+    # Start simple
     item = Item()
     item.path = "a/b/c"
     assert item.path == "a/b/c"
@@ -99,7 +99,7 @@ def test_item_se_str_property():
     with pytest.raises(TypeError):
         item.path = 42
 
-    # non-utf-8 path, needing surrogate-escaping for latin-1 u-umlaut
+    # Non-UTF-8 path, requiring surrogate escaping for a Latin-1 u-umlaut
     item = Item(internal_dict={"path": b"a/\xfc/c"})
     assert item.path == "a/\udcfc/c"  # getting a surrogate-escaped representation
     assert item.as_dict() == {"path": "a/\udcfc/c"}
@@ -132,9 +132,9 @@ def test_item_dict_property():
 
 
 def test_unknown_property():
-    # we do not want the user to be able to set unknown attributes -
-    # they won't get into the .as_dict() result dictionary.
-    # also they might be just typos of known attributes.
+    # We do not want the user to be able to set unknown attributes —
+    # they will not appear in the .as_dict() result dictionary.
+    # Also, they might just be typos of known attributes.
     item = Item()
     with pytest.raises(AttributeError):
         item.unknown_attribute = None
@@ -163,7 +163,7 @@ def test_item_optr():
         (["1234", "567A", "bC"], ["1", "23", "4567A", "b", "C"], True),  # equal
         (["12345"], ["1234", "56"], False),  # one iterator exhausted before the other
         (["1234", "65"], ["1234", "56"], False),  # content mismatch
-        (["1234", "56"], ["1234", "565"], False),  # first is the prefix of second
+        (["1234", "56"], ["1234", "565"], False),  # the first is a prefix of the second
     ],
 )
 def test_chunk_content_equal(chunk_a: str, chunk_b: str, chunks_equal):
diff --git a/src/borg/testsuite/legacyrepository_test.py b/src/borg/testsuite/legacyrepository_test.py
index 643ecdca6c..86d1d294f4 100644
--- a/src/borg/testsuite/legacyrepository_test.py
+++ b/src/borg/testsuite/legacyrepository_test.py
@@ -34,13 +34,13 @@ def remote_repository(tmp_path):
 
 
 def pytest_generate_tests(metafunc):
-    # Generates tests that run on both local and remote repos
+    # Generate tests that run on both local and remote repositories.
     if "repo_fixtures" in metafunc.fixturenames:
         metafunc.parametrize("repo_fixtures", ["repository", "remote_repository"])
 
 
 def get_repository_from_fixture(repo_fixtures, request):
-    # returns the repo object from the fixture for tests that run on both local and remote repos
+    # Return the repository object from the fixture for tests that run on both local and remote repositories.
     return request.getfixturevalue(repo_fixtures)
 
 
@@ -73,7 +73,7 @@ def get_path(repository):
 
 
 def fchunk(data, meta=b""):
-    # create a raw chunk that has valid RepoObj layout, but does not use encryption or compression.
+    # Create a raw chunk that has a valid RepoObj layout but does not use encryption or compression.
     hdr = RepoObj.obj_header.pack(len(meta), len(data), xxh64(meta), xxh64(data))
     assert isinstance(data, bytes)
     chunk = hdr + meta + data
@@ -81,7 +81,7 @@ def fchunk(data, meta=b""):
 
 
 def pchunk(chunk):
-    # parse data and meta from a raw chunk made by fchunk
+    # Parse data and meta from a raw chunk made by fchunk.
     hdr_size = RepoObj.obj_header.size
     hdr = chunk[:hdr_size]
     meta_size, data_size = RepoObj.obj_header.unpack(hdr)[0:2]
@@ -91,7 +91,7 @@ def pchunk(chunk):
 
 
 def pdchunk(chunk):
-    # parse only data from a raw chunk made by fchunk
+    # Parse only the data from a raw chunk made by fchunk.
     return pchunk(chunk)[0]
 
 
@@ -108,7 +108,7 @@ def add_keys(repository):
 def repo_dump(repository, label=None):
     label = label + ": " if label is not None else ""
     H_trans = {H(i): i for i in range(10)}
-    H_trans[None] = -1  # key == None appears in commits
+    H_trans[None] = -1  # key is None appears in commits
     tag_trans = {TAG_PUT2: "put2", TAG_PUT: "put", TAG_DELETE: "del", TAG_COMMIT: "comm"}
     for segment, fn in repository.io.segment_iterator():
         for tag, key, offset, size, _ in repository.io.iter_objects(segment):
diff --git a/src/borg/testsuite/logger_test.py b/src/borg/testsuite/logger_test.py
index 1e45f88785..23bbd7f23c 100644
--- a/src/borg/testsuite/logger_test.py
+++ b/src/borg/testsuite/logger_test.py
@@ -43,7 +43,7 @@ def test_parent_module():
 
 
 def test_lazy_logger():
-    # just calling all the methods of the proxy
+    # Just calling all the methods of the proxy.
     logger.setLevel(logging.DEBUG)
     logger.debug("debug")
     logger.info("info")
diff --git a/src/borg/testsuite/platform/darwin_test.py b/src/borg/testsuite/platform/darwin_test.py
index 9003553007..18e1a2a513 100644
--- a/src/borg/testsuite/platform/darwin_test.py
+++ b/src/borg/testsuite/platform/darwin_test.py
@@ -4,7 +4,7 @@
 from ...platform import acl_get, acl_set
 from .platform_test import skipif_not_darwin, skipif_fakeroot_detected, skipif_acls_not_working
 
-# set module-level skips
+# Set module-level skips
 pytestmark = [skipif_not_darwin, skipif_fakeroot_detected]
 
 
diff --git a/src/borg/testsuite/platform/linux_test.py b/src/borg/testsuite/platform/linux_test.py
index 6e760952a9..605dc35b70 100644
--- a/src/borg/testsuite/platform/linux_test.py
+++ b/src/borg/testsuite/platform/linux_test.py
@@ -82,9 +82,9 @@ def test_default_acl():
 @skipif_acls_not_working
 @skipif_no_ubel_user
 def test_non_ascii_acl():
-    # Testing non-ascii ACL processing to see whether our code is robust.
-    # I have no idea whether non-ascii ACLs are allowed by the standard,
-    # but in practice they seem to be out there and must not make our code explode.
+    # Testing non-ASCII ACL processing to see whether our code is robust.
+    # I have no idea whether non-ASCII ACLs are allowed by the standard,
+    # but in practice they seem to be out there and must not cause failures.
     file = tempfile.NamedTemporaryFile()
     assert get_acl(file.name) == {}
     nothing_special = b"user::rw-\ngroup::r--\nmask::rw-\nother::---\n"
diff --git a/src/borg/testsuite/platform/platform_test.py b/src/borg/testsuite/platform/platform_test.py
index 4c763d8f9e..078bb2958f 100644
--- a/src/borg/testsuite/platform/platform_test.py
+++ b/src/borg/testsuite/platform/platform_test.py
@@ -68,10 +68,10 @@ def are_acls_working():
 
 
 # define skips available to platform tests
-skipif_not_linux = pytest.mark.skipif(not is_linux, reason="linux only test")
-skipif_not_darwin = pytest.mark.skipif(not is_darwin, reason="darwin only test")
-skipif_not_freebsd = pytest.mark.skipif(not is_freebsd, reason="freebsd only test")
-skipif_not_posix = pytest.mark.skipif(not (is_linux or is_freebsd or is_darwin), reason="POSIX only tests")
+skipif_not_linux = pytest.mark.skipif(not is_linux, reason="Linux-only test")
+skipif_not_darwin = pytest.mark.skipif(not is_darwin, reason="Darwin-only test")
+skipif_not_freebsd = pytest.mark.skipif(not is_freebsd, reason="FreeBSD-only test")
+skipif_not_posix = pytest.mark.skipif(not (is_linux or is_freebsd or is_darwin), reason="POSIX-only tests")
 skipif_fakeroot_detected = pytest.mark.skipif(fakeroot_detected(), reason="not compatible with fakeroot")
 skipif_acls_not_working = pytest.mark.skipif(not are_acls_working(), reason="ACLs do not work")
 skipif_no_ubel_user = pytest.mark.skipif(not user_exists("übel"), reason="requires übel user")
diff --git a/src/borg/testsuite/remote_test.py b/src/borg/testsuite/remote_test.py
index aeb0b33c73..6f01fc334d 100644
--- a/src/borg/testsuite/remote_test.py
+++ b/src/borg/testsuite/remote_test.py
@@ -41,31 +41,31 @@ def test_write(self, monkeypatch):
 
         now = 100
 
-        it = SleepingBandwidthLimiter(100)  # bandwidth quota
+        it = SleepingBandwidthLimiter(100)  # Bandwidth quota.
 
-        # all fits
+        # All fits
         self.expect_write(5, b"test")
         it.write(5, b"test")
 
-        # only partial write
+        # Only partial write
         self.expect_write(5, b"123456")
         it.write(5, b"1234567890")
 
-        # sleeps
+        # Sleeps
         self.expect_write(5, b"123456")
         it.write(5, b"123456")
 
-        # long time interval between writes
+        # Long time interval between writes
         now += 10
         self.expect_write(5, b"1")
         it.write(5, b"1")
 
-        # long time interval between writes, filling up quota
+        # Long time interval between writes, filling up the quota
         now += 10
         self.expect_write(5, b"1")
         it.write(5, b"1")
 
-        # long time interval between writes, filling up quota to clip to maximum
+        # Long time interval between writes, filling up the quota to clip to the maximum
         now += 10
         self.expect_write(5, b"1")
         it.write(5, b"1")
@@ -104,7 +104,7 @@ def test_simple(self, cache: RepositoryCache):
         assert cache.hits == 2
 
     def test_meta(self, cache: RepositoryCache):
-        # same as test_simple, but not reading the chunk data (metadata only).
+        # Same as test_simple, but not reading the chunk data (metadata only).
         # Single get()s are not cached, since they are used for unique objects like archives.
         assert pdchunk(cache.get(H(1), read_data=False)) == b""
         assert cache.misses == 1
@@ -188,7 +188,7 @@ def truncate(self, n=None):
         with patch("builtins.open", enospc_open):
             assert pdchunk(next(iterator)) == b"5678"
             assert cache.enospc == 1
-            # We didn't patch query_size_limit which would set size_limit to some low
+            # We didn't patch query_size_limit, which would set size_limit to a low
             # value, so nothing was actually evicted.
             assert cache.evictions == 0
 
diff --git a/src/borg/testsuite/repoobj_test.py b/src/borg/testsuite/repoobj_test.py
index 44c364d81d..e05cc989ff 100644
--- a/src/borg/testsuite/repoobj_test.py
+++ b/src/borg/testsuite/repoobj_test.py
@@ -48,7 +48,7 @@ def test_format_parse_roundtrip_borg1(key):  # legacy
     meta = {}  # borg1 does not support this kind of metadata
     cdata = repo_objs.format(id, meta, data, ro_type=ROBJ_FILE_STREAM)
 
-    # borg1 does not support separate metadata and borg2 does not invoke parse_meta for borg1 repos
+    # Borg 1 does not support separate metadata, and Borg 2 does not invoke parse_meta for Borg 1 repositories.
 
     got_meta, got_data = repo_objs.parse(id, cdata, ro_type=ROBJ_FILE_STREAM)
     assert got_meta["size"] == len(data)
@@ -62,8 +62,8 @@ def test_format_parse_roundtrip_borg1(key):  # legacy
 
 
 def test_borg1_borg2_transition(key):
-    # borg transfer reads borg 1.x repo objects (without decompressing them),
-    # writes borg 2 repo objects (giving already compressed data to avoid compression).
+    # Borg transfer reads Borg 1.x repository objects (without decompressing them),
+    # and writes Borg 2 repository objects (providing already-compressed data to avoid recompression).
     meta = {}  # borg1 does not support this kind of metadata
     data = b"foobar" * 10
     len_data = len(data)
@@ -73,14 +73,14 @@ def test_borg1_borg2_transition(key):
     meta1, compr_data1 = repo_objs1.parse(
         id, borg1_cdata, decompress=True, want_compressed=True, ro_type=ROBJ_FILE_STREAM
     )  # avoid re-compression
-    # in borg 1, we can only get this metadata after decrypting the whole chunk (and we do not have "size" here):
-    assert meta1["ctype"] == LZ4.ID  # default compression
-    assert meta1["clevel"] == 0xFF  # lz4 does not know levels (yet?)
-    assert meta1["csize"] < len_data  # lz4 should make it smaller
+    # In Borg 1, we can only get this metadata after decrypting the whole chunk (and we do not have "size" here):
+    assert meta1["ctype"] == LZ4.ID  # Default compression.
+    assert meta1["clevel"] == 0xFF  # LZ4 does not support levels (yet?).
+    assert meta1["csize"] < len_data  # LZ4 should make it smaller.
 
     repo_objs2 = RepoObj(key)
-    # note: as we did not decompress, we do not have "size" and we need to get it from somewhere else.
-    # here, we just use len_data. for borg transfer, we also know the size from another metadata source.
+    # Note: As we did not decompress, we do not have "size" and need to get it from somewhere else.
+    # Here, we just use len_data. For Borg transfer, we also know the size from another metadata source.
     borg2_cdata = repo_objs2.format(
         id,
         dict(meta1),
@@ -95,36 +95,36 @@ def test_borg1_borg2_transition(key):
     assert data2 == data
     assert meta2["ctype"] == LZ4.ID
     assert meta2["clevel"] == 0xFF
-    assert meta2["csize"] == meta1["csize"] - 2  # borg2 does not store the type/level bytes there
+    assert meta2["csize"] == meta1["csize"] - 2  # Borg 2 does not store the type/level bytes there.
     assert meta2["size"] == len_data
 
     meta2 = repo_objs2.parse_meta(id, borg2_cdata, ro_type=ROBJ_FILE_STREAM)
-    # now, in borg 2, we have nice and separately decrypted metadata (no need to decrypt the whole chunk):
+    # Now, in Borg 2, we have nice and separately decrypted metadata (no need to decrypt the whole chunk).
     assert meta2["ctype"] == LZ4.ID
     assert meta2["clevel"] == 0xFF
-    assert meta2["csize"] == meta1["csize"] - 2  # borg2 does not store the type/level bytes there
+    assert meta2["csize"] == meta1["csize"] - 2  # Borg 2 does not store the type/level bytes there.
     assert meta2["size"] == len_data
 
 
 def test_spoof_manifest(key):
     repo_objs = RepoObj(key)
-    data = b"fake or malicious manifest data"  # file content could be provided by attacker.
+    data = b"fake or malicious manifest data"  # File content could be provided by an attacker.
     id = repo_objs.id_hash(data)
-    # create a repo object containing user data (file content data).
+    # Create a repository object containing user data (file content data).
     cdata = repo_objs.format(id, {}, data, ro_type=ROBJ_FILE_STREAM)
-    # let's assume an attacker somehow managed to replace the manifest with that repo object.
-    # as borg always give the ro_type it wants to read, this should fail:
+    # Let's assume an attacker managed to replace the manifest with that repository object.
+    # As Borg always gives the ro_type it intends to read, this should fail:
     with pytest.raises(IntegrityError):
         repo_objs.parse(id, cdata, ro_type=ROBJ_MANIFEST)
 
 
 def test_spoof_archive(key):
     repo_objs = RepoObj(key)
-    data = b"fake or malicious archive data"  # file content could be provided by attacker.
+    data = b"fake or malicious archive data"  # File content could be provided by an attacker.
     id = repo_objs.id_hash(data)
-    # create a repo object containing user data (file content data).
+    # Create a repository object containing user data (file content data).
     cdata = repo_objs.format(id, {}, data, ro_type=ROBJ_FILE_STREAM)
-    # let's assume an attacker somehow managed to replace an archive with that repo object.
-    # as borg always give the ro_type it wants to read, this should fail:
+    # Let's assume an attacker managed to replace an archive with that repository object.
+    # As Borg always gives the ro_type it intends to read, this should fail:
     with pytest.raises(IntegrityError):
         repo_objs.parse(id, cdata, ro_type=ROBJ_ARCHIVE_META)
diff --git a/src/borg/testsuite/repository_test.py b/src/borg/testsuite/repository_test.py
index 7e2e140852..fc1d9efec5 100644
--- a/src/borg/testsuite/repository_test.py
+++ b/src/borg/testsuite/repository_test.py
@@ -29,13 +29,13 @@ def remote_repository(tmp_path):
 
 
 def pytest_generate_tests(metafunc):
-    # Generates tests that run on both local and remote repos
+    # Generate tests that run on both local and remote repositories.
     if "repo_fixtures" in metafunc.fixturenames:
         metafunc.parametrize("repo_fixtures", ["repository", "remote_repository"])
 
 
 def get_repository_from_fixture(repo_fixtures, request):
-    # returns the repo object from the fixture for tests that run on both local and remote repos
+    # Return the repository object from the fixture for tests that run on both local and remote repositories.
     return request.getfixturevalue(repo_fixtures)
 
 
@@ -56,7 +56,7 @@ def reopen(repository, exclusive: bool | None = True, create=False):
 
 
 def fchunk(data, meta=b""):
-    # format chunk: create a raw chunk that has valid RepoObj layout, but does not use encryption or compression.
+    # Format chunk: create a raw chunk that has a valid RepoObj layout, but does not use encryption or compression.
     hdr = RepoObj.obj_header.pack(len(meta), len(data), xxh64(meta), xxh64(data))
     assert isinstance(data, bytes)
     chunk = hdr + meta + data
@@ -64,7 +64,7 @@ def fchunk(data, meta=b""):
 
 
 def pchunk(chunk):
-    # parse chunk: parse data and meta from a raw chunk made by fchunk
+    # Parse chunk: extract data and metadata from a raw chunk made by fchunk.
     hdr_size = RepoObj.obj_header.size
     hdr = chunk[:hdr_size]
     meta_size, data_size = RepoObj.obj_header.unpack(hdr)[0:2]
@@ -74,7 +74,7 @@ def pchunk(chunk):
 
 
 def pdchunk(chunk):
-    # parse only data from a raw chunk made by fchunk
+    # Parse only the data from a raw chunk made by fchunk.
     return pchunk(chunk)[0]
 
 
diff --git a/src/borg/testsuite/shell_completions_test.py b/src/borg/testsuite/shell_completions_test.py
index fa3eef3527..24c5d426fa 100644
--- a/src/borg/testsuite/shell_completions_test.py
+++ b/src/borg/testsuite/shell_completions_test.py
@@ -7,48 +7,48 @@
 
 
 def test_bash_completion_is_valid():
-    """Test that the bash completion file is valid bash syntax."""
+    """Test that the Bash completion file is valid Bash syntax."""
     bash_completion_file = SHELL_COMPLETIONS_DIR / "bash" / "borg"
     assert bash_completion_file.is_file()
 
-    # Check if bash is available
+    # Check if Bash is available
     try:
         subprocess.run(["bash", "--version"], capture_output=True, check=True)
     except (subprocess.SubprocessError, FileNotFoundError):
-        pytest.skip("bash not available")
+        pytest.skip("Bash not available")
 
-    # Test if the bash completion file can be sourced without errors
+    # Test whether the Bash completion file can be sourced without errors
     result = subprocess.run(["bash", "-n", str(bash_completion_file)], capture_output=True)
     assert result.returncode == 0, f"Bash completion file has syntax errors: {result.stderr.decode()}"
 
 
 def test_fish_completion_is_valid():
-    """Test that the fish completion file is valid fish syntax."""
+    """Test that the Fish completion file is valid Fish syntax."""
     fish_completion_file = SHELL_COMPLETIONS_DIR / "fish" / "borg.fish"
     assert fish_completion_file.is_file()
 
-    # Check if fish is available
+    # Check if Fish is available
     try:
         subprocess.run(["fish", "--version"], capture_output=True, check=True)
     except (subprocess.SubprocessError, FileNotFoundError):
-        pytest.skip("fish not available")
+        pytest.skip("Fish not available")
 
-    # Test if the fish completion file can be sourced without errors
+    # Test whether the Fish completion file can be sourced without errors
     result = subprocess.run(["fish", "-c", f"source {str(fish_completion_file)}"], capture_output=True)
     assert result.returncode == 0, f"Fish completion file has syntax errors: {result.stderr.decode()}"
 
 
 def test_zsh_completion_is_valid():
-    """Test that the zsh completion file is valid zsh syntax."""
+    """Test that the Zsh completion file is valid Zsh syntax."""
     zsh_completion_file = SHELL_COMPLETIONS_DIR / "zsh" / "_borg"
     assert zsh_completion_file.is_file()
 
-    # Check if zsh is available
+    # Check if Zsh is available
     try:
         subprocess.run(["zsh", "--version"], capture_output=True, check=True)
     except (subprocess.SubprocessError, FileNotFoundError):
-        pytest.skip("zsh not available")
+        pytest.skip("Zsh not available")
 
-    # Test if the zsh completion file can be sourced without errors
+    # Test whether the Zsh completion file can be sourced without errors
     result = subprocess.run(["zsh", "-n", str(zsh_completion_file)], capture_output=True)
     assert result.returncode == 0, f"Zsh completion file has syntax errors: {result.stderr.decode()}"
diff --git a/src/borg/testsuite/storelocking_test.py b/src/borg/testsuite/storelocking_test.py
index 3b584c48d1..ea091a83ba 100644
--- a/src/borg/testsuite/storelocking_test.py
+++ b/src/borg/testsuite/storelocking_test.py
@@ -35,11 +35,11 @@ def test_got_exclusive_lock(self, lockstore):
         assert not lock.got_exclusive_lock()
 
     def test_exclusive_lock(self, lockstore):
-        # there must not be 2 exclusive locks
+        # There must not be two exclusive locks.
         with Lock(lockstore, exclusive=True, id=ID1):
             with pytest.raises(LockTimeout):
                 Lock(lockstore, exclusive=True, id=ID2).acquire()
-        # acquiring an exclusive lock will time out if the non-exclusive does not go away
+        # Acquiring an exclusive lock will time out if the non-exclusive lock does not go away.
         with Lock(lockstore, exclusive=False, id=ID1):
             with pytest.raises(LockTimeout):
                 Lock(lockstore, exclusive=True, id=ID2).acquire()
@@ -71,10 +71,10 @@ def test_lock_refresh_stale_removal(self, lockstore):
         lock.acquire()
         lock_keys_a00 = set(lock._get_locks())
         time.sleep(0.5)
-        lock.refresh()  # shouldn't change locks, existing lock too young
+        lock.refresh()  # Should not change locks; existing lock is too young.
         lock_keys_a05 = set(lock._get_locks())
         time.sleep(0.6)
-        lock.refresh()  # that should refresh the lock!
+        lock.refresh()  # This should refresh the lock.
         lock_keys_b00 = set(lock._get_locks())
         time.sleep(2.1)
         lock_keys_b21 = set(lock._get_locks())  # now the lock should be stale & gone.
diff --git a/src/borg/testsuite/version_test.py b/src/borg/testsuite/version_test.py
index 6af62f61c7..59622ceae8 100644
--- a/src/borg/testsuite/version_test.py
+++ b/src/borg/testsuite/version_test.py
@@ -6,20 +6,20 @@
 @pytest.mark.parametrize(
     "version_str, version_tuple",
     [
-        # setuptools < 8.0 uses "-"
+        # Setuptools < 8.0 uses "-"
         ("1.0.0a1.dev204-g8866961.d20170606", (1, 0, 0, -4, 1)),
         ("1.0.0a1.dev204-g8866961", (1, 0, 0, -4, 1)),
         ("1.0.0-d20170606", (1, 0, 0, -1)),
-        # setuptools >= 8.0 uses "+"
+        # Setuptools >= 8.0 uses "+"
         ("1.0.0a1.dev204+g8866961.d20170606", (1, 0, 0, -4, 1)),
         ("1.0.0a1.dev204+g8866961", (1, 0, 0, -4, 1)),
         ("1.0.0+d20170606", (1, 0, 0, -1)),
-        # pre-release versions:
+        # Pre-release versions:
         ("1.0.0a1", (1, 0, 0, -4, 1)),
         ("1.0.0a2", (1, 0, 0, -4, 2)),
         ("1.0.0b3", (1, 0, 0, -3, 3)),
         ("1.0.0rc4", (1, 0, 0, -2, 4)),
-        # release versions:
+        # Release versions:
         ("0.0.0", (0, 0, 0, -1)),
         ("0.0.11", (0, 0, 11, -1)),
         ("0.11.0", (0, 11, 0, -1)),
@@ -33,7 +33,7 @@ def test_parse_version(version_str, version_tuple):
 @pytest.mark.parametrize("invalid_version", ["", "1", "1.2", "crap"])
 def test_parse_version_invalid(invalid_version):
     with pytest.raises(ValueError):
-        assert parse_version(invalid_version)  # we require x.y.z versions
+        assert parse_version(invalid_version)  # We require x.y.z versions
 
 
 @pytest.mark.parametrize(
diff --git a/src/borg/testsuite/xattr_test.py b/src/borg/testsuite/xattr_test.py
index 89035f7718..712f3c96b7 100644
--- a/src/borg/testsuite/xattr_test.py
+++ b/src/borg/testsuite/xattr_test.py
@@ -10,7 +10,7 @@
 @pytest.fixture()
 def tempfile_symlink(tmp_path):
     if not is_enabled(tmp_path):
-        pytest.skip("xattr not enabled on filesystem")
+        pytest.skip("xattrs not enabled on the filesystem")
     with open(os.fspath(tmp_path / "xattr"), "w") as temp_file:
         symlink = temp_file.name + ".symlink"
         os.symlink(temp_file.name, symlink)
@@ -18,7 +18,7 @@ def tempfile_symlink(tmp_path):
 
 
 def assert_equal_se(is_x, want_x):
-    # check 2 xattr lists for equality, but ignore security.selinux attr
+    # Check two xattr lists for equality, but ignore the security.selinux attribute.
     is_x = set(is_x) - {b"security.selinux", b"com.apple.provenance"}
     want_x = set(want_x)
     assert is_x == want_x
@@ -36,7 +36,7 @@ def test(tempfile_symlink):
     setxattr(tmp_fd, b"user.bar", b"foo")
     setxattr(tmp_fn, b"user.empty", b"")
     if not is_linux:
-        # linux does not allow setting user.* xattrs on symlinks
+        # Linux does not allow setting user.* xattrs on symlinks.
         setxattr(tmp_lfn, b"user.linkxattr", b"baz")
     assert_equal_se(listxattr(tmp_fn), [b"user.foo", b"user.bar", b"user.empty"])
     assert_equal_se(listxattr(tmp_fd), [b"user.foo", b"user.bar", b"user.empty"])
@@ -54,9 +54,9 @@ def test(tempfile_symlink):
 def test_listxattr_buffer_growth(tempfile_symlink):
     temp_file, symlink = tempfile_symlink
     tmp_fn = os.fsencode(temp_file.name)
-    # make it work even with ext4, which imposes rather low limits
+    # Make it work even with ext4, which imposes relatively low limits.
     buffer.resize(size=64, init=True)
-    # xattr raw key list will be > 64
+    # The raw xattr key list will be > 64.
     keys = [b"user.attr%d" % i for i in range(20)]
     for key in keys:
         setxattr(tmp_fn, key, b"x")
@@ -68,7 +68,7 @@ def test_listxattr_buffer_growth(tempfile_symlink):
 def test_getxattr_buffer_growth(tempfile_symlink):
     temp_file, symlink = tempfile_symlink
     tmp_fn = os.fsencode(temp_file.name)
-    # make it work even with ext4, which imposes rather low limits
+    # Make it work even with ext4, which imposes relatively low limits.
     buffer.resize(size=64, init=True)
     value = b"x" * 126
     setxattr(tmp_fn, b"user.big", value)
diff --git a/src/borg/upgrade.py b/src/borg/upgrade.py
index 0c4eedc199..276025393b 100644
--- a/src/borg/upgrade.py
+++ b/src/borg/upgrade.py
@@ -56,7 +56,7 @@ def new_archive(self, *, archive):
         self.hlm = HardLinkManager(id_type=bytes, info_type=list)  # hlid -> chunks_correct
 
     def upgrade_item(self, *, item):
-        """upgrade item as needed, get rid of legacy crap"""
+        """Upgrades the item as needed and removes legacy data."""
         ITEM_KEY_WHITELIST = {
             "path",
             "rdev",
diff --git a/src/borg/version.py b/src/borg/version.py
index 278054f2eb..12eeea168c 100644
--- a/src/borg/version.py
+++ b/src/borg/version.py
@@ -13,7 +13,7 @@ def parse_version(version):
     For final versions the last element is a -1.
     For prerelease versions the last two elements are a smaller negative number and the number of e.g. the beta.
 
-    This version format is part of the remote protocol, don‘t change in breaking ways.
+    This version format is part of the remote protocol; don't change it in breaking ways.
     """
     version_re = r"""
         (?P<major>\d+)\.(?P<minor>\d+)\.(?P<patch>\d+)   # version, e.g. 1.2.33
@@ -34,7 +34,7 @@ def parse_version(version):
 
 
 def format_version(version):
-    """a reverse for parse_version (obviously without the dropped information)"""
+    """A reverse for parse_version (obviously without the dropped information)."""
     f = []
     it = iter(version)
     while True:
diff --git a/src/borg/xattr.py b/src/borg/xattr.py
index 009d1f11d3..1cadd38b05 100644
--- a/src/borg/xattr.py
+++ b/src/borg/xattr.py
@@ -39,7 +39,7 @@
 
 
 def is_enabled(path=None):
-    """Determine if xattr is enabled on the filesystem"""
+    """Determines whether xattrs are enabled on the filesystem."""
     with tempfile.NamedTemporaryFile(dir=path, prefix="borg-tmp") as f:
         fd = f.fileno()
         name, value = b"user.name", b"value"
@@ -65,7 +65,7 @@ def get_all(path, follow_symlinks=False):
     and only applies when *path* is not an open file descriptor.
 
     The returned mapping maps xattr names (bytes) to values (bytes or None).
-    None indicates, as a xattr value, an empty value, i.e. a value of length zero.
+    None indicates, as an xattr value, an empty value, i.e. a value of length zero.
     """
     if isinstance(path, str):
         path = os.fsencode(path)
@@ -84,7 +84,7 @@ def get_all(path, follow_symlinks=False):
                 else:  # all others: warn, skip this single xattr name, continue processing other xattrs
                     # EPERM: we were not permitted to read this attribute
                     # EINVAL: maybe xattr name is invalid or other issue, #6988
-                    logger.warning("when getting extended attribute %s: %s", name.decode(errors="replace"), str(e))
+                    logger.warning("When getting extended attribute %s: %s", name.decode(errors="replace"), str(e))
     except OSError as e:
         if e.errno in (errno.ENOTSUP, errno.EPERM):
             # if xattrs are not supported on the filesystem, we give up.
@@ -102,10 +102,10 @@ def set_all(path, xattrs, follow_symlinks=False):
     *path* can either be a path (str or bytes) or an open file descriptor (int).
     *follow_symlinks* indicates whether symlinks should be followed
     and only applies when *path* is not an open file descriptor.
-    *xattrs* is mapping maps xattr names (bytes) to values (bytes or None).
-    None indicates, as a xattr value, an empty value, i.e. a value of length zero.
+    *xattrs* is a mapping that maps xattr names (bytes) to values (bytes or None).
+    None indicates, as an xattr value, an empty value, i.e. a value of length zero.
 
-    Return warning status (True means a non-fatal exception has happened and was dealt with).
+    Returns the warning status (True means a non-fatal exception occurred and was handled).
     """
     if isinstance(path, str):
         path = os.fsencode(path)
@@ -127,5 +127,5 @@ def set_all(path, xattrs, follow_symlinks=False):
                 # EACCES: permission denied to set this specific xattr (this may happen related to security.* keys)
                 # EPERM: operation not permitted
                 err_str = str(e)
-            logger.warning("when setting extended attribute %s: %s", k.decode(errors="replace"), err_str)
+            logger.warning("When setting extended attribute %s: %s", k.decode(errors="replace"), err_str)
     return warning

From 2c7bec0149401221545928bf84c9a6ca1ffabaf3 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Thu, 4 Sep 2025 20:29:43 +0200
Subject: [PATCH 7/8] manual corrections/reverts

---
 .github/PULL_REQUEST_TEMPLATE                 |  2 +-
 .github/workflows/ci.yml                      |  2 +-
 docs/binaries/00_README.txt                   |  2 +-
 docs/faq.rst                                  |  4 ++--
 docs/misc/internals-picture.txt               |  2 +-
 docs/quickstart_example.rst.inc               |  2 +-
 docs/usage/general.rst                        |  4 ++--
 docs/usage/general/date-time.rst.inc          |  4 ++--
 .../general/repository-locations.rst.inc      |  2 +-
 docs/usage/general/resources.rst.inc          |  2 +-
 src/borg/archiver/extract_cmd.py              |  9 +++------
 src/borg/archiver/prune_cmd.py                |  4 ++--
 src/borg/archiver/repo_create_cmd.py          |  2 +-
 src/borg/archiver/repo_delete_cmd.py          |  6 +++---
 src/borg/archiver/tar_cmds.py                 |  5 ++++-
 src/borg/helpers/fs.py                        |  4 ++--
 src/borg/helpers/msgpack.py                   | 20 +++++++++----------
 src/borg/helpers/parseformat.py               |  2 +-
 src/borg/legacyrepository.py                  |  2 +-
 src/borg/logger.py                            |  2 +-
 src/borg/platform/linux.pyx                   |  2 +-
 src/borg/repository.py                        |  6 +++---
 src/borg/storelocking.py                      |  4 ++--
 src/borg/testsuite/archive_test.py            |  2 +-
 src/borg/testsuite/archiver/__init__.py       |  4 ++--
 .../testsuite/archiver/create_cmd_test.py     |  2 +-
 src/borg/testsuite/archiver/disk_full_test.py |  2 +-
 src/borg/testsuite/compress_test.py           |  2 +-
 src/borg/testsuite/helpers/fs_test.py         |  4 ++--
 src/borg/testsuite/helpers/time_test.py       | 10 +++++-----
 src/borg/testsuite/legacyrepository_test.py   |  2 +-
 src/borg/testsuite/version_test.py            |  4 ++--
 32 files changed, 63 insertions(+), 63 deletions(-)

diff --git a/.github/PULL_REQUEST_TEMPLATE b/.github/PULL_REQUEST_TEMPLATE
index d940a67be2..d1413b5eaa 100644
--- a/.github/PULL_REQUEST_TEMPLATE
+++ b/.github/PULL_REQUEST_TEMPLATE
@@ -3,6 +3,6 @@ Thank you for contributing code to Borg; your help is appreciated!
 Before you submit a pull request, please make sure it complies with the
 guidelines in our documentation:
 
-https://borgbackup.readthedocs.io/en/stable/development.html#contributions
+https://borgbackup.readthedocs.io/en/latest/development.html#contributions
 
 **Please remove the text above before submitting your pull request.**
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 869daa0e78..5f2649cca5 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -1,4 +1,4 @@
-# badge: https://github.com/borgbackup/borg/workflows/CI/badge.svg?branch=1.4-maint
+# badge: https://github.com/borgbackup/borg/workflows/CI/badge.svg?branch=master
 
 name: CI
 
diff --git a/docs/binaries/00_README.txt b/docs/binaries/00_README.txt
index 56160e73d2..313aafcd84 100644
--- a/docs/binaries/00_README.txt
+++ b/docs/binaries/00_README.txt
@@ -9,7 +9,7 @@ Download the correct files
 --------------------------
 
 AMD64/x86_64 architecture
-~~~~~~~~~~~~~~~~~~~~~~~~~~~
+~~~~~~~~~~~~~~~~~~~~~~~~~
 
 borg-linux-glibc241 Linux (built on Debian 13 "Trixie" with glibc 2.41)
 borg-linux-glibc236 Linux (built on Debian 12 "Bookworm" with glibc 2.36)
diff --git a/docs/faq.rst b/docs/faq.rst
index 5c4c561f85..e07fcae149 100644
--- a/docs/faq.rst
+++ b/docs/faq.rst
@@ -49,7 +49,7 @@ locations), the recommended way to do that is like this:
 
 This will create distinct (different repository ID) but related repositories.
 Related means using the same chunker secret and the same id_key, thus producing
-the same chunks/the same chunk IDs if the input data is the same.
+the same chunks / the same chunk IDs if the input data is the same.
 
 The two independent borg create invocations mean there is no error propagation
 from repo1 to repo2 when done like that.
@@ -76,7 +76,7 @@ run into this by yourself by restoring an older copy of your repository.
 "attack": An attacker may have replaced your repo with an older copy, trying to
 trigger AES counter reuse and break your repo encryption.
 
-Borg users have also reported that file system (fs) issues (e.g., hardware issues or I/O errors causing
+Borg users have also reported that file system issues (e.g., hardware issues or I/O errors causing
 the file system to become read-only) can cause this warning, see :issue:`7853`.
 
 If you decide to ignore this and accept unsafe operation for this repository,
diff --git a/docs/misc/internals-picture.txt b/docs/misc/internals-picture.txt
index 60da0865f4..99c1586e90 100644
--- a/docs/misc/internals-picture.txt
+++ b/docs/misc/internals-picture.txt
@@ -1,5 +1,5 @@
 BorgBackup from 10,000 m
-=======================
+========================
 
 +--------+ +--------+     +--------+
 |archive0| |archive1| ... |archiveN|
diff --git a/docs/quickstart_example.rst.inc b/docs/quickstart_example.rst.inc
index 44bb58dffd..b6a8368ea6 100644
--- a/docs/quickstart_example.rst.inc
+++ b/docs/quickstart_example.rst.inc
@@ -44,7 +44,7 @@
 
     $ borg -r /path/to/repo extract aid:b80e24d2
 
-7. Delete the first archive (please note that this does **not** immediately free repository disk space)::
+7. Delete the first archive (please note that this does **not** free repository disk space)::
 
     $ borg -r /path/to/repo delete aid:b80e24d2
 
diff --git a/docs/usage/general.rst b/docs/usage/general.rst
index 3b9c266481..36afedf2dd 100644
--- a/docs/usage/general.rst
+++ b/docs/usage/general.rst
@@ -5,8 +5,8 @@ Borg consists of a number of commands. Each command accepts
 a number of arguments and options and interprets various environment variables.
 The following sections will describe each command in detail.
 
-Commands, options, parameters, paths, and similar elements are shown in fixed-width.
-Option values are underlined. Borg has a few options that accept a fixed set
+Commands, options, parameters, paths, and similar elements are shown in ``fixed-width``.
+Option values are `underlined. Borg has a few options that accept a fixed set
 of values (e.g., ``--encryption`` of :ref:`borg_repo-create`).
 
 .. container:: experimental
diff --git a/docs/usage/general/date-time.rst.inc b/docs/usage/general/date-time.rst.inc
index 92cebd8bce..edd97c6a64 100644
--- a/docs/usage/general/date-time.rst.inc
+++ b/docs/usage/general/date-time.rst.inc
@@ -14,5 +14,5 @@ Internally, we store and process date and time as UTC.
 
 Some options accept a TIMESPAN parameter, which can be given as a number of
 years (e.g. ``2y``), months (e.g. ``12m``), weeks (e.g. ``2w``),
-days (e.g. ``7d``), hours (e.g. ``8h``), minutes (e.g. ``30m``),
-or seconds (e.g. ``150s``).
+days (e.g. ``7d``), hours (e.g. ``8H``), minutes (e.g. ``30M``),
+or seconds (e.g. ``150S``).
diff --git a/docs/usage/general/repository-locations.rst.inc b/docs/usage/general/repository-locations.rst.inc
index 9d5cc19792..b346105da6 100644
--- a/docs/usage/general/repository-locations.rst.inc
+++ b/docs/usage/general/repository-locations.rst.inc
@@ -10,5 +10,5 @@ Commands that work with an arbitrary number of archives usually accept ``-a ARCH
 
 Archive names must not contain the ``/`` (slash) character. For simplicity,
 also avoid spaces or other characters that have special meaning to the
-shell or in a filesystem (Borg mount uses the archive name as a directory
+shell or in a filesystem (``borg mount`` uses the archive name as a directory
 name).
diff --git a/docs/usage/general/resources.rst.inc b/docs/usage/general/resources.rst.inc
index 344ac237f1..7706f69510 100644
--- a/docs/usage/general/resources.rst.inc
+++ b/docs/usage/general/resources.rst.inc
@@ -35,7 +35,7 @@ CPU server:
 CPU (only for client/server operation):
     When using Borg in a client/server way with an ssh-type repository, the SSH
     processes used for the transport layer will need some CPU on the client and
-    on the server due to the crypto they are doing—especially if you are pumping
+    on the server due to the crypto they are doing — especially if you are pumping
     large amounts of data.
 
 Memory (RAM) client:
diff --git a/src/borg/archiver/extract_cmd.py b/src/borg/archiver/extract_cmd.py
index 35f0733922..48b1476380 100644
--- a/src/borg/archiver/extract_cmd.py
+++ b/src/borg/archiver/extract_cmd.py
@@ -171,13 +171,10 @@ def build_parser_extract(self, subparsers, common_parser, mid_common_parser):
             "--numeric-ids", dest="numeric_ids", action="store_true", help="only use numeric user and group identifiers"
         )
         subparser.add_argument(
-            "--noflags",
-            dest="noflags",
-            action="store_true",
-            help="do not extract or set flags (e.g. NODUMP, IMMUTABLE)",
+            "--noflags", dest="noflags", action="store_true", help="do not extract/set flags (e.g. NODUMP, IMMUTABLE)"
         )
-        subparser.add_argument("--noacls", dest="noacls", action="store_true", help="do not extract or set ACLs")
-        subparser.add_argument("--noxattrs", dest="noxattrs", action="store_true", help="do not extract or set xattrs")
+        subparser.add_argument("--noacls", dest="noacls", action="store_true", help="do not extract/set ACLs")
+        subparser.add_argument("--noxattrs", dest="noxattrs", action="store_true", help="do not extract/set xattrs")
         subparser.add_argument(
             "--stdout", dest="stdout", action="store_true", help="write all extracted data to stdout"
         )
diff --git a/src/borg/archiver/prune_cmd.py b/src/borg/archiver/prune_cmd.py
index 05eb7867b8..2f18b485b8 100644
--- a/src/borg/archiver/prune_cmd.py
+++ b/src/borg/archiver/prune_cmd.py
@@ -119,7 +119,7 @@ def prune_split(archives, rule, n, kept_because=None):
 class PruneMixIn:
     @with_repository(compatibility=(Manifest.Operation.DELETE,))
     def do_prune(self, args, repository, manifest):
-        """Prune repository archives according to specified rules."""
+        """Prune archives according to specified rules."""
         if not any(
             (
                 args.secondly,
@@ -280,7 +280,7 @@ def build_parser_prune(self, subparsers, common_parser, mid_common_parser):
             description=self.do_prune.__doc__,
             epilog=prune_epilog,
             formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="prune repository archives",
+            help="prune archives",
         )
         subparser.set_defaults(func=self.do_prune)
         subparser.add_argument(
diff --git a/src/borg/archiver/repo_create_cmd.py b/src/borg/archiver/repo_create_cmd.py
index ded3b0918c..07b60fa8d5 100644
--- a/src/borg/archiver/repo_create_cmd.py
+++ b/src/borg/archiver/repo_create_cmd.py
@@ -69,7 +69,7 @@ def build_parser_repo_create(self, subparsers, common_parser, mid_common_parser)
         store faster.
 
         Encryption mode TL;DR
-        ++++++++++++++++++++
+        +++++++++++++++++++++
 
         The encryption mode can only be configured when creating a new repository - you can
         neither configure it on a per-archive basis nor change the mode of an existing repository.
diff --git a/src/borg/archiver/repo_delete_cmd.py b/src/borg/archiver/repo_delete_cmd.py
index c4fade0abd..aa2b531eaa 100644
--- a/src/borg/archiver/repo_delete_cmd.py
+++ b/src/borg/archiver/repo_delete_cmd.py
@@ -17,7 +17,7 @@
 class RepoDeleteMixIn:
     @with_repository(exclusive=True, manifest=False)
     def do_repo_delete(self, args, repository):
-        """Deletes the repository."""
+        """Deletes a repository."""
         self.output_list = args.output_list
         dry_run = args.dry_run
         keep_security_info = args.keep_security_info
@@ -92,7 +92,7 @@ def build_parser_repo_delete(self, subparsers, common_parser, mid_common_parser)
 
         repo_delete_epilog = process_epilog(
             """
-        This command deletes the complete repository.
+        This command deletes a complete repository.
 
         When you delete a complete repository, the security info and local cache for it
         (if any) are also deleted. Alternatively, you can delete just the local cache
@@ -109,7 +109,7 @@ def build_parser_repo_delete(self, subparsers, common_parser, mid_common_parser)
             description=self.do_repo_delete.__doc__,
             epilog=repo_delete_epilog,
             formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="delete the repository",
+            help="delete a repository",
         )
         subparser.set_defaults(func=self.do_repo_delete)
         subparser.add_argument(
diff --git a/src/borg/archiver/tar_cmds.py b/src/borg/archiver/tar_cmds.py
index 77b432c4c9..df455f8562 100644
--- a/src/borg/archiver/tar_cmds.py
+++ b/src/borg/archiver/tar_cmds.py
@@ -9,7 +9,7 @@
 from ..archive import Archive, TarfileObjectProcessors, ChunksProcessor
 from ..compress import CompressionSpec
 from ..constants import *  # NOQA
-from ..helpers import HardLinkManager
+from ..helpers import HardLinkManager, IncludePatternNeverMatchedWarning
 from ..helpers import ProgressIndicatorPercent
 from ..helpers import dash_open
 from ..helpers import msgpack
@@ -250,6 +250,9 @@ def item_to_paxheaders(format, item):
         # This does not close the fileobj (tarstream) we passed to it -- a side effect of the | mode.
         tar.close()
 
+        for pattern in matcher.get_unmatched_include_patterns():
+            self.print_warning_instance(IncludePatternNeverMatchedWarning(pattern))
+
     @with_repository(cache=True, compatibility=(Manifest.Operation.WRITE,))
     def do_import_tar(self, args, repository, manifest, cache):
         """Create a backup archive from a tarball"""
diff --git a/src/borg/helpers/fs.py b/src/borg/helpers/fs.py
index bbee196040..4b3b4a1665 100644
--- a/src/borg/helpers/fs.py
+++ b/src/borg/helpers/fs.py
@@ -126,7 +126,7 @@ def get_socket_filename():
 
 
 def get_cache_dir(*, legacy=False, create=True):
-    """Determine where to store Borg cache data"""
+    """Determine where to store Borg cache data."""
 
     if legacy:
         # Get cache home path
@@ -162,7 +162,7 @@ def get_cache_dir(*, legacy=False, create=True):
 
 
 def get_config_dir(*, legacy=False, create=True):
-    """Determine where to store the configuration"""
+    """Determine where to store the configuration."""
 
     # Get config home path
     if legacy:
diff --git a/src/borg/helpers/msgpack.py b/src/borg/helpers/msgpack.py
index cb52fac928..1d2459ffd5 100644
--- a/src/borg/helpers/msgpack.py
+++ b/src/borg/helpers/msgpack.py
@@ -1,8 +1,8 @@
 """
-Wrapping MessagePack
+Wrapping msgpack
 ================
 
-We wrap MessagePack here as needed to avoid clutter in the calling code.
+We wrap ``msgpack`` here as needed to avoid clutter in the calling code.
 
 Packing
 -------
@@ -32,17 +32,17 @@
 
 - unicode_errors = 'surrogateescape' -> see description above (will be used when raw is False).
 
-As of Borg 2.0, we have fixed most of the MessagePack str/bytes issues (#968).
+As of Borg 2.0, we have fixed most of the `msgpack`` str/bytes issues (#968).
 Borg still needs to read old repositories, archives, keys, etc., so we cannot yet fix it completely.
-From now on, Borg only writes new data according to the MessagePack 2.0 spec,
+From now on, Borg only writes new data according to the msgpack 2.0 spec,
 thus we can remove some legacy support in a later Borg release (some places are marked with "legacy").
 
-Current behavior in MessagePack terms
-----------------------------
+Current behavior in msgpack terms
+---------------------------------
 
-- pack with use_bin_type=True (according to the MessagePack 2.0 spec)
+- pack with use_bin_type=True (according to the msgpack 2.0 spec)
 - packs str -> raw and bytes -> bin
-- unpack with raw=False (according to the MessagePack 2.0 spec, using unicode_errors='surrogateescape')
+- unpack with raw=False (according to the msgpack 2.0 spec, using unicode_errors='surrogateescape')
 - unpacks bin to bytes and raw to str (thus we need to convert to desired type if we want bytes from "raw")
 """
 
@@ -69,11 +69,11 @@
 
 
 class PackException(Exception):
-    """Exception during MessagePack packing."""
+    """Exception during msgpack packing."""
 
 
 class UnpackException(Exception):
-    """Exception during MessagePack unpacking."""
+    """Exception during msgpack unpacking."""
 
 
 class Packer(mp_Packer):
diff --git a/src/borg/helpers/parseformat.py b/src/borg/helpers/parseformat.py
index d0011785df..548d0cd767 100644
--- a/src/borg/helpers/parseformat.py
+++ b/src/borg/helpers/parseformat.py
@@ -119,7 +119,7 @@ def decode_dict(d, keys, encoding="utf-8", errors="surrogateescape"):
 
 
 def positive_int_validator(value):
-    """Argparse type for positive integers."""
+    """argparse type for positive integers."""
     int_value = int(value)
     if int_value <= 0:
         raise argparse.ArgumentTypeError("A positive integer is required: %s" % value)
diff --git a/src/borg/legacyrepository.py b/src/borg/legacyrepository.py
index b74a41b826..995d508d47 100644
--- a/src/borg/legacyrepository.py
+++ b/src/borg/legacyrepository.py
@@ -109,7 +109,7 @@ class LegacyRepository:
     dir/hints.X
 
     Filesystem interaction
-    -----------------------
+    ----------------------
 
     LoggedIO generally tries to rely on common behaviours across transactional file systems.
 
diff --git a/src/borg/logger.py b/src/borg/logger.py
index 6a31459f5d..5e3020710a 100644
--- a/src/borg/logger.py
+++ b/src/borg/logger.py
@@ -60,7 +60,7 @@
 import warnings
 from pathlib import Path
 
-logging_debugging_path: Path | None = None  # if set, write borg.logger debugging log to that path/borg-*.log
+logging_debugging_path: Path | None = None  # if set, write borg.logger debugging log to that_path/borg-*.log
 
 configured = False
 borg_serve_log_queue: queue.SimpleQueue = queue.SimpleQueue()
diff --git a/src/borg/platform/linux.pyx b/src/borg/platform/linux.pyx
index b307d44f9c..5ea9370cb5 100644
--- a/src/borg/platform/linux.pyx
+++ b/src/borg/platform/linux.pyx
@@ -153,7 +153,7 @@ def set_flags(path, bsd_flags, fd=None):
 
 def get_flags(path, st, fd=None):
     if stat.S_ISBLK(st.st_mode) or stat.S_ISCHR(st.st_mode) or stat.S_ISLNK(st.st_mode):
-        # Avoid opening device files—trying to open non-present devices can be rather slow.
+        # Avoid opening device files — trying to open non-present devices can be rather slow.
         # Avoid opening symlinks; O_NOFOLLOW would make the open() fail anyway.
         return 0
     cdef int linux_flags
diff --git a/src/borg/repository.py b/src/borg/repository.py
index 073cdfa500..42405c09fa 100644
--- a/src/borg/repository.py
+++ b/src/borg/repository.py
@@ -33,7 +33,7 @@ def repo_lister(repository, *, limit=None):
 
 
 class Repository:
-    """BorgStore-based key-value store."""
+    """borgstore-based key/value store."""
 
     class AlreadyExists(Error):
         """A repository already exists at {}."""
@@ -56,12 +56,12 @@ class InsufficientFreeSpaceError(Error):
         exit_mcode = 14
 
     class InvalidRepository(Error):
-        """{} is not a valid repository. Check the repository configuration."""
+        """{} is not a valid repository. Check the repository config."""
 
         exit_mcode = 15
 
     class InvalidRepositoryConfig(Error):
-        """{} does not have a valid configuration. Check the repository configuration [{}]."""
+        """{} does not have a valid config. Check the repository config [{}]."""
 
         exit_mcode = 16
 
diff --git a/src/borg/storelocking.py b/src/borg/storelocking.py
index 850e438539..25a9af30ee 100644
--- a/src/borg/storelocking.py
+++ b/src/borg/storelocking.py
@@ -213,7 +213,7 @@ def release(self, *, ignore_not_found=False):
         locks = self._find_locks(only_mine=True)
         if not locks:
             if ignore_not_found:
-                logger.debug("LOCK-RELEASE: trying to release a lock, but none was found.")
+                logger.debug("LOCK-RELEASE: trying to release the lock, but none was found.")
                 return
             else:
                 raise NotLocked(str(self.store))
@@ -246,7 +246,7 @@ def migrate_lock(self, old_id, new_id):
         self._delete_lock(old_locks[0]["key"], update_last_refresh=False)
 
     def refresh(self):
-        """Refreshes the lock—call this frequently, but not later than every <stale> seconds."""
+        """Refreshes the lock; call this frequently, but not later than every <stale> seconds."""
         now = datetime.datetime.now(datetime.timezone.utc)
         if self.last_refresh_dt is not None and now > self.last_refresh_dt + self.refresh_td:
             old_locks = self._find_locks(only_mine=True)
diff --git a/src/borg/testsuite/archive_test.py b/src/borg/testsuite/archive_test.py
index a44d26f5ea..a3028d7924 100644
--- a/src/borg/testsuite/archive_test.py
+++ b/src/borg/testsuite/archive_test.py
@@ -247,7 +247,7 @@ def test_invalid_msgpacked_item(packed, item_keys_serialized):
     assert not valid_msgpacked_dict(packed, item_keys_serialized)
 
 
-# pytest-xdist requires the same order for the keys and dicts:
+# pytest-xdist always requires the same order for the keys and dicts:
 IK = sorted(list(ITEM_KEYS))
 
 
diff --git a/src/borg/testsuite/archiver/__init__.py b/src/borg/testsuite/archiver/__init__.py
index 02dbd2a49d..11043877e1 100644
--- a/src/borg/testsuite/archiver/__init__.py
+++ b/src/borg/testsuite/archiver/__init__.py
@@ -35,7 +35,7 @@
 RK_ENCRYPTION = "--encryption=repokey-aes-ocb"
 KF_ENCRYPTION = "--encryption=keyfile-chacha20-poly1305"
 
-# This points to src/borg/archiver (small, with only a few files).
+# This points to the ``src/borg/archiver`` directory (small, with only a few files).
 src_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "archiver"))
 src_file = "archiver/__init__.py"  # relative path of one file in src_dir
 
@@ -108,7 +108,7 @@ def cmd_fixture(request):
     elif request.param == "binary":
         exe = "borg.exe"
     else:
-        raise ValueError("Parameter must be 'python' or 'binary'.")
+        raise ValueError("param must be 'python' or 'binary'.")
 
     def exec_fn(*args, **kw):
         return exec_cmd(*args, exe=exe, fork=True, **kw)
diff --git a/src/borg/testsuite/archiver/create_cmd_test.py b/src/borg/testsuite/archiver/create_cmd_test.py
index 0bda3810f5..82b515e590 100644
--- a/src/borg/testsuite/archiver/create_cmd_test.py
+++ b/src/borg/testsuite/archiver/create_cmd_test.py
@@ -85,7 +85,7 @@ def test_basic_functionality(archivers, request):
     if are_hardlinks_supported():
         expected.append("input/hardlink")
     if not have_root:
-        # We could not create these device files without (fake) root.
+        # We could not create these device files without (fake)root.
         expected.remove("input/bdev")
         expected.remove("input/cdev")
     if has_lchflags:
diff --git a/src/borg/testsuite/archiver/disk_full_test.py b/src/borg/testsuite/archiver/disk_full_test.py
index f03695b94d..8bf8a38ca4 100644
--- a/src/borg/testsuite/archiver/disk_full_test.py
+++ b/src/borg/testsuite/archiver/disk_full_test.py
@@ -1,5 +1,5 @@
 """
-Test "disk full" is very slow and not recommended for daily test runs.
+test_disk_full is very slow and not recommended for daily test runs.
 For this test, an empty, writable 700 MB filesystem mounted on DF_MOUNT is required.
 For speed and other reasons, it is recommended that the underlying block device is
 in RAM, not a magnetic or flash disk.
diff --git a/src/borg/testsuite/compress_test.py b/src/borg/testsuite/compress_test.py
index 99b7f6b6b8..c7d45444a1 100644
--- a/src/borg/testsuite/compress_test.py
+++ b/src/borg/testsuite/compress_test.py
@@ -56,7 +56,7 @@ def test_autodetect_invalid(invalid_cdata):
 
 def test_zlib_legacy_compat():
     # For compatibility reasons, we do not add an extra header for zlib,
-    # nor do we expect one when decompressing or auto-detecting
+    # nor do we expect one when decompressing / auto-detecting.
     for level in range(10):
         c = get_compressor(name="zlib_legacy", level=level, legacy_mode=True)
         meta1, cdata1 = c.compress({}, DATA)
diff --git a/src/borg/testsuite/helpers/fs_test.py b/src/borg/testsuite/helpers/fs_test.py
index 70acc42a08..49a6cf5e47 100644
--- a/src/borg/testsuite/helpers/fs_test.py
+++ b/src/borg/testsuite/helpers/fs_test.py
@@ -237,7 +237,7 @@ def test_dash_open():
     assert dash_open("-", "wb") is sys.stdout.buffer
 
 
-@pytest.mark.skipif(not are_hardlinks_supported(), reason="hard links not supported")
+@pytest.mark.skipif(not are_hardlinks_supported(), reason="hardlinks not supported")
 def test_safe_unlink_is_safe(tmpdir):
     contents = b"Hello, world\n"
     victim = tmpdir / "victim"
@@ -250,7 +250,7 @@ def test_safe_unlink_is_safe(tmpdir):
     assert victim.read_binary() == contents
 
 
-@pytest.mark.skipif(not are_hardlinks_supported(), reason="hard links not supported")
+@pytest.mark.skipif(not are_hardlinks_supported(), reason="hardlinks not supported")
 def test_safe_unlink_is_safe_ENOSPC(tmpdir, monkeypatch):
     contents = b"Hello, world\n"
     victim = tmpdir / "victim"
diff --git a/src/borg/testsuite/helpers/time_test.py b/src/borg/testsuite/helpers/time_test.py
index 1fbd4cad8e..7dcffc8278 100644
--- a/src/borg/testsuite/helpers/time_test.py
+++ b/src/borg/testsuite/helpers/time_test.py
@@ -11,26 +11,26 @@ def utcfromtimestamp(timestamp):
 
 def test_safe_timestamps():
     if SUPPORT_32BIT_PLATFORMS:
-        # Nanoseconds fit into int64.
+        # Nanoseconds fitting into int64.
         assert safe_ns(2**64) <= 2**63 - 1
         assert safe_ns(-1) == 0
-        # Seconds fit into int32.
+        # Seconds fitting into int32.
         assert safe_s(2**64) <= 2**31 - 1
         assert safe_s(-1) == 0
-        # datetime will not stumble over the Y10K problem.
+        # datetime will not stumble over its Y10K problem.
         beyond_y10k = 2**100
         with pytest.raises(OverflowError):
             utcfromtimestamp(beyond_y10k)
         assert utcfromtimestamp(safe_s(beyond_y10k)) > datetime(2038, 1, 1)
         assert utcfromtimestamp(safe_ns(beyond_y10k) / 1000000000) > datetime(2038, 1, 1)
     else:
-        # Nanoseconds fit into int64.
+        # Nanoseconds fitting into int64.
         assert safe_ns(2**64) <= 2**63 - 1
         assert safe_ns(-1) == 0
         # Seconds are limited so that their ns conversion fits into int64.
         assert safe_s(2**64) * 1000000000 <= 2**63 - 1
         assert safe_s(-1) == 0
-        # datetime will not stumble over the Y10K problem.
+        # datetime will not stumble over its Y10K problem.
         beyond_y10k = 2**100
         with pytest.raises(OverflowError):
             utcfromtimestamp(beyond_y10k)
diff --git a/src/borg/testsuite/legacyrepository_test.py b/src/borg/testsuite/legacyrepository_test.py
index 86d1d294f4..0b6a10aa5b 100644
--- a/src/borg/testsuite/legacyrepository_test.py
+++ b/src/borg/testsuite/legacyrepository_test.py
@@ -108,7 +108,7 @@ def add_keys(repository):
 def repo_dump(repository, label=None):
     label = label + ": " if label is not None else ""
     H_trans = {H(i): i for i in range(10)}
-    H_trans[None] = -1  # key is None appears in commits
+    H_trans[None] = -1  # key == None appears in commits
     tag_trans = {TAG_PUT2: "put2", TAG_PUT: "put", TAG_DELETE: "del", TAG_COMMIT: "comm"}
     for segment, fn in repository.io.segment_iterator():
         for tag, key, offset, size, _ in repository.io.iter_objects(segment):
diff --git a/src/borg/testsuite/version_test.py b/src/borg/testsuite/version_test.py
index 59622ceae8..4b4383332e 100644
--- a/src/borg/testsuite/version_test.py
+++ b/src/borg/testsuite/version_test.py
@@ -6,11 +6,11 @@
 @pytest.mark.parametrize(
     "version_str, version_tuple",
     [
-        # Setuptools < 8.0 uses "-"
+        # setuptools < 8.0 uses "-"
         ("1.0.0a1.dev204-g8866961.d20170606", (1, 0, 0, -4, 1)),
         ("1.0.0a1.dev204-g8866961", (1, 0, 0, -4, 1)),
         ("1.0.0-d20170606", (1, 0, 0, -1)),
-        # Setuptools >= 8.0 uses "+"
+        # setuptools >= 8.0 uses "+"
         ("1.0.0a1.dev204+g8866961.d20170606", (1, 0, 0, -4, 1)),
         ("1.0.0a1.dev204+g8866961", (1, 0, 0, -4, 1)),
         ("1.0.0+d20170606", (1, 0, 0, -1)),

From 5aa536df4c541f3fb98980352ded5c94ad66746b Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Tue, 23 Sep 2025 15:11:31 +0200
Subject: [PATCH 8/8] spelling: hard link(s)

---
 src/borg/archive.py                           | 24 +++++++++---------
 src/borg/archiver/create_cmd.py               |  2 +-
 src/borg/archiver/tar_cmds.py                 |  8 +++---
 src/borg/fuse.py                              |  2 +-
 src/borg/helpers/fs.py                        | 25 ++++++++++---------
 src/borg/helpers/parseformat.py               |  2 +-
 src/borg/legacyrepository.py                  |  2 +-
 src/borg/testsuite/archiver/__init__.py       |  2 +-
 .../testsuite/archiver/extract_cmd_test.py    |  8 +++---
 .../testsuite/archiver/mount_cmds_test.py     |  6 ++---
 .../testsuite/archiver/recreate_cmd_test.py   |  8 +++---
 src/borg/testsuite/archiver/tar_cmds_test.py  |  8 +++---
 .../testsuite/archiver/transfer_cmd_test.py   | 18 ++++++-------
 src/borg/testsuite/helpers/fs_test.py         |  4 +--
 src/borg/upgrade.py                           |  2 +-
 15 files changed, 61 insertions(+), 60 deletions(-)

diff --git a/src/borg/archive.py b/src/borg/archive.py
index 7ef7e00a9b..1e01c3b5ea 100644
--- a/src/borg/archive.py
+++ b/src/borg/archive.py
@@ -240,7 +240,7 @@ def stat_update_check(st_old, st_curr):
         # in this case, we dispatched to wrong handler - abort
         raise BackupRaceConditionError("file type changed (race condition), skipping file")
     if st_old.st_ino != st_curr.st_ino:
-        # in this case, the hardlinks-related code in create_helper has the wrong inode - abort!
+        # in this case, the hard-links-related code in create_helper has the wrong inode - abort!
         raise BackupRaceConditionError("file inode changed (race condition), skipping file")
     # looks ok, we are still dealing with the same thing - return current stat:
     return st_curr
@@ -290,7 +290,7 @@ def preload_item_chunks(self, item, optimize_hardlinks=False):
         """
         Preloads the content data chunks of an item (if any).
         optimize_hardlinks can be set to True if item chunks only need to be preloaded for
-        1st hardlink, but not for any further hardlink to same inode / with same hlid.
+        1st hard link, but not for any further hard link to same inode / with same hlid.
         Returns True if chunks were preloaded.
 
         Warning: if data chunks are preloaded then all data chunks have to be retrieved,
@@ -305,7 +305,7 @@ def preload_item_chunks(self, item, optimize_hardlinks=False):
                 elif hlid in self.hlids_preloaded:
                     preload_chunks = False
                 else:
-                    # not having the hardlink's chunks already preloaded for other hardlink to same inode
+                    # not having the hard link's chunks already preloaded for other hard link to same inode
                     preload_chunks = True
                     self.hlids_preloaded.add(hlid)
             else:
@@ -730,15 +730,15 @@ def extract_helper(self, item, path, hlm, *, dry_run=False):
             link_target = hlm.retrieve(id=item.hlid)
             if link_target is not None and has_link:
                 if not dry_run:
-                    # another hardlink to same inode (same hlid) was extracted previously, just link to it
+                    # another hard link to same inode (same hlid) was extracted previously, just link to it
                     with backup_io("link"):
                         os.link(link_target, path, follow_symlinks=False)
                 hardlink_set = True
         yield hardlink_set
         if not hardlink_set:
             if "hlid" in item and has_link:
-                # Update entry with extracted item path, so that following hardlinks don't extract twice.
-                # We have hardlinking support, so we will hardlink not extract.
+                # Update entry with extracted item path, so that following hard links don't extract twice.
+                # We have hardlinking support, so we will hard link not extract.
                 hlm.remember(id=item.hlid, info=path)
             else:
                 # Broken platform with no hardlinking support.
@@ -765,7 +765,7 @@ def extract_item(
         :param dry_run: do not write any data
         :param stdout: write extracted data to stdout
         :param sparse: write sparse files (chunk-granularity, independent of the original being sparse)
-        :param hlm: maps hlid to link_target for extracting subtrees with hardlinks correctly
+        :param hlm: maps hlid to link_target for extracting subtrees with hard links correctly
         :param pi: ProgressIndicatorPercent (or similar) for file extraction progress (in bytes)
         :param continue_extraction: continue a previously interrupted extraction of the same archive
         """
@@ -791,7 +791,7 @@ def same_item(item, st):
         if dry_run or stdout:
             with self.extract_helper(item, "", hlm, dry_run=dry_run or stdout) as hardlink_set:
                 if not hardlink_set:
-                    # it does not really set hardlinks due to dry_run, but we need to behave same
+                    # it does not really set hard links due to dry_run, but we need to behave same
                     # as non-dry_run concerning fetching preloaded chunks from the pipeline or
                     # it would get stuck.
                     if "chunks" in item:
@@ -1248,7 +1248,7 @@ def create_helper(self, path, st, status=None, hardlinkable=True, strip_prefix=N
         hl_chunks = None
         update_map = False
         if hardlinked:
-            status = "h"  # hardlink
+            status = "h"  # hard link
             nothing = object()
             chunks = self.hlm.retrieve(id=(st.st_ino, st.st_dev), default=nothing)
             if chunks is nothing:
@@ -1261,7 +1261,7 @@ def create_helper(self, path, st, status=None, hardlinkable=True, strip_prefix=N
         self.add_item(item, stats=self.stats)
         if update_map:
             # remember the hlid of this fs object and if the item has chunks,
-            # also remember them, so we do not have to re-chunk a hardlink.
+            # also remember them, so we do not have to re-chunk a hard link.
             chunks = item.chunks if "chunks" in item else None
             self.hlm.remember(id=(st.st_ino, st.st_dev), info=chunks)
 
@@ -1394,13 +1394,13 @@ def process_file(self, *, path, parent_fd, name, st, cache, flags=flags_normal,
                     # this needs to be done early, so that part files also get the patched mode.
                     item.mode = stat.S_IFREG | stat.S_IMODE(item.mode)
                 # we begin processing chunks now.
-                if hl_chunks is not None:  # create_helper gave us chunks from a previous hardlink
+                if hl_chunks is not None:  # create_helper gave us chunks from a previous hard link
                     item.chunks = []
                     for chunk_id, chunk_size in hl_chunks:
                         # process one-by-one, so we will know in item.chunks how far we got
                         chunk_entry = cache.reuse_chunk(chunk_id, chunk_size, self.stats)
                         item.chunks.append(chunk_entry)
-                else:  # normal case, no "2nd+" hardlink
+                else:  # normal case, no "2nd+" hard link
                     if not is_special_file:
                         hashed_path = safe_encode(item.path)  # path as in archive item!
                         started_hashing = time.monotonic()
diff --git a/src/borg/archiver/create_cmd.py b/src/borg/archiver/create_cmd.py
index 1301c0ccb2..82d0091480 100644
--- a/src/borg/archiver/create_cmd.py
+++ b/src/borg/archiver/create_cmd.py
@@ -696,7 +696,7 @@ def build_parser_create(self, subparsers, common_parser, mid_common_parser):
         - 'd' = directory
         - 'b' = block device
         - 'c' = char device
-        - 'h' = regular file, hardlink (to already seen inodes)
+        - 'h' = regular file, hard link (to already seen inodes)
         - 's' = symlink
         - 'f' = fifo
 
diff --git a/src/borg/archiver/tar_cmds.py b/src/borg/archiver/tar_cmds.py
index df455f8562..4a0dd4c225 100644
--- a/src/borg/archiver/tar_cmds.py
+++ b/src/borg/archiver/tar_cmds.py
@@ -140,8 +140,8 @@ def item_to_tarinfo(item, original_path):
             tarinfo.uname = item.get("user", "")
             tarinfo.gname = item.get("group", "")
             # The linkname in tar has 2 uses:
-            # for symlinks it means the destination, while for hardlinks it refers to the file.
-            # Since hardlinks in tar have a different type code (LNKTYPE) the format might
+            # for symlinks it means the destination, while for hard links it refers to the file.
+            # Since hard links in tar have a different type code (LNKTYPE) the format might
             # support hardlinking arbitrary objects (including symlinks and directories), but
             # whether implementations actually support that is a whole different question...
             tarinfo.linkname = ""
@@ -152,7 +152,7 @@ def item_to_tarinfo(item, original_path):
                 if "hlid" in item:
                     linkname = hlm.retrieve(id=item.hlid)
                     if linkname is not None:
-                        # the first hardlink was already added to the archive, add a tar-hardlink reference to it.
+                        # the first hard link was already added to the archive, add a tar-hard-link reference to it.
                         tarinfo.type = tarfile.LNKTYPE
                         tarinfo.linkname = linkname
                     else:
@@ -309,7 +309,7 @@ def _import_tar(self, args, repository, manifest, key, cache, tarstream):
             elif tarinfo.issym():
                 status = tfo.process_symlink(tarinfo=tarinfo, status="s", type=stat.S_IFLNK)
             elif tarinfo.islnk():
-                # tar uses a hardlink model like: the first instance of a hardlink is stored as a regular file,
+                # tar uses a hard link model like: the first instance of a hard link is stored as a regular file,
                 # later instances are special entries referencing back to the first instance.
                 status = tfo.process_hardlink(tarinfo=tarinfo, status="h", type=stat.S_IFREG)
             elif tarinfo.isblk():
diff --git a/src/borg/fuse.py b/src/borg/fuse.py
index 811d85defa..166142b147 100644
--- a/src/borg/fuse.py
+++ b/src/borg/fuse.py
@@ -422,7 +422,7 @@ def make_versioned_name(name, version, add_dir=False):
             else:
                 inode = item_inode
                 self._items[inode] = item
-                # remember extracted item path, so that following hardlinks don't extract twice.
+                # remember extracted item path, so that following hard links don't extract twice.
                 hlm.remember(id=item.hlid, info=path)
         else:
             inode = item_inode
diff --git a/src/borg/helpers/fs.py b/src/borg/helpers/fs.py
index 4b3b4a1665..07c2630547 100644
--- a/src/borg/helpers/fs.py
+++ b/src/borg/helpers/fs.py
@@ -320,7 +320,7 @@ def to_sanitized_path(path):
 
 class HardLinkManager:
     """
-    Manage hardlinks (and avoid code duplication doing so).
+    Manage hard links (and avoid code duplication doing so).
 
     A) When creating a borg2 archive from the filesystem, we have to maintain a mapping like:
        (dev, ino) -> (hlid, chunks)  # for fs_hl_targets
@@ -328,17 +328,18 @@ class HardLinkManager:
 
     B) When extracting a borg2 archive to the filesystem, we have to maintain a mapping like:
        hlid -> path
-       If we encounter the same hlid again later, we hardlink to the path of the already extracted content of same hlid.
+       If we encounter the same hlid again later, we hard link to the path of the already extracted
+       content of same hlid.
 
     C) When transferring from a borg1 archive, we need:
        path -> chunks_correct  # for borg1_hl_targets, chunks_correct must be either from .chunks_healthy or .chunks.
        If we encounter a regular file item with source == path later, we reuse chunks_correct
        and create the same hlid = hardlink_id_from_path(source).
 
-    D) When importing a tar file (simplified 1-pass way for now, not creating borg hardlink items):
+    D) When importing a tar file (simplified 1-pass way for now, not creating borg hard link items):
        path -> chunks
        If we encounter a LNK tar entry later with linkname==path, we re-use the chunks and create a regular file item.
-       For better hardlink support (including the very first hardlink item for each group of same-target hardlinks),
+       For better hard link support (including the very first hard link item for each group of same-target hard links),
        we would need a 2-pass processing, which is not yet implemented.
     """
 
@@ -357,12 +358,12 @@ def borg1_hardlink_slave(self, item):  # legacy
         return "source" in item and self.borg1_hardlinkable(item.mode)
 
     def hardlink_id_from_path(self, path):
-        """compute a hardlink id from a path"""
+        """compute a hard link id from a path"""
         assert isinstance(path, str)
         return hashlib.sha256(path.encode("utf-8", errors="surrogateescape")).digest()
 
     def hardlink_id_from_inode(self, *, ino, dev):
-        """compute a hardlink id from an inode"""
+        """compute a hard link id from an inode"""
         assert isinstance(ino, int)
         assert isinstance(dev, int)
         return hashlib.sha256(f"{ino}/{dev}".encode()).digest()
@@ -414,11 +415,11 @@ def secure_erase(path, *, avoid_collateral_damage):
 
     If avoid_collateral_damage is True, we only secure erase if the total link count is 1,
     otherwise we just do a normal "delete" (unlink) without first overwriting it with random.
-    This avoids other hardlinks pointing to same inode as <path> getting damaged, but might be less secure.
-    A typical scenario where this is useful are quick "hardlink copies" of bigger directories.
+    This avoids other hard links pointing to same inode as <path> getting damaged, but might be less secure.
+    A typical scenario where this is useful are quick "hard link copies" of bigger directories.
 
     If avoid_collateral_damage is False, we always secure erase.
-    If there are hardlinks pointing to the same inode as <path>, they will contain random garbage afterwards.
+    If there are hard links pointing to the same inode as <path>, they will contain random garbage afterwards.
     """
     path_obj = Path(path)
     with path_obj.open("r+b") as fd:
@@ -435,7 +436,7 @@ def safe_unlink(path):
     Safely unlink (delete) *path*.
 
     If we run out of space while deleting the file, we try truncating it first.
-    BUT we truncate only if path is the only hardlink referring to this content.
+    BUT we truncate only if path is the only hard link referring to this content.
 
     Use this when deleting potentially large files when recovering
     from a VFS error such as ENOSPC. It can help a full file system
@@ -452,9 +453,9 @@ def safe_unlink(path):
         # we ran out of space while trying to delete the file.
         st = path_obj.stat()
         if st.st_nlink > 1:
-            # rather give up here than cause collateral damage to the other hardlink.
+            # rather give up here than cause collateral damage to the other hard link.
             raise
-        # no other hardlink! try to recover free space by truncating this file.
+        # no other hard link! try to recover free space by truncating this file.
         try:
             # Do not create *path* if it does not exist, open for truncation in r+b mode (=O_RDWR|O_BINARY).
             with open(path, "r+b") as fd:
diff --git a/src/borg/helpers/parseformat.py b/src/borg/helpers/parseformat.py
index 548d0cd767..5f051d0eca 100644
--- a/src/borg/helpers/parseformat.py
+++ b/src/borg/helpers/parseformat.py
@@ -945,7 +945,7 @@ def calculate_num_chunks(self, item):
         return len(item.get("chunks", []))
 
     def calculate_size(self, item):
-        # note: does not support hardlink slaves, they will be size 0
+        # note: does not support hard link slaves, they will be size 0
         return item.get_size()
 
     def hash_item(self, hash_function, item):
diff --git a/src/borg/legacyrepository.py b/src/borg/legacyrepository.py
index 995d508d47..719f947f17 100644
--- a/src/borg/legacyrepository.py
+++ b/src/borg/legacyrepository.py
@@ -338,7 +338,7 @@ def save_config(self, path, config):
 
         if os.path.isfile(config_path):
             link_error_msg = (
-                "Failed to erase old repository config file securely (hardlinks not supported). "
+                "Failed to erase old repository config file securely (hard links not supported). "
                 "Old repokey data, if any, might persist on physical storage."
             )
             try:
diff --git a/src/borg/testsuite/archiver/__init__.py b/src/borg/testsuite/archiver/__init__.py
index 11043877e1..2a546f28bd 100644
--- a/src/borg/testsuite/archiver/__init__.py
+++ b/src/borg/testsuite/archiver/__init__.py
@@ -39,7 +39,7 @@
 src_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "archiver"))
 src_file = "archiver/__init__.py"  # relative path of one file in src_dir
 
-requires_hardlinks = pytest.mark.skipif(not are_hardlinks_supported(), reason="hardlinks not supported")
+requires_hardlinks = pytest.mark.skipif(not are_hardlinks_supported(), reason="hard links not supported")
 
 
 def exec_cmd(*args, archiver=None, fork=False, exe=None, input=b"", binary_output=False, **kw):
diff --git a/src/borg/testsuite/archiver/extract_cmd_test.py b/src/borg/testsuite/archiver/extract_cmd_test.py
index 0ae3dd94af..c8369b5547 100644
--- a/src/borg/testsuite/archiver/extract_cmd_test.py
+++ b/src/borg/testsuite/archiver/extract_cmd_test.py
@@ -46,7 +46,7 @@ def test_symlink_extract(archivers, request):
 
 @pytest.mark.skipif(
     not are_symlinks_supported() or not are_hardlinks_supported() or is_darwin,
-    reason="symlinks or hardlinks or hardlinked symlinks not supported",
+    reason="symbolic links or hard links or hard-linked sym-links not supported",
 )
 def test_hardlinked_symlinks_extract(archivers, request):
     archiver = request.getfixturevalue(archivers)
@@ -323,7 +323,7 @@ def test_extract_hardlinks_twice(archivers, request):
         # if issue #5603 happens, extraction gives rc == 1 (triggering AssertionError) and warnings like:
         # input/a/hardlink: link: [Errno 2] No such file or directory: 'input/a/hardlink' -> 'input/a/hardlink'
         # input/b/hardlink: link: [Errno 2] No such file or directory: 'input/a/hardlink' -> 'input/b/hardlink'
-        # otherwise, when fixed, the hardlinks should be there and have a link count of 2
+        # otherwise, when fixed, the hard links should be there and have a link count of 2
         assert os.stat("input/a/hardlink").st_nlink == 2
         assert os.stat("input/b/hardlink").st_nlink == 2
 
@@ -690,12 +690,12 @@ def test_extract_continue(archivers, request):
         file1_st = os.stat("input/file1")
         # simulate a partially extracted file2 (smaller size, archived mtime not yet set)
         file2_st = os.stat("input/file2")
-        # make a hardlink, so it does not free the inode when unlinking input/file2
+        # make a hard link, so it does not free the inode when unlinking input/file2
         os.link("input/file2", "hardlink-to-keep-inode-f2")
         os.truncate("input/file2", 123)  # -> incorrect size, incorrect mtime
         # simulate file3 has not yet been extracted
         file3_st = os.stat("input/file3")
-        # make a hardlink, so it does not free the inode when unlinking input/file3
+        # make a hard link, so it does not free the inode when unlinking input/file3
         os.link("input/file3", "hardlink-to-keep-inode-f3")
         os.remove("input/file3")
     time.sleep(1)  # needed due to timestamp granularity of apple hfs+
diff --git a/src/borg/testsuite/archiver/mount_cmds_test.py b/src/borg/testsuite/archiver/mount_cmds_test.py
index 45623af1e6..88dd1d83a4 100644
--- a/src/borg/testsuite/archiver/mount_cmds_test.py
+++ b/src/borg/testsuite/archiver/mount_cmds_test.py
@@ -113,12 +113,12 @@ def has_noatime(some_file):
         assert same_ts_ns(sti1.st_ctime * 1e9, sto1.st_ctime * 1e9)
         assert same_ts_ns(sti1.st_mtime * 1e9, sto1.st_mtime * 1e9)
         if are_hardlinks_supported():
-            # note: there is another hardlink to this, see below
+            # note: there is another hard link to this, see below
             assert sti1.st_nlink == sto1.st_nlink == 2
         # read
         with open(in_fn, "rb") as in_f, open(out_fn, "rb") as out_f:
             assert in_f.read() == out_f.read()
-        # hardlink (to 'input/file1')
+        # hard link (to 'input/file1')
         if are_hardlinks_supported():
             in_fn = "input/hardlink"
             out_fn = os.path.join(mountpoint, "archive", "input", "hardlink")
@@ -191,7 +191,7 @@ def test_fuse_versions_view(archivers, request):
             hl3 = os.path.join(mountpoint, "input", "hardlink3", "hardlink3.00001")
             assert os.stat(hl1).st_ino == os.stat(hl2).st_ino == os.stat(hl3).st_ino
             assert open(hl3, "rb").read() == b"123456"
-    # similar again, but exclude the 1st hardlink:
+    # similar again, but exclude the 1st hard link:
     with fuse_mount(archiver, mountpoint, "-o", "versions", "-e", "input/hardlink1"):
         if are_hardlinks_supported():
             hl2 = os.path.join(mountpoint, "input", "hardlink2", "hardlink2.00001")
diff --git a/src/borg/testsuite/archiver/recreate_cmd_test.py b/src/borg/testsuite/archiver/recreate_cmd_test.py
index 4fae8e27de..ec7d6ea5e8 100644
--- a/src/borg/testsuite/archiver/recreate_cmd_test.py
+++ b/src/borg/testsuite/archiver/recreate_cmd_test.py
@@ -59,7 +59,7 @@ def test_recreate_exclude_keep_tagged(archivers, request):
     _assert_test_keep_tagged(archiver)
 
 
-@pytest.mark.skipif(not are_hardlinks_supported(), reason="hardlinks not supported")
+@pytest.mark.skipif(not are_hardlinks_supported(), reason="hard links not supported")
 def test_recreate_hardlinked_tags(archivers, request):  # test for issue #4911
     archiver = request.getfixturevalue(archivers)
     cmd(archiver, "repo-create", "--encryption=none")
@@ -69,11 +69,11 @@ def test_recreate_hardlinked_tags(archivers, request):  # test for issue #4911
     os.mkdir(os.path.join(archiver.input_path, "subdir"))  # to make sure the tag is encountered *after* file1
     os.link(
         os.path.join(archiver.input_path, "file1"), os.path.join(archiver.input_path, "subdir", CACHE_TAG_NAME)
-    )  # correct tag name, hardlink to file1
+    )  # correct tag name, hard link to file1
     cmd(archiver, "create", "test", "input")
     # in the "test" archive, we now have, in this order:
     # - a regular file item for "file1"
-    # - a hardlink item for "CACHEDIR.TAG" referring back to file1 for its contents
+    # - a hard link item for "CACHEDIR.TAG" referring back to file1 for its contents
     cmd(archiver, "recreate", "test", "--exclude-caches", "--keep-exclude-tags")
     # if issue #4911 is present, the recreate will crash with a KeyError for "input/file1"
 
@@ -113,7 +113,7 @@ def test_recreate_basic(archivers, request):
     assert "dir2/file3" not in listing
 
 
-@pytest.mark.skipif(not are_hardlinks_supported(), reason="hardlinks not supported")
+@pytest.mark.skipif(not are_hardlinks_supported(), reason="hard links not supported")
 def test_recreate_subtree_hardlinks(archivers, request):
     archiver = request.getfixturevalue(archivers)
     # This is essentially the same problem set as in test_extract_hardlinks
diff --git a/src/borg/testsuite/archiver/tar_cmds_test.py b/src/borg/testsuite/archiver/tar_cmds_test.py
index 10f8311ac7..13a4a775e3 100644
--- a/src/borg/testsuite/archiver/tar_cmds_test.py
+++ b/src/borg/testsuite/archiver/tar_cmds_test.py
@@ -105,7 +105,7 @@ def test_extract_hardlinks_tar(archivers, request):
 
 def test_import_tar(archivers, request, tar_format="PAX"):
     archiver = request.getfixturevalue(archivers)
-    create_test_files(archiver.input_path, create_hardlinks=False)  # hardlinks become separate files
+    create_test_files(archiver.input_path, create_hardlinks=False)  # hard links become separate files
     os.unlink("input/flagfile")
     cmd(archiver, "repo-create", "--encryption=none")
     cmd(archiver, "create", "src", "input")
@@ -148,7 +148,7 @@ def test_import_tar_with_dotdot(archivers, request):
 @requires_gzip
 def test_import_tar_gz(archivers, request, tar_format="GNU"):
     archiver = request.getfixturevalue(archivers)
-    create_test_files(archiver.input_path, create_hardlinks=False)  # hardlinks become separate files
+    create_test_files(archiver.input_path, create_hardlinks=False)  # hard links become separate files
     os.unlink("input/flagfile")
     cmd(archiver, "repo-create", "--encryption=none")
     cmd(archiver, "create", "src", "input")
@@ -162,7 +162,7 @@ def test_import_tar_gz(archivers, request, tar_format="GNU"):
 @requires_gnutar
 def test_import_concatenated_tar_with_ignore_zeros(archivers, request):
     archiver = request.getfixturevalue(archivers)
-    create_test_files(archiver.input_path, create_hardlinks=False)  # hardlinks become separate files
+    create_test_files(archiver.input_path, create_hardlinks=False)  # hard links become separate files
     os.unlink("input/flagfile")
     with changedir("input"):
         subprocess.check_call(["tar", "cf", "file1.tar", "file1"])
@@ -191,7 +191,7 @@ def test_import_concatenated_tar_with_ignore_zeros(archivers, request):
 @requires_gnutar
 def test_import_concatenated_tar_without_ignore_zeros(archivers, request):
     archiver = request.getfixturevalue(archivers)
-    create_test_files(archiver.input_path, create_hardlinks=False)  # hardlinks become separate files
+    create_test_files(archiver.input_path, create_hardlinks=False)  # hard links become separate files
     os.unlink("input/flagfile")
 
     with changedir("input"):
diff --git a/src/borg/testsuite/archiver/transfer_cmd_test.py b/src/borg/testsuite/archiver/transfer_cmd_test.py
index 25ec66726d..b25fe8c9d5 100644
--- a/src/borg/testsuite/archiver/transfer_cmd_test.py
+++ b/src/borg/testsuite/archiver/transfer_cmd_test.py
@@ -119,24 +119,24 @@ def convert_tz(local_naive, tzoffset, tzinfo):
                 if key in e:
                     e[key] = convert_tz(e[key], repo12_tzoffset, None)
 
-            # borg 1 used hardlink slaves linking back to their hardlink masters.
-            # borg 2 uses symmetric approach: just normal items. if they are hardlinks,
+            # borg 1 used hard link slaves linking back to their hard link masters.
+            # borg 2 uses symmetric approach: just normal items. if they are hard links,
             # each item has normal attributes, including the chunks list, size. additionally,
-            # they have a hlid and same hlid means same inode / belonging to same set of hardlinks.
+            # they have a hlid and same hlid means same inode / belonging to same set of hard links.
             hardlink = bool(g.get("hlid"))  # note: json has "" as hlid if there is no hlid in the item
             if hardlink:
                 hardlinks[g["path"]] = g["hlid"]
                 if e["mode"].startswith("h"):
-                    # fix expectations: borg1 signalled a hardlink slave with "h"
-                    # borg2 treats all hardlinks symmetrically as normal files
+                    # fix expectations: borg1 signalled a hard link slave with "h"
+                    # borg2 treats all hard links symmetrically as normal files
                     e["mode"] = g["mode"][0] + e["mode"][1:]
-                    # borg1 used source/linktarget to link back to hardlink master
+                    # borg1 used source/linktarget to link back to hard link master
                     assert e["source"] != ""
                     assert e["linktarget"] != ""
-                    # fix expectations: borg2 does not use source/linktarget any more for hardlinks
+                    # fix expectations: borg2 does not use source/linktarget any more for hard links
                     e["source"] = ""
                     e["linktarget"] = ""
-                    # borg 1 has size == 0 for hardlink slaves, borg 2 has the real file size
+                    # borg 1 has size == 0 for hard link slaves, borg 2 has the real file size
                     assert e["size"] == 0
                     assert g["size"] >= 0
                     # fix expectation for size
@@ -160,7 +160,7 @@ def convert_tz(local_naive, tzoffset, tzinfo):
             assert g == e
 
         if name == "archive1":
-            # hardlinks referring to same inode have same hlid
+            # hard links referring to same inode have same hlid
             assert hardlinks["tmp/borgtest/hardlink1"] == hardlinks["tmp/borgtest/hardlink2"]
 
     repo_path = f"{original_location}2"
diff --git a/src/borg/testsuite/helpers/fs_test.py b/src/borg/testsuite/helpers/fs_test.py
index 49a6cf5e47..70acc42a08 100644
--- a/src/borg/testsuite/helpers/fs_test.py
+++ b/src/borg/testsuite/helpers/fs_test.py
@@ -237,7 +237,7 @@ def test_dash_open():
     assert dash_open("-", "wb") is sys.stdout.buffer
 
 
-@pytest.mark.skipif(not are_hardlinks_supported(), reason="hardlinks not supported")
+@pytest.mark.skipif(not are_hardlinks_supported(), reason="hard links not supported")
 def test_safe_unlink_is_safe(tmpdir):
     contents = b"Hello, world\n"
     victim = tmpdir / "victim"
@@ -250,7 +250,7 @@ def test_safe_unlink_is_safe(tmpdir):
     assert victim.read_binary() == contents
 
 
-@pytest.mark.skipif(not are_hardlinks_supported(), reason="hardlinks not supported")
+@pytest.mark.skipif(not are_hardlinks_supported(), reason="hard links not supported")
 def test_safe_unlink_is_safe_ENOSPC(tmpdir, monkeypatch):
     contents = b"Hello, world\n"
     victim = tmpdir / "victim"
diff --git a/src/borg/upgrade.py b/src/borg/upgrade.py
index 276025393b..35d9688371 100644
--- a/src/borg/upgrade.py
+++ b/src/borg/upgrade.py
@@ -90,7 +90,7 @@ def upgrade_item(self, *, item):
                 item.chunks = chunks
                 for chunk_id, chunk_size in chunks:
                     self.cache.reuse_chunk(chunk_id, chunk_size, self.archive.stats)
-            del item.source  # not used for hardlinks any more, replaced by hlid
+            del item.source  # not used for hard links anymore, replaced by hlid
         # make sure we only have desired stuff in the new item. specifically, make sure to get rid of:
         # - 'acl' remnants of bug in attic <= 0.13
         # - 'hardlink_master' (superseded by hlid)