unsnooze 1.7.0 → 1.8.1

package/src/resumer.js

@@ -6,11 +6,11 @@
 
 import { writeFileSync, readFileSync, unlinkSync, mkdirSync } from 'node:fs';
 import { homedir } from 'node:os';
-import * as realTmux from './tmux.js';
+import { getMultiplexer } from './multiplexer.js';
 import {
   RESUMER_LOCK, STATE_DIR, POLL_INTERVAL_MS, STAGGER_MS, VERIFY_DELAY_MS,
   BUSY_DEFER_MS, MAX_BUSY_DEFERS, MAX_RESUME_ATTEMPTS, READY_TIMEOUT_MS,
-  CAPTURE_LINES, PANE_SCAN_LINES, TMUX_SESSION_NAME,
+  CAPTURE_LINES, PANE_SCAN_LINES, MUX_SESSION_NAME,
   RESET_MARGIN_MS, FALLBACK_RESET_MS,
 } from './config.js';
 import { detectLimit, isBusy } from './patterns.js';
@@ -22,9 +22,12 @@ import { workspaceFingerprint, workspaceChanged, describeChange } from './worksp
 import { notify } from './notify.js';
 import { UNSNOOZE_BIN } from './spawn.js';
 import { makeLogger } from './logger.js';
+import { createLeaseId, leaseMatches } from './lease.js';
 
 const log = makeLogger('resumer');
 const sleep = ms => new Promise(r => setTimeout(r, ms));
+const MAX_VERIFY_RETRIES = 3;
+const ctxOf = rec => ({ mux: rec.mux, pane: rec.pane, paneOwner: rec.paneOwner });
 
 function pidAlive(pid) {
   try { process.kill(pid, 0); return true; } catch { return false; }
@@ -56,22 +59,40 @@ export function dueForDispatch(now = Date.now()) {
   return dueSessions(now).filter(s => (auto || s.manual) && (!s.workspaceHold || s.manual));
 }
 
-function shellQuote(arg) {
-  return /^[\w@%+=:,./-]+$/.test(arg) ? arg : `'${arg.replace(/'/g, `'\\''`)}'`;
-}
-
-// The reopen command runs inside a fresh tmux window, i.e. with the tmux
-// SERVER's environment — which may lack npm globals or nvm's node on PATH.
-// Always embed absolute paths. UNSNOOZE_SELF is the test-harness override.
 function selfCommand() {
   return process.env.UNSNOOZE_SELF
     ? [process.env.UNSNOOZE_SELF]
     : [process.execPath, UNSNOOZE_BIN];
 }
 
-// Decide how to act on one due record. Pure-ish; tmux injectable.
-// Returns: 'sent' | 'reopened' | 'deferred' | 'skip' | 'failed'
-export async function dispatchOne(rec, { tmux = realTmux, resumeMessage, selfCmd = selfCommand(), fingerprint = workspaceFingerprint, notifier = notify } = {}) {
+export function resolveRecordMux(rec) {
+  return getMultiplexer(rec.mux, { owner: rec.paneOwner });
+}
+
+function reopenEnv(rec, leaseId) {
+  const env = { ...(rec.env || {}) };
+  env.UNSNOOZE_MUX = rec.mux;
+  if (rec.muxSession) env.UNSNOOZE_PANE_OWNER = rec.muxSession;
+  env.UNSNOOZE_LEASE_ID = leaseId;
+  return env;
+}
+
+async function driveMenu(mux, pane, agent, text) {
+  const steps = agent.menu.stepsToWait(text, PANE_SCAN_LINES);
+  if (steps === null) return false;
+  const key = steps > 0 ? 'Down' : 'Up';
+  for (let i = 0; i < Math.abs(steps); i++) await mux.sendKey(pane, key);
+  await mux.sendKey(pane, 'Enter');
+  return true;
+}
+
+// Ordered safety decision. Returns: busy | retry | progress | held | injected | reopen.
+export async function dispatchOne(rec, {
+  mux = resolveRecordMux(rec), resolveMux = null,
+  resumeMessage, selfCmd = selfCommand(), fingerprint = workspaceFingerprint,
+  notifier = notify, matchesLease = leaseMatches,
+} = {}) {
+  resolveMux ||= () => mux;
   const key = rec.key;
   const agent = getAgent(rec.agent);
   // Wake-message precedence: per-session (`unsnooze message <id> "..."`) →
@@ -88,7 +109,7 @@ export async function dispatchOne(rec, { tmux = realTmux, resumeMessage, selfCmd
       const desc = describeChange(change);
       if (guardMode === 'pause') {
         setStatus(key, 'stopped', { workspaceHold: true, holdReason: desc });
-        notifier('unsnooze: session held', `${rec.cwd}: workspace changed while stopped (${desc}) — run: unsnooze resume-now`);
+        notifier('unsnooze: session held', `${rec.cwd}: workspace changed while stopped (${desc}) — run: unsnooze resume-now`, { context: ctxOf(rec) });
         log(`${key}: workspace changed (${desc}) — held (workspaceGuard=pause)`);
         return 'held';
       }
@@ -100,76 +121,134 @@ export async function dispatchOne(rec, { tmux = realTmux, resumeMessage, selfCmd
   // Live-pane path: only if the pane still exists AND the agent CLI is its
   // foreground command (pane ids get recycled — never inject into a random
   // program).
-  if (rec.pane && await tmux.paneAlive(rec.pane)) {
-    const cmd = await tmux.paneCurrentCommand(rec.pane);
-    if (agent.isForegroundCommand(cmd)) {
-      const text = await tmux.capturePane(rec.pane, CAPTURE_LINES).catch(() => '');
-      if (isBusy(text, agent.patterns.busyPatterns)) return 'deferred';
-      setStatus(key, 'resuming', { lastAttemptAt: Date.now() });
-      await tmux.sendText(rec.pane, resumeMessage);
-      log(`${key}: sent continue to live pane ${rec.pane}`);
-      return 'sent';
+  if (rec.pane && await mux.paneAlive(rec.pane)) {
+    let text;
+    try { text = await mux.capturePane(rec.pane, CAPTURE_LINES); }
+    catch (err) {
+      setStatus(key, 'stopped', { lastError: `capture: ${err.message}` });
+      return 'retry';
+    }
+    if (isBusy(text, agent.patterns.busyPatterns)) return 'busy';
+    const d = detectLimit(text, PANE_SCAN_LINES, agent.patterns);
+    const menu = !!(agent.menu && agent.menu.isPrompt(text, PANE_SCAN_LINES));
+    let cmd = null;
+    try { cmd = await mux.paneCurrentCommand(rec.pane); }
+    catch (err) { log(`${key}: pane command lookup failed: ${err.message}`); }
+    const contentOwned = menu || d.hit || agent.patterns.idleRegex.test(text);
+    const leased = await matchesLease(rec, { mux });
+    const owned = leased || agent.isForegroundCommand(cmd);
+    const authorized = owned && contentOwned;
+
+    if (menu) {
+      if (!authorized) return reopen(rec, { mux, resolveMux, agent, resumeMessage, selfCmd });
+      if (!getConfig('menuAutoAnswer')) return 'held';
+      try {
+        if (await driveMenu(mux, rec.pane, agent, text)) return 'progress';
+        setStatus(key, 'stopped', { lastError: 'menu drive: wait option unavailable' });
+      } catch (err) {
+        setStatus(key, 'stopped', { lastError: `menu drive: ${err.message}` });
+      }
+      return 'retry';
+    }
+    if (authorized) {
+      setStatus(key, 'resuming', { lastAttemptAt: Date.now(), lastError: null, verifyRetries: 0 });
+      await mux.sendText(rec.pane, resumeMessage);
+      log(`${key}: sent continue via ${rec.mux} ${rec.paneOwner ?? '-'}:${rec.pane}`);
+      return 'injected';
     }
-    // Pane alive but the agent gone (user's shell now) — fall through to
-    // re-open; never hijack a shell prompt with a chat message.
+    if (owned) return 'busy';
   }
 
-  // Re-open path: new tmux window in the well-known session, resume by id.
-  // Records from sandboxed GUI sessions carry env (e.g. CLAUDE_CONFIG_DIR) the
-  // revived CLI needs to find its session store.
+  return reopen(rec, { mux, resolveMux, agent, resumeMessage, selfCmd });
+}
+
+async function reopen(rec, { mux, resolveMux, agent, resumeMessage, selfCmd }) {
+  const key = rec.key;
   const resume = agent.resumeArgs(rec.sessionId, resumeMessage);
-  // `env K=V cmd`, not a bare `K=V cmd` prefix: the command runs in the
-  // user's default shell, and fish/nushell reject POSIX prefix assignments.
-  const envPrefix = rec.env
-    ? 'env ' + Object.entries(rec.env).map(([k, v]) => `${k}=${shellQuote(String(v))}`).join(' ') + ' '
-    : '';
-  const command = envPrefix + [...selfCmd, '_run', agent.id, ...resume.args].map(shellQuote).join(' ');
-  setStatus(key, 'resuming', { lastAttemptAt: Date.now() });
-  let newPane;
+  const leaseId = createLeaseId();
+  const launchSpec = {
+    file: selfCmd[0], args: [...selfCmd.slice(1), '_run', agent.id, ...resume.args],
+    env: reopenEnv(rec, leaseId),
+  };
+  setStatus(key, 'resuming', { lastAttemptAt: Date.now(), verifyRetries: 0 });
+  let address;
   try {
-    // cwd can be null on watcher records (unreadable rollout head) — execFile
-    // rejects null args, so fall back to the home dir rather than crash-loop.
-    newPane = await tmux.newWindow(rec.tmuxSession || TMUX_SESSION_NAME, rec.cwd || homedir(), command);
+    address = await mux.newWindow(rec.muxSession ?? rec.tmuxSession ?? MUX_SESSION_NAME,
+      rec.cwd || homedir(), launchSpec);
   } catch (err) {
-    setStatus(key, 'stopped', { attempts: (rec.attempts || 0) + 1, lastError: `new-window: ${err.message}` });
-    return 'failed';
+    setStatus(key, 'stopped', {
+      attempts: (rec.attempts || 0) + 1,
+      lastError: `new-window: ${err.message}`,
+      verifyRetries: 0,
+    });
+    return 'retry';
   }
   updateState(state => {
     const s = state.sessions[key];
-    if (s) s.pane = newPane;
+    if (s) Object.assign(s, address, { leaseId });
   });
-  log(`${key}: re-opened in pane ${newPane} (${command})`);
+  const rebound = { ...rec, ...address, leaseId };
+  mux = resolveMux(rebound);
+  log(`${key}: re-opened via ${rec.mux} ${address.paneOwner ?? '-'}:${address.pane}`);
 
   // The resume prompt traveled in argv (e.g. `codex resume <id> "msg"`) —
   // nothing to type into the TUI; verifyOne checks the outcome later.
-  if (!resume.messageViaPane) return 'reopened';
+  if (!resume.messageViaPane) return 'reopen';
 
   // Wait for the TUI to be ready (input prompt visible), then send the message.
   const deadline = Date.now() + READY_TIMEOUT_MS;
   while (Date.now() < deadline) {
     await sleep(2000);
-    const text = await tmux.capturePane(newPane, CAPTURE_LINES).catch(() => '');
+    let text;
+    try { text = await mux.capturePane(address.pane, CAPTURE_LINES); }
+    catch { continue; }
     if ((agent.menu && agent.menu.isPrompt(text, PANE_SCAN_LINES)) || detectLimit(text, PANE_SCAN_LINES, agent.patterns).hit) {
       // Limit hadn't actually reset — the fresh session hit it immediately.
-      return 'failed';
+      return 'reopen';
     }
     // The idle input box: a prompt glyph with no busy footer.
     if (!isBusy(text, agent.patterns.busyPatterns) && agent.patterns.idleRegex.test(text)) {
-      await tmux.sendText(newPane, resumeMessage);
-      log(`${key}: resume message sent to new pane ${newPane}`);
-      return 'reopened';
+      await mux.sendText(address.pane, resumeMessage);
+      log(`${key}: resume message sent to new pane ${address.pane}`);
+      return 'reopen';
     }
   }
-  setStatus(key, 'stopped', { attempts: (rec.attempts || 0) + 1, lastError: 'ready timeout' });
-  return 'failed';
+  setStatus(key, 'stopped', {
+    attempts: (rec.attempts || 0) + 1,
+    lastError: 'ready timeout',
+    verifyRetries: 0,
+  });
+  return 'retry';
+}
+
+function recordVerifyRetry(rec, lastError) {
+  const verifyRetries = (rec.verifyRetries || 0) + 1;
+  if (verifyRetries >= MAX_VERIFY_RETRIES) {
+    setStatus(rec.key, 'stopped', {
+      attempts: (rec.attempts || 0) + 1,
+      lastError,
+      verifyRetries: 0,
+    });
+  } else {
+    setStatus(rec.key, 'resuming', { lastError, verifyRetries });
+  }
+  return 'retry';
 }
 
 // Post-dispatch verification: did the limit banner come back?
-export async function verifyOne(key, { tmux = realTmux } = {}) {
+export async function verifyOne(key, { resolveMux = resolveRecordMux } = {}) {
   const rec = readState().sessions[key];
   if (!rec || rec.status !== 'resuming') return;
   const agent = getAgent(rec.agent);
-  const text = rec.pane ? await tmux.capturePane(rec.pane, CAPTURE_LINES).catch(() => '') : '';
+  if (!rec.pane) {
+    return recordVerifyRetry(rec, 'verify: pane unavailable');
+  }
+  const mux = resolveMux(rec);
+  let text;
+  try { text = await mux.capturePane(rec.pane, CAPTURE_LINES); }
+  catch (err) {
+    return recordVerifyRetry(rec, `verify capture: ${err.message}`);
+  }
   const d = detectLimit(text, PANE_SCAN_LINES, agent.patterns);
   if (d.hit || (agent.menu && agent.menu.isPrompt(text, PANE_SCAN_LINES))) {
     // Limit not actually reset — reschedule from the fresh banner.
@@ -178,22 +257,49 @@ export async function verifyOne(key, { tmux = realTmux } = {}) {
     });
     setStatus(key, 'stopped', {
       attempts: (rec.attempts || 0) + 1, resetAt: at, resetSource: source,
-      lastError: 'limit still active at resume time',
+      lastError: 'limit still active at resume time', verifyRetries: 0,
     });
     log(`${key}: limit still active, rescheduled to ${new Date(at).toISOString()}`);
     return;
   }
-  setStatus(key, 'resumed');
+  setStatus(key, 'resumed', { lastError: null, verifyRetries: 0 });
   log(`${key}: verified resumed`);
   const fromGui = rec.origin && rec.origin !== 'cli';
-  notify('unsnoozed ✅', `${rec.cwd} is running again${fromGui ? ` (was in ${rec.origin} — revived in tmux)` : ''}`);
+  notify('unsnoozed ✅', `${rec.cwd} is running again${fromGui ? ` (was in ${rec.origin} — revived in ${rec.mux})` : ''}`, { context: ctxOf(rec) });
+  return 'resumed';
+}
+
+export function routeDispatchOutcome(result, rec, deferCounts, { maxBusyDefers = MAX_BUSY_DEFERS } = {}) {
+  if (result === 'busy') {
+    const n = (deferCounts.get(rec.key) || 0) + 1;
+    deferCounts.set(rec.key, n);
+    if (n > maxBusyDefers) {
+      setStatus(rec.key, 'resumed', { lastError: null, verifyRetries: 0 });
+      return { verify: false, waitBusy: false };
+    }
+    return { verify: false, waitBusy: true };
+  }
+  if (result === 'retry') {
+    setStatus(rec.key, 'stopped', {
+      attempts: (rec.attempts || 0) + 1,
+      lastError: readState().sessions[rec.key]?.lastError,
+      verifyRetries: 0,
+    });
+    return { verify: false, waitBusy: false };
+  }
+  if (result === 'progress') {
+    setStatus(rec.key, 'stopped', { lastError: null, verifyRetries: 0 });
+    return { verify: false, waitBusy: false };
+  }
+  if (result === 'held') return { verify: false, waitBusy: false };
+  return { verify: result === 'injected' || result === 'reopen', waitBusy: false };
 }
 
 // persistent: never exit on an empty ledger (daemon mode — `unsnooze daemon`,
 // launchd/systemd). watcher: transcript watcher ticked every loop, so GUI
 // sessions are detected without a hook or pane. signal: clean shutdown.
 export async function runResumer({
-  tmux = realTmux, pollInterval = POLL_INTERVAL_MS,
+  resolveMux = resolveRecordMux, pollInterval = POLL_INTERVAL_MS,
   persistent = false, watcher = null, signal = null,
 } = {}) {
   // A transient hook-spawned resumer may hold the lock right now; a daemon
@@ -230,33 +336,26 @@ export async function runResumer({
       // Anything over the attempts cap is dead — mark failed so we can exit.
       for (const s of dueForDispatch()) {
         if ((s.attempts || 0) >= MAX_RESUME_ATTEMPTS) {
-          setStatus(s.key, 'failed', { lastError: 'max resume attempts exceeded' });
+          setStatus(s.key, 'failed', { lastError: 'max resume attempts exceeded', verifyRetries: 0 });
           log(`${s.key}: giving up after ${s.attempts} attempts`);
-          notify('unsnooze gave up ⚠️', `${s.cwd}: ${s.attempts} resume attempts failed — check \`unsnooze status\``);
+          notify('unsnooze gave up ⚠️', `${s.cwd}: ${s.attempts} resume attempts failed — check \`unsnooze status\``, { context: ctxOf(s) });
         }
       }
 
       const dispatched = [];
       for (const rec of due) {
-        const result = await dispatchOne(rec, { tmux });
-        if (result === 'deferred') {
-          const n = (deferCounts.get(rec.key) || 0) + 1;
-          deferCounts.set(rec.key, n);
-          if (n > MAX_BUSY_DEFERS) {
-            setStatus(rec.key, 'resumed', { lastError: null });
-            log(`${rec.key}: busy through ${n} defers — it is clearly working, marking resumed`);
-          } else {
-            await sleep(BUSY_DEFER_MS);
-          }
-          continue;
-        }
-        if (result === 'sent' || result === 'reopened') dispatched.push(rec.key);
+        const result = await dispatchOne(rec, { mux: resolveMux(rec), resolveMux });
+        const routed = routeDispatchOutcome(result, rec, deferCounts);
+        if (routed.waitBusy) await sleep(BUSY_DEFER_MS);
+        if (routed.verify) dispatched.push(rec.key);
+        if (!routed.verify) continue;
         if (due.indexOf(rec) < due.length - 1) await sleep(STAGGER_MS);
       }
 
-      if (dispatched.length > 0) {
+      const verifying = [...new Set([...resuming.map(rec => rec.key), ...dispatched])];
+      if (verifying.length > 0) {
         await sleep(VERIFY_DELAY_MS);
-        for (const key of dispatched) await verifyOne(key, { tmux });
+        for (const key of verifying) await verifyOne(key, { resolveMux });
       }
 
       await sleep(pollInterval);

package/src/settings.js

@@ -13,9 +13,11 @@ import { STATE_DIR } from './config.js';
 export const CONFIG_FILE = () => join(process.env.UNSNOOZE_STATE_DIR || STATE_DIR, 'config.json');
 
 export const DEFAULTS = {
+  multiplexer: 'auto',    // auto | tmux | zellij
   autoResume: true,        // master switch: dispatch resumes when limits reset
   menuAutoAnswer: true,    // may unsnooze drive Claude's limit menu (send keys)?
   notifications: true,     // desktop notifications on detect/resume
+  notifyChannel: 'auto',   // auto | native | osc | bell
   guiWatch: true,          // daemon watches transcripts/rollouts for GUI-session stops
   updateCheck: true,       // daily registry version check + update notices/toast
   workspaceGuard: 'inform', // repo changed while stopped: off | inform | pause
@@ -26,9 +28,11 @@ export const DEFAULTS = {
 
 // Env override per key. Booleans accept 1/0, true/false, on/off, yes/no.
 const ENV_NAMES = {
+  multiplexer: 'UNSNOOZE_MULTIPLEXER',
   autoResume: 'UNSNOOZE_AUTO_RESUME',
   menuAutoAnswer: 'UNSNOOZE_MENU_AUTO_ANSWER',
   notifications: 'UNSNOOZE_NOTIFICATIONS',
+  notifyChannel: 'UNSNOOZE_NOTIFY_CHANNEL',
   guiWatch: 'UNSNOOZE_GUI_WATCH',
   updateCheck: 'UNSNOOZE_UPDATE_CHECK',
   workspaceGuard: 'UNSNOOZE_WORKSPACE_GUARD',
@@ -53,7 +57,9 @@ const KNOWN_KEYS = Object.keys(ENV_NAMES);
 
 // String settings restricted to a fixed set of values.
 const ENUMS = {
+  multiplexer: ['auto', 'tmux', 'zellij'],
   workspaceGuard: ['off', 'inform', 'pause'],
+  notifyChannel: ['auto', 'native', 'osc', 'bell'],
 };
 
 function parseBool(raw) {

package/src/state.js

@@ -15,6 +15,7 @@ import {
 } from './config.js';
 import { workspaceFingerprint } from './workspace.js';
 import { makeLogger } from './logger.js';
+import { addressHash } from './lease.js';
 
 const log = makeLogger('state');
 
@@ -53,7 +54,7 @@ function releaseLock() {
 
 export function readState() {
   try {
-    return JSON.parse(readFileSync(STATE_FILE, 'utf-8'));
+    return normalizeState(JSON.parse(readFileSync(STATE_FILE, 'utf-8')));
   } catch (err) {
     if (err.code === 'ENOENT') return EMPTY();
     // Corrupt file: quarantine loudly, start fresh — never crash the hook path.
@@ -66,6 +67,20 @@ export function readState() {
   }
 }
 
+function normalizeState(state) {
+  if (!state || typeof state !== 'object') return EMPTY();
+  state.sessions ||= {};
+  for (const rec of Object.values(state.sessions)) normalizeRecord(rec);
+  return state;
+}
+
+function normalizeRecord(rec) {
+  if (!rec.mux) rec.mux = 'tmux';
+  if (!rec.muxSession && rec.tmuxSession) rec.muxSession = rec.tmuxSession;
+  if (rec.mux === 'tmux' && rec.paneOwner === undefined) rec.paneOwner = null;
+  return rec;
+}
+
 // Locked read-modify-write. mutator receives the state object and mutates it
 // (or returns a replacement). Returns the final state.
 export function updateState(mutator) {
@@ -87,11 +102,14 @@ export function updateState(mutator) {
 // if a record for the same pane was created within DEDUPE_WINDOW_MS, merge into
 // it (a record WITH a sessionId wins over one without).
 export function upsertSession(record) {
+  record = normalizeRecord({ ...record });
   return updateState(state => {
     prune(state);
     const existingKey = findDuplicate(state, record);
     if (existingKey) {
       const existing = state.sessions[existingKey];
+      const staleBanner = existing.status === 'resumed' && !existing.bannerCleared
+        && record.status === 'stopped';
       const merged = {
         ...existing,
         ...record,
@@ -99,7 +117,11 @@ export function upsertSession(record) {
         sessionId: record.sessionId || existing.sessionId,
         // A detection that races an in-flight resume must not flip the record
         // back to 'stopped' — the post-resume verify pass owns that outcome.
-        status: existing.status === 'resuming' ? existing.status : record.status,
+        status: existing.status === 'resuming'
+          || staleBanner
+          ? existing.status : record.status,
+        attempts: staleBanner ? existing.attempts : record.attempts,
+        lastAttemptAt: staleBanner ? existing.lastAttemptAt : record.lastAttemptAt,
         key: existingKey,
       };
       state.sessions[existingKey] = merged;
@@ -111,7 +133,7 @@ export function upsertSession(record) {
     if (record.status === 'stopped' && record.workspace === undefined) {
       record.workspace = workspaceFingerprint(record.cwd);
     }
-    const key = record.sessionId || `pane:${record.pane}:${record.detectedAt}`;
+    const key = record.sessionId || `pane:${addressHash(record)}:${record.detectedAt}`;
     state.sessions[key] = { ...record, key };
     return state;
   });
@@ -126,8 +148,9 @@ function findDuplicate(state, record) {
     // 'resuming' counts too: while the resumer types into a pane, a scrape can
     // still see the banner for a few hundred ms — that must not fork a second
     // record (it would double-resume the session).
-    if (s.pane && s.pane === record.pane
-      && (s.status === 'stopped' || s.status === 'resuming')
+    if (s.pane && record.pane && addressHash(s) === addressHash(record)
+      && (s.status === 'stopped' || s.status === 'resuming'
+        || (s.status === 'resumed' && !s.bannerCleared))
       && Math.abs((s.detectedAt || 0) - record.detectedAt) < DEDUPE_WINDOW_MS) {
       return key;
     }
@@ -138,7 +161,7 @@ function findDuplicate(state, record) {
     // writes the very transcript the watcher reads, so same-cwd evidence is
     // almost always the same session, and the alternative (two records) would
     // double-resume it.
-    if (record.sessionId && !s.sessionId
+    if (record.sessionId && !s.sessionId && (!record.pane || !s.pane)
       && s.agent === record.agent && s.cwd && s.cwd === record.cwd
       && s.status === 'stopped'
       && Math.abs((s.detectedAt || 0) - record.detectedAt) < DEDUPE_WINDOW_MS) {

package/src/watcher.js

@@ -18,8 +18,9 @@ import { join, sep, basename, dirname } from 'node:path';
 import { homedir } from 'node:os';
 import {
   CLAUDE_DIR, CODEX_DIR, WATCH_OFFSETS_FILE, WATCH_FRESHNESS_MS,
-  RESET_MARGIN_MS, FALLBACK_RESET_MS, TMUX_SESSION_NAME,
+  RESET_MARGIN_MS, FALLBACK_RESET_MS, MUX_SESSION_NAME,
 } from './config.js';
+import { getMultiplexer } from './multiplexer.js';
 import { parseTranscriptLine } from './watchers/claude.js';
 import { parseRolloutLine, rolloutMeta } from './watchers/codex.js';
 import { ROLLOUT_RE } from './agents/codex.js';
@@ -177,7 +178,8 @@ export function dispatchCandidate(c) {
     cwd: c.cwd || null,
     agent: c.agent,
     origin: c.origin || null,
-    tmuxSession: TMUX_SESSION_NAME,
+    mux: getMultiplexer().name, paneOwner: null, leaseId: null,
+    muxSession: MUX_SESSION_NAME,
     status: 'stopped',
     limitType: c.limitType || 'unknown',
     detectedVia: 'transcript',

package/src/wizard.js

@@ -24,11 +24,12 @@ function defaultWhich(bin) {
 export async function runWizard() {
   p.intro('unsnooze — wake every limit-stopped AI coding session automatically');
 
-  const { tmuxAvailable } = await import('./tmux.js');
-  if (!tmuxAvailable()) {
+  const { getMultiplexer } = await import('./multiplexer.js');
+  const mux = getMultiplexer();
+  if (!mux.available()) {
     p.log.warn(process.platform === 'win32'
-      ? 'tmux not found — unsnooze does not support native Windows.\nRun it inside WSL (https://learn.microsoft.com/windows/wsl/install), where tmux and the wrappers work normally.'
-      : 'tmux not found — unsnooze needs tmux to watch and revive sessions.\nInstall it first (brew install tmux / apt install tmux), then re-run `unsnooze setup`.');
+      ? 'No supported multiplexer found — unsnooze does not support native Windows.\nRun it inside WSL.'
+      : `${mux.name} not found — install it, then re-run \`unsnooze setup\`.`);
   }
 
   const detected = detectInstalledAgents();
@@ -75,7 +76,7 @@ export async function runWizard() {
     const answer = await p.confirm({
       message: 'Also guard GUI sessions (Claude Code in VS Code/desktop, Codex app/IDE)?\n'
         + '  Installs a small background daemon (launchd/systemd) that watches session\n'
-        + '  files for limit stops; revived sessions open in tmux and stay visible in\n'
+        + '  files for limit stops; revived sessions open in the configured multiplexer and stay visible in\n'
         + '  the GUI\'s own history.',
       initialValue: DEFAULTS.guiWatch,
     });

package/src/tmux.js

@@ -1,95 +0,0 @@
-import { execFile as execFileCb, spawnSync } from 'node:child_process';
-import { promisify } from 'node:util';
-
-const execFileAsync = promisify(execFileCb);
-
-// Is tmux runnable at all? Used for a friendly error instead of a cryptic
-// spawn failure (native Windows users get pointed at WSL).
-export function tmuxAvailable() {
-  try {
-    return spawnSync('tmux', ['-V'], { stdio: 'ignore' }).status === 0;
-  } catch {
-    return false;
-  }
-}
-
-// Submit delay: text and the submitting Enter must be TWO separate send-keys
-// calls with a pause between them, or Ink (Claude Code's TUI) treats the Enter
-// as a newline inside a bracketed-paste burst instead of a submit.
-export const SUBMIT_DELAY_MS = 150;
-
-async function tmux(...args) {
-  const { stdout } = await execFileAsync('tmux', args);
-  return stdout;
-}
-
-export function insideTmux() { return !!process.env.TMUX; }
-export function currentPaneId() { return process.env.TMUX_PANE || null; }
-
-export async function capturePane(pane, lines = 200) {
-  return tmux('capture-pane', '-t', pane, '-p', '-S', `-${lines}`);
-}
-
-// Visible screen ONLY (no scrollback). Interactive menus must be checked
-// against this: a menu that scrolled into history was already answered —
-// re-driving it sends stray keystrokes into whatever is foreground now.
-export async function capturePaneVisible(pane) {
-  return tmux('capture-pane', '-t', pane, '-p');
-}
-
-// Type a message into a TUI and submit it (split form; -l sends literally so
-// tmux key names inside the message are typed, not interpreted).
-export async function sendText(pane, text) {
-  await tmux('send-keys', '-t', pane, '-l', text);
-  await new Promise(r => setTimeout(r, SUBMIT_DELAY_MS));
-  await tmux('send-keys', '-t', pane, 'Enter');
-}
-
-// Single named key ('Down', 'Up', 'Enter', 'Escape') — drives menus.
-export async function sendKey(pane, key) {
-  await tmux('send-keys', '-t', pane, key);
-}
-
-export async function paneAlive(pane) {
-  try {
-    await tmux('display-message', '-t', pane, '-p', '#{pane_id}');
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-export async function paneCurrentCommand(pane) {
-  try {
-    return (await tmux('display-message', '-t', pane, '-p', '#{pane_current_command}')).trim();
-  } catch {
-    return null;
-  }
-}
-
-// NOTE: plain session names, not the '=name' exact-match prefix — tmux 3.7b
-// rejects '=name' as a target here ("name not found" despite the session
-// existing). Exact matches take priority over prefix matches anyway.
-export async function sessionExists(name) {
-  try {
-    await tmux('has-session', '-t', name);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// Open a new window in the named session (creating the session if needed),
-// cd'd to cwd, running command. Returns the new pane id.
-export async function newWindow(sessionName, cwd, command) {
-  if (!(await sessionExists(sessionName))) {
-    await tmux('new-session', '-d', '-s', sessionName, '-c', cwd);
-    // The fresh session's first window IS our window — run the command there.
-    const pane = (await tmux('display-message', '-t', sessionName, '-p', '#{pane_id}')).trim();
-    await tmux('send-keys', '-t', pane, '-l', command);
-    await tmux('send-keys', '-t', pane, 'Enter');
-    return pane;
-  }
-  const out = await tmux('new-window', '-t', `${sessionName}:`, '-c', cwd, '-P', '-F', '#{pane_id}', command);
-  return out.trim();
-}