@mgeri1993/claude-task-manager 1.0.0

package/.env.example

@@ -0,0 +1,2 @@
+CTM_PORT=3333
+CTM_RESTART=no

package/Dockerfile

@@ -0,0 +1,11 @@
+FROM php:8.3-cli-alpine
+
+RUN apk add --no-cache bash jq
+
+WORKDIR /app
+COPY . /app
+RUN chmod +x /app/engine/task.sh /app/engine/projects.sh
+
+EXPOSE 3333
+
+CMD ["php", "-S", "0.0.0.0:3333", "-t", "/app"]

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 mgeri1993
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.hu.md

@@ -0,0 +1,255 @@
+# claude-task-manager
+
+🌐 [English](README.md) | **Magyar**
+
+Önálló, dockerizált, **több projektet** kiszolgáló Kanban task-manager Claude Code
+agentek (fő agent + teammate-ek) koordinálásához. Egy közös böngészős board, egy
+token-hatékony, `--as <agent>`-alapú `task.sh` CLI, modul-szűrés, és kétnyelvű
+(angol/magyar) felület — bármelyik regisztrált projektből hívva, a CLI-hez docker nélkül.
+
+## Képernyőképek
+
+| Kanban board (angol) | Task-részlet modal | Kanban board (magyar) |
+|---|---|---|
+| ![Kanban board, angol](docs/screenshots/board-kanban-en.png) | ![Task-részlet modal](docs/screenshots/board-modal-en.png) | ![Kanban board, magyar](docs/screenshots/board-kanban-hu.png) |
+
+## Telepítés
+
+Szükséges: `git`, `bash`, `jq`, `docker` (a `docker compose` pluginnal) és `php` — ezek
+csak akkor kellenek, ha a böngészős boardot is futtatod. Maga a `task.sh` CLI csak
+`bash` + `jq`-t igényel, dockert nem.
+
+```bash
+git clone https://github.com/GeRiY/claude-task-manager.git
+cd claude-task-manager
+cp .env.example .env        # alap: board a 3333-as porton, autostart nélkül
+```
+
+Vagy, ha klónozás nélkül csak a `ctm` parancs kell:
+
+```bash
+npm install -g @mgeri1993/claude-task-manager
+```
+
+Ennyi — nincs build-lépés. Ezután jellemzően két dolgot csinálsz:
+
+1. **Board indítása** (opcionális, csak a böngészős UI-hoz kell):
+   ```bash
+   ./bin/ctm up               # első futtatáskor image-et épít, 3333-as porton indul
+   # vagy még a ctm parancs nélkül: docker compose up -d --build
+   ```
+2. **A `ctm` parancs globális regisztrálása** és **az eszköz telepítése egy projektbe**,
+   hogy annak agentjei használhassák a `task.sh`-t:
+   ```bash
+   ln -s "$(pwd)/bin/ctm" ~/.local/bin/ctm   # győződj meg róla, hogy ~/.local/bin a PATH-adban van
+   cd /path/to/valamelyik/masik/projekt
+   ctm init                                  # regisztralja + telepiti ABBA a projektbe
+   ```
+   (A `ctm init` az első futtatáskor a `ctm` szimlinket is automatikusan regisztrálja, így
+   a fenti kézi `ln -s` opcionális — csak akkor kell, ha bármilyen projektbe telepítés
+   előtt szeretnéd elérhetővé tenni a `ctm`-et.)
+
+A teljes parancs-referenciáért lásd a [Gyors indulás](#gyors-indulás) szekciót lentebb.
+
+## Architektúra dióhéjban
+
+- **`engine/task.sh`** — a tényleges Kanban-motor (jq-alapú, atomikus írás, lock,
+  `events.jsonl`-alapú inbox-értesítés). `TM_DIR` env-változóval bármelyik projekt saját
+  adat-könyvtárára mutatható. Minden futtatáskor stderr-emlékeztetőt ír, ha a projekt
+  preferált nyelve (a boardról állítva) nem angol — lásd [Nyelv](#nyelv--i18n).
+- **`engine/projects.sh`** — projekt-regisztráló admin CLI: minden regisztrált projekthez
+  létrehoz egy `data/<id>/` adat-könyvtárat, és egy `wrappers/<id>.sh` wrappert, ami a
+  `TM_DIR`-t és az engine abszolút útját már **beégetve** hordozza.
+- **`data/<id>/`** — a projektek tényleges táblái (`tasks.json`, `context.json`,
+  `events.jsonl`, `.cursors/`, `.board-lang`) — ITT élnek, nem a célprojektben.
+- **`index.html` + `js/*` + `style.css`** — a böngészős board. Docker compose-szal
+  szolgálja ki egy PHP beépített szerver; a Forrás-választó a `data/projects.json`
+  regisztrált projektjei közt vált.
+- **`api/index.php`** — a board ÍRÁS-endpointja: allowlistelt `task.sh` parancsokat futtat
+  a kiválasztott projekt `TM_DIR`-jével (a böngésző sosem írja közvetlenül a JSON-t).
+- **`install.sh`** / **`bin/ctm`** — egy tetszőleges célprojektbe telepíti a
+  `.claude/skills/task-manager/` mappát (wrapper `task.sh` + `SKILL.md`), a generikus
+  `ctm-*` teammate-agenteket, és az `allow-task-sh.sh` / `notify-inbox.sh` hookokat, majd
+  bővíti a célprojekt Bash-allowlistjét.
+- **`bin/add-agent.sh`** (`ctm agent add`) — egyedi, `tm-*` nevű teammate-definíció
+  létrehozása egy már telepített projektben.
+- **`engine/check-update.sh`** — az admin-jellegű scriptek (`ctm`, `install.sh`,
+  `add-agent.sh`, `projects.sh`) forrásolják be, hogy sárga "van új verzió" jelzést
+  írjanak ki — lásd [Naprakészen tartás](#naprakészen-tartás).
+
+**Fontos:** a `task.sh`-hívásokhoz (agent-munkavégzés) **egyáltalán nem kell docker** — a
+wrapperek sima host-bash scriptek. Kizárólag a böngészős **board** és az **API** fut
+konténerben.
+
+## Gyors indulás
+
+### 1. A `ctm` parancs regisztrálása
+
+Bármely telepítés (`install.sh` / `ctm init`) automatikusan regisztrálja a `ctm`-et a
+PATH-on (`/usr/local/bin/ctm` vagy `~/.local/bin/ctm`, amelyik írható). Ha még sosem
+futtattál telepítést, regisztrálhatod kézzel is:
+
+```bash
+ln -s /path/to/claude-task-manager/bin/ctm ~/.local/bin/ctm
+# győződj meg róla, hogy a ~/.local/bin a PATH-adban van
+```
+
+### 2. Board indítása (docker)
+
+```bash
+ctm up            # alapértelmezett port: 3333 (lásd .env: CTM_PORT)
+ctm up 4000        # más port — átírja a .env-et és újraindítja a konténert
+```
+
+A `ctm up` **idempotens**: ha a konténer már fut ugyanazzal a konfigurációval, nem csinál
+semmit; ha nem fut, elindítja; ha a port változott, újraindítja. Ha a kért port már
+foglalt egy MÁS folyamat által, egyértelmű hibával leáll, mielőtt dockert hívna.
+
+```bash
+ctm down                 # board leállítása
+ctm autostart on|off     # docker restart-policy (unless-stopped / no) — gép/docker
+                          # újraindításkor is magától elinduljon-e a board
+```
+
+A board ezután elérhető: `http://localhost:<port>/`. Az URL a `?project=<id>&lang=<en|hu>`
+paramétereket is elfogadja, hogy egy adott projektre/nyelvre lehessen közvetlenül
+mélylinkelni.
+
+### 3. Telepítés egy projektbe
+
+Bármelyik projekt gyökeréből (vagy a git-repóján belül bárhonnan) futtatva:
+
+```bash
+cd /path/to/valamelyik/projekt
+ctm init                          # id/label = a mappa neve
+ctm init sajat-id "Szép Név"      # explicit id/label
+ctm init --force                  # felülírja a generált fájlokat rákérdezés nélkül
+```
+
+Ez létrehozza:
+
+- `<projekt>/.claude/skills/task-manager/task.sh` — a projekt saját wrappere (`TM_DIR` +
+  az engine abszolút útja beégetve; docker NEM szükséges).
+- `<projekt>/.claude/skills/task-manager/SKILL.md` — Claude Code skill-dokumentáció
+  (a `task.sh`-hívási kontraktus, workflow, `context.json` stb.) — projekt-agnosztikus.
+- `<projekt>/.claude/agents/ctm-frontend-developer.md`, `ctm-backend-developer.md`,
+  `ctm-code-investigator.md` — generikus teammate-definíciók (a konkrét stack-et a
+  projekt saját dokumentációjából olvassák ki).
+- `<projekt>/.claude/hooks/allow-task-sh.sh` + `notify-inbox.sh`, regisztrálva a
+  `<projekt>/.claude/settings.json`-ban — automatikusan engedélyezi a `task.sh`
+  Bash-hívásokat, és inbox-értesítést injektál a hívó agentnek minden `task.sh` futás után.
+- `<projekt>/.claude/settings.local.json` — bővítve a `task.sh` Bash-allowlist
+  bejegyzésével (engedélykérés nélkül).
+
+Az újrafuttatott `ctm init` **idempotens** — ha egy generált fájl már létezik, rákérdez
+felülírás előtt (kivéve `--force`/`-y`, vagy nem-interaktív módban, ahol kihagyja és
+jelzi, hogy adj meg `--force`-ot). A `data/<id>/` tábla tartalmát sosem érinti, és a saját
+`tm-*` egyedi agent-fájljaidhoz sem nyúl.
+
+### 4. Egyedi teammate hozzáadása
+
+Egy már telepített projektben, ha a 3 alap szerepkörön (frontend/backend/investigator)
+felül másra is szükséged van:
+
+```bash
+cd /path/to/mar-telepitett-projekt
+ctm agent add reviewer "Kódot review-z és minőségi kaput ellenőriz."
+```
+
+Létrehozza a `.claude/agents/tm-reviewer.md`-t. **Névkonvenció:** az `install.sh`/`ctm
+init` generálta alap készlet mindig `ctm-*`; az így hozzáadott egyedi agentek mindig
+`tm-*` — így egy pillantásra látszik, mi az automatikusan frissülő alap készlet és mi a
+saját, kézzel szerkesztett kiegészítés (a `ctm init` a `tm-*` fájlokhoz sosem nyúl).
+
+### 5. Projektek kezelése
+
+```bash
+ctm list                  # regisztrált projektek (id, címke, adat-könyvtár)
+ctm wrapper <id>          # egy projekt generált wrapperének kiírása (kézi másoláshoz)
+ctm rm <id> [--force]     # projekt törlése a regisztrációból (adat + wrapper) — rákérdez
+```
+
+## `task.sh` a projektből (docker nélkül)
+
+A telepített wrapperen keresztül, a projekt saját `.claude/skills/task-manager/`-jéből:
+
+```bash
+/path/to/projekt/.claude/skills/task-manager/task.sh summary --as main
+/path/to/projekt/.claude/skills/task-manager/task.sh list todo --as main
+/path/to/projekt/.claude/skills/task-manager/task.sh list --module auth --as main
+/path/to/projekt/.claude/skills/task-manager/task.sh add fix-1 "Bug fix" "leírás" --as main
+/path/to/projekt/.claude/skills/task-manager/task.sh module fix-1 auth --as main
+/path/to/projekt/.claude/skills/task-manager/task.sh status fix-1 in_progress --as main
+```
+
+Teljes parancslista: `task.sh help`. A hívási kontraktust (kötelező `--as`, csupasz-hívás
+szabály, review→done átadási kör) a telepített `SKILL.md` írja le részletesen. A taskok
+támogatnak egy opcionális `module` mezőt (szabad szöveg, pl. `auth`/`frontend`/`infra`)
+csoportosításhoz/szűréshez — beállítás: `task.sh module <id> <név>`, szűrés:
+`task.sh list --module <név>`, és a boardon is szűrhető.
+
+## Nyelv / i18n
+
+A board alapból **angol**. Kattints a fejléc nyelv-gombjára (vagy tedd hozzá az URL-hez
+a `?lang=hu`-t) a **magyarra** váltáshoz — a választás megmarad `localStorage`-ban, és
+tükröződik az URL-ben (`?lang=hu`), így egy board-link megosztható egy adott nyelven.
+
+A nyelv **nem** kerül semelyik taskba vagy jegyzetbe. A board minden írása elküldi az
+aktuális UI-nyelvet is; az `api/index.php` egy kis `data/<id>/.board-lang` fájlba menti
+(nem a task-séma része). Az `engine/task.sh` minden futtatáskor beolvassa ezt a fájlt
+(kivéve `help`/`inbox`, a zaj elkerülése végett), és — ha nem angol — egy emlékeztetőt ír
+ki stderr-re, pl.:
+
+```
+[task-manager] Preferred language for this project: Hungarian — please reply and do the work in Hungarian.
+```
+
+Így tudja meg egy `task.sh`-t futtató agent (a Bash toolján keresztül), milyen nyelvet
+használt a human a boardon, anélkül hogy ez az instrukció valaha is bekerülne a
+task-adatokba.
+
+## Naprakészen tartás
+
+A `ctm`, `install.sh`, `add-agent.sh` és `projects.sh` mindegyike ellenőrzi (egy
+könnyűsúlyú `git ls-remote`-tal, nem teljes fetch-csel), hogy az `origin` alapértelmezett
+ágán van-e olyan commit, ami a lokális checkoutból hiányzik. Ha igen, sárga jelzést ír ki,
+hogy futtass egy `git pull`-t; ha már naprakész vagy, nem ír ki semmit. Ez az ellenőrzés
+**szándékosan nem** fut le az `engine/task.sh`-ban — azt a scriptet minden egyes
+task-mutációnál meghívják (egy agent-sessionben gyakran sokszor), és egy hálózati
+körüljárás minden hívásnál valós, ismétlődő késleltetést adna a hot path-hoz.
+
+## Könyvtárszerkezet
+
+```
+claude-task-manager/
+  engine/task.sh, projects.sh, check-update.sh   # a motor + projekt-admin CLI + frissítés-ellenőrzés
+  bin/ctm, add-agent.sh                          # a "ctm" parancssori belépési pont
+  install.sh                                     # egy célprojekt telepítője (a ctm init hívja)
+  templates/                                     # SKILL.md / ctm-* / tm-custom / hooks sablonok (__PLACEHOLDER__-ekkel)
+  api/index.php                                  # a board írás-endpointja
+  index.html, js/, style.css                     # a böngészős board
+  favicon.svg, favicon.ico                       # board favicon
+  data/<id>/                                     # projektenkénti tábla (gitignore-olva)
+  wrappers/<id>.sh                               # generált, projektenkénti task.sh wrapperek (gitignore-olva)
+  docker-compose.yml, Dockerfile                 # a board+API konténerizálása (CTM_PORT, CTM_RESTART)
+```
+
+## Környezeti változók (`.env`)
+
+| Változó | Alap | Jelentés |
+|---|---|---|
+| `CTM_PORT` | `3333` | A board portja (host loopback: `127.0.0.1:<port>`). A `ctm up <port>` állítja. |
+| `CTM_RESTART` | `no` | Docker restart-policy. `ctm autostart on` → `unless-stopped`. |
+
+Lásd a `.env.example`-t (a valódi `.env` gitignore-olva van, mert a `ctm` írja/frissíti).
+
+## Biztonsági megjegyzések
+
+- A board docker-portja kizárólag `127.0.0.1`-re van kötve (sosem `0.0.0.0`-ra) — a LAN-ról
+  nem elérhető, csak magáról a host gépről.
+- Az írás-endpoint (`api/index.php`) csak egy explicit parancs-allowlistet futtat
+  (`status`, `note`, `priority`, `module`, `tag`, `assign`, `dep`, `status-many`, `reopen`,
+  `add`) — a destruktív parancsok (`rm`, `restore`, `raw`, `archive`) sosincsenek kiengedve
+  a böngészőnek.
+- Minden írás-kérésben a `project` id-t a `data/projects.json` regisztrált listája ellen
+  ellenőrizzük — a kliens sosem tud tetszőleges könyvtárra mutatni az API-val.

package/README.md

@@ -0,0 +1,253 @@
+# claude-task-manager
+
+🌐 **English** | [Magyar](README.hu.md)
+
+A standalone, dockerized, **multi-project** Kanban task manager for coordinating Claude
+Code agents (main agent + teammates). One shared browser board, a token-efficient
+`--as <agent>`-based `task.sh` CLI, module filtering, and a bilingual (English/Hungarian)
+UI — callable from any registered project, no docker required for the CLI itself.
+
+## Screenshots
+
+| Kanban board (English) | Task detail modal | Kanban board (Hungarian) |
+|---|---|---|
+| ![Kanban board, English](docs/screenshots/board-kanban-en.png) | ![Task detail modal](docs/screenshots/board-modal-en.png) | ![Kanban board, Hungarian](docs/screenshots/board-kanban-hu.png) |
+
+## Install
+
+Requirements: `git`, `bash`, `jq`, `docker` (with the `docker compose` plugin) and `php`
+are only needed if you plan to run the browser board — the `task.sh` CLI itself only
+needs `bash` + `jq`, no docker.
+
+```bash
+git clone https://github.com/GeRiY/claude-task-manager.git
+cd claude-task-manager
+cp .env.example .env        # default: board on port 3333, no autostart
+```
+
+Or, if you just want the `ctm` command without cloning:
+
+```bash
+npm install -g @mgeri1993/claude-task-manager
+```
+
+That's it — there's no build step. Two things you'll typically do next:
+
+1. **Start the board** (optional, only needed for the browser UI):
+   ```bash
+   ./bin/ctm up               # builds the image on first run, starts on port 3333
+   # or without the ctm command yet: docker compose up -d --build
+   ```
+2. **Register the `ctm` command globally** and **install this tool into a project**, so
+   its agents can use `task.sh`:
+   ```bash
+   ln -s "$(pwd)/bin/ctm" ~/.local/bin/ctm   # make sure ~/.local/bin is on your PATH
+   cd /path/to/some/other/project
+   ctm init                                  # registers + installs into THAT project
+   ```
+   (`ctm init` also registers the `ctm` symlink automatically the first time it runs, so
+   the manual `ln -s` above is optional — only needed if you want `ctm` available before
+   installing into any project.)
+
+See [Quick start](#quick-start) below for the full command reference.
+
+## Architecture in a nutshell
+
+- **`engine/task.sh`** — the actual Kanban engine (jq-based, atomic writes, locking,
+  `events.jsonl`-based inbox notifications). Points at any project's own data directory via
+  the `TM_DIR` environment variable. Prints a stderr reminder on every run if the project's
+  preferred language (set from the board) isn't English — see [Language](#language--i18n).
+- **`engine/projects.sh`** — the project-registration admin CLI: for every registered
+  project it creates a `data/<id>/` data directory and a `wrappers/<id>.sh` wrapper that
+  already has `TM_DIR` and the engine's absolute path **baked in**.
+- **`data/<id>/`** — the projects' actual tables (`tasks.json`, `context.json`,
+  `events.jsonl`, `.cursors/`, `.board-lang`) — they live HERE, not in the target project.
+- **`index.html` + `js/*` + `style.css`** — the browser board. Served by a PHP built-in
+  server via docker compose; the Source selector switches between the projects registered
+  in `data/projects.json`.
+- **`api/index.php`** — the board's WRITE endpoint: runs allowlisted `task.sh` commands
+  with the selected project's `TM_DIR` (the browser never writes the JSON directly).
+- **`install.sh`** / **`bin/ctm`** — installs `.claude/skills/task-manager/` (wrapper
+  `task.sh` + `SKILL.md`), the generic `ctm-*` teammate agents, and the `allow-task-sh.sh` /
+  `notify-inbox.sh` hooks into an arbitrary target project, and extends its Bash allowlist.
+- **`bin/add-agent.sh`** (`ctm agent add`) — creates a custom, `tm-*`-named teammate
+  definition in an already-installed project.
+- **`engine/check-update.sh`** — sourced by the admin-facing scripts (`ctm`, `install.sh`,
+  `add-agent.sh`, `projects.sh`) to print a yellow "update available" notice — see
+  [Staying up to date](#staying-up-to-date).
+
+**Important:** `task.sh` calls (agent work) need **no docker at all** — the wrappers are
+plain host-bash scripts. Only the browser **board** and its **API** run in a container.
+
+## Quick start
+
+### 1. Register the `ctm` command
+
+Any install (`install.sh` / `ctm init`) registers `ctm` on PATH automatically
+(`/usr/local/bin/ctm` or `~/.local/bin/ctm`, whichever is writable). If you've never run an
+install yet, register it by hand:
+
+```bash
+ln -s /path/to/claude-task-manager/bin/ctm ~/.local/bin/ctm
+# make sure ~/.local/bin is on your PATH
+```
+
+### 2. Start the board (docker)
+
+```bash
+ctm up            # default port: 3333 (see .env: CTM_PORT)
+ctm up 4000        # a different port — rewrites .env and restarts the container
+```
+
+`ctm up` is **idempotent**: if the container is already running with the same config, it
+does nothing; if it's not running, it starts it; if the port changed, it restarts it. If the
+requested port is already taken by another process, it fails with a clear message before
+ever calling docker.
+
+```bash
+ctm down                 # stop the board
+ctm autostart on|off     # docker restart-policy (unless-stopped / no) — start the board
+                          # automatically on Docker/machine restart or not
+```
+
+The board is then reachable at `http://localhost:<port>/`. The URL also accepts
+`?project=<id>&lang=<en|hu>` to deep-link directly to a project in a given language.
+
+### 3. Install into a project
+
+Run from any project's root (or anywhere inside its git repo):
+
+```bash
+cd /path/to/some/project
+ctm init                          # id/label = the folder name
+ctm init my-id "Pretty Name"      # explicit id/label
+ctm init --force                  # overwrite generated files without prompting
+```
+
+This creates:
+
+- `<project>/.claude/skills/task-manager/task.sh` — the project's own wrapper (`TM_DIR` +
+  the engine's absolute path baked in; docker NOT required).
+- `<project>/.claude/skills/task-manager/SKILL.md` — Claude Code skill documentation (the
+  `task.sh` calling contract, workflow, `context.json`, etc.) — project-agnostic.
+- `<project>/.claude/agents/ctm-frontend-developer.md`, `ctm-backend-developer.md`,
+  `ctm-code-investigator.md` — generic teammate definitions (they read the concrete stack
+  from the project's own documentation).
+- `<project>/.claude/hooks/allow-task-sh.sh` + `notify-inbox.sh`, registered in
+  `<project>/.claude/settings.json` — auto-allow `task.sh` Bash calls, and inject inbox
+  notifications into the calling agent after every `task.sh` run.
+- `<project>/.claude/settings.local.json` — extended with `task.sh`'s Bash allowlist entry
+  (no permission prompt).
+
+Re-running `ctm init` is **idempotent** — if a generated file already exists, it asks
+before overwriting (unless `--force`/`-y`, or non-interactive, where it skips and tells you
+to pass `--force`). It never touches `data/<id>/`'s table contents, and never touches your
+own `tm-*` custom agent files.
+
+### 4. Add a custom teammate
+
+In an already-installed project, when you need more than the 3 base roles
+(frontend/backend/investigator):
+
+```bash
+cd /path/to/installed/project
+ctm agent add reviewer "Reviews code and checks the quality gate."
+```
+
+Creates `.claude/agents/tm-reviewer.md`. **Naming convention:** the base set installed by
+`install.sh`/`ctm init` is always `ctm-*`; custom agents added this way are always `tm-*` —
+so at a glance you can tell the auto-refreshed base set apart from your own hand-edited
+addition (`ctm init` never touches `tm-*` files).
+
+### 5. Manage projects
+
+```bash
+ctm list                  # registered projects (id, label, data directory)
+ctm wrapper <id>          # print a project's generated wrapper (for manual copying)
+ctm rm <id> [--force]     # deregister a project (data + wrapper) — asks first
+```
+
+## `task.sh` from a project (no docker)
+
+Through the installed wrapper, from the project's own `.claude/skills/task-manager/`:
+
+```bash
+/path/to/project/.claude/skills/task-manager/task.sh summary --as main
+/path/to/project/.claude/skills/task-manager/task.sh list todo --as main
+/path/to/project/.claude/skills/task-manager/task.sh list --module auth --as main
+/path/to/project/.claude/skills/task-manager/task.sh add fix-1 "Bug fix" "description" --as main
+/path/to/project/.claude/skills/task-manager/task.sh module fix-1 auth --as main
+/path/to/project/.claude/skills/task-manager/task.sh status fix-1 in_progress --as main
+```
+
+Full command list: `task.sh help`. The calling contract (required `--as`, the bare-call
+rule, the review→done handoff loop) is documented in detail in the installed `SKILL.md`.
+Tasks support an optional `module` field (free text, e.g. `auth`/`frontend`/`infra`) for
+grouping/filtering — set with `task.sh module <id> <name>`, filter with
+`task.sh list --module <name>`, and filterable on the board too.
+
+## Language / i18n
+
+The board defaults to **English**. Click the language button in the header (or add
+`?lang=hu` to the URL) to switch to **Hungarian** — the choice persists in `localStorage`
+and is reflected in the URL (`?lang=hu`), so a board link is shareable in a specific
+language.
+
+The language is **not** stored in any task or note. Every write from the board also sends
+its current UI language; `api/index.php` persists it in a small `data/<id>/.board-lang`
+file (not part of the task schema). `engine/task.sh` reads that file on every invocation
+(except `help`/`inbox`, to avoid noise) and — if it's not English — prints a reminder to
+stderr, e.g.:
+
+```
+[task-manager] Preferred language for this project: Hungarian — please reply and do the work in Hungarian.
+```
+
+This is how an agent running `task.sh` (via its Bash tool) learns which language a human
+was using on the board, without that instruction ever being written into the task data
+itself.
+
+## Staying up to date
+
+`ctm`, `install.sh`, `add-agent.sh`, and `projects.sh` each check (via a lightweight
+`git ls-remote`, not a full fetch) whether `origin`'s default branch has commits your local
+checkout doesn't have yet. If so, they print a yellow notice telling you to `git pull`; if
+you're already up to date, they print nothing. This check is **deliberately not** run by
+`engine/task.sh` itself — that script is called on every single task mutation (often many
+times per agent session), and a network round-trip on every call would add real, repeated
+latency to that hot path.
+
+## Directory structure
+
+```
+claude-task-manager/
+  engine/task.sh, projects.sh, check-update.sh   # the engine + project-admin CLI + update-check
+  bin/ctm, add-agent.sh                          # the "ctm" command-line entry point
+  install.sh                                     # a target project's installer (ctm init calls it)
+  templates/                                     # SKILL.md / ctm-* / tm-custom / hooks templates (with __PLACEHOLDER__s)
+  api/index.php                                  # the board's write endpoint
+  index.html, js/, style.css                     # the browser board
+  favicon.svg, favicon.ico                       # board favicon
+  data/<id>/                                     # per-project table (gitignored)
+  wrappers/<id>.sh                               # generated, per-project task.sh wrappers (gitignored)
+  docker-compose.yml, Dockerfile                 # containerizes the board+API (CTM_PORT, CTM_RESTART)
+```
+
+## Environment variables (`.env`)
+
+| Variable | Default | Meaning |
+|---|---|---|
+| `CTM_PORT` | `3333` | The board's port (host loopback: `127.0.0.1:<port>`). Set by `ctm up <port>`. |
+| `CTM_RESTART` | `no` | Docker restart-policy. `ctm autostart on` → `unless-stopped`. |
+
+See `.env.example` (the real `.env` is gitignored, since `ctm` writes/updates it).
+
+## Security notes
+
+- The board's docker port is bound to `127.0.0.1` only (never `0.0.0.0`) — unreachable from
+  the LAN, only from the host itself.
+- The write endpoint (`api/index.php`) only runs an explicit command allowlist (`status`,
+  `note`, `priority`, `module`, `tag`, `assign`, `dep`, `status-many`, `reopen`, `add`) —
+  destructive commands (`rm`, `restore`, `raw`, `archive`) are never exposed to the browser.
+- The `project` id in every write request is checked against `data/projects.json`'s
+  registered list — a client can never point the API at an arbitrary directory.