unsnooze 1.0.0 → 1.2.0

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

@@ -6,7 +6,7 @@ import { execFileSync } from 'node:child_process';
 import * as p from '@clack/prompts';
 import { listAgents } from './agents/index.js';
 import { isCommunityGrokCli } from './agents/grok.js';
-import { DEFAULTS, writeConfig } from './settings.js';
+import { DEFAULTS, writeConfig, readFileConfig } from './settings.js';
 
 export function detectInstalledAgents({ which = defaultWhich } = {}) {
   return listAgents().map(agent => ({ agent, installed: which(agent.bin) }));
@@ -69,32 +69,76 @@ 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();
+  const existingMsgs = existing.resumeMessages
+    && typeof existing.resumeMessages === 'object' && !Array.isArray(existing.resumeMessages)
+    ? existing.resumeMessages : {};
+
   const customizeMsg = await p.confirm({
     message: 'Customize the message sent to resume a session?',
     initialValue: false,
   });
   if (p.isCancel(customizeMsg)) return cancelled();
 
-  let resumeMessage = DEFAULTS.resumeMessage;
+  let resumeMessage = typeof existing.resumeMessage === 'string' && existing.resumeMessage.trim()
+    ? existing.resumeMessage : DEFAULTS.resumeMessage;
   if (customizeMsg) {
     const msg = await p.text({
       message: 'Resume message:',
-      initialValue: DEFAULTS.resumeMessage,
+      initialValue: resumeMessage,
       validate: v => (v.trim() ? undefined : 'message cannot be empty'),
     });
     if (p.isCancel(msg)) return cancelled();
     resumeMessage = msg;
   }
 
+  const customizePerAgent = await p.confirm({
+    message: 'Set a different resume message for specific agents?',
+    initialValue: false,
+  });
+  if (p.isCancel(customizePerAgent)) return cancelled();
+
+  const resumeMessages = {};
+  if (customizePerAgent) {
+    for (const agent of listAgents().filter(a => agents.includes(a.id))) {
+      const msg = await p.text({
+        message: `Message for ${agent.name} (leave empty to use the global message):`,
+        initialValue: typeof existingMsgs[agent.id] === 'string' ? existingMsgs[agent.id] : '',
+      });
+      if (p.isCancel(msg)) return cancelled();
+      resumeMessages[agent.id] = typeof msg === 'string' && msg.trim() ? msg : '';
+    }
+  }
+
+  // Merge over the existing file so a setup re-run keeps settings the wizard
+  // doesn't ask about (e.g. per-agent messages set via `unsnooze config`).
   writeConfig({
-    autoResume, menuAutoAnswer, notifications, resumeMessage,
+    ...existing,
+    autoResume, menuAutoAnswer, notifications, guiWatch, resumeMessage,
+    resumeMessages: { ...existingMsgs, ...resumeMessages },
     agents: Object.fromEntries(listAgents().map(a => [a.id, agents.includes(a.id)])),
   });
 
   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