Localix Terminal 0.1.7

Added

• An end-to-end run (scripts/e2e.sh): this tree's app is started beside the person's and
  used as a person and an agent use it, in dark and in light; each step is checked, and each
  scene is pictured. The README's pictures are its output, of a demo project.
• LLXTERM_RUNTIME names the directory of an app's lock and socket: an app given one runs
  apart from the person's, and leaves their setup (the command's link, the agents' entries)
  alone.
• The Store. A tab (⇧⌘S, the "+" menu, open with kind: "store") that lists plugins,
  skills and MCP servers for coding agents: the Claude Code and Codex plugin marketplaces, Agent
  Skills and the MCP Registry, read when the Store is opened and at most once an hour, kept in
  an index of its own and searched on the Mac as you type. A listing is installed into Claude
  Code, Codex, Gemini CLI, GitHub Copilot or OpenCode, each agent shown with where it stands
  (not found, installed, a newer one listed). Before anything is written or run the Store says
  what the install would do and asks for what the listing needs, in the window's own dialog;
  a skill is copied, an MCP
  server becomes an entry of the agent's own configuration, a plugin is installed by the
  agent's own program. Installed and Updates list what the Store put in place, and it removes
  only that. Its rows of tabs, of categories and of a listing's facts scroll sideways when
  they do not fit, as the window's row of documents does, with an edge that fades where there
  is more.
• Agents use the Store through window. store searches and reads listings; install
  shows the person what it would do and waits for their answer. Nothing is installed on an
  agent's word, and only the person removes.

Changed

• The project is Localix Terminal, the terminal for you and your coding agents. The README,
  the landing page and the package's description say what it is: a terminal whose sessions
  belong to a project and come back as you left them, where Claude Code, Codex or any CLI agent
  runs as it ships, with the browser, the board and the Store beside it.
• The app is Localix Terminal and its command is llxterm. The repository is
  localixai/localix-terminal, the bundle is io.github.rsaryev.localix-terminal, the plugin and
  the MCP server are llxterm, the skills are llxterm:window, llxterm:board and
  llxterm:end, and the variables a terminal is given start with LLXTERM_. The data and
  settings live in ~/.local/share/llxterm and ~/.config/llxterm. A release's archives are
  Localix-Terminal-macos.zip, Localix-Terminal-macos.dmg and
  llxterm-x86_64-unknown-linux-gnu.tar.gz.
• LLX Desk is now Localix Terminal, and what you had comes with it. LLX Desk 0.1.6 updates
  to this release as it would to any other, and the first time Localix Terminal starts it takes
  over what LLX Desk kept: your projects, sessions, boards and settings move from
  ~/.local/share/llx-desk and ~/.config/llx-desk to ~/.local/share/llxterm and
  ~/.config/llxterm, and the database takes its new name. Nothing is copied or deleted on the
  way: what cannot be moved stays where it was, and app.log says what was done. A folder you
  chose with LLX_DESK_DATA or LLX_DESK_HOME is still used, and stays where you put it, until
  you set LLXTERM_DATA or LLXTERM_HOME.
• On macOS the app takes its new name. An LLX Desk.app that the update replaced renames
  itself Localix Terminal.app, in the same folder, and opens again from there, once. It keeps
  its old name, and runs as before, where another Localix Terminal.app is already beside it
  or the folder cannot be written to.
• Your agents' LLX Desk entries are replaced by Localix Terminal's. The llx-desk server
  in Codex, Gemini CLI, GitHub Copilot, OpenCode and Hermes, the llx-desk plugin and
  marketplace in Claude Code, the llx-desk command in ~/.local/bin and, on Linux, the LLX
  Desk desktop entry are taken out once, and the llxterm ones are put in, as before. Only
  what runs the old LLX Desk program, now gone, or this app is taken out; an LLX Desk you kept
  installed elsewhere is left alone, and an agent you said no to stays declined.
• The window is dark by default. It followed the system's appearance until the theme was
  chosen; Settings → Appearance still offers System and Light, and a theme already chosen stays.
• A kind of tab that draws itself is one description. The window, the "+" menu, the
  shortcuts, the tool's schema and the ledger read a kind's name, key, picture and fields from
  the kind itself (kind.rs), so a new kind is added in one place.

Fixed

• A fetch keeps to its size limit with any curl. Before curl 8.4, --max-filesize is
  skipped for an answer whose size is not told first (a file:// URL, a chunked answer), so a
  Store index larger than allowed was read whole. The answer's length is now checked too.
• The window opens though the project used last is gone. With that project's folder deleted
  (or on a disk not attached), the app started in the background showed no window when it was
  opened again, from the Dock or with open -a, and said nothing. It now opens with the last
  project whose folder is there, else Home.
• The app's warnings are written to its log (app.log): they were said to no one.
• A terminal's colours are read on the window's ground. A program that picks colours for a
  dark terminal (a yellow, a pale grey) was faint in the light theme; each colour now keeps a
  contrast of 4.5 to 1 with the ground.
• The Store's tiles follow the theme: light ones in the light theme, where they were dark.

Download

• macOS 12+, Apple silicon: Localix-Terminal-macos.dmg, signed and notarized. Open it and drag Localix Terminal to Applications.
• Linux x86_64 (glibc 2.35+): llxterm-x86_64-unknown-linux-gnu.tar.gz
• Either, from a terminal: curl -fsSL https://raw.githubusercontent.com/localixai/localix-terminal/main/install.sh | sh

Checksums are in SHA256SUMS.

LLX Desk 0.1.6

Added

• A session's documents are put in order by dragging. A tab of the row over them is carried
  along it, the others moving aside, and stays where it is let go: the session keeps the order,
  across a restart too. Escape puts it back.

• Files. The side shows the project's tree under its tabs (the Files head folds it away).
  A folder is read when it is opened and is heard from the system while it is in sight, so a
  file made, renamed or deleted by anyone shows at once; nothing is read or watched for a
  project no window shows. Each kind of file has its picture, the folders left open stay open,
  and an entry's menu reveals it in the Finder or copies its path, whole or from the project's
  folder.

• Files are made, named, moved and thrown away in the tree. A folder's menu makes a file or
  a folder in it, and an entry's names it anew (F2) or moves it to the Trash (⌘⌫); the name is
  written in the row itself, Return keeps it and Escape lets it go. An entry is dragged into
  another folder (a shut one opens when the pointer rests on it, and the tree scrolls at its
  edges), or out over the pages: let go over a terminal, its path is typed there, as Insert
  Path in Terminal does for the terminal in sight; a file let go over another pane opens.
  Nothing is ever written over: a name in use, a folder moved into itself and what the system
  refuses are said in one line under the entry. A file's open tab, what is unsaved in it and
  the folders left open follow an entry that is named or moved.

• Sessions. A project's tabs are its sessions: a terminal, and the files and pages opened
  in it. They are a row of tabs on the terminal's right, one of them in sight, and the side
  lists the session alone, so two terminals never mix what each has open. What an agent opens
  from a terminal joins that terminal's session; a file you pick in the tree, or a page you
  open, joins the one you look at. An agent's document does not take the pane from one you are
  reading: it waits as a tab of the row. Closing a session closes its documents, switching
  between sessions and projects shows each as it was left, at once, and the tabs you had are
  brought to this shape when the app starts. The side lists terminals' sessions and the board,
  never a file or a page: one asked from no session (another terminal app's agent, you with
  the board in sight) joins the session the project shows, else its last, and only a project
  with no terminal keeps its documents in a tab of their own, which its first terminal takes.
  A page you open is in its session the moment its tab exists, not once it has loaded: it no
  longer shows as a row of the side for a second, nor fills the window before it moves to its
  half. The row of a session's documents scrolls sideways when they do not fit, and no tab
  narrows; the one in sight is brought into view. The board stays a tab of its own, one per
  project.

• A tab's menu in the row of a session's documents opens where you clicked, not at the
  window's top left. From a file or a page, Close Other Tabs and Close Tabs to the
  Right close the documents of its row, never a terminal; from a session they close the
  other sessions and leave its own documents. A file's Show in Finder selects the file,
  and New Terminal Here opens in its folder.

• The window is told the layout once for a change, not once for each thing the change says
  (a tab opened says four): it redraws its lists and its split a quarter as often.

• An editor, a kind of tab (f1): a file picked in the tree opens in the session in
  sight, beside its terminal. Syntax colours for C and C++, CSS, Go, HTML,
  Java, JavaScript and TypeScript, JSON, Markdown, PHP, Python, Rust, SQL, XML, YAML and the
  common shell and config formats. ⌘S saves the file in place, with the line ends and byte
  order mark the disk had. A file changed on disk is followed (one Undo step) while it is not
  edited; edited on both sides, a save writes nothing and says what the disk holds. What is
  left unsaved is kept with the file's path, past its tab and the app. It takes UTF-8 text up
  to 2 MB. What is not such text opens as a page: a picture (PNG, JPEG, GIF, WebP, AVIF, HEIC,
  TIFF, BMP), a film (MP4, MOV, M4V, WebM), a sound (MP3, M4A, AAC, WAV, FLAC, Ogg) and a PDF
  are shown and played there, its tab named for the file. An SVG, text that is a picture,
  opens drawn. What no page shows (an archive, a program) says so in one quiet line, "No
  Preview for build.zip", and nothing leaves for another app unasked. A file's menu in the
  tree offers Open in New Tab and Open in Default App for every file, Open as Page
  for HTML and Open as Text for SVG.

• Agents open a file for the person with open and kind: "file" (path, line), and
  interact reads it as the person sees it. A file tab holds a file of its own project only,
  however its path is said (.., a link), and is listed, read and closed by that project's
  agents alone.

• A project's tabs open again once: a restore asked for twice in a row runs one time, and a
  file kept open in two rows comes back as one tab.

• The window with no tab left shows the mark of each coding agent you have installed, under
  its first commands: a click starts that agent in a terminal of the project.

• Dialogs. Everything the app asks or announces in its window has one look: a card over
  the window with a mark that draws itself, a title, a sentence and two buttons. Quit and
  Restart to Update are asked in it (with the window away, as the system asks).

• An update is announced once a version, in that dialog: both versions, what the release
  says is new, Restart to Update and Later. Later puts the update's row off as Not Now does.

• An event leads to what it is about even where that has no tab. A coding agent's session that
  runs outside the window (in another terminal app or an editor) and waits for you has
  Continue Here: its row's click, or its system notice's, opens a terminal of its project
  in the folder that agent works in and continues its last session there (claude --continue, codex resume --last, and each other agent's own words); the line is done with
  once that terminal opened. It is the last session of that folder that is continued, and one
  still open in the other app goes on there too. The agent is known from the program the call
  comes from, so this needs nothing of the agent or its plugin. What an event leads to is one kind of thing for every source (a tab, a
  board, a session), found or opened in one place.

• The app updates itself. A newer release is looked for soon after the app starts and every few
  hours, downloaded while you work, held to the checksum its release lists and, on macOS, to the
  project's Developer ID signature and Apple's notarization; nothing is installed on its own.
  When it is ready a row under the toolbar says so, with Restart to Update and Not Now; restarting
  asks first when a terminal still runs a program, and the window opens again with the tabs it
  had. Settings → Updates shows the build that runs, how far an update is (a download with its
  part), Check Now, the release's notes, and a choice to look for updates only when asked; the
  app menu has Check for Updates…. Only an app installed from a release is updated: a build from
  source says so and asks nothing of the network.

• A wait on a terminal ends when the shell's command does, and says how: "The command ended with
  exit code 1 after 3.2s", where it could only say the output settled. A text waited for that
  never shows is no longer waited out once the command is over, and the screen's read says
  whether the shell's command still runs or how the last one exited. A command at work is
  waited for to its end or the call's limit ("The command is still running after 10s"), not
  given up on at its first quiet moment; one that takes keys (an editor, a REPL) or stays
  quiet for three seconds (a question) ends the wait as before. zsh and bash in a tab say so
  by themselves: the shell starts on a file of the app's that reads the person's own files
  first (for bash: /etc/profile, then the first of .bash_profile, .bash_login,
  .profile, as a login shell reads them), then marks each command's start and end; nothing
  of theirs is changed, and LLX_DESK_SHELL_MARKS=0 in the environment leaves the shell as it
  is. A bash with a DEBUG trap of its own is left unmarked, and so is a line that is one
  subshell alone (( … )). Any other shell that marks its commands (OSC 133) is read the same
  way.

• What waits for you is said outside the Event Center's list too, all three read from that one
  list:

  • a tab that waits carries a dot on its icon while it is out of sight, and its second line says
    what waits (Claude asks: Which database…);
  • while you are in another app, each new thing is a notice in Notification Center, with no
    sound; a click shows the tab it is about (the list, where it has none), and the notice is
    taken back once the thing no longer waits. macOS asks once whether to allow them, when the
    first one comes; System Settings → Notifications turns them off. What already waited when
    the app was started is counted and not told again, and a notice an earlier run left is
    taken back;
  • the Dock's icon counts what is new, until the list is seen.

• A session that waits for you in a terminal is that terminal's line in the Event Center: it has
  Show, the coding agent's mark and name, and two agents of one project each keep their own line
  (one used to replace the other).

• The Claude Code plugin says more of what waits for you, each as one line that goes when the
  session goes on: a question Claude asks you (Claude asks: Which database…), and a turn an
  error ended (however short). A turn you stopped yourself says nothing.

• The Event Center has its button in the bar again, befor...

v0.1.5

• Page sizes: the size button in the window's toolbar frames the page shown as a device (iPhone SE,
  iPhone 15 Pro, Pixel 8, iPad Mini, Laptop, Desktop), in the middle of the window, or lets it fill
  the window again; Rotate turns a size. Each tab keeps its own. The agent's size takes the same
  names, mobile, tablet, WIDTHxHEIGHT or window, and frames the page instead of resizing the
  person's window. A size larger than the window is drawn smaller to fit it, as a browser's device
  view does, and the page still lays out at that size; screenshots of it are cut right. desktop
  is now the Desktop size, 1440 × 900.
• The agent no longer sizes the person's window: the resize action is gone (it could push the
  window past the screen's edge). A call to it says to give the page a size instead.
• Comments work in a modal dialog (a cart, a sign-in): the card opened under the dialog, where the
  page's inert rest took no typing. It now opens inside the dialog, on top of it, and Escape in
  it closes the card alone; a mark of a part of a dialog that closed goes with it.
• A comment comes to Claude Code as one message: its picture's path came as a turn of its own.
  window --said --follow writes each note at once, and --json prints each one as a JSON string
  on a line of its own, which the plugin reads whole.
• A narrow window keeps its toolbar in order: the address field gives way first, then the buttons
  that no longer fit go into "»", the system's menu of them, as Safari's do. They no longer slide
  over the address field.

v0.1.4

• The mini no longer goes missing on the desktop after a full-screen app leaves full screen and
  comes back: macOS left it on that app's Space alone. Going to another Space now puts it on
  every Space again.
• A closed window is let go of: each one stayed in the window server, invisible, for the rest of
  the daemon's life. AppKit's own observers of the window, from before it became a panel, made
  its teardown stop halfway (and the log say an autorelease pool was drained twice).

v0.1.3

• Closing the window takes a moment again, not seconds: the window's own thread no longer waits
  on itself for its list of tabs. The pages of a closed window are now forgotten too, and their
  owners hear tab/closed.

v0.1.2

• While the person comments on the pages, the agent's actions that would move a page (a click,
  typing, keys, a load, a goal's steps) wait for them, up to 60 s, and then answer that the person
  is commenting. Scripts are not held. Send, turning comments off, or collapsing the window gives the
  turn back; Send now ends commenting too.
• The strip says whose turn it is, in quiet words at the end of the address field: "Agent is
  working", "Paused while you comment", "Agent is waiting for you".
• A new look for the strip: monochrome, buttons in shared capsules, thin icons drawn as SVG instead
  of text characters, the address field always centred, larger project pills that count their tabs,
  and tabs in the same style.
• The Claude Code plugin hands the OpenRouter key from its settings to the MCP server, so goal
  works with a key given only there. An unfilled setting is no key.

v0.1.1

• Linux: a terminal draws as soon as it opens and after it is shown again. It showed one character
  until the window was resized: xterm paused while hidden and never heard it was back in sight.
• A page's keys type into the focused field: a character goes in at the caret with the input the
  page hears, Backspace and Delete erase, Ctrl+A selects all. They reported keys pressed and typed
  nothing.
• An argument of the wrong type is refused with what it takes ("read": "h1"), not read as absent.
• The Claude Code plugin asks for the OpenRouter key when it is enabled: optional, kept in the system
  keychain, and needed only for goal. A key in the environment still comes first.
• Linux: the history and "+" are GTK's own menus, under the button and over the page. The history
  list drawn in the strip took the pages' place there, and closing it left the window blank; "+"
  had no menu and always opened a page. The address field's suggestions no longer take the window
  on Linux either.
• The daemon's daemon/stopping reaches every subscriber before it exits.