unsnooze 1.1.0 → 1.2.0

package/CHANGELOG.md

@@ -1,5 +1,44 @@
 # Changelog
 
+## 1.2.0 — 2026-07-10
+
+### GUI surfaces: VS Code extension, desktop apps
+
+Sessions running outside a terminal — Claude Code's VS Code extension and
+desktop app, Codex's IDE extension and desktop app — are now guarded too.
+There is no pane to scrape and (for Codex) no hook, so detection tails the
+session files the CLIs already write:
+
+- **Claude Code**: rate-limit stops land in `~/.claude/projects` transcripts
+  as structured entries (`error:"rate_limit"`, session id, cwd, reset text).
+  The new watcher turns them into ledger records; the weekly banner form
+  ("resets Jul 4 at 12:30am (tz)") now parses, DST-safe.
+- **Codex**: rollouts never persist error events, but every turn's
+  `token_count` event carries a `rate_limits` snapshot (`used_percent`,
+  `resets_at` epoch). An exhausted window becomes a stop with an exact epoch
+  reset — more precise than any scraped banner — and works for every Codex
+  surface, since they share `~/.codex/sessions`.
+- **Claude desktop (cowork) sessions** *(experimental, macOS)*: sandboxed
+  sessions under `~/Library/Application Support/Claude` are detected, and
+  revival exports the session's isolated `CLAUDE_CONFIG_DIR` together with
+  `CLAUDE_SECURESTORAGE_CONFIG_DIR=''` so auth resolves through the default
+  keychain entry (the sandbox holds no credentials). Verified end-to-end
+  against a real desktop session.
+
+Revival stays terminal-based: when the limit resets, the session reopens in a
+tmux window via `claude --resume <id>` / `codex resume <id>` — the same
+session file continues, so the conversation stays visible in the GUI's own
+history. Resuming *inside* the GUI panels is not possible today (no IPC/URI
+sends a prompt into them).
+
+- **`unsnooze daemon`**: persistent watcher process; `unsnooze install
+  --daemon` (or the new wizard step) installs it as a launchd agent (macOS)
+  or systemd user unit (Linux) so GUI sessions are watched without a shell.
+- **`guiWatch` setting** (default on) gates the watching; `unsnooze status`
+  shows each stop's origin (`cli`, `vscode`, `desktop`, …).
+- Ledger dedupe: transcript records merge with hook/scrape records of the
+  same session, so terminal sessions are never double-resumed.
+
 ## 1.1.0 — 2026-07-10
 
 ### Per-agent resume messages

package/README.md

@@ -29,6 +29,7 @@ existing tool solves only a slice of it:
 | | **unsnooze** | claude-auto-retry | autoclaude | hydra |
 |---|:---:|:---:|:---:|:---:|
 | Multi-CLI (Claude Code + Codex + Grok) | ✅ | ❌ Claude only | ❌ Claude only | ✅ |
+| GUI sessions (VS Code ext, desktop apps) | ✅ watcher daemon | ❌ | ❌ | ❌ |
 | Waits for reset & resumes the **same** session | ✅ | ✅ | ✅ | ❌ switches provider |
 | All sessions at once (shared ledger + one daemon) | ✅ | ❌ one pane | ✅ | ✅ |
 | Revives sessions whose pane/process is **gone** | ✅ `--resume <id>` | ❌ | ❌ | ❌ |
@@ -52,6 +53,35 @@ existing tool solves only a slice of it:
   fallback. Hit a banner unsnooze missed? Run `unsnooze report` and paste the
   capture into an issue — that's how this adapter gets good.
 
+## GUI surfaces (VS Code extension, desktop apps)
+
+Terminal sessions are watched through the shell wrapper + tmux. Sessions in
+**Claude Code's VS Code extension / desktop app** and **Codex's IDE
+extension / desktop app** have no pane to scrape — so `unsnooze daemon` tails
+the session files those surfaces already write:
+
+- **Claude Code** records every rate-limit stop as a structured entry in its
+  `~/.claude/projects/**.jsonl` transcript (session id, cwd, reset time) —
+  shared by the CLI and the VS Code extension.
+- **Codex** writes a `rate_limits` snapshot (usage %, **exact epoch reset
+  time**) into every rollout under `~/.codex/sessions/` — shared by the CLI,
+  IDE extension, and desktop app.
+- **Claude desktop (cowork) sessions** *(experimental, macOS)* run in
+  sandboxes under `~/Library/Application Support/Claude`; unsnooze watches
+  those too and revives with the session's isolated `CLAUDE_CONFIG_DIR`
+  (plus the keychain-scope override that keeps auth working — verified
+  against a real desktop session).
+
+When the limit resets, the session is revived **in a tmux window** with
+`claude --resume <id>` / `codex resume <id>` — it's the same session file, so
+the continued conversation stays visible in the GUI's own history. (Resuming
+*inside* the GUI panel isn't possible today: no extension/app exposes an
+IPC/URI that can send a prompt.)
+
+Enable it in `unsnooze setup` (installs a launchd agent / systemd user unit),
+or run `unsnooze install --daemon` / `unsnooze daemon` yourself. Turn it off
+anytime with `unsnooze config set guiWatch off`.
+
 ## How it works
 
 <div align="center">
@@ -101,6 +131,8 @@ unsnooze cancel [id|--all]      # stop tracking a session
 unsnooze config list            # settings (see below)
 unsnooze config set <k> <v>     # e.g. autoResume off
 unsnooze logs [-f]              # what unsnooze has been doing
+unsnooze daemon                 # persistent GUI-session watcher (usually run
+                                # by launchd/systemd via `install --daemon`)
 unsnooze report [agent]         # capture a pane to report an undetected banner
 unsnooze uninstall [--purge]    # remove wrappers + hooks (+ state with --purge)
 unsnooze help                   # full command list (also -h / --help)
@@ -116,6 +148,7 @@ unsnooze help                   # full command list (also -h / --help)
 | `autoResume` | `true` | Master switch. Off = stops are still tracked, but nothing is resumed until you run `unsnooze resume-now` or turn it back on. |
 | `menuAutoAnswer` | `true` | May unsnooze answer Claude's limit menu (send keys in your pane)? Off = watch-only. |
 | `notifications` | `true` | Desktop notification on limit detected / session resumed / gave up. |
+| `guiWatch` | `true` | May the daemon watch session files for GUI-surface stops (VS Code extension, desktop apps)? Needs the daemon running (`unsnooze install --daemon`). |
 | `resumeMessage` | *"Continue where you left off…"* | The message sent to wake a session. |
 | `resumeMessages.claude` / `.codex` / `.grok` | `""` | Per-agent override of `resumeMessage`. Empty = use the global message; clear one with `unsnooze config set resumeMessages.claude ""`. |
 | `agents.claude` / `agents.codex` / `agents.grok` | `true` / `true` / `false` | Which CLIs are guarded. |

package/bin/unsnooze.js

@@ -60,6 +60,17 @@ async function main() {
       const { runResumer } = await import('../src/resumer.js');
       return runResumer();
     }
+    case 'daemon': {
+      // Persistent resumer + transcript watcher: detects and revives limit
+      // stops from GUI surfaces (VS Code extension, desktop apps) where no
+      // shell wrapper or tmux pane exists. Run via launchd/systemd or a shell.
+      const { runResumer } = await import('../src/resumer.js');
+      const { createWatcher } = await import('../src/watcher.js');
+      const controller = new AbortController();
+      process.on('SIGTERM', () => controller.abort());
+      process.on('SIGINT', () => controller.abort());
+      return runResumer({ persistent: true, watcher: createWatcher(), signal: controller.signal });
+    }
     case 'help':
     case '-h':
     case '--help':
@@ -73,6 +84,9 @@ Usage:
   unsnooze resume-now [id|--all]   resume stopped session(s) immediately
   unsnooze cancel [id|--all]       stop tracking session(s)
   unsnooze logs [-f]               show (or follow) the unsnooze log
+  unsnooze daemon                  persistent watcher for GUI sessions (VS Code
+                                   extension, desktop apps) — no tmux needed to
+                                   detect; revival still opens in tmux
   unsnooze config [list|get|set]   view or change settings (toggles, global +
                                    per-agent resume messages)
   unsnooze setup                   interactive setup wizard (agents + toggles)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unsnooze",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Wakes every limit-stopped AI coding session (Claude Code, Codex CLI, Grok) in tmux the moment the usage limit resets.",
   "keywords": [
     "claude-code",

package/src/agents/claude.js

@@ -23,6 +23,7 @@ export const patterns = {
     /resets?\s+in[:\s]\s*\d/i,
     /try again in \d+\s*(?:hours?|minutes?|h|m)/i,
     /resets?\s+(?:on\s+)?(?:mon|tue|wed|thu|fri|sat|sun)/i,   // weekly: "resets Tuesday 9am"
+    /resets?\s+(?:on\s+)?(?:jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)[a-z]*\s+\d{1,2}\b/i,   // weekly: "resets Jul 4 at 12:30am"
   ],
   weeklyPatterns: [
     /week(?:ly)?\s+limit/i,

package/src/agents/codex.js

@@ -11,10 +11,8 @@
 // the overload path, never the ledger.
 
 import { openSync, readSync, closeSync, readdirSync, statSync } from 'node:fs';
-import { homedir } from 'node:os';
 import { join } from 'node:path';
-
-const CODEX_DIR = process.env.UNSNOOZE_CODEX_DIR || join(homedir(), '.codex');
+import { CODEX_DIR } from '../config.js';
 
 const LIMIT_ANCHORS = [
   /You've hit your usage limit/i,
@@ -48,7 +46,7 @@ export const patterns = {
 // the first JSONL line carries the session cwd. Conservative: no cwd match →
 // null (the resumer then uses `codex resume --last`, which codex itself scopes
 // to the launch cwd).
-const ROLLOUT_RE = /^rollout-.*-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/i;
+export const ROLLOUT_RE = /^rollout-.*-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/i;
 
 function fileHead(path, bytes = 4096) {
   let fd;

package/src/cli.js

@@ -29,8 +29,9 @@ export function cmdStatus() {
   for (const s of sessions.sort((a, b) => (a.resetAt || 0) - (b.resetAt || 0))) {
     const id = s.sessionId ? s.sessionId.slice(0, 8) : '(no id)';
     const reset = s.resetAt ? `${new Date(s.resetAt).toLocaleString()} (${fmtCountdown(s.resetAt - now)})` : '?';
+    const origin = s.origin ?? (s.pane ? 'cli' : '?');
     console.log(`  [${s.status.toUpperCase().padEnd(9)}] ${id}  ${(s.agent || 'claude').padEnd(6)} ${s.limitType?.padEnd(7) ?? 'unknown'} ${s.cwd}`);
-    console.log(`              pane ${s.pane ?? '-'} · resets ${reset} · attempts ${s.attempts ?? 0}/${MAX_RESUME_ATTEMPTS}${s.lastError ? ` · last error: ${s.lastError}` : ''}`);
+    console.log(`              pane ${s.pane ?? '-'} · via ${origin} · resets ${reset} · attempts ${s.attempts ?? 0}/${MAX_RESUME_ATTEMPTS}${s.lastError ? ` · last error: ${s.lastError}` : ''}`);
   }
   return 0;
 }

package/src/config.js

@@ -15,6 +15,10 @@ export const RESUMER_LOCK = join(STATE_DIR, 'resumer.lock');
 
 export const CLAUDE_DIR = process.env.UNSNOOZE_CLAUDE_DIR || join(homedir(), '.claude');
 export const CLAUDE_SETTINGS = join(CLAUDE_DIR, 'settings.json');
+export const CODEX_DIR = process.env.UNSNOOZE_CODEX_DIR || join(homedir(), '.codex');
+
+// Transcript/rollout watcher (GUI detection channel)
+export const WATCH_OFFSETS_FILE = join(STATE_DIR, 'watch-offsets.json');
 
 export const TMUX_SESSION_NAME = process.env.UNSNOOZE_TMUX_SESSION || 'unsnooze';
 
@@ -28,6 +32,7 @@ export const VERIFY_DELAY_MS = envInt('UNSNOOZE_VERIFY_DELAY_MS', 20_000);
 export const BUSY_DEFER_MS = envInt('UNSNOOZE_BUSY_DEFER_MS', 60_000);
 export const READY_TIMEOUT_MS = envInt('UNSNOOZE_READY_TIMEOUT_MS', 60_000);
 export const EVENT_MARKER_TTL_MS = envInt('UNSNOOZE_EVENT_MARKER_TTL_MS', 120_000);
+export const WATCH_FRESHNESS_MS = envInt('UNSNOOZE_WATCH_FRESHNESS_MS', 15 * 60_000);
 
 // Pane scanning
 export const PANE_SCAN_LINES = envInt('UNSNOOZE_PANE_SCAN_LINES', 12);

package/src/hook.js

@@ -84,6 +84,7 @@ export async function runHook(rest = []) {
       cwd,
       pane,
       agent: agent.id,
+      origin: 'cli',   // the hook only fires for CLI launches we can see
       tmuxSession: TMUX_SESSION_NAME,
       status: 'stopped',
       limitType,

package/src/install.js

@@ -8,11 +8,13 @@
 //   - ~/.grok/hooks/unsnooze.json when the grok agent is enabled
 // --settings <path> / --zshrc <path> override targets (used by tests).
 
-import { readFileSync, writeFileSync, renameSync, existsSync, copyFileSync, rmSync, mkdirSync } from 'node:fs';
+import { readFileSync, writeFileSync, renameSync, existsSync, copyFileSync, rmSync, mkdirSync, unlinkSync } from 'node:fs';
+import { execFileSync } from 'node:child_process';
 import { homedir } from 'node:os';
 import { join, dirname } from 'node:path';
 import { CLAUDE_SETTINGS, STATE_DIR } from './config.js';
 import { getConfig, configFileExists } from './settings.js';
+import { xmlEscape } from './notify.js';
 import { installGrokHooks, uninstallGrokHooks } from './agents/grok.js';
 import { UNSNOOZE_BIN } from './spawn.js';
 
@@ -27,10 +29,11 @@ const LEGACY_FENCES = [
 const OLD_FENCE_OPEN = LEGACY_FENCES[0].open;
 
 function parseArgs(rest) {
-  const opts = { yes: false, settings: CLAUDE_SETTINGS, zshrc: join(homedir(), '.zshrc'), purge: false };
+  const opts = { yes: false, settings: CLAUDE_SETTINGS, zshrc: join(homedir(), '.zshrc'), purge: false, daemon: false };
   for (let i = 0; i < rest.length; i++) {
     if (rest[i] === '--yes' || rest[i] === '-y') opts.yes = true;
     else if (rest[i] === '--purge') opts.purge = true;
+    else if (rest[i] === '--daemon') opts.daemon = true;
     else if (rest[i] === '--settings') opts.settings = rest[++i];
     else if (rest[i] === '--zshrc') opts.zshrc = rest[++i];
   }
@@ -124,6 +127,105 @@ export function installZshrcBlock(content, agents = ['claude']) {
   return { content: result, oldRemoved };
 }
 
+// --- daemon autostart ---
+// GUI sessions (VS Code extension, desktop apps) never pass through the shell
+// wrappers, so their limit stops are only caught while `unsnooze daemon` is
+// alive. Autostart keeps it alive: a launchd user agent on macOS, a systemd
+// user unit on Linux/WSL.
+
+export const DAEMON_LABEL = 'com.unsnooze.daemon';
+
+// Env overrides keep tests/e2e away from the real LaunchAgents / systemd dirs.
+function autostartDir(platform) {
+  if (platform === 'darwin') {
+    return process.env.UNSNOOZE_LAUNCH_AGENTS_DIR || join(homedir(), 'Library', 'LaunchAgents');
+  }
+  return process.env.UNSNOOZE_SYSTEMD_USER_DIR || join(homedir(), '.config', 'systemd', 'user');
+}
+
+export function launchdPlist({
+  nodeBin = process.execPath, unsnoozeBin = UNSNOOZE_BIN,
+  logFile = join(STATE_DIR, 'daemon.log'),
+} = {}) {
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>${DAEMON_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${xmlEscape(nodeBin)}</string>
+    <string>${xmlEscape(unsnoozeBin)}</string>
+    <string>daemon</string>
+  </array>
+  <key>RunAtLoad</key><true/>
+  <key>KeepAlive</key><true/>
+  <key>StandardOutPath</key><string>${xmlEscape(logFile)}</string>
+  <key>StandardErrorPath</key><string>${xmlEscape(logFile)}</string>
+</dict>
+</plist>
+`;
+}
+
+export function systemdUnit({ nodeBin = process.execPath, unsnoozeBin = UNSNOOZE_BIN } = {}) {
+  return `[Unit]
+Description=unsnooze daemon — watches GUI AI-coding sessions for limit stops
+
+[Service]
+ExecStart="${nodeBin}" "${unsnoozeBin}" daemon
+Restart=on-failure
+RestartSec=10
+
+[Install]
+WantedBy=default.target
+`;
+}
+
+function defaultActivate(cmd, args) {
+  try {
+    execFileSync(cmd, args, { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;   // best-effort: the file is in place; a reboot/login loads it
+  }
+}
+
+export function installDaemonAutostart({ platform = process.platform, dir = null, activate = defaultActivate } = {}) {
+  if (platform === 'darwin') {
+    const target = join(dir || autostartDir(platform), `${DAEMON_LABEL}.plist`);
+    atomicWrite(target, launchdPlist());
+    activate('launchctl', ['unload', target]);   // reload cleanly if already loaded
+    activate('launchctl', ['load', '-w', target]);
+    return target;
+  }
+  if (platform === 'linux') {
+    const target = join(dir || autostartDir(platform), 'unsnooze.service');
+    atomicWrite(target, systemdUnit());
+    activate('systemctl', ['--user', 'daemon-reload']);
+    activate('systemctl', ['--user', 'enable', '--now', 'unsnooze.service']);
+    return target;
+  }
+  return null;   // native Windows: no tmux to revive into — daemon unsupported
+}
+
+export function uninstallDaemonAutostart({ platform = process.platform, dir = null, activate = defaultActivate } = {}) {
+  if (platform === 'darwin') {
+    const target = join(dir || autostartDir(platform), `${DAEMON_LABEL}.plist`);
+    if (!existsSync(target)) return null;
+    activate('launchctl', ['unload', target]);
+    try { unlinkSync(target); } catch { /* already gone */ }
+    return target;
+  }
+  if (platform === 'linux') {
+    const target = join(dir || autostartDir(platform), 'unsnooze.service');
+    if (!existsSync(target)) return null;
+    activate('systemctl', ['--user', 'disable', '--now', 'unsnooze.service']);
+    try { unlinkSync(target); } catch { /* already gone */ }
+    return target;
+  }
+  return null;
+}
+
 // --- commands ---
 
 export function enabledAgents() {
@@ -185,6 +287,13 @@ export function cmdInstall(rest, { agents = enabledAgents() } = {}) {
     console.log(`unsnooze: wrappers (${agents.join(', ')}) installed in ${rc}${oldRemoved ? ' (legacy wrapper block removed)' : ''}`);
   }
 
+  // 4. Daemon autostart (GUI-session watching), opt-in via --daemon / wizard.
+  if (opts.daemon) {
+    const target = installDaemonAutostart();
+    if (target) console.log(`unsnooze: daemon autostart installed (${target}) — GUI sessions are watched`);
+    else console.log('unsnooze: daemon autostart is not supported on this platform');
+  }
+
   console.log('\nunsnooze: done. Reload your shell:');
   console.log('  exec $SHELL');
   return 0;
@@ -211,6 +320,9 @@ export function cmdUninstall(rest) {
     }
   }
 
+  const autostart = uninstallDaemonAutostart();
+  if (autostart) console.log(`unsnooze: daemon autostart removed (${autostart})`);
+
   if (opts.purge) {
     rmSync(STATE_DIR, { recursive: true, force: true });
     console.log(`unsnooze: state dir ${STATE_DIR} removed`);

package/src/notify.js

@@ -18,7 +18,7 @@ function appleScriptString(s) {
   return `"${s.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
 }
 
-function xmlEscape(s) {
+export function xmlEscape(s) {
   return s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
     .replace(/"/g, '&quot;').replace(/'/g, '&apos;');
 }

package/src/resumer.js

@@ -5,6 +5,7 @@
 // Exits when no non-terminal records remain; the next limit event respawns it.
 
 import { writeFileSync, readFileSync, unlinkSync, mkdirSync } from 'node:fs';
+import { homedir } from 'node:os';
 import * as realTmux from './tmux.js';
 import {
   RESUMER_LOCK, STATE_DIR, POLL_INTERVAL_MS, STAGGER_MS, VERIFY_DELAY_MS,
@@ -92,12 +93,21 @@ export async function dispatchOne(rec, { tmux = realTmux, resumeMessage, selfCmd
   }
 
   // Re-open path: new tmux window in the well-known session, resume by id.
+  // Records from sandboxed GUI sessions carry env (e.g. CLAUDE_CONFIG_DIR) the
+  // revived CLI needs to find its session store.
   const resume = agent.resumeArgs(rec.sessionId, resumeMessage);
-  const command = [...selfCmd, '_run', agent.id, ...resume.args].map(shellQuote).join(' ');
+  // `env K=V cmd`, not a bare `K=V cmd` prefix: the command runs in the
+  // user's default shell, and fish/nushell reject POSIX prefix assignments.
+  const envPrefix = rec.env
+    ? 'env ' + Object.entries(rec.env).map(([k, v]) => `${k}=${shellQuote(String(v))}`).join(' ') + ' '
+    : '';
+  const command = envPrefix + [...selfCmd, '_run', agent.id, ...resume.args].map(shellQuote).join(' ');
   setStatus(key, 'resuming', { lastAttemptAt: Date.now() });
   let newPane;
   try {
-    newPane = await tmux.newWindow(rec.tmuxSession || TMUX_SESSION_NAME, rec.cwd, command);
+    // cwd can be null on watcher records (unreadable rollout head) — execFile
+    // rejects null args, so fall back to the home dir rather than crash-loop.
+    newPane = await tmux.newWindow(rec.tmuxSession || TMUX_SESSION_NAME, rec.cwd || homedir(), command);
   } catch (err) {
     setStatus(key, 'stopped', { attempts: (rec.attempts || 0) + 1, lastError: `new-window: ${err.message}` });
     return 'failed';
@@ -153,20 +163,43 @@ export async function verifyOne(key, { tmux = realTmux } = {}) {
   }
   setStatus(key, 'resumed');
   log(`${key}: verified resumed`);
-  notify('unsnoozed ✅', `${rec.cwd} is running again`);
+  const fromGui = rec.origin && rec.origin !== 'cli';
+  notify('unsnoozed ✅', `${rec.cwd} is running again${fromGui ? ` (was in ${rec.origin} — revived in tmux)` : ''}`);
 }
 
-export async function runResumer({ tmux = realTmux, pollInterval = POLL_INTERVAL_MS } = {}) {
-  if (!acquireSingleton()) { log('another resumer is running — exiting'); return 0; }
+// persistent: never exit on an empty ledger (daemon mode — `unsnooze daemon`,
+// launchd/systemd). watcher: transcript watcher ticked every loop, so GUI
+// sessions are detected without a hook or pane. signal: clean shutdown.
+export async function runResumer({
+  tmux = realTmux, pollInterval = POLL_INTERVAL_MS,
+  persistent = false, watcher = null, signal = null,
+} = {}) {
+  // A transient hook-spawned resumer may hold the lock right now; a daemon
+  // outlives it, so wait for the lock instead of dying. The watcher MUST keep
+  // ticking during the wait: it only records stops (its own state lock covers
+  // that), and a stop left unread past the freshness window is lost for good.
+  const tickWatcher = async () => {
+    if (!watcher || !getConfig('guiWatch')) return;
+    try { await watcher.tick(); } catch (err) { log(`watcher tick failed: ${err.message}`); }
+  };
+  while (!acquireSingleton()) {
+    if (!persistent) { log('another resumer is running — exiting'); return 0; }
+    if (signal?.aborted) return 0;
+    await tickWatcher();
+    log('another resumer holds the lock — daemon waiting');
+    await sleep(pollInterval);
+  }
   updateState(state => { state.resumerPid = process.pid; });
-  log(`resumer started (pid ${process.pid})`);
+  log(`resumer started (pid ${process.pid}${persistent ? ', persistent' : ''})`);
   const deferCounts = new Map();
 
   try {
     for (;;) {
+      if (signal?.aborted) { log('shutdown requested — resumer exiting'); return 0; }
+      await tickWatcher();
       const stopped = activeStopped();
       const resuming = Object.values(readState().sessions).filter(s => s.status === 'resuming');
-      if (stopped.length === 0 && resuming.length === 0) {
+      if (stopped.length === 0 && resuming.length === 0 && !persistent) {
         log('no pending sessions — resumer exiting');
         return 0;
       }

package/src/settings.js

@@ -16,6 +16,7 @@ export const DEFAULTS = {
   autoResume: true,        // master switch: dispatch resumes when limits reset
   menuAutoAnswer: true,    // may unsnooze drive Claude's limit menu (send keys)?
   notifications: true,     // desktop notifications on detect/resume
+  guiWatch: true,          // daemon watches transcripts/rollouts for GUI-session stops
   resumeMessage: 'Continue where you left off. The session was interrupted by a usage limit which has now reset — pick up the task you were working on and finish it.',
   resumeMessages: { claude: '', codex: '', grok: '' },  // per-agent override; '' = use resumeMessage
   agents: { claude: true, codex: true, grok: false },   // grok is experimental
@@ -26,6 +27,7 @@ const ENV_NAMES = {
   autoResume: 'UNSNOOZE_AUTO_RESUME',
   menuAutoAnswer: 'UNSNOOZE_MENU_AUTO_ANSWER',
   notifications: 'UNSNOOZE_NOTIFICATIONS',
+  guiWatch: 'UNSNOOZE_GUI_WATCH',
   resumeMessage: 'UNSNOOZE_RESUME_MESSAGE',
   'resumeMessages.claude': 'UNSNOOZE_RESUME_MESSAGE_CLAUDE',
   'resumeMessages.codex': 'UNSNOOZE_RESUME_MESSAGE_CODEX',

package/src/state.js

@@ -111,11 +111,27 @@ export function upsertSession(record) {
 function findDuplicate(state, record) {
   if (record.sessionId && state.sessions[record.sessionId]) return record.sessionId;
   for (const [key, s] of Object.entries(state.sessions)) {
+    // Same sessionId living under a pane-based key (a scrape record that later
+    // learned its id through a merge).
+    if (record.sessionId && s.sessionId === record.sessionId) return key;
     if (s.pane && s.pane === record.pane
       && s.status === 'stopped'
       && Math.abs((s.detectedAt || 0) - record.detectedAt) < DEDUPE_WINDOW_MS) {
       return key;
     }
+    // A transcript/hook record with a sessionId matches a scrape record that
+    // never learned its id — same agent, same cwd, same detection window.
+    // Known trade-off: TWO different sessions of the same agent in the same
+    // cwd stopping within the window would wrongly merge — but a pane session
+    // writes the very transcript the watcher reads, so same-cwd evidence is
+    // almost always the same session, and the alternative (two records) would
+    // double-resume it.
+    if (record.sessionId && !s.sessionId
+      && s.agent === record.agent && s.cwd && s.cwd === record.cwd
+      && s.status === 'stopped'
+      && Math.abs((s.detectedAt || 0) - record.detectedAt) < DEDUPE_WINDOW_MS) {
+      return key;
+    }
   }
   return null;
 }

package/src/time-parser.js

@@ -9,6 +9,9 @@ const RELATIVE_TIME_REGEX = /(?:try again|wait|resets?\s+in)[:\s]\s*(?:for\s+)?(
 // "resets Tuesday 3pm" / "resets on Mon" — weekly limits carry a day name.
 const DAY_REGEX = /resets?\s+(?:on\s+)?(mon|tue|wed|thu|fri|sat|sun)[a-z]*/i;
 const DAY_INDEX = { sun: 0, mon: 1, tue: 2, wed: 3, thu: 4, fri: 5, sat: 6 };
+// Month-date weekly form (transcript/API error text):
+//   "resets Jul 4 at 12:30am (Asia/Calcutta)"
+const RESET_DATE_REGEX = /resets?\s+(?:on\s+)?(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)[a-z]*\s+(\d{1,2})(?:st|nd|rd|th)?(?:,?\s+\d{4})?\s+(?:at\s+)?(\d{1,2})(?::(\d{2}))?\s*(am|pm)?\s*(?:\(([^)]+)\))?/i;
 
 // Codex CLI forms ("try again at …", local time):
 //   same day:  "or try again at 3:51 PM."
@@ -50,6 +53,24 @@ export function parseResetTime(text) {
     };
   }
 
+  const resetDateMatch = text.match(RESET_DATE_REGEX);
+  if (resetDateMatch) {
+    const [, mon, dayOfMonth, hourRaw, minuteRaw, ampmRaw, timezone] = resetDateMatch;
+    const ampm = ampmRaw?.toLowerCase() || null;
+    let hour = parseInt(hourRaw, 10);
+    if (ampm === 'pm' && hour !== 12) hour += 12;
+    if (ampm === 'am' && hour === 12) hour = 0;
+    return {
+      month: MONTH_INDEX[mon.toLowerCase()],
+      dayOfMonth: parseInt(dayOfMonth, 10),
+      hour,
+      minute: minuteRaw ? parseInt(minuteRaw, 10) : 0,
+      timezone: timezone || null,
+      ambiguous: !ampm && hour >= 1 && hour <= 12,
+      day: null,
+    };
+  }
+
   const dayMatch = text.match(DAY_REGEX);
   const absMatch = text.match(RESET_TIME_REGEX);
   if (absMatch) {
@@ -120,16 +141,7 @@ export function resetAtMs(parsed, { marginMs = 60_000, fallbackMs = 5 * 3_600_00
   // UTC guess until it formats as the desired local h:m. Correction normalized
   // to [-720, +720] minutes to take the minimum-magnitude step (avoids the
   // off-by-a-day bug in high-offset timezones).
-  function targetTimestamp(h, m) {
-    const parts = new Intl.DateTimeFormat('en-US', {
-      timeZone: tz, year: 'numeric', month: '2-digit', day: '2-digit', hour12: false,
-    }).formatToParts(now);
-    const y = parseInt(parts.find(p => p.type === 'year').value);
-    const mo = parseInt(parts.find(p => p.type === 'month').value);
-    const d = parseInt(parts.find(p => p.type === 'day').value);
-
-    const targetStr = `${y}-${String(mo).padStart(2, '0')}-${String(d).padStart(2, '0')}T${String(h).padStart(2, '0')}:${String(m).padStart(2, '0')}:00`;
-    let candidate = new Date(targetStr + 'Z').getTime();
+  function correctWallClock(candidate, h, m) {
     for (let i = 0; i < 3; i++) {
       const fp = new Intl.DateTimeFormat('en-US', {
         timeZone: tz, hour: 'numeric', minute: 'numeric', hour12: false,
@@ -145,6 +157,18 @@ export function resetAtMs(parsed, { marginMs = 60_000, fallbackMs = 5 * 3_600_00
     return candidate;
   }
 
+  function targetTimestamp(h, m) {
+    const parts = new Intl.DateTimeFormat('en-US', {
+      timeZone: tz, year: 'numeric', month: '2-digit', day: '2-digit', hour12: false,
+    }).formatToParts(now);
+    const y = parseInt(parts.find(p => p.type === 'year').value);
+    const mo = parseInt(parts.find(p => p.type === 'month').value);
+    const d = parseInt(parts.find(p => p.type === 'day').value);
+
+    const targetStr = `${y}-${String(mo).padStart(2, '0')}-${String(d).padStart(2, '0')}T${String(h).padStart(2, '0')}:${String(m).padStart(2, '0')}:00`;
+    return correctWallClock(new Date(targetStr + 'Z').getTime(), h, m);
+  }
+
   function nextOccurrence(h, m) {
     let t = targetTimestamp(h, m);
     if (t <= now.getTime()) t += 86_400_000;
@@ -160,6 +184,45 @@ export function resetAtMs(parsed, { marginMs = 60_000, fallbackMs = 5 * 3_600_00
     return t;
   }
 
+  // Month-date form ("resets Jul 4 at 12:30am (tz)"): roll forward from today
+  // in the target tz to the named month/day, re-correct the wall-clock (the
+  // walk may cross DST). An already-past date means we misread stale text —
+  // fall back rather than waiting toward next year.
+  if (parsed.month != null) {
+    const monthDayAt = t => {
+      const fp = new Intl.DateTimeFormat('en-US', { timeZone: tz, month: 'numeric', day: 'numeric' })
+        .formatToParts(new Date(t));
+      return [
+        parseInt(fp.find(p => p.type === 'month').value, 10) - 1,
+        parseInt(fp.find(p => p.type === 'day').value, 10),
+      ];
+    };
+    const resolve = (h, m) => {
+      // Re-correct the wall clock on EVERY day step: a raw 24h jump across a
+      // DST transition drifts the local time, and a drifted probe can match
+      // the named date at the wrong instant (landing a day late after the
+      // final correction). The walk is capped just past the 10-day acceptance
+      // window below — longer walks are discarded anyway.
+      let t = targetTimestamp(h, m);
+      for (let i = 0; i <= 12; i++) {
+        const [mo, d] = monthDayAt(t);
+        if (mo === parsed.month && d === parsed.dayOfMonth) return t;
+        t = correctWallClock(t + 86_400_000, h, m);
+      }
+      return null;   // beyond the weekly window (or an impossible date)
+    };
+    const candidates = parsed.ambiguous
+      ? [resolve(parsed.hour, parsed.minute), resolve((parsed.hour + 12) % 24, parsed.minute)]
+      : [resolve(parsed.hour, parsed.minute)];
+    // The yearless form only ever names a date within the weekly window; a
+    // resolution further out means the date already passed and the walk landed
+    // on NEXT year's occurrence — that's a misread, not an 11-month wait.
+    const maxAhead = now.getTime() + 10 * 86_400_000;
+    const future = candidates.filter(t => t != null && t > now.getTime() && t <= maxAhead);
+    if (future.length === 0) return { at: now.getTime() + fallbackMs + marginMs, source: 'fallback' };
+    return { at: Math.min(...future) + marginMs, source };
+  }
+
   let at;
   if (parsed.ambiguous) {
     const t1 = nextOccurrence(parsed.hour, parsed.minute);

package/src/watcher.js

@@ -0,0 +1,333 @@
+// Session-file watcher — the tmux-free detection channel. Tails the files the
+// agent CLIs already write (Claude Code transcripts, Codex rollouts) for
+// limit-stop evidence, so sessions running in GUI surfaces (VS Code extension,
+// desktop apps) are tracked even though there is no pane to scrape and no
+// shell wrapper in the launch path. Records land in the same ledger with
+// pane-less records the resumer already reopens by session id.
+//
+// Offset semantics: on a cold start (no offsets file) every existing file
+// starts at EOF — history is never replayed as fresh stops. Files that appear
+// later are read from the start (a stop that happened while the daemon was
+// down is still a real stop); the freshness window drops anything old.
+
+import {
+  readdirSync, statSync, readFileSync, writeFileSync, renameSync, mkdirSync,
+  openSync, readSync, closeSync, existsSync,
+} from 'node:fs';
+import { join, sep, basename, dirname } from 'node:path';
+import { homedir } from 'node:os';
+import {
+  CLAUDE_DIR, CODEX_DIR, WATCH_OFFSETS_FILE, WATCH_FRESHNESS_MS,
+  RESET_MARGIN_MS, FALLBACK_RESET_MS, TMUX_SESSION_NAME,
+} from './config.js';
+import { parseTranscriptLine } from './watchers/claude.js';
+import { parseRolloutLine, rolloutMeta } from './watchers/codex.js';
+import { ROLLOUT_RE } from './agents/codex.js';
+import { parseResetTime, resetAtMs } from './time-parser.js';
+import { upsertSession, readState, updateState } from './state.js';
+import { getConfig } from './settings.js';
+import { notify } from './notify.js';
+import { makeLogger } from './logger.js';
+
+const log = makeLogger('watcher');
+
+const MAX_WALK_DEPTH = 8;
+// A file first seen mid-run is read from the start, but never more than this —
+// a giant transcript is history, and the freshness window drops it anyway.
+const MAX_READ_BYTES = 10 * 1024 * 1024;
+
+export function claudeSource({ roots }) {
+  return {
+    agent: 'claude',
+    roots,
+    enabled: () => getConfig('agents.claude'),
+    // Subagent transcripts live under <session>/subagents/ — their limit
+    // entries duplicate the parent session's own entry.
+    match: p => p.endsWith('.jsonl') && !p.split(sep).includes('subagents'),
+    parse(lines) {
+      return lines
+        .map(parseTranscriptLine)
+        .filter(Boolean)
+        .map(rec => ({
+          agent: 'claude',
+          sessionId: rec.sessionId,
+          cwd: rec.cwd,
+          limitType: rec.limitType,
+          resetLine: rec.resetLine,
+          resetAt: null,
+          origin: rec.entrypoint,
+          timestampMs: rec.timestampMs,
+        }));
+    },
+  };
+}
+
+export function codexSource({ roots }) {
+  return {
+    agent: 'codex',
+    roots,
+    enabled: () => getConfig('agents.codex'),
+    match: p => ROLLOUT_RE.test(basename(p)),
+    parse(lines, path) {
+      const hits = lines.map(parseRolloutLine).filter(Boolean);
+      if (hits.length === 0) return [];
+      const last = hits[hits.length - 1];   // the latest snapshot governs
+      const meta = rolloutMeta(path);
+      return [{
+        agent: 'codex',
+        sessionId: meta.sessionId,
+        cwd: meta.cwd,
+        limitType: last.limitType,
+        resetLine: null,
+        resetAt: last.resetAt,
+        origin: meta.originator,
+        timestampMs: last.timestampMs,
+      }];
+    },
+  };
+}
+
+// Claude desktop (cowork) sessions are sandboxed: each runs against an
+// isolated CLAUDE_CONFIG_DIR at <session>/local_<id>/.claude, so the global
+// hook never fires and the transcripts live outside ~/.claude. Reviving one
+// needs that same CLAUDE_CONFIG_DIR exported — carried on the record as env —
+// plus CLAUDE_SECURESTORAGE_CONFIG_DIR='' so auth stays on the DEFAULT
+// keychain entry: the service name is otherwise derived from the config dir,
+// and the sandbox holds no credentials (verified against a real cowork
+// session: with the pair set, `claude -p --resume <id>` answers; without the
+// override it dies with "Not logged in").
+// Experimental: desktop worktree/VM sessions may still differ.
+export function claudeDesktopSource({ roots }) {
+  const base = claudeSource({ roots });
+  return {
+    ...base,
+    parse(lines, path) {
+      const configDir = configDirFromPath(path);
+      return base.parse(lines, path).map(rec => ({
+        ...rec,
+        origin: 'desktop',
+        env: configDir
+          ? { CLAUDE_CONFIG_DIR: configDir, CLAUDE_SECURESTORAGE_CONFIG_DIR: '' }
+          : undefined,
+      }));
+    },
+  };
+}
+
+function configDirFromPath(path) {
+  const marker = `${sep}.claude${sep}`;
+  const idx = path.indexOf(marker);
+  return idx === -1 ? null : path.slice(0, idx + marker.length - 1);
+}
+
+export function defaultSources() {
+  const sources = [
+    claudeSource({ roots: [join(CLAUDE_DIR, 'projects')] }),
+    codexSource({ roots: [join(CODEX_DIR, 'sessions')] }),
+  ];
+  if (process.platform === 'darwin') {
+    sources.push(claudeDesktopSource({
+      roots: [process.env.UNSNOOZE_CLAUDE_DESKTOP_DIR
+        || join(homedir(), 'Library', 'Application Support', 'Claude', 'local-agent-mode-sessions')],
+    }));
+  }
+  return sources;
+}
+
+// Turn a watcher candidate into a ledger record. No pane key at all — a merge
+// into an existing scrape/hook record must never clobber a live pane id.
+//
+// The same stop is re-emitted whenever the CLI appends another limit line (a
+// GUI auto-retry, or the revived session hitting the still-active limit), so
+// an existing record's lifecycle must be respected: an active record only
+// gets its reset time refreshed — never its status/attempts reset, or the
+// MAX_RESUME_ATTEMPTS cap could never bind — and a cancelled record stays
+// cancelled.
+export function dispatchCandidate(c) {
+  const detectedAt = c.timestampMs || Date.now();
+  let at, source;
+  if (c.resetAt) {
+    at = c.resetAt + RESET_MARGIN_MS;
+    source = 'absolute';
+  } else {
+    ({ at, source } = resetAtMs(parseResetTime(c.resetLine), {
+      marginMs: RESET_MARGIN_MS, fallbackMs: FALLBACK_RESET_MS,
+    }));
+  }
+
+  const existing = c.sessionId
+    ? Object.values(readState().sessions).find(s => s.sessionId === c.sessionId)
+    : null;
+  if (existing && existing.status === 'cancelled') return;
+  if (existing && (existing.status === 'stopped' || existing.status === 'resuming')) {
+    updateState(state => {
+      const s = state.sessions[existing.key];
+      if (s && (s.status === 'stopped' || s.status === 'resuming')) {
+        s.resetAt = at;
+        s.resetSource = source;
+        if (c.limitType && c.limitType !== 'unknown') s.limitType = c.limitType;
+      }
+    });
+    log(`refreshed reset for tracked stop: session=${c.sessionId} resetAt=${new Date(at).toISOString()}`);
+    return;
+  }
+
+  const record = {
+    sessionId: c.sessionId || null,
+    cwd: c.cwd || null,
+    agent: c.agent,
+    origin: c.origin || null,
+    tmuxSession: TMUX_SESSION_NAME,
+    status: 'stopped',
+    limitType: c.limitType || 'unknown',
+    detectedVia: 'transcript',
+    detectedAt,
+    resetAt: at,
+    resetSource: source,
+    attempts: 0,
+    lastAttemptAt: null,
+    lastError: null,
+  };
+  if (c.env) record.env = c.env;   // e.g. CLAUDE_CONFIG_DIR for sandboxed desktop sessions
+  upsertSession(record);
+  log(`limit stop via transcript: agent=${c.agent} session=${c.sessionId || '?'} origin=${c.origin || '?'} resetAt=${new Date(at).toISOString()} (${source})`);
+  notify('limit hit 😴', `${c.cwd || c.agent}: tracked — resumes when the limit resets`);
+}
+
+function loadOffsets(path) {
+  try {
+    const parsed = JSON.parse(readFileSync(path, 'utf-8'));
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+function readRange(path, from, to) {
+  let fd;
+  try {
+    fd = openSync(path, 'r');
+    const len = Math.min(to - from, MAX_READ_BYTES);
+    const buf = Buffer.alloc(len);
+    let read = 0;
+    while (read < len) {
+      const n = readSync(fd, buf, read, len - read, from + read);
+      if (n <= 0) break;
+      read += n;
+    }
+    return buf.subarray(0, read);
+  } catch {
+    return Buffer.alloc(0);
+  } finally {
+    if (fd !== undefined) closeSync(fd);
+  }
+}
+
+export function createWatcher({
+  sources = defaultSources(),
+  offsetsPath = WATCH_OFFSETS_FILE,
+  freshnessMs = WATCH_FRESHNESS_MS,
+  onStop = dispatchCandidate,
+  now = Date.now,
+} = {}) {
+  let offsets = loadOffsets(offsetsPath);
+  let coldStart = offsets === null;
+  if (coldStart) offsets = {};
+  let dirty = coldStart;
+
+  function setOffset(path, value) {
+    if (offsets[path] !== value) { offsets[path] = value; dirty = true; }
+  }
+
+  function saveOffsets(seen) {
+    // Unseen ≠ gone: a source may be disabled this tick or a root transiently
+    // unreadable — wiping those offsets would replay history on re-enable.
+    // Only forget files that no longer exist.
+    for (const key of Object.keys(offsets)) {
+      if (!seen.has(key) && !existsSync(key)) { delete offsets[key]; dirty = true; }
+    }
+    if (!dirty) return;
+    try {
+      mkdirSync(dirname(offsetsPath), { recursive: true });
+      const tmp = join(dirname(offsetsPath), `.offsets.tmp.${process.pid}`);
+      writeFileSync(tmp, JSON.stringify(offsets));
+      renameSync(tmp, offsetsPath);
+      dirty = false;
+    } catch (err) {
+      log(`offsets save failed: ${err.message}`);
+    }
+  }
+
+  // Appended complete lines since the last tick, advancing the stored offset.
+  // All offset math in bytes (a \n byte can't occur inside a multibyte char).
+  function readAppended(path) {
+    let size;
+    try { size = statSync(path).size; } catch { return null; }
+    const known = Object.prototype.hasOwnProperty.call(offsets, path);
+    let offset;
+    if (!known) {
+      if (coldStart) { setOffset(path, size); return null; }
+      offset = Math.max(0, size - MAX_READ_BYTES);
+    } else {
+      offset = offsets[path];
+    }
+    // Nothing new, or rewritten shorter (rotate/truncate) — pin to EOF.
+    if (size <= offset) { setOffset(path, size); return null; }
+    const buf = readRange(path, offset, size);
+    const lastNl = buf.lastIndexOf(0x0a);
+    if (lastNl === -1) { setOffset(path, offset); return null; }  // partial line — wait
+    setOffset(path, offset + lastNl + 1);
+    return buf.subarray(0, lastNl + 1).toString('utf-8').split('\n').filter(l => l.trim());
+  }
+
+  function walk(dir, depth, cb) {
+    let entries;
+    try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return; }
+    for (const e of entries) {
+      const p = join(dir, e.name);
+      if (e.isDirectory()) {
+        if (depth < MAX_WALK_DEPTH) walk(p, depth + 1, cb);
+        continue;
+      }
+      if (e.isFile()) cb(p);
+    }
+  }
+
+  return {
+    async tick() {
+      const seen = new Set();
+      const candidates = [];
+      for (const source of sources) {
+        if (source.enabled && !source.enabled()) continue;
+        for (const root of source.roots) {
+          walk(root, 0, path => {
+            if (!source.match(path)) return;
+            seen.add(path);
+            const lines = readAppended(path);
+            if (!lines || lines.length === 0) return;
+            try {
+              candidates.push(...source.parse(lines, path));
+            } catch (err) {
+              log(`parse error in ${path}: ${err.message}`);
+            }
+          });
+        }
+      }
+      coldStart = false;
+      saveOffsets(seen);
+      // Strict freshness: a candidate without a parseable timestamp cannot be
+      // dated, and dispatching it risks reviving a long-finished session (the
+      // offsets can legitimately replay old lines after a file reappears).
+      // Every real transcript/rollout line carries an ISO timestamp.
+      const fresh = [];
+      for (const c of candidates) {
+        if (Number.isFinite(c.timestampMs) && now() - c.timestampMs <= freshnessMs) fresh.push(c);
+        else log(`dropped stale/undatable candidate: agent=${c.agent} session=${c.sessionId || '?'} ts=${c.timestampMs}`);
+      }
+      for (const c of fresh) {
+        try { onStop(c); } catch (err) { log(`onStop failed: ${err.message}`); }
+      }
+      return fresh.length;
+    },
+  };
+}

package/src/watchers/claude.js

@@ -0,0 +1,39 @@
+// Claude Code transcript watcher: parses lines appended to session transcript
+// files (~/.claude/projects/<dashed-cwd>/<session-id>.jsonl) into limit-stop
+// candidates. This is the detection channel for GUI surfaces (VS Code
+// extension, desktop app) where no tmux pane exists and hooks may not fire —
+// a rate-limit stop lands in the transcript as a structured API-error entry:
+//   { "error":"rate_limit", "isApiErrorMessage":true, "apiErrorStatus":429,
+//     "entrypoint":"cli", "cwd":..., "sessionId":...,
+//     "message":{"content":[{"type":"text","text":"You've hit your session
+//       limit · resets 6:40pm (Asia/Calcutta)"}]} }
+
+import { detectLimit } from '../patterns.js';
+import { patterns } from '../agents/claude.js';
+import { PANE_SCAN_LINES } from '../config.js';
+
+// One transcript JSONL line → limit-stop candidate or null. Sidechain
+// (subagent) entries are skipped — the resume target is the parent session,
+// whose own entry carries the same error.
+export function parseTranscriptLine(line) {
+  if (!line || !line.trim()) return null;
+  let entry;
+  try { entry = JSON.parse(line); } catch { return null; }
+  if (!entry || entry.isApiErrorMessage !== true) return null;
+  if (entry.error !== 'rate_limit') return null;
+  if (entry.isSidechain) return null;
+
+  const content = entry.message?.content;
+  const text = (Array.isArray(content) && content.find(c => c?.type === 'text')?.text) || '';
+  const d = detectLimit(text, PANE_SCAN_LINES, patterns);
+  const ts = entry.timestamp ? Date.parse(entry.timestamp) : NaN;
+
+  return {
+    sessionId: entry.sessionId || null,
+    cwd: entry.cwd || null,
+    entrypoint: entry.entrypoint || null,
+    limitType: d.hit ? d.limitType : 'unknown',
+    resetLine: d.hit ? d.resetLine : null,
+    timestampMs: Number.isFinite(ts) ? ts : null,
+  };
+}

package/src/watchers/codex.js

@@ -0,0 +1,106 @@
+// Codex rollout watcher: parses lines appended to session rollout files
+// (~/.codex/sessions/YYYY/MM/DD/rollout-*.jsonl) into limit-stop candidates.
+//
+// Codex never persists Error/StreamError events to rollouts (confirmed in
+// codex-rs/rollout policy), so the limit banner text is NOT in the file. What
+// IS persisted is a token_count event per turn carrying a rate_limits
+// snapshot — used_percent per window plus an exact resets_at epoch:
+//   {"type":"event_msg","payload":{"type":"token_count","rate_limits":{
+//     "primary":{"used_percent":100,"window_minutes":300,"resets_at":1778672230},
+//     "secondary":{"used_percent":1,"window_minutes":10080,"resets_at":...},
+//     "rate_limit_reached_type":null}}}
+// That epoch is more precise than any scraped banner, and rollouts are shared
+// by every Codex surface (CLI, IDE extension, desktop app).
+
+import { openSync, readSync, closeSync } from 'node:fs';
+import { basename } from 'node:path';
+import { ROLLOUT_RE } from '../agents/codex.js';
+
+const WEEK_MINUTES = 7 * 1440;
+
+function windowLimitType(windowMinutes) {
+  if (!Number.isFinite(windowMinutes)) return 'unknown';
+  return windowMinutes >= WEEK_MINUTES ? 'weekly' : '5h';
+}
+
+// One rollout JSONL line → limit-stop candidate or null. A window binds when
+// its used_percent hits 100 (or rate_limit_reached_type says the model was
+// actually blocked); with several exhausted windows the LATEST reset governs —
+// resuming at the earlier one would immediately re-hit the other limit.
+export function parseRolloutLine(line) {
+  if (!line || !line.trim()) return null;
+  let entry;
+  try { entry = JSON.parse(line); } catch { return null; }
+  if (entry?.type !== 'event_msg' || entry.payload?.type !== 'token_count') return null;
+  const rl = entry.payload.rate_limits;
+  if (!rl || typeof rl !== 'object') return null;
+
+  const windows = ['primary', 'secondary']
+    .map(k => rl[k])
+    .filter(w => w && typeof w === 'object');
+  let binding = null;
+  const exhausted = windows.filter(w => (w.used_percent ?? 0) >= 100);
+  if (exhausted.length > 0) {
+    binding = exhausted.reduce((a, b) => ((b.resets_at || 0) > (a.resets_at || 0) ? b : a));
+  } else if (rl.rate_limit_reached_type) {
+    const named = rl[rl.rate_limit_reached_type];
+    binding = (named && typeof named === 'object')
+      ? named
+      : windows.reduce((a, b) => ((b.resets_at || 0) > (a?.resets_at || 0) ? b : a), null);
+  }
+  if (!binding) return null;
+
+  const ts = entry.timestamp ? Date.parse(entry.timestamp) : NaN;
+  return {
+    limitType: windowLimitType(binding.window_minutes),
+    resetAt: binding.resets_at ? binding.resets_at * 1000 : null,
+    reachedType: rl.rate_limit_reached_type || null,
+    timestampMs: Number.isFinite(ts) ? ts : null,
+  };
+}
+
+// The session_meta head line can be very long (it embeds the full base
+// instructions) — read in chunks until the first newline.
+function readFirstLine(path, maxBytes = 256 * 1024) {
+  let fd;
+  try {
+    fd = openSync(path, 'r');
+    const chunk = Buffer.alloc(16 * 1024);
+    let head = '';
+    let pos = 0;
+    while (pos < maxBytes) {
+      const n = readSync(fd, chunk, 0, chunk.length, pos);
+      if (n <= 0) break;
+      head += chunk.toString('utf-8', 0, n);
+      pos += n;
+      const nl = head.indexOf('\n');
+      if (nl !== -1) return head.slice(0, nl);
+    }
+    return head;
+  } catch {
+    return '';
+  } finally {
+    if (fd !== undefined) closeSync(fd);
+  }
+}
+
+// Session identity for a rollout file: the session_meta head line when
+// parseable, else the uuid embedded in the filename.
+export function rolloutMeta(path) {
+  let sessionId = null;
+  let cwd = null;
+  let originator = null;
+  try {
+    const meta = JSON.parse(readFirstLine(path));
+    if (meta?.type === 'session_meta') {
+      sessionId = meta.payload?.id || null;
+      cwd = meta.payload?.cwd || null;
+      originator = meta.payload?.originator || null;
+    }
+  } catch { /* unreadable head — fall back to the filename */ }
+  if (!sessionId) {
+    const m = basename(path).match(ROLLOUT_RE);
+    if (m) sessionId = m[1];
+  }
+  return { sessionId, cwd, originator };
+}

package/src/wizard.js

@@ -69,6 +69,20 @@ export async function runWizard() {
   });
   if (p.isCancel(notifications)) return cancelled();
 
+  // GUI watching: only meaningful where an autostart daemon can run.
+  let guiWatch = false;
+  if (process.platform === 'darwin' || process.platform === 'linux') {
+    const answer = await p.confirm({
+      message: 'Also guard GUI sessions (Claude Code in VS Code/desktop, Codex app/IDE)?\n'
+        + '  Installs a small background daemon (launchd/systemd) that watches session\n'
+        + '  files for limit stops; revived sessions open in tmux and stay visible in\n'
+        + '  the GUI\'s own history.',
+      initialValue: DEFAULTS.guiWatch,
+    });
+    if (p.isCancel(answer)) return cancelled();
+    guiWatch = answer;
+  }
+
   // Seed message prompts from the existing config so a setup re-run shows —
   // and keeps — values previously set here or via `unsnooze config`.
   const existing = readFileConfig();
@@ -116,7 +130,7 @@ export async function runWizard() {
   // doesn't ask about (e.g. per-agent messages set via `unsnooze config`).
   writeConfig({
     ...existing,
-    autoResume, menuAutoAnswer, notifications, resumeMessage,
+    autoResume, menuAutoAnswer, notifications, guiWatch, resumeMessage,
     resumeMessages: { ...existingMsgs, ...resumeMessages },
     agents: Object.fromEntries(listAgents().map(a => [a.id, agents.includes(a.id)])),
   });
@@ -124,7 +138,7 @@ export async function runWizard() {
   const s = p.spinner();
   s.start('Installing shell wrappers and hooks');
   const { cmdInstall } = await import('./install.js');
-  const code = cmdInstall(['--yes']);
+  const code = cmdInstall(guiWatch ? ['--yes', '--daemon'] : ['--yes']);
   s.stop(code === 0 ? 'Wrappers and hooks installed' : 'Install hit a problem — see output above');
 
   p.outro(code === 0