claudeers.
// Developer Tools

living-map

A decision ledger for long Claude Code sessions: remembers what is settled across compaction, shown as a board

// Developer Tools[ cli ][ api ][ desktop ][ web ][ claude ]#claude#devtools◷ MIT$open-sourceupdated 22 days ago
Actively maintained
100/100
last commit 5 days ago
last release 7 days ago
releases 399
open issues 11

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-2
Repo: https://github.com/HiAnur/living-map
Homepage/docs: —
Detected install method: git-clone → git clone https://github.com/HiAnur/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.
// or clone
git clone https://github.com/HiAnur/living-map

// compatibility

Platformscli, api, desktop, web
Operating systems—
AI compatibilityclaude
LicenseMIT
Pricingopen-source
LanguageTypeScript

Get your FREE $2.50 API credits to access TickAtlas financial data ↗

Living Map

See where your Claude Code chat stands, at a glance.
Living Map draws your chat as a mind map while you work: what waits on you, what is still open, what was decided. You answer Claude right on the map.

https://github.com/user-attachments/assets/73b3762c-e3b1-4c2b-9492-965592b0af54


When a project gets too big for your head, you draw a mind map. When a Claude chat does, you scroll, and coming back to it means asking Claude "where were we?" and waiting while it digs through everything. Living Map is that answer, already sitting beside the chat. It is a view for you, not memory for Claude: it reads your chat as it grows and keeps it as one mind map in a page beside it:

  • It follows by itself. Type /living-map once 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.
  • What waits on you stays on top. A question Claude asked stays in the strip at the top of the map until you deal with it, however far the chat has scrolled since. When work is waiting on your answer, the map draws what it holds up.
  • Lenses show what matters now: Waiting (on you), Open, Decided and Changed. 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. Claude's reply opens with "From your map: you answered …" in your words, so the decision is in the chat's own transcript too.
  • A handover that is always written. Each chat keeps one in ~/.living-map/handover/, rewritten whenever its map changes: waiting on you, next steps, still open, and what was decided, with the date and the reason. A session that stops halfway still has one.
  • 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.

Isn't this just…?

  • Asking Claude "where were we?" That works, but it costs a turn and answers in a wall of text. The map is already there when you come back, and you can click it.
  • A handover file, or ADRs? Those work between sessions, and Living Map writes the handover for you. The map is for the moment you come back to a chat, or when Claude asks something and it scrolls away.
  • Shorter sessions? Keep them short too. A two-hour session buries a question just as well, and with several sessions the question becomes which one is waiting on you.
  • A changelog? A changelog says what changed. It doesn't say what Claude asked and is still waiting on, or what you decided and why.
  • A memory tool? Memory tools help Claude remember. Living Map helps you see where the chat stands.

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 skill installs the living-map skill into ~/.claude/skills/. --hook also adds one UserPromptSubmit entry 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-map starts 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-map again 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. For a new chat, point it at the handover instead: ~/.living-map/handover/projects/<folder>.md (the project's path with every character but letters and digits turned into -, as Claude Code names its own folders: /Users/me/work → -Users-me-work) is the chat you changed last in that project, so one line in the project's CLAUDE.md can tell every new chat to read it first.
  • 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>.md for 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>.md for 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 -p call 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

PathWhat 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.cssevery 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

MIT

// 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.

7 views
★ 58 stars
unclaimed
updated 22 days ago

// embed badge

living-map on Claudeers
[![Claudeers](https://claudeers.com/api/badge/living-map-2.svg)](https://claudeers.com/living-map-2)

// retro hit counter

living-map hit counter
[![Hits](https://claudeers.com/api/counter/living-map-2.svg)](https://claudeers.com/living-map-2)

// reviews

// guestbook

0/500

// related in Developer Tools

🔓

The agent harness performance optimization system. Skills, instincts, memory, security, and research-first development for Claude Code, Codex, Opencode, Curs…

// devtoolsaffaan-m/⟨JavaScript⟩★ 307,864◷ MIT[ claude ]
🔓

Makes your AI agent think like the laziest senior dev in the room. The best code is the code you never wrote.

// devtoolsDietrichGebert/⟨JavaScript⟩★ 187,728◷ MIT[ claude ]
🔓

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,…

// devtoolssafishamsi/⟨Python⟩★ 147,800◷ MIT[ claude ]
🔓

Use Garry Tan's exact Claude Code setup: 23 opinionated tools that serve as CEO, Designer, Eng Manager, Release Manager, Doc Engineer, and QA

// devtoolsgarrytan/⟨TypeScript⟩★ 140,465◷ MIT[ claude ]
→ see how living-map connects across the ecosystem