unsnooze 1.8.1 → 1.10.0

package/src/monitor.js

@@ -14,14 +14,15 @@ import { getMultiplexer } from './multiplexer.js';
 import {
   SCRAPE_INTERVAL_MS, PANE_SCAN_LINES, CAPTURE_LINES, EVENTS_DIR,
   EVENT_MARKER_TTL_MS, OVERLOAD_BACKOFF_S, OVERLOAD_JITTER,
-  FALLBACK_RESET_MS, RESET_MARGIN_MS, MUX_SESSION_NAME,
+  PROBE_INTERVAL_MS, RESET_MARGIN_MS,
 } from './config.js';
 import { detectLimit, isBusy, overloadMatch } from './patterns.js';
 import { getAgent } from './agents/index.js';
 import { getConfig } from './settings.js';
 import { notify } from './notify.js';
-import { parseResetTime, resetAtMs } from './time-parser.js';
-import { upsertSession, setStatus, readState } from './state.js';
+import { parseResetTime, resetAtMs, sourceRank } from './time-parser.js';
+import { upsertSession, setStatus, readState, updateState } from './state.js';
+import { latestRateLimitFromTranscript } from './watchers/claude.js';
 import { spawnResumerIfNeeded } from './spawn.js';
 import { makeLogger } from './logger.js';
 import { addressHash } from './lease.js';
@@ -40,6 +41,7 @@ export function createMonitor({
   let overloadAttempt = 0;
   let terminalNotified = false;   // one notification per terminal-error appearance
   let running = true;
+  let firstTick = true;           // §6: don't inherit a previous session's banner
 
   function markerPath() {
     return join(EVENTS_DIR, `${addressHash({ mux: muxName, paneOwner, pane })}.json`);
@@ -56,27 +58,102 @@ export function createMonitor({
     }
   }
 
-  async function recordLimit(resetLine, limitType, via) {
+  // Prefer a dated transcript entry when the agent keeps one (claude).
+  function resolveBanner(paneResetLine, paneLimitType) {
     const detectedAt = Date.now();
-    const { at, source } = resetAtMs(parseResetTime(resetLine), {
-      marginMs: RESET_MARGIN_MS, fallbackMs: FALLBACK_RESET_MS,
+    const sessionId = agent.latestSessionId?.(cwd, detectedAt) || null;
+    const fromTx = latestRateLimitFromTranscript(cwd, sessionId, { now: detectedAt });
+    if (fromTx) {
+      return {
+        resetLine: fromTx.resetLine ?? paneResetLine,
+        limitType: fromTx.limitType && fromTx.limitType !== 'unknown' ? fromTx.limitType : paneLimitType,
+        bannerAt: fromTx.timestampMs,
+        sessionId: fromTx.sessionId || sessionId,
+        via: 'transcript',
+        detectedAt,
+      };
+    }
+    return {
+      resetLine: paneResetLine,
+      limitType: paneLimitType,
+      bannerAt: null,
+      sessionId,
+      via: null,   // filled by caller (scrape/hook)
+      detectedAt,
+    };
+  }
+
+  function computeReset(resetLine, bannerAt, detectedAt) {
+    return resetAtMs(parseResetTime(resetLine), {
+      marginMs: RESET_MARGIN_MS,
+      fallbackMs: PROBE_INTERVAL_MS,
+      now: new Date(detectedAt),
+      bannerAt,
+    });
+  }
+
+  // §6 first-tick corroboration: only record if a fresh transcript backs it,
+  // or an absolute clock time resolves to a still-future instant (not the
+  // "already past → due now" path, which is margin above wall clock only).
+  function isCorroborated(resolved, at, source) {
+    if (resolved.via === 'transcript' && resolved.bannerAt != null) return true;
+    if (source === 'absolute' && at - RESET_MARGIN_MS > Date.now()) return true;
+    return false;
+  }
+
+  // §7: upgrade a weak estimate (fallback/relative) when a better value
+  // becomes available. A strictly better source (e.g. fallback→absolute)
+  // always wins — absolute is truth even if later than a probe guess.
+  // Same-or-worse source may only pull the wake earlier, never push it later.
+  function maybeUpgrade(existing, at, source, bannerAt, limitType, via) {
+    if (!existing || existing.status !== 'stopped') return false;
+    const oldRank = sourceRank(existing.resetSource);
+    const newRank = sourceRank(source);
+    const betterSource = newRank > oldRank;
+    const earlier = at < existing.resetAt;
+    if (!betterSource && !earlier) return false;
+    if (!betterSource && at > existing.resetAt) return false;
+    updateState(state => {
+      const s = state.sessions[existing.key];
+      if (!s || s.status !== 'stopped') return;
+      s.resetAt = at;
+      s.resetSource = source;
+      if (bannerAt != null) s.bannerAt = bannerAt;
+      if (limitType && limitType !== 'unknown') s.limitType = limitType;
+      if (via) s.detectedVia = via;
+      if (source !== 'fallback') delete s.probeCount;
     });
-    const sessionId = agent.latestSessionId(cwd, detectedAt);
+    log(`pane ${pane}: upgraded reset ${existing.resetSource}→${source} at ${new Date(at).toISOString()}`);
+    return true;
+  }
+
+  async function recordLimit(resetLine, limitType, via) {
+    const resolved = resolveBanner(resetLine, limitType);
+    const detectedVia = resolved.via || via;
+    const { at, source } = computeReset(resolved.resetLine, resolved.bannerAt, resolved.detectedAt);
+    let muxSession = null;
+    if (typeof mux.sessionForPane === 'function') {
+      try { muxSession = await mux.sessionForPane(pane); } catch { muxSession = null; }
+    }
     const state = upsertSession({
-      sessionId, cwd, pane, mux: muxName, paneOwner, leaseId,
-      agent: agent.id, muxSession: MUX_SESSION_NAME,
-      status: 'stopped', limitType, detectedVia: via, detectedAt,
+      sessionId: resolved.sessionId, cwd, pane, mux: muxName, paneOwner, leaseId,
+      agent: agent.id, muxSession,
+      status: 'stopped', limitType: resolved.limitType, detectedVia,
+      detectedAt: resolved.detectedAt,
+      bannerAt: resolved.bannerAt,
       resetAt: at, resetSource: source,
       attempts: 0, lastAttemptAt: null, lastError: null,
+      ...(source === 'fallback' ? { probeCount: 0 } : {}),
     });
-    trackedKey = sessionId
+    trackedKey = resolved.sessionId
       || Object.values(state.sessions).find(s => s.mux === muxName
         && s.paneOwner === paneOwner && s.pane === pane
         && ['stopped', 'resuming', 'resumed'].includes(s.status))?.key
       || null;
-    log(`pane ${pane}: limit recorded (${limitType}, via ${via}), resets ${new Date(at).toISOString()}`);
+    log(`pane ${pane}: limit recorded (${resolved.limitType}, via ${detectedVia}), resets ${new Date(at).toISOString()} (${source})`);
     notifier(`${agent.name} hit a usage limit`, `${cwd} — auto-resume at ${new Date(at).toLocaleTimeString()}`, { context: notifyCtx });
     spawnResumerIfNeeded();
+    return { at, source, resolved };
   }
 
   async function driveMenu(text) {
@@ -150,9 +227,11 @@ export function createMonitor({
           log(`pane ${pane}: limit menu detected but menuAutoAnswer is off — recording only`);
           await recordLimit(d.hit ? d.resetLine : null, d.hit ? d.limitType : 'unknown', 'scrape');
         }
+        firstTick = false;
         return;
       }
       await driveMenu(visible);
+      firstTick = false;
       return;
     }
 
@@ -160,9 +239,37 @@ export function createMonitor({
     if (d.hit) {
       const state = readState();
       const existing = trackedKey && state.sessions[trackedKey];
+
+      // §7: still-stopped records can upgrade a weak estimate.
+      if (existing && existing.status === 'stopped') {
+        const resolved = resolveBanner(d.resetLine, d.limitType);
+        const via = resolved.via || (marker ? 'hook' : 'scrape');
+        const { at, source } = computeReset(resolved.resetLine, resolved.bannerAt, resolved.detectedAt);
+        maybeUpgrade(existing, at, source, resolved.bannerAt, resolved.limitType, via);
+        firstTick = false;
+        return;
+      }
+
       if (!existing || existing.status !== 'stopped') {
-        await recordLimit(d.resetLine, d.limitType, marker ? 'hook' : 'scrape');
+        const via = marker ? 'hook' : 'scrape';
+        // §6: first tick needs corroboration so we don't inherit a leftover banner.
+        if (firstTick) {
+          const resolved = resolveBanner(d.resetLine, d.limitType);
+          const detectedVia = resolved.via || via;
+          const { at, source } = computeReset(resolved.resetLine, resolved.bannerAt, resolved.detectedAt);
+          if (!isCorroborated({ ...resolved, via: detectedVia }, at, source)) {
+            log(`pane ${pane}: first tick banner uncorroborated (${source}) — skipping`);
+            firstTick = false;
+            return;
+          }
+          // Reuse recordLimit path; resolveBanner is idempotent enough.
+          await recordLimit(d.resetLine, d.limitType, via);
+          firstTick = false;
+          return;
+        }
+        await recordLimit(d.resetLine, d.limitType, via);
       }
+      firstTick = false;
       return;
     }
 
@@ -202,6 +309,8 @@ export function createMonitor({
     } else if (!marker && overloadMatch(text, agent.patterns.overloadPatterns) && !isBusy(text, agent.patterns.busyPatterns)) {
       await handleOverload();
     }
+
+    firstTick = false;
   }
 
   return {
@@ -216,6 +325,7 @@ export function createMonitor({
     stop() { running = false; },
     _tick: tick,   // exposed for tests
     get trackedKey() { return trackedKey; },
+    get _firstTick() { return firstTick; },
   };
 }
 

package/src/multiplexers/session-name.js

@@ -0,0 +1,28 @@
+// Wrapped sessions are created by name, and both tmux and zellij refuse a name
+// that is already live (tmux: "duplicate session: unsnooze"). Concurrent
+// `unsnooze <agent>` launches therefore need distinct names: the first holds
+// the base, later ones take the first free `<base>-N`.
+
+const MAX_PROBES = 64;
+
+export function resolveSessionName(base, isTaken) {
+  if (!isTaken(base)) return base;
+  for (let n = 2; n <= MAX_PROBES; n += 1) {
+    const candidate = `${base}-${n}`;
+    if (!isTaken(candidate)) return candidate;
+  }
+  // Improbable, but a name must still be returned; the pid is unique among live
+  // sessions even if a stale `<base>-<pid>` somehow lingers.
+  return `${base}-${process.pid}`;
+}
+
+// Raised by launchWrapped when the multiplexer binary could not be started
+// (spawnSync result.error). Distinct from a normal agent exit status so the
+// launcher can degrade to an unwatched CLI without double-running a healthy agent.
+export class SessionCreateError extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.name = 'SessionCreateError';
+    if (cause !== undefined) this.cause = cause;
+  }
+}

package/src/multiplexers/tmux.js

@@ -2,6 +2,8 @@ import { execFile as execFileCb, spawnSync } from 'node:child_process';
 import { constants as osConstants } from 'node:os';
 import { promisify } from 'node:util';
 
+import { resolveSessionName, SessionCreateError } from './session-name.js';
+
 const execFileAsync = promisify(execFileCb);
 
 function defaultSpawner(file, args, { sync = false, ...options } = {}) {
@@ -28,6 +30,8 @@ function wrappedSessionName(env) {
 // calls with a pause between them, or Ink treats Enter as bracketed paste.
 export const SUBMIT_DELAY_MS = 150;
 
+export { SessionCreateError };
+
 export function createTmux({ spawner = defaultSpawner, env = process.env } = {}) {
   const run = (...args) => spawner('tmux', args);
 
@@ -79,6 +83,17 @@ export function createTmux({ spawner = defaultSpawner, env = process.env } = {})
       }
     },
 
+    // Live session the pane currently lives in. Trust stdout, not the exit
+    // 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();
+        return out || null;
+      } catch {
+        return null;
+      }
+    },
+
     // Clients attached to the session that owns `pane`. Detached / missing
     // targets return [] so callers can feature-detect without try/catch.
     async clientTtys(pane) {
@@ -147,6 +162,33 @@ export function createTmux({ spawner = defaultSpawner, env = process.env } = {})
       }
     },
 
+    async listSessions() {
+      try {
+        const out = await run('list-sessions', '-F', '#{session_name}');
+        return out.split(/\r?\n/).map(line => line.trim()).filter(Boolean)
+          .map(name => ({ name, exited: false }));
+      } catch {
+        return [];
+      }
+    },
+
+    async listSessionPanes(sessionName) {
+      try {
+        const out = await run('list-panes', '-t', sessionName, '-F', '#{pane_id}');
+        return out.split(/\r?\n/).map(line => line.trim()).filter(Boolean);
+      } catch {
+        return [];
+      }
+    },
+
+    async closePane(pane) {
+      await run('kill-pane', '-t', pane);
+    },
+
+    async deleteSession(name) {
+      await run('kill-session', '-t', name);
+    },
+
     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.
@@ -159,7 +201,9 @@ export function createTmux({ spawner = defaultSpawner, env = process.env } = {})
         pane = await run('new-window', '-t', `${sessionName}:`, '-c', cwd,
           '-P', '-F', '#{pane_id}', ...launch);
       }
-      return { pane: pane.trim(), paneOwner: sessionName };
+      // tmux pane ids are server-global; paneOwner is only meaningful for
+      // zellij. Tracking the session lives on muxSession, not paneOwner.
+      return { pane: pane.trim(), paneOwner: null };
     },
 
     launchWrapped(launchSpec) {
@@ -167,9 +211,26 @@ 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 args = ['new-session', '-s', wrappedSessionName(env),
+      const name = resolveSessionName(wrappedSessionName(env), candidate => {
+        try {
+          return spawner('tmux', ['has-session', '-t', candidate],
+            { sync: true, stdio: 'ignore', env }).status === 0;
+        } catch {
+          return false;
+        }
+      });
+      // 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 || [])];
       const result = spawner('tmux', args, { sync: true, stdio: 'inherit', env });
+      if (result?.error) {
+        throw new SessionCreateError(
+          `failed to start tmux session "${name}": ${result.error.message}`,
+          result.error,
+        );
+      }
       return exitStatus(result);
     },
 

package/src/multiplexers/zellij.js

@@ -3,6 +3,8 @@ import { constants as osConstants } from 'node:os';
 import { basename } from 'node:path';
 import { promisify } from 'node:util';
 
+import { resolveSessionName, SessionCreateError } from './session-name.js';
+
 const execFileAsync = promisify(execFileCb);
 
 function defaultSpawner(file, args, { sync = false, ...options } = {}) {
@@ -48,20 +50,54 @@ function wrappedLayout(launchSpec) {
   return `layout { pane command=${kdlString(argv[0])} close_on_exit=true { args ${argv.slice(1).map(kdlString).join(' ')} } }`;
 }
 
+// Parse `zellij list-sessions -s` rows: strip ANSI, keep leading name token,
+// detect an "(EXITED …)" suffix. Rows that fail to parse are dropped.
+function parseSessionRows(stdout) {
+  return String(stdout)
+    // eslint-disable-next-line no-control-regex
+    .replace(/\u001b\[[0-9;]*m/g, '')
+    .split(/\r?\n/)
+    .map(line => line.trim())
+    .filter(Boolean)
+    .map(line => {
+      const name = line.split(/\s+/)[0];
+      if (!name) return null;
+      return { name, exited: /\(EXITED/i.test(line) };
+    })
+    .filter(Boolean);
+}
+
 export const SUBMIT_DELAY_MS = 150;
 
+export { SessionCreateError };
+
 export function createZellij({ spawner = defaultSpawner, env = process.env } = {}) {
   const childEnv = () => scrubZellijEnv(env);
   const run = (args, options = {}) => spawner('zellij', args, { env: childEnv(), ...options });
 
+  // Sync counterpart of sessionExists, for the sync launchWrapped path. Rows can
+  // carry ANSI colour and an "(EXITED …)" suffix, so only the leading name token
+  // is compared. Probe failure → empty set: assume free and let zellij arbitrate.
+  const liveSessionNames = () => {
+    try {
+      const result = spawner('zellij', ['list-sessions', '-s'],
+        { sync: true, encoding: 'utf8', env: childEnv() });
+      const stdout = typeof result === 'string' ? result : (result?.stdout ?? '');
+      return new Set(parseSessionRows(stdout).map(row => row.name));
+    } catch {
+      return new Set();
+    }
+  };
+
   const build = owner => {
     const owned = (...args) => {
       if (!owner) throw new Error('unsnooze: zellij pane operation requires a session owner');
       return run(['-s', owner, ...args]);
     };
 
-    const paneEntries = async () => {
-      const stdout = await owned('action', 'list-panes', '-a', '-j');
+    const paneEntries = async (session = owner) => {
+      if (!session) throw new Error('unsnooze: zellij pane operation requires a session owner');
+      const stdout = await run(['-s', session, 'action', 'list-panes', '-a', '-j']);
       const parsed = JSON.parse(stdout);
       return Array.isArray(parsed) ? parsed : [];
     };
@@ -127,6 +163,12 @@ export function createZellij({ spawner = defaultSpawner, env = process.env } = {
         }
       },
 
+      // Pane ids are per-session; the bound owner is the session name. Fall
+      // back to the ambient ZELLIJ_SESSION_NAME when unbound.
+      async sessionForPane(_pane) {
+        return owner || env.ZELLIJ_SESSION_NAME || null;
+      },
+
       async paneCurrentCommand(pane) {
         try {
           const id = Number(pane);
@@ -144,21 +186,75 @@ export function createZellij({ spawner = defaultSpawner, env = process.env } = {
       async sessionExists(name) {
         try {
           const stdout = await run(['list-sessions', '-s']);
-          return stdout.split(/\r?\n/).some(line => line.trim() === name);
+          return parseSessionRows(stdout).some(row => row.name === name);
         } catch {
           return false;
         }
       },
 
+      async listSessions() {
+        try {
+          const stdout = await run(['list-sessions', '-s']);
+          return parseSessionRows(stdout);
+        } catch {
+          return [];
+        }
+      },
+
+      async listSessionPanes(sessionName) {
+        try {
+          const entries = await paneEntries(sessionName);
+          return entries
+            .filter(entry => entry.is_plugin === false && entry.exited === false)
+            .map(entry => String(entry.id));
+        } catch {
+          return [];
+        }
+      },
+
+      async closePane(pane) {
+        if (!owner) throw new Error('unsnooze: zellij pane operation requires a session owner');
+        await owned('action', 'close-pane', '-p', `terminal_${pane}`);
+      },
+
+      async deleteSession(name) {
+        await run(['delete-session', name]);
+      },
+
       async newWindow(sessionName, cwd, launchSpec) {
+        let created = false;
+        let preexisting = [];
         if (!(await backend.sessionExists(sessionName))) {
+          // attach -b -c uses the default layout, which leaves a shell pane
+          // that never exits. Snapshot its ids so we can close them after the
+          // agent pane is added (closing the last pane would kill the session).
           await run(['attach', '-b', '-c', sessionName]);
+          created = true;
+          try {
+            preexisting = (await paneEntries(sessionName))
+              .filter(entry => entry.is_plugin === false)
+              .map(entry => entry.id);
+          } catch {
+            preexisting = [];
+          }
         }
+        // --close-on-exit matches launchWrapped's close_on_exit=true and tmux
+        // (pane dies with its command) so exited revivals don't keep the session.
         const stdout = await run([
-          '-s', sessionName, 'run', '--cwd', cwd, '--', ...launchArgv(launchSpec),
+          '-s', sessionName, 'run', '--close-on-exit', '--cwd', cwd, '--',
+          ...launchArgv(launchSpec),
         ]);
         const match = stdout.trim().match(/^terminal_(\d+)$/);
         if (!match) throw new Error(`unsnooze: unexpected zellij pane id: ${stdout.trim()}`);
+        if (created && preexisting.length) {
+          for (const id of preexisting) {
+            try {
+              await run(['-s', sessionName, 'action', 'close-pane', '-p', `terminal_${id}`]);
+            } catch {
+              // Best-effort: a missing default pane is fine.
+            }
+          }
+        }
         return { pane: match[1], paneOwner: sessionName };
       },
 
@@ -166,11 +262,21 @@ export function createZellij({ spawner = defaultSpawner, env = process.env } = {
         // The layout contains exactly one auto-closing pane, avoiding the
         // lingering default shell created by attach -b. The foreground client
         // owns the terminal, so Ctrl-C reaches zellij and its active pane.
+        const live = liveSessionNames();
+        const name = resolveSessionName(wrappedSessionName(env), c => live.has(c));
+        // Session name is discovered live via sessionForPane at record-write
+        // time — do NOT inject UNSNOOZE_SESSION_NAME into the layout env.
         const result = spawner('zellij', [
-          '--session', wrappedSessionName(env), '--layout-string', wrappedLayout(launchSpec),
+          '--session', name, '--layout-string', wrappedLayout(launchSpec),
         ], {
           sync: true, stdio: 'inherit', env: childEnv(),
         });
+        if (result?.error) {
+          throw new SessionCreateError(
+            `failed to start zellij session "${name}": ${result.error.message}`,
+            result.error,
+          );
+        }
         return exitStatus(result);
       },