@link-assistant/hive-mind 1.74.8 → 1.74.10

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @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
+
+- c4070e1: Fix incorrect usage-limit reset time for `--tool codex`. Codex reports weekly limits as a full calendar date (e.g. "try again at Jun 11th, 2026 12:27 AM"), but the reset-time parser dropped the month/day/year and kept only the time, making a multi-day weekly reset look like a same-day 5-hour reset. This both mis-informed users and made auto-resume fire far too early. `extractResetTime` now parses ordinal days and explicit years (keyword-independent), `parseResetTime` honors an explicit year, and Codex now traces the raw limit message and parsed reset under verbose mode.
+  </content>
+
 ## 1.74.8
 
 ### Patch Changes

package/package.json

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

package/src/codex.lib.mjs

@@ -1009,9 +1009,15 @@ export const executeCodexCommand = async params => {
         await log(`⚠️ Ignoring non-fatal Codex item error event(s): ${ignoredMessages}`, { level: 'warning', verbose: true });
       }
       if (codexErrorSummary.hasError) {
-        const limitInfo = detectUsageLimit(codexErrorSummary.message || lastMessage);
-        const retryableError = classifyRetryableError(codexErrorSummary.message || lastMessage);
+        const limitSource = codexErrorSummary.message || lastMessage;
+        const limitInfo = detectUsageLimit(limitSource);
+        const retryableError = classifyRetryableError(limitSource);
         if (limitInfo.isUsageLimit) {
+          // Issue #1869: Trace the raw limit text and what we parsed out of it so
+          // a mis-parsed reset (e.g. a weekly reset read as a 5-hour reset) can be
+          // diagnosed from the log without guessing at the original message.
+          await log(`🔍 Codex usage limit detected. Raw message: ${JSON.stringify(limitSource)}`, { verbose: true });
+          await log(`🔍 Parsed reset time: ${JSON.stringify(limitInfo.resetTime)}, timezone: ${JSON.stringify(limitInfo.timezone)}`, { verbose: true });
           limitReached = true;
           limitResetTime = limitInfo.resetTime;
 
@@ -1098,6 +1104,9 @@ export const executeCodexCommand = async params => {
         // Check for usage limit errors first (more specific)
         const limitInfo = detectUsageLimit(lastMessage);
         if (limitInfo.isUsageLimit) {
+          // Issue #1869: Trace raw limit text + parsed reset for diagnosability.
+          await log(`🔍 Codex usage limit detected (exit ${exitCode}). Raw message: ${JSON.stringify(lastMessage)}`, { verbose: true });
+          await log(`🔍 Parsed reset time: ${JSON.stringify(limitInfo.resetTime)}, timezone: ${JSON.stringify(limitInfo.timezone)}`, { verbose: true });
           limitReached = true;
           limitResetTime = limitInfo.resetTime;
 

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();

package/src/usage-limit.lib.mjs

@@ -121,19 +121,33 @@ 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
+  // Pattern 0: Weekly/long-window limit with an explicit calendar date.
+  // This pattern must come FIRST so a date+time is never truncated to a bare
+  // time by the time-only patterns below (Issue #1869): Codex reports weekly
+  // limits as "try again at Jun 11th, 2026 12:27 AM" — keeping only "12:27 AM"
+  // makes a 2-days-out weekly reset look like a same-day 5-hour reset, which
+  // both mis-informs the user and triggers a far-too-early auto-resume.
+  //
+  // Handled shapes (keyword prefix like "resets"/"try again at" is optional —
+  // the month+day+time structure is specific enough on its own):
+  //   - "resets Jan 15, 8am"                 (no year, Claude weekly)
+  //   - "resets January 20, 10:30am"
+  //   - "try again at Jun 11th, 2026 12:27 AM" (ordinal day + year, Codex weekly)
   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}`;
+  // (month) (day)[ordinal] [, year] [,] (hour)[:minute] (am|pm)
+  const dateWithTimeRegex = new RegExp(`(${monthPattern})\\s+(\\d{1,2})(?:st|nd|rd|th)?(?:,?\\s+(\\d{4}))?,?\\s+([0-9]{1,2})(?::([0-9]{2}))?\\s*([ap]m)`, 'i');
+  const dateWithTime = normalized.match(dateWithTimeRegex);
+  if (dateWithTime) {
+    const month = dateWithTime[1];
+    const day = dateWithTime[2];
+    const year = dateWithTime[3]; // optional
+    const hour = dateWithTime[4];
+    const minute = dateWithTime[5] || '00';
+    const ampm = dateWithTime[6].toUpperCase();
+    // Return formatted date+time string for weekly limits, preserving the year
+    // when present so the reset is anchored to the correct day rather than
+    // being assumed to be "this year / next occurrence".
+    return year ? `${month} ${day}, ${year}, ${hour}:${minute} ${ampm}` : `${month} ${day}, ${hour}:${minute} ${ampm}`;
   }
 
   // Pattern 1: "try again at 12:16 PM"
@@ -244,8 +258,10 @@ export function parseResetTime(timeStr, tz = null) {
   const normalized = timeStr.replace(/\bSept\b/gi, 'Sep');
 
   // 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'];
+  // dayjs uses: MMM=Jan, MMMM=January, D=day, YYYY=year, h=12-hour, mm=minutes, A=AM/PM
+  // Year-bearing formats are tried first so an explicit year (Codex weekly
+  // limits, Issue #1869) is honored instead of being dropped to the current year.
+  const dateTimeFormats = ['MMM D, YYYY, h:mm A', 'MMMM D, YYYY, h:mm A', 'MMM D, h:mm A', 'MMMM D, h:mm A'];
 
   for (const format of dateTimeFormats) {
     let parsed;
@@ -261,9 +277,11 @@ export function parseResetTime(timeStr, tz = null) {
     }
 
     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)) {
+      // When the format omits the year, dayjs defaults to the current year, so a
+      // past date should roll forward to next year. When an explicit year is
+      // present (Issue #1869), trust it verbatim and never bump it.
+      const hasExplicitYear = format.includes('YYYY');
+      if (!hasExplicitYear && parsed.isBefore(now)) {
         parsed = parsed.add(1, 'year');
       }
       return parsed;