Skip to content

llx 0.3.0

Choose a tag to compare

@rsaryev rsaryev released this 17 Nov 11:01
· 100 commits to main since this release
5804345
  • The project is now llx-cli: the repository is rsaryev/llx-cli (the action uses: rsaryev/llx-cli@v0, the skill npx skills add rsaryev/llx-cli, the image ghcr.io/rsaryev/llx-cli), and the binary's package is llx-cli (cargo install --locked --git https://github.com/rsaryev/llx-cli llx-cli). The command is still llx, inside the release's archives too, now llx-cli-<target>.tar.gz. GitHub redirects the old name.

  • A monitor waits for one thing, as Localix's does: its command is a check run every every seconds (10 by default, at least 5) until it exits 0 or its time is up, and the agent is told once how it ended (met after 4 checks (32 s), timed out after …, could not run: Exit code: 127) with what the last check printed. It no longer hands the agent each line a command prints: a monitor printing every second kept a task going for 22 turns in 32 s. In the list a monitor shows its checks (≋ ready … 3 checks · 4m 28s left), opens with Enter to what its last check printed, and stays listed with how it ended, as a command in the background does.

  • A job the agent stops says nothing more of it; one the person stops (x) opens no task of its own, and the agent reads it with the person's next task.

  • The list under the composer ends each row's time and tokens, or how a command in the background runs or ended, at the right edge, where the footer's spend ends: the rows read as one table, what a row does cut first when the room runs out.

  • A resized window draws the session again at its new width: the terminal reflows what it shows, so the live area was erased short and its copies (the composer's rules) stayed on the screen. Each block of the transcript is drawn again at the width, not cut.

  • A command in the background reads as running, not failed: Running in the background, or Moved to the background after 120.0 s under what it printed so far, never the red lines meant for the model.

  • Enter on a command in the background shows what it prints, as it prints (asked of the server each second while open, Command::JobOutput), with how it runs; x stops it, Esc goes back. One that ended stays listed with how it ended, red when it failed or was stopped (✗), until x removes it; the footer counts only those that run. A monitor's and a schedule's rows offer x stop alone.

  • A task that something from the background opened (a command's end, a monitor's lines, a schedule) starts in the session's history as where it came from ($ tests · Exit code: 1, ≋ ticks · tick 1, ◷ nightly · …), as a saved session shows it, not as the tagged message the model reads.

  • The advice that reviews an answer reads what came in during the task (a background command's end, a monitor's lines, an agent's answer, the person's words) in its place among the calls: an answer that reported a command's exit code from its <background> message was sent back twice as unfinished, the review seeing only that the command was started.

  • A long command goes on in the background, as Claude Code's do: bash waits for a command 120 s at most (or its timeout_ms, if less), and one still running then becomes a job of jobs instead of being killed: the model reads what it printed so far and the file its whole output goes to, and its end comes back once as a <background> message (a task of its own when none runs). run_in_background: true starts one there at once, named by description. It is listed and stopped as a job (jobs list, jobs stop, x on its row; the footer counts 2 shells, 1 monitor), runs at most 30 minutes (10 in exec, whose task waits for it), and ends with the session; a sleep is killed at its wait. Before, a test run that hung held the task until its timeout_ms (a benchmark lost 12 minutes to two), and the timeout's message asked the model to raise it. An agent's commands are still killed at their timeout_ms.

  • What the session could not do with something sent from the terminal (words typed for a session that had just ended, closing one already gone) is shown as an error: it was dropped without a word.

  • A session is open in one llx at a time: another llx that resumes it while it is open (llx resume <id>, -c, the list's row) is refused, session <id> is open in another llx: quit it there first, and its file is left as it was. Before, two terminals on one session each rewrote its file whole, so the tasks of the one that saved first were lost, and two saves at once could leave the file cut short. The lock is the operating system's: a process that crashes or is killed lets it go.

  • Sessions are JSON Lines (~/.llx/sessions/<id>.jsonl): the session's header, then each task as it ends and its title, appended, never rewritten whole; a line a crash cut short is left out when read. Sessions saved as .json by an earlier llx are no longer read.

  • Building llx from source needs Rust 1.89 or later (the standard library's file locks).

  • The daemon is gone (llx serve, --no-daemon, LLX_NO_DAEMON): a session at the terminal runs in the llx that shows it, with its agents and jobs, and ends with it; llx resume and llx -c go on with it from its file. "Move to background and exit" is no longer offered, llx serve status and stop are gone, and no socket is left in $TMPDIR/llx-<uid>/. A session ran no faster in the daemon (0.2 ms more to start, nothing per event), and it cost code and bugs. exec, decide and the GitHub Action never used it.

  • SIGTERM or SIGHUP at the prompt gives the terminal back as it ends the process: a session run in process (--no-daemon, and now every session) left the terminal raw.

  • The binary no longer carries Mozilla's root certificates, which it never read: TLS verifies with the system's trust store, as before (RootCerts::PlatformVerifier). 132 KB less (2.76 MB on macOS).

  • The skill describes llx instead of sending the agent to its help first: what each part is for, with examples to run as they are (a pull-request review workflow for the action, a gate, helpers in parallel, llx decide, and a search of the code by what it does as rg and llx decide make it), and at its end llx exec --help and llx decide --help as the release prints them (scripts/skill-help writes them, a test checks them). In Claude Code the skill asks once before it is used, as it grants commands; Skill(llx:llx) allows it where no one can answer.

  • An answer given while background agents still worked, then stopped while it waited for them, read twice in the session: once as the words said as the wait began, once more as the task's answer. It is shown once; stdout, -o and --json have it as before.

  • In a read-only mode (plan) the context says when to ask the person with ask, as the other modes do at a terminal: it was left out, so a plan's open questions were guessed.

  • scripts/ci-docker runs CI's jobs as runner, a user with passwordless sudo, as GitHub's runners do: as root, the action's lockdown tested for real could never drop its privileges, and the action job failed. Its volumes are new (llx-ci-runner-*); the old llx-ci-* ones can be removed.

  • A session's end reaches the interface after the last word of its monitors: a monitor still running as the session closed told its jobs after the end, and a client attaching later was handed them as the state of a session gone.

  • The skill, for any agent: skills/llx/SKILL.md, a discovery stub as agent-browser's is, installed with npx skills add rsaryev/llx (Claude Code, Codex, Cursor, Gemini CLI, OpenCode and others) or in Claude Code as the plugin (/plugin install llx --marketplace rsaryev/llx). It describes all of llx and when each part pays (the coding agent, one task in a script or CI and the GitHub Action, helpers on another model, llx decide, the modes and the sandbox), lets Claude Code run without asking, while the skill is active, llx decide and llx exec --mode plan with any arguments after them, llx doctor, llx --help and llx exec --help (its allowed-tools: nothing else; every other command goes by the person's permission settings), and points at each command's --help, which is the guide now (a paragraph for an agent in llx exec and llx decide --help), so it never goes stale. The Claude Code plugin's subagent, its session hook and its settings, and the Codex lines, are gone: the skill replaces them, and llx reads its key and model from /login as anywhere.

  • llx decide QUESTION FILE… asks about each file on its own, eight at once, and prints a line each (CHOICE<TAB>FILE, or with --json an object with its file) in the order given: one command for a directory, where a shell loop would not fit an agent's allow rule. With --expect, it exits 1 when any file's pick differs; a file that cannot be read or answered is named on stderr and ends the run with 3.

  • llx decide --check exits 0 when decide can run (an OpenRouter key is set or saved) and 3 when it cannot, asking no model.

  • An --allow rule no longer lets a command write a file through >& followed by a word that is not a descriptor (echo hi >&2x writes the file 2x): such a line is asked, as any other redirect to a file.

  • A question withdrawn as it was asked (the lane closed, the person left) is no longer shown again to every interface that attaches later.

  • An entry the session took as it was sent no longer stays shown as waiting under the composer: the queue reaches the interface in the order it changed.

  • The cursor no longer lands a row too low when rows wider than the terminal sit both above and below it in the live area.

  • A task stopped by --timeout or --budget no longer reads "out of turns" in the session list, the tree under the composer and the line a lane is told: it reads "limit reached", as one out of turns does, the error line under it saying which.

  • In a choice shown in tabs (/model's providers), a number picks only a row of the tab shown, never one of a tab out of sight.

  • The list under the composer gives the keys back to the prompt when the rows it chose among go: the last job ending, another session shown (one just opened) or a gap in what the server kept, while the list had the keys, left it on a row no longer drawn, so the next ←, Esc, Enter or x did nothing, or on a row of the other session's that the person had not chosen.

  • The list under the composer keeps the row chosen when rows come or go around it. Before, a session's first agent starting (its row and the session's come above the jobs) or a job above the one chosen ending moved the marker to another row, and x then stopped that one: the session's task, or the next job. Another session ending, one not shown, took the keys back to the prompt though the row chosen was still there. When the row chosen goes (its job ends, its agents are cleared), the prompt has the keys back; no other row is chosen in its place.

  • A session closed to make room for a new one (at the most sessions open) takes its jobs with it. Before, their rows stayed under the composer until a gap, and x on one asked to stop a job of a session already closed.

  • Ctrl+G's draft for $EDITOR is made as a new file only the person can read: a link planted at its name in a shared /tmp is no longer written through.

  • A streamed reply that fails after its first words (an error OpenRouter reports inside the stream) is no longer sent again at once: those words were billed. It is sent again only as a request that went out unanswered is, and an error before any word is still retried.

  • A daemon that did not start in time, or lost the lock to another, is waited for once it ends: a client that goes on keeps no zombie process of it.

  • A bash deny rule refuses a monitor that runs the command too: --deny 'bash(rm *)' no longer lets jobs run rm under a mode or a rule that allows jobs.

  • A patch to a file inside a nested repository's .git (sub/.git/hooks/pre-commit) is asked as one that must leave the sandbox, as one inside the workspace's own .git is: a hook written there would run at the next commit there.

  • A browser sign-in (/login) no longer waits for the browser to close where xdg-open keeps it in the foreground (Linux with no desktop it knows): the opener is left in the background, and its output never reaches the terminal.

  • An invalid patch's error names the line as the model wrote it: a heredoc around the patch and blank lines before it are counted (apply_patch said line 4 for the fifth).

  • llx decide QUESTION FILE… names a file it could not read or answer once on stderr (llx decide: FILE: could not read the file: …), no longer llx decide: FILE: llx: ….

  • A line sent to the daemon's socket that is not UTF-8 no longer ends the connection: it is dropped and said as any line that is not a frame, and a call in it is answered failed under its id.

  • apply_patch's *** Delete File on a symlink removes the link itself, as rm and Codex do: the file it pointed at was deleted and the link left dangling. A link to a directory, to nothing, or to a file outside the workspace (refused before) is removed too; a link in llx's own directories, or to one of its files, is still refused. The gate is asked delete the symlink X (to T), with the link's path as the subject an apply_patch rule matches. A file added under the same name in the same patch takes the link's place, so Delete File then Add File on a link no longer rewrites what it pointed at.

  • apply_patch's *** Update File with *** Move to on a symlink moves the link itself, as Codex does. Before, it moved the file the link pointed at (deleted it and wrote its updated content under the new name) and left the link dangling. Now the link goes and the file it pointed at stays as it was, as after mv, but the new name is a file of its own, holding the content read through the link. A link to a file outside the workspace is moved too (refused before); a link to one of llx's own files is still refused. The gate is asked move the symlink X (to T) to Y, with the link's path as the subject an apply_patch rule matches. An update without a move, or a move to the link's own name or to the file it points at, still changes that file, as an editor does.

  • On macOS a command in the workspace's sandbox no longer writes a nested repository's .git (sub/.git/hooks/pre-commit), in any case, nor makes a new .git: a hook written there would run outside any sandbox at the next commit there. Only the workspace's own .git was kept. A project's tests that make a git repository inside the workspace now need escalate (the scratch $TMPDIR still takes them), and a workspace that sits inside a .git directory is not written at all. On Linux a command in the workspace's sandbox now only reads, as it already did in a workspace with a .git of its own: Landlock cannot keep a nested repository's .git, or a new one, out of a tree it lets write, so a plain directory's builds and tests that write into it are escalated there too (patches still change its files without asking).

  • A command's spilled output ends ... 1 more line was not kept ... for one line, no longer 1 more lines were.

  • A reply to one of llx's own lists (/login, /model, /rewind) that names a row past the list, or a level past its row's, is read as a cancel: a client that sent one panicked its lane, and every lane at that desk ended with it.

  • A ninth monitor, or a schedule past the 50 jobs kept, is refused before its approval is asked: where the mode asks the person (a monitor with escalate, or a mode that asks for every command), they were asked, and the job was refused anyway.

  • An entry typed for a session as it ended is let go with the session. Before, it was answered as taken, kept in a queue made again for the session that had gone, and that queue was told to the interfaces after the session's end. A monitor's last lines after the end are let go too.

  • A session's title is asked with a 15 s deadline (before, it had none, and a host's own timeout is minutes), and a session's end waits for a title still being asked, so the request never outlives its session. A title slower than that is asked again at the next task.

  • An approval or a question from a session not shown that has no name yet names it as the session list does, session New session (in the background), no longer session (in the background).

  • With --schema, a field the schema's required names is checked where it lists no properties beside it: {"type": "object", "required": ["price"]} no longer takes {} as matching data.

  • A sign-in's callback, or the address pasted in its place, reads a percent escape only as % and two hex digits: %+1 is no longer the byte 1, but %, a space and 1.

  • Agents started in the same second are no longer given the same session id (a chance in 65,536 for each two of them), which mixed up their saved sessions, their stops, their answers and their views: a process counts its ids up from one random draw.

  • A schedule's cron with a day field that starts with * (0 0 */2 * 1) runs only on the days both fields allow, as vixie-cron reads it: it ran on every odd day and every Monday.

  • A schedule's delay too long to count (in: 999999999999999999d) is refused, and one past what the clock counts is never due: the number wrapped around, so such a schedule came due at once, or at a time no one asked for.

  • An apply_patch rule that ends in / names every file under that directory, as .gitignore reads it (--deny 'apply_patch(docs/)': any directory docs; src/gen/ from the root): it matched no file, so such a deny refused nothing.

  • A picture attached (--image, a dropped file) is read no further than the 8 MB limit: a file of gigabytes, or a pipe that does not end, is refused without being read whole.