Moving work in and out

Nothing is mounted from the host, so a cell has no path to your files and its own work has no way out. Two folders and two commands close that gap without opening one: the host is always the party that moves the bytes.

Both folders live in the cell's home, so they survive the container being replaced and are destroyed with the cell.

Send work inCopy Anchor Link

solitary send claude notes.md
solitary send claude patch.diff fixture.json

Files arrive in the cell's inbox at /home/cell/inbox. Use this for prompts, patches, fixtures, or other inputs you intentionally choose to share. Directories are refused — send an archive instead.

Paste a screenshotCopy Anchor Link

solitary send claude --clipboard

The image on this host's clipboard arrives in the inbox as clipboard-<timestamp>.png, and the agent is pointed at that path. Pasting twice leaves two files rather than replacing one.

This is what a paste looks like from a cell, and it is host-initiated for the same reason everything else here is. A terminal carries characters, so an image cannot be pasted into a shell in a cell whatever the clipboard does; and the alternative — a cell reading the host's clipboard for itself — is the path back to the host that a cell exists not to have. Whatever is on your clipboard at any moment might be a password rather than a screenshot, and nothing inside a cell can ask for it.

The reader is whatever the host session uses: wl-paste under Wayland, xclip under X11, and osascript on macOS, which ships with it. Only image/png is asked for, so text on the clipboard is refused rather than sent as a file.

Publish work outCopy Anchor Link

Inside the cell, artifact publishes into the outbox:

artifact report.pdf dist/app   # publish these, for the host to collect
artifact --list                # what is published, and what is waiting to come in

On the host:

solitary fetch claude               # copy everything published into the current directory
solitary fetch claude --list        # see what is there without copying it
solitary fetch claude report.pdf    # or name what you want
solitary fetch claude --into ./out  # land them somewhere other than here
solitary fetch claude --force       # replace files already there

Fetching copies rather than moves, so fetching twice is not a mistake and an interrupted fetch loses nothing. Clearing the outbox is the cell's own business (rm inside it).

Only the machine has to be running, not the container: what a cell published can still be collected after whatever produced it has died.

The outbox is untrusted inputCopy Anchor Link

Its contents are named by whatever runs in the cell, and those names become paths on your machine. Four rules, all enforced on the host:

• Solitary does the listing itself — regular files only, one level deep. A symlink is not followed and a directory is not descended into. For a directory, create an archive inside the cell and publish the archive.
• A name that is not a plain file name — ../escape, -rf, an empty one — is refused by name rather than silently skipped, and the rest still come out.
• Nothing is written over something already there without --force, and the check happens as a group, before the first file is copied.
• Nothing arrives executable. Fetched files land 0644. What a cell produces is data on the host, never a program.