unsnooze 1.6.0 → 1.8.0

package/src/agents/opencode.js

@@ -0,0 +1,105 @@
+// OpenCode adapter (sst/opencode, command `opencode`) — EXPERIMENTAL.
+//
+// OpenCode is unusual: it self-retries rate limits FOREVER, honoring
+// retry-after headers (it will happily sleep 3 hours until a reset), showing a
+// status line like "Rate Limited [retrying in 2h5m attempt #4]". The session
+// only stops on non-retryable errors (402 credits, auth, context overflow) or
+// user abort. So the retry banner is BOTH a limit anchor and a busy pattern:
+//   - a LIVE self-retrying pane records a stop but is busy → the resumer
+//     defers, and the monitor flips the record to 'resumed' when the banner
+//     clears (OpenCode recovered on its own)
+//   - a DEAD pane mid-wait (laptop slept, tmux killed) is revived at the reset
+//     via `opencode -s <ses_id>`
+// Banner strings are verbatim from packages/opencode/src/session/retry.ts and
+// the console zen i18n; the bracketed countdown parses via time-parser's
+// Go-duration support.
+
+import { execFileSync } from 'node:child_process';
+
+const LIMIT_ANCHORS = [
+  /(?:5.hour|weekly|monthly) usage limit reached/i,   // Zen Go plans
+  /usage limit reached/i,
+  /Free usage exceeded/i,                              // Zen free tier
+  /Subscription quota exceeded/i,                      // Zen Black
+  /Rate Limited \[retrying/i,                          // status-line retry banner
+  /Too Many Requests \[retrying/i,
+  /Rate limit exceeded: limit_/i,                      // OpenRouter limit_rpd/limit_rpm
+  /free models per day/i,                              // OpenRouter free-tier daily
+];
+
+const RETRY_BANNER = /\[retrying(?: in [^\]]+)? attempt #\d+\]/i;
+
+export const patterns = {
+  limitPatterns: LIMIT_ANCHORS,
+  resetPatterns: [
+    /It will reset in/i,
+    /Resets? in/i,
+    /Retry in/i,
+    /\[retrying in/i,
+    ...LIMIT_ANCHORS,
+  ],
+  weeklyPatterns: [/weekly usage limit/i],
+  fiveHourPatterns: [/5.hour usage limit/i],
+  busyPatterns: [
+    RETRY_BANNER,                 // self-retrying — OpenCode is handling it
+    /esc (?:again to )?interrupt/i,
+  ],
+  idleRegex: /[›❯>]/,
+  overloadPatterns: [/Provider is overloaded/i],
+  transientPatterns: [/Provider is overloaded \[retrying/i],
+  // Non-retryable, non-resetting stops: notify-only.
+  terminalPatterns: [/insufficient credits/i, /out of credits/i],
+};
+
+function runSessionList() {
+  return execFileSync(process.env.UNSNOOZE_OPENCODE_BIN || 'opencode',
+    ['session', 'list', '--format', 'json'],
+    { timeout: 5000, encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] });
+}
+
+// `opencode session list --format json` — sessions live in a SQLite db, so ask
+// the CLI rather than parsing it. Output tolerated as a JSON array or JSONL.
+export function latestSessionId(cwd, aroundTs = null, runner = runSessionList) {
+  let raw;
+  try { raw = runner(); } catch { return null; }
+  let sessions = [];
+  try {
+    const parsed = JSON.parse(raw);
+    sessions = Array.isArray(parsed) ? parsed : [parsed];
+  } catch {
+    for (const line of String(raw).split('\n')) {
+      if (!line.trim()) continue;
+      try { sessions.push(JSON.parse(line)); } catch { /* skip noise lines */ }
+    }
+  }
+  let best = null;
+  for (const s of sessions) {
+    if (!s || typeof s !== 'object') continue;
+    const dir = s.directory ?? s.dir ?? s.cwd;
+    const id = s.id ?? s.sessionID ?? s.session_id;
+    if (dir !== cwd || !id) continue;
+    const updated = s.time_updated ?? s.time?.updated ?? 0;
+    if (!best || updated > best.updated) best = { id, updated };
+  }
+  return best ? best.id : null;
+}
+
+export default {
+  id: 'opencode',
+  name: 'OpenCode',
+  bin: process.env.UNSNOOZE_OPENCODE_BIN || 'opencode',
+  experimental: true,
+  patterns,
+  menu: null,
+  // `opencode -s <id>` reopens the TUI on that session; the resume message is
+  // typed once idle. (`opencode run -s <id> "msg"` exists but is headless-only.)
+  resumeArgs(sessionId) {
+    return { args: sessionId ? ['-s', sessionId] : ['--continue'], messageViaPane: true };
+  },
+  latestSessionId,
+  isForegroundCommand(cmd) {
+    // The npm-shipped bun binary reports pane_current_command "opencode.exe"
+    // even on macOS (verified live).
+    return /^opencode(\.exe)?$/.test(cmd) || cmd === 'node' || cmd === 'unsnooze';
+  },
+};

package/src/agents/qwen.js

@@ -0,0 +1,108 @@
+// Qwen Code CLI adapter (QwenLM/qwen-code, command `qwen`) — EXPERIMENTAL.
+//
+// Limits landscape (researched 2026-07): the Qwen OAuth free tier was
+// discontinued 2026-04-15 (that message is terminal, not a limit). The paid
+// path is the Alibaba Coding Plan — a rolling 5-hour window + weekly quota
+// whose exhaustion 429 (`Throttling.AllocationQuota`) is fail-fast: the CLI
+// stops. Error strings below are verbatim from the qwen-code source
+// (packages/core/src/utils/{retry,errorParsing}.ts). No reset time is ever
+// shown or written to disk → detection leans on the 5h fallback + the
+// verify/self-correct loop.
+//
+// Qwen also supports Claude-shaped JSON hooks in ~/.qwen/settings.json with a
+// StopFailure event (matcher matches the error class: rate_limit | ... );
+// install.js merges ours in when the agent is enabled.
+
+import { readdirSync, readFileSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+const QWEN_DIR = () => process.env.UNSNOOZE_QWEN_DIR || join(homedir(), '.qwen');
+
+const LIMIT_ANCHORS = [
+  /Qwen (?:OAuth|API) quota exceeded/i,        // legacy free-tier / API-quota renders
+  /Allocated quota exceeded/i,                 // Coding Plan + "Free allocated quota exceeded"
+  /\[API Error:.*(?:429|rate limit)/i,         // OpenAI-compat providers incl. OpenRouter
+  /Possible quota limitations in place/i,      // qwen's own 429 suffix line
+  /Rate limit exceeded: limit_/i,              // OpenRouter limit_rpd/limit_rpm bodies
+];
+
+export const patterns = {
+  limitPatterns: LIMIT_ANCHORS,
+  // No reset text exists in any qwen limit render — anchors double as reset
+  // lines (codex/grok trick) and time-parser falls back to the 5h default.
+  resetPatterns: [...LIMIT_ANCHORS],
+  weeklyPatterns: [],
+  fiveHourPatterns: [/Allocated quota exceeded/i],   // Coding Plan window is rolling 5h
+  // Transient throttles self-retry with a countdown — never inject keys then.
+  busyPatterns: [
+    /Retrying in \d+s/i,          // "↻ Retrying in 5s… (attempt 2/5)"
+    /attempt \d+\/\d+/i,
+    /esc to cancel/i,
+  ],
+  idleRegex: /[›❯>]/,
+  overloadPatterns: [/\[API Error:.*5\d\d/i, /Retrying in \d+s/i],
+  transientPatterns: [/Retrying in \d+s/i],
+  // Non-resetting stops: notify-only, never the ledger.
+  terminalPatterns: [/free tier has been discontinued/i, /insufficient credits/i],
+};
+
+// qwen-code maps a cwd to a project dir by replacing every non-alphanumeric
+// char with '-' (packages/core/src/utils/paths.ts sanitizeCwd) — close to but
+// not identical with claude's scheme (which keeps '_').
+export function sanitizeCwd(cwd) {
+  return cwd.replace(/[^a-zA-Z0-9]/g, '-');
+}
+
+const RUNTIME_RE = /\.runtime\.json$/;
+const CHAT_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\.jsonl$/i;
+
+// v0.16+ writes a <sessionId>.runtime.json sidecar ({pid, session_id,
+// work_dir, started_at}) next to each chat, purpose-built for observability
+// daemons. Prefer it; fall back to the newest chat transcript by mtime.
+export function latestSessionId(cwd, aroundTs = null, qwenDir = QWEN_DIR()) {
+  const chatsDir = join(qwenDir, 'projects', sanitizeCwd(cwd), 'chats');
+  let entries;
+  try { entries = readdirSync(chatsDir); } catch { return null; }
+
+  let best = null;
+  for (const name of entries) {
+    if (!RUNTIME_RE.test(name)) continue;
+    try {
+      const meta = JSON.parse(readFileSync(join(chatsDir, name), 'utf-8'));
+      if (meta.work_dir !== cwd || !meta.session_id) continue;
+      if (!best || (meta.started_at || 0) > best.startedAt) {
+        best = { id: meta.session_id, startedAt: meta.started_at || 0 };
+      }
+    } catch { /* unreadable sidecar — skip */ }
+  }
+  if (best) return best.id;
+
+  let newest = null;
+  for (const name of entries) {
+    if (!CHAT_RE.test(name)) continue;
+    let mtime;
+    try { mtime = statSync(join(chatsDir, name)).mtimeMs; } catch { continue; }
+    if (aroundTs != null && Math.abs(mtime - aroundTs) > 30 * 60_000) continue;
+    if (!newest || mtime > newest.mtime) newest = { id: name.slice(0, -6), mtime };
+  }
+  return newest ? newest.id : null;
+}
+
+export default {
+  id: 'qwen',
+  name: 'Qwen Code',
+  bin: process.env.UNSNOOZE_QWEN_BIN || 'qwen',
+  experimental: true,
+  patterns,
+  menu: null,
+  // `qwen --resume <id>` reopens the TUI; there is no verified
+  // resume-with-prompt argv form, so the message is typed once idle.
+  resumeArgs(sessionId) {
+    return { args: sessionId ? ['--resume', sessionId] : ['--continue'], messageViaPane: true };
+  },
+  latestSessionId,
+  isForegroundCommand(cmd) {
+    return cmd === 'qwen' || cmd === 'node' || cmd === 'unsnooze';
+  },
+};

package/src/cli.js

@@ -30,6 +30,7 @@ export function cmdStatus() {
     const id = s.sessionId ? s.sessionId.slice(0, 8) : '(no id)';
     const reset = s.resetAt ? `${new Date(s.resetAt).toLocaleString()} (${fmtCountdown(s.resetAt - now)})` : '?';
     const origin = s.origin ?? (s.pane ? 'cli' : '?');
+    const pane = s.paneOwner ? `${s.paneOwner}:${s.pane ?? '-'}` : (s.pane ?? '-');
     const msg = s.resumeMessage
       ? ` · msg: "${s.resumeMessage.length > 44 ? s.resumeMessage.slice(0, 44) + '…' : s.resumeMessage}"`
       : '';
@@ -37,7 +38,7 @@ export function cmdStatus() {
       ? ` · workspace changed (${s.holdReason ?? '?'}) — resume-now to wake`
       : '';
     console.log(`  [${s.status.toUpperCase().padEnd(9)}] ${id}  ${(s.agent || 'claude').padEnd(6)} ${s.limitType?.padEnd(7) ?? 'unknown'} ${s.cwd}`);
-    console.log(`              pane ${s.pane ?? '-'} · via ${origin} · resets ${reset} · attempts ${s.attempts ?? 0}/${MAX_RESUME_ATTEMPTS}${s.lastError ? ` · last error: ${s.lastError}` : ''}${msg}${hold}`);
+    console.log(`              mux ${s.mux ?? '-'} · pane ${pane} · session ${s.muxSession ?? '-'} · via ${origin} · resets ${reset} · attempts ${s.attempts ?? 0}/${MAX_RESUME_ATTEMPTS}${s.lastError ? ` · last error: ${s.lastError}` : ''}${msg}${hold}`);
   }
   return 0;
 }

package/src/config.js

@@ -20,7 +20,9 @@ export const CODEX_DIR = process.env.UNSNOOZE_CODEX_DIR || join(homedir(), '.cod
 // Transcript/rollout watcher (GUI detection channel)
 export const WATCH_OFFSETS_FILE = join(STATE_DIR, 'watch-offsets.json');
 
-export const TMUX_SESSION_NAME = process.env.UNSNOOZE_TMUX_SESSION || 'unsnooze';
+export const MUX_SESSION_NAME = process.env.UNSNOOZE_SESSION_NAME
+  || process.env.UNSNOOZE_TMUX_SESSION || 'unsnooze';
+export const TMUX_SESSION_NAME = MUX_SESSION_NAME; // read compatibility
 
 // Timing (ms unless noted)
 export const RESET_MARGIN_MS = envInt('UNSNOOZE_RESET_MARGIN_MS', 60_000);
@@ -48,4 +50,3 @@ export const DEDUPE_WINDOW_MS = envInt('UNSNOOZE_DEDUPE_WINDOW_MS', 120_000);
 export const PRUNE_AFTER_MS = envInt('UNSNOOZE_PRUNE_AFTER_MS', 7 * 86_400_000);
 export const STALE_LOCK_MS = envInt('UNSNOOZE_STALE_LOCK_MS', 10_000);
 
-

package/src/hook.js

@@ -6,15 +6,16 @@
 
 import { mkdirSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
-import { EVENTS_DIR, FALLBACK_RESET_MS, RESET_MARGIN_MS, CAPTURE_LINES, PANE_SCAN_LINES, TMUX_SESSION_NAME } from './config.js';
+import { EVENTS_DIR, FALLBACK_RESET_MS, RESET_MARGIN_MS, CAPTURE_LINES, PANE_SCAN_LINES, MUX_SESSION_NAME } from './config.js';
 import { detectLimit } from './patterns.js';
 import { getAgent } from './agents/index.js';
 import { getConfig } from './settings.js';
 import { parseResetTime, resetAtMs } from './time-parser.js';
 import { upsertSession } from './state.js';
-import { capturePane } from './tmux.js';
+import { getMultiplexer } from './multiplexer.js';
 import { spawnResumerIfNeeded } from './spawn.js';
 import { makeLogger } from './logger.js';
+import { addressHash } from './lease.js';
 
 const log = makeLogger('hook');
 
@@ -44,7 +45,16 @@ export async function runHook(rest = []) {
     let payload = {};
     try { payload = JSON.parse(raw); } catch { /* tolerate non-JSON */ }
 
-    const pane = process.env.TMUX_PANE || payload.tmux_pane || null;
+    const managedMux = process.env.UNSNOOZE_MUX;
+    const muxName = managedMux || (process.env.ZELLIJ_PANE_ID ? 'zellij' : 'tmux');
+    const pane = managedMux
+      ? (process.env.UNSNOOZE_PANE || null)
+      : (muxName === 'zellij' ? process.env.ZELLIJ_PANE_ID : process.env.TMUX_PANE || payload.tmux_pane) || null;
+    const paneOwner = muxName === 'zellij'
+      ? (managedMux ? process.env.UNSNOOZE_PANE_OWNER : process.env.ZELLIJ_SESSION_NAME) || null
+      : null;
+    const leaseId = process.env.UNSNOOZE_LEASE_ID || null;
+    const mux = getMultiplexer(muxName, { owner: paneOwner });
     const kind = classify(payload, raw);
     log(`StopFailure: kind=${kind} pane=${pane} session=${payload.session_id || '?'}`);
 
@@ -53,8 +63,8 @@ export async function runHook(rest = []) {
       // record in state.json.
       if (pane) {
         mkdirSync(EVENTS_DIR, { recursive: true });
-        writeFileSync(join(EVENTS_DIR, `${pane.replace(/[^%\w]/g, '_')}.json`),
-          JSON.stringify({ pane, kind, at: Date.now(), payload: { error: payload.error ?? null } }));
+        writeFileSync(join(EVENTS_DIR, `${addressHash({ mux: muxName, paneOwner, pane })}.json`),
+          JSON.stringify({ mux: muxName, paneOwner, pane, kind, at: Date.now(), payload: { error: payload.error ?? null } }));
       }
       return 0;
     }
@@ -66,7 +76,7 @@ export async function runHook(rest = []) {
     let limitType = 'unknown';
     if (pane) {
       try {
-        const text = await capturePane(pane, CAPTURE_LINES);
+        const text = await mux.capturePane(pane, CAPTURE_LINES);
         const d = detectLimit(text, PANE_SCAN_LINES, agent.patterns);
         if (d.hit) { resetLine = d.resetLine; limitType = d.limitType; }
       } catch { /* pane not capturable (no tmux) — fall back below */ }
@@ -83,9 +93,12 @@ export async function runHook(rest = []) {
       sessionId: sessionId || null,
       cwd,
       pane,
+      mux: muxName,
+      paneOwner,
+      leaseId,
       agent: agent.id,
       origin: 'cli',   // the hook only fires for CLI launches we can see
-      tmuxSession: TMUX_SESSION_NAME,
+      muxSession: MUX_SESSION_NAME,
       status: 'stopped',
       limitType,
       detectedVia: 'hook',

package/src/install.js

@@ -56,15 +56,18 @@ function isLegacy(entry) {
   return (entry.hooks || []).some(h => /claude-auto-retry|csg\.js _hook-stopfailure/.test(h.command || ''));
 }
 
-export function mergeHookIntoSettings(settingsJson) {
+// agent/matcher options cover CLIs with Claude-shaped hook config in their own
+// settings.json (qwen); the default stays byte-identical for claude.
+export function mergeHookIntoSettings(settingsJson, { agent = null, matcher = 'overloaded|server_error|rate_limit' } = {}) {
   const settings = JSON.parse(settingsJson);
   settings.hooks = settings.hooks || {};
   const list = (settings.hooks.StopFailure || []).filter(e => !isLegacy(e) && !isOurs(e));
+  const agentFlag = agent ? ` --agent ${agent}` : '';
   list.push({
-    matcher: 'overloaded|server_error|rate_limit',
+    matcher,
     // Guarded like the shell wrapper: a vanished entry point must exit 0, not
     // spray MODULE_NOT_FOUND errors into every Claude Code turn.
-    hooks: [{ type: 'command', command: `test -f "${UNSNOOZE_BIN}" && node "${UNSNOOZE_BIN}" _hook-stopfailure || exit 0`, timeout: 5 }],
+    hooks: [{ type: 'command', command: `test -f "${UNSNOOZE_BIN}" && node "${UNSNOOZE_BIN}" _hook-stopfailure${agentFlag} || exit 0`, timeout: 5 }],
   });
   settings.hooks.StopFailure = list;
   return JSON.stringify(settings, null, 2) + '\n';
@@ -205,7 +208,7 @@ export function installDaemonAutostart({ platform = process.platform, dir = null
     activate('systemctl', ['--user', 'enable', '--now', 'unsnooze.service']);
     return target;
   }
-  return null;   // native Windows: no tmux to revive into — daemon unsupported
+  return null;   // native Windows: no supported multiplexer to revive into
 }
 
 export function uninstallDaemonAutostart({ platform = process.platform, dir = null, activate = defaultActivate } = {}) {
@@ -229,7 +232,36 @@ export function uninstallDaemonAutostart({ platform = process.platform, dir = nu
 // --- commands ---
 
 export function enabledAgents() {
-  return ['claude', 'codex', 'grok'].filter(id => getConfig(`agents.${id}`));
+  return ['claude', 'codex', 'grok', 'qwen', 'kimi', 'opencode', 'agy'].filter(id => getConfig(`agents.${id}`));
+}
+
+// Qwen keeps Claude-shaped hooks in its own settings.json — reuse the same
+// merge/remove machinery against ~/.qwen/settings.json. Matcher matches qwen's
+// StopFailure `error` class; `unknown` is included because the discontinued
+// free-tier message classifies as unknown, and hook.js's banner gate keeps
+// unknowns without visible limit banners out of the ledger anyway.
+const QWEN_HOOK_OPTS = { agent: 'qwen', matcher: 'rate_limit|unknown' };
+
+function qwenSettingsPath() {
+  return join(process.env.UNSNOOZE_QWEN_DIR || join(homedir(), '.qwen'), 'settings.json');
+}
+
+export function installQwenHooks() {
+  const path = qwenSettingsPath();
+  if (existsSync(path)) {
+    copyFileSync(path, `${path}.unsnooze-bak`);
+    atomicWrite(path, mergeHookIntoSettings(readFileSync(path, 'utf-8'), QWEN_HOOK_OPTS));
+  } else {
+    atomicWrite(path, mergeHookIntoSettings('{}', QWEN_HOOK_OPTS));
+  }
+  return path;
+}
+
+export function uninstallQwenHooks() {
+  const path = qwenSettingsPath();
+  if (!existsSync(path)) return null;
+  atomicWrite(path, removeHookFromSettings(readFileSync(path, 'utf-8')));
+  return path;
 }
 
 // rc files to touch: the explicit --zshrc target, or every rc file that exists
@@ -271,6 +303,12 @@ export function cmdInstall(rest, { agents = enabledAgents() } = {}) {
     console.log(`unsnooze: Grok StopFailure hook installed at ${file}`);
   }
 
+  // 2b. Qwen Code hook (Claude-shaped hooks in ~/.qwen/settings.json).
+  if (agents.includes('qwen')) {
+    const file = installQwenHooks();
+    console.log(`unsnooze: Qwen StopFailure hook installed in ${file}`);
+  }
+
   // 3. Shell wrappers (zsh + bash).
   for (const rc of rcTargets(opts, explicitRc)) {
     const rcContent = existsSync(rc) ? readFileSync(rc, 'utf-8') : '';
@@ -310,6 +348,8 @@ export function cmdUninstall(rest) {
   }
 
   uninstallGrokHooks();
+  const qwenFile = uninstallQwenHooks();
+  if (qwenFile) console.log(`unsnooze: StopFailure hook removed from ${qwenFile}`);
 
   for (const rc of rcTargets(opts, explicitRc)) {
     if (!existsSync(rc)) continue;

package/src/launcher.js

@@ -1,16 +1,16 @@
 // Default `unsnooze _run <agent> [args...]` path: run the agent CLI under watch.
-//   - outside tmux: re-exec inside a new tmux session (the monitor needs a pane
-//     to scrape) — guarded by UNSNOOZE_ACTIVE to prevent recursion
-//   - inside tmux: spawn a detached per-pane monitor, then run the CLI,
+//   - outside a multiplexer: re-exec through its launchWrapped operation
+//   - inside one: spawn a detached per-pane monitor, then run the CLI,
 //     propagating its exit code
 //   - -p/--print: pure pass-through, no monitor (nothing interactive to scrape)
 
 import { spawn, spawnSync } from 'node:child_process';
-import { insideTmux, currentPaneId, tmuxAvailable } from './tmux.js';
+import { getMultiplexer } from './multiplexer.js';
 import { getAgent } from './agents/index.js';
 import { getConfig } from './settings.js';
 import { spawnDetached } from './spawn.js';
 import { makeLogger } from './logger.js';
+import { createLeaseId, processBirth, writeLease, removeLease } from './lease.js';
 
 const log = makeLogger('launcher');
 
@@ -29,41 +29,60 @@ export function runLauncher(args, agentId = 'claude') {
     return r.status ?? 1;
   }
 
-  if (!insideTmux()) {
-    if (!tmuxAvailable()) {
+  const mux = getMultiplexer();
+  if (!mux.inside()) {
+    if (!mux.available()) {
       // Degrade gracefully: run the CLI unwatched rather than dying.
-      process.stderr.write('unsnooze: tmux not found — running without limit-watch.\n');
+      process.stderr.write(`unsnooze: ${mux.name} not found — running without limit-watch.\n`);
       if (process.platform === 'win32') {
-        process.stderr.write('unsnooze: native Windows is not supported; run inside WSL (https://learn.microsoft.com/windows/wsl/install) where tmux works.\n');
+        process.stderr.write('unsnooze: native Windows is not supported; run inside WSL.\n');
       } else {
-        process.stderr.write('unsnooze: install tmux to enable auto-resume (brew install tmux / apt install tmux).\n');
+        process.stderr.write(`unsnooze: install ${mux.name} to enable auto-resume.\n`);
       }
       const r = spawnSync(agent.bin, args, { stdio: 'inherit', env: { ...process.env, UNSNOOZE_ACTIVE: '1' } });
       return r.status ?? 1;
     }
-    // Re-enter under tmux: `tmux new-session unsnooze _run <agent> <args...>` —
-    // the inner unsnooze lands in the insideTmux() branch below.
-    log(`not in tmux — wrapping into a tmux session`);
-    const inner = ['new-session', process.execPath, process.argv[1], '_run', agent.id, ...args];
-    const r = spawnSync('tmux', inner, { stdio: 'inherit' });
-    return r.status ?? 1;
+    log(`not in ${mux.name} — wrapping into a managed session`);
+    return mux.launchWrapped({
+      file: process.execPath,
+      args: [process.argv[1], '_run', agent.id, ...args],
+      env: process.env,
+    });
   }
 
-  const pane = currentPaneId();
+  const pane = mux.currentPaneId();
+  const paneOwner = mux.name === 'zellij'
+    ? (process.env.UNSNOOZE_MUX === 'zellij'
+      ? process.env.UNSNOOZE_PANE_OWNER : process.env.ZELLIJ_SESSION_NAME) || null
+    : null;
+  const leaseId = process.env.UNSNOOZE_LEASE_ID || createLeaseId();
   if (pane) {
-    spawnDetached(['_monitor', pane, agent.id], { UNSNOOZE_CWD: process.cwd() });
-    log(`launching ${agent.id} in pane ${pane}, monitor spawned`);
+    spawnDetached(['_monitor', mux.name, paneOwner || '', pane, agent.id, leaseId],
+      { UNSNOOZE_CWD: process.cwd() });
+    log(`launching ${agent.id} in ${mux.name} ${paneOwner ?? '-'}:${pane}, monitor spawned`);
   } else {
-    log(`inside tmux but TMUX_PANE unset — launching ${agent.id} without monitor`);
+    log(`inside ${mux.name} but pane id unset — launching ${agent.id} without monitor`);
   }
 
+  const childEnv = {
+    ...process.env, UNSNOOZE_ACTIVE: '1', UNSNOOZE_MUX: mux.name,
+    UNSNOOZE_PANE: pane || '', UNSNOOZE_PANE_OWNER: paneOwner || '',
+    UNSNOOZE_LEASE_ID: leaseId,
+  };
   const child = spawn(agent.bin, args, {
     stdio: 'inherit',
-    env: { ...process.env, UNSNOOZE_ACTIVE: '1', UNSNOOZE_PANE: pane || '' },
+    env: childEnv,
   });
+  const lease = pane && child.pid ? {
+    leaseId, mux: mux.name, paneOwner, pane, agent: agent.id,
+    pid: child.pid, pidBirth: processBirth(child.pid),
+  } : null;
+  if (lease?.pidBirth) writeLease(lease);
+  const cleanup = () => { if (lease) removeLease(lease, leaseId); };
   return new Promise(resolve => {
-    child.on('exit', code => resolve(code ?? 1));
+    child.on('exit', code => { cleanup(); resolve(code ?? 1); });
     child.on('error', err => {
+      cleanup();
       process.stderr.write(`unsnooze: failed to launch ${agent.bin}: ${err.message}\n`);
       resolve(127);
     });

package/src/lease.js

@@ -0,0 +1,87 @@
+import {
+  mkdirSync, readFileSync, writeFileSync, renameSync, unlinkSync,
+} from 'node:fs';
+import { execFileSync } from 'node:child_process';
+import { randomUUID, createHash } from 'node:crypto';
+import { join } from 'node:path';
+import { STATE_DIR } from './config.js';
+
+const LEASES_DIR = join(STATE_DIR, 'leases');
+
+export function addressHash({ mux, paneOwner, pane }) {
+  return createHash('sha256')
+    .update(`${mux ?? ''}\0${paneOwner ?? ''}\0${pane ?? ''}`)
+    .digest('hex');
+}
+
+export function createLeaseId() {
+  return randomUUID();
+}
+
+export function processBirth(pid, {
+  platform = process.platform,
+  readFile = path => readFileSync(path, 'utf-8'),
+  execFile = (file, args) => execFileSync(file, args, { encoding: 'utf-8' }),
+} = {}) {
+  try {
+    if (platform === 'linux') {
+      const stat = readFile(`/proc/${pid}/stat`);
+      const close = stat.lastIndexOf(')');
+      if (close === -1) return null;
+      // The tail begins at field 3 (state); starttime is field 22.
+      return stat.slice(close + 1).trim().split(/\s+/)[19] || null;
+    }
+    if (platform === 'darwin') {
+      return execFile('ps', ['-o', 'lstart=', '-p', String(pid)]).trim() || null;
+    }
+  } catch { /* fail closed */ }
+  return null;
+}
+
+function leasePath(address, leaseId) {
+  return join(LEASES_DIR, `${addressHash(address)}.${leaseId}.json`);
+}
+
+export function writeLease(lease) {
+  mkdirSync(LEASES_DIR, { recursive: true });
+  const path = leasePath(lease, lease.leaseId);
+  const tmp = `${path}.tmp.${process.pid}.${randomUUID()}`;
+  writeFileSync(tmp, JSON.stringify(lease));
+  renameSync(tmp, path);
+  return lease;
+}
+
+export function readLease(address, leaseId) {
+  try {
+    const lease = JSON.parse(readFileSync(leasePath(address, leaseId), 'utf-8'));
+    return lease.leaseId === leaseId ? lease : null;
+  } catch {
+    return null;
+  }
+}
+
+export function removeLease(address, leaseId) {
+  const path = leasePath(address, leaseId);
+  const lease = readLease(address, leaseId);
+  if (!lease || lease.leaseId !== leaseId) return false;
+  try { unlinkSync(path); return true; } catch { return false; }
+}
+
+function defaultPidAlive(pid) {
+  try { process.kill(pid, 0); return true; } catch { return false; }
+}
+
+export async function leaseMatches(rec, {
+  mux,
+  pidAlive = defaultPidAlive,
+  processBirthFn = processBirth,
+} = {}) {
+  if (!rec?.leaseId || !rec?.pane || !mux) return false;
+  const stored = readLease(rec, rec.leaseId);
+  if (!stored || stored.leaseId !== rec.leaseId || stored.agent !== rec.agent) return false;
+  if (stored.mux !== rec.mux || stored.paneOwner !== rec.paneOwner || stored.pane !== rec.pane) return false;
+  if (!pidAlive(stored.pid)) return false;
+  const birth = processBirthFn(stored.pid);
+  if (!birth || birth !== stored.pidBirth) return false;
+  try { return await mux.paneAlive(rec.pane); } catch { return false; }
+}