unsnooze 1.12.2 → 1.14.0

package/CHANGELOG.md

@@ -2,6 +2,90 @@
 
 ## Unreleased
 
+## 1.14.0 — 2026-07-19
+
+- **Queued prompts**: `unsnooze prompt add [--agent id] [--project path]
+  [--at time|--now] <text...>` (plus `list`/`remove`/`clear`) queues a
+  one-shot prompt that spawns a **brand-new** agent session in a project
+  directory once a usage limit clears. `--now`/`--at` (epoch, ISO-8601,
+  `+2h30m`, or a bare clock time) skip the reset wait; with no reset signal
+  at all, a `next-reset` entry delivers on the very next daemon tick and
+  `prompt add` prints a notice to that effect. Delivery is verified against
+  a fresh limit banner and backs off on failure — the same backoff floor
+  applies to every mode, capped at 5 attempts (same as resume) before an
+  entry is marked failed. `autoResume` does not gate delivery. Dashboard:
+  a new **Prompts** tab (`7`) — list, `a` to add, `d`/`x` to remove — plus a
+  queued-count hint on the Status tab. Fleet: `--host <name>` relays the
+  same subcommands to a registered host's own queue (`--project`/`--agent`
+  required, everything re-validated server-side); the new `remoteQueue`
+  setting (default on) lets a host opt out of all queue traffic, answering
+  a typed `disabled` instead of silently dropping it.
+- **Fleet password auth**: hosts can now use a password instead of an ssh key
+  — `unsnooze hosts add <name> <dest> --auth password --source
+  prompt|env|keychain|command` (`prompt` is interactive no-echo and the
+  default; `env`/`keychain`/`command` are daemon-capable). `keychain` is a
+  macOS-only built-in; Windows and Linux use `--source command` with a
+  per-OS recipe (Linux `pass`/`secret-tool`, Windows `powershell`/`op read`;
+  `security` is the macOS recipe — see README's per-OS table). `unsnooze hosts test <name>` pre-flights a host without
+  ever printing its secret. Auth-gapped hosts render as `needs-auth` in
+  `fleet`/the dashboard, distinct from `unreachable`. Security: the password
+  never touches argv, `ps`, or unsnooze's own environment — it flows through
+  OpenSSH's `SSH_ASKPASS` hook, helper-stdout → ssh, in-process; unsnooze
+  stores no plaintext itself; keys stay the unchanged, BatchMode-hardened
+  default.
+- **Fleet — sessions on every machine, over your own SSH**: `unsnooze hosts
+  [add|rm|list]` registers ssh destinations; `unsnooze fleet [--json]` and
+  the dashboard's new **Fleet** tab fan out to every host in parallel and
+  show each one's tracked sessions (state, reset countdown, attach hint),
+  with a bounded-concurrency ssh pool, per-host timeouts, and a 24h stale
+  cache so one dead box never blocks the rest. `unsnooze _remote` is the
+  single remote entrypoint (`status`/`resume`/`cancel`), safe to lock to an
+  `authorized_keys` forced command; `unsnooze status --json` and a shared
+  resume core back both the local and remote paths. Security posture: no
+  listening ports, no custom auth, no tokens — transport is plain OpenSSH
+  with host-key checking never weakened; the remote is always the one that
+  types, under its own gates; and every field a remote returns is
+  control-character-stripped, length-capped, and extracted into fresh
+  objects before it touches your terminal or state.
+- **Dashboard mouse support**: click tabs and session rows, wheel-scroll the
+  status/sessions lists and a real scrollback window in Logs, clickable
+  footer hints (refresh / help / quit). Full keyboard parity kept; `m` (or
+  `mouse` config / `UNSNOOZE_MOUSE`) toggles it live so terminal text
+  selection is one keypress away. Tracking modes are always cleared on exit,
+  crash, and Ctrl-Z — no hijacked mouse after quit.
+
+## 1.13.0 — 2026-07-17
+
+- **`unsnooze usage` — know the wall before you hit it**: burn-rate &
+  time-to-limit forecast per agent × window. Every figure carries its
+  provenance — `(exact)` from Codex rollouts or the opt-in Claude statusline
+  shim, `(calibrated from N stops)` learned from unsnooze's own recorded
+  limit stops, or `(estimated)` while calibrating. Weighted token burn
+  (cache reads ×0.1) over active minutes, account-wide including subagent
+  transcripts, per Opus/Sonnet bucket on Max plans. ETA shown as a band,
+  cross-checked against the observed reset time — never a false-precision
+  minute, never a blind now+5h.
+- **Pre-wall warnings from the daemon**: hybrid thresholds (80/95% and
+  ≤30/≤10 min to the wall at current pace), deduped per window instance,
+  with a `/compact now` nudge sized from the same context estimator as
+  `unsnooze status`. Notify-only — unsnooze still never types anything you
+  didn't configure.
+- **`unsnooze usage --install-statusline`**: opt-in shim that persists
+  Claude's exact server-side percentages; chains your existing statusline
+  command (backed up once, restored on uninstall).
+- **Live dashboard**: `unsnooze dashboard` (also `status`/`usage` on an
+  interactive TTY) — full-screen Ink TUI with Status, Usage, Sessions,
+  Doctor and Logs tabs, animated ❯ z z z brand mark, help overlay (`?`),
+  and a compact layout down to 80×24. Pipes and `--json` stay plain.
+- **Fix**: undated limit banners crossing midnight ("resets 12:04am" seen
+  at 9pm) parsed as already-past and were dropped or resumed due-now into a
+  still-live limit; they now roll to tomorrow when the announced time is
+  within a window's reach, while genuinely stale banners still resolve
+  due-now.
+- Codex windows are labeled from `window_minutes` everywhere (300 → 5h,
+  10080 → weekly, 43200 → 30d on the go plan) — stop records no longer
+  conflate the monthly window with the weekly bucket.
+
 ## 1.12.2 — 2026-07-16
 
 - **Daemon autostart self-heal**: updating via npm never touches the

package/README.md

@@ -9,6 +9,8 @@
 [![node](https://img.shields.io/badge/node-%E2%89%A5%2020-3fb950)](package.json)
 [![license](https://img.shields.io/badge/license-MIT-8b949e)](LICENSE)
 
+**[unsnooze.combustortech.in](https://unsnooze.combustortech.in)** — docs · changelog · feedback
+
 **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
@@ -68,6 +70,22 @@ your agent handles permissions.
 - **Reversible install.** The settings hook and rc-file wrappers are backed up
   first (`*.unsnooze-orig` pristine + `*.unsnooze-bak` rolling); `unsnooze
   uninstall` removes every change. Releases are published with npm provenance.
+- **Fleet adds no network surface.** No listening ports, no custom auth, no
+  tokens. Transport is your own OpenSSH (`~/.ssh/config`, keys, agent);
+  unsnooze never sets `StrictHostKeyChecking=no` and fails fast on unknown
+  hosts instead of auto-trusting them.
+- **The remote is the authority.** Fleet resume only marks a session due —
+  the remote daemon types under its own gates (foreground, idle, your
+  configured message only). A compromised viewer cannot make a remote type
+  anything else.
+- **Remote output is untrusted.** Everything a host returns is
+  control-character-stripped and length-capped before it touches your
+  terminal (ANSI-injection defense), and parsed fields are extracted —
+  never merged — into fresh objects.
+- **Lock a key to unsnooze (optional, recommended for automation):**
+  `command="unsnooze _remote",restrict ssh-ed25519 AAAA… unsnooze-fleet`
+  in the remote `authorized_keys` confines that key to the fleet
+  entrypoint — it can never open a shell.
 
 **Honest limits:** unsnooze *does* inject keystrokes into your live terminal on
 your behalf, and it does not sandbox your agent or defend against prompt
@@ -196,34 +214,276 @@ StopFailure hook (claude, grok) ──────────────┤
 </details>
 
 Limit events are never persisted by the CLIs themselves; the reset time is
-parsed from the banner text, DST-safe, with a 5-hour fallback when unparseable
-— and every resume is verified afterwards (banner came back → reschedule from
-the fresh banner, capped at 5 attempts).
+parsed from the banner text, DST-safe. Unparseable banners are never guessed
+at — unsnooze probes the pane on a backoff schedule until a real reset time
+appears. Every resume is verified afterwards (banner came back → reschedule
+from the fresh banner, capped at 5 attempts).
+
+## Know the wall before you hit it
+
+Recovery (auto-resume) is only half the job. **Prevention** is knowing when the
+wall is coming — so you can `/compact`, pause, or switch models *before* a stop.
+
+```sh
+unsnooze usage                         # burn rate, % used, time-to-limit
+unsnooze usage --json                  # stable machine shape (exit 2 past warn %)
+unsnooze usage --install-statusline    # opt-in: exact Claude % via statusline
+unsnooze usage --uninstall-statusline  # remove the shim, restore your statusLine
+```
+
+```text
+$ unsnooze usage
+unsnooze usage — account burn & time-to-limit  (daemon: running · warnings at 80,95%)
+
+  claude  5h      [█████████████░░░░░░░]  ~64%  (calibrated from 4 stops)
+          burn    ~31k weighted tok/min over last 42 active min
+          wall    ~1h 10m at this pace · window resets 8:00 pm (absolute)
+
+  codex   5h      [███░░░░░░░░░░░░░░░░░]  5% used  (exact)
+          monthly [██░░░░░░░░░░░░░░░░░░]  5% used  (exact) · resets Aug 11
+          burn    idle — no active burn
+
+  Estimates are a lower bound: Claude quotas are account-pooled with claude.ai/Desktop.
+  Exact Claude percentages available via: unsnooze usage --install-statusline
+```
+
+| What you get | How |
+|---|---|
+| **Honest labels** | Every figure is tagged `(exact)`, `(calibrated from N stops)`, or `(estimated — calibrating…)`. Never a bare %. |
+| **Account-wide burn** | Sums all active sessions **and** subagents (the limit is per-account, not per-pane). Idle gaps >5 min are excluded so a quiet hour doesn't hide a fast burn. |
+| **Time-to-wall** | ETA as a band (not a false-precision minute), cross-checked against known reset times. Weekly shown info-only — no unstable weekly ETA. |
+| **Pre-wall warnings** | Daemon notifies at `%` bands (`usageWarnAt`, default `80,95`) **and** time tiers (30 / 10 min). Deduped once per window. |
+| **`/compact` nudge only** | Warnings may *suggest* `/compact` so the eventual wake is cheap. unsnooze **never auto-types it** (same security rule as resume: types only your configured message). |
+
+**Provenance ladder** (why this isn't another guessed-quota dashboard):
+
+1. **`(exact)`** — Codex always (local `used_percent` + epoch reset). Claude only with the opt-in statusline shim (server-authoritative `rate_limits` from [Claude Code's statusline JSON](https://code.claude.com/docs/en/statusline)).
+2. **`(calibrated from N stops)`** — Claude token burn vs a ceiling learned from **your** limit-stop ledger (the same stops unsnooze already records for resume). Not plan presets, not circular P90-of-history.
+3. **`(estimated)`** — used tokens + burn shown; ceiling unknown until the first observed stop.
+
+**Honest limits:** Claude transcript sums are a **lower bound** — subscription quotas are account-pooled with claude.ai and the Desktop app. Without the statusline shim, Claude tops out at calibrated/estimated. Exact Claude % needs Pro/Max after the first API response of a session (absent after `/clear` and on API auth).
 
 ## Usage
 
+On an interactive TTY, `status` / `usage` / `sessions` open a **live dashboard**
+(`unsnooze dashboard`) with the brand logo (`❯` + rising `zzz`), tabs, live
+refresh until you press **`q`** — and mouse support: click tabs and rows,
+wheel to scroll (toggle with `m`; hold Shift — Option in iTerm2 — to select text). Pipes, `NO_COLOR`, `CI`, and `--json` stay plain.
+
+```sh
+claude / codex / grok                  # normal usage — wrapped automatically
+unsnooze status                        # tracked sessions + reset countdowns
+unsnooze dashboard [tab]               # live TUI (status|usage|sessions|doctor|logs|fleet|prompts)
+unsnooze usage [--json]                # account burn & time-to-limit forecast
+unsnooze usage --install-statusline    # opt-in exact Claude % (chains your statusLine)
+unsnooze resume-now [id|--all]         # don't wait for the reset time
+unsnooze cancel [id|--all]             # stop tracking a session
+unsnooze message <id> "text"           # per-session wake message (--clear to reset)
+unsnooze preview [id]                  # dry-run: what WOULD happen right now, and why —
+                                       # nothing is typed or opened
+unsnooze sessions                      # list unsnooze-owned mux sessions + panes
+unsnooze reap [--dry-run|--yes]        # close finished panes / empty sessions (default dry-run)
+unsnooze doctor [--fix]                # install health check + retire old csg leftovers
+unsnooze prompt add [--agent id] [--project path] [--at time|--now] "text"
+                                       # queue a prompt for a NEW session (see Queued prompts)
+unsnooze prompt list [--json]          # list queued prompts
+unsnooze prompt remove <id>            # cancel a queued prompt
+unsnooze prompt clear                  # cancel all pending queued prompts
+unsnooze config list                   # settings (see below)
+unsnooze config set <k> <v>            # e.g. autoResume off
+unsnooze logs [-f]                     # what unsnooze has been doing
+unsnooze update                        # update unsnooze itself
+unsnooze daemon                        # persistent GUI-session watcher (usually run
+                                       # by launchd/systemd via `install --daemon`)
+unsnooze report [agent]                # capture a pane to report an undetected banner
+unsnooze uninstall [--purge]           # remove wrappers + hooks (+ state with --purge)
+unsnooze help                          # full command list (also -h / --help)
+```
+
+## Queued prompts
+
+Queue a prompt now; unsnooze types it into a **brand-new** agent session — a
+fresh window in a project directory — once a usage limit clears (or at a time
+you choose). It's one-shot: each entry is delivered at most once.
+
 ```sh
-claude / codex / grok           # normal usage — wrapped automatically
-unsnooze status                 # tracked sessions + reset countdowns
-unsnooze resume-now [id|--all]  # don't wait for the reset time
-unsnooze cancel [id|--all]      # stop tracking a session
-unsnooze message <id> "text"    # per-session wake message (--clear to reset)
-unsnooze preview [id]           # dry-run: what WOULD happen right now, and why —
-                                # nothing is typed or opened
-unsnooze sessions               # list unsnooze-owned mux sessions + panes
-unsnooze reap [--dry-run|--yes] # close finished panes / empty sessions (default dry-run)
-unsnooze doctor [--fix]         # install health check + retire old csg leftovers
-unsnooze config list            # settings (see below)
-unsnooze config set <k> <v>     # e.g. autoResume off
-unsnooze logs [-f]              # what unsnooze has been doing
-unsnooze update                 # update unsnooze itself
-unsnooze daemon                 # persistent GUI-session watcher (usually run
-                                # by launchd/systemd via `install --daemon`)
-unsnooze report [agent]         # capture a pane to report an undetected banner
-unsnooze uninstall [--purge]    # remove wrappers + hooks (+ state with --purge)
-unsnooze help                   # full command list (also -h / --help)
+unsnooze prompt add "run the full test suite and fix any failures"
+# → interactive agent picker on a TTY; queued for next-reset in the cwd
+
+unsnooze prompt add --agent codex --project ~/code/api --now "ship the release"
+unsnooze prompt add --at "+2h30m" "rebase onto main"   # relative duration
+unsnooze prompt add --at "9pm" "nightly cleanup pass"  # next occurrence of a clock time
+unsnooze prompt add --at 1755000000 "..."              # epoch (seconds or ms), or an ISO-8601 timestamp
+
+unsnooze prompt list [--json]   # id, agent, due, status, cwd, prompt preview
+unsnooze prompt remove <id>     # cancel one pending/launching entry
+unsnooze prompt clear           # cancel every pending/launching entry
 ```
 
+Modes:
+
+- **next-reset** (default) — delivered once no future reset time is known for
+  that agent, i.e. once the current limit clears. If unsnooze holds **no
+  reset signal at all** for that agent when you add the entry, there's
+  nothing to wait on — it delivers on the very next daemon tick, and
+  `prompt add` prints a notice to that effect right away. Use `--at` if you
+  want a specific time instead.
+- `--now` — deliver on the next daemon tick, no reset wait at all.
+- `--at <time>` — deliver at a specific time: epoch (seconds or
+  milliseconds), an ISO-8601 timestamp, a `+2h30m`-style relative duration,
+  or a bare clock time (`9pm`, `2:05pm`, `14:30`) rolled to its next local
+  occurrence.
+
+If a delivery attempt lands on a pane that's still limited — the reset
+hadn't actually cleared, or a fresh `--now`/`--at` session hits the wall
+immediately — the entry goes back to pending behind a backoff floor before
+it's retried. That floor applies to every mode, so a failing `--now`/`--at`
+entry can't burn through every retry in the first few seconds the way an
+unthrottled retry loop would. Verified delivery (capped at 5 attempts,
+same as resume) marks it `failed` and sends a notification.
+
+`autoResume` does **not** gate prompt delivery — the queue runs independently
+of session tracking, even with `autoResume off`.
+
+A far-future `--at` entry is expected to keep a transient resumer process
+alive (checking in each tick) until its delivery time arrives, however long
+that is — this is intended, not a leak.
+
+**Fleet:** `--host <name>` queues on a registered host instead of locally.
+`--project` (an absolute remote path) and `--agent` are both required — there's
+no local cwd to default to and no interactive picker over an ssh round-trip.
+The remote host re-validates everything server-side. Delivery feedback comes
+from `unsnooze fleet` / the dashboard's Fleet tab (per-host queued count) and
+that host's own notifications (ntfy reaches your phone from any host, not
+just the one you're sitting at). A host can refuse all queue traffic with
+`remoteQueue: false` (`unsnooze config set remoteQueue off`, env
+`UNSNOOZE_REMOTE_QUEUE=0`, **set on the host being controlled**) — the queue
+verbs then answer a typed "disabled" instead of silently dropping; a remote
+that predates this feature reports a clear "too old" error instead of
+failing silently.
+
+```sh
+unsnooze prompt add --host gpu-box --project /home/me/repo --agent claude --now "..."
+unsnooze prompt list --host gpu-box
+```
+
+**Dashboard:** the **Prompts** tab (`7`) lists queued entries; `a` opens an
+add form (path → agent → when — with a time prompt if you pick "at" — → a
+host step if you have hosts registered → prompt text), `d`/`x` removes the
+selected entry. The Status tab shows a `<n> prompt(s) queued — tab 7` hint
+whenever entries are pending or launching.
+
+## Fleet: sessions on every machine
+
+See and act on unsnooze sessions on other machines from one terminal — over
+your own SSH, no new service to run.
+
+```sh
+unsnooze hosts add work you@work-box.local   # register an ssh destination
+unsnooze hosts list                          # registered hosts
+unsnooze hosts rm work                       # forget a host
+unsnooze fleet [--json]                      # every host's sessions, fanned out over ssh
+unsnooze dashboard fleet                     # live Fleet tab — R resumes a selected stopped session (C cancels)
+```
+
+A registered host needs **unsnooze installed** and **ssh key auth** (no
+passwords) — nothing new to open or configure; fleet rides your existing
+`~/.ssh/config`, keys, and agent. **Before adding a host, connect to it the
+normal way once** (`ssh <host>`) so OpenSSH pins the host key itself —
+unsnooze never weakens host-key checking to skip that step, so an unknown or
+changed host fails fast instead of being silently trusted.
+
+Fleet is *see and mark*, not *type remotely*: `unsnooze fleet` and the
+dashboard's **Fleet** tab list every reachable host's tracked sessions
+(state, reset countdown, attach hint). Selecting a stopped remote session and
+pressing **`R`** (uppercase — lowercase `r` refreshes) only marks it due — the
+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
+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.
+
+### Auth: keys (default) or password
+
+Every host picks its own auth, per host — unsnooze imposes no policy:
+
+- **`key`** (default, unchanged) — the BatchMode-hardened path above. Nothing
+  about a key host changes.
+- **`password`, interactive** (`--source prompt`, the default source when you
+  pass `--auth password` with nothing else) — typed at run time, no-echo, on
+  whichever terminal is running `unsnooze fleet`/`hosts test`. Nothing is
+  stored. There's no terminal under the background daemon, so a `prompt`
+  host is naturally interactive-only — it shows `needs-auth` when the daemon
+  or a piped/non-TTY caller tries it.
+- **`password`, stored** (`--source env|keychain|command`) — resolved
+  automatically, so the daemon and `unsnooze fleet` can reach it unattended.
+
+```sh
+unsnooze hosts add <name> <dest>
+    [--auth key|password]                  # default: key
+    [--source prompt|env|keychain|command] # default: prompt, once --auth password is set
+    [--env <VARNAME>]                      # env source: var to read (default UNSNOOZE_PW_<NAME>)
+    [--service <s> --account <a>]          # keychain source (macOS only)
+    [--cmd '<command>']                    # command source: program whose stdout is the password
+unsnooze hosts test <name>                 # pre-flight: resolves the source (never prints the
+                                            #   secret) then a real ssh reachability probe
+```
+
+Examples:
+
+```sh
+unsnooze hosts add laptop me@laptop.local --auth password
+# → prompts for a password every time it's used from a real terminal
+
+unsnooze hosts add gpu ubuntu@gpu.example.com --auth password --source env --env UNSNOOZE_PW_GPU
+# → export UNSNOOZE_PW_GPU=... in your shell/session first
+
+unsnooze hosts add mac me@mac-mini.local --auth password --source keychain --service unsnooze-mac --account me
+# → macOS only; reads via `security find-generic-password`
+
+unsnooze hosts add ci ci@build.example.com --auth password --source command --cmd 'op read op://vault/ci/password'
+# → any OS; runs your own secret manager and reads its stdout
+
+unsnooze hosts test gpu   # resolves the credential + probes reachability; prints "auth ok" or a hint, never the secret
+```
+
+**`command` is the portable, first-class source** — plug in whatever secret
+manager you already run. Per-OS one-liners for `--cmd`:
+
+| OS | Example `--cmd` |
+|---|---|
+| macOS | `security find-generic-password -s <service> -a <account> -w` |
+| Linux | `pass show <path>` &nbsp;or&nbsp; `secret-tool lookup <attr> <value> ...` |
+| Windows | `powershell -Command "..."` (e.g. wrapping `Get-StoredCredential`) &nbsp;or&nbsp; `op read op://vault/item/password` |
+| any OS | `op read op://vault/item/password` (1Password CLI), or any other manager's read command |
+
+`keychain` is a convenience built-in for **macOS only** (`security
+find-generic-password`) — there's no dependable dependency-free store to
+shell out to on Windows or Linux, so those use `--source command` with the
+recipes above instead.
+
+**Security posture:** the password reaches `ssh` through OpenSSH's own
+`SSH_ASKPASS` hook — it never appears on `argv`, in `ps`, or in unsnooze's
+own environment; it flows helper-stdout → ssh, in-process, for that one ssh
+child only. unsnooze itself **stores no plaintext**: `keychain`/`command`
+delegate entirely to the OS store or your own manager, and `env` is
+user-managed (readable by your own shell already — positioned as a
+low-friction/CI convenience, not secret-manager-grade). Keys remain the
+default and their BatchMode-hardened path is untouched by any of this.
+
+**Windows note:** native `ssh.exe` (Windows' built-in OpenSSH client) prompts
+fine out of the box for an **interactive** `prompt`-source host — no shim
+needed, it's the zero-friction path. **Stored** sources (`env`/`keychain`/
+`command`) need a non-interactive askpass helper, and native `ssh.exe`
+requires that to be a real launchable `.exe` — it won't reliably run a `.js`
+or npm's `.cmd` shim. Until unsnooze ships that native launcher, use a
+**Git-for-Windows or WSL `ssh`** (both accept the script-based helper the
+same way macOS/Linux do — common on dev machines already) for stored
+password hosts on Windows; a plain `ssh <host>` prompt works with native
+`ssh.exe` regardless.
+
 ## Settings
 
 `unsnooze setup` writes `~/.unsnooze/config.json`; change anything later with
@@ -244,6 +504,9 @@ unsnooze help                   # full command list (also -h / --help)
 | `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. |
+| `usageWarn` | `notify` | Pre-wall usage warnings from the daemon (`unsnooze usage`): `notify` or `off`. Needs `notifications` on and the daemon running. Env: `UNSNOOZE_USAGE_WARN`. |
+| `usageWarnAt` | `80,95` | Percent thresholds for usage warnings (comma-separated). Non-numeric values fall back to the default — never silently disable. Time tiers (30 / 10 min) are constants, not config keys. Env: `UNSNOOZE_USAGE_WARN_AT`. |
+| `mouse` | `true` | Mouse support in `unsnooze dashboard`: click tabs and session rows, wheel-scroll lists/logs, clickable footer hints. Toggle live with `m`. Hold Shift (Option in iTerm2) to select text while it's on. Env: `UNSNOOZE_MOUSE`. |
 | `reapResumed` | `false` | Opt-in: auto-close `resumed` panes idle longer than `reapIdleAfter`. Off by default — use `unsnooze reap --yes` for explicit cleanup. |
 | `reapIdleAfter` | `604800000` (7d) | Idle age (ms) before an opt-in auto-reap closes a `resumed` pane. |
 | `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. |
@@ -251,6 +514,7 @@ unsnooze help                   # full command list (also -h / --help)
 | `ntfyServer` | `https://ntfy.sh` | ntfy server base URL (self-hosted servers welcome). |
 | `ntfyToken` | `""` | Optional `tk_…` access token (`Authorization: Bearer`) for reserved topics / authed servers. |
 | `ntfyPrivacy` | `full` | `terse` keeps directory paths out of pushed bodies (titles only) — recommended on public ntfy.sh topics. |
+| `remoteQueue` | `true` | Set **on the host being controlled**: may other hosts queue prompts on this one (`unsnooze prompt add --host <this>`)? Off = the queue verbs answer a typed `disabled` instead of silently dropping. Env: `UNSNOOZE_REMOTE_QUEUE`. |
 
 Every setting also has a `UNSNOOZE_*` env override (see `src/settings.js`), and
 all timings/paths are tunable via `UNSNOOZE_*` env vars (see `src/config.js`).

package/bin/unsnooze.js

@@ -48,12 +48,12 @@ 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', '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', 'help', '-h', '--help', '--help-unsnooze']);
 
 // Every named subcommand; anything else (or no args) is an agent launch.
 const NAMED_COMMANDS = new Set([
   ...USER_FACING, 'setup', 'install', 'uninstall', 'update', 'daemon',
-  '_hook-stopfailure', '_monitor', '_run', '_resumer', '_update-check',
+  '_hook-stopfailure', '_monitor', '_run', '_resumer', '_update-check', '_remote', '_askpass',
 ]);
 const isLaunchPath = cmd === '_run' || cmd === undefined || !NAMED_COMMANDS.has(cmd);
 const launchArgs = cmd === '_run' ? rest.slice(1) : (cmd === undefined ? [] : [cmd, ...rest]);
@@ -100,7 +100,7 @@ async function main() {
   switch (cmd) {
     case 'status': {
       const { cmdStatus } = await import('../src/cli.js');
-      return cmdStatus();
+      return cmdStatus(rest);
     }
     case 'resume-now': {
       const { cmdResumeNow } = await import('../src/cli.js');
@@ -146,6 +146,26 @@ async function main() {
       const { cmdPreview } = await import('../src/cli.js');
       return cmdPreview(rest);
     }
+    case 'dashboard': {
+      const { cmdDashboard } = await import('../src/dashboard/run.js');
+      return cmdDashboard(rest);
+    }
+    case 'usage': {
+      const { cmdUsage } = await import('../src/usage.js');
+      return cmdUsage(rest);
+    }
+    case 'hosts': {
+      const { cmdHosts } = await import('../src/fleet.js');
+      return cmdHosts(rest);
+    }
+    case 'fleet': {
+      const { cmdFleet } = await import('../src/fleet.js');
+      return cmdFleet(rest);
+    }
+    case 'prompt': {
+      const { cmdPrompt } = await import('../src/prompt.js');
+      return cmdPrompt(rest);
+    }
     case 'install': {
       const { cmdInstall } = await import('../src/install.js');
       return cmdInstall(rest);
@@ -176,6 +196,16 @@ async function main() {
       if (!mod) return 0;
       return mod.runResumer();
     }
+    case '_remote': {
+      const mod = await safeImport('../src/remote.js');
+      if (!mod) return 1;
+      return mod.cmdRemote(rest);
+    }
+    case '_askpass': {
+      const mod = await safeImport('../src/askpass.js');
+      if (!mod) return 1;
+      return mod.cmdAskpass(rest);
+    }
     case 'update': {
       const { runSelfUpdate } = await import('../src/update-check.js');
       return runSelfUpdate();
@@ -263,6 +293,25 @@ Usage:
   unsnooze preview [id]            dry-run: what WOULD happen right now, and
                                    why — nothing is typed or opened (exit 2
                                    when a wake is actionable, else 0)
+  unsnooze dashboard [tab]         live TUI (status|usage|sessions|doctor|logs|fleet|prompts) — q to quit,
+                                   mouse: click/wheel (m toggles)
+  unsnooze hosts [add|rm|list]     register ssh hosts for the fleet view
+                                   add <name> <dest> [--auth key|password]
+                                     [--source prompt|env|keychain|command]
+                                     [--env VAR] [--service s --account a]
+                                     [--cmd '<command>']
+  unsnooze hosts test <name>       pre-flight a host: resolves its credential
+                                   and probes reachability (secret never shown)
+  unsnooze fleet [--json]          all hosts' sessions (hosts add <name> first)
+  unsnooze prompt add [text...]    queue a prompt to start a NEW session in a
+                                   project when the limit resets ([--agent id]
+                                   [--project path] [--at time|--now])
+  unsnooze prompt list [--json]    list queued prompts
+  unsnooze prompt remove <id>      cancel a queued prompt
+  unsnooze prompt clear            cancel all pending queued prompts
+  unsnooze usage [--json]          account burn rate & time-to-limit forecast
+                                   (--install-statusline for exact Claude %,
+                                    --uninstall-statusline to remove it)
   unsnooze logs [-f]               show (or follow) the unsnooze log
   unsnooze update                  update unsnooze itself to the latest version
   unsnooze daemon                  persistent watcher for GUI sessions (VS Code

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "unsnooze",
-  "version": "1.12.2",
-  "description": "Auto-resume Claude Code, Codex CLI, Grok, Qwen Code, Kimi CLI, OpenCode & Antigravity when the 5-hour/weekly usage limit resets — tmux, Zellij, VS Code & desktop apps. Wakes every limit-stopped AI coding session automatically.",
+  "version": "1.14.0",
+  "description": "Auto-resume Claude Code, Codex CLI, Grok, Qwen Code, Kimi CLI, OpenCode & Antigravity when the 5-hour/weekly usage limit resets \u2014 tmux, Zellij, VS Code & desktop apps. Wakes every limit-stopped AI coding session automatically.",
   "keywords": [
     "claude",
     "claude-code",
@@ -49,7 +49,7 @@
   "bugs": {
     "url": "https://github.com/saaranshM/unsnooze/issues"
   },
-  "homepage": "https://github.com/saaranshM/unsnooze#readme",
+  "homepage": "https://unsnooze.combustortech.in",
   "type": "module",
   "bin": {
     "unsnooze": "bin/unsnooze.js"
@@ -68,6 +68,9 @@
     "node": ">=20"
   },
   "dependencies": {
-    "@clack/prompts": "^1.7.0"
+    "@clack/prompts": "^1.7.0",
+    "ink": "^7.1.1",
+    "picocolors": "^1.1.1",
+    "react": "^19.2.7"
   }
 }

package/src/agents/agy.js

@@ -93,6 +93,8 @@ export default {
   resumeArgs(sessionId) {
     return { args: sessionId ? [`--conversation=${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,
   isForegroundCommand(cmd) {
     return cmd === 'agy' || cmd === 'node' || cmd === 'unsnooze';

package/src/agents/claude.js

@@ -92,6 +92,8 @@ export default {
   resumeArgs(sessionId) {
     return { args: sessionId ? ['--resume', sessionId] : ['-c'], messageViaPane: true };
   },
+  // v1: every agent launches the bare TUI and gets the prompt typed once idle.
+  launchArgs(message) { return { args: [], messageViaPane: true }; },
   latestSessionId,
   // Estimated tokens the API re-reads on a cold wake (prompt cache long
   // expired). null → unknown, contextGuard skips. Adapters without this

package/src/agents/codex.js

@@ -123,6 +123,8 @@ export default {
       messageViaPane: false,
     };
   },
+  // v1: every agent launches the bare TUI and gets the prompt typed once idle.
+  launchArgs(message) { return { args: [], messageViaPane: true }; },
   latestSessionId,
   isForegroundCommand(cmd) {
     return cmd === 'codex' || cmd === 'node' || cmd === 'unsnooze';

package/src/agents/grok.js

@@ -87,6 +87,8 @@ export default {
   resumeArgs(sessionId) {
     return { args: sessionId ? ['--resume', sessionId] : ['-c'], messageViaPane: true };
   },
+  // v1: every agent launches the bare TUI and gets the prompt typed once idle.
+  launchArgs(message) { return { args: [], messageViaPane: true }; },
   // Session file format is undocumented; null keeps it conservative — the
   // reopen path then uses `grok -c`, which Grok itself scopes to the cwd.
   latestSessionId() {

package/src/agents/index.js

@@ -11,8 +11,14 @@ import agy from './agy.js';
 
 const REGISTRY = { claude, codex, grok, qwen, kimi, opencode, agy };
 
+// v1: every agent launches the bare TUI and gets the prompt typed once idle.
+function defaultLaunchArgs(message) { return { args: [], messageViaPane: true }; }
+
 export function getAgent(id) {
-  return REGISTRY[id] || claude;
+  const agent = REGISTRY[id] || claude;
+  // Third-party/partial adapters may lack launchArgs — synthesize the same
+  // default so callers (dispatch, tests) never have to null-check it.
+  return typeof agent.launchArgs === 'function' ? agent : { ...agent, launchArgs: defaultLaunchArgs };
 }
 
 export function listAgents() {

package/src/agents/kimi.js

@@ -111,6 +111,8 @@ export default {
       messageViaPane: false,
     };
   },
+  // v1: every agent launches the bare TUI and gets the prompt typed once idle.
+  launchArgs(message) { return { args: [], messageViaPane: true }; },
   latestSessionId,
   isForegroundCommand(cmd) {
     // /i: macOS framework builds report "Python" (verified via tmux

package/src/agents/opencode.js

@@ -96,6 +96,8 @@ export default {
   resumeArgs(sessionId) {
     return { args: sessionId ? ['-s', 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,
   isForegroundCommand(cmd) {
     // The npm-shipped bun binary reports pane_current_command "opencode.exe"