Alelyon app 0.9.0, the patch notes.

Alelyon app 0.9.0 29 October 2026

• My page, Privacy: The open network. Whether your page is on the open network that Bluesky and other apps share, and under which handle; join or leave it, each after a second press that says what it means. Shown only while Alelyon has the open network switched on.
• The developer console sets a time against the one before fairly. The time before is read at the finest step kept for it (a month back, by the day, where it was refused), its counts weighed to the time the window's own points hold, and its routes and callers scaled the same way: read whole, the 30 days before the past 30, by the day, would hold 31, and the 15 minutes before the past 15 half a minute more than the window on average.
• A time before read coarser than the window is drawn on the charts too, and said ("daily").
• alelyon-cli cloud: run Lattice's background agent in Alelyon's cloud on a folder you send (start, list, show, events --follow, answer, message, stop, changes, apply --yes, delete), and the MCP tools cloud_start through cloud_apply, with a developer token that has the cloud:tasks scope. Off until the cloud workspace is deployed.
• Cloud tasks: the folder sent, the changes brought back (never outside the folder) and the cloud's answers are read in one place, the identity client's cloud module, which the app and alelyon-cli share; a runner address must be on the cloud's own origin. alelyon-cli cloud month and the MCP tool cloud_month show the month's cloud time against its cap. A followed task outlives the cloud's ten-minute access token: the CLI asks for a new one and repeats the call, and the app is told to reconnect rather than that it is signed out. Lattice can say which other process (the app, or the host beside it) has a conversation at work, without its address or key.
• Atlas gains its first panel, Versions. In a project it shows the next version and when it is made, the notes waiting (each one's words and kind can be changed, and notes added), the versions made with the command that pushes each, and the project's settings: days, end of day, branch, writing CHANGELOG.md and the tag, own numbering, next number, versions off or on word. "Make it now" and "Skip today" act at once. At Home it lists every project's next version. Its step makes each project's version once its day has ended, whether or not the panel is open. It shows once Atlas's layout lands.
• The developer console opens with a glance: a verdict (Healthy, Worth a look, Trouble or Quiet), what the charts show in a few sentences, and what to do, each step leading to where it is done, in the app or on the website.
• Behind each error or latency spike it reads the calls that made it and names the answer, route, key or app they mostly had; behind a drop or a surge, the routes and the keys and apps that moved. Both are read after the rest is drawn.
• The glance is the website console's, computed by the same shared core and held to it case by case.
• The developer console comes to the app, on the Account page until Atlas's layout places it in the bottom region: your account's API calls as Alelyon measured them, over a range you choose (a preset, earlier or later, zoomed out, or a stretch dragged across a chart), narrowed to a kind of call, a route or a key or app.
• Its figures: the calls, the share refused or failed, how fast (p50, p95, p99) and Apdex at a target you pick, each against the time before. Its charts: calls a step by how they ended, and latency, set against the time before or the same time a week before, with one cursor across both.
• What changed: error and latency spikes, quiet stretches, a drop or a surge, and the keys and apps that stopped or started calling, each with a closer look and its own calls; refusals that began after a key change name it.
• The routes and the keys and apps, sortable, with their share of the calls and Copy as CSV; the calls themselves (failed, refused, slow or all) with each request id to copy; a request found by its id; and your monitors.
• Without telemetry it reads your keys' log (keys' calls by day for 30 days) and says so. The figures are the website console's, computed by the same shared core and held to it case by case.
• Pages: writing tools for articles. Over an article's words, the tools put in what each says, with its shortcut under the pointer: Heading (Ctrl+Alt+2, Ctrl+Alt+3), Bold (Ctrl+B), Italic (Ctrl+I), Bulleted list (Ctrl+Shift+8), Numbered list (Ctrl+Shift+7), Quote (Ctrl+Shift+9), Code (Ctrl+E, or a block with Ctrl+Alt+C), Link (Ctrl+K) and Divider. Pressed again on what carries it, a tool takes it off.
• A preview beside the words shows the article as readers will see it. While an article is written, the column takes the rail's room so both fit; in a narrower window, Write and Preview take turns.
• An article written so is drawn with its headings, lists, quotes, code and dividers where it is opened. A feed shows its opening as plain words, then "Read the article".
• A link with words opens through the link check. Words that name another site than the one it opens show its address instead.
• Older articles look as they always did.
• Pages: up to 10 photos in an article (a post still takes 4). A photo added while you write an article is placed where you are writing, on a line of its own (``): write a caption between its brackets, or move the line to move the photo. Removing a photo takes its line out, and the photos after it keep their places in the text.
• Where an article is opened, each placed photo shows there, across the column, with its caption under it; photos it does not place follow the text. The preview shows placed photos as readers will see them.
• In a feed, an article shows its cover above its opening: the first photo it places, else its first photo.
• Pages: switching a post to an article, or quoting a post, turns off a poll you were adding, because an article or a quote carries none. Its options stay typed in case you switch back to a post. Before, a poll left on there blocked the Post button ("A poll needs at least two options") and kept photos off, even though the poll would never be sent.
• Agent Playground takes Fleet's place on the rail: Fleet's sessions and Lattice's runs, models and delivery in one place. Its Overview sets both dashboards side by side, Fleet in teal and Lattice in violet, with what needs a look first and their trends; Fleet and Lattice each open in full from its bar. Lattice's dashboard lives here now: Atlas opens on the chat and the IDE, and its back button returns to the Playground.
• In Atlas the chat is part of the dock rather than a column of its own: with nothing else open it fills the dock; a page, a file or any other tab opened fills the dock and the chat keeps its column on the right, as a chat sits beside VS Code's editor. Drag the border between them to widen the chat. Beside the board and the tasks it is as before.
• In Atlas the dock splits into as many as four panes side by side, each showing a tab of its own: task threads' chats, files and pages alike, so several threads can be followed and answered at once beside the chat. Ctrl+\ (or ◫ in the tab bar, on any tab) puts the next tab beside the one in use; a pane's head names it and closes it, its tab staying open; with the dock split, Ctrl+1 to Ctrl+4 choose a pane.
• Atlas reaches the whole app without leaving the chat, as VS Code's activity bar reaches its views. In Atlas, a press on a place of the rail (Home, Agent Playground, Sinai, Pages, Research, Marketing, Account) fills Atlas's side bar with that place's pages instead of leaving the chat, and a second press closes it; Agent Playground's lists its agents' pages, delivery's (merge requests, pipelines, the merge train, releases, versions) and its models'. A page opens as a tab beside the chat, in the editor's area: an app page (Research, Marketing, Data...), one of Lattice's views (agent runs, models, the merge train...) or a panel (Versions, the developer console). A page beside the chat keeps its live updates, reads what it shows as it opens, and lays its parts out at the width it has there; two can sit side by side in a split. Each place's side view has a way to its own page, and on any other page the rail goes there as before. The command palette opens any page beside the chat ("Open Research beside the chat"), and a gear at the foot of Atlas's activity bar opens Settings.
• Versions and the developer console now open beside the chat from the bar along the window's bottom, as pages in Atlas's dock, instead of across the top of the chat or along the page's foot.
• Atlas has one activity bar, as VS Code does: the folder's files (the Explorer) head it, then Atlas's own views (Work, Search, Chats, Changes, Structure, Debug, Tools), then the app's places (Home, Agent Playground, Sinai, Pages, Research, Marketing, Account), with friends, the account, the speech engine and Settings at its foot. The rail and Atlas's own bar no longer stand side by side; on every other page the rail is as it was. Changes and Chats show how many wait for you.
• In Atlas's Groups and topics, a session shown under a thread that is not open (one working, or waiting on you) opens its thread and then its page when pressed, where what it asks is answered. It drew nothing before.
• In Atlas a session's page (how it is doing, its steps, what it did, what waits for you, and the box that guides it) opens in a tab of its own beside the chat, which keeps its task thread's channel. Another session pressed shows in the same tab; closing it, or going back to the channel, leaves the session.
• In Atlas, Settings open beside the chat, as a tab in the dock where VS Code opens its own, instead of over the window: from the gear at the foot of Atlas's activity bar, the account menu's Settings, the command palette's Settings entries, or the Account place's side view. They keep a part and a search of their own, list their parts along the top when the dock is narrow, and point to the Tools view, where the chat's own MCP servers, extensions, plugins, skills and hooks are set. On every other page Settings open over the window as before.
• An agent can see which parts Settings have (never what they hold) and open Settings beside the chat for the person.
• Atlas: the rail reads Home, Atlas (the chat and the IDE), Fleet, Sinai, Pages, Research, Marketing and Account (Ctrl+1 to Ctrl+8); Trust is under Account. A feature's panel opens over the top of the session thread's chat (the chat keeps its place under it, the IDE stays at the side) or along the page's foot, kept per project, from the bar along the bottom of every page, which also holds Friends. The chat's tool wheel is gone: its tools are buttons in the chat's header, one per layer, each opening its list.
• In Atlas the IDE's status line and the bar along the bottom of the window are one line, as VS Code has one status bar: Versions and Console first, then the terminal's button and the folder, and the friends' toggle at the right end. The title bar has a command centre in its middle: a press opens the palette, where every command, page and setting is found, Go to file among them. The activity bar keeps its views and places.
• In Atlas a task thread can sit beside the chat in a tab of its own: press ◫ on a thread in Groups and topics. The tab shows the thread's channel as it happens (its questions, approvals, decisions and finished sessions) and has a box of its own: a message typed there goes to the thread, to the topic it belongs to, as the chat's own box sends it.
• In Atlas's Groups and topics, a task thread that works or waits on you shows the sessions that do under it without being opened, and a session waiting on you says what it asks, under it: a press opens its page, where it is answered. A thread whose steps are all done says so. ◫ on a thread puts it side by side with the dock's other tabs, in a pane of its own, while there is room for one.
• Home's Projects has Chat without a project: a new chat in Atlas that belongs to no project (no folder, instructions or model of a project's). Home's links to chats say Atlas, where they open.
• alelyon-cli together leave takes paths: [...], releasing only those files (the ones a change that landed held) and keeping the rest.
• Working together: colours are a team's hue and a member's shade. Agents in one task thread share its hue, each in its own shade; another thread takes another hue; an agent in no thread is its own team; you keep your own hue. Seen from another team, a collaborator shows the hue only.
• alelyon-cli together: work together in one tree from a terminal or an agent's MCP client (where, enter, leave, pin, note, notes, answer, reply, news, and the together_* MCP tools), in the store Alelyon keeps on this computer for a repository and every worktree of it. Needs neither a token nor the app.
• Account: Open in Atlas, beside the developer console, opens the same console in Atlas's band along the foot of the page, which each project keeps open as you work.
• The developer console in the app now has service accounts: the non-human members of the organizations you own or administer, each with its own keys and its own console. Make one, give it keys (each key's secret is shown once, until you say you have it, with a copy button), revoke a key, make it an admin or a member, see each organization's calls by service account, and remove one by typing its name to be sure.
• Work in a service account to see its own console, as you would a project in another cloud's console. A picker at the top of the console switches between your account and your service accounts, and a line says whose console it is, with the way back.
• Incoming changes in the editor: a change another session waits to land through the merge train that touches the file you have open is pinned to the lines it changes, with a thin band in the margin in its team's colour and a card saying whose change it is, what it is called and how far it has come in the train. Collaborators' names in the editor now carry their team's name.
• Working together in the editor: a dot beside each file someone else is in, in their team's colour (a task thread's agents share its hue, each in its own shade); a Here line in the file's bar naming who; a band in the margin over the lines a collaborator's note is pinned to, in its author's colour; and its card at the editor's top right, answered with Done, Decline (with why) or Ask back. The editor's first unsaved change enters the file, and a save or a close leaves it.
• File operations in the IDE's Explorer: right-click a file or folder for New file, New folder, Rename (typing another folder moves it; open tabs follow) and To trash, which moves it into Lattice's own trash rather than deleting it, with Restore offered after. Nothing is ever written over, nothing leaves the folder, a file open with unsaved edits is not trashed, and an authority file (Cargo.toml, scripts, CI) asks to be confirmed.
• Home's Needs you answers what waits on you without opening anything: approve or refuse what a session asks to do, and answer its questions in your own words or with one of the options it offers (Lattice starts first when it is not running). A session's overview answers the same way, and friend requests wait there too, to accept or decline.
• Alelyon opens on Home every time, whichever page you left it on. Each page still keeps its own place: Lattice's folder, tab and panes, the window's size.
• A large Topic map no longer freezes the window. Its layout now settles in the background: the map shows its topics at once and they glide into place, instead of the app showing "Not responding" while it worked out every position. With many agent sessions this could stop the app opening at all, stuck on "Signing you in…".
• An invite to work on a friend's project together waits in Home's Needs you, with everything else that waits on you, to accept or decline there; what came of an answer shows under it.
• What Sinai holds for your answer waits at the top of Home's Needs you, worded in full as on the Sinai page: allow it, allow a click at another point, or refuse it before its time runs out.
• Home has a Together part: the projects you work on with friends. It shows the invites to answer, the projects shared with you and the people in each, your own projects to share, and friends' projects open to join. On a project of yours you invite a friend, take someone out, and make it public, and open to your friends to join. On a friend's project you leave. Declining, leaving and taking someone out each ask for a second press. Friends only, for now.
• Signed in, your projects are kept on your account as you make, bring in or save them. The account gets each one's name and what its scan found: its description, languages, stack, licence and number of files. It never gets the project's files, paths, commands or the instructions its chats are given. Archiving a project here takes it off your account, unless others are in it. A project's card says when it is on your account. For now, the same folder brought in on two computers is two projects on your account.
• In a project with a merge train, the changes that wait for your Approve wait on its Home too, each saying why (the Tier 3 areas it touches, or its session's word), approved there; its name opens it on the Merge train page.
• The IDE's completion list: Ctrl+Space, or typing . or ::, shows the language server's entries under the cursor, each with what it is and its signature; typing narrows it, Up and Down pick, Enter or Tab take one (a snippet's placeholders as plain words), Esc or leaving the word puts it away. The model's grey inline suggestions stay on Tab when no list is open.
• Extensions now add to the editor, not only list: their tasks join Run and debug's (after the folder's own), their snippets the completion list (Ctrl+Space) in a file of their language, with or without a language server, their themes Settings > Appearance's (choosing one takes its theme and colours as yours), and their keys the actions' defaults (a key you chose for an action stays yours alone). What an extension names that cannot be used, such as a theme file Lattice cannot read or a key for no action, is said under Extensions.
• The IDE watches its open files on disk: when an agent or another program changes one, a tab with no unsaved edits takes the new text at once, its cursor where it was (Undo goes back to what it had); a tab with unsaved edits keeps them and says the file changed on disk, Reload taking what is there.
• The IDE renames, formats and fixes through the file's language server: F2 renames what is under the cursor everywhere it is used, Shift+Alt+F formats the file, and Ctrl+. lists the quick fixes for the line. Every change goes through the editor, one undo step per file; a file it touches that is not open opens with the change, unsaved, to look over and save. A fix the server would carry out with a command of its own is named, not run.
• Tasks in Run and debug: the folder's .vscode/tasks.json, cargo build, test, run and clippy, package.json's scripts, pytest, dotnet build, test and run, and go build and test, each run with a press in a terminal of its own opened in the folder. Ctrl+Shift+B runs the build task.
• Two editors side by side: Ctrl+\ (or the tab bar's split button) puts the next open file beside the one on show. Clicking or typing in a pane gives it the keyboard, an accent line marks which, a tab picked opens in that pane, and the panes keep their places; Ctrl+\ again, or closing either file, goes back to one.
• Go to a symbol anywhere in the folder: in Go to file (Ctrl+P) type # and part of a name, or press Ctrl+T, and every running language server lists the functions, types and fields that fit, with their file and line; Enter opens the one chosen there.
• The Merge train's departure board no longer calls a change on time or late before it has a schedule. A change waiting for the next train says so. A train out is late only against the schedule its train set when it boarded: the time its own checks should take. Against an older train's first rough estimate, the board says how much later or sooner a change is due than first estimated, and the map marks no delay.
• On the railway's map, a train on its way in no longer covers the name of the station it left.
• On the Merge train's map, a station's name no longer sits under a train, under a train's badge ("+5" late, "2 to pick"), over a station's dot or ring, over main, or over another name. It moves to the first clear place near its station, never nearer another station, and off the lines where it can. On a narrow map where a station's trains leave no clear place, its name is left off until they move on; pointing at the station still names it.
• Lattice's Merge train page draws the train as a railway. Main is the central station; each part of the repository is a line out from it and each of its areas a station. Each change in line is a train at its platform, and those aboard the train being verified run in toward main as its estimate passes. A train held for your word waits at a red signal, one sent back is crossed out, and one set aside waits on a siding. Point at a train or a station for more, or press a train to light every station it touches.
• Beside the map, a departure board lists each change by when it is due on main: on time, early, or late against its first estimate, held at a signal, on the siding, or cancelled with what sent it back. It also shows the train out now, its checks done and those still to finish. Under it, the arrivals list the trains that ran, what each carried and how each ended.
• It reads the pulse the train writes every 15 seconds and redraws when a new one comes. When the pulse stops coming, the page says how old it is. The page's tile shows a small map, the next change due on main, and how many are late, held or sent back.
• Lattice's sidebar is a tree, as Claude Code's is: each task thread with its sessions' count, its sessions under it each with a mark (working, waiting for you, done). The task thread is the one chat: pressing a session opens its page (how it is doing, its steps, what it did last, what it spent, what it changed and ran, its questions to answer) with a small box to guide it, never a chat of its own.
• When the train's verify fails with a change's picks, Conflicts to pick says so and takes picks again. Change a pick, or press Accept again on one already made. Once every hunk is picked and one pick is newer than the failure, the change boards the next train, and that train's verify checks the new picks.
• Lattice's Merge train page shows the conflicts the train could not settle by itself, above the railway. For each hunk it shows the lines on main (current), in the change (incoming) and both together, main's first, beside the lines before it and the lines both sides began from. Press Accept current, Accept incoming or Accept both; a file one side deleted keeps one side's file whole. A pick shows at once and can be taken back until a train takes it. Once every hunk is picked, the change boards the next train, and that train's verify checks the picks.
• On the departure board, a change with conflicts says how many hunks still wait for a pick and which files they are in. On the map, it waits at its platform with the count beside it. The page's tile counts the hunks to pick too.
• The Topic map no longer freezes the window when it has nothing to show: no topics yet, or a filter such as Waiting that keeps none.
• The CRM grows into a full one: tags, saved list views, sorting and filters by owner, source and tag, a search across every kind, changes to many records at once, duplicates found before they are made and merged after, each record's history of changes, email templates, a richer Home (forecast, win rate, what closes this month, leads by source, the week's activity) and tasks grouped by when they are due.
• The CRM sends email from your own iCloud Mail, Gmail or Outlook mailbox and logs each message on its record; its Home chooses which Pages events add people as leads; Pages, My page, Privacy lets you turn off being added to others' CRMs automatically.
• Marketing becomes a CRM: leads, contacts, companies and deals with their activities, kept on the account, your own or an organization's shared one; Home with pipeline, won this month, open leads and tasks; a deal board; lead conversion; CSV import and export; Add to my CRM on Pages people and organizations. Products and plans move under Campaigns.
• A maximised window lays its pages out at its full size. Until now they laid out for the size the window had before it was maximised, with fewer columns than fit.
• Names that were plain text now open what they name: a merge request's and a job's addresses on the host open in your browser, a train run's pull request number opens it, and a flaky test's file opens in the editor.
• The developer console's note that service accounts need an organization comes with an Open Pages button.
• While you are in another window, Alelyon tells you of each new thing that waits on you, as it does when a session needs you: an act Sinai holds for your answer, a change in the merge train that waits for your Approve, a friend request, or an invite to a friend's project. Your phones hear of Sinai's acts and the train's changes too, when phone notices are on.
• Links in the agent's answers work: a file path opens the file in the editor at its line (`src/app.rs:42`, `#L42`, a `file:` address), a web address opens in your browser, and a link to anything else says Alelyon cannot open it.
• Back: when something you open takes you to another page, a Back bar returns you to where you were, and Alt+Left does the same. The bar goes once you move on by yourself.
• Every tab Atlas opens in full (the map, the runs, a merge request) has a way back to the chat, beside the way back to Agent Playground.
• A file handed to the editor with a line, such as a check's failing line in your project, now opens in the editor at that line instead of a read-only copy.
• The command palette also finds the changes in the merge train's line, by their number, name or branch: one opens the Merge train page with it picked on the railway.
• It finds your versions too: each project's next version and the versions made open the Versions panel. Opening a panel from the palette keeps the way back (Alt+Left).
• The command palette (Ctrl+Shift+P) finds things as well as places: every project's sessions, the people, organizations and posts Pages has read, the CRM's leads, contacts, companies and deals, and the research subjects. Each opens where it lives, and Back (Alt+Left) returns you.
• Words the palette lists nothing for can be looked for from it: on Pages (a person by @name, an organization by its ticker, a hashtag, or a search), and in the papers of the research subject chosen.
• The rail counts what waits on you, on every page: Home the whole of Needs you across projects, Atlas the sessions that wait on you, and Sinai the actions it holds for your answer, so nothing waits unseen.
• A verification receipt's id is a link: on Home, a session's receipts open their row in the relay's receipts on the Data page, narrowed to that receipt, and Back returns you.
• On Home, a session's largest changed files open in the editor with a press; a file the session deleted stays plain text.
• Everything in the window can be drawn Small, Medium or Large: its text, its icons and the space between them, together. Choose in Settings > Appearance, or from the command palette ("Size: Small"); the window changes at once and keeps the choice. Medium, a tenth smaller than before, is where a new window starts; Large is the size the window was drawn at until now. The window stays as large on the screen: drawn smaller, it has room for more.
• The agent reads code as the editor does, in a folder you trust. It can ask the language server for a file's errors and warnings, where a name is defined, every place it is used, what it is (type and documentation), a file's outline and the folder's symbols by name. In Agent mode it can rename a name everywhere the server refactors it, each changed file staged for your review.
• After the agent edits a file, the errors and warnings the language server finds in it come back to the agent with the edit, once a server runs for that language.
• The agent in Atlas's chat reaches the same places you do. Its new tools list your places and their pages (app_places), read what a page shows now, as its figures or its text (app_page), and open a page beside the chat for you to see (app_show); none of them changes anything you keep. What a page tells it is framed as data, with keys it recognizes hidden. A page that tells agents nothing yet says so. Your own agent outside Alelyon (through alelyon-cli) has the same three, behind the bridge's yes as before.
• An agent in Atlas's chat, or one outside the app, reads what Home, Data, Marketing and Account show (`app_page`): Home's projects, the topics the agents work on with what each waits on, and what is scheduled; Data's stores, and the open store's tables, rows and columns (a column whose name says it holds a secret is left out, and a private store's tables are not listed); Marketing's products and their pieces (never the CRM's contacts); and whether someone is signed in and their plan (never the account's address). A page that has read nothing yet says so, and opening it beside the chat reads it.
• Extensions, in Settings > Extensions: a folder with an extension.json that adds file types, language servers and debuggers to the editor, each run from the extension's own folder. Add one from its folder; while it is on, its servers and debuggers are offered for its languages, in the editor and to the agent in a trusted folder, and switching it off takes them away. Its tasks, snippets, themes and keys are listed but not used yet. VS Code's own extensions are not loaded.