nod — плагин для Claude Code: правила работы и установка
Плагин для Claude Code добавляет в каждую сессию правила работы с nod. Когда в ответе появляются номера узлов, он напоминает агенту записать их.
MIT ★ 117 обновлён 2026-11-11
/plugin marketplace add WeCarbon/noddit
/plugin install nod@nodditЧто делает nod
Плагин добавляет правила использования nod в каждую сессию Claude Code и напоминает агенту записывать ответы, связанные с номерами узлов. Так вопросы и ответы агента попадают в рабочие записи nod.
Для работы установите CLI @wecarbon/noddit командой npm i -g @wecarbon/noddit, затем запустите nod init в проекте. После этого добавьте маркетплейс WeCarbon/noddit и установите nod@noddit через команды Claude Code.
Какие задачи решает
- добавить правила nod в сессии Claude Code
- напомнить агенту записать ответ с номером узла
- сохранить ответы агента в рабочем процессе nod
Примеры запросов агенту
- Записывай ответы, в которых упоминаются номера узлов.
- Используй правила nod в этой сессии и фиксируй ответы по узлам.
Как установить nod
Через маркетплейс плагинов
/plugin marketplace add WeCarbon/noddit/plugin install nod@nodditПо шагам, с командами для каждой платформы: Плагины Claude Code: маркетплейсы, установка и как собрать свой
Вопросы о nod
Как установить nod в Claude Code?
Сначала установите CLI командой npm i -g @wecarbon/noddit и выполните nod init в проекте. Затем запустите /plugin marketplace add WeCarbon/noddit, а после — /plugin install nod@noddit.
Что делает nod?
Плагин добавляет правила nod в каждую сессию Claude Code и напоминает агенту записывать ответы о номерах узлов.
Что нужно для работы nod?
Нужен CLI @wecarbon/noddit, установленный командой npm i -g @wecarbon/noddit, и инициализированный в проекте nod через nod init.
Исходный текст
SKILL.md · MIT
**English** · [Simplified Chinese](README.zh-Hans.md) · [Traditional Chinese](README.zh-Hant.md) · [French](README.fr.md) · [Arabic](README.ar.md)
# Noddit
*Where you and your AI hand work to each other.*
You give an agent a two-hour job — or five agents, one each — and walk away.
An hour later, three of them have been sitting on a question in chats you
weren't watching, and you can't tell which one is still working.
**Noddit gives your agents one place to put their work and their questions, and
gives you one screen to watch it all. Agents ask; you answer with one keypress;
the agent hears about it and carries on — while it's still running.**
<picture>
<source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/WeCarbon/noddit/main/docs/app.en.dark.png">
<img alt="The Noddit desktop app: the Available view with a pending decision open, its two options as cards, progress bars and a new request waiting for an AI" src="https://raw.githubusercontent.com/WeCarbon/noddit/main/docs/app.en.png">
</picture>
<sub>Desktop app — <a href="https://github.com/WeCarbon/noddit/releases/latest">download for macOS, Windows and Linux</a></sub>

<sub>In the terminal</sub>
## Why
| Without Noddit | With Noddit |
|---|---|
| An agent asks "A or B?" in chat. You miss it; it waits for an hour. | Every open question is on one screen, the ones blocking an agent first. |
| You answer, the answer scrolls away, the next session never sees it. | The question and your answer are a markdown file in git, for good. |
| "What are you doing? How far along?" — you have to ask, and interrupt. | Each task shows its progress bar; one that goes quiet turns grey, then red. |
| Five agents share one `TODO.md`, pick the same number, overwrite each other. | Every task is its own file with its own id; any number of agents write at once. |
| You step away and everything stops. | Each question carries a default and says what happens if you don't answer; agents keep going on the rest. |
It's not a board you plan work on. It's the line between a running agent and
you: its question reaches you, your answer reaches it, and both are kept.
## What it looks like
1. Your agent hits a choice. Instead of asking in chat, it runs:
```sh
nod ask W4 -o 1="Keep current CDN" 2="Switch to Fastly" --default 1
```
2. You run `nod` in any terminal. W4 is at the top, marked ◆ Decide, with
both options and what each one costs.
3. You press `2`.
4. The agent is told right away, reads "Switch to Fastly" and carries on.
The question and your answer stay in `decisions/active/4-pick-cdn.md`, in git.
## Quickstart (Claude Code)
```sh
npm i -g @wecarbon/noddit
cd your-project && nod init
```
Then, inside Claude Code:
```
/plugin marketplace add wecarbon/noddit
/plugin install decs@decisions-md
```
That's it. Give your agent a task as usual. It logs its work and asks its
questions through nod on its own. Run `nod` in another terminal to watch.
(`decs` still works as an alias, for every command on this page.)
Using a different agent? Paste [`AGENTS.md`](AGENTS.md) into its instructions —
the rules are plain CLI calls, so any agent with a shell can follow them.
## Three words
- **Node** — one thing an agent is doing. One markdown file.
- **Decide** — a node that needs your answer. It shows up with options; press a number.
- **Bench** — the screen you get when you run `nod`. Everything, live.
That's all you need to start. The rest of this page is how it works underneath.
---
## The idea
One kind of thing — a **node** — and one id space.
A node is something the AI does. When the agent knows how, it just does it.
When it needs the owner first, the node becomes **needs decision**, with
options, a default, and what happens if nobody answers. A running node that
hits a question doesn't spawn a second entry; it turns into a question itself,
and goes back to running when you answer.
```
decisions/
decs.json # {"letter": "W"} → refs read W12
active/12-ship-v2-4.md # a root node still in play
active/12-ship-v2-4/13-run-test-suite.md # its children live in its folder
archived/9-rotate-api-keys.md # done or closed, kept forever
attachments/12/after.png
.ids/12 # zero-byte reservation (O_EXCL)
```
Because every node is its own file and ids are reserved with `O_EXCL`, any number
of agents can write at once without colliding. Because it's markdown in git, you
get history, diffs, review and grep for free.
## What you get
**For the human — the bench.** `nod bench` is a live terminal UI over every
project you've registered. Six tabs:
| tab | shows |
|---|---|
| **Available** | what can move now: running, waiting on someone, ready to start or still blocked behind another node, needs you, answered |
| **Active** | what's happening: running and needs-decision only |
| **Human work** | what waits on you: decisions to make, and your own to-dos — whatever blocks an AI first |
| **Waiting** | held up outside — a colleague, a customer, a service — longest wait first |
| **Live** | every change, by anyone, newest first — finished nodes too |
| **All** | everything, finished nodes folded into a `✓ Completed N` row |
The left pane is the node tree with progress bars and staleness (grey past 30
minutes without an update, red past an hour). The right pane is the selected
node: status, urgency, *"if you don't answer"*, parent, dependencies, body,
attachments. Press `1`–`9` to answer, `Enter` for the default. Screenshots
render inline in the terminal (iTerm2, kitty, Ghostty, WezTerm).
**For the agent — a CLI and a contract.** Agents create nodes, break them into
child nodes, report progress, ask questions, and get notified of your answers:
```sh
nod add "Ship v2.4" --task --author "lead · release" # → W12
nod add "Run full test suite" --task --parent W12 --after W14
nod start W13
pytest | nod progress --parse pytest # bar moves by itself
nod ask W15 -o 1="Short & playful" 2="Plain & direct" --default 2 <<'EOF'
**What.** The first screen new users see after sign-up …
EOF
```
**Human work, alongside AI's.** `nod add <title> --for me` files a to-do
that's yours, not an AI's — no agent starts it, checks in on it, or takes it
as a brief. `nod assign <id> me|ai` moves a node between the two later. The
bench's **Human work** tab lists both: decisions waiting on you and your own
to-dos, whatever blocks an AI first.
**Milestones.** `nod add <title> --milestone` (or `nod assign <id>
milestone`) marks a node as a goal with sub-goals and work under it — a
phase, not a task. It's never started or finished on its own; the bench
shows it as `⚑` with a done/total count for its children, and it doesn't
need a `--due`, though it can take one.
**Due dates, estimates, a repeat cadence.** `--due <date>` on `nod add` or
`nod edit` puts a deadline on any node — overdue turns red, in the bench and
the app. `--est 2h` records whose time it costs: yours on your own to-do,
the AI's otherwise; a parent adds up both across its subtree. `--every 3d`
gives a node its own cadence, so `nod defer --every` (or `D` on the bench)
puts it off to today plus that span without typing the date each time.
**A reminder is an AI's job, not yours.** `nod add --remind "fri 2pm"` (or
`nod edit --remind`) schedules a plain AI task for that moment — it never
mixes with options, a brief, or `--for`. At the time, `nod monitor` tells
the node's own agent once, with its next step (tell the owner, then `nod
done`); the desktop app reminds you too.
**Notifications without polling.** `nod monitor` prints one line per thing an
agent must act on — an owner answer, a reply, a new item from an external
source, an answer nobody has picked up for five minutes — and remembers where
each session left off. It wakes on a filesystem event, not a timer, so nothing
waits for the next poll. The Claude Code plugin starts it for the whole session
(`nod monitor --here`, watching the current project); it goes offline by itself
after two quiet hours with a `DECS-IDLE` line. Sub-agents, or a session after
`DECS-IDLE`, arm it with Claude Code's Monitor tool:
```
Monitor({ command: "nod monitor --mine", description: "nod", timeout_ms: 1800000 })
```
A reply or note longer than a line or two needs `--summary`; that one line —
not the full text — is what a notice, a reply card's title and the bench show.
**Dependencies and order.** `--after W13` holds a node back until W13 is done.
You can still answer a question early; the node then waits as **to do** and
starts when its turn comes.
**External sources, synced on their own schedule.** Point a tiny adapter at
GitHub issues, Azure DevOps, a support inbox or a feedback form. It syncs
*references only* (id + title, optional url/state/from), never bodies, never
credentials. Register one with `--sync-cmd "..." --every 10m` and your own
running `nod monitor` runs the sync itself on that interval — stored only on
your machine (`~/.decs/source-sync.json`), never in the repo, so cloning it
never runs anyone's command. The bench header tells you, per source,
whether it's cleared and who holds what:
```
Sources github-issues ✗ unhandled 2 W7 1 support-inbox ✓ clear
```
**Approval gates for anything that leaves the building.** Attach a draft with
`--approval-content`; nod records its sha256. Before sending, the agent runs
`nod approved W20 --check draft.html` — it fails unless *you* picked the
approving option *for exactly that content*. An agent relaying "send it" from
the chat can't approve on your behalf.
**Defer.** Press `d` on anything you want out of sight. It leaves the working
views without changing state, and the agent on it is told it was deferred and stops
until you lift it.
**Act on several at once.** `Space` marks rows on the bench; with any marked,
the same single-node keys — defer, start, reassign, important, archive — act
on all of them. The desktop app does the same with `⌘`-click, `⇧`-click, or a
box dragged from empty space or from any row that isn't itself draggable, and
mirrors in-place title/description edits, image zoom and pan, and inline
Markdown/HTML previews — see [Development](#development) below for where the
two surfaces are tracked against each other.
**Every answer keeps its own history.** A node with any unanswered option is
always **needs decision** — even one that's already running or not started —
and a reply that doesn't pick one hands that round back to the agent instead
of settling it; the node returns to **in progress** and gets asked again.
Each answer you give is its own block, labelled *Decided*; picking the pencil
to change an already-locked answer adds a new block labelled *Answer changed*
right after it, never rewriting the one before.
**Refs in prose link to their node.** Write a ref like `G91` or `W305`
anywhere — a title, body, note, summary or option — and the desktop app turns
it into a link that jumps straight to that node, across projects too. The
terminal board has no pointer to click with; type the same ref at `g` or `:`
instead.
**A daily Nod counter.** ⚡, above Views in the app's sidebar and in the
terminal board's header, counts every owner action — a reply, a decision
answered, a node you filed yourself; an AI's own writes never count — across
every registered project, archived ones included. It shows today, yesterday
and the 7-day average (floored to a whole number), and moves the instant you
act rather than waiting for the next refresh. The calendar button beside it
(`c` on the terminal board) opens the Nod calendar, a GitHub-style heatmap of
the whole last year.
**Two notice sounds, synthesized live.** Settings gets two short chimes —
*AI update* and *Needs a decision* — built from a Web Audio recipe, no audio
file to ship or license. Each has its own on/off switch, an A/B variant and a
preview button, plus one shared volume slider; at most one chime plays in any
five-second span, and a decision's chime always wins over an update's in
that span.
## Install
Requires Node 22.18+.
```sh
npm i -g @wecarbon/noddit
cd ~/code/your-project
nod init --letter W # creates decisions/, registers the project
nod add "Try nod" --task --author "me · kicking the tyres"
nod # the bench (same as nod bench); q to quit
```
No install: `npx @wecarbon/noddit init --letter W` works the same way, one command at a time.
### From source
TypeScript runs directly; there is no build step.
```sh
git clone https://github.com/wecarbon/noddit.git
cd noddit && npm install
export PATH="$PWD/bin:$PATH" # add to your shell profile
cd ~/code/your-project
nod init --letter W
nod add "Try nod" --task --author "me · kicking the tyres"
nod
```
### With Claude Code
The repo is also a Claude Code plugin marketplace. The plugin injects the usage
rules at the start of every session (plus the project's open nodes, so a
resumed session picks its work back up), starts `nod monitor` for the session
so your answers reach the agent without it polling, and reminds the agent to
record what you say about a node in chat before replying.
```
/plugin marketplace add wecarbon/noddit
/plugin install decs@decisions-md
```
(`/plugin marketplace add /path/to/noddit` works for a local clone.)
The full agent guide is [`AGENTS.md`](AGENTS.md) — paste it into your own
`AGENTS.md` / `CLAUDE.md` if you use a different agent harness. The rules are
CLI calls, so any agent with a shell can follow them.
## Language
`nod` picks the UI language in this order:
1. `--lang <code>` on any command, e.g. `nod bench --lang fr`
2. the `NODDIT_LANG` environment variable (`DECS_LANG` still works)
3. `nod config lang <code>` — stored per user in `~/.decs/config.json`
(`$NODDIT_HOME/config.json`). `nod config lang` alone shows the current
language and where it comes from; `nod config lang --off` removes it.
4. the system locale (`LC_ALL` / `LC_MESSAGES` / `LANG`, `C` / `POSIX`
ignored): `zh_CN` → `zh-Hans`, `zh_TW` / `zh_HK` → `zh-Hant`, `fr_*` →
`fr`, `ar_*` → `ar`
5. the OS display language, when none of those locale variables are set —
plain Windows terminals (cmd, PowerShell) have none, so nod reads it the
way Node's `Intl` reports it
6. otherwise, English — also where a locale nod has no translation for
ends up
Codes: `en`, `zh-Hans`, `zh-Hant`, `fr`, `ar`. The plugin's prompt
reminder follows the same resolution; the session-start rules
(`plugin/rules.md`) are English in every language.
Arabic is laid out right to left. `NODDIT_BIDI=visual|terminal` (`DECS_BIDI`
still works, or `nod config bidi visual|terminal`, `--off` to remove) picks how: `visual`
(the default) has nod reorder each line itself with the Unicode
Bidirectional Algorithm, for terminals that draw strictly left to right
(e.g. macOS Terminal); `terminal` has nod write logical order and wrap
embedded left-to-right runs (refs like W12, numbers, commands, English
titles) in Unicode isolates, for terminals that apply bidi themselves
(iTerm2 with bidi enabled, kitty, VTE-based terminals). In Arabic the bench
also mirrors: the list sits on the right, details on the left. Output to
pipes and `--json` always stays in logical order, so scripts and agents
read it unchanged. Relative times ("3 days ago") follow the language too.
The on-disk file format never changes with the language: `nod` always
writes one fixed set of section headings, so a repo stays readable by every
teammate whatever language their CLI speaks. When you write a file by hand,
`## Options`, `## Attachments` and `## Questions` are accepted. See [The file format](#the-file-format) below.
## How a session goes
1. You give the lead agent a goal. It runs `nod add "Ship v2.4" --task`, starts
it, and splits it into child nodes with `--after` dependencies.
2. It hands lanes (sub-agents) their own nodes. Each lane pipes its long
commands into `nod progress`; the bench bars move on their own.
3. A lane hits a fork in the road. It runs `nod ask <id> -o …` with options,
costs and a default. The node turns yellow `◆` in your bench.
4. You press `2`. `nod monitor` wakes the lane; it runs `nod read`, carries on,
and finally `nod done <id> --note "412/412 passing"`.
5. You never had to ask "where are we?" — and next week, the whole story is
still in `decisions/archived/`.
## CLI cheat sheet
| | |
|---|---|
| `nod init [--letter W]` | create `decisions/` here and register the project |
| `nod add <title> [--task] [-o 1=… 2=…]` | new node; with options it needs a decision. Body from stdin |
| `nod add <title> --parent W12 --after W13` | child node, ordered after another |
| `nod start / done / close <id>` | To do → In progress → Done / Closed (`--reason obsolete\|superseded\|merged-into:W15`) |
| `nod ask <id> -o 1=… 2=…` | a running node needs the owner |
| `nod hold <id> --on "Carol: icon set" --until fri` | waiting on someone outside (an active delay, purple); not counted as stuck — same as `nod defer --on` |
| `nod add <title> --for me` · `nod assign <id> me\|ai` | a to-do that's yours, not an AI's — listed in **Human work** |
| `nod add <title> --milestone [--due …]` | a goal with sub-goals under it, never started or finished on its own |
| `nod edit <id> --due <date> --est 2h --every 3d --remind "fri 2pm"` | due date · whose time it costs · a repeat cadence · an AI reminder |
| `nod progress <pct> "msg"` · `… \| nod progress --parse pytest` | report progress (or let a pipe report it) |
| `nod steps <id> "a" "b" "c"` · `nod step <id> 2` | multi-step work, percent computed for you |
| `nod note <id> "…" [--summary "…"]` | append a record (agent by default; `--human` for the owner); a summary is required past a line or two |
| `nod push <id> 2 [--note …]` | record an answer |
| `nod monitor [--mine] [--here] [--idle-exit 2h]` | the agent's notification stream |
| `nod read <id>` · `nod queue` | collect answers / see what's uncollected |
| `nod attach <id> file [--approval-content --approve-on 1]` | attach a file; gate it on approval |
| `nod approved <id> --check <file>` | exit 0 only if exactly this content was approved |
| `nod defer <id> [--until <date>]` · `nod undefer <id>` | put off, to a day or indefinitely (a passive delay, grey) / bring back |
| `nod show [open\|active\|deferred\|…] [--stale]` · `nod tree` · `nod get <id>` | read the store |
| `nod search <words> [--all]` | titles, bodies, notes, attachment names |
| `nod source register/sync/push/list/items/ack` | external sources |
| `nod changes --since <t>` | everything after a cursor, for catching up |
| `nod bench [.\|<dir>…] [--view decide]` | the live screen |
| `nod` | on a terminal, the same as `nod bench`; piped or in a script, prints the usage |
| `nod config [<setting> [<value>\|--off]]` | your settings: lang, bidi, view, images, mouse, idle-exit, unclaimed-after (also in the bench: `,`) |
Ids are `305`, `W305` (project letter), `web:305` (project name), or legacy
`D305`. `nod <command> --help` has the rest.
## Bench keys
| key | |
|---|---|
| `↑` `↓` | move |
| `←` `→` · `-` `+` | fold / unfold (remembered across sessions) |
| `Tab` `Shift-Tab` | switch view |
| `1`–`9` · `Enter` | answer · take the default |
| `w` | jump to the next node an agent is stuck on |
| `g` or `:` | go to an id |
| `Ctrl-L` | go to the cross-project main agent, or start one if it's offline |
| `N` | reply without deciding (the node goes back to the agent) |
| `d` | defer / undefer |
| `@` | flip who does it: your to-do ↔ an AI's |
| `m` | flip whether this node is a milestone |
| `Space` | mark / unmark a row; with any marked, `d D s @ ! A` act on all of them |
| `X` · `A` | close with a reason · mark looked-at and archive |
| `M` | move mode: ↑/↓ moves the node among its siblings (or its group in a list), ⏎ done; the app takes a drag |
| `i` · `o` | pick and view images · open an attachment |
| `j` `k` `Ctrl-F` `Ctrl-B` | scroll the detail pane |
| `Z` · `?` · `q` | condensed body · all keys · quit |
| `c` | Nod calendar — a heatmap of the last year behind ⚡ |
| `,` | settings (language, right-to-left text, mouse, …) |
The mouse works too: click a tab, a node, an option or an attachment; the wheel
scrolls the pane it's over.
## The file format
A node is markdown with YAML front matter. Humans can read it in any editor;
agents and the bench go through the CLI, which handles locking and history.
```markdown
---
id: 1
title: Choose a CDN
author: lane-perf · static assets
status: needs_decision
created: 2026-03-14T10:12:03+00:00
urgency: high
default: "1"
if_no_answer: stay; re-measure Friday
reversible: true
---
**What.** Static assets are served from one region.
**Why now.** APAC p95 doubled last week.
## Options
### 1 · Stay on current CDN
### 2 · Move to edge provider
```
Section headings are fixed tokens, not translated: see [Language](#language)
above for why, and how each person picks their own. Replies and notes are
appended as their own sections, each recording who wrote it and when.
A node can also carry a few optional fields, set with the matching `nod add`
/ `nod edit` flags rather than by hand: `due`, `est`, `every`, `remind_at`,
`assignee` (`human`, for a to-do that's yours) and `milestone` (`true` for a
goal with sub-goals under it). The bench and the app read all of them
straight from the front matter.
Statuses: `not_started` To do · `in_progress` In progress · `waiting`
Waiting · `needs_decision` Needs decision · `decided` Answered, for AI ·
`completed` Done · `closed` Closed. Children live in a folder named like
their parent's file; ids stay flat, so moving a node is a rename and every
reference still holds.
## Design principles
- **Files, not a service.** Everything is in `decisions/`, versioned with your
code, readable without nod installed.
- **The filesystem is the lock.** Ids come from `O_EXCL` files; each write
re-reads the node under its own lock and lands via write-then-rename. Two dozen
concurrent writers get consecutive ids and lose nothing — there's a test for it.
- **One kind of thing.** Tasks and decisions are the same node. Fewer concepts,
one id space, one tree.
- **The human never has to ask.** Status, progress, staleness, what's waiting on
whom — it's all on the bench, not in a chat thread.
- **Roles are explicit.** Every appended section says whether a human or an agent
wrote it, who, and when. Only human answers approve outbound content.
- **References, not content, from outside.** External sources sync ids and
titles; bodies and credentials stay where they live.
## FAQ
**Is this only for Claude Code?**
No. The CLI is agent-agnostic — anything with a shell can call it. The Claude
Code plugin adds session-start rules and uses `CLAUDECODE` /
`CLAUDE_SESSION_ID` to tell agent shells from yours and tag who wrote what.
Elsewhere, set `NODDIT_ROLE=agent` and `NODDIT_SESSION` (`DECS_ROLE` / `DECS_SESSION` still work).
**Does it work with git worktrees?**
Yes. `nod` always resolves to the main checkout's `decisions/`, so lanes in
worktrees share one store. Each lane should still run `nod` from its own
worktree; when one is forced to share another lane's cwd instead, set
`NODDIT_WORKTREE=<its own worktree's path>` so their identities don't
collide.
**Several repos at once?**
`nod init` registers each project; `nod bench` with no arguments opens all of
them, grouped by project letter.
**What if nobody answers?**
Every question carries a default and an `--if-no-answer`. `nod wait --timeout`
exits with code 2 and prints the default — the moment to proceed with it.
**Can I edit the files by hand?**
You can read them freely. For writes, use the CLI: it keeps ids, locks, the
answer queue and attachment history consistent.
**I have an old `DECISIONS.md`.**
`nod migrate --dir <project> --dry-run`, then without `--dry-run`.
## Python SDK
Noddit also ships a small Python package, [`noddit` on PyPI](https://pypi.org/project/noddit/) (standard library only, Python 3.10+). It lets long Python jobs report progress to a node — useful when tests or scripts run somewhere `nod` isn't installed, such as a Docker container. A pytest plugin writes one JSON line per test; `progress_events` does the same for any script. On the host, `nod progress --from-file` or `nod run` reads the file and moves the node.
```sh
pip install noddit
pytest --noddit-events events.jsonl # or NODDIT_EVENTS=events.jsonl pytest
nod run W12 --events events.jsonl -- pytest # the node's progress bar follows the run
```
```python
from noddit import progress_events
ev = progress_events("events.jsonl")
ev.start(total=23, label="recalculate")
ev.step(done=5, msg="table 3")
ev.finish(ok=True, summary="23 tables")
```
The event format is in [`python/docs/progress-events.md`](python/docs/progress-events.md).
## Development
```sh
npm test # node --test
npm run typecheck # tsc --noEmit
node scripts/render-screenshot.ts --out docs/screenshot.en # regenerate docs/screenshot.<lng>.svg/.png (mock data)
```
The desktop app (`app/src`) and the terminal board (`src/tui`) are meant to stay at feature
parity — [`docs/app-tui-parity.md`](docs/app-tui-parity.md) tracks where each feature lives in
both, and gets a new row whenever one changes.
## License
[MIT](LICENSE) © 2026 WeCarbon
© WeCarbon · MIT · WeCarbon/noddit