Alelyon app 0.14.0
- Your agent's request to act in the window (Not now, Allow), a notice's Dismiss and Stop listening sit clear of the window's own minimise, maximise and close buttons in the top right corner, instead of under them.
- On Linux, your preferences, the dock's layout, transcripts, the marketing plan and the mailbox are kept under ~/.alelyon in your home folder, so they last from one start to the next; on Windows they stay where they were. Stay signed in keeps nothing on Linux, and says so.
- Alelyon builds and runs on Linux (Ubuntu 24.04), so a project's agents can build it and open it in the project sandbox. There, the IDE's terminal runs your shell on a pseudoterminal, and what the window starts ends when the window lets it go (after a crash of the window it runs on: Linux has no job object).
- On Linux there is no folder or file picker: type a folder's path where a box asks for one, and an export goes to your Downloads folder.
- The chat reads more like Claude Code's: an answer carries no name or mark over it, the model and what it used stand quietly under it, and Copy shows on the answer the pointer is on (and on the newest, with Regenerate).
- The steps an agent takes while it answers show as quiet one-line rows, each run of them together, instead of italic lines among its words; a step no longer says "pending", which was only what it said as it began.
- Your messages and the box you write in use the answers' size.
- A new chat greets you more quietly: the two paragraphs about how the agent works are gone, and the starting suggestions are a row of small chips under the box, each saying its message on hover.
- The rail's tooltips wait a moment before they show, so passing over the rail on the way to the chat no longer covers it.
- Chats moved in from Claude Code read as they were written: where a tool step or the agent's reasoning came between its words, they are no longer run together ("I'll read it first.Found the bug."). The chats already moved in are put right once, on the next start, from Claude Code's own record of them.
- A live answer's first words after the agent reasons begin a paragraph of their own.
- A session Claude Code started from another comes into the task thread of the one it was started from, as Claude Code nests them, its worktree sessions included; one already moved in on its own goes there too.
- "Bring in" moves every session of the past day, week or month at once, asking once. It goes on while you use the rest of the app, how far it is turning in the side bar and the status bar. A session not used for a month is no longer offered.
- A session whose worktree was removed once its work landed comes in to its project's folder and goes on there.
- A folder inside one already attached is attached without asking again.
- On Linux, the Infrastructure page's Docker and Podman commands run in a process group of their own, so anything a command leaves running ends with it, as on Windows; with this, Alelyon builds on Linux with the Infrastructure page in it.
- Infrastructure: Docker and Podman in the app. A new place on the rail (Ctrl+9) shows each container engine on this computer and works it: containers live with their state, health, ports, stack, processor and memory; start, stop, restart, pause and resume at one press; kill and removals ask first and name what goes, and what deletes data for good asks twice. A container's log follows as it is written, a shell inside it opens in the terminal panel, and its environment's values stay hidden until shown. Compose stacks are read from their labels and brought up or taken down with their own files; images, volumes and networks show what uses each and clear out what nothing uses. Docker Desktop starts on a press; nothing downloads by itself. Agents read the page without secret values and may start, stop, restart, pause or resume a container with your yes; an agent's own docker and kubectl removals and downloads now ask first.
- Infrastructure: Kubernetes in the app. Every cluster of your kubeconfig, worked through kubectl, which keeps the sign-ins: contexts (marked as on this computer or not), namespaces, workloads with ready counts, pods with status and restarts, services and events, kept current by kubectl's own watch. Restart, scale and roll back a workload; delete a pod; a shell inside a pod; forward a port and open it; apply a YAML file after its difference from the cluster is shown; make or delete a local cluster with kind. Scaling to none, rolling back, deleting and applying ask first, deleting a cluster twice, and any change on a cluster that is not on this computer asks and names it. Home lists crash-looping pods; agents may restart or scale a workload with your yes.
- On Linux, Lattice now starts git and the agent's commands: a command you approve once runs in bash (the agent is told to write bash), one you always allow runs its program directly, and Stop, a timeout and the command's end close what the command started, except a program that takes itself out of the command's process group. Linux has no counterpart yet of the limits Windows puts on a command's memory and number of processes.
- On Linux a folder can now be attached to Lattice's chat and opened in the IDE (type its path, or start with --folder), under the same rules as on Windows: no file outside the folder is read or written through a link, and the system's own folders, your home folder itself, the application data in it (~/.config, ~/.ssh, ...), Lattice's own state and a folder on a network file system cannot be attached. In a folder that is a git repository, Lattice needs git 2.45 or later (Ubuntu 24.04 has 2.43); with an older one, that folder's files are not shown.
- Moving your Claude Code sessions in asks about a folder once: a folder you already attached is not asked about again. The run now says why any session could not come in.
- Atlas keeps up to 500 chats in its list, where it kept 60: the chats the old limit set aside come back on the next start, so nothing you moved in drops out of the side bar, and a session already in Atlas is never moved in a second time.
- A project's sandbox is sized to the computer: a fifth of its memory (3 GB on a 16 GB computer, 6 GB on 32 GB, at most 8 GB) and half its processors, instead of 8 GB and 8 processors everywhere, since an awake sandbox holds all the memory it is given. On a computer with under 32 GB an unused sandbox sleeps after 5 minutes; a sandbox starts only with 2 GB left free beside it, putting other sandboxes to sleep first; and the Sandbox tab shows its memory, offers another size, and restarts it to apply one. Inside, the sandbox keeps 4 GB of swap, compressed in memory first, and fits compile jobs to its memory, so a peak slows a build instead of ending it: a 3 GB sandbox builds Atlas from nothing.
- Tests only: Lattice's unit tests compile on Linux. The tests that hold only on Windows are marked for Windows, and two of their link cases have Linux tests of their own: an interpreter reached through a link under another name is never offered Allow always, and a .git link into /proc is refused before it is followed. Nothing in the app changes.
- Project sandbox (first version): each project gets one Linux virtual machine of the person's own, where the project's agents build the app and use it as a person does (sandbox_* tools in Agent mode, in a project's chats with or without a folder); the dock's Sandbox tab shows its screen live, follows the agents there, sends the acting agent a directive, and lets the person take over the mouse and keyboard. The person's own agent (Claude Code and others) uses the same sandbox through alelyon-cli's MCP server (sandbox_look, _click, _type, _key, _scroll, _open, _run), through the open window and once the person allows it, with the dock following it there. A sandbox made before an update is given the new helper on its first use; a program opens by the words a person uses for it ("text editor"), a program with no window of its own opens inside a terminal, and new bases include a text editor.
- Every project sandbox has a git new enough for Atlas to read git folders: git's own packages come from the git-core PPA, and apt takes nothing else from it. A sandbox made before gets it in its background the first time the app reaches it.
- An installed app carries the project sandbox's helper beside it, so it updates each sandbox's helper the first time it reaches that sandbox.
- VirtualBox 7, and the sandbox's base machine prepared once on the computer (docs/features/SANDBOX.md)
- the app's install also builds the sandbox's Linux helper and copies it beside the app (docs/releases/products.json); where the Linux target is missing, `rustup target add x86_64-unknown-linux-musl` once first.