Skip to content
Back to search

windstorm-tardigrade

MarketplaceWorks with Claude CodeGitHub

Windstorm Tardigrade, a Claude Code plugin by The Windstorm.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/thewindstorm--windstorm-tardigrade/badge.svg)](/listings/thewindstorm--windstorm-tardigrade)

HTML

<a href="/listings/thewindstorm--windstorm-tardigrade"><img src="/api/listings/thewindstorm--windstorm-tardigrade/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

You need Linux or macOS, Python 3, and [tmux](https://github.com/tmux/tmux/wiki) (`apt install tmux`, `dnf install tmux` or `brew install tmux`).

claude plugin marketplace add TheWindstorm/windstorm-tardigrade
claude plugin install windstorm-tardigrade@windstorm-tardigrade

Then start Claude Code and say: **set up tardigrade**.

Without the plugin system, it is one file:

git clone https://github.com/TheWindstorm/windstorm-tardigrade
python3 -I windstorm-tardigrade/scripts/tardigrade.py setup

Setup copies that one file to `~/.local/share/windstorm-tardigrade/`, installs a boot service and a 5-minute timer for your user (systemd on Linux, launchd on macOS), and writes down the sessions that are running now. It needs no administrator rights and it tells you who has to log in after a restart (see below). Run setup again after you update the plugin.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 15 lines
  1. {
  2. "name": "windstorm-tardigrade",
  3. "description": "Windstorm Tardigrade, a Claude Code plugin by The Windstorm.",
  4. "owner": {
  5. "name": "The Windstorm",
  6. "url": "https://github.com/TheWindstorm"
  7. },
  8. "plugins": [
  9. {
  10. "name": "windstorm-tardigrade",
  11. "source": "./",
  12. "description": "Windstorm Tardigrade: Claude Code sessions come back after a reboot or crash, as themselves, and one command lists what is running, hidden or down."
  13. }
  14. ]
  15. }
README.md · README · 277 lines
  1. # Windstorm Tardigrade
  2. **Your Claude Code sessions come back after a reboot, as themselves. And one command tells you what is running.**
  3. A tardigrade is a tiny animal that dries out, stops, and carries on when the water returns. This plugin is
  4. modeled on it. When your machine restarts, crashes or loses power, every Claude Code session you had running comes
  5. back by itself: the same conversation, the same name, the same folder, the same model and permission mode. Each one
  6. is told what happened, so it can pick up where it left off.
  7. It also answers a question that gets harder the more sessions you run: *what is still running?* Close a terminal
  8. window and the session inside it can keep going for weeks. `census` lists every session, and marks the ones that run
  9. with no window open.
  10. > **Status: 0.1.7, a pilot.** It has been through ten real reboots on two machines (a Linux laptop and a Mac),
  11. > two of them with no clean shutdown, and then a real reboot of a machine with 98 sessions. The first reboots on
  12. > this version found faults, which is what they were for; after the fixes every session came back every time,
  13. > all 98 included. That last reboot also showed what is still wrong: it took 25 minutes and told nobody what it
  14. > was doing. See [Tested](#tested) for what is proven, and [PROMISES.json](PROMISES.json) for what it now owes.
  15. ## Install
  16. You need Linux or macOS, Python 3, and [tmux](https://github.com/tmux/tmux/wiki) (`apt install tmux`,
  17. `dnf install tmux` or `brew install tmux`).
  18. ```bash
  19. claude plugin marketplace add TheWindstorm/windstorm-tardigrade
  20. claude plugin install windstorm-tardigrade@windstorm-tardigrade
  21. ```
  22. Then start Claude Code and say: **set up tardigrade**.
  23. Without the plugin system, it is one file:
  24. ```bash
  25. git clone https://github.com/TheWindstorm/windstorm-tardigrade
  26. python3 -I windstorm-tardigrade/scripts/tardigrade.py setup
  27. ```
  28. Setup copies that one file to `~/.local/share/windstorm-tardigrade/`, installs a boot service and a 5-minute
  29. timer for your user (systemd on Linux, launchd on macOS), and writes down the sessions that are running now. It needs
  30. no administrator rights and it tells you who has to log in after a restart (see below). Run setup again after you
  31. update the plugin.
  32. ## What you get
  33. | You say or type | What happens |
  34. |---|---|
  35. | `tardigrade setup` | Switches it on. From then on, sessions come back after a restart by themselves. |
  36. | `tardigrade census` | Lists every session: running with a window, running with **no window open**, and down. |
  37. | `tardigrade open` | Opens a terminal window for each hidden session. |
  38. | `tardigrade revive` | Brings back, now, every recorded session that is not running. `--dry-run` shows the list first. |
  39. | `tardigrade revive --only "Name"` | Brings back just that one. |
  40. | `tardigrade revive --dry-run --all` | Before a planned reboot: shows the exact line that would start each recorded session, and starts nothing. |
  41. | `tardigrade trust on` | Opt-in: after a restart, answer Claude Code's "trust this folder?" for a session's own folder. `trust off` undoes it. Off unless you switch it on. |
  42. | `tardigrade uninstall` | Switches it off. Running sessions and your record are not touched. |
  43. In Claude Code you can say these in plain words. In a terminal, each is
  44. `python3 -I ~/.local/share/windstorm-tardigrade/tardigrade.py <command>`.
  45. ### The census
  46. An example, with made-up names:
  47. ```
  48. Windstorm Tardigrade census, 2026-11-21 15:02 EST (machine up 35 days)
  49. Running: 5 with a window: 3 hidden (no window open): 2 down: 1
  50. Comes back after a reboot: yes, by itself Last record: 3 min ago, 5 session(s)
  51. HIDDEN: running, but no window shows them
  52. Docs Rewrite idle quiet 9 days tmux default:docs /home/you/docs
  53. Invoice Bot busy quiet 40 s tmux default:invoices /home/you/invoices
  54. WITH A WINDOW
  55. Website idle quiet 12 min tmux default:website /home/you/site
  56. ...
  57. DOWN: on the record, not running now
  58. Data Import last seen 2 h ago /home/you/import
  59. ```
  60. "Quiet" is the time since the session last did anything. A hidden session that has been quiet for nine days is
  61. usually one you forgot.
  62. ## What comes back, and what does not
  63. **Comes back:** the conversation, the session's name, its folder, its model, effort and permission mode, and its
  64. tmux session under the same name.
  65. **Does not come back:** anything the session had running in the background: timers, watchers, background commands.
  66. Tardigrade cannot restart those. Instead it tells each revived session, in one message, that they are gone, so the
  67. session checks its notes and starts again what is still needed. The message is typed into the session once Claude
  68. Code reports it loaded and idle, and never into one that shows a question. It costs one turn per session. To bring
  69. sessions back silent instead, put `"wake": "idle"` in `~/.config/windstorm-tardigrade/config.json`.
  70. **A session nobody ever wrote in** has no conversation, so Claude Code cannot resume it. It comes back as a new
  71. session with the same name, folder and flags.
  72. **After a crash:** if more than half of your sessions vanish at the same moment (a tmux server that died, a
  73. terminal program closed with everything in it), Tardigrade does not take that for you ending them. They stay on
  74. the record for 12 hours, the census says so, and `tardigrade revive` brings them back.
  75. **The trust question:** Claude Code asks "do you trust this folder?" on every start of a session whose folder is
  76. your home folder. By default Tardigrade does not answer for you: the census marks such a session `trust?` until you
  77. open its window and answer. If you would rather have it answered, say `tardigrade trust on`. Then, for a session
  78. Tardigrade brings back, in the folder that session was already running in, it answers Yes. It answers no other
  79. question, and it writes each answer in its log. It counts only the dialog that is open at the foot of the screen:
  80. a conversation that merely quotes the question gets no key, and neither does a screen with a usage or limit
  81. dialog on it.
  82. **Where they come back:** inside tmux, so a session outlives its window. A session that was already in tmux returns
  83. to the same tmux session name. A session that ran in a plain terminal window returns in Tardigrade's own tmux
  84. (socket `tardigrade`) with no window, and `tardigrade open` shows it.
  85. ## Who has to log in after a restart
  86. Setup tells you this for your machine. It never changes it for you.
  87. - **Linux.** With *lingering* on for your user, sessions come back about a minute after boot with nobody logged in.
  88. With it off, they come back when you log in. To switch it on, a person runs once:
  89. `sudo loginctl enable-linger $USER`.
  90. - **macOS.** Sessions come back when you are logged in at the Mac's own screen. A login over ssh does not count,
  91. and neither does another user's login, even if the Mac logs that user in by itself. With FileVault on, a
  92. restarted Mac waits at its unlock screen and nothing runs until someone types the password there. The census
  93. says which of these your Mac is.
  94. ## Safety
  95. - **Never a second copy.** A session id that any live process of yours holds is never started. Two copies of one
  96. session would both act.
  97. - **A session comes back with the permission mode it had.** If it ran with permission checks switched off, it comes
  98. back that way, with nobody watching, and the opening message gives it one turn. You chose that mode when you
  99. started it; Tardigrade does not widen it. If you do not want sessions to act by themselves after a restart, use
  100. `"wake": "idle"`.
  101. - It never ends a session and never answers a dialog for you. If a revived session stops at a question, it waits
  102. there for you. The one exception is yours to switch on: `trust on` (above). It is two keys, sent only when the
  103. screen shows the cursor on "Yes, I trust".
  104. - It types one thing of its own, the wake-up message, and only into a session it started itself that is loaded,
  105. idle and shows no question. `"wake": "idle"` switches that off.
  106. - **Nothing but the start command is on a command line.** A command line is visible to every `pkill -f WORD` on the
  107. machine, so the message is typed, and a session's settings are in a start file only you can read. Claude Code's
  108. own command line is what you would have typed: its flags and `--resume`.
  109. - **A permission mode comes back word for word.** It is never made looser.
  110. - It never stores a token or a key. For a login token it keeps the variable's name and an 8-digit one-way
  111. fingerprint, and uses it to check that a session came back on the same login. The check comes before anything
  112. is typed: a session whose login changed is listed as "needs you", with no message typed and nothing run on the
  113. wrong account. A variable whose name looks like a secret's is never recorded or copied, whatever the settings say.
  114. - On a shared machine it counts other users' Claude processes and reads nothing of theirs.
  115. - Python standard library only. No network. It prints names, folders and counts, never message text.
  116. - The record is never overwritten by a machine that is still starting, and never by an empty list.
  117. ## Settings
  118. `~/.config/windstorm-tardigrade/config.json`, all optional:
  119. | Key | Default | Meaning |
  120. |---|---|---|
  121. | `wake` | `"note"` | `"note"` tells each revived session what happened. `"idle"` says nothing. |
  122. | `stagger_s` | `3` | Seconds between two session starts. |
  123. | `boot_window_min` | `40` | The boot service acts only on a machine up for less than this. |
  124. | `retry_min` | `25` | How long failed starts are retried. The network can lag at boot. |
  125. | `shell` | your login shell | `bash` or `zsh`. Sessions start through it, so your own `claude` setup loads. |
  126. | `tmux_tmpdir` | | Set this if your shell sets `TMUX_TMPDIR`. |
  127. | `herdr_tabs` | `true` | With Herdr, re-attach each session's tab after a revive. |
  128. | `answer_trust` | `false` | Set by `trust on` / `trust off`. Answer "trust this folder?" for a revived session's own folder. |
  129. | `watch_min` | `15` | After a boot, keep looking at the started sessions this long: to type the message once each is idle, to answer the trust question if you switched that on, and to count which have loaded. A slow machine loads late. |
  130. | `load_max` | `0` | With a number here, each start waits (up to `load_wait_s`, default 120) while the machine's load is above it. |
  131. | `skip_tmux_sockets` | `[]` | tmux socket names to leave alone, for when another tool already brings those sessions back. One restorer per session. |
  132. The record is `~/.config/windstorm-tardigrade/lanes.json`. The log is
  133. `~/.local/state/windstorm-tardigrade/tardigrade.log`.
  134. ### Fitting it to a machine that has its own ways
  135. Most people need none of these. They are for machines where sessions are started through a wrapper, pinned to
  136. accounts, or shown in another tool.
  137. | Key | Default | Meaning |
  138. |---|---|---|
  139. | `claude_command` | `"claude"` | The command that starts Claude Code. The session's flags and `--resume <id>` are added to it. |
  140. | `account_env` | | The name of an environment variable that holds a session's account label, if your wrapper sets one. A label, never a secret. |
  141. | `account_command` | | Used in place of `claude_command` for a session that had a label, for example `"my-wrapper use {account}"`. |
  142. | `start_command` | | Your own whole start line, in place of the three above. Placeholders: `{session_id}` `{cwd}` `{name}` `{model}` `{effort}` `{mode}` `{account}` `{tmux_session}` and `{flags}` (the session's exact flags). Each is quoted for the shell. |
  143. | `env_file` | | A file of `NAME=value` lines (or NUL-separated, as `env -0` writes) added to each revived session's environment. For a desktop's display and session bus, which a boot service does not have. Names that look like a secret's are left out, and so are the variables that belong to the starting shell (its folder, user id, terminal). |
  144. | `tmux_conf` | | A tmux config file for a tmux server that Tardigrade has to start. |
  145. | `server_command` | | Your own command that starts the tmux server, run once when none is up, for a machine that starts its server a special way. `{socket}` is the socket path. `server_socket` names the one socket it is for. |
  146. | `carry_env` | `["CLAUDE_CODE_AUTO_COMPACT_WINDOW"]` | Settings variables a session keeps: the value it had is recorded and set again. |
  147. | `loose_socket` | `"tardigrade"` | The tmux socket name where sessions that were not in tmux come back. |
  148. | `loose_prefix` | | Put before the tmux name of such a session. |
  149. | `loose_skip` | `[]` | Patterns. A session outside tmux whose name matches is not recorded. `"^$"` means: no name. |
  150. | `herdr_default_workspace` | | With Herdr: the workspace for a session that has a tab label and no workspace. |
  151. | `tsv_path` | | Also write the record as a tab-separated table with eight columns at this path, for tools that read one. `tsv_socket` limits it to one tmux socket name. |
  152. | `lost_keep_h` | `12` | How long sessions that vanished together stay on the record as sessions to bring back. |
  153. Before a planned reboot, run `tardigrade revive --dry-run --all` and read the lines. That is exactly what will run.
  154. ## Tested
  155. Proven on 0.1.7, on real machines, 2026-11-21:
  156. - **A real reboot of a shared Linux machine with 98 sessions**, the first time that machine relied on this skill.
  157. All 98 came back by themselves: none failed, none needed a second try, each with its own permission mode, model
  158. and folder, through the machine's own command for starting its tmux server and with its desktop's variables.
  159. **It took too long and said nothing while it worked:** the starts ran one at a time for 18 minutes, the Herdr
  160. tabs were attached only at the end, and all 98 were loaded 25 and a half minutes after boot. Twenty minutes in,
  161. the machine's owner saw an empty tab, took his session for lost and started a second copy by hand. 90 of the
  162. tabs were attached; six sessions had no tab because their Herdr workspaces had not come back. Each of these is
  163. now a promise with a version (see below).
  164. - **Seven real reboots of a Linux laptop** (Ubuntu 24.04, Claude Code 2.1.330) with seven sessions: one of a team's
  165. own working sessions with its Herdr tab, one with permission checks off, one that accepts edits, one in the home
  166. folder, one that had been in a plain desktop window, and two that nobody had ever written in. The first two
  167. reboots found three faults (see the changelog); they were fixed and the reboots repeated. On the five after
  168. that, one of them a sudden reset with no shutdown, all seven were running again within four minutes of boot and
  169. all seven loaded, with nothing typed by anyone. Each time: the two home-folder sessions were asked "trust this folder?" and
  170. answered (`trust on`), the Herdr tab was attached again, the two empty sessions came back new under their names,
  171. and every command line was Claude Code's flags and `--resume`, nothing else.
  172. - **A restart in the middle of a revive** left a lock behind, and the next boot brought back nothing. That was
  173. the fault. After the fix, the boot run was started again by hand on that machine, took the lock over and brought
  174. all seven back. A second real reboot landing in the middle of a run of the fixed version is covered by a test,
  175. not yet by a machine.
  176. - **Three real reboots of a Mac** (Intel, macOS 13, logs in by itself, FileVault off), one of them an ungraceful
  177. quick restart, with four sessions, two of them a team's working sessions in the home folder with Herdr tabs.
  178. All four were loaded between three and four minutes after boot each time, and each session's login was checked. The first two
  179. showed that the Herdr tabs were not really attached on a Mac (its shell reads `=name` its own way); after the
  180. fix both tabs were attached, and the log now checks that instead of assuming it.
  181. - **The typed message, on a real session** (Linux, Claude Code 2.1.330): ended, brought back through its start
  182. file, the message typed once it was idle; the session showed its earlier conversation and answered.
  183. - **The message withheld**: on a laptop whose account was at its usage limit, five sessions came back to Claude
  184. Code's "limit reached" question. Nothing was typed into any of them, and the log named all five.
  185. - **An env file, a tmux config and a stale session bus** on a real boot: the variables reached the sessions, each
  186. session started in its own folder, the config was loaded, and a bus address that no longer existed was replaced
  187. by the user's own.
  188. - **About 100 sessions, read only**: on a shared Linux machine with 98 sessions, `revive --dry-run --all` was
  189. compared line by line with the restore tool that machine uses today: the same 98 sessions, each with the same
  190. tmux name, folder, model, effort and recorded permission mode. Nothing was started.
  191. - 65 tests on Linux with stand-ins for `claude` and `herdr`, run on every push with Python 3.10 and 3.13.
  192. Proven on earlier versions only (0.1.1 to 0.1.6): opening windows for hidden sessions on a Linux desktop.
  193. Not yet proven:
  194. - **A session acting on the message after a real reboot.** It is proven after a real end and return of one
  195. session, not after a restart of the whole machine: the test machines' account was at its usage limit.
  196. - **With nobody logged in at all.** The laptop logs into its desktop by itself, so lingering alone was not isolated.
  197. - **A Mac with FileVault on, or one that logs in as another user**: setup and the census say what will happen; no
  198. such Mac was rebooted. Opening windows on a Mac.
  199. - **A session pinned to an account by a wrapper** and **a start command of your own**: proven with stand-ins, and
  200. by a read-only dry run on a machine that uses them, not through a reboot.
  201. - **Windows** is not supported. Under WSL, use it inside the Linux system.
  202. Things the real machines taught us, which the tests now hold: Claude Code asks "do you trust this folder?" on every
  203. start of a session in the home folder, even with permission checks off; a session on an account at its limit comes
  204. back to a question; a session nobody ever wrote in cannot be resumed; a slow machine can take minutes to load a
  205. session; and a line that works in one shell can fail in another.
  206. The plan this is built from, with each claim and its proof, is
  207. [DNA-STRAND-MASTER-PLAN.md](DNA-STRAND-MASTER-PLAN.md).
  208. ### What it owes
  209. [PROMISES.json](PROMISES.json) lists what real use has shown must change, and the version each change is due in:
  210. starting several sessions at a time, attaching each tab as its session comes up, saying on the screen that sessions
  211. are on their way, waking sessions that came back idle, and twenty more. It is not a wish list. The tests refuse a version while a promise due in it is
  212. not built, and refuse the next one until the promise has been seen to work on a real machine.
  213. ## Where it comes from
  214. The record-and-revive engine was built and run by an AI agent on The Windstorm's own fleet from November 2026, on a
  215. machine with about 100 Claude Code sessions. This plugin is that engine made general, with the census added.
  216. Other tools restore terminal layouts (tmux-resurrect, tmux-continuum, Zellij) and a few small ones resume Claude
  217. Code sessions. Use what fits you. This one is for people who run many sessions and want them back without doing
  218. anything.
  219. ## License
  220. Apache-2.0. See [LICENSE](LICENSE) and [NOTICE](NOTICE).

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.