unsnooze 1.14.4 → 1.16.0

package/CHANGELOG.md

@@ -1,5 +1,132 @@
 # Changelog
 
+## 1.16.0 — 2026-08-16
+
+- **Claude Design, and native Windows along the way.** ([#13](https://github.com/saaranshM/unsnooze/issues/13))
+  Claude Design shares your 5-hour and weekly limits with everything else, so a
+  long design run stops exactly like any other session — the obstacle was never
+  the stop, it was that Design's canvas is a web app with no pane to watch, and
+  that the reporter was on Windows, where unsnooze watched nothing at all.
+  `unsnooze design setup` wires up the official `claude-design` MCP server so
+  the work runs inside Claude Code, where it is watched like anything else;
+  `unsnooze design` reports whether it is registered and signed in, keeping
+  those two apart because an expired `/design-login` is *not* a usage limit and
+  waiting will never clear it. unsnooze does not automate the web canvas and
+  will not: Anthropic's Consumer Terms bar automated access to claude.ai, and
+  accounts have been terminated over it.
+
+- **Watching without a multiplexer (`headless`).** A pane was only one of three
+  detection channels — the StopFailure hook and the transcript watcher never
+  needed one. What was missing was somewhere to put a revived agent, so there
+  is now a backend where a "pane" is a pid and a revive is a detached process
+  logging to `~/.unsnooze/headless/`. That makes native Windows, bare servers
+  and CI work. It is picked only when no multiplexer is installed, never ahead
+  of one, and it is honestly weaker: no limit-menu answering, no busy
+  detection, no live pane to attach to.
+
+- **Native Windows is supported.** Previously unsnooze printed *"native Windows
+  is not supported; run inside WSL"* and ran your CLI unwatched. Two things
+  were broken beneath that: the StopFailure hook command was POSIX
+  (`test -f …`), which cmd.exe has no `test` for, so the hook failed on every
+  turn; and the shell wrapper only ever reached `~/.zshrc` and `~/.bashrc`,
+  files a PowerShell user does not have — so nothing routed through unsnooze in
+  the first place. Both are fixed, the daemon autostarts from a logon-triggered
+  Scheduled Task, and `unsnooze doctor` stops reporting wrappers as missing
+  when they are installed. WSL remains the richer option.
+
+- **A server throttle is no longer mistaken for your usage limit.** Claude Code
+  says *"API Error: Server is temporarily limiting requests (not your usage
+  limit)"* — and `usage limit` matched the parenthetical. Since the TUI never
+  clears old banners from scrollback, any stale *"resets 3pm"* nearby was enough
+  to turn a throttle that clears in seconds into an hours-long scheduled wait.
+  It is now read as what it is and handled on the transient overload ladder.
+
+- **Non-resetting Claude stops are notified, not scheduled.** The claude adapter
+  gained the `terminalPatterns` every other adapter already had. An expired
+  Claude Design credential and an exhausted credit balance are stops no amount
+  of waiting clears, so unsnooze says so once instead of booking a wake and
+  burning the attempt cap. This matters most for unattended runs: a revived
+  headless session has no interactive terminal, so `/design-login` cannot even
+  be offered there. All patterns are anchored to the CLI's real error phrasings
+  rather than to the bare command name, so an agent explaining `/design-login`
+  is not a stop.
+
+- **Claude's own auto-continue is recognised, not raced.** Claude Code shipped
+  in-process auto-continue on 2026-08-14 (desktop; the CLI carries it behind a
+  gate that currently defaults off). unsnooze was already guarded — every resume
+  path checks whether the session moved on its own, and the 60s reset margin
+  means Claude gets there first — but a session that woke itself was recorded
+  identically to one unsnooze woke, so the deliberate stand-aside was invisible.
+  Records now carry who resumed them and `unsnooze status` says *"resumed itself
+  (unsnooze stood aside)"*. Note the native feature covers only the 5-hour
+  limit: weekly stops, closed apps, headless boxes and every non-Claude CLI
+  remain unsnooze's job.
+
+- **`launchExtraArgs.<agent>`.** The launch-side twin of `resumeExtraArgs`, for
+  flags that must hold for a whole session rather than just a revival —
+  `unsnooze config set launchExtraArgs.claude "--autocompact 400000"` keeps a
+  context-heavy run compacting instead of stalling. Revivals inherit them, so
+  the flag survives the wake.
+
+## 1.15.0 — 2026-08-15
+
+- **Two new multiplexer backends: herdr and cmux.** unsnooze now watches and
+  revives sessions in [herdr](https://herdr.dev) and [cmux](https://cmux.dev)
+  alongside tmux and Zellij, chosen automatically from the multiplexer you are
+  already inside or explicitly with `unsnooze config set multiplexer herdr`.
+  Both are terminals built for running coding agents, and both start a command
+  by *typing* it into a pane rather than exec'ing it, which is a materially
+  different contract from tmux and Zellij — a revival's arguments are now
+  shell-quoted for them, and an argument that cannot be typed at all (a
+  multi-line resume message, say) travels through the pane's environment
+  instead of being mangled or refused. herdr needs 0.8.0 or newer; Homebrew
+  still ships 0.7.3, so install the release binary. Original herdr backend by
+  Wave Consulting (@walt-verweij) with follow-up work by @gaoflow; cmux backend
+  by @echarrod.
+
+- **Per-model limits are no longer invisible.** Claude Code can stop with
+  *"You've reached your Fable 5 limit. Run /usage-credits to continue or switch
+  models with /model"* — a banner with no reset time, which the previous
+  detection (a limit phrase paired with a time) could never match, and which
+  fires no StopFailure hook. The session simply stopped, untracked and
+  unannounced. It is now detected and tracked. Because only a human clears it,
+  unsnooze never types at such a pane: it probes until the banner goes, and at
+  the ceiling records a visible failure naming both remedies rather than
+  pretending a wake is coming. Detection is deliberately conservative — an
+  agent *quoting* the banner in its own output is not a stop. (@gaoflow)
+
+- **Four reset-scheduling bugs found in production.** A banner left on screen
+  after its reset passed was re-parsed every few seconds as "now + margin", so
+  the wake slid forward forever and the resumer never fired. An undated
+  "resets 10:30pm" re-read after midnight resolved to *tomorrow*, 22 hours out.
+  Accumulated pane-snapshot records with no session id each revived their own
+  copy of the same conversation — 23 records produced roughly 8 clones in one
+  repo at a weekly reset; at most one now revives per agent and project. And a
+  stop arriving after an old record was abandoned is no longer held back by it.
+  (@gaoflow)
+
+- **New setting: `resumeExtraArgs.<agent>`.** A revival spawns the agent binary
+  directly, so flags that normally come from a shell alias or wrapper do not
+  apply — a user who always runs `claude --dangerously-skip-permissions` got a
+  permission-prompting revival, which is about as useful as none. Set them per
+  agent and they are appended to launches unsnooze performs itself. Quoting is
+  respected (`--append-system-prompt "stay in this repo"` is two arguments, not
+  five), and `config.json` accepts an array if you would rather not think about
+  quoting at all.
+
+- **A failed launch no longer leaves a monitor scraping forever.** The monitor
+  starts before the agent does, and when the agent failed to start at all there
+  was no lease to notice its absence — so the monitor watched an ordinary shell
+  prompt indefinitely, one more process per failed launch. It now writes the
+  lease unconditionally (it was previously skipped wherever process start times
+  are unavailable, including Windows) and gives up if none appears. Reported by
+  @echarrod.
+
+- **Node 20.12 is now the minimum.** `engines` promised `>=20` while a
+  dependency needed `styleText` from `node:util`, which arrived in 20.12 — so
+  installs on 20.0–20.11 succeeded and then crashed on startup. The floor is
+  honest now, and CI tests that exact version so it cannot drift again.
+
 ## 1.14.4 — 2026-08-08
 
 - **Windows: the daemon PATH check split on the wrong separator.** The check

package/README.md

@@ -16,7 +16,9 @@
 **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 or Zellij the moment the usage limit resets.**
+your projects and **wakes each one up the moment the usage limit resets** — in
+tmux, Zellij, herdr or cmux, and on **macOS, Linux and Windows**, with or
+without a terminal multiplexer.
 
 ```sh
 npm install -g unsnooze && unsnooze setup
@@ -162,9 +164,48 @@ explicit setup is:
 headroom install apply --scope provider --providers manual --target claude --target codex
 ```
 
+## Claude Design
+
+Claude Design shares your usual 5-hour and weekly limits with chat, Cowork and
+Claude Code — so a long design run stops the same way everything else does, and
+unsnooze resumes it the same way. What it needs first is a terminal to run in.
+
+Claude Design has three surfaces. The canvas at `claude.ai/design` and the
+Claude Desktop sidebar are web apps. The third is an official MCP server that
+Claude Code drives from your terminal, and that is the one unsnooze supports:
+
+```sh
+unsnooze design setup     # registers the claude-design MCP server
+# then, inside Claude Code:
+/design-login
+unsnooze design           # confirms it is registered and signed in
+```
+
+For long design runs, give the session room to compact rather than stall:
+
+```sh
+unsnooze config set launchExtraArgs.claude "--autocompact 400000"
+```
+
+**unsnooze does not automate the web canvas, and will not.** Anthropic's
+Consumer Terms bar accessing Claude "through automated or non-human means,
+whether through a bot, script, or otherwise", and accounts have been terminated
+for it. Claude Code is the documented exemption — which is exactly what
+unsnooze drives. A browser-driving "Design adapter" is not a missing feature
+here; it is one this project declines.
+
+Two things worth knowing:
+
+- A signed-out `/design-login` is **not** a usage limit. Waiting will never
+  clear it, so unsnooze reports it separately instead of letting it look like a
+  stop that will resolve itself.
+- Design used to have its own weekly allowance. It does not now — everything
+  draws from one shared pool, which is why `unsnooze usage` already accounts
+  for design work without knowing it is design work.
+
 ## GUI surfaces (VS Code extension, desktop apps)
 
-Terminal sessions are watched through the shell wrapper + tmux or Zellij. Sessions in
+Terminal sessions are watched through the shell wrapper + tmux, Zellij, or herdr. 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:
@@ -417,7 +458,8 @@ pressing **`R`** (uppercase — lowercase `r` refreshes) only marks it due — t
 remote's own daemon does the actual keystrokes, under the same
 ownership/liveness/menu gates as a local session.
 Resumed and stopped sessions print an attach hint
-(`ssh -t <host> 'tmux new -A -s <session>'` / `zellij attach <session>`) so
+(`ssh -t <host> 'tmux new -A -s <session>'` / `zellij attach <session>` /
+`ssh -t <host> 'herdr session attach <session>'`) so
 you can hop over and watch. An unreachable or out-of-date host shows
 `unreachable`/`skew` rather than blocking the rest of the fleet, and falls
 back to its last-known state (marked `stale`) for up to 24h.
@@ -508,7 +550,7 @@ password hosts on Windows; a plain `ssh <host>` prompt works with native
 
 | 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. |
+| `multiplexer` | `auto` | Backend to use: `auto`, `tmux`, `zellij`, `herdr`, `cmux`, or `headless`. `auto` prefers the current multiplexer (tmux/zellij ambient env, then `CMUX_SOCKET_PATH`); with no ambient env it falls back to whichever of tmux/zellij is installed, tmux as the tie-breaker — cmux is only selected via its ambient env or an explicit setting, never by this installed-backend fallback, since it has no attach-from-outside path to wrap into. cmux support covers resume-in-place (detect, capture, send); it has no joinable named-session model, so idle-session reaping (`unsnooze reap`) does not cover cmux panes, and no attach hint is shown for cmux sessions. `headless` is the no-multiplexer mode (see [Watching without a multiplexer](#watching-without-a-multiplexer)) — `auto` falls back to it only when no multiplexer is installed at all, never ahead of one. |
 | `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` | Master switch for all notifications (limit detected / session resumed / gave up). Off = silence every channel. |
@@ -516,6 +558,8 @@ password hosts on Windows; a plain `ssh <host>` prompt works with native
 | `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. |
 | `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. |
@@ -613,32 +657,92 @@ watcher stops (no pane context) always use native.
 
 ## Requirements
 
-- 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`)
+- Node ≥ 20.12
+- macOS, Linux, or Windows — natively on all three (see
+  [Watching without a multiplexer](#watching-without-a-multiplexer))
+- tmux ≥ 3.2, Zellij, **or** herdr ≥ 0.8.0 for pane-level watching. Optional:
+  without one, unsnooze runs `headless` and still catches and resumes stops.
+- zsh or bash (wrappers go into `~/.zshrc` / `~/.bashrc`), or PowerShell
+  (wrappers go into `$PROFILE.CurrentUserAllHosts`)
+
+### Watching without a multiplexer
+
+A terminal pane is only one of unsnooze's three detection channels. The Claude
+Code **StopFailure hook** and the **session transcript watcher** need no pane at
+all — which is what makes native Windows, bare servers and CI work.
+
+When no multiplexer is installed, `multiplexer: auto` resolves to `headless`:
+
+| | with tmux/Zellij/herdr | `headless` |
+|---|---|---|
+| detects limit stops | pane scrape + hook + transcript | hook + transcript |
+| resumes at reset | yes | yes |
+| answers Claude's limit menu | yes | no |
+| waits out a busy pane | yes | no |
+| revived session | live pane you can attach to | detached process, output in `~/.unsnooze/headless/` |
+
+`headless` is never chosen ahead of a real multiplexer — only when none is
+installed, or when you ask for it with
+`unsnooze config set multiplexer headless`. If you want the full behaviour on
+Windows, WSL is still the better home.
+
+### Windows
+
+Native Windows works: PowerShell wrappers, a cmd-safe StopFailure hook, and a
+logon-triggered Scheduled Task for the daemon. Install as usual and run
+`unsnooze doctor` to confirm.
 
-### Windows / WSL
+Two honest caveats. The daemon is started at logon but not restarted if it
+dies — Task Scheduler is not a supervisor the way launchd and systemd are — so
+after upgrading unsnooze, log out and back in (or run `unsnooze daemon`
+yourself). And stored-password fleet hosts still need Git-for-Windows or WSL
+`ssh`; native `ssh.exe` requires an `.exe` askpass helper unsnooze does not yet
+ship.
 
-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:
+WSL remains the richer option, because that is where the Unix multiplexers live
+— and where the agent CLIs often already are:
 
 ```sh
 # inside your WSL distro (Ubuntu etc.)
 sudo apt install tmux             # or install Zellij: https://zellij.dev/documentation/installation
+# install herdr from https://herdr.dev (requires herdr >= 0.8.0)
 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`.
+`brew install zellij`; install herdr from [herdr.dev](https://herdr.dev).
+herdr >= 0.8.0, which is the version the backend is verified against; older 0.x
+releases are refused by available(). Homebrew currently ships 0.7.3, so install
+the release binary from herdr.dev or GitHub rather than `brew install herdr`.
+In `auto` mode unsnooze uses the multiplexer you are currently inside; choose one
+explicitly with `unsnooze config set multiplexer tmux`, `zellij`, or `herdr`.
+
+#### herdr specifics
+
+herdr differs from tmux and Zellij in three ways that are visible in use:
+
+- **unsnooze never restarts a stopped herdr session.** herdr restores saved
+  agent panes when a session restarts (`resume_agents_on_restore` is on by
+  default), so restarting one can bring your agent back by itself — and a
+  revival on top of that would resume the same conversation twice. Reviving
+  into a stopped session therefore creates `unsnooze-2` (and so on) rather than
+  reusing the name. If you restart a stopped session yourself and herdr brings
+  the agent back, unsnooze may still open a fresh pane for it; that case is not
+  yet detected.
+- **Multi-line resume messages are carried, not typed.** herdr starts a pane
+  command by typing it into the pane's shell, where a newline would submit half
+  a command and a tab would be a completion request. Any such argument is passed
+  through the workspace environment instead and referenced by the typed line, so
+  a multi-paragraph `resumeMessage` reaches the agent as one argument, byte for
+  byte. (A NUL byte is still refused — an environment value cannot hold one.)
+- **A custom `HERDR_SOCKET_PATH` that does not match the session being
+  addressed disables watching for that pane.** herdr pane ids are per-server,
+  so acting on one from the wrong server could type into an unrelated terminal.
+  The agent still runs; unsnooze says why it is not watching.
 
 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 or Zellij there is no terminal pane to watch; unsnooze will tell you
-so and run your CLI unwatched instead of breaking it.
+`notify-send` or X server needed).
 
 ## FAQ
 
@@ -711,6 +815,7 @@ 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
+node scripts/e2e-herdr.mjs    # drives src/multiplexers/herdr.js against a real herdr (not run by CI)
 vhs demo/demo.tape           # regenerate assets/demo.gif (brew install vhs)
 ```
 

package/bin/unsnooze.js

@@ -48,7 +48,7 @@ function runAgentFallback(agentId, args) {
 
 // Only human-facing commands may print update notices — never the wrapper
 // passthrough, hooks, or daemons (their output lands in agent panes/logs).
-const USER_FACING = new Set(['status', 'resume-now', 'cancel', 'message', 'config', 'logs', 'report', 'sessions', 'reap', 'doctor', 'preview', 'usage', 'dashboard', 'hosts', 'fleet', 'prompt', 'help', '-h', '--help', '--help-unsnooze']);
+const USER_FACING = new Set(['status', 'resume-now', 'cancel', 'message', 'config', 'logs', 'report', 'sessions', 'reap', 'doctor', 'preview', 'usage', 'dashboard', 'hosts', 'fleet', 'prompt', 'design', 'help', '-h', '--help', '--help-unsnooze']);
 
 // Every named subcommand; anything else (or no args) is an agent launch.
 const NAMED_COMMANDS = new Set([
@@ -142,6 +142,10 @@ async function main() {
       const { cmdDoctor } = await import('../src/doctor.js');
       return cmdDoctor(rest);
     }
+    case 'design': {
+      const { cmdDesign } = await import('../src/design.js');
+      return cmdDesign(rest);
+    }
     case 'preview': {
       const { cmdPreview } = await import('../src/cli.js');
       return cmdPreview(rest);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "unsnooze",
-  "version": "1.14.4",
-  "description": "Automatically resume Claude Code, Codex CLI, Grok, Qwen Code, Kimi CLI, OpenCode, and Antigravity sessions when 5-hour or weekly usage limits reset—across tmux, Zellij, VS Code, and desktop apps.",
+  "version": "1.16.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.",
   "keywords": [
     "claude",
     "claude-code",
@@ -35,10 +35,18 @@
     "retry",
     "tmux",
     "zellij",
+    "herdr",
     "ai-agents",
     "agentic-coding",
     "cli",
-    "developer-tools"
+    "developer-tools",
+    "windows",
+    "powershell",
+    "claude-design",
+    "mcp",
+    "headless",
+    "wsl",
+    "cmux"
   ],
   "author": "Saaransh Menon <saaransh.dev2811@gmail.com>",
   "license": "MIT",
@@ -65,7 +73,7 @@
     "test": "node --test"
   },
   "engines": {
-    "node": ">=20"
+    "node": ">=20.12"
   },
   "dependencies": {
     "@clack/prompts": "^1.7.0",

package/src/agents/claude.js

@@ -31,6 +31,13 @@ export const patterns = {
     /limit.*(?:this|per)\s+week/i,
   ],
   fiveHourPatterns: [/\d+-hour limit/i, /session limit/i],
+  // Per-model limits carry NO reset time and are not cleared by waiting:
+  //   "You've reached your Fable 5 limit. Run /usage-credits to continue
+  //    or switch models with /model."
+  // The remedy hint is required, not optional — it is what separates a real
+  // banner from an agent discussing usage limits in its own output.
+  modelLimitPatterns: [/(?:reached|hit)\s+(?:your|the)\s+[\w.\s-]{0,24}?\blimit\b/i],
+  modelRemedyPatterns: [/\/usage-credits\b/i, /switch\s+models?\b/i, /\/model\b/i],
   // While Claude is streaming ("esc to interrupt") or running its own internal
   // retries ("Retrying in 5s · attempt 3/10"), never inject keys.
   busyPatterns: [
@@ -45,8 +52,29 @@ export const patterns = {
     /API Error:?\s*\(?5\d\d/i,
     /overloaded_error/i,
     /API Error:?\s*\(?429/i,
+    // "API Error: Server is temporarily limiting requests (not your usage
+    // limit)" — a server-side throttle. It clears in seconds, so it belongs on
+    // this ladder; patterns.js separately refuses to read its parenthetical as
+    // a usage limit.
+    /temporarily limiting requests/i,
   ],
   transientPatterns: [],   // claude's transient errors are the overload set
+  // Stops that waiting cannot clear: notify once, never enter the ledger
+  // (monitor.js). Scheduling a wake for these would burn the attempt cap on a
+  // condition only a human can fix.
+  //
+  // All verbatim from the shipped 2.1.233 bundle. The Claude Design ones matter
+  // most for headless/unattended runs: a revived session has no interactive
+  // terminal, so an expired design credential produces a stop that can never
+  // self-resolve. Anchored to the error phrasings rather than to the bare
+  // command name, so an agent explaining "/design-login" is not a stop.
+  terminalPatterns: [
+    /rejected your \/design-login credential/i,
+    /could not refresh the design access token/i,
+    /could not save the design credential/i,
+    /\/design-login requires an interactive terminal/i,
+    /credit balance is too low/i,
+  ],
 };
 
 // --- Interactive /rate-limit-options menu (Claude Code only) ---
@@ -87,10 +115,21 @@ export default {
   experimental: false,
   patterns,
   menu: { isPrompt: isRateLimitOptionsPrompt, stepsToWait: menuStepsToWaitOption },
-  // How to reopen a dead session. messageViaPane: the resume prompt is typed
-  // into the TUI once it's ready (claude has no resume-with-prompt argv form).
-  resumeArgs(sessionId) {
-    return { args: sessionId ? ['--resume', sessionId] : ['-c'], messageViaPane: true };
+  // How to reopen a dead session.
+  //
+  // Default (a real pane): the prompt is typed into the TUI once it's ready.
+  // That path is load-bearing on tmux/zellij/herdr and stays exactly as it was.
+  //
+  // canType: false (headless — no pane to type into): the prompt rides in argv.
+  // `claude --resume <id> "<prompt>"` resumes that session id and acts on the
+  // prompt, verified against claude 2.1.233 on 2026-08-16. Without a TTY it
+  // runs to completion non-interactively, which is what an unattended overnight
+  // resume wants anyway.
+  resumeArgs(sessionId, message, { canType = true } = {}) {
+    const args = sessionId ? ['--resume', sessionId] : ['-c'];
+    if (canType) return { args, messageViaPane: true };
+    if (message) args.push(message);
+    return { args, messageViaPane: false };
   },
   // v1: every agent launches the bare TUI and gets the prompt typed once idle.
   launchArgs(message) { return { args: [], messageViaPane: true }; },

package/src/cli.js

@@ -94,6 +94,11 @@ export async function cmdStatus(args = []) {
         mux: s.mux ?? null, pane: s.pane ?? null, muxSession: s.muxSession ?? null,
         attempts: s.attempts ?? 0, lastError: s.lastError ?? null,
         workspaceHold: !!s.workspaceHold,
+        // 'unsnooze' | 'native' | null. Since 2026-08-14 Claude Code can resume
+        // a five_hour stop by itself, so "resumed" alone no longer says who did
+        // it — and standing aside for the provider is a deliberate outcome, not
+        // a missing one.
+        resumedBy: s.resumedBy ?? null,
       })),
       promptQueue: queueList(),
     }, null, 2));
@@ -175,8 +180,13 @@ export async function cmdStatus(args = []) {
     let attach = '';
     const hint = await attachHintFor(s);
     if (hint) attach = ` · attach: ${hint}`;
+    // Claude Code can now resume a five_hour stop itself. When it did, say so:
+    // otherwise standing aside (the correct outcome, and the reason nothing was
+    // double-resumed) is indistinguishable from unsnooze having done the work.
+    const by = s.status === 'resumed' && s.resumedBy === 'native'
+      ? ' · resumed itself (unsnooze stood aside)' : '';
     console.log(`  [${s.status.toUpperCase().padEnd(9)}] ${id}  ${(s.agent || 'claude').padEnd(6)} ${s.limitType?.padEnd(7) ?? 'unknown'} ${s.cwd}`);
-    console.log(`              mux ${s.mux ?? '-'} · pane ${pane} · session ${s.muxSession ?? '-'} · via ${origin} · resets ${reset} · attempts ${s.attempts ?? 0}/${MAX_RESUME_ATTEMPTS}${s.lastError ? ` · last error: ${s.lastError}` : ''}${msg}${ctx}${hold}${attach}`);
+    console.log(`              mux ${s.mux ?? '-'} · pane ${pane} · session ${s.muxSession ?? '-'} · via ${origin} · resets ${reset} · attempts ${s.attempts ?? 0}/${MAX_RESUME_ATTEMPTS}${s.lastError ? ` · last error: ${s.lastError}` : ''}${msg}${ctx}${hold}${attach}${by}`);
   }
   printPromptQueueSection(pendingPromptEntries());
   return 0;
@@ -349,6 +359,7 @@ export async function cmdPreview(rest = [], {
       'give-up': () => 'would GIVE UP (attempt cap reached)',
       verifying: () => 'verifying an in-flight resume',
       retry: () => 'would RETRY later (pane capture failed)',
+      superseded: p => `would SKIP — record ${p.target?.key} revives the same conversation`,
       none: () => 'nothing to do',
     };
     let actionable = false;

package/src/config.js

@@ -65,6 +65,27 @@ export const READY_TIMEOUT_MS = envInt('UNSNOOZE_READY_TIMEOUT_MS', 60_000);
 export const EVENT_MARKER_TTL_MS = envInt('UNSNOOZE_EVENT_MARKER_TTL_MS', 120_000);
 export const WATCH_FRESHNESS_MS = envInt('UNSNOOZE_WATCH_FRESHNESS_MS', 15 * 60_000);
 
+// How long a monitor waits for its agent's lease to appear before concluding
+// the launch failed and exiting. The launcher writes the lease immediately
+// after spawn(), so this only ever elapses when no agent was started at all.
+export const LEASE_GRACE_MS = envInt('UNSNOOZE_LEASE_GRACE_MS', 60_000);
+
+// Multiplexer backends, in detection order. The single source of truth: the
+// factory, the `multiplexer` setting enum and reap's session sweep all read
+// this list. It lives here, in a module that imports nothing but node builtins,
+// because settings.js and multiplexer.js already import each other — declaring
+// it in either one puts the other in a temporal dead zone at import time.
+// cmux is last: an agent can run tmux inside a cmux surface, so tmux/zellij
+// must win detection when both are signalled (see multiplexer.js: detect()).
+// headless is last of all and never auto-detected from the environment: it is
+// the no-multiplexer fallback (native Windows, servers, CI), and a real pane
+// must always beat it.
+export const MUX_NAMES = ['tmux', 'zellij', 'herdr', 'cmux', 'headless'];
+
+// Where a headless revive tees the agent's output. There is no pane to scroll
+// back through, so the log is the only record of what an unattended run did.
+export const HEADLESS_LOG_DIR = join(STATE_DIR, 'headless');
+
 // Pane scanning
 export const PANE_SCAN_LINES = envInt('UNSNOOZE_PANE_SCAN_LINES', 12);
 export const CAPTURE_LINES = envInt('UNSNOOZE_CAPTURE_LINES', 200);