lane — Copy-on-write worktrees with memory that survives them.

A second worktree that costs no disk and no cold build.

Lane asks git for every path it ignores — including nested ones like packages/a/node_modules and single files like .env — and clones each one by reference. On a filesystem with reflink support the two copies point at the same extents, so the second tree occupies no new space and the build cache is already warm.

That is the copy half. The write half: editing a file in the lane un-shares only that file's blocks. One source edit here, plus the incremental rebuild it triggered, rewrote 550 files — 106.5 MiB. The other 1251.6 MiB stayed shared, and the 106.5 went away with the lane. Your edit is free. The rebuild is what costs, and it does not outlive the worktree.

Reflink works on APFS, btrfs, XFS with reflink=1, bcachefs and recent ZFS. Everywhere else lane init says so up front and lane new leaves you a plain worktree — byte-copying a build cache is the expensive thing lane exists to avoid. Opt a path out with git config --add lane.exclude target.

The reason you did it that way, kept next to the code it constrains.

A note costs one command and takes no taxonomy decision. Write down what must stay true, not what you changed.

$ lane note add src/auth.rs -a "fn verify" \
    "must stay constant-time; early return leaks token length"
noted -> src/auth.rs#fn verify

$ lane why src/auth.rs

[fn verify]
  - 01M0B9MBYB · 2026-08-14
    must stay constant-time; early return leaks token length

Or leave it in the commit you were already writing. lane install hooks reads one trailer and nothing else — no diff, no commit body, no history import:

$ git commit -am "make verify constant-time"
  ...
  Why: src/auth.rs#fn verify | early return leaks token length

The subject says what you did. The trailer says what must stay true. Six months later the first is history and the second is still load-bearing.

Anchors — what the note is about

Tree-sitter resolves these, not a regular expression. A span ends where the declaration ends, a # inside a code fence is not a heading, and a brace inside a string truncates nothing.

Freshness — what happens as the code moves

Each anchor is hashed on its own span, normalized, so running a formatter stales nothing and editing #script leaves a note on #style alone. A moved or renamed file is followed, not evicted — lane audit reads git's own rename detection. A drifted note keeps getting reported until you confirm, replace, or retire it.

The next agent reads the constraints before it edits.

Two agents can annotate the same file, and the same anchor, in the same second. A note text is written as a new file, so independent findings never lock the same bytes. Land them in any order; both notes are there afterwards.

$ lane why src/auth.rs

[fn verify]
  - 01M0B9MBYB · 2026-08-14
    must stay constant-time; early return leaks token length
  - 01M0B9MZQ4 · 2026-08-14
    the token bytes must never reach a log, even at debug

lane init writes a four-line protocol into AGENTS.md so the notes are already in context. Notes are plain markdown at predictable paths — an agent finds them with no tool integration at all, which is the reason they are files and not a sidecar database.

Get the binary — pick one

Once per machine

Once per repository

Lane never calls a model. lane merge is local and deterministic, so it works the same way on a plane.

$ cargo run -p lane-tour -- start
builds a throwaway repo next to this checkout and prints its path

The tour drives the real workflows — a note drifting, three lanes landing out of order, two landings colliding — and prints every command before it runs, so you finish having seen the ones you would actually type.