kanbo-cli 0.3.0 → 0.5.0

package/CHANGELOG.md

@@ -4,6 +4,52 @@ All notable changes to kanbo are documented here. The format follows [Keep a Cha
 
 ## [Unreleased]
 
+## [0.5.0] — 2026-11-06
+
+**Run `kanbo migrate` after upgrading** (on a board file `kanbo doctor --fix` does it too; on a shared Postgres board run `kanbo roles apply` after it, as after every migration). 0.5.0 adds two columns to `issue_statuses` and an index to `issue_field_changes`. Until the board is migrated, a read or a write is refused (exit 3, "Run kanbo migrate"). An app that keeps the board in its own database adds the same migration and pins this exact version.
+
+### Added
+
+- Flow rules on a column: which columns a card may enter it from (`allowedFrom`) and the most cards it holds (`wipLimit`). They are checked at the same door as entry rules, for every writer: an agent moving, creating, bulk-moving or claiming a card against them is refused with `board_column_rules_unmet` and one line per rule (`- allowed_from: Done accepts cards from In Review only`, `- wip_limit: In Progress holds 3 of 3`); a person goes through and is warned. A bulk move is held to a WIP limit as a whole. `kanbo columns flow <column> --from <columns|any> --wip <count|none>` sets them (a person only, exit 4 in an agent's shell). `kanbo prime`, `kanbo_columns`, `kanbo columns list` and `GET /issues/statuses` show them. Deleting a column takes it out of every list; a list it empties accepts cards from no column, not from every one.
+- New boards start with the standard flow: Done accepts cards only from In Review (from In Review and QA on a Review + QA board). Existing boards keep their columns as they are.
+- `kanbo claim [card]`, the `kanbo_card_claim` tool and `POST /issues/claim`: take a card to work on in one step. The run starts and the card moves from To Do into the board's first work-in-progress column in one write, and two agents never get the same card — the one that loses is told `board_nothing_ready` or `board_card_not_ready` (`run_active`, `waiting_for_person`, `not_in_to_do`). `kanbo prime`, the MCP server's instructions and the orchestrator guide tell agents to claim instead of starting a run and moving the card. `kanbo_card_claim` is published to every MCP host, including one that passes `includeRunTools: false`.
+- For applications that use kanbo as a library: `createBoardOps(store)` gains `setColumnFlowRules`, `applyStandardFlow`, `claimCard` and `listColumnEntries`. `listColumnEntries({ workspaceIds, since, limit })` lists every entry into a column since a moment, in `(at, changeId)` order, from the cards' own history — so it sees every writer — and never ends a page inside a second. The package root exports `readFlowRules`, `ColumnFlowRules`, `FLOW_RULES`, `ClaimCardInput`, `ClaimedCard`, `ColumnEntry`. `BoardStore` gains `issues.lockById` and `fieldChanges.listByFieldSince`; `KanboToolTransport` gains `cardClaim`. `BoardErrorCode` gains `board_card_run_active`, `board_nothing_ready`, `board_card_not_ready` (all `409`) and `board_flow_rule_invalid` (`400`).
+
+### Changed
+
+- A card has one run going at a time: starting a second run on a card whose run is still going is refused with `board_card_run_active`, naming that run — through `kanbo run start`, `kanbo_run_start`, `POST /issues/:id/runs` and an app's own launch alike. Finish or stop the first run before starting another.
+- A card created in a column records that column in its history as a change from no column, filed under whoever created it. The activity feed and the board page's History show it as the card's creation, as before; `kanbo card get --include history` and `GET /issues/:id/field-changes` list the row.
+- The instruction block `kanbo init` and `kanbo connect` write says "Take work with `kanbo claim`" (block v3). `kanbo doctor` reports a v2 block as written by an older kanbo, and `kanbo connect` or `kanbo doctor --fix` brings it forward; a block you edited is kept. `kanbo instructions agent` says the same.
+- A board file a migration behind refuses a read as it refuses a write — exit 3, with the sentence that names `kanbo migrate` — instead of failing on the missing column. A board whose only difference is its schema stamp stays readable. `kanbo mcp` on such a file stops at start with the same sentence, as on an outdated Postgres board.
+
+## [0.4.0] — 2026-11-04
+
+### Added
+
+- The board page shows sub-cards: a sub-card names its parent (click opens it), a parent shows how many of its sub-cards are done, and its panel lists them with their column, waiting or running state and who works them.
+- A card's panel on the board page opens with who made it and who works it, and its History reads as a timeline by day: who, the field, the old value → the new one, when (the exact time on hover), and the before and after text of a description change.
+- The board page filters cards by text, by who works them, by waiting for you, by running, by priority and by label; the filters live in the address and `/` focuses the search.
+- `kanbo serve` stops by itself about 5 seconds after the last board tab closes (2 minutes if a tab vanished without a goodbye) when it opened the browser itself; with `--no-open`, from an agent's shell or without a terminal it still runs until Ctrl-C. The board page tells the server it is open with `POST /page/presence`, and says plainly when the server has stopped.
+- `kanbo serve` offers every project kanbo knows (`~/.kanbo/projects.json`): a project dropdown on the board page, a header line saying the project's folder and where its board lives (a board file, or the Postgres host), `GET /projects`, `GET /issues/workspace` and the `/projects/:id/issues/...` routes. Started outside any project, it opens the most recently used one.
+- kanbo remembers each project folder it opens a board in (and `kanbo init` binds), in `~/.kanbo/projects.json` — the folder's path and when it was last used, nothing else, written at most once a day per project; `KANBO_HOME` moves the folder. It is the list the board page will offer.
+- `kanbo_card_update` takes `parent`, and `kanbo card update` takes `--parent <card>`: a card created at the wrong level is put under another card, or back on the top level with `"none"` (`--parent none`), and its history records the move like any other field's. A `null` for `parent` is read as not given — models send `null` for the fields they are not changing — so it never takes a card out from under its parent. The MCP server's instructions and the commands `kanbo prime` prints say so in one line each.
+- For applications that use kanbo as a library: `KanboCardUpdateInput.parent` (`string | null`; `null` is the top level, absent leaves the parent as it is) — a hand-written `KanboToolTransport` passes it on, and `createHttpTransport` sends it as `parentIssueId`, the card's exact id, as for a new card. `BoardErrorCode` gains `issue_parent_cycle`, `400` in `BOARD_ERROR_RESPONSES`.
+
+### Changed
+
+- A card on the board page opens in a large dialog instead of the narrow side panel: title and state on top, description, sub-cards and Comments / History / Runs tabs on the left, the decision and details on the right. Esc, ✕ or a click outside closes it; a board change an agent makes no longer resets your tab or scroll.
+- The board page has a new look (`src/serve/page/DIRECTION.md`): a strip board of paper and ink, light and dark. Each card carries a coloured edge for its state — orange only for "Waiting for you", blue while an agent runs it ("Running · claude"), green when done — and reads top to bottom as state, title, key and who works it, status line, priority and labels. The board fills the window under the bars and each column scrolls on its own. Only what changed moves: a card that is new or changed column fades in once, a badge calls once when a card starts waiting, a card's window fades in when it opens — never on an ordinary refresh, and nothing at all with reduced motion. On a narrow screen the token field folds into a "Token" button once a token works. History entries from before today show their clock time under their day.
+- The MCP tools that write a card — `kanbo_card_create`, `kanbo_card_update`, `kanbo_card_move`, `kanbo_status_line`, `kanbo_wait_approval` — answer with the card compact, on one line, as `kanbo_card_list` prints it (`id`, `title`, `column` slug, `statusLine`, `waitingFor`, `parentId`, `attempt`, `activeRun`, `updatedAt`), instead of every field pretty-printed: an orchestrator writing its card 20–40 times a session got 5–19k characters back each time — 19k for a one-sentence status line — and read them again on every later turn. Each takes `detail: "full"` for the whole card, as before. The CLI prints what it printed. For applications that read these tools' answers: they are compact now; pass `detail: "full"` for the old answer.
+- A write from an agent's shell is filed under the agent's name (`claude`, `codex`, `cursor`, `gemini`), and one through `kanbo mcp` under that, else the MCP client's own name, instead of the operating-system user; `KANBO_ACTOR_ID` still wins. The board page shows the writes of the person who started `kanbo serve` as **You** and every other writer by name. Rows written before this keep the OS user name, so on an existing board an agent's old writes now read as **You**.
+- A comment written from the board page is the person's (`authorKind: user`), and the page writes under the person at the machine (`KANBO_ACTOR_ID` in a person's shell, else the OS user) even when `kanbo serve` was started from an agent's shell, where it used to sign them with the agent's name. A request without the token, or sending `x-kanbo-actor: agent`, still writes as the server's writer. Rows written before keep what they were written with.
+- Approvals and returns read **You** on the board page, not `kanbo`.
+- `kanbo card get` and `kanbo_card_get` say who wrote each comment: `kanbo_card_get` comments gain `by` (the person's or agent's id, the outside writer's name, `kanbo` for the board's own lines), a person's approval or return reads `author: user`, and `card get` prints `krowli (person): …`, `claude: …`, `kanbo: Run finished`.
+- On the board page an outside writer's chip in Comments has the agent look as in History; "Worked by" names the agent of the latest run (`claude · finished`) once its run is over; `POST /page/presence` answers `204` instead of `404` on a server that does not stop by itself, and the page stops sending, so the console stays clean.
+
+### Fixed
+
+- A card can no longer be put under one of its own sub-cards, at any depth: the board operation refuses it (`issue_parent_cycle` — "A card can't be put under one of its own sub-cards."), so `PATCH /issues/:id` does too, where it used to write the loop. A loop already in a board's data does not hang the check.
+
 ## [0.3.0] — 2026-09-28
 
 kanbo 0.3 is about getting started without reading anything first — `kanbo` alone sets a project up or shows its board — about running the same everywhere (Windows included), and about agents spending fewer calls and tokens on the board. Boards need no migration: a board file or Postgres board 0.2.1 wrote opens as it is.
@@ -164,6 +210,8 @@ First public release.
 - `kanbo serve`: the `/issues` HTTP API and a board page, loopback by default, bearer token, CORS allow-list, 1 MB body limit.
 - Library entry points `kanbo`, `kanbo/sqlite`, `kanbo/sqlite/schema`, `kanbo/postgres` and `kanbo/mcp` (ESM and CJS with types).
 
+[0.5.0]: https://github.com/Krowli/kanbo/releases/tag/v0.5.0
+[0.4.0]: https://github.com/Krowli/kanbo/releases/tag/v0.4.0
 [0.3.0]: https://github.com/Krowli/kanbo/releases/tag/v0.3.0
 [0.2.1]: https://github.com/Krowli/kanbo/releases/tag/v0.2.1
 [0.2.0]: https://github.com/Krowli/kanbo/releases/tag/v0.2.0

package/README.md

@@ -7,6 +7,8 @@
 
 **A Kanban board your coding agents work, and you approve.**
 
+[Website](https://kanbo.aioomi.com) · [npm](https://www.npmjs.com/package/kanbo-cli)
+
 ## Quick start
 
 ```bash