unsnooze 1.19.1 → 1.19.3

package/CHANGELOG.md

@@ -1,5 +1,113 @@
 # Changelog
 
+## 1.19.3 — 2026-09-30
+
+Codex fixes from a single herdr report: stops that were missed, woken late,
+or woken in the wrong place.
+
+- The out-of-credits screen on Plus plans no longer hides a usage limit. Its
+  Upgrade / Add Credits picker pushed the banner off the part of the pane
+  unsnooze reads; the "Your rate limit resets on" line is now recognised
+  instead (#36).
+- A reset time that a narrow pane wraps onto the next row is read correctly,
+  instead of falling back to guessing and probing (#33).
+- A Codex stop is only marked resumed once its session log shows new output.
+  A keypress or tab switch that briefly hides the banner no longer drops the
+  stop and its exact reset time. Stops with no session log keep the old
+  behaviour (#34).
+- A session running in herdr (or any non-default multiplexer) keeps its pane
+  address when a second detection of the same stop comes in, so it is woken
+  in its own pane instead of reopened beside it (#35).
+
+## 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

package/README.md

@@ -265,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`.
 
@@ -384,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)
@@ -767,17 +769,26 @@ 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.
-
-Three 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). 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
+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

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.1",
+  "version": "1.19.3",
   "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",

package/src/agents/codex.js

@@ -14,6 +14,7 @@ import { openSync, readSync, closeSync, readdirSync, statSync, existsSync } from
 import { join, basename } from 'node:path';
 import { CODEX_DIR } from '../config.js';
 import { findOnPath } from '../which.js';
+import { stripVTControlCharacters } from 'node:util';
 
 // Since the 2026 unified ChatGPT desktop app absorbed the Codex app, the codex
 // binary ships INSIDE the app bundle and many machines have no standalone
@@ -77,13 +78,19 @@ const LIMIT_ANCHORS = [
   /You['’]ve hit your usage limit/i,   // the desktop app also emits a curly apostrophe
   /Your workspace is out of credits/i,
   /hit your spend cap/i,
+  // Plus plan: an out-of-credits picker sits under the banner and can push it
+  // past the 12-line scan (#36). This line stays inside it and carries the time.
+  /Your rate limit resets on/i,
 ];
 
 export const patterns = {
   limitPatterns: LIMIT_ANCHORS,
   // The whole banner is ONE line, so the anchors double as reset lines — the
   // proximity engine then hands that line to time-parser (which falls back to
-  // the 5h default for "Try again later.").
+  // the 5h default for "Try again later."). A narrow pane soft-wraps that
+  // line, which can strand the clock on a later row; bannerWraps tells the
+  // engine to rejoin the rows before parsing.
+  bannerWraps: true,
   resetPatterns: [
     /try again at/i,
     /try again in \d+/i,
@@ -101,6 +108,26 @@ export const patterns = {
   transientPatterns: [/stream error/i, /exceeded retry limit/i],
 };
 
+// A submitted user turn uses the same › glyph as the composer. Only accept
+// the LAST prompt, followed directly by a blank line and Codex's status footer.
+// ponytail: truncated/collapsed pastes cannot be proved; leave those for the user.
+export function pendingCodexPrompt(text, message) {
+  if (!message) return false;
+  const lines = stripVTControlCharacters(text).split('\n');
+  const start = lines.findLastIndex(line => /^\s*›/.test(line));
+  if (start < 0) return false;
+  const tail = lines.slice(start + 1);
+  const footer = tail.findIndex((line, i) => i > 0 && !tail[i - 1].trim()
+    && (/\s·\s/.test(line) || /(?:\d+% context left|\? for shortcuts)/.test(line)));
+  if (footer < 0) return false;
+  if (tail.slice(footer + 1).some(line => line.trim()
+    && !/(?:\d+% context left|\? for shortcuts)/.test(line))) return false;
+  // Ignore wrapping and the extra newline swallowed by paste-burst handling.
+  const compact = value => value.replace(/\s/g, '');
+  const draft = [lines[start].replace(/^\s*›\s?/, ''), ...tail.slice(0, footer)].join('\n');
+  return compact(draft) === compact(message);
+}
+
 // Sessions live in ~/.codex/sessions/YYYY/MM/DD/rollout-{ts}-{THREAD}.jsonl;
 // the first JSONL line carries the session cwd. Conservative: no cwd match →
 // null (the resumer then uses `codex resume --last`, which codex itself scopes
@@ -164,6 +191,30 @@ export function latestSessionId(cwd, aroundTs = null, sessionsRoot = join(CODEX_
   return null;
 }
 
+// The rollout file a thread is writing to now: the newest of its files. A
+// reverted thread continues in a second `…_<rollout id>` file, which is where
+// a resumed turn lands.
+export function rolloutPathFor(sessionId, sessionsRoot = join(CODEX_DIR, 'sessions')) {
+  if (!sessionId) return null;
+  const want = String(sessionId).toLowerCase();
+  let best = null;
+  const walk = (dir, depth) => {
+    let entries;
+    try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return; }
+    for (const e of entries) {
+      const p = join(dir, e.name);
+      if (e.isDirectory() && depth < 3) { walk(p, depth + 1); continue; }
+      const m = e.isFile() && e.name.match(ROLLOUT_RE);
+      if (!m || m[1].toLowerCase() !== want) continue;
+      let mtime;
+      try { mtime = statSync(p).mtimeMs; } catch { continue; }
+      if (!best || mtime > best.mtime) best = { path: p, mtime };
+    }
+  };
+  walk(sessionsRoot, 0);
+  return best ? best.path : null;
+}
+
 export default {
   id: 'codex',
   name: 'OpenAI Codex CLI',

package/src/agents/opencode.js

@@ -51,10 +51,11 @@ export const patterns = {
   terminalPatterns: [/insufficient credits/i, /out of credits/i],
 };
 
+// windowsHide: the console-less daemon calls this too (see workspace.js).
 function runSessionList() {
   return execFileSync(process.env.UNSNOOZE_OPENCODE_BIN || 'opencode',
     ['session', 'list', '--format', 'json'],
-    { timeout: 5000, encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] });
+    { timeout: 5000, encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'], windowsHide: true });
 }
 
 // `opencode session list --format json` — sessions live in a SQLite db, so ask

package/src/config.js

@@ -258,9 +258,24 @@ export const MUX_NAMES = ['tmux', 'zellij', 'herdr', 'cmux', 'headless'];
 // Where a headless revive tees the agent's output. There is no pane to scroll
 // back through, so the log is the only record of what an unattended run did.
 export const HEADLESS_LOG_DIR = join(STATE_DIR, 'headless');
-// The daemon's Windows Task Scheduler entry (install.js creates it; doctor names it).
+// The logon Scheduled Task that unsnooze <= 1.19.1 registered for the daemon.
+// Nothing creates it any more (see DAEMON_ON_DEMAND); uninstall still removes
+// one an older install left behind.
 export const WINDOWS_TASK_NAME = 'unsnooze';
 
+// The daemon on native Windows. There is no launchd/systemd to hand it to, and
+// every way of starting a program at sign-in — a Scheduled Task, a Run key, the
+// Startup folder — is what antivirus heuristics are trained to call malware
+// persistence: Microsoft Defender flagged `schtasks /create /sc onlogon` as
+// Trojan:Win32/Commando.A!ml. So nothing is registered with Windows. This
+// marker is the whole record (install --daemon writes it), and while it exists
+// the wrappers and the StopFailure hook start the daemon whenever it is not
+// running.
+export const DAEMON_ON_DEMAND = join(STATE_DIR, 'daemon-on-demand');
+// Which daemon is running (Windows only). Its mtime is a heartbeat, so a pid
+// that Windows recycled after a crash or a sign-out is not mistaken for it.
+export const DAEMON_PIDFILE = join(STATE_DIR, 'daemon.pid');
+
 // Pane scanning
 export const PANE_SCAN_LINES = envInt('UNSNOOZE_PANE_SCAN_LINES', 12);
 export const CAPTURE_LINES = envInt('UNSNOOZE_CAPTURE_LINES', 200);

package/src/doctor.js

@@ -20,7 +20,7 @@ import { fishConfigPath } from './fish.js';
 import { listAgents } from './agents/index.js';
 import { getConfig } from './settings.js';
 import { resolveBin } from './which.js';
-import { WINDOWS_TASK_NAME, CLAUDE_DIR, CODEX_DIR } from './config.js';
+import { CLAUDE_DIR, CODEX_DIR } from './config.js';
 
 const log = makeLogger('doctor');
 
@@ -345,12 +345,11 @@ export function agentBinFindings({
 } = {}) {
   const findings = [];
   const envVar = id => `UNSNOOZE_${String(id).toUpperCase()}_BIN`;
-  // Two commands, not `a && b`: && only exists from PowerShell 7, and the
+  // One command, never `a && b`: && only exists from PowerShell 7, and the
   // Windows PowerShell 5.1 that ships with the OS is a supported shell.
   const windowsNote = platform === 'win32'
-    ? `\n  the daemon's Scheduled Task keeps the PATH it had at logon; after an agent update, run\n`
-      + `  schtasks /end /tn ${WINDOWS_TASK_NAME}\n`
-      + `  schtasks /run /tn ${WINDOWS_TASK_NAME}   (or sign out and in)`
+    ? `\n  the daemon keeps the PATH of whatever started it; once this shell finds the agent,\n`
+      + `  restart it from here with: unsnooze install --daemon   (or sign out and back in)`
     : '';
   for (const agent of agents) {
     if (!agent?.id || !enabled(agent.id)) continue;

package/src/hook.js

@@ -16,7 +16,7 @@ import { parseResetTime, resetAtMs } from './time-parser.js';
 import { upsertSession } from './state.js';
 import { latestRateLimitFromTranscript } from './watchers/claude.js';
 import { getMultiplexer } from './multiplexer.js';
-import { spawnResumerIfNeeded } from './spawn.js';
+import { spawnResumerIfNeeded, ensureDaemon } from './spawn.js';
 import { makeLogger } from './logger.js';
 import { addressHash } from './lease.js';
 import { prepareCalibrationSample, applyCalibrationToState } from './usage.js';
@@ -56,11 +56,15 @@ export function hookContext(env = process.env, payload = {}) {
   return { muxName, pane, paneOwner };
 }
 
-export async function runHook(rest = []) {
+export async function runHook(rest = [], { ensureDaemonFn = ensureDaemon } = {}) {
   try {
     const agentIdx = rest.indexOf('--agent');
     const agent = getAgent(agentIdx !== -1 ? rest[agentIdx + 1] : 'claude');
     if (!getConfig(`agents.${agent.id}`)) return 0;   // agent disabled in settings
+    // Nothing keeps the daemon running on native Windows (see ensureDaemon),
+    // and the hook is the one entry point GUI Claude sessions pass through —
+    // so it makes sure the daemon is up. A no-op everywhere else.
+    ensureDaemonFn();
     const raw = await readStdin();
     let payload = {};
     try { payload = JSON.parse(raw); } catch { /* tolerate non-JSON */ }