Lanes 0.0.7 (preview)

Install or update:

On	Command
macOS, Linux, WSL	brew install autter-dev/tap/lanes, or curl -fsSL https://github.com/Autter-dev/lanes/releases/latest/download/lanes-installer.sh | sh
Windows	winget install Autter.Lanes, scoop install lanes (after scoop bucket add autter https://github.com/Autter-dev/scoop-bucket), or irm https://github.com/Autter-dev/lanes/releases/latest/download/lanes-installer.ps1 | iex
Anywhere with Node	npm install -g @autter/lanes

More ways, and how to check a download, at https://lanes.autter.dev/download.

Verify an archive: gh attestation verify <file> --repo Autter-dev/lanes, or compare it with SHA256SUMS.

Changes

Setup that does the work for you, and your lanes live in the terminal app. lane init and lane doctor --fix now set things up themselves and ask Y/n where the choice is yours, and lane shows every lane live, with what lanes saved you. Still a preview.

lane init            # set up this repo, asking Y/n before each step, then say what's left
lane doctor --fix    # fix what Lanes can fix by itself, asking first
lane                 # every lane, live, and what lanes saved you
lane telemetry       # exactly what the anonymous install count sends from your machine

In this version:

• lane init in a terminal walks through each step and asks before it: lane.toml for your team, putting this machine's agents in lanes, the Git hook, the AGENTS.md note, Claude Code for this repo, and installing dependencies ahead of time so the first lane is ready in seconds. It ends with what's left for you to do. --yes takes every default, and agents, scripts and CI are never asked anything.
• lane doctor --fix fixes agents not in lanes yet, this repo's Git hook and lanes whose folders have gone, asking first. The install scripts offer to set Lanes up when they finish.
• The terminal app lists every lane with its agent, status (running when its app answers), URL, changed files, last test run and extra disk, and updates as things change. "Saved by lanes" compares the disk lanes take with a worktree plus an install for each, and counts the installs they skipped. ? shows the keys, : or Ctrl-K opens a command palette, n makes a lane and d removes one.
• The anonymous install count is sent from this version on: once Lanes is set up and once after each upgrade, a random install id, the version, your OS and CPU type, and how you installed it. Nothing else, never from CI, and off with lane telemetry off or DO_NOT_TRACK=1. It goes to a small open-source service in this repo (services/install-count) that keeps no IP addresses.

Not yet:

• No background daemon: the terminal app reads Lanes' state every two seconds instead, and its status bar says so.
• Lanes made before 0.0.7 show no savings, because Lanes measures each lane as it makes it.
• No checkpoints or undo, no promote to a pull request, and no database per lane.

2026-10-18

• 14:34 Added: the install count's backend is live at https://lanes-count.autter.dev, on the D1 database lanes-install-count. Checked end to end: a count sent by lane arrived with exactly its five fields, and DELETE removed it.
• 14:23 Changed: the install count's backend keeps counts in Cloudflare D1, not Postgres, so it runs entirely on Cloudflare with no database to host elsewhere. npm run deploy applies migrations/ and deploys; its tests run the SQL on a local D1.
• 13:59 Added: the install count's backend, in services/install-count: a Cloudflare Worker that keeps counts in D1 (b1f8c8e).
  • POST /v1/installs accepts the five fields lane sends and nothing else. DELETE /v1/installs/<id> deletes everything kept about one install.
  • It never keeps IP addresses, user agents or request logs. Cloudflare's rate limiter allows 20 requests a minute per address.
  • queries.sql has the usual questions, and the README says how to host it at lanes-count.autter.dev, where release builds of lane now send the count.
• 13:19 Added: the anonymous install count, and lane telemetry to see and switch it (04e5ef2).
  • Once Lanes is set up (the welcome or lane setup), and once after each upgrade, it sends exactly what the welcome lists: a random install id, the Lanes version, the OS and CPU type, and how Lanes was installed (Homebrew, npm, Scoop, winget, cargo or the install scripts). Nothing is sent before the setting is chosen.
  • Never from CI, and never with lane telemetry off, LANE_TELEMETRY=0 or DO_NOT_TRACK=1. It's sent in the background with a 1-second limit, and no command, or anything reading its output, waits for it.
  • lane telemetry shows exactly what this machine sends; lane telemetry on and off switch it, and --json prints it for scripts.
  • Release builds send it to the service below; development builds and test runs never do.
• 12:09 Added: the terminal app's home screen shows your lanes live, and what they saved (677d880).
  • Every lane with its agent (Claude Code, Codex, Cursor), status (running when its app answers on its port), URL, changed files, last test run through lane exec, and the extra disk it takes. Narrow terminals drop the agent and tests columns.
  • Saved by lanes: disk as two bars on one scale, a worktree plus its own install for each lane against what the lanes really take, plus the installs lanes skipped and the time that saved. Lanes measures each new lane as it makes it, so lanes made before this show nothing rather than a guess.
  • A status bar: sign-in, the daemon, cores, apps running and disk saved. The daemon doesn't run yet, so the bar says so, and the screen watches Lanes' state instead, redrawing only when something changed.
  • Keys: ? shows them all; : or Ctrl-K opens a command palette you can filter; n makes a lane and d removes one (asking first), in the background; o opens the lane's app, c copies its folder and l shows the log.
• 07:36 Added: setup does everything it can by itself and asks Y/n where the choice is yours, then says what's left.
  • lane init in a terminal walks through each step and asks before it: write lane.toml for your team; put this machine's agents (Claude Code, Codex, Cursor) in lanes; add or update the Git hook; add the note to AGENTS.md; set up Claude Code for this repo only, if not for the machine; and install dependencies now in a clean copy, so the first lane is ready in seconds. Steps already in place aren't asked about. It ends with what's left: trusting the hooks in Codex once, the git add, the first claude -w, and getting instant lanes where this disk copies them. --yes takes every default without asking.
  • lane doctor --fix fixes what Lanes can fix by itself, asking first: agents not in lanes yet, this repo's Git hook, and lanes whose folders have gone. What only you can do (install Git, move a repo to a Dev Drive, change PATH) keeps its steps. --fix --yes makes every fix without asking.
  • The install scripts ask at the end whether to set Lanes up now, and run lane setup if you say yes. --no-setup or LANES_NO_SETUP=1 skips it.
  • After the welcome, Lanes prints what's next: lane init in the repo you're in, trusting Codex's hooks once, and how to get instant lanes.
  • Agents, scripts and CI are never asked anything: without a terminal, lane init does what it did before. LANE_INTERACTIVE=1 asks even where Lanes can't tell it's a terminal (some Windows terminals); LANE_INTERACTIVE=0 never asks.
• 07:22 Changed: the website offers 0.0.6, and the guide has a step for when something's off: lane doctor and lane logs.