Stopping, restarting and new versions

What survives what

What happens	Programs	Screens and scrollback	Layout, directories, names
The window is closed	keep running	kept	kept
The window is opened again	—	shown as they are	—
The daemon moves to a new version (restart from the window, isc restart-server)	keep running	kept	kept
The daemon is stopped (isc kill-server, logout, reboot)	end	kept, as text and colour	kept
The daemon dies with no warning (crash, power cut, kill -9)	end	lost	kept

After the daemon has been stopped

The layout is saved in a file. It holds every project with its tabs, splits and their shares, floats and their rectangles, minimized panes and where they return to, focus, each pane's directory, and names. The file is rewritten whenever the layout changes.

When the daemon starts, it rebuilds all of it.

• Each pane gets a fresh shell, in the pane's directory. If that directory no longer exists, the shell starts in the project's root, or failing that, your home directory.
• A pane that was running nvim or an agent comes back as a shell. Nothing is run again automatically.
• Every pane of every project starts at once.
• None of a program's environment is kept. Anything you run from the prompt runs in the new shell's environment.

Each pane comes back showing what it showed before, history included, at the same size. Below that is a dim line, "── from before the server stopped ──", and then the new shell's prompt.

• It's what was printed, redrawn. You can scroll, search and copy it, but the programs that printed it are gone.
• A program that had taken over the screen, such as an editor or htop, leaves what was under it, the same as when it quits.
• It's written when the daemon is told to stop, and when a pane's program ends by itself. It isn't written while things are running, so a crash or a power cut keeps the layout but loses what the panes showed.
• A pane you closed keeps nothing.

What panes showed is on disk. It's in ~/.local/state/insensical/screens, readable only by you. Anything a program printed is in there, secrets included. With keep-scrollback = false, nothing is written, and files already there are removed as their panes close.

What ran in a pane is offered, not run.

• A pane started with a command, as in isc run -- npm start, comes back as a shell with that command typed at the prompt. Press Enter to run it, or edit or delete it like anything else you've typed. It appears a moment after the prompt does.
• A command you typed inside a shell isn't remembered. Only the command the pane was started with is.
• An agent's session is offered the same way. With the Claude Code hooks installed, a pane where Claude was last working comes back with claude --resume <session> at the prompt. It's offered until you run something else in that pane, so it also appears for a session that you quit normally. Codex, opencode and pi are offered their own resume commands (Agents). Gemini CLI isn't.
• An agent's command comes before the pane's own.

When a machine shuts down, programs often die a moment before the daemon is told to stop. The daemon doesn't record that as panes being closed, so the layout comes back whole. A pane's removal is written two seconds late, and a termination signal freezes the file as it is.

A layout file from a version this one cannot read is ignored, and the daemon starts empty. The next save overwrites the unreadable file.

A new version installed underneath

Installing replaces files and nothing else. The running daemon keeps running what it's running, and the open window keeps working.

The window tells you in the top bar: "insensical was updated. Restart to use the new version." isc version and isc ls say the same.

To move to the new version, do any of these:

• press the notice;
• press Ctrl+Alt+Shift+R (leader U);
• choose "Restart insensical" in the palette;
• close the application and open it again;
• run isc restart-server in a terminal.

Each one asks first, and tells you that everything running carries on. Press Enter to restart, or Escape to leave everything as it is. With no terminal to ask on, isc restart-server does nothing unless you pass --yes.

Restarting ends nothing. The daemon becomes the installed version in place. It's the same process, holding the same terminals.

• Programs keep running and never notice.
• Every screen and all the scrollback is still there, including anything a program printed during the move.
• The window shows "Restarting…" for a moment, then shows everything as it was.
• isc version names the same process before and after.

The first move to a version that can do this still ends everything. A daemon from before this was possible can't make way, so it's stopped and the new one is started. The prompt then lists the panes that are running something, counts the shells waiting at a prompt, and tells you that projects, tabs and panes come back. After that, updates end nothing.

Other things to know:

• Opened after an update with the old daemon still running, the application opens a window that says so. Press Enter to restart the daemon and carry on. Press Escape to leave the daemon running and close the window.
• If the application itself is from before the update, the installed application starts in place of the running one. This has never been exercised, in a real window or off-screen.
• If the daemon cannot make way, because the installed file is gone or is a version that can't take over what this one runs, nothing is stopped. The window says "The server did not move to the new version", that it's still running everything, and why. Press Enter to go back to it. isc restart-server prints the reason and exits with status 1.
• If the new daemon fails once it has taken over, the programs end, as they do when any daemon stops, and the layout comes back on the next start. Before the old daemon lets go, the new version is asked whether it can read what it's being given, so this takes a fault and not only a difference between versions.
• The notice also appears when you rebuild or reinstall from source. The application and the daemon each remember the file they were started from and notice when it's been replaced. That's correct, not a fault.

What isn't carried across a move:

• Desktop notifications already showing stay until they're dismissed. The new daemon can't withdraw them.
• A command that was already running is timed from the move, so it may not be reported as a long command when it ends.
• Windows, isc attach, isc events and isc wait lose their connection. Windows reconnect by themselves. The commands end, and you need to run them again.
• When the new version has a different terminal engine, screens are carried across by redrawing them, not exactly. Text, colours, history and cursor are kept. A colour a program had redefined, or an escape sequence it was halfway through writing, isn't. A program that redraws itself, such as an editor or an agent, fixes that the next time it draws.

Restarting is not the way to get a fresh daemon, for instance when the daemon was started with the wrong environment. It's the same process afterwards, with the same environment. For a fresh one, run isc kill-server, which ends every program, and then run any command or open the window, which starts a new one.

When the daemon goes away under an open window

• The window says "The server has stopped" and that the layout comes back when it starts.
• It looks for a daemon once a second and carries on by itself when one appears. For instance, after you run isc restart-server in a terminal, it shows the same programs still running.
• Press Enter to start one.
• If the daemon that appears is a different version from the window, the window starts the installed application in its place. If it can't, it tells you to close and reopen.

Different versions of isc, window and daemon

• They need the same protocol and the same terminal engine to work together. A mismatch is refused with a message that names isc restart-server.
• A few things work regardless: isc version, isc status, isc notify, the agents' hooks, isc kill-server, isc restart-server.
• A daemon too old to answer those, or one that's stuck, gets three seconds and is then stopped with a signal.