You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
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.