Where state lives

What Repolane saves, where, what a resume brings back, what `lane done` deletes, and what is never kept.

Everything Repolane remembers is a file, and almost all of it is plain text inside your workspace. This page lists each piece, what scopes it, what survives a restart, and what is removed when work ends. For files that land outside the folder, see What it changes on your machine.

In brief. Everything Repolane remembers is a plain file in your workspace, plus git itself: no database, no daemon. A resume repairs and reconnects; it never restores, because nothing was elsewhere. lane done deletes worktrees (and the ignored files in them) but keeps the lane file and, by default, the branches. Conversation text is never stored by Repolane.

The short version

What is stored where

Paths are from the workspace root. The “workspace repo” column applies when you made the workspace a git repo of your own with lane init --git; without it, nothing in the workspace is tracked anywhere.

The lane file

Four sections under a small header. lane start creates it. You edit it by hand from the workspace root; a session inside a lane sets its Goal with lane-memory goal "<text>", because Claude Code refuses Edit and Write outside the lane folder.

---
id: ABC-123
status: active                    # active | parked | done
ticket:
created: 2026-10-14
updated: 2026-10-14
repos:
  - repo: web
    branch: ABC-123
    base: main
---
## Goal              what done looks like
## Resume note       written by `lane park`: where things stand, next step, blockers
## Findings          things that matter only while this work is live
## Log               one dated line per event

• lane park <id> "<note>" replaces Resume note with your note (10 characters minimum) and appends a line to Log; the other sections, Findings included, are left as they are.
• At the end of every session the SessionEnd hook appends one line to Log: the time, then for each repo its branch and how far ahead, behind and dirty it is, then up to twelve files the edit tools touched. If any worktree was dirty it ends with UNPARKED. That is one line for the whole lane, not a log per repo, and it only lists files changed through Claude’s Edit, Write, MultiEdit and NotebookEdit tools: a file changed by a shell command is not in it. Nothing reads UNPARKED back to you; it is there when you open the lane file or run lane brief. A line identical to the previous one except for its timestamp is skipped, so read-only runs do not pile up copies.
• Findings are what you file with lane note file <slug> lane (lane-memory file <slug> lane from a session). They are archived with the lane. Anything still true after the work ships belongs in repo memory instead.

What a resume brings back

lane resume <id> is a repair, not a reload. It prunes stale worktree registrations in every base clone, recreates any worktree whose folder is missing from the branch that still exists, relinks env files, re-anchors the lane folder, rewrites the lane’s settings.local.json files and marks the lane active again. Your lane file, memory and branches were never anywhere else, so there is nothing to restore.

A new Claude session in the lane starts with no conversation, and gets: the whole lane file (header, goal, resume note, findings and log) when the session starts; then, with its first prompt, a state line per repo and the memory indexes (the cross-repo MEMORY.md and one per lane repo, each cut at 3,000 characters), plus .repolane/knowledge/preferences.md and every .repolane/knowledge/shared/*.md, each also cut at 3,000 characters. A session that enters a lane, or starts inside one, is also handed .repolane/LANE.md, the rules for working inside a lane. Individual memory notes are not injected. Claude can resume an old conversation with claude --resume only from the folder it ran in; lane import copies old conversations into a lane’s folder so that works. See Working with Claude.

Scope: what is shared across repos and lanes

Memory is plain markdown, and git does not treat it specially, so which scope a note belongs in is a judgement about how long it stays true. The lane note command enforces the procedure (draft, ask which scope, file it); the guard denies a session from writing those folders directly. The scope choice itself is an instruction in the session’s context, not something a hook can verify.

What is not kept

• Conversation text. Repolane does not copy or store what you and Claude said. The lane file is what you or Claude wrote into it.
• A record of refusals. The guard answers deny or allow and nothing writes it down. A refusal exists in the Claude Code transcript and nowhere else.
• Secrets. Env files are symlinked from the base clone into each worktree, never copied or read. The guard and the board try to keep recognised secret names away from a session or a page; both match by name, by one shared list, and cannot see a secret under a name they do not know (security model). Two caveats are on Install (adoption copies ignored .env* files into the base clone) and Rules (lane park commits everything that is not ignored except files with a secret name, which it leaves on disk).
• Board state. The board keeps its token and caches in memory only; stopping it discards both.
• Anything about other people. There is one user. See Teams.

What lane done removes, exactly

1. Checks every repo before touching any: dirty tree, commits that no origin/* branch has (or none on the remote you named with --pushed-to), a detached HEAD carrying such commits, a missing worktree whose branch is not fully pushed, or an ignored or untracked secret-named file the deletion would destroy (unless --discard-ignored) each stop it with nothing removed. A repo with no origin is noted and does not block.
2. For each repo: git worktree remove. Git deletes the folder, which takes the other git-ignored files (build output and the like) with it. Symlinked env files from the base clone are only links.
3. With --delete-branches: git branch -D on the lane’s branch in the base clone.
4. For each repo, if Claude saved sessions for that worktree: asks, defaulting to what delete_sessions_on_done in .repolane/config.yml says, and deletes the folder under ~/.claude/projects/ if you agree. With no terminal it does not touch them; flags are --delete-sessions and --keep-sessions.
5. Removes lanes/<id>/, prints any Findings, moves the lane file to .repolane/registry/lanes/done/. (lane brief <id> reads the archived file; see Commands.)

A lane in a local-only repo (no origin) can finish: step 1 notes it and moves on, and the branch stays in .repolane/repos/<repo>. See lane done refusing.