unsnooze 1.0.0

package/src/logger.js

@@ -0,0 +1,23 @@
+import { appendFileSync, mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { LOG_FILE } from './config.js';
+
+let dirReady = false;
+
+export function log(component, message) {
+  const line = `${new Date().toISOString()} [${component}] ${message}\n`;
+  try {
+    if (!dirReady) {
+      mkdirSync(dirname(LOG_FILE), { recursive: true });
+      dirReady = true;
+    }
+    appendFileSync(LOG_FILE, line);
+  } catch {
+    // Logging must never crash the hook or monitor paths.
+  }
+  if (process.env.UNSNOOZE_DEBUG) process.stderr.write(line);
+}
+
+export function makeLogger(component) {
+  return (message) => log(component, message);
+}

package/src/monitor.js

@@ -0,0 +1,199 @@
+// Per-pane watcher (`unsnooze _monitor <pane>`), spawned detached by the launcher.
+// Responsibilities:
+//   - scrape the pane every SCRAPE_INTERVAL_MS for a live limit banner or the
+//     /rate-limit-options menu; on limit → record in state + spawn resumer
+//   - consume overload event markers from the StopFailure hook and run the
+//     seconds-scale backoff retry ladder (never touches state.json)
+//   - flip a tracked record to 'resumed' if the user/resumer got things moving
+//   - exit when the pane dies
+// tmux + timers are injectable for tests.
+
+import { readFileSync, unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+import * as realTmux from './tmux.js';
+import {
+  SCRAPE_INTERVAL_MS, PANE_SCAN_LINES, CAPTURE_LINES, EVENTS_DIR,
+  EVENT_MARKER_TTL_MS, OVERLOAD_BACKOFF_S, OVERLOAD_JITTER,
+  FALLBACK_RESET_MS, RESET_MARGIN_MS, TMUX_SESSION_NAME,
+} from './config.js';
+import { detectLimit, isBusy, overloadMatch } from './patterns.js';
+import { getAgent } from './agents/index.js';
+import { getConfig } from './settings.js';
+import { notify } from './notify.js';
+import { parseResetTime, resetAtMs } from './time-parser.js';
+import { upsertSession, setStatus, readState } from './state.js';
+import { spawnResumerIfNeeded } from './spawn.js';
+import { makeLogger } from './logger.js';
+
+const log = makeLogger('monitor');
+
+const sleep = ms => new Promise(r => setTimeout(r, ms));
+
+export function createMonitor({ pane, cwd, agent = getAgent('claude'), tmux = realTmux, scrapeInterval = SCRAPE_INTERVAL_MS }) {
+  let trackedKey = null;      // state key of the record we created
+  let overloadAttempt = 0;
+  let running = true;
+
+  function markerPath() {
+    return join(EVENTS_DIR, `${pane.replace(/[^%\w]/g, '_')}.json`);
+  }
+
+  function consumeMarker() {
+    try {
+      const marker = JSON.parse(readFileSync(markerPath(), 'utf-8'));
+      unlinkSync(markerPath());
+      if (Date.now() - marker.at > EVENT_MARKER_TTL_MS) return null;   // stale
+      return marker;
+    } catch {
+      return null;
+    }
+  }
+
+  async function recordLimit(resetLine, limitType, via) {
+    const detectedAt = Date.now();
+    const { at, source } = resetAtMs(parseResetTime(resetLine), {
+      marginMs: RESET_MARGIN_MS, fallbackMs: FALLBACK_RESET_MS,
+    });
+    const sessionId = agent.latestSessionId(cwd, detectedAt);
+    const state = upsertSession({
+      sessionId, cwd, pane, agent: agent.id, tmuxSession: TMUX_SESSION_NAME,
+      status: 'stopped', limitType, detectedVia: via, detectedAt,
+      resetAt: at, resetSource: source,
+      attempts: 0, lastAttemptAt: null, lastError: null,
+    });
+    trackedKey = sessionId
+      || Object.values(state.sessions).find(s => s.pane === pane && s.status === 'stopped')?.key
+      || null;
+    log(`pane ${pane}: limit recorded (${limitType}, via ${via}), resets ${new Date(at).toISOString()}`);
+    notify(`${agent.name} hit a usage limit`, `${cwd} — auto-resume at ${new Date(at).toLocaleTimeString()}`);
+    spawnResumerIfNeeded();
+  }
+
+  async function driveMenu(text) {
+    const steps = agent.menu.stepsToWait(text, PANE_SCAN_LINES);
+    if (steps === null) {
+      log(`pane ${pane}: rate-limit menu unreadable — NOT pressing Enter`);
+      return false;
+    }
+    const key = steps > 0 ? 'Down' : 'Up';
+    for (let i = 0; i < Math.abs(steps); i++) {
+      await tmux.sendKey(pane, key);
+      await sleep(120);
+    }
+    await tmux.sendKey(pane, 'Enter');
+    log(`pane ${pane}: selected "Stop and wait for limit to reset" (${steps} steps)`);
+    await sleep(1000);
+    // After selection the TUI prints the limit banner — next scrape records it.
+    return true;
+  }
+
+  async function handleOverload() {
+    if (overloadAttempt >= OVERLOAD_BACKOFF_S.length) {
+      log(`pane ${pane}: overload retries exhausted`);
+      overloadAttempt = 0;   // reset ladder; next marker starts fresh
+      return;
+    }
+    const base = OVERLOAD_BACKOFF_S[overloadAttempt] * 1000;
+    const jitter = base * OVERLOAD_JITTER * (Math.random() * 2 - 1);
+    const wait = Math.round(base + jitter);
+    overloadAttempt++;
+    log(`pane ${pane}: overload — retry ${overloadAttempt}/${OVERLOAD_BACKOFF_S.length} in ${Math.round(wait / 1000)}s`);
+    await sleep(wait);
+    if (!running) return;
+    const text = await tmux.capturePane(pane, CAPTURE_LINES).catch(() => null);
+    if (text === null) return;
+    if (isBusy(text, agent.patterns.busyPatterns)) { log(`pane ${pane}: busy after overload wait — skip inject`); return; }
+    if (!overloadMatch(text, agent.patterns.overloadPatterns)) { overloadAttempt = 0; return; }   // recovered on its own
+    await tmux.sendText(pane, 'Continue where you left off. The previous attempt failed with a transient API error.');
+    log(`pane ${pane}: overload retry message sent`);
+  }
+
+  async function tick() {
+    if (!(await tmux.paneAlive(pane))) {
+      log(`pane ${pane}: gone — monitor exiting (record persists for resumer)`);
+      running = false;
+      return;
+    }
+
+    const marker = consumeMarker();
+    let text;
+    try {
+      text = await tmux.capturePane(pane, CAPTURE_LINES);
+    } catch {
+      return;   // transient capture failure
+    }
+
+    // Interactive menu takes priority — it blocks the session until answered.
+    // Checked against the VISIBLE screen only: a menu in scrollback history
+    // was already answered, and re-driving it would inject stray keys.
+    const visible = tmux.capturePaneVisible
+      ? await tmux.capturePaneVisible(pane).catch(() => '')
+      : text;
+    if (agent.menu && agent.menu.isPrompt(visible, PANE_SCAN_LINES)) {
+      if (!getConfig('menuAutoAnswer')) {
+        // Watch-only mode: record the stop (reset time may not be visible
+        // until the menu is answered — fallback covers that), touch nothing.
+        const state = readState();
+        const existing = trackedKey && state.sessions[trackedKey];
+        if (!existing || existing.status !== 'stopped') {
+          const d = detectLimit(text, PANE_SCAN_LINES, agent.patterns);
+          log(`pane ${pane}: limit menu detected but menuAutoAnswer is off — recording only`);
+          await recordLimit(d.hit ? d.resetLine : null, d.hit ? d.limitType : 'unknown', 'scrape');
+        }
+        return;
+      }
+      await driveMenu(visible);
+      return;
+    }
+
+    const d = detectLimit(text, PANE_SCAN_LINES, agent.patterns);
+    if (d.hit) {
+      const state = readState();
+      const existing = trackedKey && state.sessions[trackedKey];
+      if (!existing || existing.status !== 'stopped') {
+        await recordLimit(d.resetLine, d.limitType, marker ? 'hook' : 'scrape');
+      }
+      return;
+    }
+
+    // No banner. If we were tracking a stopped record and claude is active
+    // again, someone resumed it (user or resumer) — mark it.
+    if (trackedKey) {
+      const state = readState();
+      const rec = state.sessions[trackedKey];
+      if (rec && rec.status === 'stopped') {
+        setStatus(trackedKey, 'resumed', { lastAttemptAt: Date.now() });
+        log(`pane ${pane}: banner cleared, ${trackedKey} marked resumed`);
+      }
+      if (rec && rec.status !== 'stopped') trackedKey = null;
+    }
+
+    // Overload marker (banner-less path).
+    if (marker && marker.kind === 'overload') {
+      await handleOverload();
+    } else if (!marker && overloadMatch(text, agent.patterns.overloadPatterns) && !isBusy(text, agent.patterns.busyPatterns)) {
+      await handleOverload();
+    }
+  }
+
+  return {
+    async run() {
+      log(`monitor started for pane ${pane} (cwd ${cwd})`);
+      while (running) {
+        await tick();
+        if (!running) break;
+        await sleep(scrapeInterval);
+      }
+    },
+    stop() { running = false; },
+    _tick: tick,   // exposed for tests
+    get trackedKey() { return trackedKey; },
+  };
+}
+
+export async function runMonitor(pane, agentId) {
+  const cwd = process.env.UNSNOOZE_CWD || process.cwd();
+  const monitor = createMonitor({ pane, cwd, agent: getAgent(agentId) });
+  await monitor.run();
+  return 0;
+}

package/src/notify.js

@@ -0,0 +1,63 @@
+// Desktop notifications — fire-and-forget, zero deps, never blocks or throws
+// (detection and resume paths must not care whether a notifier exists).
+// macOS: osascript. Linux: notify-send. WSL & native Windows: powershell.exe
+// toast (notify-send rarely exists inside WSL; powershell.exe always does).
+// Fallback: tmux status-line message.
+
+import { spawn } from 'node:child_process';
+import { release as osRelease } from 'node:os';
+import { getConfig } from './settings.js';
+
+function defaultSpawner(cmd, args) {
+  const child = spawn(cmd, args, { detached: true, stdio: 'ignore' });
+  child.on('error', () => { /* notifier missing — silently drop */ });
+  child.unref();
+}
+
+function appleScriptString(s) {
+  return `"${s.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+}
+
+function xmlEscape(s) {
+  return s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;').replace(/'/g, '&apos;');
+}
+
+export function isWsl(platform = process.platform, release = osRelease()) {
+  return platform === 'linux' && /microsoft/i.test(release);
+}
+
+// Windows toast without any module: raise it through PowerShell's own AppId
+// (unregistered AppIds get their toasts dropped on recent Windows builds).
+const PS_APP_ID = '{1AC14E77-02E7-4E5D-B744-2EB1AE5198B7}\\WindowsPowerShell\\v1.0\\powershell.exe';
+
+function powershellToast(spawner, title, message) {
+  const xml = `<toast><visual><binding template="ToastGeneric"><text>${xmlEscape(title)}</text><text>${xmlEscape(message)}</text></binding></visual></toast>`;
+  const script = [
+    `[Windows.UI.Notifications.ToastNotificationManager, Windows.UI.Notifications, ContentType = WindowsRuntime] > $null;`,
+    `$xml = New-Object Windows.Data.Xml.Dom.XmlDocument;`,
+    `$xml.LoadXml('${xml.replace(/'/g, "''")}');`,
+    `[Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier('${PS_APP_ID}').Show([Windows.UI.Notifications.ToastNotification]::new($xml));`,
+  ].join(' ');
+  spawner('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', script]);
+}
+
+export function notify(title, message, {
+  platform = process.platform,
+  wsl = isWsl(platform),
+  spawner = defaultSpawner,
+} = {}) {
+  try {
+    if (!getConfig('notifications')) return;
+    if (platform === 'darwin') {
+      spawner('osascript', ['-e',
+        `display notification ${appleScriptString(message)} with title ${appleScriptString(title)}`]);
+    } else if (platform === 'win32' || wsl) {
+      powershellToast(spawner, title, message);
+    } else if (platform === 'linux') {
+      spawner('notify-send', ['-a', 'unsnooze', title, message]);
+    } else if (process.env.TMUX) {
+      spawner('tmux', ['display-message', `${title}: ${message}`]);
+    }
+  } catch { /* never let a notification break the caller */ }
+}

package/src/patterns.js

@@ -0,0 +1,109 @@
+// Detection ENGINE for usage-limit banners in tmux pane text. Agent-agnostic:
+// every regex set comes from an agent adapter (src/agents/*), with claude as
+// the default so pre-adapter call sites keep working.
+//
+// Detection requires a "limit" line AND a "resets" line within PROXIMITY lines
+// of each other, scanning only the tail of the pane (a live banner sits at the
+// prompt; the same words in scrollback are history, not current state).
+
+import { patterns as claudePatterns } from './agents/claude.js';
+
+// ANSI stripping — full CSI/OSC/DCS/APC coverage per ECMA-48.
+const CSI_REGEX = /\x1b\[[\x20-\x3f]*[\x40-\x7e]/g;
+const OSC_REGEX = /\x1b\][\s\S]*?(?:\x07|\x1b\\)/g;
+const DCS_REGEX = /\x1bP[\s\S]*?(?:\x07|\x1b\\)/g;
+const OTHER_ESC_REGEX = /\x1b[_X^][\s\S]*?(?:\x07|\x1b\\)/g;
+
+export function stripAnsi(text) {
+  return text
+    .replace(OSC_REGEX, '')
+    .replace(DCS_REGEX, '')
+    .replace(OTHER_ESC_REGEX, '')
+    .replace(CSI_REGEX, '');
+}
+
+const PROXIMITY = 6;
+
+// tmux capture-pane pads the visible pane with blank rows below the last
+// content (a fresh pane shows a banner at the top and 20 empty rows under it).
+// The "last N lines" tail must be taken from the CONTENT, not the screen rows,
+// or a banner above the padding escapes the window.
+export function contentLines(text, tailLines) {
+  const lines = stripAnsi(text).split('\n');
+  let end = lines.length;
+  while (end > 0 && lines[end - 1].trim() === '') end--;
+  const trimmed = lines.slice(0, end);
+  return tailLines > 0 ? trimmed.slice(-tailLines) : trimmed;
+}
+
+function hasNearbyMatch(lines, idx, patterns) {
+  const start = Math.max(0, idx - PROXIMITY);
+  const end = Math.min(lines.length, idx + PROXIMITY + 1);
+  for (let j = start; j < end; j++) {
+    if (patterns.some(p => p.test(lines[j]))) return true;
+  }
+  return false;
+}
+
+// Main entry: detect a live usage-limit banner in the pane tail.
+// Returns { hit, limitType: '5h'|'weekly'|'unknown', resetLine } — resetLine is
+// the text to feed to time-parser (most recent reset mention, bottom-up).
+export function detectLimit(text, tailLines = 12, sets = claudePatterns) {
+  const lines = contentLines(text, tailLines);
+
+  let hit = false;
+  for (let i = 0; i < lines.length; i++) {
+    if (sets.limitPatterns.some(p => p.test(lines[i])) && hasNearbyMatch(lines, i, sets.resetPatterns)) {
+      hit = true;
+      break;
+    }
+  }
+  if (!hit) return { hit: false, limitType: null, resetLine: null };
+
+  const joined = lines.join('\n');
+  let limitType = 'unknown';
+  if (sets.weeklyPatterns.some(p => p.test(joined))) limitType = 'weekly';
+  else if ((sets.fiveHourPatterns || []).some(p => p.test(joined))) limitType = '5h';
+
+  // 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 (!resetLine) {
+    for (let i = lines.length - 1; i >= 0; i--) {
+      if (sets.limitPatterns.some(p => p.test(lines[i]))) { resetLine = lines[i].trim(); break; }
+    }
+  }
+  return { hit: true, limitType, resetLine };
+}
+
+function tail(text, n = 12) {
+  return contentLines(text, n);
+}
+
+// While the agent is streaming or running its own internal retries, the pane
+// is NOT in a terminal state — never inject keys then.
+export function isBusy(text, busyPatterns = claudePatterns.busyPatterns) {
+  return tail(text).some(line => busyPatterns.some(p => p.test(line)));
+}
+
+// Overload patterns are adapter-supplied, anchored to the CLI's actual error
+// render ("API Error: 529", "overloaded_error") — never bare digits.
+export function overloadMatch(text, patterns = []) {
+  if (!patterns || patterns.length === 0) return null;
+  const lines = tail(text);
+  if (!lines.join('').trim()) return null;
+  const regexes = [];
+  for (const p of patterns) {
+    if (p instanceof RegExp) { regexes.push(p); continue; }
+    if (typeof p !== 'string' || !p) continue;
+    try { regexes.push(new RegExp(p, 'i')); } catch { /* skip invalid */ }
+  }
+  for (const line of lines) {
+    for (const r of regexes) {
+      if (r.test(line)) return { pattern: r.source, line: line.trim().slice(0, 200) };
+    }
+  }
+  return null;
+}

package/src/report.js

@@ -0,0 +1,46 @@
+// `unsnooze report [pane]` — capture a pane (ANSI-stripped), show it to the
+// user, and print a pre-filled GitHub issue URL. Exists mainly so early Grok
+// Build users can contribute real limit-banner text (the patterns for grok
+// are generic until someone shows us the actual banner).
+
+import { capturePane, currentPaneId } from './tmux.js';
+import { stripAnsi } from './patterns.js';
+
+export const REPO_URL = 'https://github.com/saaranshM/unsnooze';
+const MAX_CAPTURE_CHARS = 3000;
+
+export function buildIssueUrl(agentId, captureText) {
+  const title = `[banner-capture] ${agentId}: limit banner sample`;
+  const body = [
+    `**Agent CLI:** ${agentId}`,
+    '',
+    'Pane capture (redact anything sensitive before submitting!):',
+    '',
+    '```text',
+    captureText.slice(-MAX_CAPTURE_CHARS),
+    '```',
+  ].join('\n');
+  return `${REPO_URL}/issues/new?title=${encodeURIComponent(title)}&body=${encodeURIComponent(body)}`;
+}
+
+export async function cmdReport(rest) {
+  const [agentId = 'grok', paneArg] = rest;
+  const pane = paneArg || currentPaneId();
+  if (!pane) {
+    console.error('unsnooze report: no pane (run inside tmux or pass a pane id, e.g. %3)');
+    return 2;
+  }
+  let text;
+  try {
+    text = stripAnsi(await capturePane(pane, 200));
+  } catch (err) {
+    console.error(`unsnooze report: cannot capture pane ${pane}: ${err.message}`);
+    return 1;
+  }
+  console.log('--- pane capture (review & redact before sharing) ---');
+  console.log(text.trimEnd());
+  console.log('--- end capture ---\n');
+  console.log('If this shows a usage-limit banner, please open an issue so detection improves:');
+  console.log(buildIssueUrl(agentId, text));
+  return 0;
+}

package/src/resumer.js

@@ -0,0 +1,211 @@
+// Resumer daemon (`unsnooze _resumer`) — SINGLETON. Watches state.json for stopped
+// sessions, polls wall-clock against the earliest resetAt (interval polling,
+// never one long setTimeout — survives laptop sleep; a wake past the target
+// fires on the next tick), then re-opens/continues every due session.
+// Exits when no non-terminal records remain; the next limit event respawns it.
+
+import { writeFileSync, readFileSync, unlinkSync, mkdirSync } from 'node:fs';
+import * as realTmux from './tmux.js';
+import {
+  RESUMER_LOCK, STATE_DIR, POLL_INTERVAL_MS, STAGGER_MS, VERIFY_DELAY_MS,
+  BUSY_DEFER_MS, MAX_BUSY_DEFERS, MAX_RESUME_ATTEMPTS, READY_TIMEOUT_MS,
+  CAPTURE_LINES, PANE_SCAN_LINES, TMUX_SESSION_NAME,
+  RESET_MARGIN_MS, FALLBACK_RESET_MS,
+} from './config.js';
+import { detectLimit, isBusy } from './patterns.js';
+import { getAgent } from './agents/index.js';
+import { parseResetTime, resetAtMs } from './time-parser.js';
+import { readState, updateState, setStatus, dueSessions, activeStopped } from './state.js';
+import { getConfig } from './settings.js';
+import { notify } from './notify.js';
+import { UNSNOOZE_BIN } from './spawn.js';
+import { makeLogger } from './logger.js';
+
+const log = makeLogger('resumer');
+const sleep = ms => new Promise(r => setTimeout(r, ms));
+
+function pidAlive(pid) {
+  try { process.kill(pid, 0); return true; } catch { return false; }
+}
+
+export function acquireSingleton() {
+  mkdirSync(STATE_DIR, { recursive: true });
+  try {
+    const pid = parseInt(readFileSync(RESUMER_LOCK, 'utf-8'), 10);
+    if (Number.isFinite(pid) && pid !== process.pid && pidAlive(pid)) return false;
+  } catch { /* no lock */ }
+  writeFileSync(RESUMER_LOCK, String(process.pid));
+  return true;
+}
+
+export function releaseSingleton() {
+  try {
+    const pid = parseInt(readFileSync(RESUMER_LOCK, 'utf-8'), 10);
+    if (pid === process.pid) unlinkSync(RESUMER_LOCK);
+  } catch { /* already gone */ }
+}
+
+// Due sessions that are actually allowed to dispatch: everything when
+// autoResume is on; only explicitly `resume-now`-marked (manual) records when
+// it's off. Stops stay tracked either way.
+export function dueForDispatch(now = Date.now()) {
+  const auto = getConfig('autoResume');
+  return dueSessions(now).filter(s => auto || s.manual);
+}
+
+function shellQuote(arg) {
+  return /^[\w@%+=:,./-]+$/.test(arg) ? arg : `'${arg.replace(/'/g, `'\\''`)}'`;
+}
+
+// The reopen command runs inside a fresh tmux window, i.e. with the tmux
+// SERVER's environment — which may lack npm globals or nvm's node on PATH.
+// Always embed absolute paths. UNSNOOZE_SELF is the test-harness override.
+function selfCommand() {
+  return process.env.UNSNOOZE_SELF
+    ? [process.env.UNSNOOZE_SELF]
+    : [process.execPath, UNSNOOZE_BIN];
+}
+
+// Decide how to act on one due record. Pure-ish; tmux injectable.
+// Returns: 'sent' | 'reopened' | 'deferred' | 'skip' | 'failed'
+export async function dispatchOne(rec, { tmux = realTmux, resumeMessage = getConfig('resumeMessage'), selfCmd = selfCommand() } = {}) {
+  const key = rec.key;
+  const agent = getAgent(rec.agent);
+
+  // Live-pane path: only if the pane still exists AND the agent CLI is its
+  // foreground command (pane ids get recycled — never inject into a random
+  // program).
+  if (rec.pane && await tmux.paneAlive(rec.pane)) {
+    const cmd = await tmux.paneCurrentCommand(rec.pane);
+    if (agent.isForegroundCommand(cmd)) {
+      const text = await tmux.capturePane(rec.pane, CAPTURE_LINES).catch(() => '');
+      if (isBusy(text, agent.patterns.busyPatterns)) return 'deferred';
+      setStatus(key, 'resuming', { lastAttemptAt: Date.now() });
+      await tmux.sendText(rec.pane, resumeMessage);
+      log(`${key}: sent continue to live pane ${rec.pane}`);
+      return 'sent';
+    }
+    // Pane alive but the agent gone (user's shell now) — fall through to
+    // re-open; never hijack a shell prompt with a chat message.
+  }
+
+  // Re-open path: new tmux window in the well-known session, resume by id.
+  const resume = agent.resumeArgs(rec.sessionId, resumeMessage);
+  const command = [...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);
+  } catch (err) {
+    setStatus(key, 'stopped', { attempts: (rec.attempts || 0) + 1, lastError: `new-window: ${err.message}` });
+    return 'failed';
+  }
+  updateState(state => {
+    const s = state.sessions[key];
+    if (s) s.pane = newPane;
+  });
+  log(`${key}: re-opened in pane ${newPane} (${command})`);
+
+  // The resume prompt traveled in argv (e.g. `codex resume <id> "msg"`) —
+  // nothing to type into the TUI; verifyOne checks the outcome later.
+  if (!resume.messageViaPane) return 'reopened';
+
+  // Wait for the TUI to be ready (input prompt visible), then send the message.
+  const deadline = Date.now() + READY_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    await sleep(2000);
+    const text = await tmux.capturePane(newPane, CAPTURE_LINES).catch(() => '');
+    if ((agent.menu && agent.menu.isPrompt(text, PANE_SCAN_LINES)) || detectLimit(text, PANE_SCAN_LINES, agent.patterns).hit) {
+      // Limit hadn't actually reset — the fresh session hit it immediately.
+      return 'failed';
+    }
+    // The idle input box: a prompt glyph with no busy footer.
+    if (!isBusy(text, agent.patterns.busyPatterns) && agent.patterns.idleRegex.test(text)) {
+      await tmux.sendText(newPane, resumeMessage);
+      log(`${key}: resume message sent to new pane ${newPane}`);
+      return 'reopened';
+    }
+  }
+  setStatus(key, 'stopped', { attempts: (rec.attempts || 0) + 1, lastError: 'ready timeout' });
+  return 'failed';
+}
+
+// Post-dispatch verification: did the limit banner come back?
+export async function verifyOne(key, { tmux = realTmux } = {}) {
+  const rec = readState().sessions[key];
+  if (!rec || rec.status !== 'resuming') return;
+  const agent = getAgent(rec.agent);
+  const text = rec.pane ? await tmux.capturePane(rec.pane, CAPTURE_LINES).catch(() => '') : '';
+  const d = detectLimit(text, PANE_SCAN_LINES, agent.patterns);
+  if (d.hit || (agent.menu && agent.menu.isPrompt(text, PANE_SCAN_LINES))) {
+    // Limit not actually reset — reschedule from the fresh banner.
+    const { at, source } = resetAtMs(parseResetTime(d.resetLine), {
+      marginMs: RESET_MARGIN_MS, fallbackMs: FALLBACK_RESET_MS,
+    });
+    setStatus(key, 'stopped', {
+      attempts: (rec.attempts || 0) + 1, resetAt: at, resetSource: source,
+      lastError: 'limit still active at resume time',
+    });
+    log(`${key}: limit still active, rescheduled to ${new Date(at).toISOString()}`);
+    return;
+  }
+  setStatus(key, 'resumed');
+  log(`${key}: verified resumed`);
+  notify('unsnoozed ✅', `${rec.cwd} is running again`);
+}
+
+export async function runResumer({ tmux = realTmux, pollInterval = POLL_INTERVAL_MS } = {}) {
+  if (!acquireSingleton()) { log('another resumer is running — exiting'); return 0; }
+  updateState(state => { state.resumerPid = process.pid; });
+  log(`resumer started (pid ${process.pid})`);
+  const deferCounts = new Map();
+
+  try {
+    for (;;) {
+      const stopped = activeStopped();
+      const resuming = Object.values(readState().sessions).filter(s => s.status === 'resuming');
+      if (stopped.length === 0 && resuming.length === 0) {
+        log('no pending sessions — resumer exiting');
+        return 0;
+      }
+
+      const due = dueForDispatch().filter(s => (s.attempts || 0) < MAX_RESUME_ATTEMPTS);
+      // Anything over the attempts cap is dead — mark failed so we can exit.
+      for (const s of dueForDispatch()) {
+        if ((s.attempts || 0) >= MAX_RESUME_ATTEMPTS) {
+          setStatus(s.key, 'failed', { lastError: 'max resume attempts exceeded' });
+          log(`${s.key}: giving up after ${s.attempts} attempts`);
+          notify('unsnooze gave up ⚠️', `${s.cwd}: ${s.attempts} resume attempts failed — check \`unsnooze status\``);
+        }
+      }
+
+      const dispatched = [];
+      for (const rec of due) {
+        const result = await dispatchOne(rec, { tmux });
+        if (result === 'deferred') {
+          const n = (deferCounts.get(rec.key) || 0) + 1;
+          deferCounts.set(rec.key, n);
+          if (n > MAX_BUSY_DEFERS) {
+            setStatus(rec.key, 'resumed', { lastError: null });
+            log(`${rec.key}: busy through ${n} defers — it is clearly working, marking resumed`);
+          } else {
+            await sleep(BUSY_DEFER_MS);
+          }
+          continue;
+        }
+        if (result === 'sent' || result === 'reopened') dispatched.push(rec.key);
+        if (due.indexOf(rec) < due.length - 1) await sleep(STAGGER_MS);
+      }
+
+      if (dispatched.length > 0) {
+        await sleep(VERIFY_DELAY_MS);
+        for (const key of dispatched) await verifyOne(key, { tmux });
+      }
+
+      await sleep(pollInterval);
+    }
+  } finally {
+    releaseSingleton();
+    updateState(state => { if (state.resumerPid === process.pid) state.resumerPid = null; });
+  }
+}