Lanes 0.0.8 (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

Five agents, Lanes' own tools for them, and a daemon that keeps it all in step. Gemini CLI and GitHub Copilot now put their work in lanes on their own, lane mcp gives agents tools to read the repo and make lanes, and laned makes every change to lanes and keeps the terminal app live. Still a preview.

lane setup                          # puts Gemini CLI and GitHub Copilot in lanes too
claude mcp add lanes -- lane mcp    # Lanes' tools for Claude Code; any MCP client works
lane daemon status                  # whether laned is running, and the changes it has made

In this version:

• Gemini CLI and GitHub Copilot (the Copilot CLI and VS Code's agent mode) put their work in lanes on their own, set up once per machine like Claude Code, Codex and Cursor. The worktrees they make become ready-to-run lanes, and copying the repo is turned down with a pointer to lane new. Their settings files keep their comments, and lane setup --yes --agents off gives each one back byte for byte.
• lane mcp: an MCP server over stdio with repo.read, repo.outline, repo.grep, lane.new and lane.list, so agents read code and make lanes through tools. Lanes adds it to no agent's settings; claude mcp add lanes -- lane mcp adds it to Claude Code.
• laned, the daemon, is the one writer. While it runs, every change to lanes, from your commands, agents' hooks or the terminal app, is made there, one at a time per repo, with your environment, and install output comes back as it happens. It keeps the terminal app live, sending only what changed. Your own commands start it; agents' sessions, hooks and CI only use it if it's running. It keeps nothing of its own, so stopping it loses nothing, and it leaves by itself after half an hour with nobody connected. lane daemon shows, starts and stops it.

Known issues:

• On Windows, removing Lanes without first running lane setup --yes --agents off leaves the Copilot CLI with a hook it can't run, and the Copilot CLI then turns down every tool. Run that command before you uninstall, or delete ~/.copilot/hooks/lanes.json.
• Gemini CLI and GitHub Copilot are checked against their documented hook formats, not yet in live sessions.

Not yet:

• No checkpoints or undo, no promote to a pull request, and no database per lane.

2026-10-18

• 17:20 Changed: laned is the one writer. While it runs, lane new, lane rm and lane adopt, agents' hooks, lane doctor --fix and the terminal app send it their changes, and it makes them one at a time per repo (0b0a6d4).
  • Install output comes back to your terminal as it happens, and installs run with your environment (PATH, package manager settings), not the daemon's.
  • Results and errors are exactly as before: the same output, --json, exit codes and hints.
  • Once it has a change it finishes it, even if the command that asked is stopped, so no lane is left half made. If it stops mid-change, the command says so and how to check where it got to.
  • Your own lane new, rm and adopt start it when it isn't running. Agents' sessions, hooks and CI only use it if it's running, and LANE_DAEMON=0 keeps anything from starting it. Without it, everything runs in lane as before.
  • lane daemon status counts the changes it has made.
• 17:14 Added: Gemini CLI and GitHub Copilot put their work in lanes on their own, set up once per machine by lane setup and the welcome, like Claude Code, Codex and Cursor. (281b48f)
  • Gemini CLI, in ~/.gemini/settings.json: a SessionStart hook makes a worktree gemini -w made a lane, a BeforeTool hook on run_shell_command turns down copies of the repo with the reason shown to the model, and AGENTS.md joins context.fileName (keeping GEMINI.md).
  • GitHub Copilot: the Copilot CLI and VS Code's agent mode both read Lanes' own ~/.copilot/hooks/lanes.json, with sessionStart and preToolUse hooks; a turned-down command exits 2 so the model sees why. VS Code's user settings get chat.useAgentsMdFile unless you've set it.
  • lane hook gemini session-start|before-tool and lane hook copilot session-start|pre-tool-use answer in each agent's documented format. lane doctor, the welcome and lane init list both agents.
  • Their settings allow comments, so Lanes edits them as text, and lane setup --yes --agents off gives each file back byte for byte. Lanes notes the values it set (agent-settings.json, next to its settings) and puts back what was there, unless you've changed them since. The guide shows the guided lane init with its Y/n questions, the terminal app and what lanes saved, lane doctor --fix, and what the install count sends with lane telemetry. (4e7be85)
• 17:05 Added: lane mcp, an MCP server over stdio, so coding agents read the repo and make lanes through tools: repo.read (a file or some of its lines, and nothing outside the repo), repo.outline (top-level definitions and their line numbers, best effort for Rust, TypeScript, JavaScript, Python and Go), repo.grep (git grep, so .gitignore is respected), lane.new and lane.list. A tool's errors say what to do next, as the commands do. Add it to Claude Code with claude mcp add lanes -- lane mcp; Lanes doesn't change any agent's settings for it. Built on rmcp, the official Rust MCP SDK. (0d3a709)
• 17:02 Added: laned, the daemon, keeps the terminal app live, and lane daemon shows, starts and stops it (e1b9b5a).
  • One runs per user. The terminal app starts it; agents' hooks, scripts and CI never do, and LANE_DAEMON=0 stops the app from starting it too. It stops by itself after half an hour with nobody connected.
  • It reads each repo's lanes once, however many terminal apps watch, and sends them only what changed. The app's status bar says "daemon running". If the daemon goes away, the app carries on by reading Lanes' state itself.
  • It keeps nothing of its own, so killing it loses nothing. A daemon from another Lanes version is replaced when the app or lane daemon start connects.
  • It listens on a local socket (a named pipe on Windows). On macOS and Linux it only talks to the same user's processes. A second copy leaves at once, and lane doctor reports whether it's running.
  • Making and removing lanes don't go through it yet: they work as before, safely, with or without it.
• 17:02 Fixed: the README listed lane telemetry under commands coming next; it shipped in 0.0.7.
• 14:58 Changed: the website offers 0.0.7. The guide shows the guided lane init with its Y/n questions, the terminal app and what lanes saved, lane doctor --fix, and what the install count sends with lane telemetry. (4e7be85)