diff --git a/.dockerignore b/.dockerignore
index 98084ce..14e031a 100644
--- a/.dockerignore
+++ b/.dockerignore
@@ -1,8 +1,5 @@
 # Version control
-# .git is intentionally NOT excluded - the Dockerfile reads it at build
-# time (git rev-parse) to bake the running commit into the image as
-# /app/BUILD_VERSION, then deletes .git itself in that same build step so
-# it never ends up in the final image.
+.git
 .gitignore
 .github
 
diff --git a/Dockerfile b/Dockerfile
index 9d2a461..069aa8e 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -5,9 +5,8 @@ FROM python:3.13.5-slim-bookworm
 WORKDIR /app
 
 # ffprobe (from ffmpeg) reads each video's duration for the library
-# browser's "how long is this course" display; git is only needed
-# transiently below, to bake this build's commit into the image
-RUN apt-get update && apt-get install -y --no-install-recommends ffmpeg git \
+# browser's "how long is this course" display
+RUN apt-get update && apt-get install -y --no-install-recommends ffmpeg \
     && rm -rf /var/lib/apt/lists/*
 
 # copy the dependencies file to the working directory
@@ -20,15 +19,6 @@ RUN pip install -r requirements.txt
 # copy the content of the local src directory to the working directory
 COPY . .
 
-# Record which commit and when this image was built, so the running app
-# can show it (Settings page, /health) - a full-image-rebuild webhook
-# deploy gives no other visible confirmation that a push actually landed
-# in the running container. .git is removed right after so the image
-# doesn't carry the repo's full history.
-RUN (git rev-parse --short HEAD 2>/dev/null || echo unknown) > /app/BUILD_VERSION \
-    && date -u +"%Y-%m-%d %H:%M UTC" >> /app/BUILD_VERSION \
-    && rm -rf /app/.git
-
 EXPOSE 5000
 
 # add healthcheck using Python standard library
diff --git a/README.md b/README.md
index 90777c8..fb2cc01 100644
--- a/README.md
+++ b/README.md
@@ -44,13 +44,16 @@ triggers a full image **rebuild** from the Dockerfile (confirmed, not just a
 container restart), so Dockerfile changes (e.g. adding `ffmpeg`) take effect
 on the very next push without any manual step.
 
-**Confirming a deploy landed:** the Dockerfile bakes the exact commit and
-build time into the image as `/app/BUILD_VERSION` (`git rev-parse` at build
-time, `.git` itself is deleted again right after so it doesn't ship in the
-image) - shown at the bottom of the Settings page and in `/health`'s JSON
-response, so after a push you can check the running container actually
-picked it up instead of guessing. Reads as `dev` outside Docker (no
-`BUILD_VERSION` file to read).
+**Confirming a deploy landed:** a plain `VERSION` file at the repo root
+(a timestamp + short description, updated by hand alongside each commit)
+ships into the image via the normal `COPY . .` and is shown at the bottom
+of the Settings page and in `/health`'s JSON response, so after a push you
+can check the running container actually picked it up instead of
+guessing. Deliberately not derived from `git rev-parse` at Docker build
+time - Dockhand's build context doesn't reliably have `.git` available,
+which silently produced "unknown" instead of an actual commit. Reads as
+`dev` outside Docker (no `VERSION` file to read, e.g. before the first
+commit that adds one).
 
 ---
 
diff --git a/VERSION b/VERSION
new file mode 100644
index 0000000..9609c20
--- /dev/null
+++ b/VERSION
@@ -0,0 +1 @@
+2026-08-24 17:56 UTC — version display fix
diff --git a/offlineu_core.py b/offlineu_core.py
index c1f3c16..8e4d294 100644
--- a/offlineu_core.py
+++ b/offlineu_core.py
@@ -33,22 +33,23 @@ app.config['SECRET_KEY'] = 'your-secret-key-change-in-production'
 
 def _load_build_version() -> str:
     """
-    Commit + build time baked into the image at build time (see
-    Dockerfile) - lets Settings and /health show which version is
-    actually running, the only way to confirm a git push made it into a
-    rebuilt container, since the webhook does a full image rebuild with
-    no other visible confirmation. Falls back to 'dev' outside Docker,
-    where there's no BUILD_VERSION file (e.g. running via --library-path
-    directly).
+    Reads the repo-committed VERSION file - lets Settings and /health show
+    which version is actually running, the only way to confirm a push made
+    it into a rebuilt container, since the webhook does a full image
+    rebuild with no other visible confirmation. Deliberately a plain file
+    checked into the repo (updated by hand alongside each commit) rather
+    than baked from `git rev-parse` at Docker build time: Dockhand's build
+    context doesn't reliably have .git available, which silently produced
+    "unknown" instead of a real commit. Falls back to 'dev' if the file is
+    ever missing (shouldn't happen once committed, since it ships via the
+    same COPY . . as everything else).
     """
-    version_file = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'BUILD_VERSION')
+    version_file = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'VERSION')
     try:
         with open(version_file, 'r') as f:
-            lines = [line.strip() for line in f if line.strip()]
-        if len(lines) >= 2:
-            return f'{lines[0]} · built {lines[1]}'
-        if lines:
-            return lines[0]
+            content = f.read().strip()
+        if content:
+            return content
     except OSError:
         pass
     return 'dev'