diff --git a/package.json b/package.json
index cb87ef1a..8824bd8c 100644
--- a/package.json
+++ b/package.json
@@ -3,7 +3,8 @@
   "version": "1.0.0",
   "description": "PR Readiness Checker - Track and monitor GitHub Pull Request status",
   "scripts": {
-    "dev": "wrangler dev",
+    "fingerprint": "node scripts/fingerprint.js",
+    "dev": "npm run fingerprint && wrangler dev",
     "deploy": "wrangler deploy",
     "db:create": "wrangler d1 create pr_tracker",
     "db:migrate:local": "wrangler d1 migrations apply pr_tracker --local",
diff --git a/public/asset-manifest.json b/public/asset-manifest.json
new file mode 100644
index 00000000..ce531fb2
--- /dev/null
+++ b/public/asset-manifest.json
@@ -0,0 +1,5 @@
+{
+  "error-reporter.js": "error-reporter.1b9dc33f.js",
+  "how-it-works.js": "how-it-works.3ebd3397.js",
+  "theme.js": "theme.196e3e21.js"
+}
diff --git a/public/diagnostics.html b/public/diagnostics.html
index 1f294302..5a8fca38 100644
--- a/public/diagnostics.html
+++ b/public/diagnostics.html
@@ -23,7 +23,7 @@
             }
         })();
     </script>
-    <script src="error-reporter.js"></script>
+    <script src="error-reporter.1b9dc33f.js"></script>
 
     <script src="https://cdn.tailwindcss.com"></script>
     <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css"
@@ -55,10 +55,10 @@
                     class="text-slate-600 hover:text-slate-900 dark:text-slate-400 dark:hover:text-slate-100">
                     <i class="fab fa-github"></i> GitHub
                 </a>
-                <button id="themeToggle"
+                <button data-theme-toggle
                     class="rounded-lg p-2 text-slate-500 hover:bg-slate-100 dark:text-slate-400 dark:hover:bg-slate-700 transition-colors"
                     title="Toggle dark/light mode">
-                    <i class="fas fa-moon" id="themeIcon"></i>
+                    <i class="fas fa-moon" data-theme-icon></i>
                 </button>
             </nav>
         </div>
@@ -168,8 +168,8 @@ <h1 class="text-3xl font-bold text-slate-900 dark:text-white mb-2 flex items-cen
         buildList();
 
         // Theme toggle
-        const themeToggle = document.getElementById('themeToggle');
-        const themeIcon = document.getElementById('themeIcon');
+        const themeToggle = document.querySelector('[data-theme-toggle]');
+        const themeIcon = document.querySelector('[data-theme-icon]');
         themeToggle.addEventListener('click', () => {
             const isDark = document.documentElement.classList.toggle('dark');
             themeIcon.className = isDark ? 'fas fa-sun' : 'fas fa-moon';
diff --git a/public/error-reporter.1b9dc33f.js b/public/error-reporter.1b9dc33f.js
new file mode 100644
index 00000000..5d2d594b
--- /dev/null
+++ b/public/error-reporter.1b9dc33f.js
@@ -0,0 +1,181 @@
+// Global error reporter: forwards JS errors to the backend,
+// which relays them to the configured SLACK_ERROR_WEBHOOK.
+(function () {
+    function safeTruncate(text, maxLen) {
+        var str = String(text || '');
+        if (str.length <= maxLen) return str;
+        if (maxLen <= 3) return str.slice(0, Math.max(0, maxLen));
+        return str.slice(0, maxLen - 3) + '...';
+    }
+
+    function redactSensitive(text) {
+        var str = String(text || '');
+        str = str.replace(
+            /(authorization|token|apikey|api[_-]?key|password|passwd|cookie|set-cookie|session|secret|bearer)\s*[:=]\s*([^\s,;]+)/gi,
+            '$1:[redacted]'
+        );
+        str = str.replace(/[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/gi, '[redacted-email]');
+        str = str.replace(/\b[A-Za-z0-9_\-]{24,}\b/g, '[redacted-token]');
+        return str;
+    }
+
+    function sanitizeText(text, maxLen) {
+        return safeTruncate(redactSensitive(text), maxLen);
+    }
+
+    function sanitizeExtra(extra) {
+        var clean = {};
+        var source = extra || {};
+
+        Object.keys(source).forEach(function (key) {
+            var value = source[key];
+            if (value == null) {
+                clean[key] = value;
+                return;
+            }
+            if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+                clean[key] = sanitizeText(value, 500);
+                return;
+            }
+            clean[key] = '[redacted-object]';
+        });
+
+        return clean;
+    }
+
+    function getPageUrl() {
+        try {
+            return location.origin + location.pathname;
+        } catch (e) {
+            return location.pathname || '';
+        }
+    }
+
+    function serializeConsoleArg(value) {
+        if (value instanceof Error) {
+            return value.name + ': ' + value.message + '\n' + (value.stack || '');
+        }
+        if (typeof value === 'object') {
+            try {
+                return JSON.stringify(value);
+            } catch (e) {
+                return '[object]';
+            }
+        }
+        return String(value);
+    }
+
+    function sendPayload(payload) {
+        try {
+            var body = JSON.stringify(payload);
+
+            var ok = false;
+            try {
+                ok = navigator.sendBeacon('/api/client-error', body);
+            } catch (e) {
+                ok = false;
+            }
+
+            if (!ok) {
+                fetch('/api/client-error', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: body,
+                    keepalive: true,
+                }).catch(function () {});
+            }
+        } catch (e) {}
+    }
+
+    function reportError(errorType, message, stack, extra) {
+        var payload = Object.assign(
+            {
+                error_type: sanitizeText(errorType || 'Error', 100),
+                message: sanitizeText(message || 'Unknown error', 300),
+                stack: sanitizeText(stack || '', 2000),
+            },
+            sanitizeExtra(extra)
+        );
+        sendPayload(payload);
+    }
+
+    window.addEventListener(
+        'error',
+        function (event) {
+            var target = event.target || {};
+            var resourceUrl = target.src || target.href;
+            var shouldReportResource =
+                target.tagName === 'SCRIPT' ||
+                target.tagName === 'LINK' ||
+                (target.tagName === 'IMG' &&
+                    !target.hasAttribute('onerror') &&
+                    !target.hasAttribute('data-ignore-error'));
+
+            if (resourceUrl && shouldReportResource) {
+                reportError(
+                    'ResourceError',
+                    'Failed to load or execute resource',
+                    (event.error && event.error.stack) || '',
+                    { url: getPageUrl(), resource: resourceUrl }
+                );
+                return;
+            }
+
+            reportError(
+                (event.error && event.error.name) || 'Error',
+                event.message ||
+                    (event.error && event.error.message) ||
+                    String(event.error) ||
+                    'Unknown error',
+                (event.error && event.error.stack) || '',
+                { url: getPageUrl(), line: event.lineno, col: event.colno }
+            );
+        },
+        true
+    );
+
+    window.addEventListener('unhandledrejection', function (event) {
+        var reason = event.reason || {};
+        reportError(
+            reason.name || 'UnhandledRejection',
+            reason.message || String(reason),
+            reason.stack || '',
+            { url: getPageUrl() }
+        );
+    });
+
+    (function hookConsoleError() {
+        var original = console.error;
+        console.error = function () {
+            try {
+                var args = Array.prototype.slice.call(arguments);
+                var errors = args.filter(function (arg) {
+                    return arg instanceof Error;
+                });
+                var msg = args.map(serializeConsoleArg).join(' ');
+
+                if (errors.length > 0) {
+                    var primary = errors[0];
+                    reportError(
+                        primary.name || 'ConsoleError',
+                        (primary.name || 'ConsoleError') + ': ' + (primary.message || ''),
+                        primary.stack || msg,
+                        {
+                            url: getPageUrl(),
+                            source: 'console.error:unhandled',
+                            report_channel: 'dedupe-candidate',
+                            error_count: String(errors.length),
+                        }
+                    );
+                } else if (msg) {
+                    reportError('ConsoleError', msg, msg, {
+                        url: getPageUrl(),
+                        source: 'console.error',
+                    });
+                }
+            } catch (e) {}
+
+            return original.apply(console, arguments);
+        };
+    })();
+})();
diff --git a/public/error-reporter.js b/public/error-reporter.js
index f178bf78..5d2d594b 100644
--- a/public/error-reporter.js
+++ b/public/error-reporter.js
@@ -1,104 +1,181 @@
-// Global error reporter: forwards JS errors to the backend.
+// Global error reporter: forwards JS errors to the backend,
+// which relays them to the configured SLACK_ERROR_WEBHOOK.
 (function () {
-  function sendPayload(payload) {
-    try {
-      var body = JSON.stringify(payload);
-
-      // Prefer beacon (best for unload), fallback to fetch if beacon fails.
-      var ok = false;
-      try {
-        ok = navigator.sendBeacon("/api/client-error", body);
-      } catch (e) {
-        ok = false;
-      }
-
-      if (!ok) {
-        fetch("/api/client-error", {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: body,
-          keepalive: true,
-        }).catch(function () {});
-      }
-    } catch (e) {}
-  }
-
-  function reportError(errorType, message, stack, extra) {
-    var payload = Object.assign(
-      { error_type: errorType, message: message, stack: stack || "" },
-      extra || {}
-    );
-    sendPayload(payload);
-  }
-
-  window.addEventListener(
-    "error",
-    function (event) {
-      var target = event.target || {};
-      var resourceUrl = target.src || target.href;
-
-      if (
-        resourceUrl &&
-        (target.tagName === "SCRIPT" ||
-          target.tagName === "LINK" ||
-          target.tagName === "IMG")
-      ) {
-        reportError(
-          "ResourceError",
-          "Failed to load or execute resource",
-          (event.error && event.error.stack) || "",
-          { url: location.href, resource: resourceUrl }
+    function safeTruncate(text, maxLen) {
+        var str = String(text || '');
+        if (str.length <= maxLen) return str;
+        if (maxLen <= 3) return str.slice(0, Math.max(0, maxLen));
+        return str.slice(0, maxLen - 3) + '...';
+    }
+
+    function redactSensitive(text) {
+        var str = String(text || '');
+        str = str.replace(
+            /(authorization|token|apikey|api[_-]?key|password|passwd|cookie|set-cookie|session|secret|bearer)\s*[:=]\s*([^\s,;]+)/gi,
+            '$1:[redacted]'
         );
-        return;
-      }
-
-      reportError(
-        (event.error && event.error.name) || "Error",
-        event.message ||
-          (event.error && event.error.message) ||
-          String(event.error) ||
-          "Unknown error",
-        (event.error && event.error.stack) || "",
-        { url: location.href, line: event.lineno, col: event.colno }
-      );
-    },
-    true
-  );
-
-  window.addEventListener("unhandledrejection", function (event) {
-    var reason = event.reason || {};
-    reportError(
-      reason.name || "UnhandledRejection",
-      reason.message || String(reason),
-      reason.stack || "",
-      { url: location.href }
-    );
-  });
-
-  (function hookConsoleError() {
-    var original = console.error;
-    console.error = function () {
-      try {
-        var args = Array.prototype.slice.call(arguments);
-        var msg = args
-          .map(function (a) {
-            if (a instanceof Error) {
-              return a.name + ": " + a.message + "\n" + (a.stack || "");
+        str = str.replace(/[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/gi, '[redacted-email]');
+        str = str.replace(/\b[A-Za-z0-9_\-]{24,}\b/g, '[redacted-token]');
+        return str;
+    }
+
+    function sanitizeText(text, maxLen) {
+        return safeTruncate(redactSensitive(text), maxLen);
+    }
+
+    function sanitizeExtra(extra) {
+        var clean = {};
+        var source = extra || {};
+
+        Object.keys(source).forEach(function (key) {
+            var value = source[key];
+            if (value == null) {
+                clean[key] = value;
+                return;
             }
-            if (typeof a === "object") {
-              try { return JSON.stringify(a); } catch (_) { return "[object]"; }
+            if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+                clean[key] = sanitizeText(value, 500);
+                return;
             }
-            return String(a);
-          })
-          .join(" ");
-
-        reportError("ConsoleError", msg.slice(0, 300), msg.slice(0, 2000), {
-          url: location.href,
-          source: "console.error",
+            clean[key] = '[redacted-object]';
         });
-      } catch (e) {}
 
-      return original.apply(console, arguments);
-    };
-  })();
-})();
\ No newline at end of file
+        return clean;
+    }
+
+    function getPageUrl() {
+        try {
+            return location.origin + location.pathname;
+        } catch (e) {
+            return location.pathname || '';
+        }
+    }
+
+    function serializeConsoleArg(value) {
+        if (value instanceof Error) {
+            return value.name + ': ' + value.message + '\n' + (value.stack || '');
+        }
+        if (typeof value === 'object') {
+            try {
+                return JSON.stringify(value);
+            } catch (e) {
+                return '[object]';
+            }
+        }
+        return String(value);
+    }
+
+    function sendPayload(payload) {
+        try {
+            var body = JSON.stringify(payload);
+
+            var ok = false;
+            try {
+                ok = navigator.sendBeacon('/api/client-error', body);
+            } catch (e) {
+                ok = false;
+            }
+
+            if (!ok) {
+                fetch('/api/client-error', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: body,
+                    keepalive: true,
+                }).catch(function () {});
+            }
+        } catch (e) {}
+    }
+
+    function reportError(errorType, message, stack, extra) {
+        var payload = Object.assign(
+            {
+                error_type: sanitizeText(errorType || 'Error', 100),
+                message: sanitizeText(message || 'Unknown error', 300),
+                stack: sanitizeText(stack || '', 2000),
+            },
+            sanitizeExtra(extra)
+        );
+        sendPayload(payload);
+    }
+
+    window.addEventListener(
+        'error',
+        function (event) {
+            var target = event.target || {};
+            var resourceUrl = target.src || target.href;
+            var shouldReportResource =
+                target.tagName === 'SCRIPT' ||
+                target.tagName === 'LINK' ||
+                (target.tagName === 'IMG' &&
+                    !target.hasAttribute('onerror') &&
+                    !target.hasAttribute('data-ignore-error'));
+
+            if (resourceUrl && shouldReportResource) {
+                reportError(
+                    'ResourceError',
+                    'Failed to load or execute resource',
+                    (event.error && event.error.stack) || '',
+                    { url: getPageUrl(), resource: resourceUrl }
+                );
+                return;
+            }
+
+            reportError(
+                (event.error && event.error.name) || 'Error',
+                event.message ||
+                    (event.error && event.error.message) ||
+                    String(event.error) ||
+                    'Unknown error',
+                (event.error && event.error.stack) || '',
+                { url: getPageUrl(), line: event.lineno, col: event.colno }
+            );
+        },
+        true
+    );
+
+    window.addEventListener('unhandledrejection', function (event) {
+        var reason = event.reason || {};
+        reportError(
+            reason.name || 'UnhandledRejection',
+            reason.message || String(reason),
+            reason.stack || '',
+            { url: getPageUrl() }
+        );
+    });
+
+    (function hookConsoleError() {
+        var original = console.error;
+        console.error = function () {
+            try {
+                var args = Array.prototype.slice.call(arguments);
+                var errors = args.filter(function (arg) {
+                    return arg instanceof Error;
+                });
+                var msg = args.map(serializeConsoleArg).join(' ');
+
+                if (errors.length > 0) {
+                    var primary = errors[0];
+                    reportError(
+                        primary.name || 'ConsoleError',
+                        (primary.name || 'ConsoleError') + ': ' + (primary.message || ''),
+                        primary.stack || msg,
+                        {
+                            url: getPageUrl(),
+                            source: 'console.error:unhandled',
+                            report_channel: 'dedupe-candidate',
+                            error_count: String(errors.length),
+                        }
+                    );
+                } else if (msg) {
+                    reportError('ConsoleError', msg, msg, {
+                        url: getPageUrl(),
+                        source: 'console.error',
+                    });
+                }
+            } catch (e) {}
+
+            return original.apply(console, arguments);
+        };
+    })();
+})();
diff --git a/public/how-it-works.3ebd3397.js b/public/how-it-works.3ebd3397.js
new file mode 100644
index 00000000..43ad62aa
--- /dev/null
+++ b/public/how-it-works.3ebd3397.js
@@ -0,0 +1,123 @@
+// Interactive Score Calculator for BLT-Leaf "How It Works" Page
+
+function calculateScore() {
+    // Get input values
+    const ciPassed = parseInt(document.getElementById('ciPassed').value);
+    const ciFailed = parseInt(document.getElementById('ciFailed').value);
+    const approvals = parseInt(document.getElementById('approvals').value);
+    const changesRequested = parseInt(document.getElementById('changesRequested').value);
+    const conversations = parseInt(document.getElementById('conversations').value);
+    const responseRate = parseInt(document.getElementById('responseRate').value);
+
+    // Update displayed values
+    document.getElementById('ciPassedValue').textContent = ciPassed;
+    document.getElementById('ciFailedValue').textContent = ciFailed;
+    document.getElementById('approvalsValue').textContent = approvals;
+    document.getElementById('changesRequestedValue').textContent = changesRequested;
+    document.getElementById('conversationsValue').textContent = conversations;
+    document.getElementById('responseRateValue').textContent = responseRate + '%';
+
+    // Calculate CI Score
+    const totalChecks = ciPassed + ciFailed;
+    let ciScore = 0;
+    let ciConfidence = 'Low';
+    let ciConfidenceBadge = 'badge-low';
+
+    if (totalChecks > 0) {
+        ciScore = (ciPassed / totalChecks) * 100;
+        ciConfidence = 'High';
+        ciConfidenceBadge = 'badge-high';
+    } else {
+        // No checks run - low confidence, assume failure
+        ciScore = 0;
+        ciConfidence = 'Low';
+        ciConfidenceBadge = 'badge-low';
+    }
+
+    // Calculate Review Score
+    let reviewScore = 0;
+    let reviewConfidence = 'Medium';
+    let reviewConfidenceBadge = 'badge-medium';
+
+    if (approvals > 0 && changesRequested === 0) {
+        reviewScore = 100;
+        reviewConfidence = 'High';
+        reviewConfidenceBadge = 'badge-high';
+    } else if (approvals > 0 && changesRequested > 0) {
+        reviewScore = 50;
+        reviewConfidence = 'Medium';
+        reviewConfidenceBadge = 'badge-medium';
+    } else if (approvals === 0 && changesRequested > 0) {
+        reviewScore = 0;
+        reviewConfidence = 'High';
+        reviewConfidenceBadge = 'badge-high';
+    } else {
+        // No approvals, no changes requested
+        reviewScore = 0;
+        reviewConfidence = 'Medium';
+        reviewConfidenceBadge = 'badge-medium';
+    }
+
+    // Response Score (direct mapping)
+    const responseScore = responseRate;
+    let responseConfidence = 'High';
+    let responseConfidenceBadge = 'badge-high';
+
+    if (responseRate < 50) {
+        responseConfidence = 'Low';
+        responseConfidenceBadge = 'badge-low';
+    } else if (responseRate < 80) {
+        responseConfidence = 'Medium';
+        responseConfidenceBadge = 'badge-medium';
+    }
+
+    // Calculate Overall Score
+    // Formula: (CI × 0.4) + (Review × 0.4) + (Response × 0.2) - (3 × conversations)
+    let overallScore = (ciScore * 0.4) + (reviewScore * 0.4) + (responseScore * 0.2);
+
+    // Deduct 3 points per unresolved conversation
+    overallScore = Math.max(0, overallScore - (conversations * 3));
+
+    // Determine overall status
+    let overallStatus = '';
+    let overallColor = '';
+
+    if (overallScore >= 80) {
+        overallStatus = '✅ Merge Ready';
+        overallColor = 'text-green-600 dark:text-green-400';
+    } else if (overallScore >= 60) {
+        overallStatus = '⚠️ Needs Attention';
+        overallColor = 'text-yellow-600 dark:text-yellow-400';
+    } else {
+        overallStatus = '❌ Not Ready';
+        overallColor = 'text-red-600 dark:text-red-400';
+    }
+
+    // Update UI
+    const overallScoreElement = document.getElementById('overallScore');
+    overallScoreElement.textContent = Math.round(overallScore) + '%';
+    overallScoreElement.className = overallColor + ' text-5xl font-bold mb-2';
+
+    document.getElementById('overallStatus').textContent = overallStatus;
+
+    document.getElementById('ciScoreDisplay').innerHTML =
+        `${Math.round(ciScore)}% <span class="${ciConfidenceBadge} px-2 py-0.5 rounded text-xs ml-1">${ciConfidence}</span>`;
+
+    document.getElementById('reviewScoreDisplay').innerHTML =
+        `${Math.round(reviewScore)}% <span class="${reviewConfidenceBadge} px-2 py-0.5 rounded text-xs ml-1">${reviewConfidence}</span>`;
+
+    document.getElementById('responseScoreDisplay').innerHTML =
+        `${Math.round(responseScore)}% <span class="${responseConfidenceBadge} px-2 py-0.5 rounded text-xs ml-1">${responseConfidence}</span>`;
+}
+
+// Initialize calculator on page load
+document.addEventListener('DOMContentLoaded', function () {
+    // Attach event listeners to all range inputs
+    const rangeInputs = document.querySelectorAll('input[type="range"]');
+    rangeInputs.forEach(input => {
+        input.addEventListener('input', calculateScore);
+    });
+
+    // Initial calculation
+    calculateScore();
+});
diff --git a/public/how-it-works.html b/public/how-it-works.html
index 6f5261f6..e3f3690a 100644
--- a/public/how-it-works.html
+++ b/public/how-it-works.html
@@ -8,22 +8,7 @@
     <title>How It Works — BLT-Leaf</title>
     <link rel="shortcut icon" href="favicon.ico" type="image/x-icon">
 
-    <script>
-        window.tailwind = {
-            config: {
-                darkMode: 'class'
-            }
-        };
-
-        (function () {
-            const savedTheme = localStorage.getItem('theme');
-            const isDark = savedTheme === 'dark' || (!savedTheme && window.matchMedia('(prefers-color-scheme: dark)').matches);
-            if (isDark) {
-                document.documentElement.classList.add('dark');
-            }
-        })();
-    </script>
-    <script src="error-reporter.js"></script>
+    <script src="error-reporter.1b9dc33f.js"></script>
 
     <script src="https://cdn.tailwindcss.com"></script>
     <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css"
@@ -94,10 +79,10 @@
                     class="text-slate-600 hover:text-slate-900 dark:text-slate-400 dark:hover:text-slate-100">
                     <i class="fab fa-github"></i> GitHub
                 </a>
-                <button id="themeToggle"
+                <button data-theme-toggle
                     class="rounded-lg p-2 text-slate-500 hover:bg-slate-100 dark:text-slate-400 dark:hover:bg-slate-700 transition-colors"
                     title="Toggle dark/light mode">
-                    <i class="fas fa-moon" id="themeIcon"></i>
+                    <i class="fas fa-moon" data-theme-icon></i>
                 </button>
             </nav>
         </div>
@@ -1098,53 +1083,12 @@ <h2 class="text-2xl font-semibold text-slate-900 dark:text-white mb-4">
         </div>
     </footer>
 
-    <!-- Theme Toggle JavaScript -->
-    <script>
-        // Initialize theme on page load
-        function initTheme() {
-            const savedTheme = localStorage.getItem('theme');
-            const isDark = savedTheme === 'dark' || (!savedTheme && window.matchMedia('(prefers-color-scheme: dark)').matches);
-            const themeIcon = document.getElementById('themeIcon');
-
-            if (isDark) {
-                document.documentElement.classList.add('dark');
-                if (themeIcon) themeIcon.className = 'fas fa-sun';
-            } else {
-                document.documentElement.classList.remove('dark');
-                if (themeIcon) themeIcon.className = 'fas fa-moon';
-            }
-        }
-
-        // Toggle theme
-        function toggleTheme() {
-            const isDark = document.documentElement.classList.contains('dark');
-            const themeIcon = document.getElementById('themeIcon');
-
-            if (isDark) {
-                document.documentElement.classList.remove('dark');
-                if (themeIcon) themeIcon.className = 'fas fa-moon';
-                localStorage.setItem('theme', 'light');
-            } else {
-                document.documentElement.classList.add('dark');
-                if (themeIcon) themeIcon.className = 'fas fa-sun';
-                localStorage.setItem('theme', 'dark');
-            }
-        }
-
-        // Attach event listener when DOM is ready
-        document.addEventListener('DOMContentLoaded', () => {
-            // Initialize theme icon (dark class already set in head)
-            initTheme();
+    <!-- Theme behavior provided by shared script -->
 
-            const themeToggleBtn = document.getElementById('themeToggle');
-            if (themeToggleBtn) {
-                themeToggleBtn.addEventListener('click', toggleTheme);
-            }
-        });
-    </script>
+    <script src="theme.196e3e21.js"></script>
 
     <!-- JavaScript for Interactive Calculator -->
-    <script src="how-it-works.js"></script>
+    <script src="how-it-works.3ebd3397.js"></script>
 
 </body>
 
diff --git a/public/index.html b/public/index.html
index ff0b2152..dc707537 100644
--- a/public/index.html
+++ b/public/index.html
@@ -28,7 +28,7 @@
             }
         })();
     </script>
-    <script src="/error-reporter.js" defer></script>
+    <script src="/error-reporter.1b9dc33f.js"></script>
     <!-- Font Awesome -->
     <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css" />
     <style>
@@ -329,9 +329,9 @@ <h1 class="text-xs font-bold text-slate-900 dark:text-white">BLT-LEAF</h1>
                             title="Toggle auto-refresh">
                             <i class="fas fa-sync-alt text-xs" id="autoRefreshIcon"></i>
                         </button>
-                        <button id="themeToggle"
+                        <button data-theme-toggle aria-label="Toggle theme" title="Toggle theme"
                             class="rounded-lg p-1.5 text-slate-500 hover:bg-slate-100 dark:text-slate-400 dark:hover:bg-slate-700">
-                            <i class="fas fa-moon text-xs" id="themeIcon"></i>
+                            <i class="fas fa-moon text-xs" data-theme-icon aria-hidden="true"></i>
                         </button>
                         <a href="/how-it-works.html"
                             class="inline-flex items-center rounded-lg p-1.5 text-slate-700 hover:bg-slate-100 dark:text-slate-300 dark:hover:bg-slate-700"
@@ -427,9 +427,9 @@ <h1 class="text-sm font-bold text-slate-900 dark:text-white sm:text-base">BLT-LE
                         title="Toggle auto-refresh">
                         <i class="fas fa-sync-alt" id="autoRefreshIcon"></i>
                     </button>
-                    <button id="themeToggle"
+                    <button data-theme-toggle aria-label="Toggle theme" title="Toggle theme"
                         class="rounded-lg p-2 text-slate-500 hover:bg-slate-100 focus:outline-none focus:ring-2 focus:ring-slate-200 dark:text-slate-400 dark:hover:bg-slate-700 dark:focus:ring-slate-600">
-                        <i class="fas fa-moon" id="themeIcon"></i>
+                        <i class="fas fa-moon" data-theme-icon aria-hidden="true"></i>
                     </button>
                     <a href="/how-it-works.html"
                         class="inline-flex items-center gap-2 rounded-lg px-2 sm:px-3 py-2 text-sm font-medium text-slate-700 hover:bg-slate-100 dark:text-slate-300 dark:hover:bg-slate-700 transition-colors"
@@ -3288,10 +3288,7 @@ <h3 class="text-xl font-semibold text-slate-900 dark:text-slate-100">${emptyTitl
             }
         }
 
-        // Theme toggle - handle both mobile and desktop buttons
-        document.querySelectorAll('#themeToggle').forEach(btn => {
-            btn.addEventListener('click', toggleTheme);
-        });
+        // Theme handled by shared theme.js
         
         // Auto-refresh toggle - handle both mobile and desktop buttons
         document.querySelectorAll('#autoRefreshToggle').forEach(btn => {
@@ -3394,41 +3391,7 @@ <h3 class="text-xl font-semibold text-slate-900 dark:text-slate-100">${emptyTitl
             });
         }
 
-        // Theme toggle functionality
-        function initTheme() {
-            // Theme class is already set in the head, just update the icon
-            const isDark = document.documentElement.classList.contains('dark');
-            const themeIcons = document.querySelectorAll('#themeIcon');
 
-            if (isDark) {
-                themeIcons.forEach(icon => {
-                    icon.className = 'fas fa-sun' + (icon.classList.contains('text-xs') ? ' text-xs' : '');
-                });
-            } else {
-                themeIcons.forEach(icon => {
-                    icon.className = 'fas fa-moon' + (icon.classList.contains('text-xs') ? ' text-xs' : '');
-                });
-            }
-        }
-
-        function toggleTheme() {
-            const isDark = document.documentElement.classList.contains('dark');
-            const themeIcons = document.querySelectorAll('#themeIcon');
-
-            if (isDark) {
-                document.documentElement.classList.remove('dark');
-                themeIcons.forEach(icon => {
-                    icon.className = 'fas fa-moon' + (icon.classList.contains('text-xs') ? ' text-xs' : '');
-                });
-                localStorage.setItem('theme', 'light');
-            } else {
-                document.documentElement.classList.add('dark');
-                themeIcons.forEach(icon => {
-                    icon.className = 'fas fa-sun' + (icon.classList.contains('text-xs') ? ' text-xs' : '');
-                });
-                localStorage.setItem('theme', 'dark');
-            }
-        }
 
         // Raw data modal event listeners
         document.getElementById('closeRawDataModal').addEventListener('click', hideRawDataModal);
@@ -3689,10 +3652,38 @@ <h3 class="text-xl font-semibold text-slate-900 dark:text-slate-100">${emptyTitl
             }
         }
 
-        initTheme();
-        loadAuthState();
-        loadRateLimit();
-        loadLatestRelease();
+        async function setupServiceWorkerForEnvironment() {
+            if (!('serviceWorker' in navigator)) {
+                return;
+            }
+
+            const isLocalDev = window.location.hostname === '127.0.0.1' || window.location.hostname === 'localhost';
+            if (isLocalDev) {
+                try {
+                    const registrations = await navigator.serviceWorker.getRegistrations();
+                    await Promise.all(registrations.map(reg => reg.unregister()));
+                } catch (err) {
+                    console.warn('SW unregister failed:', err);
+                }
+
+                if ('caches' in window) {
+                    try {
+                        const keys = await caches.keys();
+                        await Promise.all(keys.map(key => caches.delete(key)));
+                    } catch (err) {
+                        console.warn('Cache clear failed:', err);
+                    }
+                }
+                return;
+            }
+
+            try {
+                const reg = await navigator.serviceWorker.register('/sw.js');
+                console.log('SW Registered:', reg.scope);
+            } catch (err) {
+                console.warn('SW Registration failed:', err);
+            }
+        }
 
         // Handle Refresh All Org button in the sidebar
         (function initRefreshAllOrgBtn() {
@@ -3861,23 +3852,28 @@ <h3 class="text-xl font-semibold text-slate-900 dark:text-slate-100">${emptyTitl
         initOrgFilter();
         // initAuthorFilter sets up event listeners only; dropdown items are populated from /api/authors.
         initAuthorFilter();
-        loadRepos();
-        loadAuthors();
-        loadPrs().then(handlePrUrlParam);
-        setInterval(loadRateLimit, 600000);
 
-        // Initialize auto-refresh
-        updateAutoRefreshUI();
-        if (autoRefreshEnabled) {
-            startAutoRefresh();
-        }
+        (async function bootstrapPageData() {
+            if (typeof window.updateThemeIcons === 'function') {
+                window.updateThemeIcons();
+            }
 
-        // Service Worker Registration
-        if ('serviceWorker' in navigator) {
-            navigator.serviceWorker.register('/sw.js')
-                .then(reg => console.log('SW Registered:', reg.scope))
-                .catch(err => console.warn('SW Registration failed:', err));
-        }
+            await setupServiceWorkerForEnvironment();
+
+            loadAuthState();
+            loadRateLimit();
+            loadLatestRelease();
+            loadRepos();
+            loadAuthors();
+            loadPrs().then(handlePrUrlParam);
+            setInterval(loadRateLimit, 600000);
+
+            // Initialize auto-refresh
+            updateAutoRefreshUI();
+            if (autoRefreshEnabled) {
+                startAutoRefresh();
+            }
+        })();
     </script>
 
     <!-- Footer -->
@@ -3941,6 +3937,7 @@ <h3 class="text-xl font-semibold text-slate-900 dark:text-slate-100">${emptyTitl
             }
         })();
     </script>
+    <script src="theme.196e3e21.js"></script>
 </body>
 
 </html>
diff --git a/public/sw.js b/public/sw.js
index 5be438bf..e39725ee 100644
--- a/public/sw.js
+++ b/public/sw.js
@@ -1,16 +1,24 @@
 // Service Worker - caches static assets, API responses, and HTML pages for faster loads.
 
+// Bump this version whenever a new deployment ships new fingerprinted asset names.
 const CACHE_VERSION = 'blt-leaf-v3';
 const STATIC_CACHE = `${CACHE_VERSION}-static`;
 const API_CACHE = `${CACHE_VERSION}-api`;
 const CDN_CACHE = `${CACHE_VERSION}-cdn`;
+const IS_LOCAL_DEV = self.location.hostname === '127.0.0.1' || self.location.hostname === 'localhost';
 
-// Static assets to precache on install
+// Matches fingerprinted asset URLs produced by scripts/fingerprint.js.
+// e.g. /error-reporter.abc12345.js  /theme.abc12345.js
+const FINGERPRINTED_RE = /\/[^/]+\.[0-9a-f]{8}\.(js|css)(\?.*)?$/;
+
+// Static assets to precache on install.
+// Fingerprinted JS/CSS are NOT listed here — they are cached on first use by
+// the cacheFirst handler below and remain valid indefinitely because their URL
+// changes whenever their content changes.
 const PRECACHE_URLS = [
     '/',
     '/index.html',
     '/how-it-works.html',
-    '/how-it-works.js',
     '/static/logo.png'
 ];
 
@@ -32,6 +40,10 @@ const API_CACHE_MAX_AGE = 5 * 60 * 1000;
 
 // Install
 self.addEventListener('install', (event) => {
+    if (IS_LOCAL_DEV) {
+        event.waitUntil(self.skipWaiting());
+        return;
+    }
     event.waitUntil(
         caches.open(STATIC_CACHE)
             .then((cache) => cache.addAll(PRECACHE_URLS))
@@ -45,6 +57,14 @@ self.addEventListener('install', (event) => {
 
 // Activate
 self.addEventListener('activate', (event) => {
+    if (IS_LOCAL_DEV) {
+        event.waitUntil(
+            caches.keys()
+                .then((keys) => Promise.all(keys.map((key) => caches.delete(key))))
+                .then(() => self.clients.claim())
+        );
+        return;
+    }
     event.waitUntil(
         caches.keys().then((keys) =>
             Promise.all(
@@ -63,6 +83,20 @@ self.addEventListener('fetch', (event) => {
     // Only handle GET requests
     if (request.method !== 'GET') return;
 
+    // In local dev, bypass SW cache for static assets to avoid stale JS/CSS/HTML/sw.js.
+    if (IS_LOCAL_DEV &&
+        url.origin === self.location.origin &&
+        (
+            url.pathname === '/' ||
+            url.pathname === '/sw.js' ||
+            url.pathname.endsWith('.js') ||
+            url.pathname.endsWith('.css') ||
+            url.pathname.endsWith('.html')
+        )) {
+        event.respondWith(fetch(request, { cache: 'no-store' }));
+        return;
+    }
+
     // Auth endpoints must bypass service-worker caching/interception because
     // OAuth relies on network redirects and Set-Cookie propagation.
     if (url.origin === self.location.origin && url.pathname.startsWith('/api/auth/')) {
@@ -129,6 +163,13 @@ self.addEventListener('fetch', (event) => {
         return;
     }
 
+    // Fingerprinted assets (immutable content) — cache forever on first fetch.
+    // Their URLs change with every content update so stale entries are never served.
+    if (FINGERPRINTED_RE.test(url.pathname)) {
+        event.respondWith(cacheFirst(request, STATIC_CACHE));
+        return;
+    }
+
     // All other static assets
     event.respondWith(cacheFirst(request, STATIC_CACHE));
 });
diff --git a/public/test-error.html b/public/test-error.html
index e70fd591..f7019477 100644
--- a/public/test-error.html
+++ b/public/test-error.html
@@ -23,7 +23,7 @@
             }
         })();
     </script>
-    <script src="error-reporter.js"></script>
+    <script src="error-reporter.1b9dc33f.js"></script>
 
     <script src="https://cdn.tailwindcss.com"></script>
     <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css"
@@ -55,10 +55,10 @@
                     class="text-slate-600 hover:text-slate-900 dark:text-slate-400 dark:hover:text-slate-100">
                     <i class="fab fa-github"></i> GitHub
                 </a>
-                <button id="themeToggle"
+                <button data-theme-toggle
                     class="rounded-lg p-2 text-slate-500 hover:bg-slate-100 dark:text-slate-400 dark:hover:bg-slate-700 transition-colors"
                     title="Toggle dark/light mode">
-                    <i class="fas fa-moon" id="themeIcon"></i>
+                    <i class="fas fa-moon" data-theme-icon></i>
                 </button>
             </nav>
         </div>
@@ -222,8 +222,8 @@ <h2 class="text-lg font-semibold text-slate-900 dark:text-white mb-1">Frontend J
 
         // ── Theme toggle ──────────────────────────────────────────────────────────
 
-        const themeToggle = document.getElementById('themeToggle');
-        const themeIcon = document.getElementById('themeIcon');
+        const themeToggle = document.querySelector('[data-theme-toggle]');
+        const themeIcon = document.querySelector('[data-theme-icon]');
         themeToggle.addEventListener('click', () => {
             const isDark = document.documentElement.classList.toggle('dark');
             themeIcon.className = isDark ? 'fas fa-sun' : 'fas fa-moon';
diff --git a/public/theme.196e3e21.js b/public/theme.196e3e21.js
new file mode 100644
index 00000000..a8ab7ac5
--- /dev/null
+++ b/public/theme.196e3e21.js
@@ -0,0 +1,58 @@
+// Shared theme utilities for BLT-Leaf
+// - sets Tailwind config for dark mode
+// - applies the saved or preferred theme early to avoid FOUC
+// - provides `toggleTheme()` and wires up theme icons/toggles on DOMContentLoaded
+
+window.tailwind = window.tailwind || {};
+window.tailwind.config = window.tailwind.config || {};
+window.tailwind.config.darkMode = 'class';
+
+(function applyInitialTheme() {
+    try {
+        const savedTheme = localStorage.getItem('theme');
+        if (savedTheme === 'dark') {
+            document.documentElement.classList.add('dark');
+        } else if (savedTheme === 'light') {
+            document.documentElement.classList.remove('dark');
+        } else {
+            // No explicit saved theme: respect the OS/browser preference.
+            if (window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches) {
+                document.documentElement.classList.add('dark');
+            } else {
+                document.documentElement.classList.remove('dark');
+            }
+        }
+    } catch (e) {
+        // Storage unavailable — leave any theme class already set in the <head> as-is.
+    }
+})();
+
+function updateThemeIcons() {
+    const icons = document.querySelectorAll('[data-theme-icon]');
+    icons.forEach(icon => {
+        const isTextXs = icon.classList.contains('text-xs');
+        const base = document.documentElement.classList.contains('dark') ? 'fas fa-sun' : 'fas fa-moon';
+        icon.className = base + (isTextXs ? ' text-xs' : '');
+    });
+}
+
+function toggleTheme() {
+    const isDark = document.documentElement.classList.contains('dark');
+    if (isDark) {
+        document.documentElement.classList.remove('dark');
+        try { localStorage.setItem('theme', 'light'); } catch (e) {}
+    } else {
+        document.documentElement.classList.add('dark');
+        try { localStorage.setItem('theme', 'dark'); } catch (e) {}
+    }
+    updateThemeIcons();
+}
+
+document.addEventListener('DOMContentLoaded', function () {
+    updateThemeIcons();
+    document.querySelectorAll('[data-theme-toggle]')
+        .forEach(btn => btn.addEventListener('click', toggleTheme));
+});
+
+// Export for other scripts
+window.toggleTheme = toggleTheme;
diff --git a/public/theme.js b/public/theme.js
new file mode 100644
index 00000000..a8ab7ac5
--- /dev/null
+++ b/public/theme.js
@@ -0,0 +1,58 @@
+// Shared theme utilities for BLT-Leaf
+// - sets Tailwind config for dark mode
+// - applies the saved or preferred theme early to avoid FOUC
+// - provides `toggleTheme()` and wires up theme icons/toggles on DOMContentLoaded
+
+window.tailwind = window.tailwind || {};
+window.tailwind.config = window.tailwind.config || {};
+window.tailwind.config.darkMode = 'class';
+
+(function applyInitialTheme() {
+    try {
+        const savedTheme = localStorage.getItem('theme');
+        if (savedTheme === 'dark') {
+            document.documentElement.classList.add('dark');
+        } else if (savedTheme === 'light') {
+            document.documentElement.classList.remove('dark');
+        } else {
+            // No explicit saved theme: respect the OS/browser preference.
+            if (window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches) {
+                document.documentElement.classList.add('dark');
+            } else {
+                document.documentElement.classList.remove('dark');
+            }
+        }
+    } catch (e) {
+        // Storage unavailable — leave any theme class already set in the <head> as-is.
+    }
+})();
+
+function updateThemeIcons() {
+    const icons = document.querySelectorAll('[data-theme-icon]');
+    icons.forEach(icon => {
+        const isTextXs = icon.classList.contains('text-xs');
+        const base = document.documentElement.classList.contains('dark') ? 'fas fa-sun' : 'fas fa-moon';
+        icon.className = base + (isTextXs ? ' text-xs' : '');
+    });
+}
+
+function toggleTheme() {
+    const isDark = document.documentElement.classList.contains('dark');
+    if (isDark) {
+        document.documentElement.classList.remove('dark');
+        try { localStorage.setItem('theme', 'light'); } catch (e) {}
+    } else {
+        document.documentElement.classList.add('dark');
+        try { localStorage.setItem('theme', 'dark'); } catch (e) {}
+    }
+    updateThemeIcons();
+}
+
+document.addEventListener('DOMContentLoaded', function () {
+    updateThemeIcons();
+    document.querySelectorAll('[data-theme-toggle]')
+        .forEach(btn => btn.addEventListener('click', toggleTheme));
+});
+
+// Export for other scripts
+window.toggleTheme = toggleTheme;
diff --git a/scripts/fingerprint.js b/scripts/fingerprint.js
new file mode 100644
index 00000000..569aef75
--- /dev/null
+++ b/scripts/fingerprint.js
@@ -0,0 +1,137 @@
+/**
+ * fingerprint.js — Content-hash static assets for cache busting.
+ *
+ * For each asset listed in ASSETS:
+ *   1. Compute the first 8 hex chars of its SHA-256 content hash.
+ *   2. Write a fingerprinted copy:  <stem>.<hash>.<ext>  (e.g. theme.c06488f2.js)
+ *   3. Delete any stale fingerprinted copies for the same base name.
+ *   4. Rewrite all src="…<stem>.<ext>…" references in HTML_FILES to the new name.
+ *
+ * Run automatically via the wrangler build command:
+ *   node scripts/fingerprint.js && bash scripts/migration.sh
+ *
+ * Or manually:
+ *   node scripts/fingerprint.js
+ */
+
+'use strict';
+
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+
+const PUBLIC = path.join(__dirname, '..', 'public');
+
+// Local JS/CSS assets to fingerprint.
+// CDN resources, sw.js, and HTML files are intentionally excluded.
+const ASSETS = [
+    'error-reporter.js',
+    'how-it-works.js',
+    'theme.js',
+];
+
+// HTML files whose asset references will be rewritten.
+const HTML_FILES = [
+    'index.html',
+    'how-it-works.html',
+    'diagnostics.html',
+    'test-error.html',
+];
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+function hashFile(filePath) {
+    const content = fs.readFileSync(filePath);
+    return crypto.createHash('sha256').update(content).digest('hex').slice(0, 8);
+}
+
+function escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+// ── Fingerprint each asset ────────────────────────────────────────────────────
+
+const manifest = {};
+const missingAssets = [];
+
+for (const asset of ASSETS) {
+    const srcPath = path.join(PUBLIC, asset);
+    if (!fs.existsSync(srcPath)) {
+        missingAssets.push(asset);
+        continue;
+    }
+
+    const ext = path.extname(asset);         // '.js'
+    const stem = path.basename(asset, ext);  // 'theme'
+    const hash = hashFile(srcPath);
+    const fingerprinted = `${stem}.${hash}${ext}`;  // 'theme.c06488f2.js'
+    const destPath = path.join(PUBLIC, fingerprinted);
+
+    // Remove stale fingerprinted copies (different hash) for this asset.
+    const stalePattern = new RegExp(
+        `^${escapeRegex(stem)}\\.[0-9a-f]{8}\\${ext}$`
+    );
+    for (const existing of fs.readdirSync(PUBLIC)) {
+        if (stalePattern.test(existing) && existing !== fingerprinted) {
+            fs.unlinkSync(path.join(PUBLIC, existing));
+            console.log(`[fingerprint] Removed stale: ${existing}`);
+        }
+    }
+
+    // Write the fingerprinted copy if it doesn't already exist.
+    if (!fs.existsSync(destPath)) {
+        fs.copyFileSync(srcPath, destPath);
+        console.log(`[fingerprint] Created: ${fingerprinted}`);
+    } else {
+        console.log(`[fingerprint] Up to date: ${fingerprinted}`);
+    }
+
+    manifest[asset] = fingerprinted;
+}
+
+if (missingAssets.length > 0) {
+    throw new Error(
+        `[fingerprint] Missing required asset(s): ${missingAssets.join(', ')}`
+    );
+}
+
+// Persist the manifest so other tools can read it if needed.
+const manifestPath = path.join(PUBLIC, 'asset-manifest.json');
+fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2) + '\n');
+console.log('[fingerprint] Wrote asset-manifest.json');
+
+// ── Rewrite HTML references ───────────────────────────────────────────────────
+
+for (const htmlFile of HTML_FILES) {
+    const htmlPath = path.join(PUBLIC, htmlFile);
+    if (!fs.existsSync(htmlPath)) continue;
+
+    let html = fs.readFileSync(htmlPath, 'utf8');
+    let changed = false;
+
+    for (const [original, fingerprinted] of Object.entries(manifest)) {
+        const ext = path.extname(original);        // '.js'
+        const stem = path.basename(original, ext); // 'theme'
+
+        // Matches both unhashed and hashed names:
+        //   src="(optional-path/)stem.ext"
+        //   src="(optional-path/)stem.1234abcd.ext"
+        const re = new RegExp(
+            `(src=["'][^"']*)${escapeRegex(stem)}(?:\\.[0-9a-f]{8})?${escapeRegex(ext)}(["'])`,
+            'g'
+        );
+
+        const updated = html.replace(re, `$1${fingerprinted}$2`);
+        if (updated !== html) {
+            html = updated;
+            changed = true;
+        }
+    }
+
+    if (changed) {
+        fs.writeFileSync(htmlPath, html, 'utf8');
+        console.log(`[fingerprint] Updated: ${htmlFile}`);
+    } else {
+        console.log(`[fingerprint] No changes: ${htmlFile}`);
+    }
+}
diff --git a/src/index.py b/src/index.py
index 62941b7a..f0a0dcdd 100644
--- a/src/index.py
+++ b/src/index.py
@@ -1,50 +1,100 @@
 """Main entry point for BLT-Leaf PR Readiness Checker - Cloudflare Worker"""
+
 import json
-from js import Response, URL, Object
+import re
 import time as _time
+
+from js import Headers, Object, Response, URL
 from pyodide.ffi import to_js
-from slack_notifier import notify_slack_exception, notify_slack_error
+
+from slack_notifier import notify_slack_error, notify_slack_exception
+
 # Import all handlers
 from handlers import (
     handle_add_pr,
-    handle_list_prs,
-    handle_list_repos,
-    handle_list_authors,
-    handle_refresh_pr,
     handle_batch_refresh_prs,
-    handle_refresh_org,
-    handle_rate_limit,
-    handle_status,
-    handle_pr_updates_check,
     handle_get_pr,
     handle_github_webhook,
-    handle_pr_timeline,
-    handle_pr_review_analysis,
+    handle_list_authors,
+    handle_list_prs,
+    handle_list_repos,
     handle_pr_readiness,
-    handle_scheduled_refresh
+    handle_pr_review_analysis,
+    handle_pr_timeline,
+    handle_pr_updates_check,
+    handle_rate_limit,
+    handle_refresh_org,
+    handle_refresh_pr,
+    handle_scheduled_refresh,
+    handle_status,
 )
 from auth_handlers import (
-    handle_auth_login,
     handle_auth_callback,
-    handle_auth_user,
+    handle_auth_login,
     handle_auth_logout,
+    handle_auth_user,
 )
 
-_err_rl:     dict = {}                               # rate-limit buckets
-_err_dedup:  dict = {}                               # dedup: sig -> expiry
-_slack_bgt:  dict = {'count': 0, 'window_start': 0.0}  # global Slack budget
+# Matches fingerprinted asset filenames produced by scripts/fingerprint.js.
+# Pattern: <stem>.<8 hex chars>.<ext> e.g. error-reporter.abc12345.js
+_FINGERPRINTED_RE = re.compile(r"\.[0-9a-f]{8}\.(js|css)$")
+
+_err_rl: dict = {}
+_err_dedup: dict = {}
+_slack_bgt: dict = {"count": 0, "window_start": 0.0}
+
+
+def is_local_dev_request(request):
+    """Detect local wrangler dev traffic."""
+    request_url = str(request.url)
+    return "127.0.0.1" in request_url or "localhost" in request_url
+
+
+def is_cache_controlled_static_path(path):
+    """Static asset paths that should get explicit cache-control headers."""
+    if path == "/" or path == "/sw.js":
+        return True
+    return path.endswith(".js") or path.endswith(".css") or path.endswith(".html")
+
+
+async def fetch_static_asset_with_cache_headers(request, env, path):
+    """Fetch static assets and enforce cache behavior by asset type."""
+    asset_response = await env.ASSETS.fetch(request)
+    if not is_cache_controlled_static_path(path):
+        return asset_response
+
+    headers = Headers.new(asset_response.headers)
+    if is_local_dev_request(request):
+        headers.set("Cache-Control", "no-store")
+    elif path == "/" or path == "/sw.js" or path.endswith(".html"):
+        headers.set("Cache-Control", "no-cache, must-revalidate")
+    elif _FINGERPRINTED_RE.search(path):
+        headers.set("Cache-Control", "public, max-age=31536000, immutable")
+    else:
+        headers.set("Cache-Control", "no-cache, must-revalidate")
+
+    return Response.new(
+        asset_response.body,
+        {
+            "status": asset_response.status,
+            "statusText": asset_response.statusText,
+            "headers": headers,
+        },
+    )
+
 
 def check_rate_limit_bucket(bucket, ip, limit, window):
     now = _time.time()
     key = f"{bucket}:{ip}"
-    e = _err_rl.get(key)
-    if not e or (now - e['window_start']) >= window:
-        _err_rl[key] = {'count': 1, 'window_start': now}
+    entry = _err_rl.get(key)
+    if not entry or (now - entry["window_start"]) >= window:
+        _err_rl[key] = {"count": 1, "window_start": now}
         return True, 0
-    if e['count'] < limit:
-        e['count'] += 1
+    if entry["count"] < limit:
+        entry["count"] += 1
         return True, 0
-    return False, int(window - (now - e['window_start'])) + 1
+    return False, int(window - (now - entry["window_start"])) + 1
+
 
 def should_send_dedupe(sig, ttl):
     now = _time.time()
@@ -53,100 +103,95 @@ def should_send_dedupe(sig, ttl):
     _err_dedup[sig] = now + ttl
     return True
 
+
 def slack_budget_allow(limit, window):
     now = _time.time()
-    ws = _slack_bgt['window_start']
-    if not ws or (now - ws) >= window:
-        _slack_bgt.update({'count': 1, 'window_start': now})
+    window_start = _slack_bgt["window_start"]
+    if not window_start or (now - window_start) >= window:
+        _slack_bgt.update({"count": 1, "window_start": now})
         return True, 0
-    if _slack_bgt['count'] < limit:
-        _slack_bgt['count'] += 1
+    if _slack_bgt["count"] < limit:
+        _slack_bgt["count"] += 1
         return True, 0
-    return False, int(window - (now - ws)) + 1
+    return False, int(window - (now - window_start)) + 1
+
 
 def _get_client_ip(request):
     return (
-        request.headers.get('cf-connecting-ip')
-        or (request.headers.get('x-forwarded-for') or '').split(',')[0].strip()
-        or request.headers.get('x-real-ip')
-        or 'unknown'
+        request.headers.get("cf-connecting-ip")
+        or (request.headers.get("x-forwarded-for") or "").split(",")[0].strip()
+        or request.headers.get("x-real-ip")
+        or "unknown"
     )
 
+
 def json_response(data: dict, status: int, extra_headers: dict | None = None):
-    headers = {'Content-Type': 'application/json'}
+    headers = {"Content-Type": "application/json"}
     if extra_headers:
         headers.update(extra_headers)
 
-    # Convert to a real JS init object so status is respected
     init = to_js(
-        {'status': status, 'headers': headers},
-        dict_converter=Object.fromEntries
+        {"status": status, "headers": headers},
+        dict_converter=Object.fromEntries,
     )
     return Response.new(json.dumps(data), init)
+
+
 async def on_fetch(request, env):
-    """Main request handler"""
-    slack_webhook = getattr(env, 'SLACK_ERROR_WEBHOOK', '')
+    """Main request handler."""
+    slack_webhook = getattr(env, "SLACK_ERROR_WEBHOOK", "")
 
     url = URL.new(request.url)
     path = url.pathname
-    
-    # Strip /leaf prefix
-    if path == '/leaf': 
-        path = '/'
-    elif path.startswith('/leaf/'): 
-        path = path[5:]  # Remove '/leaf' (5 characters)
-    
-    # CORS headers
-    # NOTE: '*' allows all origins for public access. In production, consider
-    # restricting to specific domains by setting this to your domain(s).
+
+    if path == "/leaf":
+        path = "/"
+    elif path.startswith("/leaf/"):
+        path = path[5:]
+
     cors_headers = {
-        'Access-Control-Allow-Origin': '*',
-        'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
-        'Access-Control-Allow-Headers': 'Content-Type, x-github-token',
+        "Access-Control-Allow-Origin": "*",
+        "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+        "Access-Control-Allow-Headers": "Content-Type, x-github-token",
     }
 
     try:
-        # Handle CORS preflight
-        if request.method == 'OPTIONS':
-            return Response.new('', {'headers': cors_headers})
-        
-        # Serve HTML for root path 
-        if path == '/' or path == '/index.html':
-            # Use env.ASSETS to serve static files if available
-            if hasattr(env, 'ASSETS'): 
-                return await env.ASSETS.fetch(request)
-            # Fallback: return simple message
-            return Response.new('Please configure assets in wrangler.toml', 
-                              {'status': 200, 'headers': {**cors_headers, 'Content-Type': 'text/html'}})
-        
-        # API endpoints
+        if request.method == "OPTIONS":
+            return Response.new("", {"headers": cors_headers})
+
+        if path == "/" or path == "/index.html":
+            if hasattr(env, "ASSETS"):
+                return await fetch_static_asset_with_cache_headers(request, env, path)
+            return Response.new(
+                "Please configure assets in wrangler.toml",
+                {"status": 200, "headers": {**cors_headers, "Content-Type": "text/html"}},
+            )
+
         response = None
-        
-        if path == '/api/prs/updates' and request.method == 'GET':
+
+        if path == "/api/prs/updates" and request.method == "GET":
             response = await handle_pr_updates_check(env)
-        elif path == '/api/prs':
-            if request.method == 'GET':
-                repo = url.searchParams.get('repo')
-                org = url.searchParams.get('org')
-                author = url.searchParams.get('author')
-                page = url.searchParams.get('page')
-                per_page_param = url.searchParams.get('per_page')
-                sort_by = url.searchParams.get('sort_by')
-                sort_dir = url.searchParams.get('sort_dir')
-                
-                # Parse and validate per_page parameter
-                per_page = 30  # default
+        elif path == "/api/prs":
+            if request.method == "GET":
+                repo = url.searchParams.get("repo")
+                org = url.searchParams.get("org")
+                author = url.searchParams.get("author")
+                page = url.searchParams.get("page")
+                per_page_param = url.searchParams.get("per_page")
+                sort_by = url.searchParams.get("sort_by")
+                sort_dir = url.searchParams.get("sort_dir")
+
+                per_page = 30
                 if per_page_param:
                     try:
                         per_page = int(per_page_param)
-                        # Validate per_page is in allowed range (10-1000)
                         if per_page < 10:
                             per_page = 10
                         elif per_page > 1000:
                             per_page = 1000
                     except (ValueError, TypeError):
                         per_page = 30
-                
+
                 response = await handle_list_prs(
                     env,
                     repo,
@@ -155,130 +200,124 @@ async def on_fetch(request, env):
                     sort_by,
                     sort_dir,
                     org,
-                    author
+                    author,
                 )
-            elif request.method == 'POST':
+            elif request.method == "POST":
                 response = await handle_add_pr(request, env)
-        # Single PR endpoint - GET /api/prs/{id}
-        # The '/' check ensures sub-paths like /api/prs/{id}/timeline are not intercepted here
-        elif path.startswith('/api/prs/') and '/' not in path[len('/api/prs/'):] and request.method == 'GET':
-            pr_id_str = path[len('/api/prs/'):]
+        elif path.startswith("/api/prs/") and "/" not in path[len("/api/prs/"):] and request.method == "GET":
+            pr_id_str = path[len("/api/prs/"):]
             if pr_id_str.isdigit():
                 response = await handle_get_pr(env, int(pr_id_str))
-        elif path == '/api/repos' and request.method == 'GET':
+        elif path == "/api/repos" and request.method == "GET":
             response = await handle_list_repos(env)
-        elif path == '/api/authors' and request.method == 'GET':
+        elif path == "/api/authors" and request.method == "GET":
             response = await handle_list_authors(env)
-        elif path == '/api/refresh' and request.method == 'POST':
+        elif path == "/api/refresh" and request.method == "POST":
             response = await handle_refresh_pr(request, env)
-        elif path == '/api/refresh-batch' and request.method == 'POST':
+        elif path == "/api/refresh-batch" and request.method == "POST":
             response = await handle_batch_refresh_prs(request, env)
-        elif path == '/api/refresh-org' and request.method == 'POST':
+        elif path == "/api/refresh-org" and request.method == "POST":
             response = await handle_refresh_org(request, env)
-        elif path == '/api/rate-limit' and request.method == 'GET':
+        elif path == "/api/rate-limit" and request.method == "GET":
             response = await handle_rate_limit(request, env)
             for key, value in cors_headers.items():
                 response.headers.set(key, value)
-            return response 
-        elif path == '/api/auth/login' and request.method == 'GET':
+            return response
+        elif path == "/api/auth/login" and request.method == "GET":
             response = await handle_auth_login(request, env)
             for key, value in cors_headers.items():
                 response.headers.set(key, value)
             return response
-        elif path == '/api/auth/callback' and request.method == 'GET':
+        elif path == "/api/auth/callback" and request.method == "GET":
             response = await handle_auth_callback(request, env)
             for key, value in cors_headers.items():
                 response.headers.set(key, value)
             return response
-        elif path == '/api/auth/user' and request.method == 'GET':
+        elif path == "/api/auth/user" and request.method == "GET":
             response = await handle_auth_user(request, env)
             for key, value in cors_headers.items():
                 response.headers.set(key, value)
             return response
-        elif path == '/api/auth/logout' and request.method == 'POST':
+        elif path == "/api/auth/logout" and request.method == "POST":
             response = await handle_auth_logout(request, env)
             for key, value in cors_headers.items():
                 response.headers.set(key, value)
             return response
-        elif path == '/api/status' and request.method == 'GET':
+        elif path == "/api/status" and request.method == "GET":
             response = await handle_status(env)
-        elif path == '/api/github/webhook' and request.method == 'POST':
+        elif path == "/api/github/webhook" and request.method == "POST":
             response = await handle_github_webhook(request, env)
             for key, value in cors_headers.items():
                 response.headers.set(key, value)
             return response
-        
-        elif path == '/api/error-test' and request.method == 'POST':
+        elif path == "/api/test-error" and request.method == "POST":
+            raise RuntimeError("Slack test error triggered intentionally from /api/test-error")
+        elif path == "/api/error-test" and request.method == "POST":
             ip = _get_client_ip(request)
 
-            # Rate limit (keep it strict; default 1/min/IP)
-            limit = int(getattr(env, 'ERROR_TEST_RATE_LIMIT', 1) or 1)
-            window = int(getattr(env, 'ERROR_TEST_RATE_WINDOW', 60) or 60)
-            allowed, retry_after = check_rate_limit_bucket('error-test', ip, limit, window)
+            limit = int(getattr(env, "ERROR_TEST_RATE_LIMIT", 1) or 1)
+            window = int(getattr(env, "ERROR_TEST_RATE_WINDOW", 60) or 60)
+            allowed, retry_after = check_rate_limit_bucket("error-test", ip, limit, window)
             if not allowed:
                 response = json_response(
-                    {'ok': False, 'reason': 'Rate limit exceeded'},
+                    {"ok": False, "reason": "Rate limit exceeded"},
                     429,
-                    extra_headers={'Retry-After': str(retry_after)}
+                    extra_headers={"Retry-After": str(retry_after)},
                 )
-                for k, v in cors_headers.items():
-                    response.headers.set(k, v)
+                for key, value in cors_headers.items():
+                    response.headers.set(key, value)
                 return response
 
-            slack_webhook = (getattr(env, 'SLACK_ERROR_WEBHOOK', '') or '').strip()
+            slack_webhook = (getattr(env, "SLACK_ERROR_WEBHOOK", "") or "").strip()
             if not slack_webhook:
-                response = json_response({'ok': False, 'reason': 'SLACK_ERROR_WEBHOOK not set'}, 500)
-                for k, v in cors_headers.items():
-                    response.headers.set(k, v)
+                response = json_response({"ok": False, "reason": "SLACK_ERROR_WEBHOOK not set"}, 500)
+                for key, value in cors_headers.items():
+                    response.headers.set(key, value)
                 return response
 
             slack_ok = await notify_slack_error(
                 slack_webhook,
-                error_type='ErrorTest',
-                error_message='Slack error-test triggered',
-                context={'source': '/api/error-test', 'url': str(request.url), 'ip': ip},
+                error_type="ErrorTest",
+                error_message="Slack error-test triggered",
+                context={"source": "/api/error-test", "url": str(request.url), "ip": ip},
                 stack_trace=None,
             )
             if slack_ok:
-                response = json_response({'ok': True, 'sent_to_slack': True}, 200)
+                response = json_response({"ok": True, "sent_to_slack": True}, 200)
             else:
-                print('Error-test Slack send failed')
-                response = json_response({'ok': False, 'reason': 'Slack send failed (check worker logs)'}, 502)
+                print("Error-test Slack send failed")
+                response = json_response({"ok": False, "reason": "Slack send failed (check worker logs)"}, 502)
 
-            for k, v in cors_headers.items():
-                response.headers.set(k, v)
+            for key, value in cors_headers.items():
+                response.headers.set(key, value)
             return response
-        # Frontend client-error reporting endpoint
-        elif path == '/api/client-error' and request.method == 'POST':
+        elif path == "/api/client-error" and request.method == "POST":
             ip = _get_client_ip(request)
 
-            # Rate limit per IP (default 10/min)
-            limit = int(getattr(env, 'CLIENT_ERROR_RATE_LIMIT', 5) or 5)
-            window = int(getattr(env, 'CLIENT_ERROR_RATE_WINDOW', 60) or 60)
-            allowed, retry_after = check_rate_limit_bucket('client-error', ip, limit, window)
+            limit = int(getattr(env, "CLIENT_ERROR_RATE_LIMIT", 5) or 5)
+            window = int(getattr(env, "CLIENT_ERROR_RATE_WINDOW", 60) or 60)
+            allowed, retry_after = check_rate_limit_bucket("client-error", ip, limit, window)
             if not allowed:
                 response = json_response(
-                    {'error': 'Rate limit exceeded'},
+                    {"error": "Rate limit exceeded"},
                     429,
-                    extra_headers={'Retry-After': str(retry_after)}
+                    extra_headers={"Retry-After": str(retry_after)},
                 )
-                for k, v in cors_headers.items():
-                    response.headers.set(k, v)
+                for key, value in cors_headers.items():
+                    response.headers.set(key, value)
                 return response
 
-            # Payload cap (default 8KB)
-            max_bytes = int(getattr(env, 'CLIENT_ERROR_MAX_BYTES', 8192) or 8192)
+            max_bytes = int(getattr(env, "CLIENT_ERROR_MAX_BYTES", 8192) or 8192)
             try:
-                content_len = int(request.headers.get('content-length') or '0')
+                content_len = int(request.headers.get("content-length") or "0")
             except Exception:
                 content_len = 0
             if content_len and content_len > max_bytes:
-                response = json_response({'error': 'Payload too large'}, 413)
-                for k, v in cors_headers.items():
-                    response.headers.set(k, v)
+                response = json_response({"error": "Payload too large"}, 413)
+                for key, value in cors_headers.items():
+                    response.headers.set(key, value)
                 return response
 
-            # Parse JSON once (tolerate beacon text/plain too)
             body = {}
             try:
                 body = (await request.json()).to_py()
@@ -289,28 +328,26 @@ async def on_fetch(request, env):
                 except Exception:
                     body = {}
 
-            error_type = str(body.get('error_type', 'FrontendError'))[:80]
-            error_message = str(body.get('message', 'Unknown frontend error'))[:300]
-            stack_trace = (str(body.get('stack', ''))[:2000] or None)
+            error_type = str(body.get("error_type", "FrontendError"))[:80]
+            error_message = str(body.get("message", "Unknown frontend error"))[:300]
+            stack_trace = str(body.get("stack", ""))[:2000] or None
 
-            url_here = str(body.get('url', ''))[:200] or ''
-            line = str(body.get('line', ''))[:20] or ''
-            col = str(body.get('col', ''))[:20] or ''
-            resource = str(body.get('resource', ''))[:200] or ''
+            url_here = str(body.get("url", ""))[:200] or ""
+            line = str(body.get("line", ""))[:20] or ""
+            col = str(body.get("col", ""))[:20] or ""
+            resource = str(body.get("resource", ""))[:200] or ""
 
-            # Dedupe key: same error signature shouldn't spam Slack
-            dedupe_ttl = int(getattr(env, 'CLIENT_ERROR_DEDUPE_TTL', 300) or 300)  # 5 min default
+            dedupe_ttl = int(getattr(env, "CLIENT_ERROR_DEDUPE_TTL", 300) or 300)
             signature = f"{error_type}|{error_message}|{url_here}|{line}|{col}|{resource}"
             should_slack = should_send_dedupe(signature, dedupe_ttl)
 
-            # Global Slack cap (default 20/min total)
-            slack_cap = int(getattr(env, 'SLACK_MAX_PER_MIN', 20) or 20)
+            slack_cap = int(getattr(env, "SLACK_MAX_PER_MIN", 20) or 20)
             slack_allowed, slack_retry = slack_budget_allow(slack_cap, 60)
 
-            ctx = {k: str(v)[:200] for k, v in body.items() if k not in ('error_type', 'message', 'stack')}
-            ctx['source'] = 'frontend'
-            ctx['ip'] = ip
-            ctx['dedupe'] = '1' if should_slack else '0'
+            ctx = {key: str(value)[:200] for key, value in body.items() if key not in ("error_type", "message", "stack")}
+            ctx["source"] = "frontend"
+            ctx["ip"] = ip
+            ctx["dedupe"] = "1" if should_slack else "0"
 
             slack_sent = False
             if should_slack and slack_allowed:
@@ -322,75 +359,78 @@ async def on_fetch(request, env):
                     stack_trace=stack_trace,
                 )
                 if not slack_sent:
-                    print('Slack: failed to report frontend error')
+                    print("Slack: failed to report frontend error")
             else:
                 if not should_slack:
                     print("Slack: deduped client-error")
                 elif not slack_allowed:
                     print(f"Slack: global cap reached, retry after {slack_retry}s")
 
-            response = json_response({'ok': True, 'slack_sent': slack_sent, 'deduped': (not should_slack)}, 200)
-            for k, v in cors_headers.items():
-                response.headers.set(k, v)
+            response = json_response(
+                {"ok": True, "slack_sent": slack_sent, "deduped": not should_slack},
+                200,
+            )
+            for key, value in cors_headers.items():
+                response.headers.set(key, value)
             return response
-        # Timeline endpoint - GET /api/prs/{id}/timeline
-        elif path.startswith('/api/prs/') and path.endswith('/timeline') and request.method == 'GET':
+        elif path.startswith("/api/prs/") and path.endswith("/timeline") and request.method == "GET":
             response = await handle_pr_timeline(request, env, path)
             for key, value in cors_headers.items():
                 response.headers.set(key, value)
             return response
-        # Review analysis endpoint - GET /api/prs/{id}/review-analysis
-        elif path.startswith('/api/prs/') and path.endswith('/review-analysis') and request.method == 'GET':
+        elif path.startswith("/api/prs/") and path.endswith("/review-analysis") and request.method == "GET":
             response = await handle_pr_review_analysis(request, env, path)
             for key, value in cors_headers.items():
                 response.headers.set(key, value)
             return response
-        # PR readiness endpoint - GET /api/prs/{id}/readiness
-        elif path.startswith('/api/prs/') and path.endswith('/readiness') and request.method == 'GET':
+        elif path.startswith("/api/prs/") and path.endswith("/readiness") and request.method == "GET":
             response = await handle_pr_readiness(request, env, path)
             for key, value in cors_headers.items():
                 response.headers.set(key, value)
             return response
-        
-        # If no API route matched, try static assets or return 404
+
         if response is None:
-            if hasattr(env, 'ASSETS'): return await env.ASSETS.fetch(request)
-            return Response.new('Not Found', {'status': 404, 'headers': cors_headers})
-        
-        # Apply CORS to API responses
+            if hasattr(env, "ASSETS"):
+                return await fetch_static_asset_with_cache_headers(request, env, path)
+            return Response.new("Not Found", {"status": 404, "headers": cors_headers})
+
         for key, value in cors_headers.items():
-            if response: response.headers.set(key, value)
+            if response:
+                response.headers.set(key, value)
         return response
 
     except Exception as exc:
         try:
-            await notify_slack_exception(slack_webhook, exc, context={
-                'path': path,
-                'method': str(request.method),
-            })
+            await notify_slack_exception(
+                slack_webhook,
+                exc,
+                context={
+                    "path": path,
+                    "method": str(request.method),
+                },
+            )
         except Exception as slack_err:
-            print(f'Slack: failed to report exception: {slack_err}')
+            print(f"Slack: failed to report exception: {slack_err}")
         return Response.new(
             '{"error": "Internal server error"}',
-            {'status': 500, 'headers': {**cors_headers, 'Content-Type': 'application/json'}},
+            {"status": 500, "headers": {**cors_headers, "Content-Type": "application/json"}},
         )
 
 
 async def on_scheduled(controller, env, ctx):
-    """Cloudflare Cron Trigger handler – runs every hour.
-
-    Refreshes all PR records in the database using the minimal-request
-    GraphQL batch API so that essential information stays current without
-    consuming unnecessary GitHub API quota.
-    """
-    slack_webhook = getattr(env, 'SLACK_ERROR_WEBHOOK', '')
+    """Cloudflare Cron Trigger handler - runs every hour."""
+    slack_webhook = getattr(env, "SLACK_ERROR_WEBHOOK", "")
     try:
         await handle_scheduled_refresh(env)
     except Exception as exc:
         try:
-            await notify_slack_exception(slack_webhook, exc, context={
-                'handler': 'on_scheduled',
-            })
+            await notify_slack_exception(
+                slack_webhook,
+                exc,
+                context={
+                    "handler": "on_scheduled",
+                },
+            )
         except Exception as slack_err:
-            print(f'Slack: failed to report scheduled exception: {slack_err}')
+            print(f"Slack: failed to report scheduled exception: {slack_err}")
         raise
diff --git a/wrangler.toml b/wrangler.toml
index adfd4d03..6b7f6346 100644
--- a/wrangler.toml
+++ b/wrangler.toml
@@ -10,7 +10,7 @@ database_id = "014201e7-6c0e-4b6a-8c0e-c53d18305dca"
 
 # Automatically run D1 migrations before deployment
 [build]
-command = "bash scripts/migration.sh"
+command = "node scripts/fingerprint.js && bash scripts/migration.sh"
 
 [vars]
 ENVIRONMENT = "production"