@link-assistant/hive-mind 1.74.9 → 1.74.10

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @link-assistant/hive-mind
 
+## 1.74.10
+
+### Patch Changes
+
+- 88adc75: Fix the auto-resume wait calculation for weekly `--tool codex` usage limits (Issue #1869, phase 2). After the display parser was fixed to keep the full reset date, the separate auto-resume parser in `solve.validation.lib.mjs` still crashed with `Invalid time format: Jun 11, 2026, 12:27 AM` and, even when it parsed, discarded the date and scheduled for today/tomorrow — so auto-resume woke up far too early. `calculateWaitTime` now delegates to the robust date-aware `parseResetTime` from `usage-limit.lib.mjs` (honoring explicit year, weekly date, and timezone) and returns the real time-until-reset, and all three call sites now forward the timezone. This consolidates onto a single reset-time parser.
+
 ## 1.74.9
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "1.74.9",
+  "version": "1.74.10",
   "description": "AI-powered issue solver and hive mind for collaborative problem solving",
   "main": "src/hive.mjs",
   "type": "module",

package/src/solve.auto-continue.lib.mjs

@@ -92,7 +92,7 @@ export const autoContinueWhenLimitResets = async (issueUrl, sessionId, argv, sho
     const nextAutoResumeIteration = currentAutoResumeIteration + 1;
     const resetTime = global.limitResetTime;
     const timezone = global.limitTimezone || null;
-    const baseWaitMs = calculateWaitTime(resetTime);
+    const baseWaitMs = calculateWaitTime(resetTime, timezone);
 
     // Add buffer time after limit reset to account for server time differences
     // Default: 10 minutes (configurable via HIVE_MIND_LIMIT_RESET_BUFFER_MS)

package/src/solve.auto-merge.lib.mjs

@@ -735,7 +735,7 @@ No further AI sessions will be started automatically for this run. Please review
             limitResumeCount++;
             const resumeSessionId = toolResult.sessionId;
             const resetTime = toolResult.limitResetTime;
-            const baseWaitMs = resetTime ? calculateWaitTime(resetTime) : 0;
+            const baseWaitMs = resetTime ? calculateWaitTime(resetTime, toolResult.limitTimezone || null) : 0;
             const bufferMs = limitReset.bufferMs;
             const jitterMs = Math.floor(Math.random() * limitReset.jitterMs);
             const waitMs = baseWaitMs + bufferMs + jitterMs;

package/src/solve.mjs

@@ -1029,7 +1029,7 @@ try {
             // Calculate wait time in d:h:m:s format
             const validation = await import('./solve.validation.lib.mjs');
             const { calculateWaitTime } = validation;
-            const waitMs = calculateWaitTime(global.limitResetTime);
+            const waitMs = calculateWaitTime(global.limitResetTime, global.limitTimezone || null);
 
             const formatWaitTime = ms => {
               const seconds = Math.floor(ms / 1000);

package/src/solve.validation.lib.mjs

@@ -43,6 +43,13 @@ const claudeLib = await import('./claude.lib.mjs');
 const sentryLib = await import('./sentry.lib.mjs');
 const { reportError } = sentryLib;
 
+// Import the robust usage-limit reset-time parser.
+// This returns a full dayjs date (honoring an explicit year and timezone) so the
+// auto-resume wait calculation can respect weekly limits that are days out, rather
+// than collapsing every reset to "today/tomorrow at HH:MM" (Issue #1869).
+const usageLimitLib = await import('./usage-limit.lib.mjs');
+const { parseResetTime: parseResetTimeToDate } = usageLimitLib;
+
 const { validateClaudeConnection } = claudeLib;
 
 // Wrapper function for disk space check using imported module
@@ -394,13 +401,23 @@ export const parseUrlComponents = issueUrl => {
   };
 };
 
-// Helper function to parse time string and calculate wait time
+// Helper function to parse a reset time string into hour/minute components.
+//
+// Accepts:
+//   - Time-only forms: "5:30am", "11:45pm", "12:16 PM", "07:05 Am", "5am", "5 AM"
+//   - Date+time forms: "Apr 17, 4:00 AM"  (date portion ignored)
+//   - Date+year+time forms: "Jun 11, 2026, 12:27 AM"  (date+year ignored — Issue #1869)
+//
+// NOTE: This helper only extracts the time-of-day. For computing the actual wait
+// duration use calculateWaitTime(), which preserves the full date so weekly limits
+// (which can be days away) are honored instead of being collapsed to today/tomorrow.
 export const parseResetTime = timeStr => {
-  // Normalize and parse time formats like:
-  // "5:30am", "11:45pm", "12:16 PM", "07:05 Am", "5am", "5 AM"
-  // Also accepts date+time forms like "Apr 17, 4:00 AM" and ignores the date portion.
   const normalized = (timeStr || '').toString().trim();
-  const timePortion = normalized.replace(/^(?:Jan(?:uary)?|Feb(?:ruary)?|Mar(?:ch)?|Apr(?:il)?|May|Jun(?:e)?|Jul(?:y)?|Aug(?:ust)?|Sep(?:t(?:ember)?)?|Oct(?:ober)?|Nov(?:ember)?|Dec(?:ember)?)\s+\d{1,2},\s+/i, '');
+  // Strip an optional leading "Month Day," and an optional "Year," so the
+  // remaining string is just the time-of-day. The year group (Issue #1869) makes
+  // Codex weekly-limit strings like "Jun 11, 2026, 12:27 AM" parse instead of
+  // throwing "Invalid time format".
+  const timePortion = normalized.replace(/^(?:Jan(?:uary)?|Feb(?:ruary)?|Mar(?:ch)?|Apr(?:il)?|May|Jun(?:e)?|Jul(?:y)?|Aug(?:ust)?|Sep(?:t(?:ember)?)?|Oct(?:ober)?|Nov(?:ember)?|Dec(?:ember)?)\s+\d{1,2}(?:st|nd|rd|th)?,\s+(?:\d{4},\s+)?/i, '');
 
   // Accept both HH:MM am/pm and HH am/pm
   let match = timePortion.match(/^(\d{1,2})(?::(\d{2}))?\s*([ap]m)$/i);
@@ -423,8 +440,32 @@ export const parseResetTime = timeStr => {
   return { hour, minute };
 };
 
-// Calculate milliseconds until the next occurrence of the specified time
-export const calculateWaitTime = resetTime => {
+// Calculate milliseconds until the limit reset.
+//
+// Issue #1869: This MUST respect the full reset date (including an explicit year),
+// not just the time-of-day. A weekly Codex limit reports "Jun 11th, 2026 12:27 AM"
+// which can be days in the future; the previous implementation only looked at the
+// hour/minute and scheduled for today/tomorrow, so auto-resume woke up far too early
+// and burned an auto-resume iteration without the limit actually having reset.
+//
+// We delegate to the robust usage-limit parser, which returns a full dayjs date that
+// already handles: explicit year, weekly date+time, time-only (rolls forward to the
+// next occurrence), and an optional IANA timezone. We then return the real diff.
+//
+// @param {string} resetTime - Reset time string (time-only, date+time, or date+year+time)
+// @param {string|null} timezone - Optional IANA timezone (e.g. "Europe/Berlin")
+// @returns {number} - Milliseconds until reset (never negative)
+export const calculateWaitTime = (resetTime, timezone = null) => {
+  const resetDate = parseResetTimeToDate(resetTime, timezone);
+
+  if (resetDate && resetDate.isValid()) {
+    const diffMs = resetDate.valueOf() - Date.now();
+    return diffMs > 0 ? diffMs : 0;
+  }
+
+  // Fallback: the robust parser could not interpret the string. Fall back to the
+  // legacy time-of-day behavior (today/tomorrow) so we still wait a sensible amount
+  // rather than throwing — parseResetTime throws for genuinely unparseable input.
   const { hour, minute } = parseResetTime(resetTime);
 
   const now = new Date();