diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0adf7ce22..645f63b86 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,6 +7,21 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [7.2.4] - 21 July 2026
+
+### Added
+
+* Added shortcuts to the editors for easily inserting dates and times
+  * `@now` / `@time` inserts `HH:mm:ss UTC`
+  * `@today` / `@date` inserts the date using Django’s configured `DATE_FORMAT`
+  * Spaces and unicode punctuation trigger the expansion
+  * There are guards in place so code blocks and email-like strings do not trigger expansion
+  * If an editor is left open overnight, there is a trigger to refresh the date
+
+### Fixed
+
+* Fixed an issue where a blank line would be included after lists in report output
+
 ## [7.2.3] - 18 July 2026
 
 ### Added
diff --git a/DOCS/features/operation-logs/create-a-new-entry.mdx b/DOCS/features/operation-logs/create-a-new-entry.mdx
index 0cf0a76fc..dc7e1573a 100644
--- a/DOCS/features/operation-logs/create-a-new-entry.mdx
+++ b/DOCS/features/operation-logs/create-a-new-entry.mdx
@@ -20,6 +20,11 @@ To manually create an entry, click on the "Create a new entry" button in the act
 
 You see a new row appear pre-populated with the current UTC timestamps and your username in the _Operator_ field.
 
+<Tip>
+When writing in a rich text field, type `@today` or `@date` followed by a space or punctuation to insert the current UTC date using
+Ghostwriter's configured date format. Type `@now` or `@time` the same way to insert the current time in UTC, such as `20:14:13 UTC`.
+</Tip>
+
 ### Modifying an Entry
 
 You can modify fields by double-clicking the table row you want to edit or pressing _Enter_ while it is selected. A modal form will open:
diff --git a/DOCS/features/reporting/collaborative-editor/editor-features.mdx b/DOCS/features/reporting/collaborative-editor/editor-features.mdx
index 42283bb1b..932f36b52 100644
--- a/DOCS/features/reporting/collaborative-editor/editor-features.mdx
+++ b/DOCS/features/reporting/collaborative-editor/editor-features.mdx
@@ -5,6 +5,13 @@ description: "Features of the collaborative editor"
 
 Collaborative editing is the star of the show, but the editor contains other features worth exploring.
 
+## Inserting the Current Date and Time
+
+Type `@today` or its alias `@date` followed by a space or punctuation to insert the current UTC date using Ghostwriter's configured date
+format. For example, with the default format, `@today,` becomes `21 Jul 2026,`. Type `@now` or its alias `@time` the same way to insert
+the current time in UTC, such as `20:14:13 UTC`. The inserted values are ordinary text and do not change afterward. The shortcuts are
+disabled inside inline code and code blocks.
+
 ## Inserting Objects
 
 The editor supports inserting objects that make it easier to visualize certain elements of your writing, such as captions and evidence files.
diff --git a/DOCS/sample_reports/template.docx b/DOCS/sample_reports/template.docx
index 52ddc15ea..56986c02e 100644
Binary files a/DOCS/sample_reports/template.docx and b/DOCS/sample_reports/template.docx differ
diff --git a/VERSION b/VERSION
index 6ea2e395e..0852c00de 100644
--- a/VERSION
+++ b/VERSION
@@ -1,2 +1,2 @@
-v7.2.3
-18 July 2026
+v7.2.4
+21 July 2026
diff --git a/config/settings/base.py b/config/settings/base.py
index 380625f0e..6240bde31 100644
--- a/config/settings/base.py
+++ b/config/settings/base.py
@@ -11,9 +11,9 @@
 # 3rd Party Libraries
 import environ
 
-__version__ = "7.2.3"
+__version__ = "7.2.4"
 VERSION = __version__
-RELEASE_DATE = "18 July 2026"
+RELEASE_DATE = "21 July 2026"
 
 ROOT_DIR = Path(__file__).resolve(strict=True).parent.parent.parent
 APPS_DIR = ROOT_DIR / "ghostwriter"
diff --git a/ghostwriter/commandcenter/templates/user_extra_fields/admin_change_form.html b/ghostwriter/commandcenter/templates/user_extra_fields/admin_change_form.html
index 3b2b311bb..e162ed314 100644
--- a/ghostwriter/commandcenter/templates/user_extra_fields/admin_change_form.html
+++ b/ghostwriter/commandcenter/templates/user_extra_fields/admin_change_form.html
@@ -3,6 +3,7 @@
 
 {% block admin_change_form_document_ready %}
 {{ block.super }}
+{% include "snippets/editor_shortcuts_config.html" %}
 {% if original.is_collab_editable %}
     <script type="module" src="{% static 'assets/admin_tiptap.js' %}"></script>
     <link rel="stylesheet" href="{% static 'assets/collab_common.css' %}">
@@ -101,4 +102,4 @@
         });
     });
 </script>
-{% endblock %}
\ No newline at end of file
+{% endblock %}
diff --git a/ghostwriter/context_processors.py b/ghostwriter/context_processors.py
index 953685456..a6dba9dcb 100644
--- a/ghostwriter/context_processors.py
+++ b/ghostwriter/context_processors.py
@@ -1,9 +1,17 @@
 # Django Imports
 from django.conf import settings
 
+# Ghostwriter Libraries
+from ghostwriter.home.editor_shortcuts import get_editor_shortcuts_date_config
+
 
 def selected_settings(request):
     return {
         "VERSION": settings.VERSION,
         "RELEASE_DATE": settings.RELEASE_DATE,
+        "EDITOR_SHORTCUTS_DATE_CONFIG": (
+            get_editor_shortcuts_date_config()
+            if request.user.is_authenticated
+            else None
+        ),
     }
diff --git a/ghostwriter/home/editor_shortcuts.py b/ghostwriter/home/editor_shortcuts.py
new file mode 100644
index 000000000..e7464cb73
--- /dev/null
+++ b/ghostwriter/home/editor_shortcuts.py
@@ -0,0 +1,32 @@
+"""Server-provided configuration for rich-text editor date shortcuts."""
+
+# Standard Libraries
+from datetime import datetime, time, timedelta, timezone as datetime_timezone
+
+# Django Imports
+from django.conf import settings
+from django.urls import reverse
+from django.utils import dateformat, timezone
+
+
+def _current_utc_time():
+    """Return the current time normalized to UTC."""
+    return timezone.now().astimezone(datetime_timezone.utc)
+
+
+def get_editor_shortcuts_date_config():
+    """Return the formatted current UTC date and its next UTC rollover."""
+    current_time = _current_utc_time()
+    current_date = current_time.date()
+    next_midnight = datetime.combine(
+        current_date + timedelta(days=1),
+        time.min,
+        tzinfo=datetime_timezone.utc,
+    )
+
+    return {
+        "date": dateformat.format(current_date, settings.DATE_FORMAT),
+        "expiresAt": round(next_midnight.timestamp() * 1000),
+        "serverTime": round(current_time.timestamp() * 1000),
+        "refreshUrl": reverse("home:ajax_editor_shortcuts_date"),
+    }
diff --git a/ghostwriter/home/tests/test_views.py b/ghostwriter/home/tests/test_views.py
index 3da594de5..f10f950fc 100644
--- a/ghostwriter/home/tests/test_views.py
+++ b/ghostwriter/home/tests/test_views.py
@@ -1,15 +1,18 @@
 # Standard Libraries
 import logging
-from datetime import date, datetime, timedelta
+from datetime import date, datetime, timedelta, timezone as datetime_timezone
 from io import StringIO
+from unittest.mock import patch
+from zoneinfo import ZoneInfo
 
 # Django Imports
 from django.conf import settings
 from django.core.management import call_command
 from django.core.management.base import CommandError
 from django.db.models import Q
-from django.test import Client, TestCase
+from django.test import Client, TestCase, override_settings
 from django.urls import reverse
+from django.utils import timezone
 
 # 3rd Party Libraries
 from allauth.mfa.totp.internal.auth import generate_totp_secret, TOTP
@@ -35,6 +38,56 @@
 PASSWORD = "SuperNaturalReporting!"
 
 
+class EditorShortcutsDateTests(TestCase):
+    """Tests for refreshing server-formatted editor shortcut dates."""
+
+    @classmethod
+    def setUpTestData(cls):
+        cls.user = UserFactory(password=PASSWORD)
+        cls.uri = reverse("home:ajax_editor_shortcuts_date")
+
+    def setUp(self):
+        self.client = Client()
+        self.client_auth = Client()
+        self.assertTrue(
+            self.client_auth.login(username=self.user.username, password=PASSWORD)
+        )
+
+    def test_view_requires_login(self):
+        response = self.client.get(self.uri)
+
+        self.assertEqual(response.status_code, 302)
+
+    @override_settings(DATE_FORMAT="Y/m/d")
+    @patch("ghostwriter.home.editor_shortcuts._current_utc_time")
+    def test_view_returns_date_and_next_utc_midnight(self, mock_current_utc_time):
+        local_timezone = ZoneInfo("America/Los_Angeles")
+        local_time = datetime(2026, 7, 21, 23, 59, 30, tzinfo=local_timezone)
+        current_time = local_time.astimezone(datetime_timezone.utc)
+        mock_current_utc_time.return_value = current_time
+
+        with timezone.override(local_timezone):
+            response = self.client_auth.get(self.uri)
+
+        next_midnight = datetime(2026, 7, 23, tzinfo=datetime_timezone.utc)
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(
+            response.json(),
+            {
+                "date": "2026/07/22",
+                "expiresAt": round(next_midnight.timestamp() * 1000),
+                "serverTime": round(current_time.timestamp() * 1000),
+                "refreshUrl": self.uri,
+            },
+        )
+        self.assertIn("no-store", response.headers["Cache-Control"])
+
+    def test_view_rejects_post(self):
+        response = self.client_auth.post(self.uri)
+
+        self.assertEqual(response.status_code, 405)
+
+
 # Tests related to custom management commands
 
 
diff --git a/ghostwriter/home/urls.py b/ghostwriter/home/urls.py
index 8f68f6ce9..772bce038 100644
--- a/ghostwriter/home/urls.py
+++ b/ghostwriter/home/urls.py
@@ -17,6 +17,11 @@
 
 # URLs for AJAX test functions
 urlpatterns += [
+    path(
+        "ajax/editor-shortcuts/date",
+        views.editor_shortcuts_date,
+        name="ajax_editor_shortcuts_date",
+    ),
     path(
         "ajax/management/test/aws",
         views.TestAWSConnection.as_view(),
diff --git a/ghostwriter/home/views.py b/ghostwriter/home/views.py
index de56582e0..b75850239 100644
--- a/ghostwriter/home/views.py
+++ b/ghostwriter/home/views.py
@@ -12,6 +12,8 @@
 from django.db.models import Prefetch, Q
 from django.http import HttpResponseNotAllowed, JsonResponse
 from django.shortcuts import redirect, render
+from django.views.decorators.cache import never_cache
+from django.views.decorators.http import require_GET
 from django.views.generic.edit import View
 
 # 3rd Party Libraries
@@ -20,6 +22,7 @@
 
 # Ghostwriter Libraries
 from ghostwriter.api.utils import RoleBasedAccessControlMixin, get_project_list, verify_user_is_privileged
+from ghostwriter.home.editor_shortcuts import get_editor_shortcuts_date_config
 from ghostwriter.modules.health_utils import DjangoHealthChecks
 from ghostwriter.reporting.models import ReportFindingLink, ReportObservationLink
 from ghostwriter.rolodex.models import ProjectAssignment
@@ -30,6 +33,14 @@
 logger = logging.getLogger(__name__)
 
 
+@login_required
+@require_GET
+@never_cache
+def editor_shortcuts_date(request):
+    """Return the current server-formatted date for long-lived editor pages."""
+    return JsonResponse(get_editor_shortcuts_date_config())
+
+
 def _format_assignment_operator(assignment):
     if not assignment.operator:
         return "Unassigned"
diff --git a/ghostwriter/modules/reportwriter/base/html_rich_text.py b/ghostwriter/modules/reportwriter/base/html_rich_text.py
index 863331518..edd2352c9 100644
--- a/ghostwriter/modules/reportwriter/base/html_rich_text.py
+++ b/ghostwriter/modules/reportwriter/base/html_rich_text.py
@@ -11,6 +11,24 @@
 
 _H = [f"h{n}" for n in range(1, 7)]
 
+
+def remove_trailing_empty_paragraphs(body):
+    """Remove editor-only trailing paragraphs from parsed rich text."""
+    for child in reversed(list(body.children)):
+        if isinstance(child, bs4.NavigableString):
+            if child.strip():
+                break
+            continue
+        if (
+            child.name == "p"
+            and not child.get_text(strip=True)
+            and child.find(True) is None
+        ):
+            child.extract()
+            continue
+        break
+
+
 def rich_text_template(
     env: jinja2.Environment,
     text: str,
diff --git a/ghostwriter/modules/reportwriter/richtext/ooxml.py b/ghostwriter/modules/reportwriter/richtext/ooxml.py
index a108e811a..0f35db96c 100644
--- a/ghostwriter/modules/reportwriter/richtext/ooxml.py
+++ b/ghostwriter/modules/reportwriter/richtext/ooxml.py
@@ -6,6 +6,11 @@
 # 3rd Party Libraries
 import bs4
 
+# Ghostwriter Libraries
+from ghostwriter.modules.reportwriter.base.html_rich_text import (
+    remove_trailing_empty_paragraphs,
+)
+
 logger = logging.getLogger(__name__)
 
 ALLOWED_HYPERLINK_PROTOCOLS = {"http", "https", "mailto", "tel"}
@@ -111,6 +116,7 @@ def run(cls, text: str, *args, **kwargs):
         tag = soup.find("body")
         instance = cls(*args, **kwargs)
         if tag is not None:
+            remove_trailing_empty_paragraphs(tag)
             instance.process_children(tag.children)
         return instance
 
diff --git a/ghostwriter/modules/reportwriter/richtext/plain_text.py b/ghostwriter/modules/reportwriter/richtext/plain_text.py
index 163c6e995..736bf3650 100644
--- a/ghostwriter/modules/reportwriter/richtext/plain_text.py
+++ b/ghostwriter/modules/reportwriter/richtext/plain_text.py
@@ -1,6 +1,13 @@
-import bs4
+# Standard Libraries
 from io import StringIO
 
+# 3rd Party Libraries
+import bs4
+
+# Ghostwriter Libraries
+from ghostwriter.modules.reportwriter.base.html_rich_text import (
+    remove_trailing_empty_paragraphs,
+)
 from ghostwriter.modules.reportwriter.richtext.ooxml import strip_text_whitespace
 
 
@@ -9,6 +16,7 @@ def html_to_plain_text(text: str, evidences) -> str:
     tag = soup.find("body")
     if tag is None:
         return ""
+    remove_trailing_empty_paragraphs(tag)
     out = StringIO()
     _build_html_str(tag, evidences, out)
 
diff --git a/ghostwriter/oplog/templates/oplog/oplog_detail.html b/ghostwriter/oplog/templates/oplog/oplog_detail.html
index bc3b10469..8c49cc9f1 100644
--- a/ghostwriter/oplog/templates/oplog/oplog_detail.html
+++ b/ghostwriter/oplog/templates/oplog/oplog_detail.html
@@ -303,6 +303,7 @@ <h5 class="modal-title" id="oplogHelpModalLabel"><i class="fas fa-book-open mr-2
                                       <li><strong>&uarr;&darr; arrow keys</strong> move between entries once one is selected.</li>
                                       <li><kbd>Enter</kbd> opens the selected entry's edit form.</li>
                                       <li><kbd>Ctrl+Enter</kbd> or <kbd>Cmd+Enter</kbd> submits the edit form, saving the entry and closing the modal.</li>
+                                      <li>Typing <code>@today</code>/<code>@date</code> or <code>@now</code>/<code>@time</code> followed by a space or punctuation in a rich text field inserts the current date or time.</li>
                                       <li><kbd>Esc</kbd> closes the details pane and deselects the entry, giving the table full width.</li>
                                       <li><kbd>Ctrl+N</kbd> creates a new entry.</li>
                                   </ul>
diff --git a/ghostwriter/oplog/tests/test_views.py b/ghostwriter/oplog/tests/test_views.py
index bfa3637ff..c1bed8029 100644
--- a/ghostwriter/oplog/tests/test_views.py
+++ b/ghostwriter/oplog/tests/test_views.py
@@ -175,6 +175,27 @@ def test_view_exposes_active_time_zone(self):
         self.assertEqual(response.status_code, 200)
         self.assertContains(response, 'data-time-zone="America/Los_Angeles"')
 
+    @override_settings(DATE_FORMAT="Y/m/d")
+    @patch(
+        "ghostwriter.context_processors.get_editor_shortcuts_date_config",
+        return_value={
+            "date": "2026/07/21",
+            "expiresAt": 1784707200000,
+            "serverTime": 1784678400000,
+            "refreshUrl": "/ajax/editor-shortcuts/date",
+        },
+    )
+    def test_view_documents_date_time_shortcuts(self, _mock_date_config):
+        response = self.client_mgr.get(self.uri)
+
+        self.assertEqual(response.status_code, 200)
+        self.assertContains(response, "@now")
+        self.assertContains(response, "@time")
+        self.assertContains(response, "@today")
+        self.assertContains(response, "@date")
+        self.assertContains(response, 'id="gw-current-date"')
+        self.assertContains(response, '"2026/07/21"')
+
     def test_view_displays_last_sanitization(self):
         OplogSanitization.objects.create(
             oplog=self.oplog,
diff --git a/ghostwriter/reporting/tests/test_rich_text_docx.py b/ghostwriter/reporting/tests/test_rich_text_docx.py
index 89c3e8ec1..0a6cb6d16 100644
--- a/ghostwriter/reporting/tests/test_rich_text_docx.py
+++ b/ghostwriter/reporting/tests/test_rich_text_docx.py
@@ -79,6 +79,39 @@ def test_func(self):
 class RichTextToDocxTests(SimpleTestCase):
     maxDiff = None
 
+    def test_trailing_empty_paragraph_after_list_is_omitted(self):
+        doc = docx.Document()
+        HtmlToDocx.run(
+            "<ul><li><p>dc01.gbi.local</p></li>"
+            "<li><p>fs01.gbi.local</p></li>"
+            "<li><p>portal.gbi.example</p></li></ul><p></p><p></p>",
+            doc,
+            None,
+        )
+
+        self.assertEqual(
+            [paragraph.text for paragraph in doc.paragraphs],
+            ["dc01.gbi.local", "fs01.gbi.local", "portal.gbi.example"],
+        )
+
+    def test_internal_empty_paragraph_is_preserved(self):
+        doc = docx.Document()
+        HtmlToDocx.run("<p>Before</p><p></p><p>After</p>", doc, None)
+
+        self.assertEqual(
+            [paragraph.text for paragraph in doc.paragraphs],
+            ["Before", "", "After"],
+        )
+
+    def test_trailing_hard_break_is_preserved(self):
+        doc = docx.Document()
+        HtmlToDocx.run("<p>Before</p><p><br></p>", doc, None)
+
+        self.assertEqual(
+            [paragraph.text for paragraph in doc.paragraphs],
+            ["Before", "\n"],
+        )
+
     def test_table_cell_paragraphs_remain_in_the_cell(self):
         doc = docx.Document()
         HtmlToDocx.run(
diff --git a/ghostwriter/reporting/tests/test_rich_text_plain_text.py b/ghostwriter/reporting/tests/test_rich_text_plain_text.py
new file mode 100644
index 000000000..404ee034d
--- /dev/null
+++ b/ghostwriter/reporting/tests/test_rich_text_plain_text.py
@@ -0,0 +1,29 @@
+"""Tests for HTML conversion used by XLSX rich-text cells."""
+
+# Django Imports
+from django.test import SimpleTestCase
+
+# Ghostwriter Libraries
+from ghostwriter.modules.reportwriter.richtext.plain_text import html_to_plain_text
+
+
+class RichTextToPlainTextTests(SimpleTestCase):
+    """Tests for report rich text converted to XLSX-compatible text."""
+
+    def test_trailing_empty_paragraph_after_list_is_omitted(self):
+        result = html_to_plain_text(
+            "<ul><li><p>First</p></li><li><p>Second</p></li></ul><p></p>",
+            {},
+        )
+
+        self.assertEqual(result, "First\nSecond\n")
+
+    def test_internal_empty_paragraph_is_preserved(self):
+        result = html_to_plain_text("<p>Before</p><p></p><p>After</p>", {})
+
+        self.assertEqual(result, "Before\n\nAfter\n")
+
+    def test_trailing_hard_break_is_preserved(self):
+        result = html_to_plain_text("<p>Before</p><p><br></p>", {})
+
+        self.assertEqual(result, "Before\n\n\n")
diff --git a/ghostwriter/reporting/tests/test_rich_text_pptx.py b/ghostwriter/reporting/tests/test_rich_text_pptx.py
index 17a9e45fe..21da566e0 100644
--- a/ghostwriter/reporting/tests/test_rich_text_pptx.py
+++ b/ghostwriter/reporting/tests/test_rich_text_pptx.py
@@ -95,6 +95,23 @@ def test_func(self):
 class RichTextToPptxTests(SimpleTestCase):
     maxDiff = None
 
+    def test_trailing_empty_paragraph_after_list_is_omitted(self):
+        ppt = pptx.Presentation()
+        slide = ppt.slides.add_slide(ppt.slide_layouts[SLD_LAYOUT_TITLE_AND_CONTENT])
+        shape = slide.shapes.placeholders[1]
+        shape.text_frame.clear()
+        HtmlToPptx.run(
+            "<ul><li><p>First</p></li><li><p>Second</p></li></ul><p></p>",
+            slide,
+            shape,
+        )
+        HtmlToPptx.delete_extra_paragraph(shape)
+
+        self.assertEqual(
+            [paragraph.text for paragraph in shape.text_frame.paragraphs],
+            ["First", "Second"],
+        )
+
     def test_safe_links_are_preserved(self):
         ppt = pptx.Presentation()
         slide = ppt.slides.add_slide(ppt.slide_layouts[SLD_LAYOUT_TITLE_AND_CONTENT])
diff --git a/ghostwriter/static/js/editor_shortcuts.js b/ghostwriter/static/js/editor_shortcuts.js
new file mode 100644
index 000000000..f17e814c2
--- /dev/null
+++ b/ghostwriter/static/js/editor_shortcuts.js
@@ -0,0 +1,184 @@
+(function () {
+    'use strict';
+
+    const CONFIG_ELEMENT_ID = 'gw-current-date';
+    const RETRY_DELAY_MS = 60 * 1000;
+    const STOP_REFRESH = {};
+    let activated = false;
+    let clockOffsetMs = 0;
+    let refreshPromise = null;
+    let refreshTimeoutId = null;
+
+    function isValidConfig(config) {
+        return Boolean(
+            config &&
+            typeof config === 'object' &&
+            typeof config.date === 'string' &&
+            config.date.length > 0 &&
+            Number.isFinite(config.expiresAt) &&
+            Number.isFinite(config.serverTime) &&
+            typeof config.refreshUrl === 'string' &&
+            config.refreshUrl.length > 0
+        );
+    }
+
+    function isFreshConfig(config) {
+        return isValidConfig(config) && config.expiresAt > config.serverTime;
+    }
+
+    function readConfig() {
+        const configElement = document.getElementById(CONFIG_ELEMENT_ID);
+        if (!configElement || !configElement.textContent) {
+            return null;
+        }
+
+        try {
+            const config = JSON.parse(configElement.textContent);
+            return isValidConfig(config) ? config : null;
+        } catch (error) {
+            return null;
+        }
+    }
+
+    function serverNow() {
+        return Date.now() + clockOffsetMs;
+    }
+
+    function setConfig(config) {
+        const configElement = document.getElementById(CONFIG_ELEMENT_ID);
+        if (!configElement || !isValidConfig(config)) {
+            return false;
+        }
+
+        configElement.textContent = JSON.stringify(config);
+        clockOffsetMs = config.serverTime - Date.now();
+        return true;
+    }
+
+    const initialConfig = readConfig();
+    if (initialConfig) {
+        clockOffsetMs = initialConfig.serverTime - Date.now();
+    }
+
+    function scheduleRefresh(config) {
+        if (!isValidConfig(config)) {
+            return false;
+        }
+        if (refreshTimeoutId !== null) {
+            window.clearTimeout(refreshTimeoutId);
+        }
+
+        const delay = Math.max(config.expiresAt - serverNow() + 250, 0);
+        refreshTimeoutId = window.setTimeout(refreshCurrentDate, delay);
+        return true;
+    }
+
+    function scheduleRetry() {
+        if (refreshTimeoutId !== null) {
+            window.clearTimeout(refreshTimeoutId);
+        }
+        refreshTimeoutId = window.setTimeout(refreshCurrentDate, RETRY_DELAY_MS);
+    }
+
+    function stopRefreshing() {
+        if (refreshTimeoutId !== null) {
+            window.clearTimeout(refreshTimeoutId);
+            refreshTimeoutId = null;
+        }
+        activated = false;
+    }
+
+    function refreshCurrentDate() {
+        if (refreshPromise) {
+            return refreshPromise;
+        }
+
+        const config = readConfig();
+        if (!config) {
+            return Promise.resolve(false);
+        }
+
+        refreshPromise = window.fetch(config.refreshUrl, {
+            cache: 'no-store',
+            credentials: 'same-origin',
+            headers: {Accept: 'application/json'},
+        }).then(function (response) {
+            if (response.redirected || response.status === 401 || response.status === 403) {
+                stopRefreshing();
+                return STOP_REFRESH;
+            }
+            if (!response.ok) {
+                throw new Error(`Date shortcut refresh failed with status ${response.status}`);
+            }
+            return response.json();
+        }).then(function (newConfig) {
+            if (newConfig === STOP_REFRESH) {
+                return false;
+            }
+            if (!isFreshConfig(newConfig)) {
+                throw new Error('Date shortcut refresh returned an invalid configuration');
+            }
+            if (!setConfig(newConfig)) {
+                return false;
+            }
+            return scheduleRefresh(newConfig);
+        }).catch(function () {
+            scheduleRetry();
+            return false;
+        }).finally(function () {
+            refreshPromise = null;
+        });
+
+        return refreshPromise;
+    }
+
+    function currentDate() {
+        activate();
+        const config = readConfig();
+        if (!config) {
+            return '';
+        }
+        if (serverNow() >= config.expiresAt) {
+            refreshCurrentDate();
+            return '';
+        }
+        return config.date;
+    }
+
+    function resolveCurrentDate() {
+        const date = currentDate();
+        if (date) {
+            return Promise.resolve(date);
+        }
+
+        return refreshCurrentDate().then(function (refreshed) {
+            const config = readConfig();
+            if (!refreshed || !config || serverNow() >= config.expiresAt) {
+                return '';
+            }
+            return config.date;
+        });
+    }
+
+    function activate() {
+        if (activated) {
+            return true;
+        }
+
+        const config = readConfig();
+        if (!config) {
+            return false;
+        }
+
+        activated = true;
+        scheduleRefresh(config);
+        return true;
+    }
+
+    window.GW_EDITOR_SHORTCUTS = Object.freeze({
+        activate: activate,
+        currentDate: currentDate,
+        refreshCurrentDate: refreshCurrentDate,
+        resolveCurrentDate: resolveCurrentDate,
+    });
+})();
diff --git a/ghostwriter/static/js/tinymce/config.js b/ghostwriter/static/js/tinymce/config.js
index 294dafc2a..55347ce4b 100644
--- a/ghostwriter/static/js/tinymce/config.js
+++ b/ghostwriter/static/js/tinymce/config.js
@@ -275,6 +275,190 @@
         });
     }
 
+    const GW_NOW_SHORTCUT_TOKEN = '@now';
+    const GW_TIME_SHORTCUT_TOKEN = '@time';
+    const GW_NOW_SHORTCUT_TIME_ZONE = 'UTC';
+    const GW_TODAY_SHORTCUT_TOKEN = '@today';
+    const GW_DATE_SHORTCUT_TOKEN = '@date';
+
+    function gwCreateShortcutBoundaryPattern(includeAllWhitespace) {
+        const whitespacePattern = includeAllWhitespace ? '\\s' : ' ';
+        try {
+            return new RegExp(`^(?:${whitespacePattern}|\\p{P})$`, 'u');
+        } catch (error) {
+            if (!(error instanceof SyntaxError)) {
+                throw error;
+            }
+            return new RegExp(
+                `^(?:${whitespacePattern}|[\\x21-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\x7e])$`
+            );
+        }
+    }
+
+    const GW_SHORTCUT_BOUNDARY_PATTERN = gwCreateShortcutBoundaryPattern(true);
+    const GW_SHORTCUT_TRIGGER_PATTERN = gwCreateShortcutBoundaryPattern(false);
+
+    function gwFormatNowShortcut(date) {
+        const parts = {};
+        const formatter = new Intl.DateTimeFormat('en-US', {
+            timeZone: GW_NOW_SHORTCUT_TIME_ZONE,
+            hour: '2-digit',
+            minute: '2-digit',
+            second: '2-digit',
+            hourCycle: 'h23',
+        });
+
+        formatter.formatToParts(date || new Date()).forEach(function (part) {
+            if (part.type !== 'literal') {
+                parts[part.type] = part.value;
+            }
+        });
+
+        return `${parts.hour}:${parts.minute}:${parts.second} ${GW_NOW_SHORTCUT_TIME_ZONE}`;
+    }
+
+    function gwGetConfiguredCurrentDate() {
+        return window.GW_EDITOR_SHORTCUTS
+            ? window.GW_EDITOR_SHORTCUTS.currentDate()
+            : '';
+    }
+
+    function gwResolveConfiguredCurrentDate() {
+        return window.GW_EDITOR_SHORTCUTS &&
+            typeof window.GW_EDITOR_SHORTCUTS.resolveCurrentDate === 'function'
+            ? window.GW_EDITOR_SHORTCUTS.resolveCurrentDate()
+            : Promise.resolve('');
+    }
+
+    function gwInsertPlainText(editor, text) {
+        editor.insertContent(editor.dom.encode(text));
+    }
+
+    function gwReplacePendingShortcut(editor, range, token, replacement) {
+        const editorBody = editor.getBody();
+        if (
+            !replacement ||
+            !editorBody ||
+            !editorBody.contains(range.commonAncestorContainer) ||
+            range.toString() !== token
+        ) {
+            return;
+        }
+
+        const activeRange = editor.selection.getRng().cloneRange();
+        editor.undoManager.transact(function () {
+            editor.selection.setRng(range);
+            gwInsertPlainText(editor, replacement);
+        });
+
+        if (editorBody.contains(activeRange.commonAncestorContainer)) {
+            editor.selection.setRng(activeRange);
+        }
+    }
+
+    const GW_DATE_TIME_SHORTCUTS = [
+        {
+            token: GW_NOW_SHORTCUT_TOKEN,
+            replacement: gwFormatNowShortcut,
+        },
+        {
+            token: GW_TIME_SHORTCUT_TOKEN,
+            replacement: gwFormatNowShortcut,
+        },
+        {
+            token: GW_TODAY_SHORTCUT_TOKEN,
+            replacement: gwGetConfiguredCurrentDate,
+            resolveReplacement: gwResolveConfiguredCurrentDate,
+        },
+        {
+            token: GW_DATE_SHORTCUT_TOKEN,
+            replacement: gwGetConfiguredCurrentDate,
+            resolveReplacement: gwResolveConfiguredCurrentDate,
+        },
+    ];
+
+    function gwExpandDateTimeShortcut(editor, event) {
+        if (
+            !GW_SHORTCUT_TRIGGER_PATTERN.test(event.key) ||
+            event.defaultPrevented ||
+            event.isComposing ||
+            event.ctrlKey ||
+            event.metaKey ||
+            event.altKey
+        ) {
+            return false;
+        }
+
+        const selectedNode = editor.selection.getNode();
+        if (
+            editor.dom.is(selectedNode, 'code,pre') ||
+            editor.dom.getParent(selectedNode, 'code,pre')
+        ) {
+            return false;
+        }
+
+        const range = editor.selection.getRng();
+        const container = range.startContainer;
+        const offset = range.startOffset;
+        if (
+            !range.collapsed ||
+            container.nodeType !== 3 ||
+            offset < GW_NOW_SHORTCUT_TOKEN.length
+        ) {
+            return false;
+        }
+
+        let shortcut = null;
+        for (const candidate of GW_DATE_TIME_SHORTCUTS) {
+            const candidateStart = offset - candidate.token.length;
+            if (
+                candidateStart >= 0 &&
+                container.data.slice(candidateStart, offset) === candidate.token
+            ) {
+                shortcut = candidate;
+                break;
+            }
+        }
+        if (!shortcut) {
+            return false;
+        }
+
+        const tokenStart = offset - shortcut.token.length;
+        const textBeforeToken = container.data.slice(0, tokenStart);
+        if (
+            textBeforeToken &&
+            !GW_SHORTCUT_BOUNDARY_PATTERN.test(textBeforeToken.slice(-1))
+        ) {
+            return false;
+        }
+
+        const replacement = shortcut.replacement();
+        if (!replacement) {
+            if (shortcut.resolveReplacement) {
+                const pendingRange = range.cloneRange();
+                pendingRange.setStart(container, tokenStart);
+                shortcut.resolveReplacement().then(function (resolvedReplacement) {
+                    gwReplacePendingShortcut(
+                        editor,
+                        pendingRange,
+                        shortcut.token,
+                        resolvedReplacement
+                    );
+                });
+            }
+            return false;
+        }
+
+        event.preventDefault();
+        const replacementRange = range.cloneRange();
+        replacementRange.setStart(container, tokenStart);
+        editor.undoManager.transact(function () {
+            editor.selection.setRng(replacementRange);
+            gwInsertPlainText(editor, `${replacement}${event.key}`);
+        });
+        return true;
+    }
+
     const GW_TINYMCE_DEFAULT_CONFIG = window.GW_TINYMCE_DEFAULT_CONFIG = {
         entity_encoding: 'raw',
         branding: false,
@@ -420,6 +604,10 @@
         table_default_attributes: {class: 'table table-sm table-striped table-bordered'},
         table_header_type: 'sectionCells',
         setup: function(editor) {
+            if (window.GW_EDITOR_SHORTCUTS) {
+                window.GW_EDITOR_SHORTCUTS.activate();
+            }
+
             editor.ui.registry.addButton('codeInline', {
                 context: 'format',
                 icon: 'sourcecode',
@@ -464,6 +652,10 @@
             });
 
             editor.on('keydown', function (event) {
+                if (gwExpandDateTimeShortcut(editor, event)) {
+                    return;
+                }
+
                 if (
                     event.key === 'Enter' &&
                     (event.ctrlKey || event.metaKey) &&
diff --git a/ghostwriter/templates/base_generic.html b/ghostwriter/templates/base_generic.html
index c5f33129b..fc988c0ae 100644
--- a/ghostwriter/templates/base_generic.html
+++ b/ghostwriter/templates/base_generic.html
@@ -44,6 +44,7 @@
 
   <!-- TinyMCE -->
   <script src="{% static 'js/tinymce/tinymce.min.js' %}"></script>
+  {% include "snippets/editor_shortcuts_config.html" %}
 
   <!-- Ghostwriter JS & CSS -->
   <script src="{% static 'js/project.js' %}"></script>
diff --git a/ghostwriter/templates/base_generic_empty.html b/ghostwriter/templates/base_generic_empty.html
index 3e93050d3..2c895af02 100644
--- a/ghostwriter/templates/base_generic_empty.html
+++ b/ghostwriter/templates/base_generic_empty.html
@@ -41,6 +41,7 @@
 
   <!-- TinyMCE -->
   <script src="{% static 'js/tinymce/tinymce.min.js' %}"></script>
+  {% include "snippets/editor_shortcuts_config.html" %}
 
   <!-- Ghostwriter JS & CSS -->
   <script src="{% static 'js/project.js' %}"></script>
diff --git a/ghostwriter/templates/snippets/editor_shortcuts_config.html b/ghostwriter/templates/snippets/editor_shortcuts_config.html
new file mode 100644
index 000000000..4b5eedcf3
--- /dev/null
+++ b/ghostwriter/templates/snippets/editor_shortcuts_config.html
@@ -0,0 +1,6 @@
+{% load static %}
+
+{% if user.is_authenticated and EDITOR_SHORTCUTS_DATE_CONFIG %}
+  {{ EDITOR_SHORTCUTS_DATE_CONFIG|json_script:"gw-current-date" }}
+  <script src="{% static 'js/editor_shortcuts.js' %}"></script>
+{% endif %}
diff --git a/ghostwriter/users/tests/test_views.py b/ghostwriter/users/tests/test_views.py
index 896bad85a..ae1209b43 100644
--- a/ghostwriter/users/tests/test_views.py
+++ b/ghostwriter/users/tests/test_views.py
@@ -3,6 +3,7 @@
 import os
 from base64 import b64decode
 from io import BytesIO
+from unittest.mock import patch
 
 # Django Imports
 from django.conf import settings
@@ -235,6 +236,15 @@ def test_view_uses_correct_template(self):
         self.assertEqual(response.status_code, 200)
         self.assertTemplateUsed(response, "account/login.html")
 
+    @patch("ghostwriter.context_processors.get_editor_shortcuts_date_config")
+    def test_anonymous_view_does_not_load_editor_shortcuts(self, mock_date_config):
+        response = self.client.get(self.uri)
+
+        self.assertEqual(response.status_code, 200)
+        mock_date_config.assert_not_called()
+        self.assertNotContains(response, 'id="gw-current-date"')
+        self.assertNotContains(response, "js/editor_shortcuts.js")
+
     def test_valid_credentials(self):
         response = self.client.post(self.uri, {"login": self.user.username, "password": PASSWORD})
         self.assertEqual(response.status_code, 302)
diff --git a/javascript/src/tiptap_gw/index.ts b/javascript/src/tiptap_gw/index.ts
index 0e2922c8e..1320c9b65 100644
--- a/javascript/src/tiptap_gw/index.ts
+++ b/javascript/src/tiptap_gw/index.ts
@@ -27,6 +27,7 @@ import TextAlign from "./text_align";
 import Caption from "./caption";
 import Footnote from "./footnote";
 import { PassiveVoiceDecoration } from "./passive_voice_decoration";
+import DateTimeShortcuts from "./now_shortcut";
 
 const EXTENSIONS: Extensions = [
     StarterKit.configure({
@@ -76,6 +77,7 @@ const EXTENSIONS: Extensions = [
     Caption,
     Footnote,
     PassiveVoiceDecoration,
+    DateTimeShortcuts,
 ];
 
 export default EXTENSIONS;
diff --git a/javascript/src/tiptap_gw/now_shortcut.ts b/javascript/src/tiptap_gw/now_shortcut.ts
new file mode 100644
index 000000000..c913e21b7
--- /dev/null
+++ b/javascript/src/tiptap_gw/now_shortcut.ts
@@ -0,0 +1,211 @@
+import { Extension, InputRule, type Editor } from "@tiptap/core";
+import type { EditorState } from "@tiptap/pm/state";
+
+export const NOW_SHORTCUT_TOKEN = "@now";
+export const TIME_SHORTCUT_TOKEN = "@time";
+export const NOW_SHORTCUT_TIME_ZONE = "UTC";
+export const TODAY_SHORTCUT_TOKEN = "@today";
+export const DATE_SHORTCUT_TOKEN = "@date";
+
+type RegExpFactory = (pattern: string, flags?: string) => RegExp;
+
+const createRegExp: RegExpFactory = (pattern, flags) =>
+    new RegExp(pattern, flags);
+
+export function createShortcutInputRegex(
+    tokens: string,
+    regexpFactory: RegExpFactory = createRegExp
+): RegExp {
+    const unicodeLeadingBoundary = "(?:\\s|\\p{P})";
+    const unicodeTriggerBoundary = "(?: |\\p{P})";
+    try {
+        return regexpFactory(
+            `(?:^|${unicodeLeadingBoundary})(@(?:${tokens}))(${unicodeTriggerBoundary})$`,
+            "u"
+        );
+    } catch (error) {
+        if (!(error instanceof SyntaxError)) {
+            throw error;
+        }
+        const asciiLeadingBoundary =
+            "(?:\\s|[\\x21-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\x7e])";
+        const asciiTriggerBoundary =
+            "(?: |[\\x21-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\x7e])";
+        return regexpFactory(
+            `(?:^|${asciiLeadingBoundary})(@(?:${tokens}))(${asciiTriggerBoundary})$`
+        );
+    }
+}
+
+export const NOW_SHORTCUT_INPUT_REGEX = createShortcutInputRegex("now|time");
+export const TODAY_SHORTCUT_INPUT_REGEX =
+    createShortcutInputRegex("today|date");
+
+declare global {
+    interface Window {
+        GW_EDITOR_SHORTCUTS?: Readonly<{
+            activate: () => boolean;
+            currentDate: () => string;
+            refreshCurrentDate: () => Promise<boolean>;
+            resolveCurrentDate: () => Promise<string>;
+        }>;
+    }
+}
+
+/** Format a date for insertion by the @now rich-text shortcut. */
+export function formatNowShortcut(date: Date = new Date()): string {
+    const parts: Record<string, string> = {};
+    const formatter = new Intl.DateTimeFormat("en-US", {
+        timeZone: NOW_SHORTCUT_TIME_ZONE,
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit",
+        hourCycle: "h23",
+    });
+
+    formatter.formatToParts(date).forEach((part) => {
+        if (part.type !== "literal") {
+            parts[part.type] = part.value;
+        }
+    });
+
+    return `${parts.hour}:${parts.minute}:${parts.second} ${NOW_SHORTCUT_TIME_ZONE}`;
+}
+
+function isInCodeContext(state: EditorState): boolean {
+    const { $from } = state.selection;
+    return (
+        Boolean($from.parent.type.spec.code) ||
+        $from.marks().some((mark) => Boolean(mark.type.spec.code))
+    );
+}
+
+export function createNowShortcutInputRule(
+    formatTimestamp: () => string = formatNowShortcut
+): InputRule {
+    return new InputRule({
+        find: NOW_SHORTCUT_INPUT_REGEX,
+        handler: ({ state, range, match }) => {
+            if (isInCodeContext(state)) {
+                return null;
+            }
+            const replacement = formatTimestamp();
+            if (!replacement) {
+                return null;
+            }
+
+            const tokenStart = range.from + match[0].lastIndexOf(match[1]);
+            state.tr.insertText(
+                `${replacement}${match[2]}`,
+                tokenStart,
+                range.to
+            );
+        },
+    });
+}
+
+/** Return today's date as formatted by Django using the configured DATE_FORMAT. */
+export function getConfiguredCurrentDate(
+    currentWindow: Window | undefined = typeof window === "undefined"
+        ? undefined
+        : window
+): string {
+    return currentWindow?.GW_EDITOR_SHORTCUTS?.currentDate() ?? "";
+}
+
+export function resolveConfiguredCurrentDate(
+    currentWindow: Window | undefined = typeof window === "undefined"
+        ? undefined
+        : window
+): Promise<string> {
+    const resolveCurrentDate =
+        currentWindow?.GW_EDITOR_SHORTCUTS?.resolveCurrentDate;
+    return typeof resolveCurrentDate === "function"
+        ? resolveCurrentDate()
+        : Promise.resolve("");
+}
+
+type PendingDateShortcut = Readonly<{
+    from: number;
+    token: string;
+}>;
+
+type PendingDateShortcutHandler = (pending: PendingDateShortcut) => void;
+
+export function replacePendingDateShortcut(
+    editor: Editor,
+    pending: PendingDateShortcut,
+    replacement: string
+): boolean {
+    const to = pending.from + pending.token.length;
+    if (
+        !replacement ||
+        editor.isDestroyed ||
+        editor.state.doc.textBetween(pending.from, to) !== pending.token
+    ) {
+        return false;
+    }
+
+    editor.view.dispatch(
+        editor.state.tr.insertText(replacement, pending.from, to)
+    );
+    return true;
+}
+
+export function createTodayShortcutInputRule(
+    formatDate: () => string = getConfiguredCurrentDate,
+    handlePendingDate?: PendingDateShortcutHandler
+): InputRule {
+    return new InputRule({
+        find: TODAY_SHORTCUT_INPUT_REGEX,
+        handler: ({ state, range, match }) => {
+            if (isInCodeContext(state)) {
+                return null;
+            }
+            const replacement = formatDate();
+            if (!replacement) {
+                handlePendingDate?.({
+                    from: range.from + match[0].lastIndexOf(match[1]),
+                    token: match[1],
+                });
+                return null;
+            }
+
+            const tokenStart = range.from + match[0].lastIndexOf(match[1]);
+            state.tr.insertText(
+                `${replacement}${match[2]}`,
+                tokenStart,
+                range.to
+            );
+        },
+    });
+}
+
+const DateTimeShortcuts = Extension.create({
+    name: "dateTimeShortcuts",
+    onCreate() {
+        if (typeof window !== "undefined") {
+            window.GW_EDITOR_SHORTCUTS?.activate();
+        }
+    },
+    addInputRules() {
+        const editor = this.editor;
+        return [
+            createNowShortcutInputRule(),
+            createTodayShortcutInputRule(
+                getConfiguredCurrentDate,
+                (pending) => {
+                    void resolveConfiguredCurrentDate().then((replacement) => {
+                        replacePendingDateShortcut(
+                            editor,
+                            pending,
+                            replacement
+                        );
+                    });
+                }
+            ),
+        ];
+    },
+});
+
+export default DateTimeShortcuts;
diff --git a/javascript/tests/e2e/now_shortcut.spec.ts b/javascript/tests/e2e/now_shortcut.spec.ts
new file mode 100644
index 000000000..677caae9b
--- /dev/null
+++ b/javascript/tests/e2e/now_shortcut.spec.ts
@@ -0,0 +1,405 @@
+import { expect, test } from "@playwright/test";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import DateTimeShortcuts, {
+    createNowShortcutInputRule,
+    createShortcutInputRegex,
+    createTodayShortcutInputRule,
+    formatNowShortcut,
+    getConfiguredCurrentDate,
+    NOW_SHORTCUT_INPUT_REGEX,
+    replacePendingDateShortcut,
+    resolveConfiguredCurrentDate,
+    TODAY_SHORTCUT_INPUT_REGEX,
+} from "../../src/tiptap_gw/now_shortcut";
+
+const browserShortcutScript = path.resolve(
+    path.dirname(fileURLToPath(import.meta.url)),
+    "../../../ghostwriter/static/js/editor_shortcuts.js"
+);
+
+function runInputRule(
+    rule: ReturnType<typeof createNowShortcutInputRule>,
+    to: number,
+    token: string,
+    delimiter: string,
+    delimiterAlreadyInserted = false,
+    codeContext: "none" | "block" | "inline" = "none"
+) {
+    let insertion: { text: string; from: number; to: number } | undefined;
+    const matchText = ` ${token}${delimiter}`;
+    const rangeTo = delimiterAlreadyInserted ? to + delimiter.length : to;
+    rule.handler({
+        state: {
+            selection: {
+                $from: {
+                    parent: {
+                        type: { spec: { code: codeContext === "block" } },
+                    },
+                    marks: () =>
+                        codeContext === "inline"
+                            ? [{ type: { spec: { code: true } } }]
+                            : [],
+                },
+            },
+            tr: {
+                insertText: (text: string, from: number, insertTo: number) => {
+                    insertion = { text, from, to: insertTo };
+                },
+            },
+        } as never,
+        range: {
+            from:
+                rangeTo -
+                (matchText.length -
+                    (delimiterAlreadyInserted ? 0 : delimiter.length)),
+            to: rangeTo,
+        },
+        match: [matchText, token, delimiter] as never,
+        commands: {} as never,
+        chain: (() => undefined) as never,
+        can: (() => undefined) as never,
+    });
+    return insertion;
+}
+
+test.describe("date and time rich-text shortcuts", () => {
+    test("formats a zero-padded UTC time", () => {
+        expect(formatNowShortcut(new Date("2026-07-21T20:14:13.000Z"))).toBe(
+            "20:14:13 UTC"
+        );
+        expect(formatNowShortcut(new Date("2026-07-21T00:01:02.000Z"))).toBe(
+            "00:01:02 UTC"
+        );
+    });
+
+    test("matches complete lowercase tokens followed by spaces or punctuation", () => {
+        expect(NOW_SHORTCUT_INPUT_REGEX.test("@now ")).toBe(true);
+        expect(NOW_SHORTCUT_INPUT_REGEX.test("@time ")).toBe(true);
+        expect(NOW_SHORTCUT_INPUT_REGEX.test("On July 21, at @now.")).toBe(
+            true
+        );
+        expect(TODAY_SHORTCUT_INPUT_REGEX.test("On @today, at")).toBe(false);
+        expect(TODAY_SHORTCUT_INPUT_REGEX.test("On @today,")).toBe(true);
+        expect(TODAY_SHORTCUT_INPUT_REGEX.test("On @date,")).toBe(true);
+        expect(TODAY_SHORTCUT_INPUT_REGEX.test("(@today)")).toBe(true);
+        expect(NOW_SHORTCUT_INPUT_REGEX.test("email@now ")).toBe(false);
+        expect(TODAY_SHORTCUT_INPUT_REGEX.test("email@today.")).toBe(false);
+        expect(NOW_SHORTCUT_INPUT_REGEX.test("@now")).toBe(false);
+        expect(NOW_SHORTCUT_INPUT_REGEX.test("@now\n")).toBe(false);
+        expect(NOW_SHORTCUT_INPUT_REGEX.test("@Now ")).toBe(false);
+    });
+
+    test("falls back to ASCII punctuation when Unicode properties are unsupported", () => {
+        const unsupportedUnicodeFactory = (pattern: string, flags?: string) => {
+            if (pattern.includes("\\p{P}")) {
+                throw new SyntaxError(
+                    "Unicode property escapes are unsupported"
+                );
+            }
+            return new RegExp(pattern, flags);
+        };
+        const fallbackPattern = createShortcutInputRegex(
+            "now|time",
+            unsupportedUnicodeFactory
+        );
+
+        expect(fallbackPattern.test("@now ")).toBe(true);
+        expect(fallbackPattern.test("On @time.")).toBe(true);
+        expect(fallbackPattern.test("(@now)")).toBe(true);
+        expect(fallbackPattern.test("On @now—")).toBe(false);
+        expect(fallbackPattern.test("@now\n")).toBe(false);
+    });
+
+    test("does not mask unexpected regular expression errors", () => {
+        const unexpectedError = new Error("Unexpected failure");
+
+        expect(() =>
+            createShortcutInputRegex("now|time", () => {
+                throw unexpectedError;
+            })
+        ).toThrow(unexpectedError);
+    });
+
+    test("does not expand shortcuts in code blocks or inline code", () => {
+        const nowRule = createNowShortcutInputRule(() => "20:14:13 UTC");
+        const todayRule = createTodayShortcutInputRule(() => "21 Jul 2026");
+
+        expect(runInputRule(nowRule, 18, "@now", " ", false, "block")).toBe(
+            undefined
+        );
+        expect(
+            runInputRule(todayRule, 20, "@today", " ", false, "inline")
+        ).toBe(undefined);
+    });
+
+    test("can initialize without a browser window", () => {
+        expect(typeof window).toBe("undefined");
+        expect(() =>
+            DateTimeShortcuts.config.onCreate?.call({} as never)
+        ).not.toThrow();
+    });
+
+    test("replaces @now and preserves the triggering punctuation", () => {
+        const rule = createNowShortcutInputRule(() => "20:14:13 UTC");
+        expect(runInputRule(rule, 18, "@now", ".")).toEqual({
+            text: "20:14:13 UTC.",
+            from: 14,
+            to: 18,
+        });
+    });
+
+    test("replaces shortcuts after composed punctuation input", () => {
+        const rule = createNowShortcutInputRule(() => "20:14:13 UTC");
+        expect(runInputRule(rule, 18, "@now", ".", true)).toEqual({
+            text: "20:14:13 UTC.",
+            from: 14,
+            to: 19,
+        });
+    });
+
+    test("replaces @time as an alias of @now", () => {
+        const rule = createNowShortcutInputRule(() => "20:14:13 UTC");
+        expect(runInputRule(rule, 19, "@time", " ")).toEqual({
+            text: "20:14:13 UTC ",
+            from: 14,
+            to: 19,
+        });
+    });
+
+    test("replaces @today with the server-formatted date", () => {
+        const rule = createTodayShortcutInputRule(() => "21 Jul 2026");
+        expect(runInputRule(rule, 20, "@today", ",")).toEqual({
+            text: "21 Jul 2026,",
+            from: 14,
+            to: 20,
+        });
+    });
+
+    test("replaces @date as an alias of @today", () => {
+        const rule = createTodayShortcutInputRule(() => "21 Jul 2026");
+        expect(runInputRule(rule, 19, "@date", ".")).toEqual({
+            text: "21 Jul 2026.",
+            from: 14,
+            to: 19,
+        });
+    });
+
+    test("queues an unavailable date for replacement after refresh", () => {
+        let pending: { from: number; token: string } | undefined;
+        const rule = createTodayShortcutInputRule(
+            () => "",
+            (shortcut) => {
+                pending = shortcut;
+            }
+        );
+
+        expect(runInputRule(rule, 20, "@today", ",")).toBeUndefined();
+        expect(pending).toEqual({ from: 14, token: "@today" });
+    });
+
+    test("reads the Django-formatted date from the page configuration", async () => {
+        const currentWindow = {
+            GW_EDITOR_SHORTCUTS: {
+                activate: () => true,
+                currentDate: () => "2026/07/21",
+                refreshCurrentDate: () => Promise.resolve(true),
+                resolveCurrentDate: () => Promise.resolve("2026/07/21"),
+            },
+        } as unknown as Window;
+
+        expect(getConfiguredCurrentDate(currentWindow)).toBe("2026/07/21");
+        expect(getConfiguredCurrentDate(undefined)).toBe("");
+        await expect(resolveConfiguredCurrentDate(currentWindow)).resolves.toBe(
+            "2026/07/21"
+        );
+        await expect(resolveConfiguredCurrentDate(undefined)).resolves.toBe("");
+    });
+
+    test("replaces a pending date after its asynchronous refresh", () => {
+        let insertion: { text: string; from: number; to: number } | undefined;
+        let dispatched = false;
+        const transaction = {
+            insertText: (text: string, from: number, to: number) => {
+                insertion = { text, from, to };
+                return transaction;
+            },
+        };
+        const editor = {
+            state: {
+                doc: {
+                    textBetween: (from: number, to: number) =>
+                        from === 14 && to === 20 ? "@today" : "",
+                },
+                tr: transaction,
+            },
+            view: {
+                dispatch: () => {
+                    dispatched = true;
+                },
+            },
+        } as unknown as Parameters<typeof replacePendingDateShortcut>[0];
+
+        expect(
+            replacePendingDateShortcut(
+                editor,
+                { from: 14, token: "@today" },
+                "21 Jul 2026"
+            )
+        ).toBe(true);
+        expect(insertion).toEqual({
+            text: "21 Jul 2026",
+            from: 14,
+            to: 20,
+        });
+        expect(dispatched).toBe(true);
+    });
+
+    test("does not refresh until an editor activates the shortcuts", async ({
+        page,
+    }) => {
+        const now = Date.now();
+        let refreshRequests = 0;
+        const initialConfig = {
+            date: "21 Jul 2026",
+            expiresAt: now - 1000,
+            serverTime: now,
+            refreshUrl: "http://ghostwriter.test/refresh-date",
+        };
+        const refreshedConfig = {
+            date: "22 Jul 2026",
+            expiresAt: now + 24 * 60 * 60 * 1000,
+            serverTime: now,
+            refreshUrl: initialConfig.refreshUrl,
+        };
+
+        await page.route("http://ghostwriter.test/**", async (route) => {
+            const url = new URL(route.request().url());
+            if (url.pathname === "/refresh-date") {
+                refreshRequests += 1;
+                await route.fulfill({ json: refreshedConfig });
+                return;
+            }
+            await route.fulfill({
+                contentType: "text/html",
+                body: `<script id="gw-current-date" type="application/json">${JSON.stringify(initialConfig)}</script>`,
+            });
+        });
+
+        await page.goto("http://ghostwriter.test/");
+        await page.addScriptTag({ path: browserShortcutScript });
+
+        await page.waitForTimeout(300);
+        expect(refreshRequests).toBe(0);
+
+        await page.evaluate(() => window.GW_EDITOR_SHORTCUTS?.activate());
+
+        await expect
+            .poll(() =>
+                page.evaluate(() => window.GW_EDITOR_SHORTCUTS?.currentDate())
+            )
+            .toBe("22 Jul 2026");
+        expect(refreshRequests).toBe(1);
+    });
+
+    test("uses the load-time clock offset when activation is delayed", async ({
+        page,
+    }) => {
+        const initialTime = Date.now();
+        let refreshRequests = 0;
+        const initialConfig = {
+            date: "21 Jul 2026",
+            expiresAt: initialTime + 1000,
+            serverTime: initialTime,
+            refreshUrl: "http://ghostwriter.test/refresh-date",
+        };
+        const refreshedConfig = {
+            date: "22 Jul 2026",
+            expiresAt: initialTime + 24 * 60 * 60 * 1000,
+            serverTime: initialTime + 2000,
+            refreshUrl: initialConfig.refreshUrl,
+        };
+
+        await page.route("http://ghostwriter.test/**", async (route) => {
+            const url = new URL(route.request().url());
+            if (url.pathname === "/refresh-date") {
+                refreshRequests += 1;
+                await route.fulfill({ json: refreshedConfig });
+                return;
+            }
+            await route.fulfill({
+                contentType: "text/html",
+                body: `<script id="gw-current-date" type="application/json">${JSON.stringify(initialConfig)}</script>`,
+            });
+        });
+
+        await page.goto("http://ghostwriter.test/");
+        await page.evaluate((now) => {
+            const clock = { now };
+            (
+                window as typeof window & {
+                    testEditorShortcutClock: typeof clock;
+                }
+            ).testEditorShortcutClock = clock;
+            Date.now = () => clock.now;
+        }, initialTime);
+        await page.addScriptTag({ path: browserShortcutScript });
+        await page.evaluate(() => {
+            (
+                window as typeof window & {
+                    testEditorShortcutClock: { now: number };
+                }
+            ).testEditorShortcutClock.now += 2000;
+        });
+
+        expect(
+            await page.evaluate(() =>
+                window.GW_EDITOR_SHORTCUTS?.resolveCurrentDate()
+            )
+        ).toBe(refreshedConfig.date);
+        expect(refreshRequests).toBe(1);
+    });
+
+    test("rejects malformed refresh payloads without an immediate retry", async ({
+        page,
+    }) => {
+        const now = Date.now();
+        let refreshRequests = 0;
+        const initialConfig = {
+            date: "21 Jul 2026",
+            expiresAt: now + 24 * 60 * 60 * 1000,
+            serverTime: now,
+            refreshUrl: "http://ghostwriter.test/refresh-date",
+        };
+
+        await page.route("http://ghostwriter.test/**", async (route) => {
+            const url = new URL(route.request().url());
+            if (url.pathname === "/refresh-date") {
+                refreshRequests += 1;
+                await route.fulfill({ json: { date: "22 Jul 2026" } });
+                return;
+            }
+            await route.fulfill({
+                contentType: "text/html",
+                body: `<script id="gw-current-date" type="application/json">${JSON.stringify(initialConfig)}</script>`,
+            });
+        });
+
+        await page.goto("http://ghostwriter.test/");
+        await page.addScriptTag({ path: browserShortcutScript });
+        await page.evaluate(() => window.GW_EDITOR_SHORTCUTS?.activate());
+
+        expect(
+            await page.evaluate(() =>
+                window.GW_EDITOR_SHORTCUTS?.refreshCurrentDate()
+            )
+        ).toBe(false);
+        await page.waitForTimeout(300);
+
+        expect(refreshRequests).toBe(1);
+        expect(
+            await page.evaluate(() => window.GW_EDITOR_SHORTCUTS?.currentDate())
+        ).toBe(initialConfig.date);
+    });
+});