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

Your agents put their work in lanes on their own. Run lane once, and Claude Code, Codex and Cursor get a lane for each task, in every repo, ready to run. Nobody types lane new. Still a preview.

lane                 # once: checks your machine and puts your agents in lanes
cd your-repo
claude -w fix-auth   # or start a Codex or Cursor agent in a worktree of its own
lane list            # each agent's lane, with its ports and folder

In this version:

• Setup happens once per machine. The welcome (and lane setup --yes) adds Lanes to each agent's own user settings. It's a switch, and --agents off takes it back out exactly. Set up Lanes before 0.0.5? Run lane setup once more.
• Claude Code: claude -w, subagents and background sessions get lanes in every repo, without lane init. A lanes skill has Claude start a task in a lane of its own.
• Codex and Cursor: when a session starts in a worktree they made, it becomes a lane (codex-<id>, cursor-<id>), and the agent is told which lane it's in. In Codex, open /hooks once to trust Lanes' hooks.
• Lanes from agents are ready to run: dependencies are cloned from a clean copy, and each lane gets its own ports and .env. A repo doesn't need a lane.toml for this.
• Agents are turned down when they try to copy the repo (git worktree add, a git clone of it, cp -r), with a pointer to lane new.
• lane init handles repos whose Git hooks belong to Husky or lefthook.

Not yet:

• Gemini CLI, Copilot and other agents get lanes only when they make a Git worktree, through the hook lane init adds.
• There's no background daemon, no checkpoints or undo, no promote to a pull request, and no database per lane.

2026-10-17

• 18:32 Added: the home screen says when an agent installed here isn't in lanes yet (say, after an update from 0.0.4), and to run lane setup.
• 18:18 Added: agents get lanes on their own, with nothing to set up per repo: Claude Code, Codex and Cursor. (dd754be, cc529ae)
  • Once per machine: the first-run welcome and lane setup --yes put your agents in lanes, in each agent's own user settings. It's a switch on the welcome's last screen (a), on by default. lane setup --yes --agents off takes back exactly what was added, and nothing else in those files changes.
    • Claude Code: its hooks in ~/.claude/settings.json and the lanes skill in ~/.claude/skills/lanes, so claude -w makes a lane in every repo without lane init.
    • Codex: hooks in ~/.codex/hooks.json. Codex makes its worktrees with Git hooks off, so when a Codex session starts in one, it becomes a lane (codex-<id>), ready to run, and Codex is told which lane it's in. Copies of the repo are turned down. Codex runs new hooks only once you trust them, so lane setup says to open /hooks in Codex once.
    • Cursor: hooks in ~/.cursor/hooks.json. When a Cursor agent starts in a worktree Cursor made, it becomes a lane (cursor-<id>), ready to run, and the agent is told which lane it's in. Copies of the repo are turned down with a message the agent reads.
    • Codex and Cursor share the skill in ~/.agents/skills/lanes.
  • A lanes skill: tells an agent to start each task in a lane of its own (lane new <task> --print-path, or Claude Code's EnterWorktree), to run dev servers with lane exec, and never to copy the repo. The Claude Code plugin carries it too.
  • No lane.toml needed: in a repo without one, Lanes uses what lane init would find (install steps, dev command, .env template), so a lane an agent makes is ready to run. A lane.toml still wins when there is one.
  • Worktrees other tools make are ready to run: the Git hook now makes each one ready, like a lane from lane new. Dependencies (node_modules, .venv) are cloned from the clean _base copy when the lockfiles match, and installed in the worktree when they don't. The lane gets its own .env too. lane adopt --ready does the same by hand. The hook lane init added in 0.0.4 is upgraded the next time lane init runs.
• 17:17 Added: a guide on the website, lanes.autter.dev/guide, from install to two agents in their own lanes, in nine steps. It's written for your system: it picks macOS, Linux or Windows from your browser, with that system's commands, shell, folders and example output, and a switch to see another. It remembers your pick. On a phone it says Lanes runs on a computer. Without JavaScript, every system shows, each labelled. The nav's "Get started", the home page and the download page link to it.
• 17:15 Added: lane init sets up the post-checkout hook in repos whose Git hooks belong to Husky or lefthook, so worktrees other tools make become lanes there too. (047f922)
  • Husky 9 (core.hooksPath is .husky/_): one line goes at the top of .husky/post-checkout, which is made if it isn't there. The file is checked in, so lane init says so and puts it in its git add step. Where lane isn't installed the line does nothing, and it never fails a checkout.
  • lefthook with a post-checkout hook: nothing is written, because lefthook moves aside hooks it didn't write and never runs them. lane init prints the lanes command to add to lefthook's config, in its format (YAML, TOML or JSON). When lefthook doesn't run post-checkout, the hook goes in .git/hooks as before.
  • Any other core.hooksPath, Husky 8 and older included: nothing is written, and lane init prints the line to add.
  • lane hook git post-checkout: what that line and that command run. A new worktree becomes a lane. Branch switches, the repo's own folder and Lanes' own worktrees are left alone.
  • In --json, an entry in agents has check_in when its file belongs in Git, and snippet with the text to add by hand.
• 17:15 Added: Claude Code is turned down when it tries to copy the repo, not only when it runs git worktree add. In a Lanes repo, the pre-tool-use hook also turns down the two below. (047f922)
  • A git clone of this repo: by one of its folders (., .., a path, cd .. && git clone app app-2, git -C), by its origin URL however it's written (https://, git@host:, ssh://), by "$(git remote get-url origin)", or with gh repo clone owner/repo. Clones of other repos, and --bare or --mirror clones, run as usual.
  • A recursive copy of one of the repo's folders: cp -r, -R or -a; xcopy /E or /S; robocopy /E, /S or /MIR; Copy-Item -Recurse and PowerShell's cp -r; also inside bash -c, cmd /c and pwsh -Command. Copies of a subfolder, and copies that leave .git out (robocopy /XD .git), run as usual.
  • Each has its own reason, pointing to lane new <name> --print-path. A copy's reason also points to git archive for an export.
  • Most commands still return before any Git or disk work. A session told about lanes now hears that clones and copies are out too.
• 17:01 Changed: the website offers 0.0.4: the download page's archives, and a 0.0.4 entry on the releases page.