unsnooze 1.19.2 → 1.19.3

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## 1.19.3 — 2026-09-30
+
+Codex fixes from a single herdr report: stops that were missed, woken late,
+or woken in the wrong place.
+
+- The out-of-credits screen on Plus plans no longer hides a usage limit. Its
+  Upgrade / Add Credits picker pushed the banner off the part of the pane
+  unsnooze reads; the "Your rate limit resets on" line is now recognised
+  instead (#36).
+- A reset time that a narrow pane wraps onto the next row is read correctly,
+  instead of falling back to guessing and probing (#33).
+- A Codex stop is only marked resumed once its session log shows new output.
+  A keypress or tab switch that briefly hides the banner no longer drops the
+  stop and its exact reset time. Stops with no session log keep the old
+  behaviour (#34).
+- A session running in herdr (or any non-default multiplexer) keeps its pane
+  address when a second detection of the same stop comes in, so it is woken
+  in its own pane instead of reopened beside it (#35).
+
 ## 1.19.2 — 2026-09-27
 
 Setup on Windows no longer creates a Scheduled Task. That task is what

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unsnooze",
-  "version": "1.19.2",
+  "version": "1.19.3",
   "description": "Automatically resume Claude Code, Codex CLI, Grok, Qwen Code, Kimi CLI, OpenCode, Antigravity, and Cursor CLI sessions when 5-hour or weekly usage limits reset—on macOS, Linux and Windows, with or without a terminal multiplexer.",
   "keywords": [
     "claude",

package/src/agents/codex.js

@@ -78,13 +78,19 @@ const LIMIT_ANCHORS = [
   /You['’]ve hit your usage limit/i,   // the desktop app also emits a curly apostrophe
   /Your workspace is out of credits/i,
   /hit your spend cap/i,
+  // Plus plan: an out-of-credits picker sits under the banner and can push it
+  // past the 12-line scan (#36). This line stays inside it and carries the time.
+  /Your rate limit resets on/i,
 ];
 
 export const patterns = {
   limitPatterns: LIMIT_ANCHORS,
   // The whole banner is ONE line, so the anchors double as reset lines — the
   // proximity engine then hands that line to time-parser (which falls back to
-  // the 5h default for "Try again later.").
+  // the 5h default for "Try again later."). A narrow pane soft-wraps that
+  // line, which can strand the clock on a later row; bannerWraps tells the
+  // engine to rejoin the rows before parsing.
+  bannerWraps: true,
   resetPatterns: [
     /try again at/i,
     /try again in \d+/i,
@@ -185,6 +191,30 @@ export function latestSessionId(cwd, aroundTs = null, sessionsRoot = join(CODEX_
   return null;
 }
 
+// The rollout file a thread is writing to now: the newest of its files. A
+// reverted thread continues in a second `…_<rollout id>` file, which is where
+// a resumed turn lands.
+export function rolloutPathFor(sessionId, sessionsRoot = join(CODEX_DIR, 'sessions')) {
+  if (!sessionId) return null;
+  const want = String(sessionId).toLowerCase();
+  let best = null;
+  const walk = (dir, depth) => {
+    let entries;
+    try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return; }
+    for (const e of entries) {
+      const p = join(dir, e.name);
+      if (e.isDirectory() && depth < 3) { walk(p, depth + 1); continue; }
+      const m = e.isFile() && e.name.match(ROLLOUT_RE);
+      if (!m || m[1].toLowerCase() !== want) continue;
+      let mtime;
+      try { mtime = statSync(p).mtimeMs; } catch { continue; }
+      if (!best || mtime > best.mtime) best = { path: p, mtime };
+    }
+  };
+  walk(sessionsRoot, 0);
+  return best ? best.path : null;
+}
+
 export default {
   id: 'codex',
   name: 'OpenAI Codex CLI',

package/src/monitor.js

@@ -25,6 +25,7 @@ import { parseResetTime, resetAtMs, sourceRank } from './time-parser.js';
 import { upsertSession, setStatus, readState, updateState } from './state.js';
 import { prepareCalibrationSample, applyCalibrationToState } from './usage.js';
 import { latestRateLimitFromTranscript } from './watchers/claude.js';
+import { hasCodexProgressAfter } from './watchers/codex.js';
 import { spawnResumerIfNeeded, spawnDetached, monitorSpawnArgs, UNSNOOZE_BIN } from './spawn.js';
 import { restartOnVersionSkew, hasVersionSkew, PKG_VERSION } from './update-check.js';
 import { makeLogger } from './logger.js';
@@ -410,17 +411,21 @@ export function createMonitor({
     }
 
     // A banner leaving the 12-line scan is not evidence of a resume: ordinary
-    // output (including background-agent notices) can scroll it away. Claude
-    // is terminal only after its parent transcript records newer non-error
-    // assistant usage. Other adapters retain their legacy behavior until they
-    // expose an equally authoritative progress signal.
+    // output (including background-agent notices) can scroll it away, and in
+    // Codex a keypress or tab switch can hide it while the session is still
+    // stopped. Claude is terminal only after its parent transcript records
+    // newer non-error assistant usage; Codex only after its rollout records
+    // newer model output (or, with no rollout to read, the legacy rule).
+    // Other adapters retain their legacy behavior until they expose an
+    // equally authoritative progress signal.
     if (trackedKey) {
       const state = readState();
       const rec = state.sessions[trackedKey];
       if (rec && rec.status === 'stopped') {
         const cutoff = rec.bannerAt ?? rec.detectedAt;
-        const progressed = agent.id !== 'claude'
-          || hasClaudeParentUsageAfter(rec, cutoff);
+        const progressed = agent.id === 'claude' ? hasClaudeParentUsageAfter(rec, cutoff)
+          : agent.id === 'codex' ? hasCodexProgressAfter(rec, cutoff) !== false
+            : true;
         if (progressed) {
           const next = setStatus(trackedKey, 'resumed', {
             lastAttemptAt: Date.now(), bannerCleared: true, lastError: null,

package/src/patterns.js

@@ -96,6 +96,25 @@ function quotedLineFlags(lines) {
   return flags;
 }
 
+// A banner the terminal soft-wraps continues on the next rows until its
+// closing punctuation. Codex writes one long line, so at some widths the
+// reset clock lands on a later row than the phrase that introduces it:
+//   "... or try" / "again at 6:02 PM."    "... try again at 6:02" / "PM."
+// Rejoin those rows. Stop at a blank row, at the next TUI glyph, or once the
+// sentence has ended, so a footer hint below the banner is never absorbed.
+const WRAP_MAX_ROWS = 3;
+const NEW_BLOCK = /^\s*[›•■⏺⚠>]/;
+function joinWrapped(lines, idx) {
+  let joined = lines[idx].trim();
+  for (let j = idx + 1; j <= idx + WRAP_MAX_ROWS && j < lines.length; j++) {
+    if (/[.!?]$/.test(joined)) break;
+    const next = lines[j].trim();
+    if (!next || NEW_BLOCK.test(lines[j])) break;
+    joined += ` ${next}`;
+  }
+  return joined;
+}
+
 export function detectLimit(text, tailLines = 12, sets = claudePatterns) {
   const lines = contentLines(text, tailLines);
 
@@ -138,7 +157,10 @@ export function detectLimit(text, tailLines = 12, sets = claudePatterns) {
   // Most recent reset line wins (the TUI never clears old banners from scrollback).
   let resetLine = null;
   for (let i = lines.length - 1; i >= 0; i--) {
-    if (sets.resetPatterns.some(p => p.test(lines[i]))) { resetLine = lines[i].trim(); break; }
+    if (sets.resetPatterns.some(p => p.test(lines[i]))) {
+      resetLine = sets.bannerWraps ? joinWrapped(lines, i) : lines[i].trim();
+      break;
+    }
   }
   if (!resetLine) {
     for (let i = lines.length - 1; i >= 0; i--) {

package/src/state.js

@@ -249,6 +249,10 @@ export function upsertSession(record, { after = null } = {}) {
   const fingerprint = needsFingerprint ? workspaceFingerprint(record.cwd) : undefined;
   return updateState(state => {
     prune(state);
+    // A transcript/GUI detection has no pane, so its address fields are only
+    // defaults (see watcher.js). Taken before the closing branch below, which
+    // nulls the address on purpose and must stay distinguishable from this.
+    const panelessDetection = !record.pane;
     const closing = state.paneClosures.find(c => c.pane && c.leaseId
       && c.mux === record.mux && c.paneOwner === record.paneOwner
       && c.pane === record.pane && c.leaseId === record.leaseId);
@@ -294,6 +298,17 @@ export function upsertSession(record, { after = null } = {}) {
       const merged = {
         ...existing,
         ...record,
+        // A pane-less detection does not know where the session runs. When it
+        // lands on a record that holds a live pane, keep that pane's address:
+        // the defaults would otherwise point the pane id at another
+        // multiplexer, and the resumer would reopen the session beside the
+        // running one instead of waking it.
+        ...(panelessDetection && existing.pane ? {
+          mux: existing.mux,
+          paneOwner: existing.paneOwner,
+          leaseId: existing.leaseId,
+          muxSession: existing.muxSession,
+        } : {}),
         ...(keepReset ? {
           resetAt: existing.resetAt,
           resetSource: existing.resetSource,

package/src/watchers/codex.js

@@ -30,9 +30,9 @@
 // it carries no reset time, and the pane path files it under transient
 // overload for the same reason.
 
-import { openSync, readSync, closeSync } from 'node:fs';
+import { openSync, readSync, closeSync, statSync } from 'node:fs';
 import { basename } from 'node:path';
-import { ROLLOUT_RE, patterns as codexPatterns } from '../agents/codex.js';
+import { ROLLOUT_RE, rolloutPathFor, patterns as codexPatterns } from '../agents/codex.js';
 import { detectLimit } from '../patterns.js';
 // Usage extractor lives in usage.js (shared cold path + daemon); re-exported
 // here so the plan's watcher surface is the documented import site.
@@ -351,3 +351,76 @@ export function rolloutMeta(path) {
   }
   return { sessionId, cwd, originator };
 }
+
+// Model output the rollout records only when a request succeeded. A turn the
+// usage limit refuses writes the user message and a task_complete error, never
+// one of these.
+const MODEL_OUTPUT = new Set(['reasoning', 'function_call', 'custom_tool_call', 'local_shell_call', 'web_search_call']);
+function isModelOutput(entry) {
+  if (entry?.type !== 'response_item') return false;
+  const p = entry.payload || {};
+  return (p.type === 'message' && p.role === 'assistant') || MODEL_OUTPUT.has(p.type);
+}
+
+// Durable evidence that a Codex session made progress after a recorded stop:
+// model output in its rollout, newer than the stop and not followed by a newer
+// limit. The Codex counterpart of hasClaudeParentUsageAfter. A banner leaving
+// the pane's scan window is not evidence; a keypress, tab switch or overlay
+// can do that while the session is still stopped. Returns null when there is
+// no rollout to read (no session id, file not found, read error), so the
+// caller can fall back instead of holding the stop forever.
+//
+// The monitor asks every scrape tick while the banner is hidden, so the path
+// lookup (a walk of ~/.codex/sessions) is reused for a minute. A reverted
+// thread's newer continuation file is still picked up within that minute.
+const PATH_TTL_MS = 60_000;
+const pathCache = new Map();
+function cachedRolloutPath(sessionId, sessionsRoot) {
+  const key = `${sessionsRoot ?? ''}|${sessionId}`;
+  const hit = pathCache.get(key);
+  if (hit && Date.now() - hit.at < PATH_TTL_MS) return hit.path;
+  const path = sessionsRoot ? rolloutPathFor(sessionId, sessionsRoot) : rolloutPathFor(sessionId);
+  if (path) pathCache.set(key, { path, at: Date.now() });
+  else pathCache.delete(key);
+  return path;
+}
+
+export function hasCodexProgressAfter(rec, afterMs, {
+  sessionsRoot,
+  window = 256 * 1024,
+  maxWindow = 4 * 1024 * 1024,
+} = {}) {
+  if (!rec?.sessionId || !Number.isFinite(afterMs)) return null;
+  const path = cachedRolloutPath(rec.sessionId, sessionsRoot);
+  if (!path) return null;
+  let fd;
+  try {
+    const { size } = statSync(path);
+    fd = openSync(path, 'r');
+    for (let win = window; ; win = Math.min(win * 2, maxWindow)) {
+      const len = Math.min(win, size);
+      const buf = Buffer.alloc(len);
+      readSync(fd, buf, 0, len, size - len);
+      const lines = buf.toString('utf-8').split('\n');
+      if (len < size) lines.shift();   // the first line may be truncated
+      for (let i = lines.length - 1; i >= 0; i--) {
+        if (!lines[i].trim()) continue;
+        let entry;
+        try { entry = JSON.parse(lines[i]); } catch { continue; }
+        const at = Date.parse(entry?.timestamp);
+        if (!Number.isFinite(at)) continue;
+        // Lines are chronological: nothing older can postdate the stop.
+        if (at <= afterMs) return false;
+        // Newest first, so a limit written after the last output means the
+        // session stopped again.
+        if (parseRolloutLine(lines[i])) return false;
+        if (isModelOutput(entry)) return true;
+      }
+      if (len >= size || win >= maxWindow) return false;
+    }
+  } catch {
+    return null;
+  } finally {
+    if (fd !== undefined) closeSync(fd);
+  }
+}