unsnooze 1.5.0 → 1.7.0

package/CHANGELOG.md

@@ -1,5 +1,47 @@
 # Changelog
 
+## 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`,
+  default `inform`): the repo's HEAD + dirty state are fingerprinted when a
+  session stops and re-checked at wake. `inform` resumes with a "workspace
+  changed while you slept — re-read before acting" note in the wake message;
+  `pause` holds the session (desktop notification, `workspace changed` marker
+  in status) until `unsnooze resume-now`, which prints the diff stat first.
+  Non-git directories are unaffected. Suggested by r/codex feedback.
+
 ## 1.5.0 — 2026-07-12
 
 - **`unsnooze update`**: one command to update unsnooze itself — runs

package/README.md

@@ -9,7 +9,7 @@
 [![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.**
@@ -53,6 +53,42 @@ 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)
 
@@ -153,8 +189,10 @@ unsnooze help                   # full command list (also -h / --help)
 | `notifications` | `true` | Desktop notification on limit detected / session resumed / gave up. |
 | `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
@@ -178,6 +216,11 @@ all timings/paths are tunable via `UNSNOOZE_*` env vars (see `src/config.js`).
   block the CLI).
 - **Overload ≠ limit**: 5xx/529/429 transient errors take a seconds-scale
   backoff path ([30,60,120,240,300]s ± jitter) and never enter the ledger.
+- **Stale-workspace guard**: the repo's HEAD + dirty state are fingerprinted
+  when a session stops. If another session (or you) changed the repo before
+  the wake, the resumed agent is told to re-read before acting — or, with
+  `workspaceGuard=pause`, the session is held and `unsnooze resume-now`
+  shows the diff first.
 
 ## Requirements
 
@@ -233,6 +276,15 @@ desktop notification per version); after updating, the next command shows a
 short "what's new" from the changelog. It's a plain registry GET with nothing
 identifying — turn it off with `unsnooze config set updateCheck off`.
 
+### What if another session changed the repo while one was stopped?
+
+unsnooze fingerprints the workspace (HEAD + uncommitted state) at stop time
+and re-checks at wake. By default the session still resumes, but the wake
+message includes what changed ("HEAD abc1234 → def5678 — re-read before
+continuing"). Set `workspaceGuard` to `pause` to hold such sessions for a
+manual `unsnooze resume-now` (which prints the diff stat), or `off` to
+disable the check.
+
 ### Does it work if my laptop was asleep or the terminal was closed?
 
 Yes — reset times are stored as absolute timestamps and checked every 30

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "unsnooze",
-  "version": "1.5.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.7.0",
+  "description": "Auto-resume Claude Code, Codex CLI, Grok, Qwen Code, Kimi CLI, OpenCode & Antigravity CLI sessions in tmux 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",

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/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);
+  },
+};

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

@@ -33,8 +33,11 @@ export function cmdStatus() {
     const msg = s.resumeMessage
       ? ` · msg: "${s.resumeMessage.length > 44 ? s.resumeMessage.slice(0, 44) + '…' : s.resumeMessage}"`
       : '';
+    const hold = s.workspaceHold
+      ? ` · 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}`);
+    console.log(`              pane ${s.pane ?? '-'} · via ${origin} · resets ${reset} · attempts ${s.attempts ?? 0}/${MAX_RESUME_ATTEMPTS}${s.lastError ? ` · last error: ${s.lastError}` : ''}${msg}${hold}`);
   }
   return 0;
 }
@@ -46,15 +49,30 @@ function selectKeys(state, idOrAll, statuses = ['stopped']) {
   return match.map(s => s.key);
 }
 
-export function cmdResumeNow(idOrAll) {
+export async function cmdResumeNow(idOrAll) {
   const state = readState();
   const keys = selectKeys(state, idOrAll);
   if (keys.length === 0) { console.log('unsnooze: no matching stopped sessions.'); return 1; }
+  // The commenter's "show me the diff": held records print what moved since
+  // the stop-time baseline before we wake them. Best-effort, never blocking.
+  for (const key of keys) {
+    const rec = state.sessions[key];
+    if (rec?.workspaceHold && rec.workspace?.head && rec.cwd) {
+      try {
+        const { execFileSync } = await import('node:child_process');
+        const stat = execFileSync('git', ['-C', rec.cwd, 'diff', '--stat', `${rec.workspace.head}..HEAD`],
+          { stdio: ['ignore', 'pipe', 'ignore'], timeout: 2000 }).toString().trim();
+        if (stat) console.log(`unsnooze: workspace changes since ${key.slice(0, 12)} stopped:\n${stat}`);
+      } catch { /* repo gone or git unhappy — proceed anyway */ }
+    }
+  }
   updateState(s => {
     for (const key of keys) {
       if (s.sessions[key]) {
         s.sessions[key].resetAt = Date.now();
-        s.sessions[key].manual = true;   // explicit user action beats autoResume=off
+        s.sessions[key].manual = true;   // explicit user action beats autoResume=off + workspaceGuard
+        delete s.sessions[key].workspaceHold;
+        delete s.sessions[key].holdReason;
       }
     }
   });

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';
@@ -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/monitor.js

@@ -29,9 +29,10 @@ const log = makeLogger('monitor');
 
 const sleep = ms => new Promise(r => setTimeout(r, ms));
 
-export function createMonitor({ pane, cwd, agent = getAgent('claude'), tmux = realTmux, scrapeInterval = SCRAPE_INTERVAL_MS }) {
+export function createMonitor({ pane, cwd, agent = getAgent('claude'), tmux = realTmux, scrapeInterval = SCRAPE_INTERVAL_MS, notifier = notify }) {
   let trackedKey = null;      // state key of the record we created
   let overloadAttempt = 0;
+  let terminalNotified = false;   // one notification per terminal-error appearance
   let running = true;
 
   function markerPath() {
@@ -156,6 +157,20 @@ export function createMonitor({ pane, cwd, agent = getAgent('claude'), tmux = re
       return;
     }
 
+    // Non-resetting terminal errors (credits exhausted, membership expired,
+    // discontinued tiers): notify once per appearance, never touch the ledger —
+    // there is no reset to wait for. Re-arms when the error clears.
+    const term = overloadMatch(text, agent.patterns.terminalPatterns || []);
+    if (term) {
+      if (!terminalNotified) {
+        terminalNotified = true;
+        notifier(`${agent.name} needs attention ⚠️`, `${cwd} — ${term.line}`);
+        log(`pane ${pane}: terminal error (no auto-resume): ${term.line}`);
+      }
+    } else {
+      terminalNotified = false;
+    }
+
     // No banner. If we were tracking a stopped record and claude is active
     // again, someone resumed it (user or resumer) — mark it.
     if (trackedKey) {

package/src/resumer.js

@@ -18,6 +18,7 @@ import { getAgent } from './agents/index.js';
 import { parseResetTime, resetAtMs } from './time-parser.js';
 import { readState, updateState, setStatus, dueSessions, activeStopped } from './state.js';
 import { getConfig, resolveResumeMessage } from './settings.js';
+import { workspaceFingerprint, workspaceChanged, describeChange } from './workspace.js';
 import { notify } from './notify.js';
 import { UNSNOOZE_BIN } from './spawn.js';
 import { makeLogger } from './logger.js';
@@ -51,7 +52,8 @@ export function releaseSingleton() {
 // it's off. Stops stay tracked either way.
 export function dueForDispatch(now = Date.now()) {
   const auto = getConfig('autoResume');
-  return dueSessions(now).filter(s => auto || s.manual);
+  // workspaceHold: guarded sessions wait for an explicit resume-now (manual).
+  return dueSessions(now).filter(s => (auto || s.manual) && (!s.workspaceHold || s.manual));
 }
 
 function shellQuote(arg) {
@@ -69,7 +71,7 @@ function selfCommand() {
 
 // Decide how to act on one due record. Pure-ish; tmux injectable.
 // Returns: 'sent' | 'reopened' | 'deferred' | 'skip' | 'failed'
-export async function dispatchOne(rec, { tmux = realTmux, resumeMessage, selfCmd = selfCommand() } = {}) {
+export async function dispatchOne(rec, { tmux = realTmux, resumeMessage, selfCmd = selfCommand(), fingerprint = workspaceFingerprint, notifier = notify } = {}) {
   const key = rec.key;
   const agent = getAgent(rec.agent);
   // Wake-message precedence: per-session (`unsnooze message <id> "..."`) →
@@ -77,6 +79,24 @@ export async function dispatchOne(rec, { tmux = realTmux, resumeMessage, selfCmd
   // both the live-pane sendText and the argv reopen path.
   resumeMessage = rec.resumeMessage ?? resumeMessage ?? resolveResumeMessage(agent.id);
 
+  // Stale-workspace guard: another session (or a human) may have moved the
+  // repo while this one slept. Manual resumes (resume-now) always proceed.
+  const guardMode = getConfig('workspaceGuard');
+  if (rec.workspace && guardMode !== 'off' && !rec.manual) {
+    const change = workspaceChanged(rec, fingerprint(rec.cwd));
+    if (change) {
+      const desc = describeChange(change);
+      if (guardMode === 'pause') {
+        setStatus(key, 'stopped', { workspaceHold: true, holdReason: desc });
+        notifier('unsnooze: session held', `${rec.cwd}: workspace changed while stopped (${desc}) — run: unsnooze resume-now`);
+        log(`${key}: workspace changed (${desc}) — held (workspaceGuard=pause)`);
+        return 'held';
+      }
+      resumeMessage += `\n\nHeads up: this workspace changed while the session was stopped (${desc}). Re-read the current state of the repo before continuing.`;
+      log(`${key}: workspace changed (${desc}) — informing agent in the wake message`);
+    }
+  }
+
   // Live-pane path: only if the pane still exists AND the agent CLI is its
   // foreground command (pane ids get recycled — never inject into a random
   // program).

package/src/settings.js

@@ -18,9 +18,10 @@ export const DEFAULTS = {
   notifications: true,     // desktop notifications on detect/resume
   guiWatch: true,          // daemon watches transcripts/rollouts for GUI-session stops
   updateCheck: true,       // daily registry version check + update notices/toast
+  workspaceGuard: 'inform', // repo changed while stopped: off | inform | pause
   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: '' },  // per-agent override; '' = use resumeMessage
-  agents: { claude: true, codex: true, grok: false },   // grok is experimental
+  resumeMessages: { claude: '', codex: '', grok: '', qwen: '', kimi: '', opencode: '', agy: '' },  // per-agent override; '' = use resumeMessage
+  agents: { claude: true, codex: true, grok: false, qwen: false, kimi: false, opencode: false, agy: false },   // experimental agents default off
 };
 
 // Env override per key. Booleans accept 1/0, true/false, on/off, yes/no.
@@ -30,17 +31,31 @@ const ENV_NAMES = {
   notifications: 'UNSNOOZE_NOTIFICATIONS',
   guiWatch: 'UNSNOOZE_GUI_WATCH',
   updateCheck: 'UNSNOOZE_UPDATE_CHECK',
+  workspaceGuard: 'UNSNOOZE_WORKSPACE_GUARD',
   resumeMessage: 'UNSNOOZE_RESUME_MESSAGE',
   'resumeMessages.claude': 'UNSNOOZE_RESUME_MESSAGE_CLAUDE',
   'resumeMessages.codex': 'UNSNOOZE_RESUME_MESSAGE_CODEX',
   'resumeMessages.grok': 'UNSNOOZE_RESUME_MESSAGE_GROK',
+  'resumeMessages.qwen': 'UNSNOOZE_RESUME_MESSAGE_QWEN',
+  'resumeMessages.kimi': 'UNSNOOZE_RESUME_MESSAGE_KIMI',
+  'resumeMessages.opencode': 'UNSNOOZE_RESUME_MESSAGE_OPENCODE',
+  'resumeMessages.agy': 'UNSNOOZE_RESUME_MESSAGE_AGY',
   'agents.claude': 'UNSNOOZE_AGENT_CLAUDE',
   'agents.codex': 'UNSNOOZE_AGENT_CODEX',
   'agents.grok': 'UNSNOOZE_AGENT_GROK',
+  'agents.qwen': 'UNSNOOZE_AGENT_QWEN',
+  'agents.kimi': 'UNSNOOZE_AGENT_KIMI',
+  'agents.opencode': 'UNSNOOZE_AGENT_OPENCODE',
+  'agents.agy': 'UNSNOOZE_AGENT_AGY',
 };
 
 const KNOWN_KEYS = Object.keys(ENV_NAMES);
 
+// String settings restricted to a fixed set of values.
+const ENUMS = {
+  workspaceGuard: ['off', 'inform', 'pause'],
+};
+
 function parseBool(raw) {
   if (/^(1|true|on|yes)$/i.test(raw)) return true;
   if (/^(0|false|off|no)$/i.test(raw)) return false;
@@ -98,6 +113,9 @@ export function setConfigValue(key, rawValue) {
     value = b;
   } else {
     value = String(rawValue);
+    if (ENUMS[key] && !ENUMS[key].includes(value)) {
+      throw new Error(`unsnooze: "${key}" must be one of: ${ENUMS[key].join(', ')}`);
+    }
   }
   const config = readFileConfig();
   const parts = key.split('.');

package/src/state.js

@@ -13,6 +13,7 @@ import {
   STATE_DIR, STATE_FILE, LOCK_DIR, STALE_LOCK_MS, PRUNE_AFTER_MS,
   DEDUPE_WINDOW_MS,
 } from './config.js';
+import { workspaceFingerprint } from './workspace.js';
 import { makeLogger } from './logger.js';
 
 const log = makeLogger('state');
@@ -105,6 +106,11 @@ export function upsertSession(record) {
       log(`merged duplicate detection for pane ${record.pane} into ${existingKey}`);
       return state;
     }
+    // Baseline for the stale-workspace guard, captured once at stop time.
+    // (Merged duplicates above keep the ORIGINAL baseline — spread semantics.)
+    if (record.status === 'stopped' && record.workspace === undefined) {
+      record.workspace = workspaceFingerprint(record.cwd);
+    }
     const key = record.sessionId || `pane:${record.pane}:${record.detectedAt}`;
     state.sessions[key] = { ...record, key };
     return state;

package/src/time-parser.js

@@ -19,7 +19,32 @@ const RESET_DATE_REGEX = /resets?\s+(?:on\s+)?(jan|feb|mar|apr|may|jun|jul|aug|s
 //   older:     "Try again in 4 days 20 hours 9 minutes."
 const TRY_AT_TIME_REGEX = /try again at\s+(\d{1,2})(?::(\d{2}))?\s*(am|pm)/i;
 const TRY_AT_DATE_REGEX = /try again at\s+(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)[a-z]*\s+(\d{1,2})(?:st|nd|rd|th)?,?\s+(\d{4})\s+(\d{1,2}):(\d{2})\s*(am|pm)/i;
-const MULTI_RELATIVE_REGEX = /try again in\s+(?:(\d+)\s*days?\s*)?(?:(\d+)\s*hours?\s*)?(?:(\d+)\s*min(?:ute)?s?)?/i;
+// Multi-unit relative, verb-generalized across CLIs: codex "Try again in 4 days
+// 20 hours 9 minutes", agy "Refreshes in 6 days and 18 hours", opencode "It
+// will reset in 2 hours 5 minutes" / "Retry in 45 minutes".
+const MULTI_RELATIVE_REGEX = /(?:try again|resets?|refreshes|retry|wait)\s+in\s+(?:(\d+)\s*days?\b(?:\s+and)?\s*)?(?:(\d+)\s*hours?\b(?:\s+and)?\s*)?(?:(\d+)\s*min(?:ute)?s?\b)?/i;
+// opencode status line: "Rate Limited [retrying in 2h5m attempt #4]" — the
+// duration is Go-style ("2h5m", "2m 5s", "~2 days").
+const RETRY_BANNER_REGEX = /retrying in\s+([^\]\n]*?)\s*attempt\s*#?\d+/i;
+// (?![a-z]) instead of \b: compact Go durations pack units against the next
+// digit ("2h5m"), where h→5 is not a word boundary.
+const DURATION_TOKEN_REGEX = /~?\s*(\d+(?:\.\d+)?)\s*(ms|milliseconds?|seconds?|secs?|s|min(?:ute)?s?|m|hours?|hrs?|h|days?|d|weeks?|w)(?![a-z])/gi;
+const DURATION_UNIT_MS = {
+  ms: 1, s: 1000, m: 60_000, h: 3_600_000, d: 86_400_000, w: 604_800_000,
+  millisecond: 1, second: 1000, sec: 1000, min: 60_000, minute: 60_000,
+  hour: 3_600_000, hr: 3_600_000, day: 86_400_000, week: 604_800_000,
+};
+
+function parseGoDuration(text) {
+  let total = 0;
+  for (const m of text.matchAll(DURATION_TOKEN_REGEX)) {
+    const raw = m[2].toLowerCase();
+    // Exact form first ("ms" must not singular-strip to "m"), then singular.
+    const perUnit = DURATION_UNIT_MS[raw] ?? DURATION_UNIT_MS[raw.replace(/s$/, '')];
+    if (perUnit) total += parseFloat(m[1]) * perUnit;
+  }
+  return total;
+}
 const MONTH_INDEX = { jan: 0, feb: 1, mar: 2, apr: 3, may: 4, jun: 5, jul: 6, aug: 7, sep: 8, oct: 9, nov: 10, dec: 11 };
 
 function to24h(hour, ampm) {
@@ -32,6 +57,14 @@ function to24h(hour, ampm) {
 export function parseResetTime(text) {
   if (!text) return null;
 
+  // Self-retry countdown banner first (opencode) — the bracketed duration is
+  // the live countdown and beats any older prose in the same line.
+  const retryMatch = text.match(RETRY_BANNER_REGEX);
+  if (retryMatch) {
+    const waitMs = parseGoDuration(retryMatch[1]);
+    if (waitMs > 0) return { relative: true, waitMs };
+  }
+
   // Full-date form first — its trailing "9:01 PM" would otherwise be eaten by
   // the same-day "try again at" regex.
   const dateMatch = text.match(TRY_AT_DATE_REGEX);
@@ -89,16 +122,9 @@ export function parseResetTime(text) {
     };
   }
 
-  const relMatch = text.match(RELATIVE_TIME_REGEX);
-  if (relMatch) {
-    const amount = parseInt(relMatch[1], 10);
-    const unit = relMatch[2].toLowerCase();
-    const isMinutes = unit.startsWith('m');
-    return { relative: true, waitMs: amount * (isMinutes ? 60_000 : 3_600_000) };
-  }
-
-  // Multi-unit relative ("in 4 days 20 hours 9 minutes") — checked after the
-  // single-unit form, which already covers "in 2 hours" / "in 5 minutes".
+  // Multi-unit relative ("in 4 days 20 hours 9 minutes", "in 6 days and 18
+  // hours", "reset in 2 hours 5 minutes") — checked BEFORE the single-unit
+  // form, which would truncate "2 hours 5 minutes" to just "2 hours".
   const multiMatch = text.match(MULTI_RELATIVE_REGEX);
   if (multiMatch && (multiMatch[1] || multiMatch[2] || multiMatch[3])) {
     const days = parseInt(multiMatch[1] || '0', 10);
@@ -107,6 +133,16 @@ export function parseResetTime(text) {
     return { relative: true, waitMs: ((days * 24 + hours) * 60 + minutes) * 60_000 };
   }
 
+  // Single-unit fallback covers colon/verb forms the multi regex doesn't
+  // ("resets in: 3 hours", "wait 5 minutes").
+  const relMatch = text.match(RELATIVE_TIME_REGEX);
+  if (relMatch) {
+    const amount = parseInt(relMatch[1], 10);
+    const unit = relMatch[2].toLowerCase();
+    const isMinutes = unit.startsWith('m');
+    return { relative: true, waitMs: amount * (isMinutes ? 60_000 : 3_600_000) };
+  }
+
   // Day-only weekly banner ("resets Tuesday") with no time — midnight-ish target,
   // resolved by resetAtMs via hour 0.
   if (dayMatch) {

package/src/wizard.js

@@ -142,7 +142,7 @@ export async function runWizard() {
   s.stop(code === 0 ? 'Wrappers and hooks installed' : 'Install hit a problem — see output above');
 
   p.outro(code === 0
-    ? 'Done. Reload your shell (`exec $SHELL`) and use claude/codex/grok as usual.\nCheck `unsnooze status` anytime; change settings with `unsnooze config`.'
+    ? 'Done. Reload your shell (`exec $SHELL`) and use your AI CLIs as usual.\nCheck `unsnooze status` anytime; change settings with `unsnooze config`.'
     : 'Setup incomplete — fix the issue above and re-run `unsnooze setup`.');
   return code;
 }

package/src/workspace.js

@@ -0,0 +1,44 @@
+// Stale-workspace guard: fingerprint a repo when a session stops, compare at
+// wake time. If another session (or a human) moved the repo meanwhile, the
+// resumer either warns the agent in the wake message or holds the session,
+// per the `workspaceGuard` setting. Non-git directories fingerprint to null
+// and are never guarded.
+
+import { execFileSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+
+function git(cwd, args) {
+  return execFileSync('git', ['-C', cwd, ...args], {
+    stdio: ['ignore', 'pipe', 'ignore'], timeout: 1500,
+  }).toString().trim();
+}
+
+export function workspaceFingerprint(cwd) {
+  if (!cwd) return null;
+  try {
+    const head = git(cwd, ['rev-parse', 'HEAD']);
+    const dirty = git(cwd, ['status', '--porcelain']);
+    return { head, dirtyHash: createHash('sha1').update(dirty).digest('hex') };
+  } catch {
+    return null;   // not a git repo / git missing / unreadable — skip the guard
+  }
+}
+
+// null → nothing to report (no baseline, no current, or identical).
+export function workspaceChanged(rec, current) {
+  const before = rec?.workspace;
+  if (!before || !current) return null;
+  if (before.head === current.head && before.dirtyHash === current.dirtyHash) return null;
+  return {
+    oldHead: before.head,
+    newHead: current.head,
+    dirtyChanged: before.dirtyHash !== current.dirtyHash,
+  };
+}
+
+export function describeChange(d) {
+  const parts = [];
+  if (d.oldHead !== d.newHead) parts.push(`HEAD ${d.oldHead.slice(0, 7)} → ${d.newHead.slice(0, 7)}`);
+  if (d.dirtyChanged) parts.push('uncommitted changes differ');
+  return parts.join('; ');
+}