@link-assistant/hive-mind 1.2.10 → 1.3.0

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # @link-assistant/hive-mind
 
+## 1.3.0
+
+### Minor Changes
+
+- a403c0e: Add --auto-gitkeep-file option to automatically fallback to .gitkeep when CLAUDE.md is in .gitignore
+
+  This feature pre-checks if CLAUDE.md would be ignored by .gitignore BEFORE creating the file, preventing the "paths are ignored by one of your .gitignore files" error. When detected, automatically switches to .gitkeep mode. Enabled by default (--auto-gitkeep-file=true).
+
+## 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
@@ -943,7 +960,7 @@
 
   This feature allows users to choose which file type to use for PR creation:
   - `--claude-file` (default: true): Use CLAUDE.md file for task details
-  - `--gitkeep-file` (default: false, experimental): Use .gitkeep file instead
+  - `--gitkeep-file` (default: false): Use .gitkeep file instead
 
   The flags are mutually exclusive:
   - Using `--gitkeep-file` automatically disables `--claude-file`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "1.2.10",
+  "version": "1.3.0",
   "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.auto-pr.lib.mjs

@@ -31,12 +31,20 @@ export async function handleAutoPrCreation({ argv, tempDir, branchName, issueNum
 
   try {
     // Determine which file to create based on CLI flags
-    const useClaudeFile = argv.claudeFile !== false; // Default to true
-    const useGitkeepFile = argv.gitkeepFile === true; // Default to false
+    let useClaudeFile = argv.claudeFile !== false;
+    const useAutoGitkeepFile = argv.autoGitkeepFile !== false;
+
+    // Pre-check: If CLAUDE.md would be ignored by .gitignore, automatically switch to .gitkeep mode
+    if (useClaudeFile && useAutoGitkeepFile) {
+      const checkResult = await $({ cwd: tempDir, silent: true })`git check-ignore CLAUDE.md 2>/dev/null`;
+      if (checkResult.code === 0) {
+        await log(formatAligned('ℹ️', 'Pre-check:', 'CLAUDE.md is in .gitignore, switching to .gitkeep mode\n'));
+        useClaudeFile = false;
+      }
+    }
 
-    // Log which mode we're using
     if (argv.verbose) {
-      await log(`   Using ${useClaudeFile ? 'CLAUDE.md' : '.gitkeep'} mode (--claude-file=${useClaudeFile}, --gitkeep-file=${useGitkeepFile})`, { verbose: true });
+      await log(`   Using ${useClaudeFile ? 'CLAUDE.md' : '.gitkeep'} mode (--claude-file=${argv.claudeFile !== false}, --gitkeep-file=${argv.gitkeepFile === true}, --auto-gitkeep-file=${useAutoGitkeepFile})`, { verbose: true });
     }
 
     let filePath;
@@ -62,14 +70,13 @@ export async function handleAutoPrCreation({ argv, tempDir, branchName, issueNum
         }
       }
     } else {
-      // Create .gitkeep file directly (experimental mode)
-      await log(formatAligned('📝', 'Creating:', '.gitkeep (experimental mode)'));
+      // .gitkeep mode (via explicit --gitkeep-file or auto-gitkeep-file fallback)
+      const modeDesc = argv.gitkeepFile === true ? '.gitkeep (explicit --gitkeep-file)' : '.gitkeep (CLAUDE.md is ignored)';
+      await log(formatAligned('📝', 'Creating:', modeDesc));
 
       filePath = path.join(tempDir, '.gitkeep');
       fileName = '.gitkeep';
-
-      // .gitkeep files are typically small, no need to check for existing content
-      // But we'll check if it exists for proper handling
+      // Check if .gitkeep already exists for proper handling
       try {
         existingContent = await fs.readFile(filePath, 'utf8');
         fileExisted = true;
@@ -125,12 +132,13 @@ Proceed.
         finalContent = taskInfo;
       }
     } else {
-      // .gitkeep: Use minimal metadata format
+      // .gitkeep: Use minimal metadata format (explicit --gitkeep-file or auto-gitkeep-file fallback)
+      const creationReason = argv.gitkeepFile === true ? '# This file was created with --gitkeep-file flag' : '# This file was created because CLAUDE.md is in .gitignore (--auto-gitkeep-file=true)';
       const gitkeepContent = `# Auto-generated file for PR creation
 # Issue: ${issueUrl}
 # Branch: ${branchName}
 # Timestamp: ${timestamp}
-# This file was created with --gitkeep-file flag (experimental)
+${creationReason}
 # It will be removed when the task is complete`;
 
       if (fileExisted && existingContent) {
@@ -289,9 +297,8 @@ Proceed.
     }
 
     await log(formatAligned('📝', 'Creating commit:', `With ${commitFileName} file`));
-
-    // Determine commit message based on which file is being committed
-    const fileDesc = commitFileName === 'CLAUDE.md' ? 'CLAUDE.md with task information for AI processing' : `.gitkeep for PR creation (${useGitkeepFile ? 'created with --gitkeep-file flag (experimental)' : 'CLAUDE.md is in .gitignore'})`;
+    // Commit message distinguishes between explicit --gitkeep-file and auto-gitkeep-file fallback
+    const fileDesc = commitFileName === 'CLAUDE.md' ? 'CLAUDE.md with task information for AI processing' : `.gitkeep for PR creation (${argv.gitkeepFile === true ? 'created with --gitkeep-file flag' : 'CLAUDE.md is in .gitignore'})`;
     const commitMessage = `Initial commit with task details\n\nAdding ${fileDesc}.\nThis file will be removed when the task is complete.\n\nIssue: ${issueUrl}`;
 
     // Use explicit cwd option for better reliability

package/src/solve.config.lib.mjs

@@ -130,9 +130,14 @@ export const createYargsConfig = yargsInstance => {
       })
       .option('gitkeep-file', {
         type: 'boolean',
-        description: 'Create .gitkeep file instead of CLAUDE.md (experimental, mutually exclusive with --claude-file)',
+        description: 'Create .gitkeep file instead of CLAUDE.md (mutually exclusive with --claude-file)',
         default: false,
       })
+      .option('auto-gitkeep-file', {
+        type: 'boolean',
+        description: 'Automatically use .gitkeep if CLAUDE.md is in .gitignore (pre-checks before creating file)',
+        default: true,
+      })
       .option('attach-logs', {
         type: 'boolean',
         description: 'Upload the solution draft log file to the Pull Request on completion (⚠️ WARNING: May expose sensitive data)',

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}`;

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})`;
 }