unsnooze 1.0.0 → 1.2.0

package/CHANGELOG.md

@@ -1,5 +1,69 @@
 # 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
+
+- **`resumeMessages.claude` / `.codex` / `.grok`**: optional per-agent override
+  of the global `resumeMessage` — `unsnooze config set resumeMessages.codex
+  "..."` or `UNSNOOZE_RESUME_MESSAGE_CODEX`. Empty means "use the global
+  message"; clear with `unsnooze config set resumeMessages.codex ""`.
+  Specificity beats source: a per-agent file value outranks a global env var.
+- **Setup wizard** asks for per-agent messages, prefills every message prompt
+  from the existing config, and merges over the config file — re-runs no
+  longer clobber values set via `unsnooze config`.
+- Blank or whitespace-only messages are never sent: resolution falls through
+  to the global message, then the built-in default.
+
+### CLI & fixes
+
+- **`-h` / `--help`** now print the unsnooze help (previously only
+  `unsnooze help`), and the usage documents every command.
+- **Install**: `unsnooze setup` / `install` no longer crashes with ENOENT on
+  machines without a `~/.claude/` directory.
+- `unsnooze config set <key> ""` is a valid way to clear string overrides, and
+  a config file holding non-object JSON is treated as empty instead of
+  corrupting later writes.
+
 ## 1.0.0 — 2026-07-10
 
 First public release (previously the private `claude-session-guard`/`csg`).

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,8 +131,11 @@ 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)
 ```
 
 ## Settings
@@ -115,7 +148,9 @@ unsnooze uninstall [--purge]    # remove wrappers + hooks (+ state with --purge)
 | `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. |
 
 Every setting also has a `UNSNOOZE_*` env override (see `src/settings.js`), and

package/bin/unsnooze.js

@@ -60,7 +60,20 @@ 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':
     case '--help-unsnooze': {
       console.log(`unsnooze — wakes every limit-stopped AI coding session when the limit resets
 
@@ -71,11 +84,16 @@ 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 config [list|get|set]   view or change settings (toggles, message)
+  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)
   unsnooze install [--yes]         wire up shell wrappers + hooks (non-interactive)
   unsnooze uninstall [--purge]     remove wrappers + hooks (and state with --purge)
-  unsnooze report [agent] [pane]   capture a pane to report an undetected banner`);
+  unsnooze report [agent] [pane]   capture a pane to report an undetected banner
+  unsnooze help                    show this help (also -h / --help)`);
       return 0;
     }
     default: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unsnooze",
-  "version": "1.0.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;
 }
@@ -89,7 +90,7 @@ export function cmdConfig(rest) {
       const listed = listConfig();
       console.log(`unsnooze settings (${CONFIG_FILE()}):\n`);
       for (const [k, v] of Object.entries(listed)) {
-        console.log(`  ${k.padEnd(16)} ${JSON.stringify(v)}`);
+        console.log(`  ${k.padEnd(24)} ${JSON.stringify(v)}`);
       }
       return 0;
     }
@@ -100,7 +101,9 @@ export function cmdConfig(rest) {
     }
     if (action === 'set') {
       const value = valueParts.join(' ');
-      if (!key || value === '') { console.error('unsnooze config set <key> <value>'); return 2; }
+      // An explicit "" is a valid value (clears string overrides); only a
+      // genuinely missing value is a usage error.
+      if (!key || valueParts.length === 0) { console.error('unsnooze config set <key> <value>'); return 2; }
       const applied = setConfigValue(key, value);
       console.log(`unsnooze: ${key} = ${JSON.stringify(applied)}`);
       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 } 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];
   }
@@ -38,6 +41,7 @@ function parseArgs(rest) {
 }
 
 function atomicWrite(path, content) {
+  mkdirSync(dirname(path), { recursive: true });   // e.g. ~/.claude may not exist yet
   const tmp = join(dirname(path), `.${Date.now()}.tmp`);
   writeFileSync(tmp, content);
   renameSync(tmp, path);
@@ -123,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() {
@@ -184,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;
@@ -210,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,
@@ -16,7 +17,7 @@ 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 { getConfig, resolveResumeMessage } from './settings.js';
 import { notify } from './notify.js';
 import { UNSNOOZE_BIN } from './spawn.js';
 import { makeLogger } from './logger.js';
@@ -68,9 +69,11 @@ function selfCommand() {
 
 // 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() } = {}) {
+export async function dispatchOne(rec, { tmux = realTmux, resumeMessage, selfCmd = selfCommand() } = {}) {
   const key = rec.key;
   const agent = getAgent(rec.agent);
+  // Explicit option wins; otherwise the agent's own message (or the global).
+  resumeMessage = resumeMessage ?? resolveResumeMessage(agent.id);
 
   // 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
@@ -90,12 +93,21 @@ export async function dispatchOne(rec, { tmux = realTmux, resumeMessage = getCon
   }
 
   // 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';
@@ -151,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

@@ -1,6 +1,10 @@
 // User-facing settings: ~/.unsnooze/config.json, managed by `unsnooze config`
-// and the setup wizard. Precedence: env var > config file > default — env
-// stays the power-user/test escape hatch, the file is what the wizard writes.
+// and the setup wizard. Precedence per key: env var > config file > default —
+// env stays the power-user/test escape hatch, the file is what the wizard
+// writes. One cross-key exception: the resume message resolves by specificity
+// first, so a per-agent resumeMessages.<id> value (from either source) beats
+// the global resumeMessage even when the global came from an env var (see
+// resolveResumeMessage).
 
 import { readFileSync, writeFileSync, renameSync, mkdirSync } from 'node:fs';
 import { join, dirname } from 'node:path';
@@ -12,7 +16,9 @@ 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
 };
 
@@ -21,7 +27,11 @@ 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',
+  'resumeMessages.grok': 'UNSNOOZE_RESUME_MESSAGE_GROK',
   'agents.claude': 'UNSNOOZE_AGENT_CLAUDE',
   'agents.codex': 'UNSNOOZE_AGENT_CODEX',
   'agents.grok': 'UNSNOOZE_AGENT_GROK',
@@ -35,9 +45,11 @@ function parseBool(raw) {
   return null;
 }
 
-function readFileConfig() {
+export function readFileConfig() {
   try {
-    return JSON.parse(readFileSync(CONFIG_FILE(), 'utf-8'));
+    const parsed = JSON.parse(readFileSync(CONFIG_FILE(), 'utf-8'));
+    // Wrong-typed but valid JSON (a bare string/array) counts as corrupt too.
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : {};
   } catch {
     return {};   // missing or corrupt file → defaults (never crash the hook path)
   }
@@ -63,6 +75,17 @@ export function getConfig(key) {
   return fromFile !== undefined ? fromFile : def;
 }
 
+// The message to send a given agent: its resumeMessages.<id> override when
+// set, else the global resumeMessage. Unknown agent ids fall back to global;
+// blank values (empty or whitespace-only) fall through to the next level so a
+// blank message is never sent.
+export function resolveResumeMessage(agentId) {
+  const key = `resumeMessages.${agentId}`;
+  const set = v => (typeof v === 'string' && v.trim() ? v : '');
+  const perAgent = agentId && KNOWN_KEYS.includes(key) ? getConfig(key) : '';
+  return set(perAgent) || set(getConfig('resumeMessage')) || DEFAULTS.resumeMessage;
+}
+
 export function setConfigValue(key, rawValue) {
   if (!KNOWN_KEYS.includes(key)) throw new Error(`unsnooze: unknown setting "${key}" (known: ${KNOWN_KEYS.join(', ')})`);
   const def = dig(DEFAULTS, key);

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