unsnooze 1.6.0 → 1.8.0

package/CHANGELOG.md

@@ -1,5 +1,66 @@
 # Changelog
 
+## Unreleased
+
+## 1.8.0 — 2026-07-13
+
+- **Notification channels** (`notifyChannel`: `auto` | `native` | `osc` |
+  `bell`, env `UNSNOOZE_NOTIFY_CHANNEL`): terminal-branded alerts via OSC 9
+  (iTerm2, kitty, WezTerm, Ghostty, Warp) or OSC 777 (rxvt), plus BEL on the
+  pane tty. `auto` sends OSC+BEL when tmux can reach client/pane ttys and
+  falls back to the OS toast only if OSC delivered nothing; denylisted
+  terminals (Apple Terminal, VS Code, Alacritty, Zed) skip OSC in auto.
+  OSC/BEL require tmux — Zellij and GUI-watcher stops use native. Existing
+  `notifications` remains the master off-switch.
+- **Unified ChatGPT desktop app support** (July 2026: the Codex app became the
+  ChatGPT app). Verified against a real install: the app's bundled
+  `codex app-server` still writes rollouts to `~/.codex/sessions/` in the same
+  format (now with additive `limit_id`/`credits`/`plan_type` fields and
+  reason-string `rate_limit_reached_type` values — both handled), and
+  `codex resume <uuid>` works for app-originated sessions. New: when `codex`
+  is not on PATH but ChatGPT.app is installed, unsnooze resolves the
+  app-bundled binary (`ChatGPT.app/Contents/Resources/codex`) for wrappers,
+  wizard detection, and revival. Rollouts older than 7 days are now
+  zstd-compressed by codex; irrelevant for detection (freshness window is
+  minutes) but noted for `unsnooze report` archaeology.
+- Added a dual tmux/Zellij multiplexer backend. The new `multiplexer` setting
+  accepts `auto`, `tmux`, or `zellij`; status output identifies the backend,
+  qualified pane address, and revival session. Zellij revival uses structured
+  pane ownership and a reserved-session smoke test without adding a statusline
+  notification path.
+
+## 1.7.0 — 2026-07-12
+
+- **Four new agent adapters** (all ⚠️ experimental, off by default — enable in
+  `unsnooze setup`):
+  - **Qwen Code** (`qwen`): Claude-shaped `StopFailure` hook installed into
+    `~/.qwen/settings.json` + verbatim quota-banner scraping (legacy OAuth,
+    Coding Plan `Allocated quota exceeded` → 5h window, OpenRouter
+    passthroughs). Resumes via `qwen --resume <id>`, ids from qwen's
+    `*.runtime.json` sidecars.
+  - **Kimi CLI** (`kimi`): detects the terminal red
+    `Error code: 429 … rate_limit_reached_error` line; resumes via
+    `kimi -r <id> -p "<msg>"` with an on-disk id check (kimi silently starts a
+    NEW session for unknown ids). `Membership expired` is notify-only.
+  - **OpenCode** (`opencode`): OpenCode self-retries limits forever (sleeping
+    until reset), so unsnooze records the stop, never touches a live
+    self-retrying pane, and revives dead panes mid-wait via
+    `opencode -s <ses_id>` — reset time parsed from the
+    `[retrying in 2h5m attempt #N]` countdown.
+  - **Antigravity CLI** (`agy`, Google's Gemini-CLI successor): scrapes
+    `Model quota limit exceeded` / `Refreshes in 6 days and 18 hours`
+    (multi-day refresh = weekly cap); `503 MODEL_CAPACITY_EXHAUSTED` is treated
+    as transient overload. Resumes via `agy --conversation=<id>`.
+- **OpenRouter awareness**: 429 bodies (`Rate limit exceeded: limit_…`,
+  free-models-per-day) are detected inside OpenCode/Qwen sessions; credit
+  exhaustion (402) notifies instead of snoozing.
+- **Terminal-error channel**: non-resetting errors (credits exhausted,
+  membership expired, discontinued tiers) now raise a single desktop
+  notification instead of being retried against a reset that will never come.
+- **time-parser**: understands `Refreshes in 6 days and 18 hours`,
+  `It will reset in 2 hours 5 minutes`, `Retry in 45 minutes`, and Go-style
+  countdowns (`2h5m`, `2m 5s`, `~2 days`).
+
 ## 1.6.0 — 2026-07-12
 
 - **Stale-workspace guard** (`workspaceGuard`: `off` | `inform` | `pause`,

package/README.md

@@ -9,10 +9,10 @@
 [![node](https://img.shields.io/badge/node-%E2%89%A5%2020-3fb950)](package.json)
 [![license](https://img.shields.io/badge/license-MIT-8b949e)](LICENSE)
 
-**Claude Code · Codex CLI · Grok** — when they hit the 5-hour or weekly usage limit
+**Claude Code · Codex CLI · Grok · Qwen · Kimi · OpenCode · Antigravity** — when they hit the 5-hour or weekly usage limit
 ("You've hit your usage limit"), your session just… stops.<br/>
 unsnooze auto-resumes them: it tracks **every** limit-stopped session across all
-your projects and **wakes each one up in tmux the moment the usage limit resets.**
+your projects and **wakes each one up in tmux or Zellij the moment the usage limit resets.**
 
 ```sh
 npm install -g unsnooze && unsnooze setup
@@ -40,7 +40,7 @@ existing tool solves only a slice of it:
 ## Supported CLIs
 
 - **Claude Code** — dual-channel detection: the `StopFailure` hook (authoritative,
-  carries `session_id`) plus tmux pane scraping for banners and the interactive
+  carries `session_id`) plus multiplexer pane scraping for banners and the interactive
   limit menu (always answered with *"Stop and wait for limit to reset"*, never a
   blind Enter). Dead sessions revive via `claude --resume <id>`.
 - **OpenAI Codex CLI** — scrape-based (Codex fires no event on limits). Detects
@@ -53,10 +53,46 @@ existing tool solves only a slice of it:
   not publicly documented, so detection uses generic patterns with a safe
   fallback. Hit a banner unsnooze missed? Run `unsnooze report` and paste the
   capture into an issue — that's how this adapter gets good.
+- **Qwen Code** — ⚠️ *experimental*. Dual-channel: a Claude-shaped `StopFailure`
+  hook installed into `~/.qwen/settings.json` (fires with `error: rate_limit`)
+  plus scraping for the verbatim quota renders (`Qwen OAuth quota exceeded`,
+  Coding Plan `Allocated quota exceeded`, and OpenRouter `Rate limit exceeded:
+  limit_…` passthroughs). Qwen never shows a reset time, so waits use the
+  5-hour fallback and self-correct on verify. Dead sessions revive via
+  `qwen --resume <id>` (session ids come from the `*.runtime.json` sidecars
+  qwen writes for exactly this purpose).
+- **Kimi CLI (Moonshot)** — ⚠️ *experimental*. Scrape-based: kimi retries a 429
+  three times within seconds, then stops with a red `LLM provider error: Error
+  code: 429 … rate_limit_reached_error` line — that's the detection anchor.
+  The 429 body carries no reset time (5h fallback + verify). Dead sessions
+  revive via `kimi -r <id> -p "<message>"` — with a guard: kimi silently starts
+  a *new* session for unknown ids, so the id is verified on disk first
+  (`--continue` otherwise). `Membership expired` (402) is notify-only.
+- **OpenCode** — ⚠️ *experimental*, and a different shape: OpenCode *retries
+  rate limits itself, forever*, honoring `retry-after` (it will sleep hours
+  until the reset, showing `Rate Limited [retrying in 2h5m attempt #4]`). So
+  unsnooze records the stop but never touches a live self-retrying pane; its
+  job is reviving sessions whose process died mid-wait (laptop slept, tmux
+  gone) via `opencode -s <ses_id>`, with the reset time parsed straight from
+  the banner countdown. Zen plan banners (`5 hour/weekly/monthly usage limit
+  reached…`) and OpenRouter passthroughs are detected too; `insufficient
+  credits` (402) is notify-only.
+- **Antigravity CLI (Google, `agy`)** — ⚠️ *experimental*. The Gemini-CLI
+  successor. Scrapes the forum-reported quota strings (`Model quota limit
+  exceeded`, `Refreshes in 6 days and 18 hours` — parsed, multi-day refresh =
+  the weekly cap) and treats `503 MODEL_CAPACITY_EXHAUSTED` as a transient
+  overload, not a limit. Dead sessions revive via `agy --conversation=<id>`
+  (ids from `~/.gemini/antigravity-cli/history.jsonl`). Like Grok: closed
+  source, so `unsnooze report` captures make this adapter better.
+
+**OpenRouter** (the API gateway) isn't a separate agent: its 429 bodies
+(`Rate limit exceeded: limit_rpd/…`, free-models-per-day) are detected inside
+the CLIs that use it (OpenCode, Qwen Code), and credit exhaustion (402) is
+surfaced as a notification — there's no reset to wait for, only a top-up.
 
 ## GUI surfaces (VS Code extension, desktop apps)
 
-Terminal sessions are watched through the shell wrapper + tmux. Sessions in
+Terminal sessions are watched through the shell wrapper + tmux or Zellij. Sessions in
 **Claude Code's VS Code extension / desktop app** and **Codex's IDE
 extension / desktop app** have no pane to scrape — so `unsnooze daemon` tails
 the session files those surfaces already write:
@@ -66,14 +102,19 @@ the session files those surfaces already write:
   shared by the CLI and the VS Code extension.
 - **Codex** writes a `rate_limits` snapshot (usage %, **exact epoch reset
   time**) into every rollout under `~/.codex/sessions/` — shared by the CLI,
-  IDE extension, and desktop app.
+  IDE extension, and the **unified ChatGPT desktop app** (July 2026: the Codex
+  app became the ChatGPT app; its bundled `codex app-server` writes the same
+  rollouts to the same store — verified against a real install). On machines
+  where Codex lives only inside ChatGPT.app (no `codex` on PATH), unsnooze
+  automatically resumes through the app-bundled binary
+  (`/Applications/ChatGPT.app/Contents/Resources/codex`).
 - **Claude desktop (cowork) sessions** *(experimental, macOS)* run in
   sandboxes under `~/Library/Application Support/Claude`; unsnooze watches
   those too and revives with the session's isolated `CLAUDE_CONFIG_DIR`
   (plus the keychain-scope override that keeps auth working — verified
   against a real desktop session).
 
-When the limit resets, the session is revived **in a tmux window** with
+When the limit resets, the session is revived **in a multiplexer pane** with
 `claude --resume <id>` / `codex resume <id>` — it's the same session file, so
 the continued conversation stays visible in the GUI's own history. (Resuming
 *inside* the GUI panel isn't possible today: no extension/app exposes an
@@ -93,7 +134,7 @@ anytime with `unsnooze config set guiWatch off`.
 <summary>text version</summary>
 
 ```
-claude / codex / grok (shell wrapper) ──► unsnooze _run <agent> ──► CLI in tmux pane
+claude / codex / grok (shell wrapper) ──► unsnooze _run <agent> ──► CLI in mux pane
                                               │
                                               ├─ per-pane monitor (scrapes for limit
                                               │  banners, drives Claude's limit menu,
@@ -110,7 +151,7 @@ StopFailure hook (claude, grok) ──────────────┤
                                               │
                           ┌───────────────────┴────────────────────┐
                  pane still alive?                          pane gone?
-                 send resume message into it                tmux new-window,
+                 send resume message into it                new multiplexer pane,
                  (only if the CLI is foreground             `unsnooze _run <agent>
                  and not mid-stream)                        --resume <id>`, verify
 ```
@@ -148,19 +189,52 @@ unsnooze help                   # full command list (also -h / --help)
 
 | key | default | meaning |
 |---|---|---|
+| `multiplexer` | `auto` | Backend to use: `auto`, `tmux`, or `zellij`. `auto` prefers the current multiplexer, then the only installed backend, with tmux as the tie-breaker. |
 | `autoResume` | `true` | Master switch. Off = stops are still tracked, but nothing is resumed until you run `unsnooze resume-now` or turn it back on. |
 | `menuAutoAnswer` | `true` | May unsnooze answer Claude's limit menu (send keys in your pane)? Off = watch-only. |
-| `notifications` | `true` | Desktop notification on limit detected / session resumed / gave up. |
+| `notifications` | `true` | Master switch for all notifications (limit detected / session resumed / gave up). Off = silence every channel. |
+| `notifyChannel` | `auto` | How to deliver: `auto`, `native`, `osc`, or `bell` (see [Notification channels](#notification-channels)). Env: `UNSNOOZE_NOTIFY_CHANNEL`. |
 | `guiWatch` | `true` | May the daemon watch session files for GUI-surface stops (VS Code extension, desktop apps)? Needs the daemon running (`unsnooze install --daemon`). |
 | `resumeMessage` | *"Continue where you left off…"* | The message sent to wake a session. Override it for a single session with `unsnooze message <id> "…"` — visible in `unsnooze status`. |
-| `resumeMessages.claude` / `.codex` / `.grok` | `""` | Per-agent override of `resumeMessage`. Empty = use the global message; clear one with `unsnooze config set resumeMessages.claude ""`. |
-| `agents.claude` / `agents.codex` / `agents.grok` | `true` / `true` / `false` | Which CLIs are guarded. |
+| `resumeMessages.claude` / `.codex` / `.grok` / `.qwen` / `.kimi` / `.opencode` / `.agy` | `""` | Per-agent override of `resumeMessage`. Empty = use the global message; clear one with `unsnooze config set resumeMessages.claude ""`. |
+| `agents.claude` / `agents.codex` | `true` | Which CLIs are guarded. |
+| `agents.grok` / `agents.qwen` / `agents.kimi` / `agents.opencode` / `agents.agy` | `false` | Experimental adapters — off by default; enable in `unsnooze setup` or `unsnooze config set agents.qwen on`. |
 | `workspaceGuard` | `inform` | Repo changed while a session slept? `inform` wakes it with a heads-up in the message; `pause` holds it (desktop notification, diff shown on `resume-now`); `off` disables. |
 | `updateCheck` | `true` | Daily new-version check (a plain GET to the npm registry, nothing identifying is sent). Notices after commands + one desktop toast per version. |
 
 Every setting also has a `UNSNOOZE_*` env override (see `src/settings.js`), and
 all timings/paths are tunable via `UNSNOOZE_*` env vars (see `src/config.js`).
 
+### Notification channels
+
+When a limit is hit, a session resumes, or unsnooze gives up, it can alert you
+via an OS toast, a terminal OSC sequence, a BEL, or a mix — controlled by
+`notifyChannel` (default `auto`). `notifications=false` (or
+`UNSNOOZE_NOTIFICATIONS=off`) turns every channel off.
+
+| channel | what it does |
+|---|---|
+| `auto` | OSC (when the terminal supports it) **plus** BEL on the pane tty; falls back to native only if OSC delivered nothing (avoids double banners). No pane / non-tmux mux → native. |
+| `native` | OS toast (macOS `osascript`, Linux `notify-send`, WSL/Windows PowerShell toast); tmux `display-message` as a last-resort statusline fallback on other platforms. |
+| `osc` | Force OSC to attached client ttys; native if zero deliveries. |
+| `bell` | BEL to the pane tty; native if undeliverable. |
+
+**Terminal support (OSC)** — detection uses `TERM_PROGRAM` / termname / known
+env markers:
+
+| terminals | sequence |
+|---|---|
+| iTerm2, kitty, WezTerm, Ghostty, Warp | OSC 9 (`\x1b]9;title: body\x07`) |
+| rxvt / urxvt | OSC 777 (`\x1b]777;notify;title;body\x07`) |
+| Apple Terminal, VS Code, Alacritty, Zed | denylisted — OSC skipped (prefer `native`; force `osc` does not unlock these) |
+| unknown | skipped in `auto`; OSC 9 when `notifyChannel=osc` |
+
+**tmux only for OSC/BEL.** Those paths write to the client's tty (OSC) or the
+pane's tty (BEL), which requires tmux's client/pane tty APIs. **Zellij has no
+equivalent**, so OSC/BEL are not attempted under Zellij — notifications fall
+back to native (and Zellij has no statusline-inject equivalent either). GUI
+watcher stops (no pane context) always use native.
+
 ## Safety properties
 
 - **Never injects blind**: keys are only sent when the pane's foreground
@@ -187,26 +261,31 @@ all timings/paths are tunable via `UNSNOOZE_*` env vars (see `src/config.js`).
 
 ## Requirements
 
-- Node ≥ 20 and tmux
+- Node ≥ 20 and tmux ≥ 3.2 **or** Zellij
 - macOS, Linux, or **Windows via WSL** (see below)
 - zsh or bash (the wrappers are installed into `~/.zshrc` / `~/.bashrc`)
 
 ### Windows / WSL
 
-unsnooze is built on tmux, so on Windows it runs inside
+tmux and Zellij are Unix tools, so on Windows unsnooze runs inside
 [WSL](https://learn.microsoft.com/windows/wsl/install) — which is where the
 agent CLIs live on Windows anyway:
 
 ```sh
 # inside your WSL distro (Ubuntu etc.)
-sudo apt install tmux
+sudo apt install tmux             # or install Zellij: https://zellij.dev/documentation/installation
 npm install -g unsnooze && unsnooze setup
 ```
 
+On macOS, install either backend with `brew install tmux` or
+`brew install zellij`. In `auto` mode unsnooze uses the multiplexer you are
+currently inside; choose one explicitly with
+`unsnooze config set multiplexer tmux` or `zellij`.
+
 Everything works as on Linux, including desktop notifications: inside WSL,
 unsnooze raises **native Windows toasts** through `powershell.exe` (no
 `notify-send` or X server needed). Native Windows (PowerShell/cmd, no WSL) is
-not supported — without tmux there is nothing to watch; unsnooze will tell you
+not supported — without tmux or Zellij there is no terminal pane to watch; unsnooze will tell you
 so and run your CLI unwatched instead of breaking it.
 
 ## FAQ
@@ -252,7 +331,7 @@ disable the check.
 
 Yes — reset times are stored as absolute timestamps and checked every 30
 seconds, so a laptop that slept through the reset resumes on the next tick,
-and dead panes are reopened by session id in a fresh tmux window.
+and dead panes are reopened by session id in a fresh multiplexer pane.
 
 ## Development
 
@@ -260,6 +339,7 @@ and dead panes are reopened by session id in a fresh tmux window.
 npm test                     # unit tests (node:test)
 ./scripts/e2e-simulate.sh    # full detect → wait → re-open cycle in a
                              # scratch tmux session (no real limits needed)
+bash -n scripts/e2e-zellij.sh # syntax-check the reserved-session Zellij smoke test
 ```
 
 ## License

package/bin/unsnooze.js

@@ -69,9 +69,9 @@ async function main() {
       return runHook(rest);
     }
     case '_monitor': {
-      if (!rest[0]) { console.error('unsnooze _monitor: pane id required'); return 2; }
+      if (!rest[0] || !rest[2]) { console.error('unsnooze _monitor: mux owner pane required'); return 2; }
       const { runMonitor } = await import('../src/monitor.js');
-      return runMonitor(rest[0], rest[1]);
+      return runMonitor(rest[0], rest[1], rest[2], rest[3], rest[4]);
     }
     case '_run': {
       if (!rest[0]) { console.error('unsnooze _run: agent id required'); return 2; }
@@ -93,7 +93,7 @@ async function main() {
     case 'daemon': {
       // Persistent resumer + transcript watcher: detects and revives limit
       // stops from GUI surfaces (VS Code extension, desktop apps) where no
-      // shell wrapper or tmux pane exists. Run via launchd/systemd or a shell.
+      // shell wrapper or multiplexer pane exists. Run via launchd/systemd or a shell.
       const { runResumer } = await import('../src/resumer.js');
       const { createWatcher } = await import('../src/watcher.js');
       const controller = new AbortController();
@@ -122,10 +122,11 @@ Usage:
   unsnooze logs [-f]               show (or follow) the unsnooze log
   unsnooze update                  update unsnooze itself to the latest version
   unsnooze daemon                  persistent watcher for GUI sessions (VS Code
-                                   extension, desktop apps) — no tmux needed to
-                                   detect; revival still opens in tmux
+                                   extension, desktop apps) — no live pane needed
+                                   to detect; revival opens in tmux or Zellij
   unsnooze config [list|get|set]   view or change settings (toggles, global +
-                                   per-agent resume messages, updateCheck)
+                                   per-agent resume messages, notifyChannel
+                                   auto|native|osc|bell, updateCheck)
   unsnooze setup                   interactive setup wizard (agents + toggles)
   unsnooze install [--yes]         wire up shell wrappers + hooks (non-interactive)
   unsnooze uninstall [--purge]     remove wrappers + hooks (and state with --purge)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "unsnooze",
-  "version": "1.6.0",
-  "description": "Auto-resume Claude Code, Codex CLI & Grok sessions in tmux when the usage limit (5-hour or weekly) resets. Wakes every limit-stopped AI coding session automatically.",
+  "version": "1.8.0",
+  "description": "Auto-resume Claude Code, Codex CLI, Grok, Qwen Code, Kimi CLI, OpenCode & Antigravity CLI sessions in tmux or Zellij when the usage limit (5-hour or weekly) resets. Wakes every limit-stopped AI coding session automatically.",
   "keywords": [
     "claude",
     "claude-code",
@@ -10,6 +10,14 @@
     "openai",
     "anthropic",
     "grok",
+    "qwen",
+    "qwen-code",
+    "kimi",
+    "kimi-cli",
+    "opencode",
+    "antigravity",
+    "antigravity-cli",
+    "openrouter",
     "usage-limit",
     "usage limit",
     "rate-limit",
@@ -20,6 +28,7 @@
     "resume",
     "retry",
     "tmux",
+    "zellij",
     "ai-agents",
     "agentic-coding",
     "cli"

package/src/agents/agy.js

@@ -0,0 +1,100 @@
+// Google Antigravity CLI adapter (`agy`) — EXPERIMENTAL.
+//
+// agy is the closed-source Go successor to Gemini CLI (which stopped serving
+// individual accounts 2026-06-18). Limits: rolling ~5h "sprint" window plus a
+// weekly cap, metered per model. The banner strings here come from Google
+// forum reports, not source ("Model quota limit exceeded", "Refreshes in
+// 6 days and 18 hours") — grok-bar experimental; improve via `unsnooze report`.
+//
+// 503 MODEL_CAPACITY_EXHAUSTED is provider capacity (transient), NOT a user
+// quota — it takes the overload path.
+//
+// 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.
+
+import { openSync, readSync, closeSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+const AGY_DIR = () => process.env.UNSNOOZE_AGY_DIR || join(homedir(), '.gemini', 'antigravity-cli');
+
+const LIMIT_ANCHORS = [
+  /Model quota limit exceeded/i,
+  /RESOURCE_EXHAUSTED/,
+  /quota (?:limit )?exceeded/i,
+];
+
+export const patterns = {
+  limitPatterns: LIMIT_ANCHORS,
+  // "Refreshes in 6 days and 18 hours" renders near the quota banner; anchors
+  // double as reset lines for the API-key single-line renders.
+  resetPatterns: [
+    /Refreshes in/i,
+    ...LIMIT_ANCHORS,
+  ],
+  weeklyPatterns: [/Refreshes in \d+ days?/i],   // multi-day refresh = the weekly cap
+  fiveHourPatterns: [],
+  busyPatterns: [
+    /esc to interrupt/i,
+    /attempt \d+\/\d+/i,
+  ],
+  idleRegex: /[›❯>]/,
+  overloadPatterns: [/MODEL_CAPACITY_EXHAUSTED/i, /503.*(?:capacity|exhausted)/i],
+  transientPatterns: [/MODEL_CAPACITY_EXHAUSTED/i],
+  terminalPatterns: [/not logged into Antigravity/i],   // auth, not quota — notify only
+};
+
+// ~/.gemini/antigravity-cli/history.jsonl indexes all conversations. Schema is
+// undocumented (and a SQLite migration is rumored) — parse the tail
+// tolerantly: an entry counts if any string value equals the cwd, its id is
+// the first conversation-ish field. Null on any doubt (the resumer then opens
+// a fresh agy session; the wake message explains the context loss).
+function tailBytes(path, bytes = 64 * 1024) {
+  let fd;
+  try {
+    const size = statSync(path).size;
+    fd = openSync(path, 'r');
+    const start = Math.max(0, size - bytes);
+    const buf = Buffer.alloc(size - start);
+    const n = readSync(fd, buf, 0, buf.length, start);
+    return buf.toString('utf-8', 0, n);
+  } catch {
+    return '';
+  } finally {
+    if (fd !== undefined) closeSync(fd);
+  }
+}
+
+export function latestSessionId(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 id = entry.conversation_id ?? entry.conversationId ?? entry.id;
+    if (typeof id === 'string' && id) return id;
+  }
+  return null;
+}
+
+export default {
+  id: 'agy',
+  name: 'Antigravity CLI (Google)',
+  bin: process.env.UNSNOOZE_AGY_BIN || 'agy',
+  experimental: true,
+  patterns,
+  menu: null,
+  // `agy --conversation=<id>` resumes (printed by agy itself on exit);
+  // `--continue` reopens the most recent conversation (verified in agy --help).
+  resumeArgs(sessionId) {
+    return { args: sessionId ? [`--conversation=${sessionId}`] : ['--continue'], messageViaPane: true };
+  },
+  latestSessionId,
+  isForegroundCommand(cmd) {
+    return cmd === 'agy' || cmd === 'node' || cmd === 'unsnooze';
+  },
+};

package/src/agents/codex.js

@@ -10,10 +10,30 @@
 // Transient errors render "stream error: … retrying 4/5 in 1.4s" and must take
 // the overload path, never the ledger.
 
-import { openSync, readSync, closeSync, readdirSync, statSync } from 'node:fs';
+import { openSync, readSync, closeSync, readdirSync, statSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { CODEX_DIR } from '../config.js';
 
+// Since the 2026 unified ChatGPT desktop app absorbed the Codex app, the codex
+// binary ships INSIDE the app bundle and many machines have no standalone
+// `codex` on PATH at all — yet ~/.codex/sessions rollouts (and the resume
+// command) work identically through the bundled binary (verified live against
+// codex-cli 0.144 from ChatGPT.app).
+export const CHATGPT_CODEX_BIN = '/Applications/ChatGPT.app/Contents/Resources/codex';
+
+function codexOnPath(env = process.env) {
+  return (env.PATH || '').split(':').some(dir => {
+    try { return dir && existsSync(join(dir, 'codex')); } catch { return false; }
+  });
+}
+
+export function resolveCodexBin({ env = process.env, onPath = () => codexOnPath(env), exists = existsSync } = {}) {
+  if (env.UNSNOOZE_CODEX_BIN) return env.UNSNOOZE_CODEX_BIN;
+  if (onPath()) return 'codex';
+  if (exists(CHATGPT_CODEX_BIN)) return CHATGPT_CODEX_BIN;
+  return 'codex';   // neither — the launcher degrades gracefully on spawn error
+}
+
 const LIMIT_ANCHORS = [
   /You've hit your usage limit/i,
   /Your workspace is out of credits/i,
@@ -91,7 +111,7 @@ export function latestSessionId(cwd, aroundTs = null, sessionsRoot = join(CODEX_
 export default {
   id: 'codex',
   name: 'OpenAI Codex CLI',
-  bin: process.env.UNSNOOZE_CODEX_BIN || 'codex',
+  bin: resolveCodexBin(),
   experimental: false,
   patterns,
   menu: null,                      // no interactive limit menu

package/src/agents/index.js

@@ -4,8 +4,12 @@
 import claude from './claude.js';
 import codex from './codex.js';
 import grok from './grok.js';
+import qwen from './qwen.js';
+import kimi from './kimi.js';
+import opencode from './opencode.js';
+import agy from './agy.js';
 
-const REGISTRY = { claude, codex, grok };
+const REGISTRY = { claude, codex, grok, qwen, kimi, opencode, agy };
 
 export function getAgent(id) {
   return REGISTRY[id] || claude;

package/src/agents/kimi.js

@@ -0,0 +1,120 @@
+// Kimi CLI adapter (MoonshotAI/kimi-cli, command `kimi`) — EXPERIMENTAL.
+//
+// Limits (researched 2026-07): rolling 5-hour window + weekly quota (7 days
+// from subscription date); a concurrency throttle returns the SAME 429. The
+// CLI retries 429/5xx three times within seconds, then stops with a red
+// "LLM provider error: Error code: 429 - {...rate_limit_reached_error...}"
+// line. The 429 body carries NO reset time → 5h fallback + verify loop.
+// Known limitation: a weekly limit burns fallback attempts until the resumer
+// gives up (a future resetProbe against GET api.kimi.com/coding/v1/usages
+// would fix that).
+//
+// kimi-cli is Python today (pane_current_command may be python3); its
+// kimi-code successor is TypeScript (node) with the same `kimi` command and
+// auto-migrated ~/.kimi state — both are covered.
+
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { createHash } from 'node:crypto';
+
+const KIMI_DIR = () => process.env.UNSNOOZE_KIMI_DIR || join(homedir(), '.kimi');
+
+const LIMIT_ANCHORS = [
+  /rate_limit_reached_error/i,
+  /LLM provider error:.*429/i,
+  /receiving too many requests at the moment/i,
+];
+
+export const patterns = {
+  limitPatterns: LIMIT_ANCHORS,
+  // The 429 render is one line with no reset text — anchors double as reset
+  // lines and time-parser falls back to the 5h default.
+  resetPatterns: [...LIMIT_ANCHORS],
+  weeklyPatterns: [],
+  fiveHourPatterns: [],
+  // Fast in-CLI retries ("Retrying after rate limit · attempt 2/3 · 1.2s")
+  // resolve within seconds — never inject keys during them.
+  busyPatterns: [
+    /Retrying after rate limit/i,
+    /attempt \d+\/\d+/i,
+    /esc to interrupt/i,
+  ],
+  idleRegex: /[›❯>]/,
+  overloadPatterns: [/LLM provider error:.*5\d\d/i, /Retrying after rate limit/i],
+  transientPatterns: [/Retrying after rate limit/i],
+  // 402: no reset exists — notify-only.
+  terminalPatterns: [/Membership expired/i],
+};
+
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+// Sessions live in ~/.kimi/sessions/<md5(cwd)>/<uuid>/.
+function sessionsDirFor(cwd, kimiDir) {
+  return join(kimiDir, 'sessions', createHash('md5').update(cwd).digest('hex'));
+}
+
+function sessionExists(sessionId, kimiDir) {
+  let hashes;
+  try { hashes = readdirSync(join(kimiDir, 'sessions')); } catch { return false; }
+  return hashes.some(h => existsSync(join(kimiDir, 'sessions', h, sessionId)));
+}
+
+// ~/.kimi/kimi.json maps each workdir to its last-used session. The exact
+// entry shape is undocumented — accept a bare id or any uuid-valued field.
+function sessionFromKimiJson(cwd, kimiDir) {
+  try {
+    const meta = JSON.parse(readFileSync(join(kimiDir, 'kimi.json'), 'utf-8'));
+    const entry = meta?.work_dirs?.[cwd];
+    if (typeof entry === 'string' && UUID_RE.test(entry)) return entry;
+    if (entry && typeof entry === 'object') {
+      for (const v of Object.values(entry)) {
+        if (typeof v === 'string' && UUID_RE.test(v)) return v;
+      }
+    }
+  } catch { /* missing or unreadable — fall through */ }
+  return null;
+}
+
+export function latestSessionId(cwd, aroundTs = null, kimiDir = KIMI_DIR()) {
+  const fromMeta = sessionFromKimiJson(cwd, kimiDir);
+  if (fromMeta) return fromMeta;
+
+  const dir = sessionsDirFor(cwd, kimiDir);
+  let entries;
+  try { entries = readdirSync(dir); } catch { return null; }
+  let best = null;
+  for (const name of entries) {
+    if (!UUID_RE.test(name)) continue;
+    let mtime;
+    try { mtime = statSync(join(dir, name)).mtimeMs; } catch { continue; }
+    if (aroundTs != null && Math.abs(mtime - aroundTs) > 30 * 60_000) continue;
+    if (!best || mtime > best.mtime) best = { id: name, mtime };
+  }
+  return best ? best.id : null;
+}
+
+export default {
+  id: 'kimi',
+  name: 'Kimi CLI',
+  bin: process.env.UNSNOOZE_KIMI_BIN || 'kimi',
+  experimental: true,
+  patterns,
+  menu: null,
+  // `kimi -r <id> -p "<msg>"` carries the prompt in argv. Guard: a missing id
+  // makes kimi silently create a NEW session, so verify it exists on disk and
+  // otherwise use --continue (kimi scopes that to the cwd itself).
+  resumeArgs(sessionId, message) {
+    const valid = sessionId && sessionExists(sessionId, KIMI_DIR());
+    return {
+      args: valid ? ['-r', sessionId, '-p', message] : ['--continue', '-p', message],
+      messageViaPane: false,
+    };
+  },
+  latestSessionId,
+  isForegroundCommand(cmd) {
+    // /i: macOS framework builds report "Python" (verified via tmux
+    // pane_current_command against the real pipx install).
+    return cmd === 'kimi' || cmd === 'node' || cmd === 'unsnooze' || /^python(\d(\.\d+)?)?$/i.test(cmd);
+  },
+};