unsnooze 1.19.4 → 1.19.5

package/CHANGELOG.md

@@ -1,5 +1,38 @@
 # Changelog
 
+## 1.19.5 — 2026-10-05
+
+Sessions resume again under psmux, Antigravity no longer wakes early, and
+`unsnooze update` updates the copy you are running.
+
+### psmux (tmux on native Windows)
+
+- Every Claude revival in psmux failed five times with `ready timeout`. psmux
+  ran the launch command through a shell, so the space in
+  `C:\Program Files\nodejs\node.exe` closed the window before Claude started.
+  Each revival now opens its own psmux session with its arguments passed
+  through as-is, which also keeps a Codex resume message in one piece (#43).
+- A resume message can no longer be typed into an unrelated window. psmux
+  sends keys for a pane that has closed to some other pane, and every psmux
+  session numbers its first pane `%1`. unsnooze now addresses panes as
+  `session:%N` and checks the pane still exists before reading or typing (#43).
+
+### Antigravity (`agy`)
+
+- A session could be woken hours before its quota came back. The `Resets in
+  3h` countdown was dated from the last prompt sent in that folder, which can
+  be much older than the banner. It is now dated from when unsnooze reads the
+  banner, so a wake can be slightly late but not early (#40).
+
+### `unsnooze update`
+
+- With two npm installs on one machine (for example unsnooze under `~/.local`
+  and nvm's npm first on PATH), the update went into the other npm's folder
+  and the running copy never changed. The update now targets the folder the
+  running copy was installed into (#41).
+- It no longer prints "already up to date" when a newer version is known and
+  this copy did not change. It says what happened and exits with an error (#41).
+
 ## 1.19.4 — 2026-09-30
 
 Antigravity's new quota banner, and a shorter README.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unsnooze",
-  "version": "1.19.4",
+  "version": "1.19.5",
   "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/agy.js

@@ -12,6 +12,10 @@
 // Deferred by design: the hooks.json channel (schema drifted between builds)
 // and the loopback RetrieveUserQuotaSummary endpoint (authoritative per-meter
 // resetTime) — the latter is the natural future resetProbe seam.
+//
+// No latestBannerAt: history.jsonl only records prompts, never banners, so its
+// newest timestamp can predate the banner by hours. Anchoring a relative
+// "Resets in 3h" to it fires the wake early. Countdowns anchor to scrape time.
 
 import { openSync, readSync, closeSync, statSync } from 'node:fs';
 import { homedir } from 'node:os';
@@ -106,28 +110,6 @@ export function latestSessionId(cwd, aroundTs = null, agyDir = AGY_DIR()) {
   return recentIds.size === 1 ? recentIds.values().next().value : null;
 }
 
-export function latestBannerAt(cwd, aroundTs = null, agyDir = AGY_DIR()) {
-  const text = tailBytes(join(agyDir, 'history.jsonl'));
-  if (!text) return null;
-  const lines = text.split('\n').filter(l => l.trim());
-  for (let i = lines.length - 1; i >= 0; i--) {
-    let entry;
-    try { entry = JSON.parse(lines[i]); } catch { continue; }
-    if (!entry || typeof entry !== 'object') continue;
-    if (!Object.values(entry).some(v => v === cwd)) continue;
-    const timestamp = typeof entry.timestamp === 'number'
-      ? entry.timestamp
-      : typeof entry.timestamp === 'string' ? Date.parse(entry.timestamp) : NaN;
-    if (Number.isFinite(timestamp)) {
-      if (!Number.isFinite(aroundTs)) return timestamp;
-      if (timestamp <= (aroundTs + 5000) && (aroundTs - timestamp) <= SESSION_RECENCY_MS) {
-        return timestamp;
-      }
-    }
-  }
-  return null;
-}
-
 export default {
   id: 'agy',
   name: 'Antigravity CLI (Google)',
@@ -143,7 +125,6 @@ export default {
   // v1: every agent launches the bare TUI and gets the prompt typed once idle.
   launchArgs(message) { return { args: [], messageViaPane: true }; },
   latestSessionId,
-  latestBannerAt,
   isForegroundCommand(cmd) {
     return cmd === 'agy' || cmd === 'node' || cmd === 'unsnooze';
   },

package/src/hook.js

@@ -16,6 +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 { tmuxPaneFromEnv } from './multiplexers/tmux.js';
 import { spawnResumerIfNeeded, ensureDaemon } from './spawn.js';
 import { makeLogger } from './logger.js';
 import { addressHash } from './lease.js';
@@ -47,7 +48,7 @@ export function hookContext(env = process.env, payload = {}) {
   const pane = managedMux
     ? (env.UNSNOOZE_PANE || null)
     : (muxName === 'herdr' ? env.HERDR_PANE_ID
-      : muxName === 'zellij' ? env.ZELLIJ_PANE_ID : env.TMUX_PANE || payload.tmux_pane) || null;
+      : muxName === 'zellij' ? env.ZELLIJ_PANE_ID : tmuxPaneFromEnv(env) || payload.tmux_pane) || null;
   const paneOwner = muxName === 'herdr'
     ? (managedMux ? env.UNSNOOZE_PANE_OWNER : (env.HERDR_SESSION || 'default'))
     : muxName === 'zellij'

package/src/monitor.js

@@ -113,13 +113,10 @@ export function createMonitor({
         detectedAt,
       };
     }
-    const bannerAt = typeof agent.latestBannerAt === 'function'
-      ? agent.latestBannerAt(cwd, detectedAt)
-      : null;
     return {
       resetLine: paneResetLine,
       limitType: paneLimitType,
-      bannerAt,
+      bannerAt: null,
       sessionId,
       via: null,   // filled by caller (scrape/hook)
       detectedAt,

package/src/multiplexers/tmux.js

@@ -6,9 +6,11 @@ import { resolveSessionName, SessionCreateError } from './session-name.js';
 
 const execFileAsync = promisify(execFileCb);
 
+// windowsHide: the console-less monitor polls through the async path every few
+// seconds (see workspace.js). The sync new-session needs the real console.
 function defaultSpawner(file, args, { sync = false, ...options } = {}) {
   if (sync) return spawnSync(file, args, options);
-  return execFileAsync(file, args, options).then(({ stdout }) => stdout);
+  return execFileAsync(file, args, { windowsHide: true, ...options }).then(({ stdout }) => stdout);
 }
 
 function envArgs(env = {}) {
@@ -51,8 +53,43 @@ const SESSION_START_ERROR_RE = new RegExp([
 
 export { SessionCreateError };
 
-export function createTmux({ spawner = defaultSpawner, env = process.env } = {}) {
+// tmux on native Windows is psmux, and three of its differences break revival
+// (verified against psmux 3.3.6, which reports itself as "tmux 3.3.6"):
+//  - Command words are joined with spaces and run through pwsh/cmd unless `--`
+//    precedes them, and only new-session honours `--` — new-window always goes
+//    through the shell. `C:\Program Files\nodejs\node.exe` then dies at
+//    "C:\Program" and the window closes before the agent ever starts.
+//  - Pane ids are per session: every session's first pane is %1, and a bare
+//    `-t %1` means whichever session is newest. `session:%1` is exact.
+//  - A target pane that is gone resolves to some other pane: send-keys exits 0
+//    and types into it, capture-pane reads it.
+// Real tmux accepts `--` and `session:%N` too, so an MSYS2 tmux is unharmed.
+
+// This pane's id as unsnooze addresses it: `session:%N` inside psmux, which
+// exports PSMUX_SESSION; the bare server-global %N under real tmux.
+export function tmuxPaneFromEnv(env = process.env) {
+  if (!env.TMUX_PANE) return null;
+  return env.PSMUX_SESSION ? `${env.PSMUX_SESSION}:${env.TMUX_PANE}` : env.TMUX_PANE;
+}
+
+export function createTmux({ spawner = defaultSpawner, env = process.env, platform = process.platform } = {}) {
   const run = (...args) => spawner('tmux', args);
+  const psmux = platform === 'win32';
+  const PANE_FMT = psmux ? '#{session_name}:#{pane_id}' : '#{pane_id}';
+  const RAW = psmux ? ['--'] : [];
+  // A pane-targeted command, refused for a pane that is gone — real tmux does
+  // that itself; psmux would run it against another pane.
+  const onPane = async (pane, cmd, ...args) => {
+    if (psmux && !(await backend.paneAlive(pane))) throw new Error(`can't find pane: ${pane}`);
+    return run(cmd, '-t', pane, ...args);
+  };
+  const sessionTaken = name => {
+    try {
+      return spawner('tmux', ['has-session', '-t', name], { sync: true, stdio: 'ignore', env }).status === 0;
+    } catch {
+      return false;
+    }
+  };
 
   const backend = {
     name: 'tmux',
@@ -69,33 +106,33 @@ export function createTmux({ spawner = defaultSpawner, env = process.env } = {})
     inside() { return !!env.TMUX; },
     currentPaneId() {
       if (env.UNSNOOZE_MUX === 'tmux' && env.UNSNOOZE_PANE) return env.UNSNOOZE_PANE;
-      return env.TMUX_PANE || null;
+      return tmuxPaneFromEnv(env);
     },
 
     async capturePane(pane, lines = 200) {
-      return run('capture-pane', '-t', pane, '-p', '-S', `-${lines}`);
+      return onPane(pane, 'capture-pane', '-p', '-S', `-${lines}`);
     },
 
     async capturePaneVisible(pane) {
-      return run('capture-pane', '-t', pane, '-p');
+      return onPane(pane, 'capture-pane', '-p');
     },
 
     async sendText(pane, text) {
-      await run('send-keys', '-t', pane, '-l', text);
+      await onPane(pane, 'send-keys', '-l', text);
       await new Promise(resolve => setTimeout(resolve, SUBMIT_DELAY_MS));
-      await run('send-keys', '-t', pane, 'Enter');
+      await onPane(pane, 'send-keys', 'Enter');
     },
 
     async sendKey(pane, key) {
-      await run('send-keys', '-t', pane, key);
+      await onPane(pane, 'send-keys', key);
     },
 
     async paneAlive(pane) {
       try {
         // tmux 3.7b prints a blank line and exits 0 for a nonexistent target,
-        // so the exit code alone is not evidence — the output must echo the
-        // pane id back.
-        const out = await run('display-message', '-t', pane, '-p', '#{pane_id}');
+        // and psmux names a different pane, so the exit code alone is not
+        // evidence — the output must echo the pane id back.
+        const out = await run('display-message', '-t', pane, '-p', PANE_FMT);
         return out.trim() === pane;
       } catch {
         return false;
@@ -106,7 +143,7 @@ export function createTmux({ spawner = defaultSpawner, env = process.env } = {})
     // code (same tmux 3.7b blank-success pitfall as paneAlive).
     async sessionForPane(pane) {
       try {
-        const out = (await run('display-message', '-t', pane, '-p', '#{session_name}')).trim();
+        const out = (await onPane(pane, 'display-message', '-p', '#{session_name}')).trim();
         return out || null;
       } catch {
         return null;
@@ -133,7 +170,7 @@ export function createTmux({ spawner = defaultSpawner, env = process.env } = {})
 
     async paneTty(pane) {
       try {
-        const out = (await run('display-message', '-t', pane, '-p', '#{pane_tty}')).trim();
+        const out = (await onPane(pane, 'display-message', '-p', '#{pane_tty}')).trim();
         return out || null;
       } catch {
         return null;
@@ -166,7 +203,7 @@ export function createTmux({ spawner = defaultSpawner, env = process.env } = {})
 
     async paneCurrentCommand(pane) {
       try {
-        return (await run('display-message', '-t', pane, '-p', '#{pane_current_command}')).trim();
+        return (await onPane(pane, 'display-message', '-p', '#{pane_current_command}')).trim();
       } catch {
         return null;
       }
@@ -178,7 +215,7 @@ export function createTmux({ spawner = defaultSpawner, env = process.env } = {})
     // older tmux fails quietly and callers fall back to lease checks.
     async stampPaneOwner(pane, leaseId) {
       try {
-        await run('set-option', '-p', '-t', pane, '@unsnooze_owner', String(leaseId));
+        await onPane(pane, 'set-option', '-p', '@unsnooze_owner', String(leaseId));
         return true;
       } catch {
         return false;
@@ -189,7 +226,7 @@ export function createTmux({ spawner = defaultSpawner, env = process.env } = {})
     // both null — trust stdout, not the exit code (tmux 3.7b blank-success).
     async paneOwnerStamp(pane) {
       try {
-        const out = (await run('display-message', '-t', pane, '-p', '#{@unsnooze_owner}')).trim();
+        const out = (await onPane(pane, 'display-message', '-p', '#{@unsnooze_owner}')).trim();
         return out || null;
       } catch {
         return null;
@@ -217,7 +254,7 @@ export function createTmux({ spawner = defaultSpawner, env = process.env } = {})
 
     async listSessionPanes(sessionName) {
       try {
-        const out = await run('list-panes', '-t', sessionName, '-F', '#{pane_id}');
+        const out = await run('list-panes', '-t', sessionName, '-F', PANE_FMT);
         return out.split(/\r?\n/).map(line => line.trim()).filter(Boolean);
       } catch {
         return [];
@@ -235,7 +272,15 @@ export function createTmux({ spawner = defaultSpawner, env = process.env } = {})
     async newWindow(sessionName, cwd, launchSpec) {
       // Environment flags require tmux >= 3.0 for new-window and >= 3.2 for
       // new-session. Older tmux fails revival with an "unknown flag -e" error.
-      const launch = [...envArgs(launchSpec.env), launchSpec.file, ...(launchSpec.args || [])];
+      const launch = [...envArgs(launchSpec.env), ...RAW, launchSpec.file, ...(launchSpec.args || [])];
+      // psmux: new-window would run the command through a shell, so each
+      // revival opens its own session — resumer and prompt-queue persist it.
+      if (psmux) {
+        const session = resolveSessionName(sessionName, sessionTaken);
+        const pane = await run('new-session', '-d', '-s', session, '-c', cwd,
+          '-P', '-F', PANE_FMT, ...launch);
+        return { pane: pane.trim(), paneOwner: null, session };
+      }
       let pane;
       if (!(await backend.sessionExists(sessionName))) {
         pane = await run('new-session', '-d', '-s', sessionName, '-c', cwd,
@@ -254,20 +299,13 @@ export function createTmux({ spawner = defaultSpawner, env = process.env } = {})
       // tmux in the foreground also gives Ctrl-C to the active pane directly.
       // Its -e environment flags require tmux >= 3.2; older versions fail
       // revival with an "unknown flag -e" error.
-      const name = resolveSessionName(wrappedSessionName(env), candidate => {
-        try {
-          return spawner('tmux', ['has-session', '-t', candidate],
-            { sync: true, stdio: 'ignore', env }).status === 0;
-        } catch {
-          return false;
-        }
-      });
+      const name = resolveSessionName(wrappedSessionName(env), sessionTaken);
       launchSpec.onSessionCreated?.(name);
       // Session name is discovered live via sessionForPane at record-write
       // time — do NOT inject UNSNOOZE_SESSION_NAME (would leak into daemons
       // spawned from the agent via {...process.env}).
       const args = ['new-session', '-s', name,
-        ...envArgs(launchSpec.env), launchSpec.file, ...(launchSpec.args || [])];
+        ...envArgs(launchSpec.env), ...RAW, launchSpec.file, ...(launchSpec.args || [])];
       // stderr is piped, not inherited: the tmux client draws its UI on the
       // stdin/stdout tty; stderr carries only tmux's own error messages, and
       // capturing them is how a session-start failure is told apart from the

package/src/resumer.js

@@ -342,10 +342,6 @@ export async function probeFallback(rec, {
     return null;
   }
 
-  if (!bannerAt && typeof agent.latestBannerAt === 'function') {
-    bannerAt = agent.latestBannerAt(rec.cwd, now);
-  }
-
   // Banner still present. If it now parses to a real time, upgrade off fallback.
   if (resetLine) {
     const { at, source } = resetAtMs(parseResetTime(resetLine), {
@@ -959,8 +955,6 @@ export async function verifyOne(key, { resolveMux = resolveRecordMux } = {}) {
     if (fromTx) {
       resetLine = fromTx.resetLine ?? resetLine;
       bannerAt = fromTx.timestampMs;
-    } else if (typeof agent.latestBannerAt === 'function') {
-      bannerAt = agent.latestBannerAt(rec.cwd, Date.now());
     }
     const { at, source } = resetAtMs(parseResetTime(resetLine), {
       marginMs: RESET_MARGIN_MS,

package/src/update-check.js

@@ -9,7 +9,7 @@
 
 import { readFileSync, existsSync } from 'node:fs';
 import { spawnSync } from 'node:child_process';
-import { join, dirname } from 'node:path';
+import { join, dirname, posix, win32 } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { getConfig } from './settings.js';
 import { notify } from './notify.js';
@@ -225,24 +225,59 @@ export async function runUpdateCheck({ fetcher, notifier = notify, now = Date.no
   return 0;
 }
 
-// `unsnooze update` — self-update via npm, then show what changed. npm -g
-// overwrites this install in place, so re-reading package.json/CHANGELOG.md
-// after a successful install yields the NEW version's info.
-export function runSelfUpdate({ runner = spawnSync, print = console.log } = {}) {
-  print(`unsnooze ${PKG_VERSION} — updating via npm install -g unsnooze@latest …`);
-  const r = runner('npm', ['install', '-g', 'unsnooze@latest'], { stdio: 'inherit' });
+// The npm prefix this copy was installed into, so `unsnooze update` replaces
+// the copy that is running. With two npm prefixes on one machine (nvm's npm
+// first on PATH while unsnooze lives under ~/.local, or Homebrew's npm next
+// to nvm), a bare `npm install -g` writes into npm's own prefix and leaves
+// the copy the wrappers, the StopFailure hook and the daemon unit exec as it
+// was. npm's global layout is <prefix>/lib/node_modules/unsnooze plus a
+// <prefix>/bin/unsnooze link on POSIX, <prefix>\node_modules\unsnooze plus
+// <prefix>\unsnooze.cmd on Windows. Anything else (a checkout or `npm link`,
+// npx, a pnpm/yarn/bun global, a project dependency) is null: npm's default
+// prefix, as before.
+export function installPrefix({ root = ROOT, platform = process.platform, exists = existsSync } = {}) {
+  const win = platform === 'win32';
+  const path = win ? win32 : posix;
+  const modules = path.dirname(root);
+  if (path.basename(root) !== 'unsnooze' || path.basename(modules) !== 'node_modules') return null;
+  const parent = path.dirname(modules);
+  if (win) return exists(path.join(parent, 'unsnooze.cmd')) ? parent : null;
+  if (path.basename(parent) !== 'lib') return null;
+  const prefix = path.dirname(parent);
+  return exists(path.join(prefix, 'bin', 'unsnooze')) ? prefix : null;
+}
+
+// `unsnooze update` — self-update via npm, then show what changed. With
+// --prefix pointed at this copy's own prefix, npm -g overwrites this install
+// in place, so re-reading package.json/CHANGELOG.md after a successful
+// install yields the NEW version's info.
+export function runSelfUpdate({ runner = spawnSync, print = console.log, root = ROOT, current = PKG_VERSION } = {}) {
+  const prefix = installPrefix({ root });
+  const args = ['install', '-g', ...(prefix ? ['--prefix', prefix] : []), 'unsnooze@latest'];
+  const command = ['npm', ...args].map(a => (/\s/.test(a) ? `"${a}"` : a)).join(' ');
+  print(`unsnooze ${current} — updating via ${command} …`);
+  const r = runner('npm', args, { stdio: 'inherit' });
   if (r.error || r.status !== 0) {
     print(`unsnooze: update failed (${r.error ? r.error.message : `npm exited ${r.status}`}).`);
-    print('unsnooze: try it manually: npm install -g unsnooze@latest');
+    print(`unsnooze: try it manually: ${command}`);
     print('unsnooze: (permission errors usually mean your npm prefix needs sudo or a user-writable prefix)');
     return r.status || 1;
   }
-  let newVersion = PKG_VERSION;
+  let newVersion;
   try {
-    newVersion = JSON.parse(readFileSync(join(ROOT, 'package.json'), 'utf-8')).version;
+    newVersion = JSON.parse(readFileSync(join(root, 'package.json'), 'utf-8')).version;
   } catch { /* moved install dir — the generic message below still holds */ }
-  if (newVersion === PKG_VERSION) {
-    print(`unsnooze: already up to date (${PKG_VERSION}).`);
+  // npm exited 0 but this copy is unchanged, while the registry check already
+  // knows a newer release: most likely npm installed it into another prefix.
+  const { latest } = readCache();
+  if (newVersion === current && isNewer(latest, current)) {
+    print(`unsnooze: npm finished, but this copy is still ${current} and ${latest} is out.`);
+    print(`unsnooze: npm may have installed it into its own prefix (\`npm prefix -g\`) instead of ${root}.`);
+    return 1;
+  }
+  newVersion ??= current;
+  if (newVersion === current) {
+    print(`unsnooze: already up to date (${current}).`);
   } else {
     const section = changelogSection(newVersion);
     print(`unsnooze: updated to ${newVersion}.${section ? ` What's new:\n${section}` : ''}`);