@link-assistant/hive-mind 1.74.7 → 1.74.9

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # @link-assistant/hive-mind
 
+## 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
+
+- c132ce0: Fix `/stop <issue-or-pr-url>` so it can stop tasks that started immediately
+  (empty queue) or were already dispatched to a detached isolation session. The
+  URL lookup now also consults the session-monitor registry and forwards CTRL+C
+  to the tracked start-command UUID, so all three stop modes (issue URL, PR URL,
+  and session UUID) work end-to-end (#1871).
+
 ## 1.74.7
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "1.74.7",
+  "version": "1.74.9",
   "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/session-monitor.lib.mjs

@@ -150,7 +150,11 @@ function isMessageAlreadyUpdatedError(error) {
 }
 
 function normalizeSessionUrl(url) {
-  return url.replace(/\/+$/, '').replace(/#.*$/, '').toLowerCase();
+  // Strip the fragment first, then any trailing slashes, so URLs that carry a
+  // fragment after a trailing slash (e.g. `.../issues/18/#comment`) normalize to
+  // the same value as the bare `.../issues/18`. Doing it in the other order
+  // would leave a dangling trailing slash. (Issue #1871.)
+  return url.replace(/#.*$/, '').replace(/\/+$/, '').toLowerCase();
 }
 
 function isNonIsolationSessionActive(sessionName, sessionInfo, verbose = false) {
@@ -488,6 +492,73 @@ export function hasActiveSessionForUrl(url, verbose = false) {
   return { isActive: false, sessionName: null };
 }
 
+const SESSION_UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+/**
+ * Issue #1871: Find a tracked, still-running session for a GitHub issue/PR URL
+ * and report whether it can be stopped by forwarding CTRL+C to the
+ * start-command session UUID.
+ *
+ * The `/stop <url>` Telegram flow originally consulted only the in-memory solve
+ * queue. But a `/solve` or `/codex` that starts immediately (queue empty)
+ * dispatches straight to a detached isolation session and is removed from the
+ * queue's `processing` Map the moment it is launched. From that point on the
+ * session-monitor's in-memory registry is the only place that still knows the
+ * URL → start-command-UUID mapping, so `/stop <url>` reported "no task found"
+ * even though the task was clearly running. This helper exposes that registry
+ * so the stop flow can recover the UUID and interrupt the session.
+ *
+ * A session is stoppable when it was launched with an isolation backend and its
+ * start-command UUID is UUID-shaped (the value `$ --stop <uuid>` expects). Plain
+ * non-isolation screen sessions are reported but marked `stoppable: false`
+ * because `$ --stop` cannot interrupt them.
+ *
+ * @param {string} url - GitHub issue or PR URL (any normalization)
+ * @param {boolean} verbose - Whether to log verbose output
+ * @returns {{ sessionName: string, sessionId: string|null, sessionInfo: Object,
+ *   isolationBackend: string|null, stoppable: boolean }|null} Match or null
+ */
+export function findStoppableSessionByUrl(url, verbose = false) {
+  if (!url) return null;
+
+  const normalizedUrl = normalizeSessionUrl(url);
+
+  for (const [sessionName, sessionInfo] of activeSessions.entries()) {
+    if (!sessionInfo.url || normalizeSessionUrl(sessionInfo.url) !== normalizedUrl) {
+      continue;
+    }
+    // Issue #1586: skip expired non-isolation sessions — they are no longer running.
+    if (!sessionInfo.isolationBackend && !isNonIsolationSessionActive(sessionName, sessionInfo, verbose)) {
+      continue;
+    }
+
+    // The UUID `$ --stop` expects is the start-command session id. For
+    // isolation sessions it is tracked either as sessionInfo.sessionId or as
+    // the (UUID-shaped) session key itself.
+    const candidateId = sessionInfo.sessionId || sessionName;
+    const sessionId = SESSION_UUID_RE.test(candidateId) ? candidateId : null;
+    const stoppable = Boolean(sessionInfo.isolationBackend && sessionId);
+
+    if (verbose) {
+      const mode = sessionInfo.isolationBackend ? `isolation:${sessionInfo.isolationBackend}` : 'non-isolation';
+      console.log(`[VERBOSE] findStoppableSessionByUrl: matched ${sessionName} for ${url} (${mode}, stoppable=${stoppable})`);
+    }
+
+    return {
+      sessionName,
+      sessionId,
+      sessionInfo,
+      isolationBackend: sessionInfo.isolationBackend || null,
+      stoppable,
+    };
+  }
+
+  if (verbose) {
+    console.log(`[VERBOSE] findStoppableSessionByUrl: no tracked session for ${url}`);
+  }
+  return null;
+}
+
 /**
  * Async active-session check for command handlers.
  *

package/src/telegram-bot.mjs

@@ -43,7 +43,7 @@ const { isOldMessage: _isOldMessage, isGroupChat: _isGroupChat, isChatAuthorized
 const { installTelegramFormattingFallback, isTelegramFormattingError, isTelegramMessageTooLongError, safeEditMessageText, safeReply, TELEGRAM_TEXT_LIMIT } = await import('./telegram-safe-reply.lib.mjs');
 const { registerTerminalWatchCommand, startAutoTerminalWatchForSession } = await import('./telegram-terminal-watch-command.lib.mjs');
 const { launchBotWithRetry } = await import('./telegram-bot-launcher.lib.mjs');
-const { trackSession, startSessionMonitoring, hasActiveSessionForUrlAsync } = await import('./session-monitor.lib.mjs');
+const { trackSession, startSessionMonitoring, hasActiveSessionForUrlAsync, findStoppableSessionByUrl } = await import('./session-monitor.lib.mjs');
 const { formatExecutingWorkSessionMessage, formatStartingWorkSessionMessage } = await import('./work-session-formatting.lib.mjs');
 const { buildTelegramHelpMessage, buildTelegramInfoBlock, buildSolveQueuedMessage } = await import('./telegram-ui-messages.lib.mjs');
 
@@ -1068,7 +1068,7 @@ const { registerTopCommand } = await import('./telegram-top-command.lib.mjs');
 const { registerStartStopCommands } = await import('./telegram-start-stop-command.lib.mjs');
 const { registerLogCommand } = await import('./telegram-log-command.lib.mjs');
 registerTopCommand(bot, sharedCommandOpts);
-registerStartStopCommands(bot, { ...sharedCommandOpts, getSolveQueue });
+registerStartStopCommands(bot, { ...sharedCommandOpts, getSolveQueue, findRunningSessionByUrl: (url, verbose) => findStoppableSessionByUrl(url, verbose) });
 await registerLogCommand(bot, sharedCommandOpts);
 await registerTerminalWatchCommand(bot, sharedCommandOpts);
 

package/src/telegram-start-stop-command.lib.mjs

@@ -16,10 +16,15 @@
  * - `/stop <issue-or-pr-url>` (or reply to a message that contains one) looks
  *   the URL up in the in-memory solve queue and either cancels the queued
  *   item or forwards CTRL+C to the running isolated session (issue #1780).
+ * - `/stop <issue-or-pr-url>` also consults the session-monitor registry of
+ *   running detached sessions, so it can interrupt a task that started
+ *   immediately (queue empty) and was therefore never left in the queue's
+ *   `processing` Map — the case shown in issue #1871's screenshots.
  *
  * @see https://github.com/link-assistant/hive-mind/issues/1081
  * @see https://github.com/link-assistant/hive-mind/issues/524
  * @see https://github.com/link-assistant/hive-mind/issues/1780
+ * @see https://github.com/link-assistant/hive-mind/issues/1871
  * @see https://github.com/link-foundation/start/issues/112
  */
 
@@ -257,6 +262,12 @@ export function isStopTargetRequester({ userId, queueItem = null, sessionInfo =
  *   When omitted, the URL flow degrades gracefully to a "no queue available"
  *   message so unit tests for non-URL paths don't need to construct a queue.
  *   See https://github.com/link-assistant/hive-mind/issues/1780.
+ * @param {Function} [options.findRunningSessionByUrl] - Override for tests; looks
+ *   the URL up in the session-monitor registry of running detached sessions so
+ *   `/stop <url>` can interrupt tasks that started immediately (queue empty) and
+ *   were therefore never left in the queue's `processing` Map. When omitted, the
+ *   real `findStoppableSessionByUrl` from session-monitor is lazy-imported.
+ *   See https://github.com/link-assistant/hive-mind/issues/1871.
  */
 export function registerStartStopCommands(bot, options) {
   const { VERBOSE = false, isOldMessage, isForwardedOrReply, isGroupChat, isChatAuthorized, isTopicAuthorized, buildAuthErrorMessage, getSolveQueue } = options;
@@ -274,6 +285,26 @@ export function registerStartStopCommands(bot, options) {
     return mod.getTrackedSessionInfo(sessionId);
   }
 
+  // Issue #1871: look a URL up in the session-monitor registry of running
+  // detached sessions. A /solve or /codex that started immediately (queue
+  // empty) is dispatched straight to an isolation session and removed from the
+  // queue's `processing` Map, so the queue lookup alone reports "no task found"
+  // for a task that is clearly running. The session monitor still knows the
+  // URL → start-command-UUID mapping, which lets /stop <url> recover and
+  // interrupt the session. Test stubs can inject findRunningSessionByUrl.
+  async function lookupRunningSessionByUrl(url) {
+    try {
+      if (typeof options.findRunningSessionByUrl === 'function') {
+        return await options.findRunningSessionByUrl(url, VERBOSE);
+      }
+      const mod = await import('./session-monitor.lib.mjs');
+      return mod.findStoppableSessionByUrl(url, VERBOSE);
+    } catch (error) {
+      console.error('[ERROR] /stop: findStoppableSessionByUrl failed:', error);
+      return null;
+    }
+  }
+
   /**
    * Validate command context: checks old message, forwarded, group chat, authorized, and owner status.
    * @param {Object} ctx - Telegraf context
@@ -529,18 +560,42 @@ export function registerStartStopCommands(bot, options) {
       const url = target.value;
       VERBOSE && console.log(`[VERBOSE] /stop: detected URL ${url} (source=${target.source})`);
 
-      // Look up the queue item BEFORE auth so we can allow the original task
-      // requester to cancel their own task in a group (#1783). The lookup
-      // here does NOT mutate the queue — actual cancel happens below in
-      // resolveQueueLookupForUrl after auth has passed.
+      // Look up the queue item AND any running detached session BEFORE auth so
+      // we can allow the original task requester to cancel their own task in a
+      // group (#1783), regardless of whether the task is still queued or already
+      // dispatched to an isolation session (#1871). Neither lookup mutates
+      // state — actual cancel/stop happens below after auth has passed.
       const candidate = findQueueCandidateForUrl(url);
-      const ok = await authorizeTargetedStop(ctx, 'URL', { queueItem: candidate.item || null });
+      const runningSession = await lookupRunningSessionByUrl(url);
+      const ok = await authorizeTargetedStop(ctx, 'URL', { queueItem: candidate.item || null, sessionInfo: runningSession?.sessionInfo || null });
       if (!ok) return;
 
       const lookup = resolveQueueLookupForUrl(url);
       VERBOSE && console.log(`[VERBOSE] /stop: queue lookup for ${url} → ${lookup.action}`);
 
+      // Issue #1871: when the queue has no record of the task (it started
+      // immediately and was dispatched to a detached session) but the session
+      // monitor still tracks a running isolated session for this URL, forward
+      // CTRL+C to its start-command UUID. This is the common case for tasks
+      // that begin executing right away with `--isolation screen`.
+      const queueHasTask = lookup.action === 'cancel-queued' || lookup.action === 'stop-running';
+      if (!queueHasTask && runningSession?.stoppable && runningSession.sessionId) {
+        VERBOSE && console.log(`[VERBOSE] /stop: forwarding CTRL+C to tracked session ${runningSession.sessionId} for ${url} (queue action=${lookup.action})`);
+        await runStopIsolatedSessionFlow(ctx, runningSession.sessionId);
+        return;
+      }
+
       if (lookup.action === 'no-queue') {
+        // No solve queue in this context. If the session monitor found a
+        // running-but-non-stoppable (non-isolation) session, say so; otherwise
+        // fall back to the UUID hint.
+        if (runningSession) {
+          await ctx.reply(`⚠️ Found a running task for ${url}, but it was not started with an isolation backend, so \`/stop\` cannot forward CTRL+C to it.\n\nNext time you can run the command with \`--isolation screen\` to make this task interruptible via \`/stop\`.`, {
+            parse_mode: 'Markdown',
+            reply_to_message_id: message.message_id,
+          });
+          return;
+        }
         await ctx.reply(`ℹ️ Cannot look up tasks by URL right now (the bot has no solve queue available in this context).\n\nIf you have the session UUID, you can use \`/stop <UUID>\` instead.`, {
           parse_mode: 'Markdown',
           reply_to_message_id: message.message_id,
@@ -549,6 +604,16 @@ export function registerStartStopCommands(bot, options) {
       }
 
       if (lookup.action === 'not-found') {
+        // The session monitor also had no stoppable session (otherwise we would
+        // have forwarded CTRL+C above). If it tracked a non-isolation session,
+        // explain why it can't be stopped; otherwise report not found.
+        if (runningSession) {
+          await ctx.reply(`⚠️ Found a running task for ${url}, but it was not started with an isolation backend, so \`/stop\` cannot forward CTRL+C to it.\n\nNext time you can run the command with \`--isolation screen\` to make this task interruptible via \`/stop\`.`, {
+            parse_mode: 'Markdown',
+            reply_to_message_id: message.message_id,
+          });
+          return;
+        }
         await ctx.reply(`ℹ️ No queued or running task found for ${url}.\n\nIf the task is running with \`--isolation screen\`, try \`/stop <UUID>\` (the UUID is shown in the bot's session-id message).`, {
           parse_mode: 'Markdown',
           reply_to_message_id: message.message_id,

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;