I run several Claude Code sessions at the same time, and they sometimes change the same files or servers.
Build a small coordination system so they don't step on each other.

STEP 1 — before writing any file: list the shared things in this project that sessions should claim
(servers, databases, DNS, deploy configs, CMS, shared docs — only what actually exists here). Then STOP and
ask me to confirm the list.

STEP 2 — after I confirm, build this:

1. A bash script `coord.sh` (bash, coreutils, grep, sed and awk; nothing else). It keeps its state in `.coord/`
   and its board in `BOARD.md`, both next to the script. Commands:
   - `claim <name>... [--why "text"]` — an advisory lock made with `mkdir` (atomic) under `.coord/claims/`.
     If another session holds it, refuse, print who holds it and for how long, and exit 1. Several names are
     all-or-nothing: if one is held, take none.
   - `release <name>...` — only the holder can release. Anyone else, or an unclaimed name, exits 1.
   - `say "message"` — append one line to BOARD.md:  - **YYYY-MM-DD HH:MM:SS** · `<session>` — <message>
     Timestamps must be unique on the board (wait a second if needed): an ask's timestamp is its ID.
   - `ask <session-or-prefix-*> "message"` — a say whose message is "ASK → <target>: message". It stays OPEN
     until a post whose message BEGINS "DONE re <its timestamp>" or "DECLINED re <its timestamp>".
   - `reply "<timestamp>" DONE|ACK|DECLINED "message"` — posts "<KIND> re <timestamp> — message". Refuse if no
     ASK has that timestamp. ACK means "seen, working on it" and keeps the ask open.
   - `asks [session]` — open asks addressed to that session (prefix-* targets match).
   - `takeover <name> --human-ok "<my exact words>"` — take a claim someone else holds; it records my words
     on the board. Sessions may use it only after I say yes in chat.
   - `status` — claims held (with age; anything over 90 minutes is flagged STALE), open asks, last 8 posts.
   The session name comes from the COORD_SESSION environment variable; claiming or posting without it fails.
2. Names starting with @ (like @prod-db or @dns) are shared resources, compared exactly as typed. Every other
   name is a file path, even if the file doesn't exist yet: resolve symlinks, `..` and the current folder,
   then store it relative to the folder holding coord.sh, so two spellings of one file are the same claim.
3. A STALE claim is never released automatically and still blocks others.
4. Never delete board history. After each post, if BOARD.md is over 150,000 bytes, move posts from past
   months into archive/BOARD-YYYY-MM.md. Count posts before and after; if the counts differ, change nothing.
   `asks` and `reply` must search the archive too.
5. Add a short "Coordination" section to CLAUDE.md telling every session to: pick a COORD_SESSION name;
   run status at the start of every task; claim before changing anything on the confirmed list; post
   ABOUT TO before risky changes and DONE + "Released" after; use ask for anything it needs from another
   session; keep posts under ~300 characters. Put COORD_SESSION=<name> in front of every command (each Bash
   call is a fresh shell, so export doesn't stick). Include the confirmed list.
6. Write a test script that runs in a temporary folder and leaves nothing behind in the project. Prove:
   second claim refused, non-holder can't release, two spellings of one file collide, an ask stays open
   after ACK and closes on DONE, archiving loses no posts, and 20 sessions racing for one claim produce
   exactly one winner. Pair every "X is gone" test with a check that proves the test can see X when it is
   there; a test that can't fail proves nothing. Run it and show me the output. Don't call it done until
   every test passes.