Omniscio

SSH Remote (run sessions on another machine)

SSH Remote lets any individual Omniscio session run its Claude CLI on a different machine — your GPU box, a Linux dev server, a cloud VM — while you drive it from the Omniscio UI on your desktop. Under the hood Omniscio opens an SSH connection to the remote host, pipes a bash bootstrap script over stdin, launches the CLI remotely, and streams the NDJSON output back to your local UI as if the process were running here.

On this page

Editing a saved remote

On the Remotes tab in Settings, use the pencil beside a remote to open its saved details. Change the fields and choose Update. This changes the existing remote without adding another entry. If saving fails, your entered values remain so you can try again.

To create a different remote, return to the Remotes tab and open Add Remote. It starts with a clean form, separate from the remote you were editing.

What it is

SSH Remote lets any individual Omniscio session run its Claude CLI on a different machine — your GPU box, a Linux dev server, a cloud VM — while you drive it from the Omniscio UI on your desktop. Under the hood Omniscio opens an SSH connection to the remote host, pipes a bash bootstrap script over stdin, launches the CLI remotely, and streams the NDJSON output back to your local UI as if the process were running here. Useful when the code you need Claude to edit lives on a remote box, when a session needs GPU access your laptop doesn't have, or when you want session work isolated to a cheap cloud VM. Per-session (not per-project), so you can freely mix local and remote sessions in the same project.

Where to find it

Settings → SSH Remotes — add a host, choose a key strategy, and optionally set it as the default. A session then picks a remote from the Run chip.

How it behaves

How to use it

  1. Add a remote host. Settings → SSH Remotes → Add remote. Fill in a nickname, host, port (default 22), username, and pick a key strategy — Generate new Ed25519 key (Omniscio creates one for this host, stored in {userData}/keys/) or Use existing (point at a private key file you already manage). If the host is only reachable through a bastion, put it in Proxy Jump (user@bastion.example.com, or a comma-separated chain of hops for a multi-hop route); leave the field blank for a direct connection. Import from SSH Config reads your existing ~/.ssh/config hosts, including their ProxyJump.
  2. Install the public key on the server. Omniscio shows you the public key — paste it into ~/.ssh/authorized_keys on the remote host (or use your existing method). Click Test connection — Omniscio does a quick handshake and reports success/failure with the exact error if it fails.
  3. Trust the host key. First connection adds the server's SSH host-key to an app-managed ssh_known_hosts file (isolated from your regular ~/.ssh/known_hosts so Omniscio can't pollute your system config). Subsequent connections TOFU-verify against this file — mismatches will fail closed, which is what you want if someone's MITM'ing you. (Builds before 2026-10-12 accidentally saved host keys on a Mac to a stray ~/Library/Application file, because ssh split the folder name at its space. The first launch of a newer build copies those keys into ssh_known_hosts once, so a host you already trusted stays pinned to the same key. It never edits or deletes the stray file.)
  4. Launch a session on the remote. Start a new session, then on the new-session screen use the Run chip in the pill row (beside Model / Thinking / MCP). It lists Local plus every SSH remote you configured (the remotes Omniscio creates for its own cloud sessions are internal and never listed). Pick one and send your first message — the session is created on that host, and the status dot, output stream, and input all behave like a local session. The pick is staged, so nothing connects until you send. Each project gets its own folder on the remote: a new session runs in <Remote Working Dir>/<project-slug>, created automatically on first use, so two projects on the same remote never share a directory. That folder is decided once, when a session first runs, and stays put — renaming the project or editing the remote never moves a running session's work, and a session that already ran keeps the directory it has been using. (Cloud VMs and Windows remotes keep a single working directory instead.)
  5. Switch defaults. If most of your work happens on one remote, make it the default via Settings → SSH Remotes → Set as default. The Run chip then pre-selects it on every new session, with Local one click away.

Which engines can run remotely. Only the native Claude engine. Every other engine (Codex, Gemini, Cursor, the DeepSeek/Kimi/GLM family, the GPT/xAI proxies, and the rest) runs on your own computer regardless of this setting — their credentials are a local overlay that is never forwarded to the remote host. The Run chip greys those remotes out and says so, rather than letting a session silently run in the wrong place.

Confirming a remote session stopped

Omniscio can confirm stops on Linux and macOS for sessions carrying the marker added when they launch. On macOS, it checks marked processes belonging to the remote user, including processes without a terminal. If the machine cannot read its process table, the stop remains unconfirmed. Marker text in a process's arguments also leaves the stop unconfirmed without signalling that process. A known limit remains: the macOS listing cannot distinguish the marker from the same text deliberately embedded inside another environment variable belonging to that user. Real-Mac positive-control verification is deferred until after landing.

Keep working while this computer sleeps

Off until you switch it on, for your own Linux remotes: Settings → SSH Remotes → Keep sessions working while this computer sleeps (on the Remotes tab). With it on, close the lid or let the computer sleep and a session on the remote keeps working there — and keeps spending while it does.

  • Approvals. While you are away, the remote approves exactly what your approval level already allows. Anything else waits for you — and once the remote has answered an ask, you are never asked it again.
  • Coming back. When the computer wakes, the app reconnects and shows everything the remote did as one reply. The message is never sent again. If the remote stays unreachable, the app keeps trying for a while, then says so and offers Retry.
  • Sending while it reconnects. A message you send while the app is reconnecting (or after it gave up) waits in the queue: the app first shows what the remote did, then sends it.
  • Stop stops the work on the remote too, not just the connection.
  • Needs. A Linux machine with Node.js. If the keep-working helper cannot be installed there, the session refuses to start with a message naming the remote, rather than quietly running without it — switch the setting off to run there the normal way. A Windows remote is never included, and cloud VMs have their own switch and ignore this one.
  • Switching it off applies to the next launch. A run already going on the remote keeps going until it ends, so press Stop first if you want it to end now.

Using this computer's Claude accounts on your own machine. In Managed accounts mode, each of your own Linux or Mac remotes in Settings → SSH Remotes shows a switch, Use this computer's Claude accounts. It starts off. With it on:

  • Sessions on that machine run on your Managed accounts, chosen by the same chooser your local sessions use, and move to another account when one hits its usage limit (the 10-minute rate-limit sweep resumes them, honouring Auto-Switch Account on Rate Limit). Move-account works for them too.
  • Your sign-in never goes to the machine. It gets a pass that works for one run and the address of this computer's account relay, reached back over the same SSH connection on a fresh port bound to the machine's loopback only, landing on this computer's box-only port. The pass stops working when the run ends.
  • The machine's own Claude login is not used for those sessions. Competing credentials in its shell (ANTHROPIC_API_KEY, ANTHROPIC_AUTH_TOKEN, the Bedrock / Vertex / Foundry switches) are cleared before Claude starts, and a remote whose saved environment variables set one is refused by name.
  • The connection uses only the details saved here: your ~/.ssh/config is not read for that machine, so a host alias, IdentityFile or ProxyCommand set only there does not apply. Default keys and ssh-agent still work.
  • Changing the host, port, username or Proxy Jump turns the switch off. Only you — from this computer, or with the full-trust CLI token — can turn it on; an agent's token can only turn it off.
  • Flipping the switch saves only the switch (the ssh:set-desktop-pool call takes just the remote's id and the on/off value; scripts use POST /ssh/remotes/:id/desktop-pool, which only your own full-trust token can use to turn it on). A rename or any other edit made elsewhere since the settings screen loaded is kept, and the row then shows the remote as it is now saved.
  • The way back over the SSH connection reaches this computer's control server, so anyone signed in to the remote machine can knock on it. Without your token they get nothing: every route that changes something answers 401, every other read route answers 401/403 from its own token check (even with every feature switched on), the jump-to links (/focus, /inbox, /project/<name>, /superprompt/<id>) answer 403 even when the caller claims to be a same-origin page, and only the liveness answers (/ping, /health-probe, /status without its project details) say the app is up.

Not covered: Windows remotes, Omniscio's own cloud machines (they have their own road), sessions set to keep running after Omniscio closes (they keep the machine's own login, and the session says so), and the Your API key / Claude Code login sign-in methods (the switch is hidden). Known limits: a Claude apiKeyHelper or a credential in the machine's own Claude settings makes the call fail at the relay instead of billing a pooled account; an SSH server with forwarding disabled fails the launch; a machine signed in to a company Claude gateway keeps that route.

Messaging other sessions from your own machine. Once you turn on Let sessions here message your other sessions for one of your own Linux or Mac remotes (Settings → SSH Remotes, off for every remote until you do), a session there can report to its crew lead, answer a peer and message a session in another project, just like a session on this computer. Only you can turn it on (an agent can only turn it off), it turns off if you change the remote's address, and it is separate from the account-pool switch:

  • Omniscio starts one small relay on the machine (127.0.0.1:19519) in a folder beside your project folders (<Remote Working Dir>/.amc-cloud-hooks), shared by every project there, and reaches this computer back over the session's own SSH connection. Its supervisor keeps that address for as long as any session on the machine may still hold its key, however long that session sits idle.
  • The session gets its own key only after the relay proves it is Omniscio's (it answers with a secret only your login user can read, from an address your user holds), only when no other person can log in to the machine (root and your own account aside), and only once its private scratch folder is claimed. On a Mac the same checks read the Mac's own account list (dscl) and lsof. The machine's clock must also be within 4 minutes of this computer's, measured when the launch starts (a slow setup never counts against it). Otherwise the session runs without a key, AMC_ROUTE_HOME_REFUSED says why (shared-server, remote-accounts, accounts-unreadable, nsswitch-unreadable, clock-skew, launch-in-future, launch-too-old, bad-launch-time, route-folder-layout, relay-outdated, wrong-answer, listener-not-ours, no-answer, no-listener, secret-not-private, route-folder-not-private, scratch-not-private, scratch-too-large-to-audit, bad-session-tmp, no-socket-table, unsupported-platform), and it cannot message anyone.
  • When the machine's relay is still starting up (the first session after it shut down for being idle for ten minutes), the session waits for it, up to 8 seconds, instead of being refused.
  • Folder layout. The road home needs the remote's Remote Working Dir to be a full path (/…) or start with ~, and the session's folder to sit directly inside it. With the switch on and a folder that does not fit, Settings shows the reason under the switch, and each session there says once, in the session, that it cannot message anyone and where to fix it (route-folder-layout).
  • A session there cannot start another session. With the road home on, the key the session holds is refused on every way of starting a session (new session, fan-out, recipe, swarm, crew helper, review and the like) and is told to use the remote-start request door instead. It still messages its crew lead and peers, joins its crew and reports. Cloud-box sessions are not affected.
  • The relay looks up at most 8 callers at once; a connection past that is closed and logged (route_relay_lookup_cap), so another user on the machine flooding it can delay your sessions' messages but never get a key.
  • The key reaches exactly what a cloud session's key reaches, sends only as that session, and stops working when the session ends (seven days at most). It only works through that machine's own relay, which serves only your login user and signs every line home with a fresh one-time code, so a copy of the key, or of a line home, is no use to anyone else.
  • Turning the switch off, removing the remote or changing its address stops the keys at once. The relay itself stops when the last session there ends, or at the next launch. That launch deletes the relay's key file first (a key it cannot delete is logged as relay-attest-delete-failed), then stops only a relay it proves is yours, holding the address; anything else is left running and logged by name.
  • A machine that gets this road connects with the details saved here only (your ~/.ssh/config is not read for it), as the account-pool switch below already does.
  • Takes effect the next time each session launches; an updated relay is picked up while it runs. Not covered: Windows remotes, machines whose accounts also come from a directory service (sss, ldap, nis, winbind) or a Mac network directory, and machines with no /etc/nsswitch.conf (such as Alpine), which refuse.
  • After updating from a build before 2026-10-29: the next session you launch on a machine replaces the old relay running there on its own, once it has proven that relay is yours. If it cannot, that session reports relay-outdated; then turn that remote's switch off, launch one session there (that stops the old relay), and turn it back on. Contract: own-ssh-server-route-home-contract.md.

Phone and web. Choosing a remote is desktop-only. The SSH commands are deliberately refused over the mobile bridge because they expose private-key paths, so on a phone the Run chip shows Local only. The refusal covers the whole SSH-management family, not only the calls that return a key path: every SSH call starts from the desktop's Settings → SSH Remotes or session-launch menu, and there is no phone SSH screen, so blocking them costs a phone nothing. ssh:get-config-hosts returns each ~/.ssh/config entry's private-key path, ssh:test-connection makes this computer open an SSH connection to a stored or caller-supplied host, ssh:set-default / ssh:get-default write and read the default remote, and ssh:set-desktop-pool turns a machine's account-pool switch on or off — each is listed in BLOCKED_CHANNELS in web-access-ws-channels.ts (W3 / F007).

Opening the files a remote session mentions. Click a file path a remote session printed and the Peek viewer shows that computer's copy, read-only (a small Remote · read-only tag sits by the name) — text and code, Markdown, images and PDFs. A relative path opens from the session's folder on the remote. Omniscio reads it over the session's own SSH setup with a single read-only connection and changes nothing on the remote computer. Private keys, .ssh, .env, cloud-tool logins, shell history, the system password and sudo files and Claude's credentials are never shown, even through a shortcut. Folders and other file types say they can't be opened from a remote computer yet. This also works from the phone (it sends no key paths to it); it does not cover Omniscio's cloud sessions or Windows remotes yet. Details: peek-viewer.md.

The host page

With Settings → Lab → SSH host pages on, each saved remote in Settings → SSH Remotes gets a Host page button. The page shows how many sessions run or ran there and lets you:

  • Give a project its own folder on the host. Pick the project and type a folder (~/code/app or an absolute path). Omniscio checks the host answers before saving; a folder that does not exist yet is created when a session first runs. New sessions of that project on that host then run there; a session that already ran keeps its folder.
  • Browse files, read-only. Open a folder, step into sub-folders, and view text files. Keys, secrets and credentials are left out of listings, and nothing on the host is changed.
  • Read git, read-only. See changes, recent commits and the diff of the folder shown. The app never commits, pushes, pulls or discards on the host; the agent or your own terminal does that.

The app uses at most two connections to a host at a time, and each command gives up after 15 seconds. Windows hosts keep running agent sessions as before, but files and git say they are not available there yet. Omniscio's own cloud machines are never shown as hosts. Deleting a remote now says how many sessions ran there and how many project folders it forgets; those sessions stay readable but cannot start new turns, and nothing on the host is deleted. A host session's Terminal tab opens a shell on the host in the session's folder. All of this is desktop-only.

How it works

The 9 IPC channels are declared in remote.ts: SSH_LIST_REMOTES, SSH_SAVE_REMOTE, SSH_DELETE_REMOTE, SSH_GET_DEFAULT, SSH_SET_DEFAULT, SSH_TEST_CONNECTION, SSH_GET_CONFIG_HOSTS, SSH_QUICK_CONNECT_BOOTSTRAP, SSH_QUICK_CONNECT_PROGRESS. Handlers live in ssh-handlers.ts. CRUD + validation + connection-testing is in ssh-remote-manager.ts. Ed25519 keys are generated by spawning ssh-keygen via ssh-key-manager.ts and stored at file mode 0o600 in {userData}/keys/. Spawn construction — which is where the security invariants bite — is ssh-command-builder.ts: never uses shell: true, always runs shellEscape() on any user-supplied value (remote working directory, environment variables, arguments), pipes a bash bootstrap script to stdin so we don't have to argv-encode multi-line scripts. Per-session resolution — which remote to use for a given sessionId — happens in ssh-remote-resolver.ts. The settings UI is SshRemotesSettings.tsx. TOFU host-key verification uses an app-private ssh_known_hosts file in {userData}/ — isolated from ~/.ssh/known_hosts so Omniscio can neither read your personal hosts nor mutate them. Ed25519 private keys are not additionally encrypted by Omniscio — on-disk protection is OS file permissions only (0600). Full security context: security.md.

Letting agents start sessions on a machine

Remote sessions is still being finished, so its controls (the machine switch below, the kill switch, the limits, standing OKs and the log) are hidden on the Remotes tab until you switch on "Remote sessions" in Settings > Lab. They are never hidden from anyone who could be using them: they show whenever a machine lets agents start sessions, a remote session is running, or a stop is still waiting. Hiding changes only what the tab shows. The limits, the kill switch, the approvals and the log work exactly the same either way.

Each saved machine of your own has a switch, "Agents may start sessions here", under its row in Settings → SSH Remotes. It starts off. Only you can turn it on, by clicking it in the app window and then pressing Allow in the dialog that names the machine. An agent cannot turn it on, with any key, and a machine an agent saved stays off. The switch turns itself off if you change the machine's host, port, login or jump host, and a restored backup never brings it back.

Behind the switch sit a kill switch and four limits, which start at 2 sessions at once on each machine, 4 in total, $10 per session and $40 per day. An agent can tighten any of these or switch a machine off, but only you can loosen them, with the same click and dialog. A log of every request is kept that nothing can edit or delete. The kill switch is the "Remote sessions kill switch" at the top of the Remotes tab, and Settings search finds it by "kill switch"; OFF stops every remote session and ON means they are allowed. Turning it off refuses new requests, withdraws waiting ones, revokes every approval and stops every running remote session, but never touches the machine, and turning it back on asks you to confirm. The four limits are on the same Remotes tab, in a panel under that switch: lowering one applies at once, and raising one asks you to confirm in a window. Once a minute the app also stops every running remote session if the day's money is spent, and any single one that used all the money it was approved for.

A crew lead can ask to start a Claude session on one of your allowed machines. The ask raises a card in your inbox that names the machine and its address, the project, why, what it will run, the money limit for that session and how many remote sessions already run. Nothing starts until you tap Approve, and no agent, token or setting can tap for you; the same card can be answered from your paired phone. When you tap, the app checks the kill switch, the machine's switch, its address, the counts and today's money again, so a limit reached since the ask stops the start, and the lead is told why. Switching remote sessions off withdraws every waiting card.

A lead can also ask you to allow a machine. That card changes nothing until you tap Approve and then press Allow in the dialog on this computer, wherever you tapped. Every remote session carries its approval on disk: the money it may spend, the machine's address and a 24 hour life from your tap. Each time one starts, and each time one is woken by a message or an app restart, the app checks that approval, the kill switch, the machine's switch and address, the counts and the money again. A session that fails any check is ended, told why in its own chat, written to the log and reported to the lead who asked. It gets only the money it has left, so a restart never gives it a fresh cap. Past 24 hours, or after its money is spent, it needs a new card. A session cannot be created on one of your own machines except through an approved request, and a remote session cannot create sessions at all. A lead can also ask for a standing OK: up to 5 starts over up to 8 hours on one allowed machine, at the money limit shown on the card. That card needs your tap and then a confirmation on this computer that says plainly you will not be asked for each start. While it lasts, a start on that machine by a crew lead runs with no card, still through the kill switch, the machine's switch and address, the counts and the money; a remote session can never use it, and no agent can grant, extend or widen one. It ends on its own, and sessions started under it can only be woken until it ends. Each live standing OK shows on the Remotes tab with its starts left and a Revoke button, and switching remote sessions off revokes them all.

Leads decide where a worker runs before they start it. The overseer instructions keep your own computer free for you: they read the app's memory gauge and the count of running sessions, send long, light work (research, read-only audits, drafting, reviews) to an allowed machine with a free slot whenever one exists, and keep anything that needs the live app, a screen, Mac-only files or heavy builds on your computer. They ask you for one standing OK per machine per day, not a card per session, and when no slot is free the work waits instead of starting somewhere else. A read-only list at GET /remote-sessions/machines shows them each allowed machine's free slots; it never shows an address, login or key, and neither does the list of live standing OKs at GET /remote-sessions/standing-oks. These rules guide the agents and change none of your limits, the kill switch or what needs your tap.

Seeing what uses space on a machine

Each machine of your own that is not a per-session cloud machine and does not run Windows has a "What uses space" button in Settings → SSH Remotes. Pressing it reads the machine over SSH and shows how full its disk is, then what sits one level under the machine's project folder, biggest first: each folder's size, what kind of thing it is, how long since anything in it changed, and how much of it could be rebuilt (package folders and build output). It also totals the package caches, the temporary files the app left, and the session transcripts, which are marked as never cleaned, and says how much of the disk it cannot account for. The report only reads: it creates, changes and deletes nothing on the machine. It has a time limit; when it runs out it says the list is incomplete. Only you can press it (a click in the app window), and the phone and web view cannot. Moving finished project folders into a trash folder, and the daily cleanup that does it for you, are described below.

Cleaning caches and old temporary files on a machine

The app can clear the rebuildable junk on one of your own Linux machines: the npm and pnpm caches, the Cypress, electron and node-gyp download caches, and old amc-* temporary files the app left in /tmp. It never touches project folders, session transcripts, other files in /tmp, or the app's own log files there. A cache or temp file that changed in the last few minutes (or a temp file less than a day old, or one a running session or process is using) is kept, and the result says why.

It works in two steps, and both are a click in the app window (the phone and web view cannot):

  • Dry run. Lists every path it would remove, its size, the total it would free, and what it would keep and why. It changes nothing on the machine and writes nothing.
  • Real clean-up. Asks you to confirm, writes down what it is about to remove, removes only those paths, then reads the disk again and shows one line: how much was removed and freed, the disk percentage before and after, and what was kept. A clean-up that cannot write its record removes nothing. One clean-up runs at a time per machine.

It refuses, and removes nothing, on a machine that is a per-session cloud machine, a Windows machine, not saved by you, or not Linux, when the machine cannot be reached, or when the app cannot read which sessions are open. The record of each clean-up is kept in the app's data folder.

The daily cleanup below runs this pass for you when its switch is on; otherwise nothing cleans a machine unless you ask for it. The pnpm package store is not cleaned here, because project folders link into it; pnpm's own prune is the right tool for that.

Moving finished project folders to the trash on a machine

On one of your own Linux machines, the app can find project folders whose work is finished and move them into a trash folder (.amc-trash, inside the machine's project folder). The move itself never deletes anything. Moving a folder into the trash stays on the same disk, so it frees no space until the trash is emptied. The daily cleanup below empties the trash for you once a trashed folder is 3 days old.

A folder counts as finished only when all of these hold, and anything the app is unsure about counts as not finished:

  • No open session uses it. The app checks its own records of the sessions open on that machine, and checks for a program running inside the folder on the machine itself. A session that works at the project folder itself keeps every folder.
  • All the work in it is pushed. Every repository in it has a remote, a clean tree with no untracked file, no stash, and no commit (on any branch) that is not on a remote branch. A folder with no repository at all is kept, and so is one tied to work-trees stored elsewhere.
  • Nothing in it changed for 3 days.

It works in two steps, and both are a click in the app window (the phone and web view cannot):

  • Dry run. Lists each finished folder with its size, how many repositories it holds and the names of the remotes the work was checked against, then every folder it kept and why. It changes nothing on the machine.
  • Move. Takes the exact folders you approved and asks you to confirm. It checks each one again on the machine, so a folder that stopped being finished since the dry run stays where it is. Each moved folder lands in its own folder in the trash together with a note saying what it was, why it was moved, when, and the exact command to put it back. A move that cannot write its record moves nothing.

There is also a script for doing this by hand: it prints the exact text to run on the machine, for the dry run or for a move of a list you name. It will not print until you say which folders open sessions use, or that none are open.

The daily cleanup below runs this step for you when its switch is on.

Cleaning your servers every day

Settings → SSH Remotes has a switch, Clean up my servers every day. It is off until you turn it on, and only your own click in the app can turn it on; an agent cannot. While it is off nothing runs.

When it is on, the app runs the cleanup by itself once a day, from 04:15 on, on the computer that is running Omniscio. This works in the installed app. If the app was closed at 04:15, it runs once when you next open the app that day, and does not catch up older days. It only touches machines you saved by hand that run Linux and that you have allowed agents to start sessions on. It never touches a cloud-session machine, a Windows machine, or the shared cloud test fleet. For each machine it does this, in order:

  • Skips the machine if any session is open on it. An idle session you left open also counts, so close sessions you are done with.
  • Clears caches and old temporary files (the same pass as the cleanup button).
  • Moves finished folders to the trash. It first does the dry run itself, then moves exactly the folders that dry run listed. The machine checks each folder again before moving it, with the same rules as above, so nothing is moved that you would not have been shown.
  • Deletes old trash for good. A trashed folder is deleted when it is more than 3 days old, sits directly in the trash folder, is a real folder (never a shortcut) and holds the restore note the move wrote. Anything else in the trash is left alone, and a shortcut inside a trashed folder is removed without ever being followed. This is the only step that deletes a project folder, and it is why the disk gets room about 3 days after a folder is moved.

The remote sessions kill switch stops the run, and so does turning this switch off: both are checked before every step. Press the dry run on a machine first the day you turn the switch on, so the first run holds no surprise.

Each run leaves a short record you can read: what was cleared, moved, deleted and kept, and why, per machine, in the file remote-machine-cleanup-last-run.json in the .amc folder of your home folder, with the same lines added to remote-machine-cleanup.jsonl next to it. If a machine fails (for example it cannot be reached) the run is recorded as failed and tried again the next day; there is no inbox card for it. A machine skipped because a session is open, or a run the kill switch refused, is not a failure.

Not built: running the cleanup when a disk passes 75 percent full, and an end entry in the start log when a remote session finishes on its own.

Last verified 2026-11-10