# Changelog Notable changes to Vela Server and its browser dashboard. SDKs and individual apps are versioned in their own repositories. Changes stay under Unreleased until the release workflow prepares a tested server version. ## Unreleased ## 0.1.21 - 2026-10-01 No additional release notes were provided. ## 0.1.20 - 2026-09-30 ### Added - **Apps can use web APIs that need a key or token.** An app can now declare one public HTTPS service it talks to, such as `api.github.com`. The install review names that address. Paste the service's API key or token into the app's settings in Vela. Vela stores it and adds it to the app's requests from the server, so the app never sees it, and nothing shows it again once saved. **Remove** deletes it. If an update points the app at a different address, you need to paste the token in again. Such an app can also open links on that service's site in a new tab, for example a pull request on `github.com`. See the `http` provider in [the app contract](docs/CONTRACT.md#app-data-connections-and-https). - **Keyboard shortcuts for windows and desktops.** **Alt+\`** switches between windows: keep Alt held to go further, and let go to choose. **Alt+↑** maximizes, **Alt+↓** restores or minimizes, **Alt+←** and **Alt+→** move a window to half the screen, **Alt+Shift+W** closes it, and **Alt+Shift+D** shows the desktop and then brings the same windows back. **Alt+Shift+←** and **Alt+Shift+→** step between desktops. On a Mac, Alt is Option. The title bar's menu now also has Minimize, Maximize and Close, with their keys beside them, and **?** shows every shortcut grouped by what it acts on. Keys typed inside an app still go to that app, so click a window's title bar first. - **Snap layouts, show desktop, all desktops and quick settings.** Rest the pointer on a window's maximize button, press **Alt+Z**, or use the window menu to pick a layout: halves, thirds, two thirds and a third, a half and two quarters, or four quarters. Dragging a window to the top of the desk maximizes it, and dragging it into a corner fills that quarter. Right-click the wallpaper for **Show desktop** and **Bring windows back**. **All desktops** (**Alt+Shift+↑**, or the rail's desktop menu) shows every desktop with its wallpaper, its open windows and whether it needs you. The new quick settings button beside the bell switches light and dark, changes this desktop's wallpaper, dimming and labels, and reaches these from one place. With an app lock set up, **Alt+Shift+L** or quick settings locks Vela, and the lock screen now shows the time. Pinned apps can be dragged into a new order on the rail, or dropped there from All apps, and rail labels wait a moment before appearing, then say whether an open window is in front, minimized, maximized or in one half. ### Changed - **The top bar sits beside the rail.** The rail now runs the full height of the window and the top bar starts beside it. The bar stays blank on an empty desk and names something only when it has focus, and its search opens in the middle of the screen, over the page rather than pushing it down. - **The desk is cleaner.** The search field and the **⋯** button no longer sit on the wallpaper. Search is in the top bar (or **⌘K** / **Ctrl+K**), and the desk's menu — Add widget, Arrange desk, Personalise, Reset desk — opens with a right-click, or a long press on a phone. Widgets now start a little lower, clear of the top bar. - **Vela works more like a desktop.** The Vela logo at the top of the rail opens All apps, and clicking it again, or anything else on the rail, puts it away; the separate Home and All apps buttons are gone. Choose a desktop in the rail's desktop menu to go back to its desk from any page. On a wide screen **Settings** opens as a window on the desk, with its sections listed down the side: move, snap, minimize or close it like any other window. There is only one; opening Settings again, or a link to one part of it, brings it forward at that section. Because windows live on the desk, opening Settings from a page such as Ask now takes you to the desk. Phones keep the full-screen Settings. - **Personalise lives in Settings › Appearance.** Light or dark, the style, and this desktop's wallpaper, dimming, labels and weather are now in one place instead of a separate drawer; **Personalise** in the desk menu opens it there. The **Ask on this board** switch is gone: add or remove the Ask widget with **Add widget** or the widget's own menu, like any other widget. - **Windows and menus respond more like a desktop.** Clicking inside an app now brings its window to the front, and the browser tab is named after the window you are using, such as "Notes · Vela". Windows behind the active one show a dimmer title. In All apps, typing while a tile has focus goes straight into the search box. In any menu, typing a letter jumps to the next item that starts with it, and pressing the right mouse button, moving onto an item and releasing chooses it. Menus and All apps open with a short animation (none with reduced motion) and close at once. - **The Python tests run in parallel.** `npm --prefix web run check` now runs the Python suite through `scripts/run-python-tests.py`, which spreads the same tests over worker processes. A full run drops from over twenty minutes to about three on an 8-core machine or larger. `python -m unittest discover -s tests` still runs the same suite serially. ### Fixed - **Settings on a phone respects reduced motion.** With reduced motion turned on, the Settings screens no longer slide in. ## 0.1.19 - 2026-09-26 ### Added - **Apps on this computer can connect to Vela.** A desktop app that supports it, such as Prompture Desk or Faro, registers itself when it starts and appears in the Marketplace under **Found on this computer**. Once you connect it, its widgets go on your desk and its buttons work from any phone signed in to your Vela, for example to pause an automation or pause file transfers. Its icon gets a dot when it needs you, with one phone notification if notifications are set up. The app keeps its own window. Vela shows it as not running when it is closed and can start it again. If the program or its buttons change, Vela stops talking to it until you accept the change. A connected app gets no Vela account or data and cannot call Vela. Vela only talks to it over this computer's own loopback address. - **Pair the Vela app for Android.** Settings → General has a new **Vela app** section. With Wi-Fi access on, **Pair the Vela app** shows a QR code that works once, for ten minutes. Scanning it connects the app directly: the QR code carries the certificate fingerprint, so no certificate setup is needed, and the phone never asks for your Vela password. Each paired device is listed with when it last connected. Removing one signs it out immediately without affecting your password or any other device. A TV has no camera, so **Add a TV** works the other way round. Type this computer's address on the TV, then enter the code the TV shows. Vela and the TV both show a short check, and matching them confirms the TV is talking to this computer. On a TV, the dashboard is navigated with the remote's arrows and OK, with a clear focus ring and a margin for screens that crop their edges. The Android app is still in development and not yet available to download. - **A top bar that follows what you are looking at.** The dashboard gains a menu bar across the top. It shows the name of whatever has focus — click a Calculator window on the desk and it reads "Calc", click Notes and it reads "Notes", open the Ask page and it reads "Ask" — along with that app's menus and the things you want reachable from anywhere: search, notifications and the time. Phone layouts are unchanged: there is no bar there, and the rail and the page header stay exactly as they were. Apps can put things in it, through the same kind of contract that lets them put summaries on the desk. An app declares its menus in its manifest, so you see them when you install it, and it can publish up to three small status items — a temperature, a queue, a connection light — that sit in the bar while it is running and disappear when you close its window. What an app sends is plain data: Vela draws it, from Vela's own icons and colours, and an app cannot put a picture, a link or any of its own code up there. - **Windows the shape their app says they are.** An app can now declare that its window is fixed-size or cannot be maximized, and Vela honours it: a calculator shows no maximize button, has no resize grips, and ignores a double-click on its title bar — while still being something you can pick up and move wherever you like. An app can also say what size to open at, which is used the first time and never again, so a window you have resized stays the size you left it. The maximize control is now a square rather than a pair of arrows, which is what it actually does. - **Host an existing web app.** Vela can now install and run a self-hosted web application — Memos, for example — that was never written for Vela. It downloads the release the package names, checks it against the package's checksum, and shows you the program's source, licence and exact build for this computer before anything is installed. The app keeps its own interface, accounts and database; Vela owns installing it, running it, its web address and its backups. Installing one grants it nothing inside Vela: no app storage, no actions, no desk widgets, no assistant or agent access, and no Vela credentials. The install review says plainly that the program runs with your own permissions, because it does. Each app is published on an address of its own, `http://.apps.localhost`, which every browser resolves without setup and on which Vela's own dashboard is never served. Opening an app from Vela hands your browser a link that works once and expires in thirty seconds; signing out, locking Vela, stopping the app or updating it all end that access immediately, including pages already open. Reaching an app from a phone needs one manual step on your network — a wildcard DNS entry for `*.apps.vela.invalid` pointing at this computer — and each app says so beside the address rather than offering a link that fails. Closing an app's window leaves it running; Stop is what ends it, and Vela remembers that you stopped it across a restart even with **Start with Vela** on. A crashed app is started again a few times with a growing pause and then left alone with the reason and its log. Backups are taken per app with the service stopped, so a database with a write-ahead log is copied whole; an update takes a checkpoint first, and **Go back** restores the previous version together with its matching data. Removing an app keeps its data and says where it is; erasing that data is a separate, confirmed action. - **One-command development environment.** `./dev.sh` (Linux/macOS/WSL/Git Bash) and `.\dev.ps1` (native Windows) start the backend and the Vite dashboard together against a disposable `.local/dev-data` directory, creating the virtualenv and installing dependencies on first run. `frontend` mode serves the dashboard with hot reload against an already running server — the quick path for CSS/UI-only work — and `build` refreshes `web/dist` without starting anything. `backend`, `check` and `setup` modes cover the rest; `--backend-port`/`--frontend-port` pin ports, which default to 7700 and 5173 and move aside when busy. - **A launch animation for opening an app.** The window frame lands the moment you click — 220 ms, whether or not the app has answered — with the app's name and an "Opening…" label in the title bar and a hairline sweeping underneath it. The body shows nothing but the app's own icon, gently pulsing: no skeleton rows to mistake for content. When the app answers, the icon hands off and the real content rises into place; an app that answers immediately skips the waiting state entirely. ### Changed - **Window title bars show three buttons.** Minimize, maximize and close are the only buttons at rest. The arranging menu — move left, move right, swap panes, leave split view — now opens with a right-click on the title bar, or from the keyboard: tabbing into the window's controls reveals its trigger. - **A window's starting state looks like one.** While an app loads, its window shows the app's icon with a progress ring and what it is doing, on a solid ground rather than a dimmed peek at a half-loaded page. If the app never gets there, the window says so after ten seconds and offers Reload — the same bargain the full-screen app page makes. ### Fixed - **Clicking a window no longer restarts the app inside it.** Bringing a window to the front reloaded whatever was running in it: an app lost its place, a half-written note went with it, and anything the app had put on screen disappeared. Which window is in front is remembered separately from where the windows are drawn now, so bringing one forward is only that. - **Restoring a window plays its motion again.** A window brought back from the rail popped in instantly instead of flying out of its icon, because the animation's starting position was never painted before the release was scheduled — both commits landed in the same frame. The restore now waits for a real paint, so it travels over the same 480 ms as the minimize. - **Windows work on an empty desk.** The work area was measured from the desk's content, so a desk with no widgets gave windows a short strip at the top of the screen: dragging downward stopped at its edge, and maximizing filled only the strip. The desk now fills the workspace whether or not the board has anything on it. - **Dragging no longer dies over the app inside the window.** Once the app had loaded, moving the pointer across its iframe handed the gesture to the frame and the window simply stopped following. The window's content stays out of the hit test while a drag or resize is active, so the gesture holds for its whole length. - **Short windows are accepted again.** The server rejected any window shorter than 240 px with a 422, so moves of a short window were never saved — the viewer allows windows down to 160 px tall, and the server now matches it per axis instead of using one minimum for both. - **Windows no longer wait forever on "Starting…".** A legacy app has no bridge to answer with, so the ready signal the window waited for could never arrive and the starting state stayed up over a fully loaded app. The window now waits only for what the app can actually send: the frame's own load event for a legacy app, the bridge's ready for an isolated one. - **Opening an app no longer flashes the app before its loading state.** A fast frame painted before the waiting state appeared, was covered, then shown again. The frame stays hidden until the app answers, and the loading state renders only once the wait has actually lasted a moment — a fast app opens straight into content, a slow one shows only the icon and the hairline in between. ## 0.1.18 - 2026-09-18 No additional release notes were provided. ## 0.1.17 - 2026-09-18 ### Added - **Themes: pick how Vela looks, or bring one somebody made.** Personalise gains a Theme row beside Wallpaper. Seven themes ship, each showing its own colours in the picker; choosing one changes the dashboard, every app window's title bar and the rail at once, with no reload, and it is still there after one. Light and dark are unchanged and stay in Settings — a theme decides what light and dark are made of, not which you are in. A theme may suggest a wallpaper; it never changes yours. Import a theme file and Vela shows you what it is and what it would change before applying any of it, keeps only colours, lengths, shadows and fonts from its own list, and tells you what it left out. A theme can never load anything from the internet, and Vela never goes looking for one. Export the theme you are using, edit it, bring it back. Imported themes and your choice are included in backups. - **Every theme Vela ships is checked for legibility, every time Vela is built.** Text stands out from the surface behind it, lines and marks stand out from the surfaces they sit on, and a theme that stopped doing either would not ship. One theme, Alto contraste, goes further than the rest. - **Every widget on your desk is drawn the same way.** Each card now leads with a small tinted icon and its name, and what it shows underneath follows one recipe whichever app it came from: a number, a bar, a ring, a chart or a list of rows. Health shows how many of its checks passed as a ring; Flows shows the week's automation runs as a chart; Backups shows how long until the next one. - **Apps can publish a chart or a table to the desk.** An app's widget may now declare `chart` — up to twenty-four numbers, drawn as bars with the most recent one strongest — or `keyvalue`, a list of label-and-value rows. Both are drawn by Vela from the JSON the app publishes, on the same card as a widget Vela wrote itself; no app code runs on your desk, as before. Manifest schema 0.5.0. Apps that use the four original layouts are unaffected. - **Text on the light theme is easier to read.** Muted captions and the marks that show what is running were below the contrast Vela promises, and now clear it. - **Vela now shows everything it is doing for you in one place.** An automation run, an agent desktop's task, an update, a backup, an app being installed and the health sweep are all listed the same way, in the same words. System gains an Activity section listing what needs you, what is running and what has just finished; the notification bell counts what is waiting on a person and lists it above the recent events; and the desk's "Needs you" widget shows it beside the apps that asked for you. All four read one list, so they cannot disagree. ### Changed - **Deleting an automation asks first.** "Delete permanently" in an automation's menu used to remove it and its history on the click, with no confirmation. It now asks, like removing an app or deleting a desktop. - **Signing out, removing an app, deleting a desktop, deleting a bot, deleting a conversation, clearing a log, resetting the desk and closing a window with unsaved work all ask in the same dialog.** Signing out used the browser's own prompt; the rest each had a dialog of their own. What they say is unchanged. - **For contributors: the dashboard's colour and spacing come from one place.** `web/src/styles/_tokens.scss` is generated from `web/src/design/theme.vela.json` and is no longer edited by hand; tonal ramps are derived in OKLCH on one shared lightness scale. No stylesheet outside it writes a colour, padding, gap and margin read a spacing scale, and a new ratchet guard keeps both true. Reduced motion is honoured from one rule rather than from fourteen. The pieces the dashboard is drawn with live in `web/src/components/ds/`. See `docs/DESIGN.md`. - **For contributors: four shared foundations in the dashboard.** The check command now runs ratchet guards over the source tree — style ownership, the browser-API boundary, the status vocabulary and inline styles — each against a committed baseline that may only shrink. `web/src/operations/` gives every kind of background work one shape and one status vocabulary. `useForm` and `useConfirm` own form state and confirmation. `web/src/storage.js` and `web/src/clipboard.js` are the only places that touch browser storage, the clipboard or `window.open`. Two concurrent identical GETs now share one request, which took one desk load in development from 43 requests to 25 while showing more than it did. See `docs/DEVELOPMENT.md` and `docs/TESTING.md`. - **For contributors and app developers: four shared foundations in the engine.** Routes now live in `vela/routers/`, one module per group, mounted from the ordered table in `vela/router_registry.py`; `vela/api.py` is the app factory and defines none of them. A service refuses a request by raising a typed error from `vela/errors_http.py`, which one handler renders, so no service module imports FastAPI to say no. Every process-lifetime loop is a `BackgroundLoop` or `BackgroundThread` from `vela/loop.py` with a name in one registry, an idempotent start, a bounded stop and errors that reach the log. `docs/API_SURFACE.md` is now the committed list of every route the engine serves: a route change regenerates it in the same commit. For app developers, every error body now carries `code` (a stable `group.reason` name for the refusal) and `status` alongside `detail`; `detail` is unchanged, so nothing that reads it needs to change. See `docs/DEVELOPMENT.md` and `docs/CONTRACT.md`. ### Fixed - **Release checks tolerate slower background scheduling.** Loop tests now wait for the ticks they verify instead of requiring several ticks within milliseconds. They still check recovery after errors, error logging and prompt shutdown, and clean up workers even when an assertion fails. This fixes the intermittent macOS test failure that blocked patch publication. - **The server download starts again.** The routers that serve the dashboard's API are now listed in one table and loaded by name, which the packaged build could not see, so a downloaded server exited at startup instead of coming up. The build now reads that same table, and a test fails if a new router is ever left out of a download. - **Copy buttons work on a server reached over plain HTTP.** "Copy link" on the phone-handoff and iOS install screens, and "Copy" on an Ask message, used the clipboard API, which browsers do not provide outside a secure context — so on a home-network server over HTTP they silently did nothing. They now fall back to selecting the text and copying it. - **A double-clicked Save sends one request.** A second click that arrived before the button could disable itself sent the form twice. - **Typing straight after picking a mention puts the words where you typed them.** In Ask, choosing an app or a bot from the `@` picker and then pressing Shift+Enter moved the caret back in front of the new line a moment later, so the rest of the message went above the break instead of below it. - **The rail says which app's page you are on again.** A pinned or running app's rail entry stopped carrying that mark for screen readers when it became a button that opens a window. ## 0.1.16 - 2026-09-18 No additional release notes were provided. ## 0.1.15 - 2026-09-18 No additional release notes were provided. ## 0.1.14 - 2026-09-17 No additional release notes were provided. ## 0.1.13 - 2026-09-16 No additional release notes were provided. ## 0.1.12 - 2026-09-16 No additional release notes were provided. ## 0.1.11 - 2026-09-16 ### Changed - **Bundled wallpapers download once instead of shipping in the installer.** Each of the eight painted wallpapers is now published as a single 4K master; the first start downloads the set (about 33 MB) and derives the desk and picker sizes on your own computer, keeping the installer and server bundle smaller while the dashboard still only ever reads the small derived files. Nothing to do on upgrade — an existing server fetches the set on its next start, and a start with no connection simply tries again later. - **The README reflects the current release.** Its badges now read the latest release, its date and the total download count from GitHub instead of a hand-typed version number, the Quick Start names the Marketplace, the ServerKit note no longer points at the `dev` branch, and windows on the desk and agent desktops get a short introduction with a link to their guide. - **Existing 0.1.x servers need one manual update.** The updater ships *in* this release, so a server running an earlier version cannot use it to get here. Download this release the way you installed Vela originally — the installer, the portable zip or the archive — and from then on Vela can update itself. - **Settings and app-state files keep a spare copy.** Each time Vela writes one it keeps the previous good version beside it, so a file that will no longer read can be put back from Settings → Health instead of falling back to defaults. Your desk is no longer one of these files — it lives with your desktops now and is covered by backups instead. - **Apps open in windows on your desk.** Opening an app — from the rail, All apps, a desk widget, search or a shortcut — now puts it in a window rather than filling the screen. It gets a title bar with three controls that do three different things: **minimize** puts it away and nothing else — the app keeps running and whatever you had typed is still there when you bring it back; **maximize** fills the desk; **close** is the only one that ends the window, and the only one that asks about unsaved work. Windows can be moved, resized and snapped to a half, they stay where you left them, and each desktop keeps its own. Opening an app that already has a window brings that window forward instead of opening a second copy of it. Some apps still open full screen, because a window is not the right answer for them: anything on a phone, an app that opens outside Vela, a connected site, and an app you have not installed yet. You can ask for the full-screen page for any app — right-click it in All apps and choose **Open full screen** — and a link straight to an app still opens it that way. - **Windows travel to and from the rail.** Minimizing shrinks the window into its icon in the rail and bringing it back reverses the same motion, so you can see where it went. Vela does not read an app's pixels to do this — a browser will not let this page do that, and weakening an app's sandbox for an animation would be trading a real boundary for a decoration — so the window itself moves, with the app still running inside it. Reduced motion skips it. - **The rail names what is open.** Windows on the desktop you are looking at appear in the rail under **Open**, showing which one is selected and which are minimized; clicking one brings it forward, and clicking the one you are in puts it away. Apps whose process is running without a window here appear separately under **Running**, and no app is listed in both. A window whose app was reinstalled says it needs reopening rather than pretending to still be connected. - **All apps opens over what you were doing.** The app grid used to be a page, so going to look for an app left the one you had open. It is now a layer over the current page: the app underneath stays exactly as it was, with whatever you had typed still in it, and Escape or the rail puts you back. The rail entry is called **All apps** now; Ctrl+Space (Cmd+Space) and the `/apps` link both still open it. - **The server log is readable again.** Vela no longer records a line for every request the dashboard makes, so its log holds what Vela did rather than thousands of routine polls. Both ways of starting Vela — the tray on Windows and `python -m vela` in a terminal — now write the same log, where before only the tray kept one, and it keeps five 2 MB files instead of three. - **The desk is a desktop now.** The search sits in the middle of the wallpaper where a launcher's does, and the buttons that used to crowd it moved into a **⋯** menu at the top-right and a **right-click** (long press on a phone) on the wallpaper: Add widget, Arrange desk, Personalise, and **Reset desk** to put a board back the way Vela ships it. Right-click a widget for its own quick menu — open its app, resize it, or remove it — without arranging the whole board. A fresh desk fills the screen with no bare gaps, and your apps show as a labelled icon grid with **Open all** leading to the Launchpad. The desk and the Launchpad no longer draw a blurred bar across the top of the wallpaper: the search, the notification bell and the **⋯** menu share one line at the top, and the page runs the full height behind them. - **Apps open in a real window.** An app you open now has its own title bar: a back arrow to where you came from, its name and whether it is running, and a **⋯** menu to pin it to the rail, add its widget to your desk, reach its settings, reload it, open it in a new tab, stop it or close it — no more second search box above the app. While an app is starting you see it over a dimmed background, and if it never answers Vela says so and offers to reload or stop it. Opening an app that is no longer installed leads back to the Marketplace. An app can ask (with `view.appearance`) for its title bar to stay dark so a dark app is not topped by a light strip. - **The Library is now the Marketplace.** One place — still at the same address — to find, install, update and remove apps, in three tabs. **Discover** shows the apps you do not have yet, led by a small featured row. **Installed** is everything on this computer, connected websites included, where you open an app to update or remove it. **Updates** gathers the apps with a newer release and can update them all at once. The separate Manage apps page is gone; its job lives in the Installed tab. - **The rail is yours to arrange.** It now shows the apps you pin plus whatever is open, instead of every app you have installed. Desk and the Launchpad stay at the top; below them are your pinned apps — Ask and the Marketplace to start — then the apps that are open but not pinned, then Settings. Right-click an app on the rail or in the Launchpad (or press and hold on a phone) to pin, unpin or reorder it. Vela's own tools — Ask, Automations, the Marketplace, Settings and System — are core apps now: they show in the Launchpad under **Vela**, they turn up in search, and they can be pinned like any app. The old **More** menu is gone. - **Promoting dev to main now builds the downloads first.** A pull request to `main` runs the release the way the release workflow will: it runs the release script and builds and smoke-tests the server on Windows, Linux and macOS, stopping short of tagging or uploading anything. Release breakage that used to surface only after a merge — a script that fails to start, a download missing for a runner's architecture — now shows on the promotion PR instead. Contributors working on `scripts/` should expect that PR to take longer than a routine `dev` check. ### Fixed - **The rail avatar draws properly.** Its stylesheet was never loaded, so the letter standing for whoever the server belongs to appeared unstyled. - **The wallpaper no longer disappears when you close All apps.** The desk and the All apps grid are on screen at the same time and both ask for the same picture; closing the grid cleared it for the desk underneath as well, leaving a plain background until something else happened to set it again. - **Apps installed by an older Vela can be opened in a window.** Installing an app records which installation of it this is, and windows are opened against that record — but apps that were already installed before Vela started keeping it had none, so a window could not be opened for them at all. Vela now gives every installed app that record when it starts. Nothing is reinstalled and no app data is touched; an app you removed is not brought back. ### Added - **Agent desktops are in the download.** A Vela download now carries the piece that drives an agent's browser, along with the record of which browser build it was made against and a checksum of its own code that Vela verifies before starting it. Two halves from different downloads are refused with a sentence about reinstalling rather than failing later in a way that looks like a bug in whatever the agent was doing. The browser itself is not in the download — it is a few hundred megabytes and lives in a cache shared with anything else that uses one. Vela says which command fetches it and will never download a browser while you are waiting for a task. - **Agent desktops tidy up after themselves, and say so.** Four things pile up while one works and they now have four stated lifetimes: a picture of a window lasts two minutes, a record that something happened lasts a day, a file lasts a week, and tasks last as long as you keep history. Vela sweeps what has expired when it starts and periodically after that. Turning off **Keep history** now reaches everything, not only the task list: the activity under each task goes with it. A backup covers your settings, your desktops and what your apps saved — it is not a copy of a browser session, so a sign-in a desktop was keeping, a file staged for a task and a picture of a window are all outside it. Restoring one stops every agent desktop first, drops every permission they held, and reports what was running as interrupted rather than resuming it. **Settings → Health** has three new checks — whether agent desktops can run here and against which browser, how much room their files are using with a button to clean up, and whether any browser is open for a desktop that is no longer an agent's. A support bundle now carries those numbers and nothing else about the feature: no task wording, no results, no websites you approved, no sign-in, no file and no picture of a window. - **Windows move the way they should.** Minimizing and restoring an agent's window now plays a short warp toward its entry in the rail — 480 milliseconds, the same in both directions, and it narrows toward the icon rather than sliding as a rectangle. It happens where Vela actually has a picture of the window to move, which means a window the agent's own browser is rendering. An ordinary app on your own desktop runs in a frame this page is not allowed to read the pixels of; that is a browser rule, not a missing feature, and Vela will not ask for screen recording or weaken an app's isolation to get around it for an animation — those windows minimize immediately instead. Ask your system for reduced motion and there is no warp at all. Either way it is decoration over a decision that has already happened: minimizing a window never pauses a task, ends a session or stops an agent, and the window goes where you put it whether or not anything was drawn. A picture of the agent's screen that has gone stale now says how old it is, and Stop never depended on that stream. - **Two windows side by side, and everything a drag does without one.** Drag a window's title bar to the left or right edge and Vela shows the half it would take; let go and it goes there. The other half either keeps the window it had or becomes a clearly empty pane that offers to be filled — it never quietly shows the same window twice, and closing or minimizing one member leaves its slot there so the window can come back into it. The divider between the panes can be dragged, moved with the arrow keys, sent back to equal halves with Home or a double-click, and it announces where it is to a screen reader. A **⋯** menu on every title bar does the same things a drag does — move left, move right, swap the panes, even them up, leave split view — so none of this needs a pointer. Dragging an app onto the desk still makes a widget of it, and dragging one into a task's box now names it for that task. What travels is the app's identity and nothing else: no install happens, nothing is submitted, and what the desktop is allowed to use does not change. There is a **Mention an app** picker beside the Start button for anyone not dragging. - **Two desktops can work at once, and a queue stops when something goes wrong.** Vela runs two agent desktops at a time on one computer; a third is refused with a sentence, and a task waiting for one of the two says it is waiting instead of showing *Starting* for ten minutes. Each desktop keeps its own queue, its own limits and its own window in front, and nothing one does reaches the other. A task that failed, was interrupted or sent something nobody could confirm now **holds** the rest of that desktop's queue and says why, rather than starting the next one on top of it. **Carry on** releases it, and so does giving the desktop something new to do. A result that did not succeed says how far it actually got — the last step there is a receipt for. **Try again** queues the same instruction as a new task. It is never the old one carrying on: what that one did, it did. A desktop with something unaccounted for will not repeat it until you say you have checked. Updating, removing or upgrading an app now takes its authority with it. Every permission an agent desktop held against that app is dropped and any question waiting about it can no longer be answered, so an approval reviewed against one version of an app can never apply to another. - **An agent desktop can use a website, and bring a file back.** Approving a site is two decisions now, so the setup asks two questions. **Reading only** is the default: it can browse, and signing in, sending a form or anything else that would change something there stops and asks you to take over. **Ask me before it sends anything** holds the request before it leaves your computer and shows you what it is — the address, the method and the *names* of the fields, never the values, because a prompt gets screenshotted. Saying yes allows that exact request and nothing else. Requests Vela cannot describe honestly are not offered as a question at all; they ask for a person. Signing in is yours. Vela will not attempt one and will not try to get past a challenge meant to tell people from programs — it stops, says so, and hands you the window. A desktop forgets website sign-ins when its browser closes unless you turn on keeping them, and what is kept belongs to that desktop alone: two agent desktops are never signed in as each other, your own browser's profile is never read, and **Erase** clears both the file and the browser that is open. Files go through your own picker. The agent is told which files exist and can attach one to a page that asks for one; there is no tool that takes a path, so there is nothing to point elsewhere. Anything it downloads from an approved site appears in the same list with where it came from. Up to 25 MB for a file you add, 100 MB for a download and 250 MB for one task, shown before a transfer rather than discovered by one failing. A file is stored under a name Vela generated, nothing is extracted and nothing is run. **If something was sent and no answer came back, Vela says so.** The task ends with *Outcome unknown*, the Files panel shows what went out, and nothing sends it again until you say you have checked. One honest limit: when a connection dies before any reply, the browser itself may resend below anything Vela can intercept, so the site may have received it more than once — which is exactly why checking is a person's job and not a retry. See [agent desktops](docs/AGENT-DESKTOPS.md). - **Watch what the agent is doing, and take the keyboard when you want it.** The Agent window shows the actual screen the agent is working on. Watching is watching: clicking the picture does nothing. **Take over** stops the agent first, then hands you the window — your clicks and keys go to it, and the task stays paused until you say carry on, even after you give control back. Only one person can be typing at a time, and anyone else watching can see who it is. When the agent does carry on, it looks at the screen again before doing anything, so it sees what you changed. Closing the tab does not hand the keyboard to the agent; control simply times out. Pause holds a task where it is, Stop ends it — and neither pretends to undo something that already happened. Vela never reads your clipboard. - **Set up a desktop that works for you, and watch it.** The rail's desktop menu has an Agent button on every desktop. On one that is still yours it opens a short setup — which model, which apps, which websites, and whether changes ask first — and it will not let you start a desktop that could not work: a missing model server or a model that cannot operate an app is said plainly, next to the choice, before you commit to anything. Asking before changes is the default, and the other option allows only the actions you pick. Afterwards the same window is where you give it work. It shows what is being worked on, how long it has actually been working, what is queued behind it and what came of earlier tasks, with Pause, Carry on and Stop. A change that needs you appears here as a card saying what would change, with Allow, No, and Allow for an hour — and this window is the only place that can answer it. Every result says whether anything was really changed, read from what happened rather than from how the task described it. Desktops working in the background show a mark on the rail, so you can see that Desktop 2 needs you while you are on Desktop 1. If you have notifications set up, Vela sends one line when a task finishes or needs you — not one per click — and nothing at all for a task you stopped yourself. There is a new switch for it beside the others. - **A desktop can carry out a task while you do something else.** Give an agent desktop an instruction and Vela works on it on the server: you can close the dashboard, switch to another desktop or shut the browser, and the task carries on. It runs inside the limits the desktop's settings give it — how many steps, how long, how many times it may ask the model — and when it reaches one it stops and says which. Time spent waiting for you to approve something is not charged against it. Pause, resume and stop are yours; stopping ends what has not happened yet and never pretends to undo what has. What a task reports is checked against what it actually did. A summary that claims a change with nothing to show for it is refused, and every result records whether anything really changed — read from the receipts, not from the wording. Vela never restarts a task by itself: if the server stops mid-task it says the task was interrupted and leaves anything queued for you to start. **Not every model can do this.** A task needs a model that supports tool calling, and Vela checks before opening anything rather than failing halfway through. Beyond that, models differ a great deal in whether they can actually work an app, and a bigger model is not automatically better at it. See [evaluating a model](docs/DEVELOPMENT.md#evaluating-a-model). - **A change can wait for you to say yes.** When an app running on an agent's desktop tries to save something the desktop was not already allowed to save, the change becomes a question rather than a failure. Nothing is written while it is open, the question says in plain language what would change — and describes a password-like field rather than repeating it — and saying yes approves that exact change and no other. Say no, close the window, change the desktop's permissions or stop the task, and a click arriving afterwards does nothing at all. Questions expire on their own, and no amount of asking for more time pushes that past twenty minutes. Apps are not left hanging while you decide. An app that loads Vela's own SDK waits as long as the question does; one that bundles an older copy is told straight away that it cannot wait, so you can make the change yourself in the window instead. Your own clicks are unaffected: using your own computer has never needed anyone's approval and still does not. - **App developers: label your controls and declare your actions.** Vela is building desktops an agent can work in, and the parts that read and operate an app's window now exist. An app is found by the accessible name of its controls — `aria-label`, a real `