@link-assistant/hive-mind 1.2.9 → 1.2.11

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # @link-assistant/hive-mind
 
+## 1.2.11
+
+### Patch Changes
+
+- 8404b75: fix: Support weekly limit date parsing in extractResetTime and parseResetTime
+  - Added Pattern 0 to extractResetTime() to handle date+time formats like "resets Jan 15, 8am"
+  - Updated parseResetTime() to parse date+time strings with month name and day
+  - This ensures weekly limit messages are displayed with the "Usage Limit Reached" format
+
+## 1.2.10
+
+### Patch Changes
+
+- 7ba1476: Auto-cleanup .playwright-mcp/ folder to prevent false auto-restart triggers
+  - Add auto-cleanup of .playwright-mcp/ folder before checking uncommitted changes
+  - Add --playwright-mcp-auto-cleanup option (enabled by default)
+  - Use --no-playwright-mcp-auto-cleanup to disable cleanup for debugging
+  - Add comprehensive case study documentation for issue #1124
+
 ## 1.2.9
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "1.2.9",
+  "version": "1.2.11",
   "description": "AI-powered issue solver and hive mind for collaborative problem solving",
   "main": "src/hive.mjs",
   "type": "module",
@@ -13,8 +13,9 @@
     "hive-telegram-bot": "./src/telegram-bot.mjs"
   },
   "scripts": {
-    "test": "node tests/solve-queue.test.mjs",
+    "test": "node tests/solve-queue.test.mjs && node tests/test-usage-limit.mjs",
     "test:queue": "node tests/solve-queue.test.mjs",
+    "test:usage-limit": "node tests/test-usage-limit.mjs",
     "lint": "eslint 'src/**/*.{js,mjs,cjs}'",
     "lint:fix": "eslint 'src/**/*.{js,mjs,cjs}' --fix",
     "format": "prettier --write \"**/*.{js,mjs,json,md}\"",
@@ -65,6 +66,7 @@
     "@secretlint/secretlint-rule-preset-recommend": "^11.2.5",
     "@sentry/node": "^10.15.0",
     "@sentry/profiling-node": "^10.15.0",
+    "dayjs": "^1.11.19",
     "secretlint": "^11.2.5"
   },
   "lint-staged": {

package/src/claude.lib.mjs

@@ -896,6 +896,7 @@ export const executeClaudeCommand = async params => {
     let sessionId = null;
     let limitReached = false;
     let limitResetTime = null;
+    let limitTimezone = null;
     let messageCount = 0;
     let toolUseCount = 0;
     let lastMessage = '';
@@ -1162,6 +1163,7 @@ export const executeClaudeCommand = async params => {
             sessionId,
             limitReached: false,
             limitResetTime: null,
+            limitTimezone: null,
             messageCount,
             toolUseCount,
           };
@@ -1208,6 +1210,7 @@ export const executeClaudeCommand = async params => {
             sessionId,
             limitReached: false,
             limitResetTime: null,
+            limitTimezone: null,
             messageCount,
             toolUseCount,
             is503Error: true,
@@ -1220,6 +1223,7 @@ export const executeClaudeCommand = async params => {
         if (limitInfo.isUsageLimit) {
           limitReached = true;
           limitResetTime = limitInfo.resetTime;
+          limitTimezone = limitInfo.timezone;
 
           // Format and display user-friendly message
           const messageLines = formatUsageLimitMessage({
@@ -1284,6 +1288,7 @@ export const executeClaudeCommand = async params => {
           sessionId,
           limitReached,
           limitResetTime,
+          limitTimezone,
           messageCount,
           toolUseCount,
           errorDuringExecution,
@@ -1353,6 +1358,7 @@ export const executeClaudeCommand = async params => {
         sessionId,
         limitReached,
         limitResetTime,
+        limitTimezone,
         messageCount,
         toolUseCount,
         anthropicTotalCostUSD, // Pass Anthropic's official total cost
@@ -1401,6 +1407,7 @@ export const executeClaudeCommand = async params => {
         sessionId,
         limitReached,
         limitResetTime: null,
+        limitTimezone: null,
         messageCount,
         toolUseCount,
       };

package/src/limits.lib.mjs

@@ -9,6 +9,11 @@ import { readFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { promisify } from 'node:util';
+import dayjs from 'dayjs';
+import utc from 'dayjs/plugin/utc.js';
+
+// Initialize dayjs plugins
+dayjs.extend(utc);
 
 // Import cache TTL configuration
 import { cacheTtl } from './config.lib.mjs';
@@ -51,7 +56,7 @@ async function readCredentials(credentialsPath = DEFAULT_CREDENTIALS_PATH, verbo
 }
 
 /**
- * Format an ISO date string to a human-readable reset time
+ * Format an ISO date string to a human-readable reset time using dayjs
  *
  * @param {string} isoDate - ISO date string (e.g., "2025-12-03T17:59:59.626485+00:00")
  * @param {boolean} includeTimezone - Whether to include timezone suffix (default: true)
@@ -61,18 +66,11 @@ function formatResetTime(isoDate, includeTimezone = true) {
   if (!isoDate) return null;
 
   try {
-    const date = new Date(isoDate);
-    const months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
-    const month = months[date.getUTCMonth()];
-    const day = date.getUTCDate();
-    const hours = date.getUTCHours();
-    const minutes = date.getUTCMinutes();
-
-    // Convert 24h to 12h format
-    const hour12 = hours === 0 ? 12 : hours > 12 ? hours - 12 : hours;
-    const ampm = hours >= 12 ? 'pm' : 'am';
-
-    const timeStr = `${month} ${day}, ${hour12}:${minutes.toString().padStart(2, '0')}${ampm}`;
+    const date = dayjs(isoDate).utc();
+    if (!date.isValid()) return isoDate;
+
+    // dayjs format: MMM=Jan, D=day, h=12-hour, mm=minutes, a=am/pm
+    const timeStr = date.format('MMM D, h:mma');
     return includeTimezone ? `${timeStr} UTC` : timeStr;
   } catch {
     return isoDate;
@@ -80,7 +78,7 @@ function formatResetTime(isoDate, includeTimezone = true) {
 }
 
 /**
- * Format relative time from now to a future date
+ * Format relative time from now to a future date using dayjs
  *
  * @param {string} isoDate - ISO date string
  * @returns {string|null} Relative time string (e.g., "1h 34m" or "6d 20h 13m") or null if date is in the past
@@ -89,49 +87,40 @@ function formatRelativeTime(isoDate) {
   if (!isoDate) return null;
 
   try {
-    const now = new Date();
-    const target = new Date(isoDate);
-    const diffMs = target - now;
+    const now = dayjs();
+    const target = dayjs(isoDate);
 
-    // Check for invalid date (NaN)
-    if (isNaN(diffMs)) return null;
+    if (!target.isValid()) return null;
 
+    const diffMs = target.diff(now);
     if (diffMs < 0) return null; // Past date
 
-    const totalHours = Math.floor(diffMs / (1000 * 60 * 60));
-    const minutes = Math.floor((diffMs % (1000 * 60 * 60)) / (1000 * 60));
+    const totalMinutes = Math.floor(diffMs / (1000 * 60));
+    const totalHours = Math.floor(totalMinutes / 60);
+    const totalDays = Math.floor(totalHours / 24);
+
+    const days = totalDays;
+    const hours = totalHours % 24;
+    const minutes = totalMinutes % 60;
 
     // If hours >= 24, show days
-    if (totalHours >= 24) {
-      const days = Math.floor(totalHours / 24);
-      const hours = totalHours % 24;
+    if (days > 0) {
       return `${days}d ${hours}h ${minutes}m`;
     }
 
-    return `${totalHours}h ${minutes}m`;
+    return `${hours}h ${minutes}m`;
   } catch {
     return null;
   }
 }
 
 /**
- * Format current time in UTC
+ * Format current time in UTC using dayjs
  *
  * @returns {string} Current time in UTC (e.g., "Dec 3, 6:45pm UTC")
  */
 function formatCurrentTime() {
-  const now = new Date();
-  const months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
-  const month = months[now.getUTCMonth()];
-  const day = now.getUTCDate();
-  const hours = now.getUTCHours();
-  const minutes = now.getUTCMinutes();
-
-  // Convert 24h to 12h format
-  const hour12 = hours === 0 ? 12 : hours > 12 ? hours - 12 : hours;
-  const ampm = hours >= 12 ? 'pm' : 'am';
-
-  return `${month} ${day}, ${hour12}:${minutes.toString().padStart(2, '0')}${ampm} UTC`;
+  return dayjs().utc().format('MMM D, h:mma [UTC]');
 }
 
 /**

package/src/solve.config.lib.mjs

@@ -311,6 +311,11 @@ export const createYargsConfig = yargsInstance => {
         description: 'Include prompt to check related/sibling pull requests when studying related work. Enabled by default, use --no-prompt-check-sibling-pull-requests to disable.',
         default: true,
       })
+      .option('playwright-mcp-auto-cleanup', {
+        type: 'boolean',
+        description: 'Automatically remove .playwright-mcp/ folder before checking for uncommitted changes. This prevents browser automation artifacts from triggering auto-restart. Use --no-playwright-mcp-auto-cleanup to keep the folder for debugging.',
+        default: true,
+      })
       .parserConfiguration({
         'boolean-negation': true,
       })

package/src/solve.mjs

@@ -898,10 +898,13 @@ try {
   limitReached = toolResult.limitReached;
   cleanupContext.limitReached = limitReached;
 
-  // Capture limit reset time globally for downstream handlers (auto-continue, cleanup decisions)
+  // Capture limit reset time and timezone globally for downstream handlers (auto-continue, cleanup decisions)
   if (toolResult && toolResult.limitResetTime) {
     global.limitResetTime = toolResult.limitResetTime;
   }
+  if (toolResult && toolResult.limitTimezone) {
+    global.limitTimezone = toolResult.limitTimezone;
+  }
 
   // Handle limit reached scenario
   if (limitReached) {
@@ -974,8 +977,9 @@ try {
           const tool = argv.tool || 'claude';
           const resumeCmd = tool === 'claude' ? buildClaudeResumeCommand({ tempDir, sessionId, model: argv.model }) : null;
           const resumeSection = resumeCmd ? `To resume after the limit resets, use:\n\`\`\`bash\n${resumeCmd}\n\`\`\`` : `Session ID: \`${sessionId}\``;
-          // Format the reset time with relative time if available
-          const formattedResetTime = resetTime ? formatResetTimeWithRelative(resetTime) : null;
+          // Format the reset time with relative time and UTC conversion if available
+          const timezone = global.limitTimezone || null;
+          const formattedResetTime = resetTime ? formatResetTimeWithRelative(resetTime, timezone) : null;
           const failureComment = formattedResetTime ? `❌ **Usage Limit Reached**\n\nThe AI tool has reached its usage limit. The limit will reset at: **${formattedResetTime}**\n\n${resumeSection}` : `❌ **Usage Limit Reached**\n\nThe AI tool has reached its usage limit. Please wait for the limit to reset.\n\n${resumeSection}`;
 
           const commentResult = await $`gh pr comment ${prNumber} --repo ${owner}/${repo} --body ${failureComment}`;
@@ -1116,6 +1120,27 @@ try {
     await safeExit(1, `${argv.tool.toUpperCase()} execution failed`);
   }
 
+  // Clean up .playwright-mcp/ folder before checking for uncommitted changes
+  // This prevents browser automation artifacts from triggering auto-restart (Issue #1124)
+  if (argv.playwrightMcpAutoCleanup !== false) {
+    const playwrightMcpDir = path.join(tempDir, '.playwright-mcp');
+    try {
+      const playwrightMcpExists = await fs
+        .stat(playwrightMcpDir)
+        .then(() => true)
+        .catch(() => false);
+      if (playwrightMcpExists) {
+        await fs.rm(playwrightMcpDir, { recursive: true, force: true });
+        await log('🧹 Cleaned up .playwright-mcp/ folder (browser automation artifacts)', { verbose: true });
+      }
+    } catch (cleanupError) {
+      // Non-critical error, just log and continue
+      await log(`⚠️  Could not clean up .playwright-mcp/ folder: ${cleanupError.message}`, { verbose: true });
+    }
+  } else {
+    await log('ℹ️  Playwright MCP auto-cleanup disabled via --no-playwright-mcp-auto-cleanup', { verbose: true });
+  }
+
   // Check for uncommitted changes
   // When limit is reached, force auto-commit of any uncommitted changes to preserve work
   const shouldAutoCommit = argv['auto-commit-uncommitted-changes'] || limitReached;

package/src/solve.watch.lib.mjs

@@ -15,6 +15,10 @@ const use = globalThis.use;
 // Use command-stream for consistent $ behavior across runtimes
 const { $ } = await use('command-stream');
 
+// Import path and fs for cleanup operations
+const path = (await use('path')).default;
+const fs = (await use('fs')).promises;
+
 // Import shared library functions
 const lib = await import('./lib.mjs');
 const { log, cleanErrorMessage, formatAligned } = lib;
@@ -50,10 +54,36 @@ const checkPRMerged = async (owner, repo, prNumber) => {
   return false;
 };
 
+/**
+ * Clean up .playwright-mcp/ folder to prevent browser automation artifacts
+ * from triggering auto-restart (Issue #1124)
+ */
+const cleanupPlaywrightMcpFolder = async (tempDir, argv) => {
+  if (argv.playwrightMcpAutoCleanup !== false) {
+    const playwrightMcpDir = path.join(tempDir, '.playwright-mcp');
+    try {
+      const playwrightMcpExists = await fs
+        .stat(playwrightMcpDir)
+        .then(() => true)
+        .catch(() => false);
+      if (playwrightMcpExists) {
+        await fs.rm(playwrightMcpDir, { recursive: true, force: true });
+        await log('🧹 Cleaned up .playwright-mcp/ folder (browser automation artifacts)', { verbose: true });
+      }
+    } catch (cleanupError) {
+      // Non-critical error, just log and continue
+      await log(`⚠️  Could not clean up .playwright-mcp/ folder: ${cleanupError.message}`, { verbose: true });
+    }
+  }
+};
+
 /**
  * Check if there are uncommitted changes in the repository
  */
-const checkForUncommittedChanges = async (tempDir, $) => {
+const checkForUncommittedChanges = async (tempDir, $, argv = {}) => {
+  // First, clean up .playwright-mcp/ folder to prevent false positives (Issue #1124)
+  await cleanupPlaywrightMcpFolder(tempDir, argv);
+
   try {
     const gitStatusResult = await $({ cwd: tempDir })`git status --porcelain 2>&1`;
     if (gitStatusResult.code === 0) {
@@ -130,7 +160,7 @@ export const watchForFeedback = async params => {
 
     // In temporary watch mode, check if all changes have been committed
     if (isTemporaryWatch && !firstIterationInTemporaryMode) {
-      const hasUncommitted = await checkForUncommittedChanges(tempDir, $);
+      const hasUncommitted = await checkForUncommittedChanges(tempDir, $, argv);
       if (!hasUncommitted) {
         await log('');
         await log(formatAligned('✅', 'CHANGES COMMITTED!', 'Exiting auto-restart mode'));
@@ -185,7 +215,7 @@ export const watchForFeedback = async params => {
       // In temporary watch mode, also check for uncommitted changes as a restart trigger
       let hasUncommittedInTempMode = false;
       if (isTemporaryWatch && !firstIterationInTemporaryMode) {
-        hasUncommittedInTempMode = await checkForUncommittedChanges(tempDir, $);
+        hasUncommittedInTempMode = await checkForUncommittedChanges(tempDir, $, argv);
       }
 
       const shouldRestart = hasFeedback || firstIterationInTemporaryMode || hasUncommittedInTempMode;

package/src/usage-limit.lib.mjs

@@ -4,9 +4,21 @@
  * This module provides utilities for detecting and handling usage limit errors
  * from AI tools (Claude, Codex, OpenCode).
  *
- * Related issue: https://github.com/link-assistant/hive-mind/issues/719
+ * Related issues:
+ *   - https://github.com/link-assistant/hive-mind/issues/719 (original)
+ *   - https://github.com/link-assistant/hive-mind/issues/1122 (weekly limit date parsing with timezone)
  */
 
+import dayjs from 'dayjs';
+import utc from 'dayjs/plugin/utc.js';
+import timezone from 'dayjs/plugin/timezone.js';
+import customParseFormat from 'dayjs/plugin/customParseFormat.js';
+
+// Initialize dayjs plugins
+dayjs.extend(utc);
+dayjs.extend(timezone);
+dayjs.extend(customParseFormat);
+
 /**
  * Detect if an error message indicates a usage limit has been reached
  *
@@ -46,11 +58,48 @@ export function isUsageLimitError(message) {
   return patterns.some(pattern => lowerMessage.includes(pattern));
 }
 
+/**
+ * Extract timezone from usage limit error message
+ *
+ * Extracts IANA timezone identifiers like "Europe/Berlin", "UTC", "America/New_York"
+ * from messages like "resets Jan 15, 8am (Europe/Berlin)"
+ *
+ * @param {string} message - Error message to analyze
+ * @returns {string|null} - Timezone string or null if not found
+ */
+export function extractTimezone(message) {
+  if (!message || typeof message !== 'string') {
+    return null;
+  }
+
+  // Pattern: (Timezone) - matches IANA timezone format or "UTC"
+  // IANA format: Continent/City or Continent/Region/City
+  const timezoneMatch = message.match(/\(([A-Za-z_]+(?:\/[A-Za-z_]+){0,2})\)/);
+  if (timezoneMatch) {
+    const tz = timezoneMatch[1];
+    // Validate it's a recognizable timezone by trying to use it with dayjs
+    try {
+      const testDate = dayjs().tz(tz);
+      if (testDate.isValid()) {
+        return tz;
+      }
+    } catch {
+      // Invalid timezone, return null
+    }
+  }
+
+  return null;
+}
+
 /**
  * Extract reset time from usage limit error message
  *
+ * Supports both time-only formats (5-hour limits) and date+time formats (weekly limits):
+ * - "resets 10pm" → "10:00 PM"
+ * - "resets Jan 15, 8am" → "Jan 15, 8:00 AM"
+ *
  * @param {string} message - Error message to analyze
- * @returns {string|null} - Reset time string (e.g., "12:16 PM") or null if not found
+ * @returns {string|null} - Reset time string (e.g., "12:16 PM" or "Jan 15, 8:00 AM") or null if not found
  */
 export function extractResetTime(message) {
   if (!message || typeof message !== 'string') {
@@ -60,6 +109,21 @@ export function extractResetTime(message) {
   // Normalize whitespace for easier matching
   const normalized = message.replace(/\s+/g, ' ');
 
+  // Pattern 0: Weekly limit with date - "resets Jan 15, 8am" or "resets January 15, 8:00am"
+  // This pattern must come first to avoid partial matches by time-only patterns
+  const monthPattern = '(?:Jan(?:uary)?|Feb(?:ruary)?|Mar(?:ch)?|Apr(?:il)?|May|Jun(?:e)?|Jul(?:y)?|Aug(?:ust)?|Sep(?:t(?:ember)?)?|Oct(?:ober)?|Nov(?:ember)?|Dec(?:ember)?)';
+  const resetsWithDateRegex = new RegExp(`resets\\s+(${monthPattern})\\s+(\\d{1,2}),?\\s+([0-9]{1,2})(?::([0-9]{2}))?\\s*([ap]m)`, 'i');
+  const resetsWithDate = normalized.match(resetsWithDateRegex);
+  if (resetsWithDate) {
+    const month = resetsWithDate[1];
+    const day = resetsWithDate[2];
+    const hour = resetsWithDate[3];
+    const minute = resetsWithDate[4] || '00';
+    const ampm = resetsWithDate[5].toUpperCase();
+    // Return formatted date+time string for weekly limits
+    return `${month} ${day}, ${hour}:${minute} ${ampm}`;
+  }
+
   // Pattern 1: "try again at 12:16 PM"
   const tryAgainMatch = normalized.match(/try again at ([0-9]{1,2}:[0-9]{2}\s*[AP]M)/i);
   if (tryAgainMatch) {
@@ -130,78 +194,142 @@ export function extractResetTime(message) {
  * Detect usage limit error and extract all relevant information
  *
  * @param {string} message - Error message to analyze
- * @returns {Object} - { isUsageLimit: boolean, resetTime: string|null }
+ * @returns {Object} - { isUsageLimit: boolean, resetTime: string|null, timezone: string|null }
  */
 export function detectUsageLimit(message) {
   const isUsageLimit = isUsageLimitError(message);
   const resetTime = isUsageLimit ? extractResetTime(message) : null;
+  const timezone = isUsageLimit ? extractTimezone(message) : null;
 
   return {
     isUsageLimit,
     resetTime,
+    timezone,
   };
 }
 
 /**
- * Parse time string (e.g., "11:00 PM") and convert to Date object for today
+ * Parse time string and convert to dayjs object using dayjs custom parse format
+ *
+ * Supports both formats:
+ * - Time only: "11:00 PM" → today or tomorrow at that time
+ * - Date+time: "Jan 15, 8:00 AM" → specific date at that time
+ *
+ * Uses dayjs customParseFormat plugin for cleaner parsing.
  *
- * @param {string} timeStr - Time string in format "HH:MM AM/PM"
- * @returns {Date|null} - Date object or null if parsing fails
+ * @param {string} timeStr - Time string in format "HH:MM AM/PM" or "Mon DD, HH:MM AM/PM"
+ * @param {string|null} tz - Optional IANA timezone (e.g., "Europe/Berlin")
+ * @returns {dayjs.Dayjs|null} - dayjs object or null if parsing fails
  */
-export function parseResetTime(timeStr) {
+export function parseResetTime(timeStr, tz = null) {
   if (!timeStr || typeof timeStr !== 'string') {
     return null;
   }
 
-  // Match pattern like "11:00 PM" or "11:00PM"
-  const match = timeStr.match(/(\d{1,2}):(\d{2})\s*(AM|PM)/i);
-  if (!match) {
-    return null;
-  }
+  const now = dayjs();
+
+  // Normalize "Sept" to "Sep" for dayjs compatibility
+  const normalized = timeStr.replace(/\bSept\b/gi, 'Sep');
 
-  let hour = parseInt(match[1], 10);
-  const minute = parseInt(match[2], 10);
-  const ampm = match[3].toUpperCase();
+  // Try date+time formats using dayjs custom parse
+  // dayjs uses: MMM=Jan, MMMM=January, D=day, h=12-hour, mm=minutes, A=AM/PM
+  const dateTimeFormats = ['MMM D, h:mm A', 'MMMM D, h:mm A'];
+
+  for (const format of dateTimeFormats) {
+    let parsed;
+    if (tz) {
+      try {
+        // Parse in the specified timezone
+        parsed = dayjs.tz(normalized, format, tz);
+      } catch {
+        parsed = dayjs(normalized, format);
+      }
+    } else {
+      parsed = dayjs(normalized, format);
+    }
 
-  // Convert to 24-hour format
-  if (ampm === 'PM' && hour !== 12) {
-    hour += 12;
-  } else if (ampm === 'AM' && hour === 12) {
-    hour = 0;
+    if (parsed.isValid()) {
+      // dayjs parses without year, so it defaults to current year
+      // If the date is in the past, assume next year
+      if (parsed.isBefore(now)) {
+        parsed = parsed.add(1, 'year');
+      }
+      return parsed;
+    }
   }
 
-  // Create date for today with the parsed time
-  const now = new Date();
-  const resetDate = new Date(now.getFullYear(), now.getMonth(), now.getDate(), hour, minute, 0, 0);
+  // Try time-only format: "8:00 PM" or "8:00PM"
+  const timeOnlyFormats = ['h:mm A', 'h:mmA'];
+
+  for (const format of timeOnlyFormats) {
+    let parsed;
+    if (tz) {
+      try {
+        parsed = dayjs.tz(normalized, format, tz);
+      } catch {
+        parsed = dayjs(normalized, format);
+      }
+    } else {
+      parsed = dayjs(normalized, format);
+    }
+
+    if (parsed.isValid()) {
+      // For time-only, set to today's date
+      parsed = parsed.year(now.year()).month(now.month()).date(now.date());
+
+      // Re-apply timezone after setting date components
+      if (tz) {
+        try {
+          const dateStr = parsed.format('YYYY-MM-DD HH:mm');
+          parsed = dayjs.tz(dateStr, tz);
+        } catch {
+          // Keep the parsed value
+        }
+      }
 
-  // If the time is in the past today, assume it's tomorrow
-  if (resetDate <= now) {
-    resetDate.setDate(resetDate.getDate() + 1);
+      // If the time is in the past today, assume tomorrow
+      if (parsed.isBefore(now)) {
+        parsed = parsed.add(1, 'day');
+      }
+      return parsed;
+    }
   }
 
-  return resetDate;
+  return null;
 }
 
 /**
  * Format relative time (e.g., "in 1h 23m")
  *
- * @param {Date} resetDate - Date object for reset time
+ * Uses dayjs for accurate time difference calculations.
+ * Accepts both Date objects and dayjs objects.
+ *
+ * @param {Date|dayjs.Dayjs} resetDate - Date or dayjs object for reset time
  * @returns {string} - Formatted relative time string
  */
 export function formatRelativeTime(resetDate) {
-  if (!resetDate || !(resetDate instanceof Date)) {
+  // Accept both Date objects and dayjs objects
+  let resetDayjs;
+  if (resetDate instanceof Date) {
+    resetDayjs = dayjs(resetDate);
+  } else if (dayjs.isDayjs(resetDate)) {
+    resetDayjs = resetDate;
+  } else {
     return '';
   }
 
-  const now = new Date();
-  const diffMs = resetDate - now;
+  if (!resetDayjs.isValid()) {
+    return '';
+  }
+
+  const now = dayjs();
+  const diffMs = resetDayjs.diff(now);
 
   if (diffMs <= 0) {
     return 'now';
   }
 
-  const totalSeconds = Math.floor(diffMs / 1000);
-  const totalMinutes = Math.floor(totalSeconds / 60);
+  const totalMinutes = Math.floor(diffMs / (1000 * 60));
   const totalHours = Math.floor(totalMinutes / 60);
   const totalDays = Math.floor(totalHours / 24);
 
@@ -219,17 +347,20 @@ export function formatRelativeTime(resetDate) {
 
 /**
  * Format reset time with relative time and UTC time
- * Example: "in 1h 23m (11:00 PM UTC)"
+ * Example: "in 1h 23m (Jan 15, 7:00 AM UTC)"
+ *
+ * Uses dayjs for proper timezone conversion to UTC.
  *
- * @param {string} resetTime - Time string in format "HH:MM AM/PM"
- * @returns {string} - Formatted string with relative and absolute time
+ * @param {string} resetTime - Time string in format "HH:MM AM/PM" or "Mon DD, HH:MM AM/PM"
+ * @param {string|null} timezone - Optional IANA timezone (e.g., "Europe/Berlin")
+ * @returns {string} - Formatted string with relative and absolute UTC time
  */
-export function formatResetTimeWithRelative(resetTime) {
+export function formatResetTimeWithRelative(resetTime, timezone = null) {
   if (!resetTime) {
     return resetTime;
   }
 
-  const resetDate = parseResetTime(resetTime);
+  const resetDate = parseResetTime(resetTime, timezone);
   if (!resetDate) {
     // If we can't parse it, return the original time
     return resetTime;
@@ -237,12 +368,9 @@ export function formatResetTimeWithRelative(resetTime) {
 
   const relativeTime = formatRelativeTime(resetDate);
 
-  // Format the UTC time
-  const utcHours = resetDate.getUTCHours();
-  const utcMinutes = resetDate.getUTCMinutes();
-  const utcAmPm = utcHours >= 12 ? 'PM' : 'AM';
-  const utcHour12 = utcHours % 12 || 12;
-  const utcTimeStr = `${utcHour12}:${String(utcMinutes).padStart(2, '0')} ${utcAmPm} UTC`;
+  // Convert to UTC and format
+  const utcDate = resetDate.utc();
+  const utcTimeStr = utcDate.format('MMM D, h:mm A [UTC]');
 
   return `${relativeTime} (${utcTimeStr})`;
 }