Skip to content

altitude v0.7.0

Choose a tag to compare

@github-actions github-actions released this 04 Nov 11:47
· 295 commits to main since this release
Immutable release. Only release title and notes can be modified.
v0.7.0
dde3052

Signals worth reading

  • A signal body is drawn as markdown: headings, lists, quotes, code, and tables that get a grid of their own instead of running into a paragraph. The agent is told its bodies are drawn this way, so what it writes as a table arrives as a table.
  • A mermaid fence becomes a diagram drawn inside the card that carried it, scaled to the column and to the words around it, and never taller than forty rows.
  • A picture in a message is drawn in the terminal — kitty, sixel or iTerm2 — where the terminal can draw one. Where it cannot, the source is shown instead, because a diagram is mostly its labels.
  • A picture raised on another machine is fetched by its digest, and one posted in a signal reaches the issue as a picture, in the comment that named it.
  • A picture nothing names anymore is cleared at startup, instead of being kept for the life of the data directory.

The task list

  • The card grid is a table on an even grid — title, signals, issue, pull requests, age — reading across the whole window instead of crowding the border.
  • Rows are grouped by the most urgent thread that is still open: failed, needs you, ready to review, decisions, info, working, queued, limited, paused, done. A group folds from its own heading.
  • The signal count says what is waiting by kind (?1 →5 ○35), because a task asking a question and a task reporting progress are looked at at different times. A task with nothing but reports is filed with the work it reports on.

Tracker

  • The issue's thread carries what the agent says and thinks as it happens: a line per thought, permanent, so the session reads as a transcript rather than one line changing under the operator. Tool calls stay out of it.
  • The pickup line names whose agent it is — "Gaby's Pi is picking up this task" — instead of leaving the operator out of a sentence about their own work.
  • A message from the issue steers the running agent, the way a message typed into the task does. It no longer stops the run, throws the sandbox away and builds it again four seconds after you commented.
  • A reply is answered once, by the run that follows it, rather than by every run from then on.
  • The first run of a session says who picked the task up, permanently. A task that waited is no longer stuck under the ephemeral queue notice that the run it started never replaced.

Remotes

  • A first start says which part it is on — installing the runtime, pulling the base image with the bytes it has moved, building the project's environment — and a client waiting on that machine reads the announcement again rather than sitting on the word it was given.
  • A watched task's activity travels with its card, so a task running on another machine shows what the agent is doing and not only its plan. What travels is the newest line, not the run's history; the terminal is still the record.
  • A machine owed nothing no longer reads "sending setup…" for as long as the application runs. The row says there is nothing to send, that a task is still holding its copy, that a configuration is on its way, or that it is up to date.

Tasks and agents

  • A usage limit no longer fails a task. It pauses with a clock, gives its sandbox slot back so the wait costs no room, and comes back on its own when the window reopens — by the admission pass that already runs every ten seconds, not by you replying. The issue's session says what happened, once, and the details line says which window ran out and the hour it lets go.
  • Only Claude Code reports its account's windows today. Pi reports what a run cost and nothing about its account, so a pi task is not paused on a limit and does not resume itself.
  • A refusal that is not a window — no credits, or a limit with no time on it — is still yours, and it says what the account said rather than that the command was rejected.
  • A task says what it has spent, in its harness's own accounting. Altitude prices nothing itself, and on a subscription the figure is hidden: a plan's turns are priced at list rates whether or not anything is being paid.
  • What the agent is doing is on its card while it runs: the tool it started, the file or command that tool is aimed at, and the words around it. Pi and Claude Code both report it, and it is dropped when the run ends.
  • The activity stream is what the agent says and thinks, not its shell. A shell command's text is gone — the line reads using <tool> — and the reasoning the harness streams beside its messages is there, marked as thinking.
  • A harness is pinned by major, so an environment refresh cannot hand back the same three-week-old harness. Claude Code's stable pointer must still be 2.x or the build stops instead of arriving unannounced in a sandbox.

Interface

  • The task screen shows what the agent is doing, under the plan, as it arrives: the newest line bright, the older ones dim, scrolling on the wheel and the keyboard the way the signal threads do, keeping the last two hundred lines.
  • The plan and the activity hold half the column each, both titled and both scrollable, and the activity keeps its half when it is empty so the column does not change shape under the reader when a run starts.
  • A focused pane shows a rail and its name. The focus ring is built from what the screen actually drew, so it cannot stop on a pane that is behind a tab, and a focus whose pane went away falls back to the list.
  • The boot screen shows the base image download with a percentage and the bytes moved, and it keeps painting with animations turned off.

Settings and projects

  • A credential is named one way everywhere. The list of services is read from the kinds that own them rather than kept a second time beside them, and the difference you see is a credential called "Claude" in the interface, the way a task row already called it.

Internal

  • One contract and the things that answer it are a providers/ folder: agent, tracker, vcs and isolation each state a trait in the folder above and keep the implementations beside it.
  • The files that had more than one job are folders named for the jobs, and no method changed on the way out: the app is twenty-three files beside an input/ folder with one file per screen it answers, the run loop is control, lifecycle, transfer, review, watching, admission and terminal, the remote host is task host, tracker host, transfer and run, the tracker host is intake, delegation, answering, reporting, delivery and records, the signals screen is frame, plan, threads and conversation, the isolation runtime is base, snapshot, lifecycle, files and engine, the sandbox is profile, plan, guest and run, the store is events, reports and signals, and Linear's client is queries, issues, comments, sessions and agent sessions.
  • utils is shimmer and format, because that is what was in it.
  • A preview harness for looking at the interface without asking real agents to run: scripts/demo.py writes a throwaway home of fabricated tasks covering every group of the list, and ALTITUDE_PREVIEW=1 draws that list with no task service behind it (a release build needs --features preview).
  • Dependencies: pulldown-cmark 0.13, mermaid-rs-renderer 0.3, resvg 0.49, image 0.25, ratatui-image 11.1.