Where state lives

Three places on disk, split by who reads them. Every file and directory AutoDev keeps, and what each one holds.

Split by reader #

AutoDev keeps its state in files, and it keeps them in three places.

.autodev/ in the repository holds what a person reads, edits and reviews in a pull request, and what travels with a clone.
~/.autodev/<project>-<hash>/ holds what only the machine reads: the state of a run, the daemon's pid, sessions, checkpoints, the thread, the event log, logs and attachments.
~/.autodev/ holds a few files that belong to the machine and not to any project.

<project> is the name of the project's folder. <hash> is the first 8 hex characters of a SHA-1 of the folder's full absolute path, so two clones with the same name in different places never share a folder.

The split is on by default. Setting AUTODEV_SPLIT_STATE to 0 or false is the only way back, and it keeps the machine's files inside .autodev/. A project that was last used before the split moves its files on first contact: the CLI does it when it starts, and the panel does it when it activates. The move copies each file, removes the original, and never overwrites a file that is already in the new place.

AutoDev never touches CLAUDE.md or AGENTS.md.

In the repository #

Path	What it holds
`goal.md`	The objective. Each message you send, from the panel or with `autodev send`, is appended to it under a heading with the time, newest last. The file is yours to edit.
`memory.md`	What a later turn or a later night would pay to learn again: decisions and why, constraints, dead ends. Every run starts with one. Participants write to it with the `remember`, `revise` and `forget` tools, one line for each memory, and you can edit it.
`config.json`	The project's settings. Every config key lists them, and says which few live on the machine instead.
`participants/`	One `<id>.md` per participant. The participant file format describes the file.
`mcp.json`	The configuration of AutoDev's own MCP server, written when it is first needed and passed to a CLI in addition to yours.

AutoDev's own commits leave .autodev/ out. Whether any of these files is committed is your decision.

On the machine, per project #

These files are in ~/.autodev/<project>-<hash>/.

Path	What it holds
`state.json`	The status of the run, whose turn it is, the heartbeat, a pending gate or proposal, spend, and the counters that bound a wait, an audit and a run of talk.
`control.json`	The command waiting for the daemon: `none`, `pause`, `resume` or `stop`.
`daemon.pid`	The pid of the process that supervises the daemon.
`sessions.json`	The session id of each participant, with the provider it belongs to.
`inbox.json`	The queue of operations sent to the daemon, such as your messages. The daemon is the only one that drains it.
`checkpoints.json`	The list of checkpoints that `autodev restore` reads.
`thread.jsonl`	The shared thread, one JSON object per post.
`events.jsonl`	The log of machine activity. The panel's Feed is built from it.
`cursors.json`	Per participant, the last post it has seen.
`turn.json`	Whose turn is open, and whether they have posted.
`notices.json`	The notices participants left you while the run kept going, with their answers, holds and dismissals.
`browser-profile/`	AutoDev's own browser profile, where the logins you made for the browser tools live. `autodev new-run` leaves it where it is.
`attachments/`	Images attached to a message, whose paths the message text carries.
`logs/`	`daemon.log` and `serve.log`. Reading the logs describes them.

autodev new-run moves these files, except the browser profile, into a folder beside this one, named after it with .run- and the day added, and -2, -3 for a second one the same day. It also copies goal.md and memory.md there before it empties them.

On the machine, for all projects #

These files are in ~/.autodev/.

Path	What it holds
`workspaces.json`	An index of every project started on this machine, which `autodev workspaces` lists. It can be rebuilt.
`config.json`	The machine's settings: `suspendOnCompletion` and the `notify` block. Every config key says why they are here.
`trust.json`	The folders you have trusted. It lives outside the repository so that a clone cannot mark itself trusted.
`providers.json`	The agent CLIs you adopted. It holds no credentials, and it can be rebuilt by detecting them again.
`quota.jsonl`	The quota measurements. It cannot be rebuilt, and it never rotates.
`serve.json`	The connection descriptor of `autodev serve`, with its token. A machine runs one.
`team/`	Your default team, as participant files. A new project is offered it.

A damaged file #

A file that will not parse is read as empty or as default, never as a crash. The effect differs by file:

state.json falls back to defaults.
checkpoints.json reads as no checkpoints, which loses the restore history and nothing else.
trust.json reads as nothing trusted, and AutoDev asks again.
providers.json reads as nothing adopted, and AutoDev detects again.
config.json, the project's or the machine's, reads as an empty config.
notices.json reads as no notices, and cursors.json as nobody having seen anything.

Every write goes through a temporary file that is then renamed, so a reader never sees half a file.

What survives a restart says which of these files a restart depends on.