unsnooze 1.19.2 → 1.19.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unsnooze",
-  "version": "1.19.2",
+  "version": "1.19.4",
   "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/agy.js

@@ -18,23 +18,33 @@ import { homedir } from 'node:os';
 import { join } from 'node:path';
 
 const AGY_DIR = () => process.env.UNSNOOZE_AGY_DIR || join(homedir(), '.gemini', 'antigravity-cli');
+const SESSION_RECENCY_MS = 5 * 60 * 60 * 1000;
 
 const LIMIT_ANCHORS = [
+  /Individual quota reached/i,
   /Model quota limit exceeded/i,
   /RESOURCE_EXHAUSTED/,
   /quota (?:limit )?exceeded/i,
 ];
 
 export const patterns = {
+  bannerWraps: true,
   limitPatterns: LIMIT_ANCHORS,
   // "Refreshes in 6 days and 18 hours" renders near the quota banner; anchors
   // double as reset lines for the API-key single-line renders.
   resetPatterns: [
-    /Refreshes in/i,
+    /Refreshes\s+in/i,
+    /Resets\s+in/i,
+    /\b(?:Resets|Refreshes)(?:\s+in)?\s*$/i,
     ...LIMIT_ANCHORS,
   ],
-  weeklyPatterns: [/Refreshes in \d+ days?/i],   // multi-day refresh = the weekly cap
-  fiveHourPatterns: [],
+  weeklyPatterns: [
+    /Refreshes\s+in\s+\d+\s+days?/i,
+    /(?:Refreshes|Resets)\s+in\s+\d+(?:\.\d+)?\s*(?:days?|d)(?![a-z])/i,
+  ],
+  fiveHourPatterns: [
+    /(?:Refreshes|Resets)\s+in\s+\d+(?:\.\d+)?\s*(?:hours?|hrs?|h|minutes?|mins?|m|seconds?|secs?|s)(?![a-z])/i,
+  ],
   busyPatterns: [
     /esc to interrupt/i,
     /attempt \d+\/\d+/i,
@@ -47,9 +57,10 @@ export const patterns = {
 
 // ~/.gemini/antigravity-cli/history.jsonl indexes all conversations. Schema is
 // undocumented (and a SQLite migration is rumored) — parse the tail
-// tolerantly: an entry counts if any string value equals the cwd, its id is
-// the first conversation-ish field. Null on any doubt (the resumer then opens
-// a fresh agy session; the wake message explains the context loss).
+// tolerantly. A workspace can have multiple live conversations, so when the
+// caller supplies a detection time, use an id only if exactly one conversation
+// appears in recent history. Otherwise the live pane can still be resumed in
+// place; if it has disappeared, the adapter falls back to --continue.
 function tailBytes(path, bytes = 64 * 1024) {
   let fd;
   try {
@@ -70,13 +81,49 @@ export function latestSessionId(cwd, aroundTs = null, agyDir = AGY_DIR()) {
   const text = tailBytes(join(agyDir, 'history.jsonl'));
   if (!text) return null;
   const lines = text.split('\n').filter(l => l.trim());
+  const recentIds = new Set();
+  let latestId = null;
+  let hasTimestamp = false;
   for (let i = lines.length - 1; i >= 0; i--) {
     let entry;
     try { entry = JSON.parse(lines[i]); } catch { continue; }
     if (!entry || typeof entry !== 'object') continue;
     if (!Object.values(entry).some(v => v === cwd)) continue;
     const id = entry.conversation_id ?? entry.conversationId ?? entry.id;
-    if (typeof id === 'string' && id) return id;
+    if (typeof id !== 'string' || !id) continue;
+    latestId ||= id;
+    const timestamp = typeof entry.timestamp === 'number'
+      ? entry.timestamp
+      : typeof entry.timestamp === 'string' ? Date.parse(entry.timestamp) : NaN;
+    if (Number.isFinite(timestamp)) {
+      hasTimestamp = true;
+      if (Number.isFinite(aroundTs) && Math.abs(aroundTs - timestamp) <= SESSION_RECENCY_MS) {
+        recentIds.add(id);
+      }
+    }
+  }
+  if (!Number.isFinite(aroundTs) || !hasTimestamp) return latestId;
+  return recentIds.size === 1 ? recentIds.values().next().value : null;
+}
+
+export function latestBannerAt(cwd, aroundTs = null, agyDir = AGY_DIR()) {
+  const text = tailBytes(join(agyDir, 'history.jsonl'));
+  if (!text) return null;
+  const lines = text.split('\n').filter(l => l.trim());
+  for (let i = lines.length - 1; i >= 0; i--) {
+    let entry;
+    try { entry = JSON.parse(lines[i]); } catch { continue; }
+    if (!entry || typeof entry !== 'object') continue;
+    if (!Object.values(entry).some(v => v === cwd)) continue;
+    const timestamp = typeof entry.timestamp === 'number'
+      ? entry.timestamp
+      : typeof entry.timestamp === 'string' ? Date.parse(entry.timestamp) : NaN;
+    if (Number.isFinite(timestamp)) {
+      if (!Number.isFinite(aroundTs)) return timestamp;
+      if (timestamp <= (aroundTs + 5000) && (aroundTs - timestamp) <= SESSION_RECENCY_MS) {
+        return timestamp;
+      }
+    }
   }
   return null;
 }
@@ -96,6 +143,7 @@ export default {
   // v1: every agent launches the bare TUI and gets the prompt typed once idle.
   launchArgs(message) { return { args: [], messageViaPane: true }; },
   latestSessionId,
+  latestBannerAt,
   isForegroundCommand(cmd) {
     return cmd === 'agy' || cmd === 'node' || cmd === 'unsnooze';
   },

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';
@@ -112,10 +113,13 @@ export function createMonitor({
         detectedAt,
       };
     }
+    const bannerAt = typeof agent.latestBannerAt === 'function'
+      ? agent.latestBannerAt(cwd, detectedAt)
+      : null;
     return {
       resetLine: paneResetLine,
       limitType: paneLimitType,
-      bannerAt: null,
+      bannerAt,
       sessionId,
       via: null,   // filled by caller (scrape/hook)
       detectedAt,
@@ -131,6 +135,7 @@ export function createMonitor({
   // "already past → due now" path, which is margin above wall clock only).
   function isCorroborated(resolved, at, source) {
     if (resolved.via === 'transcript' && resolved.bannerAt != null) return true;
+    if (resolved.bannerAt != null && at - RESET_MARGIN_MS > Date.now()) return true;
     if (source === 'absolute' && at - RESET_MARGIN_MS > Date.now()) return true;
     // A model limit carries no time to corroborate — its own remedy hint is
     // the evidence, and the record only ever probes (never blind-wakes), so
@@ -410,17 +415,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/resumer.js

@@ -342,6 +342,10 @@ export async function probeFallback(rec, {
     return null;
   }
 
+  if (!bannerAt && typeof agent.latestBannerAt === 'function') {
+    bannerAt = agent.latestBannerAt(rec.cwd, now);
+  }
+
   // Banner still present. If it now parses to a real time, upgrade off fallback.
   if (resetLine) {
     const { at, source } = resetAtMs(parseResetTime(resetLine), {
@@ -955,6 +959,8 @@ export async function verifyOne(key, { resolveMux = resolveRecordMux } = {}) {
     if (fromTx) {
       resetLine = fromTx.resetLine ?? resetLine;
       bannerAt = fromTx.timestampMs;
+    } else if (typeof agent.latestBannerAt === 'function') {
+      bannerAt = agent.latestBannerAt(rec.cwd, Date.now());
     }
     const { at, source } = resetAtMs(parseResetTime(resetLine), {
       marginMs: RESET_MARGIN_MS,

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