unsnooze 1.19.0 → 1.19.2

package/CHANGELOG.md

@@ -1,5 +1,223 @@
 # Changelog
 
+## 1.19.2 — 2026-09-27
+
+Setup on Windows no longer creates a Scheduled Task. That task is what
+Microsoft Defender flagged as a Trojan.
+
+### Website redesign
+
+- The new night-shift design now covers the homepage, documentation, changelog,
+  and feedback page, with responsive layouts and reduced-motion support.
+- Release metadata refreshes every five minutes so the site follows published
+  npm versions. Failed feedback-board reads now show an error instead of
+  loading indefinitely.
+- Windows setup and troubleshooting docs describe the on-demand daemon.
+
+### Codex wake recovery
+
+- Team/business stops with a null credits balance now retain the exhausted
+  five-hour window's reset instead of being held as a workspace credit wall.
+- If Codex consumes Enter as a pasted newline, verification retries Enter
+  up to three times while the exact wake prompt remains in the composer.
+  Each retry rechecks pane ownership and agent liveness. The old banner is
+  not re-recorded as a new stop, and the wake text is never pasted twice.
+  An unconfirmed submission is left visible for manual inspection.
+
+### No Scheduled Task on Windows
+
+A user reported that Microsoft Defender flagged `unsnooze setup` as
+`Trojan:Win32/Commando.A!ml` as it created the `\unsnooze` Scheduled Task. It
+was a false positive, but an understandable one. Setup ran
+`schtasks /create /f /sc onlogon /tr "node.exe …\AppData\Roaming\npm\…\unsnooze.js daemon"`:
+an interpreter told to run a script out of `%APPDATA%` at every logon, which is
+exactly how malware persists, and `Commando.A!ml` is Defender's
+machine-learning verdict on command lines like that one. A Run key or a
+Startup-folder entry reads the same way, so the daemon uses none of them now.
+The task rarely worked anyway: from a shell that is not elevated, `schtasks`
+refuses an `onlogon` task with "Access is denied", and setup said it was
+installed regardless.
+
+On Windows the daemon is now an ordinary background process:
+
+- **Setup starts it.** Saying yes to guarding GUI sessions (or running
+  `unsnooze install --daemon`) starts the daemon at once and records that
+  choice in `~/.unsnooze/daemon-on-demand`. Nothing is registered with Windows.
+- **It is started again on demand.** Every agent launched through the
+  PowerShell wrappers, and every Claude Code StopFailure hook, starts the
+  daemon if it is not running. After a restart it is back as soon as you use
+  an agent.
+- **One runs at a time.** The daemon keeps a heartbeat pidfile
+  (`~/.unsnooze/daemon.pid`), and a second daemon stands down at once. Once the
+  heartbeat is five minutes old the file no longer counts, whoever its pid
+  belongs to by then, so a pid Windows recycles after a sign-out cannot keep
+  the daemon from starting. A resumer lock left behind by a daemon that was
+  killed is cleared too, so it cannot stall every resume.
+- **It carries no session with it.** Started from inside a Claude Code
+  session (by the hook), it used to inherit that session's environment,
+  including `CLAUDECODE=1`, Claude Code's nested-session guard. Every Claude
+  session it revived would then have refused to start. Background processes
+  now drop the variables that mark one session; your own settings, such as
+  `CLAUDE_CONFIG_DIR` and `CLAUDE_CODE_USE_BEDROCK`, are kept. They also run in
+  your home directory, not the project that happened to start them, which
+  Windows would otherwise refuse to delete or rename until sign-out. The
+  transient resumer the hook starts gets the same treatment, on every
+  platform.
+- **No console windows.** A background daemon has no console. The `git` calls
+  it makes when a session stops and wakes, and the agent a revival starts,
+  now run hidden instead of each popping up a window of its own.
+- **Its output goes to `~/.unsnooze/daemon.log`**, as the launchd daemon's
+  does, so a crash leaves a trace.
+- **Re-running setup restarts it.** `unsnooze install --daemon` stops the
+  running daemon and starts a fresh one. That is how it picks up a new
+  version, or a `PATH` that now finds an agent, and `unsnooze doctor` now
+  says so instead of pointing at `schtasks`.
+
+If you use only the Codex app or IDE on Windows, nothing you do passes through
+a wrapper or the hook. After signing in, run `unsnooze install --daemon` (or
+launch any wrapped agent) to start the daemon.
+
+`unsnooze uninstall` removes the marker first, then stops the daemon, so
+nothing can start it again halfway through; a daemon that was only starting at
+that moment sees the marker gone and exits. It also deletes a `\unsnooze`
+Scheduled Task left by an earlier version, after checking that one exists, so
+a machine that never had one only ever sees a read-only query. If the delete
+is refused (a task created from an administrator shell can need one to
+remove), it prints the command to run. Setup does not go looking for that
+task: that would mean running `schtasks` again. A daemon such a task already
+started keeps running until you sign out; from the next sign-in the task only
+starts the same on-demand daemon, which the pidfile keeps to one. macOS and
+Linux are unchanged (launchd / systemd).
+
+## 1.19.1 — 2026-09-21
+
+A Codex usage reading that was averaged down, a headless Codex revival
+that could never have worked — reported as a success — and Codex stops that
+were never seen at all behind a proxy or in a reverted thread.
+
+### `unsnooze usage` reports Codex's exact percentage as read
+
+The 64% in [issue #20](https://github.com/saaranshM/unsnooze/issues/20) was
+`(29 + 99) / 2`: a jump of more than 15 points was averaged with the reading
+before it and still labelled `exact`. The averaging was meant to soften a
+one-tick spike, but at the moment a session is blocked no further reading
+arrives, so the low number stayed for the rest of the window — and 64 is
+below the 80/95 warning thresholds, so the usage-wall notification never
+fired. Codex's `used_percent` is the server's own number and is now shown
+unchanged (still clamped to 0–100).
+
+Two things could put a much lower reading in front of the latest one: Codex
+writes one snapshot per rate-limit bucket per response, and `unsnooze usage`
+read every bucket (`premium`, `codex_other`, …) as the account window; and
+Codex Desktop tabs and sub-agents each write their own rollout, so "the
+previous reading" could be another thread's minutes-old snapshot. Only the
+account bucket feeds the 5h/weekly lines now, and burn is measured between
+readings of the same rollout. Thanks to
+[@mio-tsuki](https://github.com/mio-tsuki) for working out the arithmetic.
+
+### Headless Codex revivals run, and a revival that dies says so
+
+[Issue #25](https://github.com/saaranshM/unsnooze/issues/25): on Windows the
+daemon's Scheduled Task could not find `codex`, every revival died with
+`spawn codex ENOENT`, and unsnooze logged `verified resumed` anyway.
+
+- **`codex exec resume`.** Under the headless backend a revival ran the Codex
+  TUI, which exits before touching the session when stdin is not a terminal —
+  on every OS, since the backend shipped in 1.16.0. Headless Codex revivals
+  now run `codex exec resume <id> "<prompt>"`, which continues the same
+  conversation non-interactively, the way Claude's headless revival already
+  passed its prompt in argv. It is given `--skip-git-repo-check`: `exec`
+  refuses any directory that is not a git repository, which the TUI never
+  did, and the session being revived already ran there. `resumeExtraArgs.codex`
+  goes right after `exec`, where `-s`, `-p` and `--add-dir` parse; after
+  `resume` they were rejected outright.
+- **A dead revival is a failed attempt.** With no pane to capture, an empty
+  capture used to count as a cleared banner. The headless backend now records
+  each revival's exit, and a non-zero one puts the stop back on the ledger
+  with backoff and a `last error` that carries the child's own words — visible
+  in `unsnooze status`, and kept when unsnooze finally gives up on the session.
+  A revival still running at the 20-second check is watched for up to two
+  minutes before it counts as resumed, long enough to catch the failures that
+  take a while (an auth refresh giving up, a retry loop); exit 0 counts as
+  resumed. A revival started by a resumer the Claude hook spawned no longer
+  inherits Claude's nested-launch marker, which had made it drop
+  `launchExtraArgs` and fail with a bare "exit 1".
+- **A revival into a deleted directory no longer takes the daemon down.** When
+  a session's directory was gone (a removed worktree, say), the headless
+  launch failed with an error nothing was listening for, and the daemon
+  crashed. It is now an ordinary failed attempt that names the reason.
+- **`unsnooze preview` shows the headless command.** It described a typed
+  resume and the Codex TUI for sessions that dispatch revives through argv
+  and `codex exec resume`.
+- **Windows finds the Codex runtime.** The Desktop/Store install keeps
+  `codex.exe` under a versioned directory that changes on update, and a daemon
+  started at logon keeps the PATH it was born with. Codex is now resolved at
+  launch: `UNSNOOZE_CODEX_BIN`, then `codex.exe` on PATH, then the newest
+  runtime under `%LOCALAPPDATA%\OpenAI\Codex\bin`. A `.cmd`/`.bat` shim
+  cannot be launched directly by Node; the launcher now says so and names the
+  variable to point at the `.exe` instead of failing with `EINVAL`.
+- **`unsnooze doctor` names each agent's binary** as the launcher would resolve
+  it, and reports an agent that cannot be launched as a health problem — on
+  Windows with the note that the daemon's environment can lag the shell's and
+  how to refresh it. Only for agents that have run on the machine: Claude and
+  Codex are both on by default, and a Claude-only machine is not unhealthy for
+  having no `codex`. The lookup follows spawn's own Windows rules: an `.exe`
+  anywhere on PATH wins over an npm shim earlier on it, quoted PATH entries
+  count, and a path given without its extension finds the `.exe`.
+- **Codex stops bind to the right reset.** A `rate_limit_reached` at a reported
+  99.x% was scheduled for the *weekly* reset (the latest one), days out; it now
+  binds the window nearest exhaustion. A workspace wall — credits depleted or
+  a spend cap, with no window spent — has no reset to wait for: it is announced
+  as needing you rather than "resumes when the limit resets", probed, and then
+  held with the remedy (add credits or raise the cap, then continue the
+  session in Codex) instead of a blind wake. A spent window (99% or more)
+  still governs when a workspace reason rides along, since its reset is what
+  brings the plan allowance back. `unsnooze status --json` shows the reason as
+  `limitReason`.
+- **A weaker reading no longer undoes an exact reset.** A re-detected stop
+  whose only evidence is a banner ("Try again later.") used to replace the
+  exact reset the rollout snapshot had given, turning a known wake into a
+  15-minute probe; the stronger schedule now stands until it passes, the rule
+  pane detection already followed. `unsnooze usage` in the dashboard also
+  stops reading Codex burn as idle whenever the daemon is running.
+
+The Windows resolution follows the layout in the report and wants a Windows
+run before it is trusted; continuing an open Codex Desktop thread in place
+(`codex queue`) is a separate follow-up. Thanks to
+[@nwn900](https://github.com/nwn900) for the precise report.
+
+### Codex stops behind a proxy, and in reverted threads
+
+[Issue #27](https://github.com/saaranshM/unsnooze/issues/27) found two ways
+a Codex desktop-app or IDE session went untracked:
+
+- **Reverted threads are watched.** An edited, regenerated or `/undo`-ed
+  thread continues in `rollout-<ts>-<thread id>_<rollout id>.jsonl`, a name
+  the rollout watcher never opened. Those files are now watched, counted by
+  `unsnooze usage`, and resumed by the stable thread id.
+- **A stop recorded only as an error is a stop.** Behind an OpenAI-compatible
+  proxy the rate-limit headers never reach Codex, every snapshot has empty
+  windows, and no stop was ever detected. Since codex-cli 0.145 the failed
+  turn's `task_complete` carries the limit error itself; unsnooze now reads
+  it and dates it from the banner the way a scraped pane is dated ("Try again
+  later." is probed). When the same turn also wrote an exhausted snapshot,
+  its exact reset still wins, and a workspace wall — in the snapshot or in
+  the banner's own words — stays a wall. Only the banner counts: Codex marks
+  billing and plan errors ("Quota exceeded…", "upgrade to Plus…") with the
+  same `usage_limit_exceeded` code, and those are not stops, nor is a bare 429,
+  which carries no reset time.
+- **Codex's current banner is recognized.** Codex now writes "You’ve hit your
+  usage limit" with a typographic apostrophe; the anchor accepts both, in
+  rollouts and in panes.
+- **A reset in the banner's own minute is not tomorrow.** Codex prints the
+  reset time without seconds, so a limit hit at 7:36:15 that resets at
+  7:36:40 says "try again at 7:36 AM" — which was read as 7:36 the next
+  morning, a day late. It now wakes at 7:37.
+
+Thanks to [@d-jiao](https://github.com/d-jiao) for the report, the fix in
+[PR #28](https://github.com/saaranshM/unsnooze/pull/28), and checking it
+against 523 real rollouts.
+
 ## 1.19.0 — 2026-09-10
 
 Fish shell support, direct help/version commands, and a fix for Codex sessions

package/README.md

@@ -244,6 +244,15 @@ the session files those surfaces already write:
   one minute by an empty `premium` bucket with no credits, using the previous
   future reset time. The snapshots must come from the same rollout; 99% alone
   is not a stop signal. This works across watcher polls and daemon restarts.
+  Since codex-cli 0.145 the failed turn's `task_complete` also carries the
+  limit error itself (`codex_error_info: "usage_limit_exceeded"` plus the
+  banner text), and unsnooze reads that too — it is the only signal when
+  Codex runs behind an OpenAI-compatible proxy (`model_providers.<x>.base_url`),
+  where the rate-limit headers never reach Codex and every snapshot has empty
+  windows. The banner's time is parsed like a scraped pane; "Try again later."
+  takes the probe path. Reverted threads (the desktop app's edit/regenerate,
+  `/undo`) continue in `rollout-<ts>-<thread id>_<rollout id>.jsonl`; those
+  files are watched and resumed by the stable thread id.
 - **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`
@@ -256,7 +265,8 @@ 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),
+Enable it in `unsnooze setup` (installs a launchd agent / systemd user unit;
+on Windows the daemon is started on demand instead — see [Windows](#windows)),
 or run `unsnooze install --daemon` / `unsnooze daemon` yourself. Turn it off
 anytime with `unsnooze config set guiWatch off`.
 
@@ -375,7 +385,8 @@ unsnooze config set <k> <v>            # e.g. autoResume off
 unsnooze logs [-f]                     # what unsnooze has been doing
 unsnooze update                        # update unsnooze itself
 unsnooze daemon                        # persistent GUI-session watcher (usually run
-                                       # by launchd/systemd via `install --daemon`)
+                                       # by launchd/systemd via `install --daemon`;
+                                       # on Windows, started on demand)
 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)
@@ -719,7 +730,10 @@ herdr restores saved agent panes itself, so a revival on top would resume the
 same conversation twice.
 ² Into a fresh workspace; cmux has no joinable named-session model.
 ³ As a detached process. Its output goes to `~/.unsnooze/headless/<session>.log`,
-since there is no scrollback to read it out of later.
+since there is no scrollback to read it out of later; the prompt rides in argv
+(`claude --resume <id> "…"`, `codex exec resume <id> "…"`), and a revival that
+exits non-zero is retried, with its last output as the `last error` in
+`unsnooze status`.
 ⁴ Nothing to wrap into — your own terminal is the session.
 
 Pick one explicitly with `unsnooze config set multiplexer tmux|zellij|herdr|cmux|headless`.
@@ -755,15 +769,30 @@ Windows, WSL is still the better home.
 ### Windows
 
 Native Windows works: PowerShell wrappers, a cmd-safe StopFailure hook, and a
-logon-triggered Scheduled Task for the daemon. Install as usual and run
-`unsnooze doctor` to confirm.
-
-Two honest caveats. The daemon is started at logon but not restarted if it
-dies — Task Scheduler is not a supervisor the way launchd and systemd are — so
-after upgrading unsnooze, log out and back in (or run `unsnooze daemon`
-yourself). And stored-password fleet hosts still need Git-for-Windows or WSL
-`ssh`; native `ssh.exe` requires an `.exe` askpass helper unsnooze does not yet
-ship.
+daemon started on demand. Install as usual and run `unsnooze doctor` to confirm.
+
+unsnooze registers nothing to run at sign-in on Windows — no Scheduled Task, Run
+key or Startup-folder entry. (Up to 1.19.1 it created a logon Scheduled Task,
+and Microsoft Defender flagged setup as `Trojan:Win32/Commando.A!ml` for it;
+`unsnooze uninstall` removes one left behind.)
+Setup starts the daemon instead, and every agent you launch from PowerShell and
+every Claude Code StopFailure hook starts it again whenever it is not running,
+so after a restart it is back as soon as you use an agent. If you only use the
+Codex app or IDE, nothing you do passes through a wrapper or the hook: run
+`unsnooze install --daemon` after signing in to start it.
+
+Three honest caveats. Nothing supervises the daemon the way launchd and systemd
+do, and a running daemon keeps the code it started with, so after upgrading
+unsnooze re-run `unsnooze install --daemon` (or sign out and back in). The
+daemon also keeps the `PATH` it was born with: an agent whose install directory
+changes on update (the Codex Desktop/Store runtime lives under
+`%LOCALAPPDATA%\OpenAI\Codex\bin\<hash>`) can vanish from the daemon's view
+while your shell still finds it — unsnooze looks that directory up at launch
+time, `unsnooze doctor` prints what each agent resolves to, and
+`UNSNOOZE_CODEX_BIN` (or `UNSNOOZE_CLAUDE_BIN`, …) pins a path; point it at an
+`.exe`, since Node cannot launch a `.cmd` shim directly. And stored-password
+fleet hosts still need Git-for-Windows or WSL `ssh`; native `ssh.exe` requires
+an `.exe` askpass helper unsnooze does not yet ship.
 
 WSL remains the richer option, because that is where the Unix multiplexers live
 — and where the agent CLIs often already are:

package/bin/unsnooze.js

@@ -223,81 +223,107 @@ async function main() {
     case 'daemon': {
       // Persistent resumer + transcript watcher: detects and revives limit
       // stops from GUI surfaces (VS Code extension, desktop apps) where no
-      // shell wrapper or multiplexer pane exists. Run via launchd/systemd or a shell.
+      // shell wrapper or multiplexer pane exists. Run via launchd/systemd, on
+      // demand on native Windows (spawn.js ensureDaemon), or from a shell.
       // Exit 0 on load failure: with launchd KeepAlive a crash here means an
       // instant-respawn crash-loop for the whole upgrade window.
       const resumerMod = await safeImport('../src/resumer.js');
       const watcherMod = await safeImport('../src/watcher.js');
-      if (!resumerMod || !watcherMod) return 0;
+      const spawnMod = await safeImport('../src/spawn.js');
+      if (!resumerMod || !watcherMod || !spawnMod) return 0;
       const { runResumer } = resumerMod;
       const { createWatcher } = watcherMod;
       const controller = new AbortController();
       process.on('SIGTERM', () => controller.abort());
       process.on('SIGINT', () => controller.abort());
-      // Self-heal pre-1.12 autostart units: they lack PATH, so this daemon
-      // cannot find tmux and every revival dies. Healing rewrites the unit
-      // and reloads it — which intentionally kills THIS process; the
-      // supervisor restarts us under the fixed unit. One-time: healed units
-      // pass the check forever after.
-      const installMod = await safeImport('../src/install.js');
-      if (installMod?.healDaemonAutostart) {
-        try {
-          const healed = installMod.healDaemonAutostart();
-          if (healed) {
-            const lm = await safeImport('../src/logger.js');
-            lm?.log('daemon', `autostart unit lacked PATH — regenerated ${healed}, reloading (self-heal)`);
-          }
-        } catch { /* heal is best-effort — a broken unit must not block the daemon */ }
-      }
-      // daemon.log is launchd/systemd-captured stdout+stderr. launchd holds
-      // an open fd on it for our whole lifetime, so rotation must be
-      // copy-truncate: renaming would leave launchd appending to the renamed
-      // inode forever, with no fresh daemon.log until the next respawn.
-      const loggerMod = await safeImport('../src/logger.js');
-      const configMod = await safeImport('../src/config.js');
-      if (loggerMod && configMod) {
-        const { join } = await import('node:path');
-        loggerMod.copyTruncateIfLarge(join(configMod.STATE_DIR, 'daemon.log'));
+      // Native Windows has no launchd/systemd to keep this a single instance,
+      // and the wrappers and the hook can both start one at once. Claim the
+      // pidfile before doing anything else: a daemon that finds a live one
+      // already running exits here, and one that later finds itself replaced
+      // stands down. --on-demand (how ensureDaemon starts it) also ties the
+      // daemon to its marker, so uninstall ends it rather than sign-out.
+      const onDemand = rest.includes('--on-demand');
+      let releaseDaemon = null;
+      if (process.platform === 'win32') {
+        const wanted = onDemand ? () => spawnMod.onDemandWanted() : () => true;
+        if (!wanted()) return 0;   // uninstalled between the start and now
+        releaseDaemon = spawnMod.claimDaemon({ onLost: () => controller.abort(), wanted });
+        if (!releaseDaemon) {
+          // Reaches a terminal only when a user ran `unsnooze daemon` by hand;
+          // an on-demand start has nowhere to print.
+          const pid = spawnMod.runningDaemonPid();
+          console.error(`unsnooze: the daemon is already running${pid ? ` (pid ${pid})` : ''} — not starting another`);
+          return 0;
+        }
       }
-      // Version-skew guard: when npm swaps the package underneath us, exit
-      // cleanly so launchd/systemd restart the daemon on the fresh code.
-      // Interval stays at 15 minutes on purpose — a tighter loop raises the
-      // odds of restarting INTO a half-installed package, which is the
-      // crash-loop the unit throttles exist to survive.
-      // Exiting is only safe under a supervisor. `unsnooze daemon` run from a
-      // shell has nothing to restart it, so there it warns and keeps watching
-      // rather than ending GUI watching silently.
-      const updMod = await safeImport('../src/update-check.js');
-      const notifyMod = await safeImport('../src/notify.js');
-      if (updMod?.hasVersionSkew) {
-        let warnedSkew = false;
-        setInterval(() => {
-          const action = updMod.daemonSkewAction({
-            skewed: updMod.hasVersionSkew(),
-            // Unknown means assume supervised: that is how the daemon is
-            // installed for all but a handful of users, and it preserves the
-            // long-standing behavior when install.js could not be loaded.
-            supervised: installMod?.isSupervised ? installMod.isSupervised() : true,
-            alreadyWarned: warnedSkew,
-          });
-          if (action === 'restart') controller.abort();
-          else if (action === 'warn') {
-            warnedSkew = true;
-            const msg = 'package was upgraded on disk but this daemon is not supervised — '
-              + 'still running the old code; restart it to pick up the new version';
-            loggerMod?.log('daemon', msg);
-            notifyMod?.notify('unsnooze needs a restart', msg, { priority: 4 });
-          }
-        }, 15 * 60_000).unref();
+      // From the claim on, every way out gives it back.
+      try {
+        // Self-heal pre-1.12 autostart units: they lack PATH, so this daemon
+        // cannot find tmux and every revival dies. Healing rewrites the unit
+        // and reloads it — which intentionally kills THIS process; the
+        // supervisor restarts us under the fixed unit. One-time: healed units
+        // pass the check forever after.
+        const installMod = await safeImport('../src/install.js');
+        if (installMod?.healDaemonAutostart) {
+          try {
+            const healed = installMod.healDaemonAutostart();
+            if (healed) {
+              const lm = await safeImport('../src/logger.js');
+              lm?.log('daemon', `autostart unit lacked PATH — regenerated ${healed}, reloading (self-heal)`);
+            }
+          } catch { /* heal is best-effort — a broken unit must not block the daemon */ }
+        }
+        // daemon.log is launchd/systemd-captured stdout+stderr. launchd holds
+        // an open fd on it for our whole lifetime, so rotation must be
+        // copy-truncate: renaming would leave launchd appending to the renamed
+        // inode forever, with no fresh daemon.log until the next respawn.
+        const loggerMod = await safeImport('../src/logger.js');
+        const configMod = await safeImport('../src/config.js');
+        if (loggerMod && configMod) {
+          const { join } = await import('node:path');
+          loggerMod.copyTruncateIfLarge(join(configMod.STATE_DIR, 'daemon.log'));
+        }
+        // Version-skew guard: when npm swaps the package underneath us, exit
+        // cleanly so launchd/systemd restart the daemon on the fresh code.
+        // Interval stays at 15 minutes on purpose — a tighter loop raises the
+        // odds of restarting INTO a half-installed package, which is the
+        // crash-loop the unit throttles exist to survive.
+        // Exiting is only safe under a supervisor. `unsnooze daemon` run from a
+        // shell has nothing to restart it, so there it warns and keeps watching
+        // rather than ending GUI watching silently.
+        const updMod = await safeImport('../src/update-check.js');
+        const notifyMod = await safeImport('../src/notify.js');
+        if (updMod?.hasVersionSkew) {
+          let warnedSkew = false;
+          setInterval(() => {
+            const action = updMod.daemonSkewAction({
+              skewed: updMod.hasVersionSkew(),
+              // Unknown means assume supervised: that is how the daemon is
+              // installed for all but a handful of users, and it preserves the
+              // long-standing behavior when install.js could not be loaded.
+              supervised: installMod?.isSupervised ? installMod.isSupervised() : true,
+              alreadyWarned: warnedSkew,
+            });
+            if (action === 'restart') controller.abort();
+            else if (action === 'warn') {
+              warnedSkew = true;
+              const msg = 'package was upgraded on disk but this daemon is not supervised — '
+                + 'still running the old code; '
+                + (onDemand ? 'run `unsnooze install --daemon` to restart it' : 'restart it to pick up the new version');
+              loggerMod?.log('daemon', msg);
+              notifyMod?.notify('unsnooze needs a restart', msg, { priority: 4 });
+            }
+          }, 15 * 60_000).unref();
+        }
+        // Daily update check from the daemon: GUI-only users never run CLI
+        // commands, so this is what gets them the "new version" desktop toast.
+        const { spawnDetached } = spawnMod;
+        spawnDetached(['_update-check']);
+        setInterval(() => spawnDetached(['_update-check']), 24 * 3_600_000).unref();
+        return await runResumer({ persistent: true, watcher: createWatcher(), signal: controller.signal });
+      } finally {
+        releaseDaemon?.();
       }
-      // Daily update check from the daemon: GUI-only users never run CLI
-      // commands, so this is what gets them the "new version" desktop toast.
-      const spawnMod = await safeImport('../src/spawn.js');
-      if (!spawnMod) return 0;
-      const { spawnDetached } = spawnMod;
-      spawnDetached(['_update-check']);
-      setInterval(() => spawnDetached(['_update-check']), 24 * 3_600_000).unref();
-      return runResumer({ persistent: true, watcher: createWatcher(), signal: controller.signal });
     }
     case 'help':
     case '-h':

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unsnooze",
-  "version": "1.19.0",
+  "version": "1.19.2",
   "description": "Automatically resume Claude Code, Codex CLI, Grok, Qwen Code, Kimi CLI, OpenCode, Antigravity, and Cursor CLI sessions when 5-hour or weekly usage limits reset—on macOS, Linux and Windows, with or without a terminal multiplexer.",
   "keywords": [
     "claude",