unsnooze 1.19.0 → 1.19.2

package/src/agents/codex.js

@@ -11,8 +11,10 @@
 // the overload path, never the ledger.
 
 import { openSync, readSync, closeSync, readdirSync, statSync, existsSync } from 'node:fs';
-import { join } from 'node:path';
+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
@@ -21,21 +23,59 @@ import { CODEX_DIR } from '../config.js';
 // codex-cli 0.144 from ChatGPT.app).
 export const CHATGPT_CODEX_BIN = '/Applications/ChatGPT.app/Contents/Resources/codex';
 
-function codexOnPath(env = process.env) {
-  return (env.PATH || '').split(':').some(dir => {
-    try { return dir && existsSync(join(dir, 'codex')); } catch { return false; }
-  });
+// Windows keeps the Desktop/Store install's CLI under a versioned runtime
+// directory — %LOCALAPPDATA%\OpenAI\Codex\bin\<hash>\codex.exe — whose name
+// changes on every update. The interactive shell finds it through a PATH the
+// app rewrote; a daemon started at logon keeps the PATH it was born with,
+// which after an update names a directory that no longer exists (#25). So
+// look the directory up at launch time and take the newest runtime, the way
+// CHATGPT_CODEX_BIN covers the macOS bundle. Layout as reported by the
+// issue's Microsoft Store install; a machine without it just gets null.
+export function windowsBundledCodex({ env = process.env, readdir = readdirSync, stat = statSync } = {}) {
+  if (!env.LOCALAPPDATA) return null;
+  const base = join(env.LOCALAPPDATA, 'OpenAI', 'Codex', 'bin');
+  let entries;
+  try { entries = readdir(base, { withFileTypes: true }); } catch { return null; }
+  let best = null;
+  for (const e of entries) {
+    if (!e.isDirectory()) continue;
+    const exe = join(base, e.name, 'codex.exe');
+    let mtime;
+    try { mtime = stat(exe).mtimeMs; } catch { continue; }
+    if (!best || mtime > best.mtime) best = { exe, mtime };
+  }
+  return best ? best.exe : null;
 }
 
-export function resolveCodexBin({ env = process.env, onPath = () => codexOnPath(env), exists = existsSync } = {}) {
+// What to spawn for codex. Order, on Windows: an explicit UNSNOOZE_CODEX_BIN,
+// a codex.exe on PATH (spawn resolves the bare name itself), the newest
+// Desktop/Store runtime, then a .cmd/.bat shim on PATH by full path — Node
+// refuses to spawn those without a shell, and a full path makes the launcher's
+// error say which file it was. Elsewhere: PATH, then the macOS app bundle.
+export function resolveCodexBin({
+  env = process.env,
+  platform = process.platform,
+  exists = existsSync,
+  onPath = null,
+  bundled = () => windowsBundledCodex({ env }),
+} = {}) {
   if (env.UNSNOOZE_CODEX_BIN) return env.UNSNOOZE_CODEX_BIN;
-  if (onPath()) return 'codex';
+  if (platform === 'win32') {
+    if (findOnPath(['codex.exe'], { env, exists, platform })) return 'codex';
+    const runtime = bundled();
+    if (runtime) return runtime;
+    const shim = findOnPath(['codex.cmd', 'codex.bat'], { env, exists, platform });
+    if (shim) return shim.path;
+    return 'codex';
+  }
+  const found = onPath ? onPath() : !!findOnPath(['codex'], { env, exists, platform });
+  if (found) return 'codex';
   if (exists(CHATGPT_CODEX_BIN)) return CHATGPT_CODEX_BIN;
   return 'codex';   // neither — the launcher degrades gracefully on spawn error
 }
 
 const LIMIT_ANCHORS = [
-  /You've hit your usage limit/i,
+  /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,
 ];
@@ -62,11 +102,48 @@ export const patterns = {
   transientPatterns: [/stream error/i, /exceeded retry limit/i],
 };
 
-// Sessions live in ~/.codex/sessions/YYYY/MM/DD/rollout-{ts}-{UUID}.jsonl;
+// 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
 // to the launch cwd).
-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;
+//
+// A reverted thread (the desktop app's edit/regenerate, `/undo`) continues in
+// rollout-{ts}-{THREAD}_{ROLLOUT}.jsonl — codex-rs/rollout/src/rollout_file_name.rs:
+// "filenames for reverted threads append an underscore and a distinct rollout
+// ID after the stable thread ID". Group 1 is always the thread id, which is
+// the id `codex resume` takes; the rollout id after the underscore is not.
+const UUID = '[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}';
+export const ROLLOUT_RE = new RegExp(`^rollout-.*-(${UUID})(?:_${UUID})?\\.jsonl$`, 'i');
+
+// The thread uuid a rollout path names, or null for anything else. Cheaper than
+// rolloutMeta() (no read) and the same id in every rollout seen so far. A
+// reverted thread's `…_<rollout id>` file names the same thread, so usage
+// readings compare across the two files of one conversation.
+export function rolloutId(path) {
+  if (typeof path !== 'string') return null;
+  const m = basename(path).match(ROLLOUT_RE);
+  return m ? m[1].toLowerCase() : null;
+}
 
 function fileHead(path, bytes = 4096) {
   let fd;
@@ -115,12 +192,40 @@ export default {
   experimental: false,
   patterns,
   menu: null,                      // no interactive limit menu
+  // What to do about a workspace wall (credits depleted, a spend cap): no
+  // window reset clears it, so the resumer's ceiling notification names this.
+  // Not `unsnooze resume-now`: the hold leaves the record failed, and
+  // resume-now only wakes stopped ones — it would answer "no matching stopped
+  // sessions" to the one command the notification told the user to run.
+  modelRemedy: 'add credits or raise the spend cap in the ChatGPT workspace (or ask its owner to), then continue the session in Codex',
   // Resume takes the prompt in argv — `codex resume <id> "msg"` starts the turn
   // immediately, nothing to type into the TUI.
-  resumeArgs(sessionId, message) {
+  //
+  // canType: false (headless — no pane): the TUI cannot run there at all. It
+  // refuses a non-TTY stdin before it looks at the session ("Error: stdin is
+  // not a terminal", exit 1 — reproduced against codex-cli 0.150 with the
+  // headless backend's exact stdio), so `codex exec resume <id> "msg"` carries
+  // the same conversation forward non-interactively instead (#25). With
+  // --last, codex reads a lone positional as the prompt, not a session id.
+  //
+  // `exec` also refuses any directory that is not a git repository unless
+  // told --skip-git-repo-check ("Not inside a trusted directory…", exit 1),
+  // a guard the TUI never had: without the flag, a session that ran in a
+  // plain folder could never be revived headless. It is the user's own
+  // session, resumed where it already ran, so the flag goes on.
+  //
+  // extraArgsAt: resumeExtraArgs go right after `exec`, not at the end. The
+  // `resume` subcommand rejects -s/--sandbox, -p/--profile and --add-dir
+  // ("unexpected argument", exit 2) — exactly what a user sets to match
+  // their normal launch — while `exec` takes them. (TUI-only flags such as
+  // -a or --search have no exec equivalent and still fail, visibly.)
+  resumeArgs(sessionId, message, { canType = true } = {}) {
+    const tail = sessionId ? [sessionId, message] : ['--last', message];
+    if (canType) return { args: ['resume', ...tail], messageViaPane: false };
     return {
-      args: sessionId ? ['resume', sessionId, message] : ['resume', '--last', message],
+      args: ['exec', '--skip-git-repo-check', 'resume', ...tail],
       messageViaPane: false,
+      extraArgsAt: 1,
     };
   },
   // v1: every agent launches the bare TUI and gets the prompt typed once idle.

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/cli.js

@@ -90,6 +90,10 @@ export async function cmdStatus(args = []) {
       sessions: Object.values(state.sessions).map(s => ({
         key: s.key, sessionId: s.sessionId ?? null, agent: s.agent ?? 'claude',
         cwd: s.cwd ?? null, status: s.status, limitType: s.limitType ?? null,
+        // Why the provider refused, when it said (Codex's rate_limit_reached_type,
+        // e.g. workspace_member_credits_depleted) — the reason a stop is probed
+        // and held rather than scheduled.
+        limitReason: s.limitReason ?? null,
         resetAt: s.resetAt ?? null, resetSource: s.resetSource ?? null,
         mux: s.mux ?? null, pane: s.pane ?? null, muxSession: s.muxSession ?? null,
         attempts: s.attempts ?? 0, lastError: s.lastError ?? null,

package/src/config.js

@@ -229,6 +229,10 @@ export const PROBE_INTERVAL_MS = envInt('UNSNOOZE_PROBE_INTERVAL_MS', 15 * 60_00
 export const PROBE_MAX_MS = envInt('UNSNOOZE_PROBE_MAX_MS', 60 * 60_000);
 export const STAGGER_MS = envInt('UNSNOOZE_STAGGER_MS', 8_000);
 export const VERIFY_DELAY_MS = envInt('UNSNOOZE_VERIFY_DELAY_MS', 20_000);
+// A headless revival still running at verify time is watched this long before
+// it counts as resumed: the failures worth catching (an auth refresh that gives
+// up, a retry loop on a bad network) take longer than VERIFY_DELAY_MS to exit.
+export const HEADLESS_SETTLE_MS = envInt('UNSNOOZE_HEADLESS_SETTLE_MS', 2 * 60_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);
@@ -254,6 +258,23 @@ 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 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);

package/src/doctor.js

@@ -17,6 +17,10 @@ import { shouldUseTui, formatDoctorTui } from './tui.js';
 import { designRegisteredOffline } from './design.js';
 import { powershellProfilePath } from './powershell.js';
 import { fishConfigPath } from './fish.js';
+import { listAgents } from './agents/index.js';
+import { getConfig } from './settings.js';
+import { resolveBin } from './which.js';
+import { CLAUDE_DIR, CODEX_DIR } from './config.js';
 
 const log = makeLogger('doctor');
 
@@ -187,6 +191,11 @@ export async function runDoctor({
   profileContent = undefined,
   autostartDir = null,
   stateDir = STATE_DIR,
+  env = process.env,
+  exists = existsSync,
+  agents = listAgents(),
+  enabled = id => !!getConfig(`agents.${id}`),
+  inUse = agentInUse,
 } = {}) {
   const findings = [];
 
@@ -288,6 +297,14 @@ export async function runDoctor({
     }
   } catch { /* best-effort: a PATH check must never break doctor */ }
 
+  // What each enabled agent would actually be launched as — resolved the way
+  // the launcher resolves it, from this environment. #25 was a daemon whose
+  // logon-time PATH no longer named the Codex runtime directory; every revival
+  // died with ENOENT and nothing said so until the headless log was read.
+  // Doctor cannot see the daemon's environment, only its own, so on Windows
+  // it also says how the two can differ.
+  for (const f of agentBinFindings({ platform, env, exists, agents, enabled, inUse })) findings.push(f);
+
   findings.push({
     id: 'daemon', kind: 'info',
     title: daemonRunning() ? 'resumer/daemon: running' : 'resumer/daemon: not running (starts on the next limit stop)',
@@ -310,6 +327,65 @@ export async function runDoctor({
   return { findings, healthy };
 }
 
+// claude and codex are enabled by default, so "enabled" does not mean "used
+// here": a machine that has only ever run one of them has nothing of the
+// other's to revive, and must not be reported unhealthy for lacking its
+// binary. Their own data directories say whether they have run here. The
+// other agents are opt-in; the user switching one on is evidence enough.
+const AGENT_HOMES = { claude: CLAUDE_DIR, codex: CODEX_DIR };
+export function agentInUse(id, { exists = existsSync } = {}) {
+  const home = AGENT_HOMES[id];
+  return home ? exists(home) : true;
+}
+
+export function agentBinFindings({
+  platform = process.platform, env = process.env, exists = existsSync,
+  agents = listAgents(), enabled = id => !!getConfig(`agents.${id}`),
+  inUse = agentInUse,
+} = {}) {
+  const findings = [];
+  const envVar = id => `UNSNOOZE_${String(id).toUpperCase()}_BIN`;
+  // 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 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;
+    const bin = agent.bin;
+    let resolved = null;
+    try { resolved = resolveBin(bin, { env, exists, platform }); } catch { resolved = null; }
+    if (resolved?.launchable) {
+      findings.push({
+        id: `agent-bin-${agent.id}`, kind: 'info',
+        title: `${agent.id}: ${resolved.path}`,
+        detail: '',
+      });
+    } else if (resolved) {
+      findings.push({
+        id: `agent-bin-${agent.id}`, kind: 'health',
+        title: `${agent.id} resolves to ${resolved.path}, a .cmd/.bat shim that cannot be launched directly`,
+        detail: `  set ${envVar(agent.id)} to the agent's .exe`,
+      });
+    } else if (!inUse(agent.id)) {
+      findings.push({
+        id: `agent-bin-${agent.id}`, kind: 'info',
+        title: `${agent.id}: not installed (no ${agent.id} sessions here to revive)`,
+        detail: '',
+      });
+    } else {
+      findings.push({
+        id: `agent-bin-${agent.id}`, kind: 'health',
+        title: `${agent.id} is not launchable from this environment (${bin} not found)`,
+        detail: `  every revival of a ${agent.id} session will fail with ENOENT\n`
+          + `  install it, put it on PATH, or set ${envVar(agent.id)}${windowsNote}`,
+      });
+    }
+  }
+  return findings;
+}
+
 // --- fixes ------------------------------------------------------------------------
 
 function defaultKill(pid) {

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 */ }

package/src/install.js

@@ -14,14 +14,14 @@
 import { readFileSync, writeFileSync, renameSync, existsSync, copyFileSync, rmSync, mkdirSync, unlinkSync } from 'node:fs';
 import { execFileSync } from 'node:child_process';
 import { homedir, userInfo } from 'node:os';
-import { join, dirname, delimiter } from 'node:path';
-import { CLAUDE_SETTINGS, STATE_DIR } from './config.js';
+import { join, dirname, basename, delimiter } from 'node:path';
+import { CLAUDE_SETTINGS, STATE_DIR, WINDOWS_TASK_NAME, DAEMON_ON_DEMAND } from './config.js';
 import { getConfig, configFileExists } from './settings.js';
 import { xmlEscape } from './notify.js';
 import { installGrokHooks, uninstallGrokHooks } from './agents/grok.js';
 import { getAgent } from './agents/index.js';
 import { findCsgProcesses, findCsgAutostarts } from './doctor.js';
-import { UNSNOOZE_BIN, stopResumer } from './spawn.js';
+import { UNSNOOZE_BIN, stopResumer, restartDaemon, stopDaemon } from './spawn.js';
 import { uninstallStatuslineShim } from './usage.js';
 import { powershellProfilePath } from './powershell.js';
 import { fishConfigPath } from './fish.js';
@@ -248,12 +248,13 @@ export function installFishBlock(content, agents = ['claude'], bin = UNSNOOZE_BI
 // 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.
+// user unit on Linux/WSL. Native Windows deliberately gets neither a unit nor
+// a Scheduled Task — the daemon is started on demand there (DAEMON_ON_DEMAND).
 
 export const DAEMON_LABEL = 'com.unsnooze.daemon';
-// Task Scheduler has no reverse-DNS convention and shows this name to the user
-// in taskschd.msc, so it is a plain word rather than the launchd label.
-export const WINDOWS_TASK_NAME = 'unsnooze';
+// The Scheduled Task name unsnooze <= 1.19.1 used; kept for the uninstall that
+// removes one left behind.
+export { WINDOWS_TASK_NAME };
 
 // Is this process running under the supervisor we install, rather than from
 // somebody's shell? It decides whether exiting is safe: a supervised daemon
@@ -269,14 +270,15 @@ export const WINDOWS_TASK_NAME = 'unsnooze';
 export function isSupervised({ platform = process.platform, env = process.env } = {}) {
   if (platform === 'darwin') return env.XPC_SERVICE_NAME === DAEMON_LABEL;
   if (platform === 'linux') return typeof env.INVOCATION_ID === 'string' && env.INVOCATION_ID !== '';
-  // win32 stays false on purpose, even though we now install a Scheduled Task.
-  // launchd KeepAlive and systemd Restart=always bring the daemon straight
-  // back; a logon-triggered task does not restart anything until the next
-  // logon. Answering true here would let the version-skew guard exit 0 into
-  // nothing and stop Windows watching silently — the exact failure mode of
-  // issue #8, just with a different trigger. The cost is that a Windows daemon
-  // keeps running pre-upgrade code until the user logs back in; that is the
-  // lesser of the two, and `unsnooze doctor` reports the skew.
+  // win32 stays false on purpose. launchd KeepAlive and systemd Restart=always
+  // bring the daemon straight back; on Windows it is only started again by the
+  // next wrapped launch or StopFailure hook, which may be hours away. Answering
+  // true here would let the version-skew guard exit 0 into nothing and stop
+  // Windows watching silently — the exact failure mode of issue #8, just with a
+  // different trigger. The cost is that a Windows daemon keeps running
+  // pre-upgrade code until it is restarted (a sign-out, or re-running
+  // `unsnooze install --daemon`); that is the lesser of the two, and
+  // `unsnooze doctor` reports the skew.
   return false;
 }
 
@@ -434,20 +436,49 @@ function defaultActivate(cmd, args) {
   }
 }
 
+// Native Windows keeps its "unit" in the state dir: a marker that asks for the
+// daemon to be started on demand. `dir` relocates it, as it does the unit dir
+// elsewhere.
+function onDemandMarker(dir) {
+  return dir ? join(dir, basename(DAEMON_ON_DEMAND)) : DAEMON_ON_DEMAND;
+}
+
+const ON_DEMAND_NOTE = 'While this file exists, the unsnooze daemon is started on demand — by the\n'
+  + 'agent wrappers and the StopFailure hook — whenever it is not running. Nothing\n'
+  + 'is registered to run at sign-in. `unsnooze uninstall` removes this file.\n';
+
+// unsnooze <= 1.19.1 registered the daemon as a logon Scheduled Task. Nothing
+// creates one now, but an install from then may still have it; uninstall
+// removes it. Ask before deleting, so a machine that never had one — most of
+// them: creating it needed an elevated shell — only ever sees a read-only
+// query. /f so the delete is not an interactive prompt. 'removed', 'stuck'
+// (it exists but the delete failed — a task created from an elevated shell
+// can need one to delete), or null when there was none.
+export function removeLegacyScheduledTask({ activate = defaultActivate } = {}) {
+  if (!activate('schtasks', ['/query', '/tn', WINDOWS_TASK_NAME])) return null;
+  return activate('schtasks', ['/delete', '/f', '/tn', WINDOWS_TASK_NAME]) ? 'removed' : 'stuck';
+}
+
 export function installDaemonAutostart({
   platform = process.platform, dir = null, activate = defaultActivate, path = undefined,
+  start = restartDaemon,
 } = {}) {
-  // Native Windows has no unit *file* — the Task Scheduler holds the record —
-  // so it is handled before the file-based platforms below. It matters more
-  // here than anywhere else: the transcript watcher lives in the daemon, and
-  // headless has no pane monitor to fall back on, so without this a Windows
-  // machine only ever catches limit stops through the StopFailure hook.
+  // Native Windows matters more than anywhere: the transcript watcher lives in
+  // the daemon, and headless has no pane monitor to fall back on. But nothing
+  // is registered with Windows to start it. Up to 1.19.1 this created a logon
+  // Scheduled Task (`schtasks /create /sc onlogon /tr "node … daemon"`), and
+  // Microsoft Defender flagged setup as Trojan:Win32/Commando.A!ml for it —
+  // an interpreter running a script from %APPDATA% at every logon is exactly
+  // how malware persists, and any logon entry (Run key, Startup folder) reads
+  // the same way. Without elevation schtasks refused the task anyway. So the
+  // daemon is started now, and started again on demand (spawn.js ensureDaemon).
   if (platform === 'win32') {
-    // /f overwrites an existing task rather than failing with "already exists",
-    // which is what re-running setup does every time.
-    activate('schtasks', ['/create', '/f', '/tn', WINDOWS_TASK_NAME, '/sc', 'onlogon',
-      '/tr', `"${process.execPath}" "${UNSNOOZE_BIN}" daemon`]);
-    return `Scheduled Task \\${WINDOWS_TASK_NAME}`;
+    const marker = onDemandMarker(dir);
+    atomicWrite(marker, ON_DEMAND_NOTE);
+    // Same interlock as the unit platforms below: the real starter only runs
+    // for the marker it would actually read.
+    if (start !== restartDaemon || marker === DAEMON_ON_DEMAND) start();
+    return marker;
   }
   const target = autostartUnitPath({ platform, dir });
   if (!target) return null;
@@ -528,11 +559,30 @@ export function healDaemonAutostart({
   return installDaemonAutostart({ platform, dir, activate, path: better });
 }
 
-export function uninstallDaemonAutostart({ platform = process.platform, dir = null, activate = defaultActivate } = {}) {
+export function uninstallDaemonAutostart({
+  platform = process.platform, dir = null, activate = defaultActivate, stop = stopDaemon,
+  say = () => {},
+} = {}) {
   if (platform === 'win32') {
-    // /f so a missing task is not an interactive prompt on an uninstall path.
-    activate('schtasks', ['/delete', '/f', '/tn', WINDOWS_TASK_NAME]);
-    return `Scheduled Task \\${WINDOWS_TASK_NAME}`;
+    const removed = [];
+    // The marker first, so nothing starts the daemon again once it is stopped
+    // (and an on-demand daemon that is only now starting sees it gone).
+    const marker = onDemandMarker(dir);
+    if (existsSync(marker)) {
+      try { unlinkSync(marker); removed.push(marker); } catch { /* still there — not reported as removed */ }
+    }
+    const live = marker === DAEMON_ON_DEMAND;
+    if (stop !== stopDaemon || live) stop();
+    // The interlock again: a relocated marker is a fixture, and the machine's
+    // real Task Scheduler is none of its business.
+    const act = (activate === defaultActivate && !live) ? () => false : activate;
+    const legacy = removeLegacyScheduledTask({ activate: act });
+    if (legacy === 'removed') removed.push(`Scheduled Task \\${WINDOWS_TASK_NAME}`);
+    else if (legacy === 'stuck') {
+      say(`could not delete the Scheduled Task \\${WINDOWS_TASK_NAME} an earlier version created; `
+        + `from an administrator shell run: schtasks /delete /tn ${WINDOWS_TASK_NAME} /f`);
+    }
+    return removed.length ? removed.join(' and ') : null;
   }
   if (platform === 'darwin') {
     const target = join(dir || autostartDir(platform), `${DAEMON_LABEL}.plist`);
@@ -696,8 +746,21 @@ export function cmdInstall(rest, { agents = enabledAgents() } = {}) {
 
   // 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`);
+    // On Windows the start's outcome is kept, so the message can be honest.
+    let started = null;
+    const target = installDaemonAutostart(process.platform === 'win32'
+      ? { start: () => { started = restartDaemon(); } } : {});
+    if (target && process.platform === 'win32') {
+      if (started) console.log(`unsnooze: daemon started in the background (pid ${started}) — GUI sessions are watched`);
+      else console.log('unsnooze: the daemon did not start — run `unsnooze daemon` to see why');
+      console.log('unsnooze: nothing is registered to run at sign-in (no Scheduled Task); your wrapped');
+      console.log('unsnooze: agents and the Claude hook start the daemon again whenever it is not running');
+      // A task left by 1.19.1 or earlier is deliberately not looked for here:
+      // node.exe spawning schtasks.exe is the pairing Defender reacted to, and
+      // setup should spawn nothing of the kind. Such a task only starts this
+      // same daemon at sign-in, which the pidfile tolerates; uninstall removes
+      // it.
+    } else 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');
   }
 
@@ -724,7 +787,16 @@ export function cmdUninstall(rest) {
   const opts = parseArgs(rest);
   const explicitRc = rest.includes('--zshrc');
 
-  // Stop the resumer/daemon first so it cannot keep writing state after hooks
+  // Whatever starts the daemon goes first — the launchd/systemd unit, or on
+  // Windows the marker the wrappers and the hook consult — so nothing can
+  // start it again mid-uninstall. On Windows this order also stops the daemon
+  // while its pidfile still proves which process it is, not after
+  // stopResumer has killed it and left a pid that may already be someone
+  // else's.
+  const autostart = uninstallDaemonAutostart({ say: m => console.log(`unsnooze: ${m}`) });
+  if (autostart) console.log(`unsnooze: daemon autostart removed (${autostart})`);
+
+  // Stop the resumer/daemon so it cannot keep writing state after hooks
   // are gone (zombie-daemon-running-deleted-code failure mode).
   try {
     const result = stopResumer();
@@ -780,9 +852,6 @@ export function cmdUninstall(rest) {
     }
   }
 
-  const autostart = uninstallDaemonAutostart();
-  if (autostart) console.log(`unsnooze: daemon autostart removed (${autostart})`);
-
   // Restore Claude statusLine if our usage shim was chained in.
   try {
     const r = uninstallStatuslineShim({ settingsPath: opts.settings });