unsnooze 1.17.0 → 1.18.0

package/CHANGELOG.md

@@ -1,5 +1,69 @@
 # Changelog
 
+## 1.18.0 — 2026-09-02
+
+**Cursor CLI support**, a wrapper change that keeps `cursor .` working, and a
+model-limit notification that finally names a remedy the CLI actually has.
+
+### Cursor CLI (`cursor-agent`)
+
+⚠️ Experimental, off by default — turn it on in `unsnooze setup`, or:
+
+```sh
+unsnooze config set agents.cursor on && unsnooze setup
+```
+
+| | |
+|---|---|
+| **Detection** | pane scrape |
+| **Limit type** | `model` — probed, never a scheduled wake |
+| **Revive** | `cursor-agent --resume=<id>`, else `--continue` |
+| **Chat ids** | `~/.cursor/chats/<md5 of cwd>/<id>/meta.json`, verified against the cwd |
+| **Wraps** | `cursor-agent` only |
+
+**Cursor's limit is the first one not worth waiting for.** Its usage resets on
+your monthly *billing cycle*, not a rolling window. From a real limit:
+
+```
+Error: You've hit your usage limit
+Get Cursor Pro for more Agent usage, unlimited Tab, and more.
+fallbackModel:
+spendLimitHit: false
+chatMessage: *…Your usage limits will reset when your monthly cycle ends on 10/2/2026.*
+spendLimits: [50,100,200]
+```
+
+A month out. Sleeping on that would mean a monitor waking in October to type
+into a wall that never moved. So unsnooze treats it as a **model limit**:
+
+- records the stop and tells you it needs a decision
+- probes at 15/30/60 min, resuming the moment the banner clears — you change
+  plan, or the cycle rolls
+- marks the record `failed` at the probe ceiling instead of sending a futile wake
+
+`resetPatterns` is empty on purpose (a test pins it): any reset pattern there
+would silently re-route Cursor onto the 5-hour fallback ladder.
+
+Transport errors take the transient-overload ladder and `Authentication
+required` is notify-only — neither reaches the ledger. Banner text is
+server-provided and plan-dependent, so `unsnooze report cursor` is how it
+improves.
+
+### `cursor .` still opens the IDE
+
+Cursor ships its CLI as both `cursor-agent` and `agent`, while the bare
+`cursor` is the *editor* launcher. Adapters can now declare `wrapperNames`, so
+unsnooze wraps `cursor-agent` and leaves the other two alone — `agent` is far
+too generic to shadow safely. Wrapper output for the existing seven adapters is
+unchanged, byte for byte.
+
+### Model limits now suggest something you can actually do
+
+Both the "needs you" and probe-ceiling notifications hardcoded Claude's
+wording, so a Cursor user was told to run `/usage-credits` — a command Cursor
+does not have. The hint moves onto the adapter, and since a model limit has no
+reset time to wait for, that one sentence is the whole remedy.
+
 ## 1.17.0 — 2026-08-23
 
 - **A state directory unsnooze cannot write to no longer pins a CPU core

package/README.md

@@ -13,7 +13,7 @@
 
 [Website](https://unsnooze.dev) · [Documentation](https://unsnooze.dev/docs/) · [Changelog](https://unsnooze.dev/changelog/) · [Feedback](https://unsnooze.dev/feedback/)
 
-**Claude Code · Codex CLI · Grok · Qwen · Kimi · OpenCode · Antigravity** — when they hit the 5-hour or weekly usage limit
+**Claude Code · Codex CLI · Grok · Qwen · Kimi · OpenCode · Antigravity · Cursor** — 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 the moment the usage limit resets** — in
@@ -35,7 +35,7 @@ existing tool solves only a slice of it:
 
 | | **unsnooze** | claude-auto-retry | autoclaude | hydra |
 |---|:---:|:---:|:---:|:---:|
-| Multi-CLI (Claude · Codex · Grok · Qwen · Kimi · OpenCode · Antigravity) | ✅ | ❌ Claude only | ❌ Claude only | partial |
+| Multi-CLI (Claude · Codex · Grok · Qwen · Kimi · OpenCode · Antigravity · Cursor) | ✅ | ❌ Claude only | ❌ Claude only | partial |
 | GUI sessions (VS Code ext, desktop apps) | ✅ watcher daemon | ❌ | ❌ | ❌ |
 | Waits for reset & resumes the **same** session | ✅ | ✅ | ✅ | ❌ switches provider |
 | All sessions at once (shared ledger + one daemon) | ✅ | ❌ one pane | ✅ | ✅ |
@@ -143,6 +143,24 @@ risks, and vulnerability reporting: **[SECURITY.md](SECURITY.md)**.
   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.
+- **Cursor CLI (`cursor-agent`)** — ⚠️ *experimental*, and the only adapter
+  whose limit is **not waitable**. Cursor's included usage resets on your
+  monthly *billing cycle*, not a rolling window, so unsnooze deliberately never
+  schedules a wake for it: the banner is classified as a model limit, which
+  probes every 15/30/60 min and resumes the moment it clears (you switch to
+  Auto, enable on-demand, or the cycle rolls) instead of sleeping for weeks.
+  The banner text is server-provided — the CLI renders `Error: <title>` plus a
+  detail line and `key: value` extras — and the patterns are pinned against a
+  real captured limit (whose own reset date was a month out, which is the point).
+  `unsnooze report cursor` is how the rest gets better. Transport errors take the transient-overload ladder and
+  `Authentication required` is notify-only. Dead sessions revive via
+  `cursor-agent --resume=<id>` — ids come from `~/.cursor/chats/<md5 of the
+  cwd>/<chatId>/meta.json`, which records the `cwd` so every candidate is
+  verified before use — and `--continue` otherwise, which is workspace-scoped.
+
+  The wrapper shadows **`cursor-agent`** only. The bare `cursor` command is the
+  IDE launcher (`cursor .`) and is never touched; the newer `agent` alias is
+  left alone too, being too generic a name to shadow safely.
 
 **OpenRouter** (the API gateway) isn't a separate agent: its 429 bodies
 (`Rate limit exceeded: limit_rpd/…`, free-models-per-day) are detected inside
@@ -557,11 +575,11 @@ password hosts on Windows; a plain `ssh <host>` prompt works with native
 | `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` / `.qwen` / `.kimi` / `.opencode` / `.agy` | `""` | Per-agent override of `resumeMessage`. Empty = use the global message; clear one with `unsnooze config set resumeMessages.claude ""`. |
-| `resumeExtraArgs.claude` / `.codex` / `.grok` / `.qwen` / `.kimi` / `.opencode` / `.agy` | `""` | Extra flags for launches unsnooze performs itself. A revival spawns the agent binary directly, so flags you normally get from a shell alias or wrapper (`--dangerously-skip-permissions`, `--model …`) do not apply unless you put them here. Quoting is respected: `--append-system-prompt "stay in this repo"` is two arguments, not five. `config.json` may also hold an array (`["--append-system-prompt", "stay in this repo"]`), which skips parsing entirely. |
-| `launchExtraArgs.claude` / `.codex` / `.grok` / `.qwen` / `.kimi` / `.opencode` / `.agy` | `""` | Extra flags for the sessions **you** start through the shell wrapper — the launch-side twin of `resumeExtraArgs`. Use it for flags that have to hold for the whole session: `unsnooze config set launchExtraArgs.claude "--autocompact 400000"` keeps a long, context-heavy run compacting instead of stalling. Flags are placed before your own arguments, since `claude "do the thing"` puts a positional prompt there. Revivals inherit them too, so a flag survives the wake. |
+| `resumeMessages.claude` / `.codex` / `.grok` / `.qwen` / `.kimi` / `.opencode` / `.agy` / `.cursor` | `""` | Per-agent override of `resumeMessage`. Empty = use the global message; clear one with `unsnooze config set resumeMessages.claude ""`. |
+| `resumeExtraArgs.claude` / `.codex` / `.grok` / `.qwen` / `.kimi` / `.opencode` / `.agy` / `.cursor` | `""` | Extra flags for launches unsnooze performs itself. A revival spawns the agent binary directly, so flags you normally get from a shell alias or wrapper (`--dangerously-skip-permissions`, `--model …`) do not apply unless you put them here. Quoting is respected: `--append-system-prompt "stay in this repo"` is two arguments, not five. `config.json` may also hold an array (`["--append-system-prompt", "stay in this repo"]`), which skips parsing entirely. |
+| `launchExtraArgs.claude` / `.codex` / `.grok` / `.qwen` / `.kimi` / `.opencode` / `.agy` / `.cursor` | `""` | Extra flags for the sessions **you** start through the shell wrapper — the launch-side twin of `resumeExtraArgs`. Use it for flags that have to hold for the whole session: `unsnooze config set launchExtraArgs.claude "--autocompact 400000"` keeps a long, context-heavy run compacting instead of stalling. Flags are placed before your own arguments, since `claude "do the thing"` puts a positional prompt there. Revivals inherit them too, so a flag survives the wake. |
 | `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`. |
+| `agents.grok` / `agents.qwen` / `agents.kimi` / `agents.opencode` / `agents.agy` / `agents.cursor` | `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. |
 | `contextGuard` | `inform` | Big cold context at wake? Waking a session re-reads its **entire context at full uncached price** ([why](#why-did-resuming-a-big-session-eat-so-much-of-my-quota)). `inform` resumes and notifies you of the size; `pause` holds sessions above the threshold for `unsnooze resume-now`; `off` disables. Claude Code only for now. |
 | `contextGuardTokens` | `100000` | Context-size threshold (tokens) at which `contextGuard` notifies or holds. |

package/bin/unsnooze.js

@@ -26,6 +26,7 @@ const AGENT_FALLBACK_BINS = {
   kimi: () => process.env.UNSNOOZE_KIMI_BIN || 'kimi',
   opencode: () => process.env.UNSNOOZE_OPENCODE_BIN || 'opencode',
   agy: () => process.env.UNSNOOZE_AGY_BIN || 'agy',
+  cursor: () => process.env.UNSNOOZE_CURSOR_BIN || 'cursor-agent',
 };
 
 async function safeImport(specifier) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "unsnooze",
-  "version": "1.17.0",
-  "description": "Automatically resume Claude Code, Codex CLI, Grok, Qwen Code, Kimi CLI, OpenCode, and Antigravity sessions when 5-hour or weekly usage limits reset—on macOS, Linux and Windows, with or without a terminal multiplexer.",
+  "version": "1.18.0",
+  "description": "Automatically resume Claude Code, Codex CLI, Grok, Qwen Code, Kimi CLI, OpenCode, Antigravity, and Cursor CLI sessions when 5-hour or weekly usage limits reset—on macOS, Linux and Windows, with or without a terminal multiplexer.",
   "keywords": [
     "claude",
     "claude-code",
@@ -18,6 +18,9 @@
     "moonshot",
     "opencode",
     "antigravity",
+    "cursor",
+    "cursor-cli",
+    "cursor-agent",
     "antigravity-cli",
     "gemini",
     "google",

package/src/agents/claude.js

@@ -114,6 +114,9 @@ export default {
   bin: process.env.UNSNOOZE_CLAUDE_BIN || 'claude',
   experimental: false,
   patterns,
+  // Remedy hint for a model limit — no reset time to wait for, so the
+  // notification has to say what the user can actually do about it.
+  modelRemedy: 'switch models (/model) or add credits (/usage-credits)',
   menu: { isPrompt: isRateLimitOptionsPrompt, stepsToWait: menuStepsToWaitOption },
   // How to reopen a dead session.
   //

package/src/agents/cursor.js

@@ -0,0 +1,225 @@
+// Cursor CLI adapter (`cursor-agent`) — EXPERIMENTAL.
+//
+// Cursor ships its terminal agent as ~/.local/bin/{agent,cursor-agent}, both
+// symlinks to ~/.local/share/cursor-agent/versions/<v>/cursor-agent. That file
+// is a bash shim that runs `exec -a "$0" <bundled node> index.js`, so the
+// binary is Node and tmux reports `node` as pane_current_command (verified on
+// darwin/arm64, 2026.08.31-4057e58).
+//
+// The id is `cursor` but the wrapped command is `cursor-agent` (see
+// `wrapperNames` below): the bare `cursor` is the IDE launcher (`cursor .`)
+// and must never be shadowed. The other name, `agent`, is deliberately NOT
+// wrapped — too generic to shadow safely.
+//
+// WHY resetPatterns IS EMPTY — do not "fix" this.
+// Cursor's included usage resets on the monthly BILLING CYCLE ("Your usage
+// limits will reset when your monthly cycle ends on 8/14/2025"), not on a
+// rolling window. detectLimit() runs the waitable-limit loop before the
+// model-limit branch, so a reset pattern here would pair with the banner and
+// produce a `limitType: 'unknown'` record whose unparseable date falls back to
+// 5h — i.e. a blind resume into a wall that is still standing. An empty
+// resetPatterns routes the banner down the model-limit path instead, which
+// probes until the banner clears and never schedules a blind wake. There is a
+// test pinning this.
+//
+// Banner provenance: the limit text is SERVER-provided. The CLI bundle
+// contains no limit strings — it renders `Error: ${details.title}`, then
+// `details.detail`, then one `key: value` line per `details.additionalInfo`
+// entry, with persistUntilInput so the banner stays on screen. CAPTURED FROM A
+// REAL LIMIT (free plan, 2026-09-02):
+//
+//   Error: You've hit your usage limit
+//   Get Cursor Pro for more Agent usage, unlimited Tab, and more.
+//   fallbackModel:
+//   spendLimitHit: false
+//   chatMessage: *You've hit your free requests limit. [Upgrade to
+//   Pro](https://www.cursor.com/...) for more usage, frontier models, Cloud
+//   Agents, and more. Your usage limits will reset when your monthly cycle
+//   ends on 10/2/2026.*
+//   spendLimits: [50,100,200]
+//
+// Note the reset is a MONTH out — exactly why this is not a waitable stop. A
+// `-p` run prints the same thing to stderr with the error class as the prefix
+// (`ActionRequiredError: ...`) and exits 1. Pro-plan wording differs ("Switch
+// to Auto…", "set a Spend Limit") and is covered from user reports; improve
+// the rest from real hits with `unsnooze report cursor`.
+//
+// Verified live against 2026.08.31-4057e58 (logged in, real tmux):
+//   idle      ` → Plan, search, build anything` / ` → Add a follow-up`
+//   busy      `⠘⠤ Working` (braille spinner + label) and the input box's
+//             right placeholder `ctrl+c to stop`
+//   resume    `--continue` is WORKSPACE-scoped — run from project A it resumed
+//             A's chat, not the globally-newest one in B. That is what the
+//             resumer's one-anonymous-record-per-agent+cwd rule assumes, so no
+//             --workspace flag is needed.
+//   submit    the wake message lands with tmux's `send-keys -l` + a separate
+//             `send-keys Enter`, which is exactly what mux.sendText already does.
+//
+// A first launch in an untrusted directory shows a modal "⚠ Workspace Trust
+// Required" screen instead of the prompt. It carries no `→`, so idleRegex
+// already refuses to type into it; busyPatterns names it as well so the refusal
+// does not depend on that. unsnooze deliberately does NOT pass `--trust` on
+// revival — granting execution trust is the user's call, not a side effect of
+// waking a session.
+//
+// Deferred: Cursor writes a status into the TERMINAL TITLE (idle/generating/
+// planning/shell-running/waiting-for-user...), which is a far cleaner
+// busy/idle signal than scraping — but the adapter contract only sees
+// capture-pane text. See the adapter notes in the changelog.
+
+import { readdirSync, readFileSync, statSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+const CURSOR_DIR = () => process.env.UNSNOOZE_CURSOR_DIR || join(homedir(), '.cursor');
+const SCAN_LIMIT = 50;   // project dirs walked by the fallback scan
+
+const LIMIT_ANCHORS = [
+  /You[’']ve hit your (?:usage|free requests?|monthly) limit/i,
+  /You[’']ve hit your limit/i,
+  /(?:usage|spend) limit reached/i,
+];
+
+export const patterns = {
+  limitPatterns: LIMIT_ANCHORS,
+  resetPatterns: [],          // deliberate — see the header
+  weeklyPatterns: [],
+  fiveHourPatterns: [],
+  // The monthly cap is lifted by a human choice (switch to Auto, enable
+  // on-demand, wait for the billing date), never by a short wait — the same
+  // shape as claude's per-model limit, so it takes the same path.
+  modelLimitPatterns: LIMIT_ANCHORS,
+  // The detail line is plan-dependent — a free account is told to upgrade, a Pro
+  // account to switch models or raise a spend limit — so cover both rather than
+  // leaning on the additionalInfo keys alone, which Cursor could drop.
+  modelRemedyPatterns: [
+    /Get Cursor Pro for more Agent usage/i,        // free tier (captured live)
+    /\[?Upgrade to\s+Pro\]?/i,
+    /Switch to Auto for more usage/i,              // Pro tier (reported)
+    /set a Spend Limit/i,
+    /usage limits will reset when your monthly cycle ends/i,
+    /enable (?:on-demand|usage-based)/i,
+    // additionalInfo entries render as bare `key: value` lines under the detail.
+    /^\s*(?:spendLimitHit|fallbackModel|spendLimits|chatMessage):/,
+  ],
+  busyPatterns: [
+    /ctrl\+c to stop/i,                          // input box's right placeholder while generating
+    /[\u2800-\u28ff]\s*(?:Working|Composing)\b/,  // braille spinner + label, e.g. `⠘⠤ Working`
+    // Not "busy" in the streaming sense, but equally un-typeable: the modal
+    // trust gate on a first launch in a directory.
+    /Workspace Trust Required/i,
+    /Do you trust the contents of this directory/i,
+  ],
+  idleRegex: /→/,           // the input box prompt glyph
+  overloadPatterns: [
+    /Can[’']t (?:resolve the Cursor API host|reach the Cursor API)/i,
+    /\b(?:ECONNRESET|ECONNREFUSED|ETIMEDOUT|EPIPE|ENOTFOUND|EAI_AGAIN|NGHTTP2|ERR_HTTP2_SESSION_ERROR)\b/,
+    /socket hang up|Premature close|connection aborted/i,
+    /Agent stopped retrying/i,
+  ],
+  transientPatterns: [
+    /\b(?:ECONNRESET|ETIMEDOUT|EAI_AGAIN)\b/,
+  ],
+  // Auth is not a quota — notify once and record nothing. `-p` runs print the
+  // error class instead of the `Error:` prefix the TUI uses, so match the text
+  // rather than either prefix.
+  terminalPatterns: [
+    /Authentication required\b/i,
+    /Please run '(?:cursor-)?agent login'/i,
+  ],
+};
+
+// Cursor stores each CLI chat as ~/.cursor/chats/<md5(cwd)>/<chatId>/, where
+// <chatId> is the directory name and is exactly what `--resume=<id>` takes
+// (verified live). Its meta.json carries `{ cwd, updatedAtMs, title }`, so the
+// mapping needs no SQLite and no dependency — and every candidate is checked
+// against the cwd before it is used. If Cursor ever changes the hash, the
+// bounded fallback scan below still finds it; if it changes meta.json too,
+// this returns null and the resumer falls back to `--continue`, which is
+// workspace-scoped anyway. A wrong id would resume someone else's
+// conversation, so null is always preferred to a guess.
+//
+// aroundTs is accepted and ignored (as in agy): the chat that just stopped is
+// the most recently updated one for the cwd, which is what we return.
+function readChatMeta(chatDir) {
+  try {
+    const meta = JSON.parse(readFileSync(join(chatDir, 'meta.json'), 'utf-8'));
+    if (!meta || typeof meta.cwd !== 'string') return null;
+    return { cwd: meta.cwd, updatedAtMs: Number(meta.updatedAtMs) || 0 };
+  } catch {
+    return null;
+  }
+}
+
+// Newest chat under `dir` whose meta.json cwd equals `cwd`.
+function newestChatIn(dir, cwd) {
+  let best = null;
+  let entries;
+  try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return null; }
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const meta = readChatMeta(join(dir, entry.name));
+    if (!meta || meta.cwd !== cwd) continue;
+    if (!best || meta.updatedAtMs > best.updatedAtMs) best = { id: entry.name, updatedAtMs: meta.updatedAtMs };
+  }
+  return best;
+}
+
+export function latestSessionId(cwd, aroundTs = null, cursorDir = CURSOR_DIR()) {
+  if (!cwd) return null;
+  const chats = join(cursorDir, 'chats');
+  // Fast path: the project directory is md5 of the cwd (verified live).
+  const direct = newestChatIn(join(chats, createHash('md5').update(cwd).digest('hex')), cwd);
+  if (direct) return direct.id;
+  // Fallback: the hash scheme changed. Scan the most recently touched project
+  // directories only — bounded so a long-lived install never walks hundreds.
+  let projects;
+  try {
+    projects = readdirSync(chats, { withFileTypes: true })
+      .filter(e => e.isDirectory())
+      .map(e => {
+        const full = join(chats, e.name);
+        let mtimeMs = 0;
+        try { mtimeMs = statSync(full).mtimeMs; } catch { /* skip */ }
+        return { full, mtimeMs };
+      })
+      .sort((a, b) => b.mtimeMs - a.mtimeMs)
+      .slice(0, SCAN_LIMIT);
+  } catch {
+    return null;
+  }
+  let best = null;
+  for (const project of projects) {
+    const found = newestChatIn(project.full, cwd);
+    if (found && (!best || found.updatedAtMs > best.updatedAtMs)) best = found;
+  }
+  return best ? best.id : null;
+}
+
+export default {
+  id: 'cursor',
+  name: 'Cursor CLI',
+  bin: process.env.UNSNOOZE_CURSOR_BIN || 'cursor-agent',
+  // `cursor` is the IDE launcher — wrap the agent command only.
+  wrapperNames: ['cursor-agent'],
+  experimental: true,
+  patterns,
+  // Cursor has /model, but no /usage-credits — on-demand usage is a dashboard
+  // setting. Telling a Cursor user to run a command that does not exist is
+  // worse than saying nothing.
+  modelRemedy: 'switch to Auto (/model) or enable on-demand usage in your Cursor dashboard',
+  menu: null,
+  // `--resume [chatId]` and `--continue` both verified in `cursor-agent --help`
+  // (2026.08.31). --resume takes an optional value, so use the equals form.
+  resumeArgs(sessionId) {
+    return { args: sessionId ? [`--resume=${sessionId}`] : ['--continue'], messageViaPane: true };
+  },
+  // v1: every agent launches the bare TUI and gets the prompt typed once idle.
+  launchArgs(message) { return { args: [], messageViaPane: true }; },
+  latestSessionId,
+  // The bash shim execs the bundled node, so tmux reports `node`.
+  isForegroundCommand(cmd) {
+    return cmd === 'cursor-agent' || cmd === 'agent' || cmd === 'node' || cmd === 'unsnooze';
+  },
+};

package/src/agents/index.js

@@ -8,8 +8,9 @@ import qwen from './qwen.js';
 import kimi from './kimi.js';
 import opencode from './opencode.js';
 import agy from './agy.js';
+import cursor from './cursor.js';
 
-const REGISTRY = { claude, codex, grok, qwen, kimi, opencode, agy };
+const REGISTRY = { claude, codex, grok, qwen, kimi, opencode, agy, cursor };
 
 // v1: every agent launches the bare TUI and gets the prompt typed once idle.
 function defaultLaunchArgs(message) { return { args: [], messageViaPane: true }; }

package/src/install.js

@@ -16,6 +16,7 @@ import { CLAUDE_SETTINGS, STATE_DIR } from './config.js';
 import { getConfig, configFileExists } from './settings.js';
 import { xmlEscape } from './notify.js';
 import { installGrokHooks, uninstallGrokHooks } from './agents/grok.js';
+import { getAgent } from './agents/index.js';
 import { findCsgProcesses, findCsgAutostarts } from './doctor.js';
 import { UNSNOOZE_BIN, stopResumer } from './spawn.js';
 import { uninstallStatuslineShim } from './usage.js';
@@ -115,18 +116,29 @@ export function removeHookFromSettings(settingsJson) {
 
 // --- zshrc block management ---
 
+// Which shell commands an agent's wrappers shadow. Normally exactly the id,
+// because the id IS the command users type. Cursor breaks that: its id is
+// `cursor` but its command is `cursor-agent`, and the bare `cursor` belongs to
+// the IDE launcher (`cursor .`) which must never be shadowed. An adapter names
+// the commands to wrap via `wrapperNames`; the `_run` argument stays the id.
+export function wrapperNamesFor(id) {
+  const agent = getAgent(id);
+  // getAgent falls back to claude for unknown ids — never borrow its names.
+  return agent.id === id && agent.wrapperNames?.length ? agent.wrapperNames : [id];
+}
+
 export function wrapperBlock(agents = ['claude']) {
   // The missing-file guard is load-bearing: if unsnooze is ever uninstalled,
   // moved, or renamed without cleaning the rc file, the wrapper must degrade
   // to the plain CLI — never brick the user's `claude`/`codex` command.
-  const fns = agents.map(id => `unalias ${id} 2>/dev/null || true
-${id}() {
+  const fns = agents.flatMap(id => wrapperNamesFor(id).map(name => `unalias ${name} 2>/dev/null || true
+${name}() {
   if [ "\${UNSNOOZE_ACTIVE}" = "1" ] || [ ! -f "${UNSNOOZE_BIN}" ]; then
-    command ${id} "$@"
+    command ${name} "$@"
     return $?
   fi
   node "${UNSNOOZE_BIN}" _run ${id} "$@"
-}`).join('\n');
+}`)).join('\n');
   return `${FENCE_OPEN}
 # unsnooze wrappers: route every interactive launch of the CLIs below through
 # unsnooze so limit stops are recorded and auto-resumed.
@@ -142,16 +154,16 @@ ${FENCE_CLOSE}`;
 // PowerShell comments are `#`, so the same fence markers work and
 // stripFencedBlock() removes it unchanged.
 export function powershellWrapperBlock(agents = ['claude'], bin = UNSNOOZE_BIN) {
-  const fns = agents.map(id => `Remove-Item -Path Alias:${id} -Force -ErrorAction SilentlyContinue
-function ${id} {
+  const fns = agents.flatMap(id => wrapperNamesFor(id).map(name => `Remove-Item -Path Alias:${name} -Force -ErrorAction SilentlyContinue
+function ${name} {
   if ($env:UNSNOOZE_ACTIVE -eq '1' -or -not (Test-Path -LiteralPath '${bin}')) {
-    $real = Get-Command ${id} -CommandType Application -ErrorAction SilentlyContinue |
+    $real = Get-Command ${name} -CommandType Application -ErrorAction SilentlyContinue |
       Select-Object -First 1
-    if ($real) { & $real.Source @args } else { Write-Error '${id}: not found' }
+    if ($real) { & $real.Source @args } else { Write-Error '${name}: not found' }
     return
   }
   & node '${bin}' _run ${id} @args
-}`).join('\n');
+}`)).join('\n');
   return `${FENCE_OPEN}
 # unsnooze wrappers: route every interactive launch of the CLIs below through
 # unsnooze so limit stops are recorded and auto-resumed.
@@ -502,7 +514,7 @@ export function uninstallDaemonAutostart({ platform = process.platform, dir = nu
 // --- commands ---
 
 export function enabledAgents() {
-  return ['claude', 'codex', 'grok', 'qwen', 'kimi', 'opencode', 'agy'].filter(id => getConfig(`agents.${id}`));
+  return ['claude', 'codex', 'grok', 'qwen', 'kimi', 'opencode', 'agy', 'cursor'].filter(id => getConfig(`agents.${id}`));
 }
 
 // Qwen keeps Claude-shaped hooks in its own settings.json — reuse the same

package/src/monitor.js

@@ -16,7 +16,7 @@ import {
   EVENT_MARKER_TTL_MS, OVERLOAD_BACKOFF_S, OVERLOAD_JITTER,
   PROBE_INTERVAL_MS, RESET_MARGIN_MS, LEASE_GRACE_MS,
 } from './config.js';
-import { detectLimit, isBusy, overloadMatch } from './patterns.js';
+import { detectLimit, isBusy, overloadMatch, modelRemedy } from './patterns.js';
 import { getAgent } from './agents/index.js';
 import { getConfig } from './settings.js';
 import { notify } from './notify.js';
@@ -208,7 +208,7 @@ export function createMonitor({
     log(`pane ${pane}: limit recorded (${resolved.limitType}, via ${detectedVia}), resets ${new Date(at).toISOString()} (${source})`);
     if (resolved.limitType === 'model') {
       notifier(`${agent.name} hit a model limit — needs you`,
-        `${cwd} — switch models (/model) or add credits (/usage-credits); unsnooze wakes it once the banner clears`,
+        `${cwd} — ${modelRemedy(agent)}; unsnooze wakes it once the banner clears`,
         { context: notifyCtx });
     } else {
       notifier(`${agent.name} hit a usage limit`, `${cwd} — auto-resume at ${new Date(at).toLocaleTimeString()}`, { context: notifyCtx });

package/src/patterns.js

@@ -148,6 +148,13 @@ export function detectLimit(text, tailLines = 12, sets = claudePatterns) {
   return { hit: true, limitType, resetLine };
 }
 
+// What a user can actually do about a model limit. There is no reset time to
+// wait for, so the notification must name a real remedy — and the remedy is
+// per-CLI (claude has /usage-credits, cursor does not).
+export function modelRemedy(agent) {
+  return agent?.modelRemedy || 'switch models or add credits';
+}
+
 function tail(text, n = 12) {
   return contentLines(text, n);
 }

package/src/resumer.js

@@ -14,7 +14,7 @@ import {
   CAPTURE_LINES, PANE_SCAN_LINES, RESUME_SESSION_NAME,
   RESET_MARGIN_MS, FALLBACK_RESET_MS, PROBE_INTERVAL_MS, PROBE_MAX_MS,
 } from './config.js';
-import { detectLimit, isBusy } from './patterns.js';
+import { detectLimit, isBusy, modelRemedy } from './patterns.js';
 import { getAgent } from './agents/index.js';
 import { parseResetTime, resetAtMs, nextProbeDelayMs } from './time-parser.js';
 import {
@@ -372,7 +372,7 @@ function rescheduleProbe(rec, now = Date.now()) {
       }, { expect: ['stopped'] });
       log(`${key}: model limit still active at probe ceiling — needs a human`);
       notify('unsnooze: model limit needs you ⚠️',
-        `${rec.cwd}: still limited after probing — /model to switch or /usage-credits`,
+        `${rec.cwd}: still limited after probing — ${modelRemedy(getAgent(rec.agent))}`,
         { context: ctxOf(rec), priority: 4 });
       return 'held';
     }

package/src/settings.js

@@ -45,19 +45,19 @@ export const DEFAULTS = {
   // command that answers 'disabled' still returns a valid framed envelope.
   remoteQueue: true,
   resumeMessage: 'Continue where you left off. The session was interrupted by a usage limit which has now reset — pick up the task you were working on and finish it.',
-  resumeMessages: { claude: '', codex: '', grok: '', qwen: '', kimi: '', opencode: '', agy: '' },  // per-agent override; '' = use resumeMessage
+  resumeMessages: { claude: '', codex: '', grok: '', qwen: '', kimi: '', opencode: '', agy: '', cursor: '' },  // per-agent override; '' = use resumeMessage
   // Extra argv appended when unsnooze itself launches the agent binary (dead-pane
   // reopen, queued prompts). Space-separated. Lets a revived session match the
   // user's normal launch mode — shell aliases don't apply to direct spawns
   // (e.g. claude users who always launch with --dangerously-skip-permissions).
-  resumeExtraArgs: { claude: '', codex: '', grok: '', qwen: '', kimi: '', opencode: '', agy: '' },
+  resumeExtraArgs: { claude: '', codex: '', grok: '', qwen: '', kimi: '', opencode: '', agy: '', cursor: '' },
   // Extra argv for launches the USER performs through the shell wrapper — the
   // launch-side twin of resumeExtraArgs. A flag that has to hold for the whole
   // session (claude's --autocompact, which decides when the context window is
   // compacted) is useless if it only applies to revives, because the session
   // that runs out of context is the one the user started.
-  launchExtraArgs: { claude: '', codex: '', grok: '', qwen: '', kimi: '', opencode: '', agy: '' },
-  agents: { claude: true, codex: true, grok: false, qwen: false, kimi: false, opencode: false, agy: false },   // experimental agents default off
+  launchExtraArgs: { claude: '', codex: '', grok: '', qwen: '', kimi: '', opencode: '', agy: '', cursor: '' },
+  agents: { claude: true, codex: true, grok: false, qwen: false, kimi: false, opencode: false, agy: false, cursor: false },   // experimental agents default off
 };
 
 // Env override per key. Booleans accept 1/0, true/false, on/off, yes/no.
@@ -90,6 +90,7 @@ const ENV_NAMES = {
   'resumeMessages.kimi': 'UNSNOOZE_RESUME_MESSAGE_KIMI',
   'resumeMessages.opencode': 'UNSNOOZE_RESUME_MESSAGE_OPENCODE',
   'resumeMessages.agy': 'UNSNOOZE_RESUME_MESSAGE_AGY',
+  'resumeMessages.cursor': 'UNSNOOZE_RESUME_MESSAGE_CURSOR',
   'resumeExtraArgs.claude': 'UNSNOOZE_RESUME_EXTRA_ARGS_CLAUDE',
   'resumeExtraArgs.codex': 'UNSNOOZE_RESUME_EXTRA_ARGS_CODEX',
   'resumeExtraArgs.grok': 'UNSNOOZE_RESUME_EXTRA_ARGS_GROK',
@@ -97,6 +98,7 @@ const ENV_NAMES = {
   'resumeExtraArgs.kimi': 'UNSNOOZE_RESUME_EXTRA_ARGS_KIMI',
   'resumeExtraArgs.opencode': 'UNSNOOZE_RESUME_EXTRA_ARGS_OPENCODE',
   'resumeExtraArgs.agy': 'UNSNOOZE_RESUME_EXTRA_ARGS_AGY',
+  'resumeExtraArgs.cursor': 'UNSNOOZE_RESUME_EXTRA_ARGS_CURSOR',
   'launchExtraArgs.claude': 'UNSNOOZE_LAUNCH_EXTRA_ARGS_CLAUDE',
   'launchExtraArgs.codex': 'UNSNOOZE_LAUNCH_EXTRA_ARGS_CODEX',
   'launchExtraArgs.grok': 'UNSNOOZE_LAUNCH_EXTRA_ARGS_GROK',
@@ -104,6 +106,7 @@ const ENV_NAMES = {
   'launchExtraArgs.kimi': 'UNSNOOZE_LAUNCH_EXTRA_ARGS_KIMI',
   'launchExtraArgs.opencode': 'UNSNOOZE_LAUNCH_EXTRA_ARGS_OPENCODE',
   'launchExtraArgs.agy': 'UNSNOOZE_LAUNCH_EXTRA_ARGS_AGY',
+  'launchExtraArgs.cursor': 'UNSNOOZE_LAUNCH_EXTRA_ARGS_CURSOR',
   'agents.claude': 'UNSNOOZE_AGENT_CLAUDE',
   'agents.codex': 'UNSNOOZE_AGENT_CODEX',
   'agents.grok': 'UNSNOOZE_AGENT_GROK',
@@ -111,6 +114,7 @@ const ENV_NAMES = {
   'agents.kimi': 'UNSNOOZE_AGENT_KIMI',
   'agents.opencode': 'UNSNOOZE_AGENT_OPENCODE',
   'agents.agy': 'UNSNOOZE_AGENT_AGY',
+  'agents.cursor': 'UNSNOOZE_AGENT_CURSOR',
 };
 
 const KNOWN_KEYS = Object.keys(ENV_NAMES);