
living-map
A decision ledger for long Claude Code sessions: remembers what is settled across compaction, shown as a board
Install with your AI
Paste into Claude Code, Cursor, or any agent — it reads the repo and wires the tool into your project.
Install and set up living-map (git-clone project) into my current project. Found on https://claudeers.com/living-map Repo: https://github.com/harshit-pi/living-map Homepage/docs: — Detected install method: git-clone → git clone https://github.com/harshit-pi/living-map Category: devtools. Platforms: cli, api, desktop, web. Read the repo's README for exact setup and env vars, then install it and wire it into my project. Claudeers Health Verdict: active; community-verified: false. Confirm the source before running anything.
git clone https://github.com/harshit-pi/living-map
// compatibility
| Platforms | cli, api, desktop, web |
|---|---|
| Operating systems | — |
| AI compatibility | claude |
| License | MIT |
| Pricing | open-source |
| Language | TypeScript |
A live map of your Claude Code chat, beside it.
What waits on you, what is still open and what was decided, kept up to date as you talk, with nothing to ask for.
https://github.com/user-attachments/assets/73b3762c-e3b1-4c2b-9492-965592b0af54
Long Claude Code sessions bury the things you need to act on. Living Map reads your chat as it grows and keeps it as one mind map in a page beside it:
- It follows by itself. Type
/living-maponce in a chat. A few seconds after each turn, the map files what was new: questions waiting on you, tasks Claude is on, decisions made, what changed in your code. You never tell it what happened. - Lenses show what matters now: Waiting (on you), Open, Decided and Changed, with a strip that steps through them. Settled topics fold away; each decision sits under the topic where it was made, and findings sit in the list.
- Answer from the map. Answer a question, pick an option or tick a task on the map, and it reaches your chat at once.
- Side chats on any item: a read-only Claude that has read the map and the chat, can read your project, and proposes changes to the map you apply with one click.
- An empty chat starts as an empty map that fills in as you talk. A chat you link partway through is read from its start, or from its newest 40 turns if it is longer.
Everything runs on your machine. Living Map talks to the model through your own Claude Code (claude -p) and keeps its data in ~/.living-map/.
Install
You need Node.js 23.6 or later, and Claude Code installed and signed in (claude on your PATH).
Ask Claude Code to do it
Paste this into a Claude Code chat:
Install Living Map for me from https://github.com/harshit-pi/living-map:
1. Check that `node -v` is 23.6 or newer and that `claude` is on my PATH. If not, stop and tell me what to install.
2. Clone it to ~/living-map (if that folder already exists, run `git pull` there instead), then run `npm install` in ~/living-map.
3. In ~/living-map, run `npm run skill -- --hook` to install the living-map skill and its hook.
4. Tell me it is done, and that I type /living-map in any Claude Code chat to open its map.
Then type /living-map in any chat: in the desktop app, the terminal or an IDE. If that chat does not list the skill yet, start a new one.
Or by hand
git clone https://github.com/harshit-pi/living-map.git ~/living-map
cd ~/living-map
npm install
npm run skill -- --hook
npm run skillinstalls theliving-mapskill into~/.claude/skills/.--hookalso adds oneUserPromptSubmitentry to~/.claude/settings.json, leaving the rest as it is: whatever you did on the map comes with your next message, if it has not reached the chat already.
Using it
/living-mapstarts the server if it is not running (in the background, so it outlives the chat), links the chat and opens the map: in the desktop app's browser pane beside the chat if there is one, or as a link to open. Nothing to choose, nothing to describe.- Saying
/living-mapagain in the same chat opens its map again. Another chat gets its own map. - Ask the chat "what's pending?", "what's open?" or "what did we decide?" and it reads that one section of the map back: a few lines, not the chat again. "What does my map say?" or "where were we?" gets the whole outline: what waits on you, what is open, what was decided and what Claude is on, then the map with settled topics folded. Pasted into a file, that outline is a handoff.
- A handover of each chat is kept on disk and rewritten whenever its map changes, so a session that stops halfway still leaves one: what waits on you, the next steps, what is still open, and what was decided, when and why. It's at
~/.living-map/handover/projects/<folder>.mdfor the chat you were in most recently in a project folder (the folder's path with every character other than a letter or digit turned into-), and~/.living-map/handover/<chat>.mdfor each chat. One line in a project's CLAUDE.md, "Before anything else, read ~/.living-map/handover/projects/.md if it exists.", has every new chat start from it. - The first time each kind of box is on screen, a tip explains it. Each tip shows once in that browser; No more tips turns them off and Show tips again (under ⋯) brings them back.
- The map is one page on http://localhost:4317. It stays signed in in the browser that opened it. To have it in your own browser too, open http://localhost:4317 there and click Show my maps (or choose ⋯ → Open in your browser on the map); from then on that address lists every mapped chat, each opening in a new tab. Any browser on this machine can sign itself in that way, so on a computer you share, another account could see your maps.
Cost. Filing new turns is a quick call on Claude Code's default model that reads only those turns: about $1.70 per 100 turns on Opus at API prices, which on the author's own chats came to about 0.13% of the tokens the chat itself used. On a Claude subscription it counts toward your usage, and the page shows no prices. Side chats cost only when you open one.
Updates
Every push to main that passes CI publishes a release (v0.1.<n>).
When a newer one is out, the map's top bar shows New version available. One click pulls it (git pull --rebase), installs (npm ci), builds and restarts, and the page reloads into it. The installed skill is rewritten from the new copy as the server starts.
It runs only on a clean checkout of main; otherwise the popover says what is in the way.
How it works
your chat (transcript) ──new turns──► server ──► claude -p (files them as changes) ──► ~/.living-map/ledger.db
│ │
your chat ◄──answers, picks, ticks───────┤◄──────────────── the map page ◄──live view───────┘
- The server reads your chat's transcript as it grows, and never tool output. A fresh
claude -pcall with no tools turns the new turns into typed changes, and code checks each one before it is stored. - The map never re-reads the whole chat: each call is sent the map so far and only the turns since the last call.
- Side chats run as their own
claude -p, read-only and kept to your project folder, with no web. - The model sits behind one interface (
server/providers/types.ts). Claude Code is the default; another model is one new file.
Project layout
| Path | What it holds |
|---|---|
ledger/ | the map of your chat: following the transcript, the store, side chats |
server/ | routes, the token, the one-click update, the model providers |
web/map/ | the map's page |
web/brand.css | every colour and font, by role: restyle the app in one place |
skill/ | the living-map skill, its installer, starter, hook and listener |
Contributing
Issues and pull requests are welcome. See CONTRIBUTING.md for setup, the checks every change must pass, and the code conventions, and AGENTS.md for how the code fits together.
Security
The server listens on 127.0.0.1 only, and every API call needs a local token kept in ~/.living-map/token, readable only by you. See SECURITY.md to report a problem.
License
// faq
What is living-map?
A decision ledger for long Claude Code sessions: remembers what is settled across compaction, shown as a board. It is open-source on GitHub.
Is living-map free to use?
living-map is open-source under the MIT license, so it is free to use.
What category does living-map belong to?
living-map is listed under devtools in the Claudeers registry of Claude-compatible tools.
// embed badge
[](https://claudeers.com/living-map)
// retro hit counter
[](https://claudeers.com/living-map)
// reviews
// guestbook
// related in Developer Tools
The agent harness performance optimization system. Skills, instincts, memory, security, and research-first development for Claude Code, Codex, Opencode, Curs…
Makes your AI agent think like the laziest senior dev in the room. The best code is the code you never wrote.
AI coding assistant skill (Claude Code, Codex, OpenCode, Cursor, Gemini CLI, and more). Turn any folder of code, SQL schemas, R scripts, shell scripts, docs,…
Use Garry Tan's exact Claude Code setup: 23 opinionated tools that serve as CEO, Designer, Eng Manager, Release Manager, Doc Engineer, and QA