Skip to content
Back to search

lot-map

MarketplaceWorks with Claude CodeGitHub

A live map of Claude Code's work, drawn beside the chat

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 14 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/alexeyw/lot-map with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/alexeyw/lot-map'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/alexeyw--lot-map/badge.svg)](/listings/alexeyw--lot-map)

HTML

<a href="/listings/alexeyw--lot-map"><img src="/api/listings/alexeyw--lot-map/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

At the prompt of a terminal session:

/plugin install lot-map --marketplace alexeyw/lot-map

Answer `y` to add the marketplace, then choose a scope. From a shell:

claude plugin install lot-map --marketplace alexeyw/lot-map

If it answers that the plugin is not found in any marketplace, add the marketplace first:

claude plugin marketplace add alexeyw/lot-map
claude plugin install lot-map@lot-map

In the desktop app: click **+** next to the prompt box, then **Plugins**, **Add marketplace** with `alexeyw/lot-map`, then **Add plugin**.

The pane opens by itself when a session starts. In a terminal it needs at least 144 columns, otherwise type `/lot-map`, and it draws text only unless you ask for the map's picture: see [In a terminal](#in-a-terminal). Built and tested on Claude Code 2.1.321 on macOS; users report it working on Windows as well.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 13 lines
  1. {
  2. "name": "lot-map",
  3. "description": "A live map of Claude Code's work, drawn beside the chat",
  4. "owner": {
  5. "name": "alexeyw"
  6. },
  7. "plugins": [
  8. {
  9. "name": "lot-map",
  10. "source": "./"
  11. }
  12. ]
  13. }
README.md · README · 210 lines
  1. # lot-map
  2. A mod for Claude Code: a live map of the work, in a pane beside the chat. Every tool call, model step, hook and skill sends a pulse from the centre to its station, so you see memory, files, shell, web and agents at work instead of reading a list of commands.
  3. ![The map during a work session](docs/demo.gif)
  4. *A made-up session replayed through the mod's own drawing code. [Video (MP4)](docs/demo.mp4).*
  5. ## Install
  6. At the prompt of a terminal session:
  7. ```
  8. /plugin install lot-map --marketplace alexeyw/lot-map
  9. ```
  10. Answer `y` to add the marketplace, then choose a scope. From a shell:
  11. ```bash
  12. claude plugin install lot-map --marketplace alexeyw/lot-map
  13. ```
  14. If it answers that the plugin is not found in any marketplace, add the marketplace first:
  15. ```bash
  16. claude plugin marketplace add alexeyw/lot-map
  17. claude plugin install lot-map@lot-map
  18. ```
  19. In the desktop app: click **+** next to the prompt box, then **Plugins**, **Add marketplace** with `alexeyw/lot-map`, then **Add plugin**.
  20. The pane opens by itself when a session starts. In a terminal it needs at least 144 columns, otherwise type `/lot-map`, and it draws text only unless you ask for the map's picture: see [In a terminal](#in-a-terminal). Built and tested on Claude Code 2.1.321 on macOS; users report it working on Windows as well.
  21. ## Updating
  22. From a shell:
  23. ```bash
  24. claude plugin marketplace update lot-map
  25. claude plugin update lot-map@lot-map
  26. ```
  27. Then start a new session. The first command is needed: without it the second one reports the installed version as the latest.
  28. What each version changed is in [CHANGELOG.md](CHANGELOG.md).
  29. ## What lights up
  30. | Station | When |
  31. | --- | --- |
  32. | You | your messages, questions and files sent to you, the task list and the plan |
  33. | Model | each model request, context compaction |
  34. | Memory | Claude Code's memory folder, plus whatever you name in the options |
  35. | Files | Read, Write, Edit, Grep, Glob, and shell commands that work on files and nothing else: they read, search, move, delete or edit in place (`cat`, `grep`, `mv`, `rm`, `sed`, `tee`, `find … -delete`) |
  36. | Shell | every other shell command |
  37. | Network | web fetch and search, MCP servers, and shell commands known to reach the network: `curl`, `gh`, `ssh`, `rsync`, `git push`, `npm install`, `docker pull` and the like, also inside `$(…)` |
  38. | Browser | browser tools |
  39. | Agents | subagents, workflows and schedules; their own calls start from this station |
  40. | Skills | skills, tool search, and the skill and plugin catalogue |
  41. | Hooks | settings hooks that refuse a call, ask for permission, add context or take a moment |
  42. On Windows the PowerShell tool is read the same way as Bash, with PowerShell's own names: `Get-Content` and `Select-String` light Files, `Invoke-WebRequest` lights Network. A program run by its full path is read by its name, also from a quoted path with a space, and `CURL.EXE` is `curl`.
  43. The shell stations go by the command's name, not by what it does: a script that opens a connection itself, such as `python -c "…"`, shows as Shell. A command behind `sudo`, `env`, `timeout`, `nohup`, `xargs` and the like is read as the command it runs, and `find … -exec` as the command it is told to run. `npx` counts as Network only with `-y`, since without it it mostly runs what is installed already.
  44. A pulse flies out when something starts and returns when it ends. Refusals and errors turn red.
  45. ## Reading the map
  46. - **The route.** A thin line joins the last few stations the main loop went through, in order, and its newest leg draws itself. A leg stays for 40 seconds and then fades over 20, so a minute after the work stops only the spokes are left; their thickness keeps where the work went. Model steps are left out, or every leg would pass through Model.
  47. - **Worn spokes.** A spoke grows thicker and brighter the more its station is used, so at the end of a session the map shows where the work went.
  48. - **How long.** Two clock hands grow around a station while a call runs: the inner one goes round in a minute, the outer one in ten.
  49. - **Background work.** A command sent to the background, a monitor, a background subagent or a workflow stays lit on its station after the turn that started it is over, with the clock hands growing, until the task reports that it ended. A task that failed leaves the red dot. The report itself is not shown as a message of yours.
  50. - **Several at once.** Calls that start together fly side by side, and the station carries their number, such as `×3`.
  51. - **What went wrong.** A red dot with a count stays on a station from an error or a refusal until your next message.
  52. - **Memory.** It has a colour of its own. A solid pulse is a memory Claude asked for; a hollow one on a dashed line is what a hook brought unasked. Under the station, the plain number counts the first and `↓` the second.
  53. - **The context window.** The ring around the centre fills as the session goes, with the percentage above the name. It turns amber at 70% and red at 90%.
  54. - **A change of model.** The centre and the Model station ring for a few seconds, and the feed gets a row such as `opus 5.5 → fable 5.2`. This also happens when a session starts on a different model from the last session in the same folder.
  55. - **Subagents.** Each one still at work circles the Agents station as a small dot, and its calls start from there.
  56. - **The answer.** One wide ring leaves the centre when the answer is ready.
  57. Below the map are a line that says what runs now, and the last 16 rows: `●` running, `·` done, `✕` failed or blocked, `◆` a change of model. Finished calls that follow one another at one station fold into one row, marked `+2` for the two it stands for besides the one named.
  58. Each row is one line. Its words are cut at the pane's edge; its time stands in a column at the right, with a dash for what took none, such as a message arriving, and on the answer's row the length of the whole turn. A row with a long label has a `▸` before its time: press it to read the row whole, and again to close it. One row is open at a time. In a terminal the line of now also holds the context percentage and the model at its right, since no drawing is there to show them.
  59. | At work | Subagents | A hook refuses |
  60. | --- | --- | --- |
  61. | ![At work](docs/map-working.png) | ![Subagents](docs/map-agents.png) | ![A hook refuses](docs/map-blocked.png) |
  62. | A change of model | After the answer | Light colours |
  63. | --- | --- | --- |
  64. | ![A change of model](docs/map-switch.png) | ![After the answer](docs/map-after.png) | ![Light colours](docs/map-light.png) |
  65. ## In a terminal
  66. A terminal shows the rows alone. With `terminalView` set to `picture`, a terminal that shows pictures, such as iTerm2 3.5 and later, kitty or Ghostty, gets the map as a picture above the rows, moving as it does in the desktop app. Claude Code must draw in fullscreen. If the pane stands under the conversation and not beside it, Claude Code is drawing on the main screen, and the rows stay alone: type `/tui fullscreen`, or start it as `CLAUDE_CODE_NO_FLICKER=1 claude`. Inside tmux, set `allow-passthrough on` and `focus-events on`. Any other terminal shows the rows alone, as before, and so does a pane narrower than 24 columns.
  67. The mod paints the picture itself, from the same drawing as the desktop app's, with letters from the X.Org misc-fixed bitmap fonts, which are in the public domain; [FONTS.md](FONTS.md) says where they come from. It paints up to thirty frames a second while anything on the map moves. The core breathes in the picture only while something runs, smoothly for ten minutes after the map last changed and then a frame every five seconds; at rest the picture stands still once the trails have faded.
  68. With `theme` on `auto` the picture is light or dark by the terminal's `COLORFGBG`, which iTerm2, rxvt and Konsole set; where nothing says, it is dark, and on a light terminal that does not say, set `theme` to `light`. The picture has no background of its own, so the terminal's shows through it; in iTerm2 that is a shade off the pane's grey, which leaves a faint box around the map. `colors` with `background=#rrggbb` gives the picture a background of its own.
  69. Nor does a terminal say how tall its cells are. `cellShape` does: how many times taller a cell is than it is wide, 2.4 by default, as iTerm2 draws Monaco 12, and about 2 for Menlo in kitty. If the picture leaves an empty band below it, raise it; if the band is at its right, lower it.
  70. ## In VS Code
  71. In the VS Code extension the pane is short, and the map drawn as wide as the pane does not fit it. There, and only there, three buttons stand at the end of the line of now. **Zoom out** and **Zoom in** draw the map at one of six widths, from 160 to 400 pixels, or as wide as the pane. **Hide map** folds the pane to that one line, and **Show map** brings the map back. What you chose is kept for the next session.
  72. ## Options
  73. The install offers them on a screen. Later, use `/config` in a terminal or `claude plugin configure`, then restart the session.
  74. | Option | Default | Meaning |
  75. | --- | --- | --- |
  76. | `language` | `en` | `en`, `ru`, `es`, `fr`, `de`, `it` or `pt` |
  77. | `coreName` | `CLAUDE` | what the circle in the middle says, up to ten characters |
  78. | `memoryServers` | `memory` | MCP servers whose tools light Memory |
  79. | `memoryCommands` | none | shell commands or scripts that light Memory; a name counts when it is the command itself or begins with it and `-`, `_` or `.`, so `recall` also names `recall-sync.py` |
  80. | `memorySubcommands` | none | words after a memory command that the map may show, such as `add` or `search`; without them the command goes by its own name |
  81. | `memoryPaths` | none | parts of a path that make a file a memory |
  82. | `memoryLabels` | none | short names for memory tools, each as `tool=name` |
  83. | `hookRecords` | `false` | turn on if a hook of yours adds memory records numbered like `[#123]`; they appear on Memory by number only. Such a number in the text of any hook counts, not only a memory hook's |
  84. | `hookReasons` | `false` | show the first line of a hook's refusal, up to 72 characters; off, the map says only which tool was stopped |
  85. | `theme` | `auto` | the map's colours: `dark`, `light`, or `auto`, which is dark on a dark surface and light on a light one |
  86. | `background` | `solid` | the map's own background, or `transparent`, which lets the pane behind it show through. The rim around the labels keeps the background's colour, so on a surface of another shade it shows as a faint halo |
  87. | `colors` | none | colours of your own, each as `name=#rrggbb`; see [Colours of your own](#colours-of-your-own) |
  88. | `layout` | `you-top` | where you are on the map: `you-top`, or `you-bottom`, which turns the ring half a turn so that you are at the bottom and the network and the browser at the top |
  89. | `motion` | `full` | `full`, or `reduced`: nothing flies, spreads or spins. A call still lights its station and flashes its spoke, the route still gets its leg, and those only fade; the clock hands around a running station stay, as slow as a clock's |
  90. | `textSize` | `footnote` | the size of the rows under the map: `caption`, `footnote` or `body`. A terminal has one size and ignores it |
  91. | `terminalView` | `text` | how the map looks in a terminal: `text`, the rows alone, or `picture`, the map's picture above them in a terminal that shows pictures; see [In a terminal](#in-a-terminal) |
  92. | `cellShape` | `2.4` | for the terminal picture: how many times taller a terminal cell is than it is wide, from 1.2 to 4, so that the picture fills its box; see [In a terminal](#in-a-terminal) |
  93. For example, Russian labels and your own memory server:
  94. ```bash
  95. echo '{"language":"ru","memoryServers":"my-memory"}' | claude plugin configure lot-map@lot-map --values-stdin
  96. ```
  97. Lists are written with commas.
  98. | Russian labels | `layout` set to `you-bottom` |
  99. | --- | --- |
  100. | <img src="docs/map-russian.png" width="320" alt="The map with Russian labels"> | <img src="docs/map-turned.png" width="320" alt="The map turned, with the person at the bottom"> |
  101. ## Colours of your own
  102. `colors` replaces the map's colours one by one. Set one, a few, or all thirteen; what you leave out stays as it is.
  103. ```bash
  104. echo '{"theme":"dark","colors":"accent=#7fb4ff,active=#b8d6ff,text=#e6edf7"}' | claude plugin configure lot-map@lot-map --values-stdin
  105. ```
  106. | Name | What it colours |
  107. | --- | --- |
  108. | `background` | the map's ground, and the rim around the labels |
  109. | `node` | the inside of a station and of the centre |
  110. | `line`, `spoke` | the dashed contours and the idle spokes |
  111. | `text`, `label`, `faint` | the name in the centre and lit labels, the other labels, the counts |
  112. | `accent`, `active` | the main colour, and a station at work |
  113. | `error` | errors and refusals |
  114. | `memory`, `memoryActive` | the Memory station and its spoke |
  115. | `route` | the route between stations |
  116. <img src="docs/map-colors.png" width="640" alt="The map in two palettes of one's own: a cool blue one and a green one">
  117. - Only `#rgb` and `#rrggbb` are taken. Anything else, and any other name, counts as not set.
  118. - With `theme` left on `auto`, a colour of your own holds on a light surface as well, and the rest is repainted as before. With a whole palette of your own, set `theme` to `dark` or `light`.
  119. - With `background` set to `transparent`, still give `background` here the colour of your pane: the rim around the labels takes it, and the halo is gone.
  120. ## What it shows and what it keeps
  121. The mod makes no network requests, reads no files, runs no processes, calls no model and adds nothing to the conversation. Its rows live only for the session. The same on one page: [Privacy](PRIVACY.md).
  122. Like any mod that follows tool calls, it is handed every call's whole input, including command lines and the text written to files. It takes names from that and nothing else; the code that does so is `classify` in `hooks/classify.ts`. A marketplace added from this repository follows its `main` branch, so an update brings whatever is there: read the diff before updating if that matters to you.
  123. It asks Claude Code for one thing: how full the context window is, after each model step. Between sessions it keeps one thing, the name of the model last used in each folder, so that it can show a change. Each is stored under the folder's full path, in Claude Code's own store for the plugin.
  124. What its hooks do. The mod listens to the session's start, prompts, turns, model steps, tool calls, skills, compaction, and to three events of settings hooks: `PreToolUse`, where it sees whether a hook refused the call, asked for permission or took a moment, and `UserPromptSubmit` and `SessionStart`, where it sees the context a hook added. Each of its hooks passes the event on as it came and returns what came back as it was: it changes no input, no result, no context and no permission decision, and makes none of its own. Its one command, `/lot-map`, opens the pane.
  125. A label holds a name, never content:
  126. - a file: the last two parts of its path;
  127. - a web address: the host alone, without a login, password, path or query; an address that can be read two ways shows only its scheme;
  128. - a shell command or a monitor: the short description Claude wrote for it, or the command's name, never the command line. The description is the model's own words, and the mod shows them as written;
  129. - a search: the tool's name for `Grep` and `Glob`, the words `web search` for a web search and `loading tools` for a tool search, in the map's language, never the pattern or the query;
  130. - a memory call: the tool's name and a record number or short identifier, never the text or the query;
  131. - a memory command: its name, and the word after it only if you listed that word in `memorySubcommands`;
  132. - a subagent: the short description it was started with;
  133. - a background task's report: that the task ended and whether it failed, never its summary or its output;
  134. - a hook's refusal: the name of the tool it stopped. Its first line shows only with `hookReasons` on, because a refusal may quote what the hook found.
  135. Control characters are taken out of every label before it is drawn.
  136. A fault on the map never reaches a tool call or a model turn.
  137. ## Developing
  138. ```bash
  139. claude plugin test .
  140. claude plugin validate .
  141. ```
  142. Words live in `hooks/text.ts`; a new language is one more table there and one more value of `language` in `.claude-plugin/plugin.json`.
  143. The terminal picture is painted by `hooks/raster.ts`, which reads the drawing `drawMap` makes. A test paints every kind of drawing and fails on anything the painter does not know, so a change to the drawing that needs more of SVG shows there first. Another, `the terminal picture's font has every letter the map writes, in every language`, names the letters a new language needs added to `hooks/font.ts`; [FONTS.md](FONTS.md) says how to make that file again.
  144. Before you send a change, read [CONTRIBUTING.md](CONTRIBUTING.md). What the mod holds to, and the check behind each point, is in [PRINCIPLES.md](PRINCIPLES.md).
  145. ## License
  146. [MIT](LICENSE)

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.