Compare commits

..
6 Commits
Author SHA1 Message Date
Ansho ReiandClaude Opus 5 37dbd722e0 (3b16540) Open a search with / in the tui, and bump to 0.13.6
Finding a ticket meant scrolling four columns and reading, which is what the
id and the title are for.

The real work was the input mode: every key in the dispatch was a single-shot
action, and a query needs one that swallows the keys bound to them. That is
Board::search_key, offered every key ahead of the action arms and reporting
what it took. With no prompt open it takes nothing, so every other state's
dispatch is unchanged. On Board for the reason dismiss is: the arm is not
reachable from a test.

ctrl-c is the one key the prompt declines, since a terminal application
always honours it. Every other control combination is swallowed and does
nothing: it must not type its letter, and it must not fall through either,
because the action arms match on the code alone and ctrl-d would reach the
arm bound to d.

first_match runs over every card in the visible columns, in reading order,
not the rows on screen: a query that answered differently on a tall terminal
and a short one is not a search, and the jump scrolls the match into view. A
hidden done column stays out, or the highlight would land on a ticket that is
not on the board. Id and title only, both lowercased.

The jump goes through select_at, extracted as the tail select_card already
used, so follow_selection scrolls the match's own column and refresh_detail
keeps an open overlay on it. Nothing calculates either a second way.

A hit closes the prompt; a miss keeps it open, marked in brightred beside the
query it is about, with the selection untouched, so the query can be
corrected in place rather than retyped from /. The mark clears on the next
edit. An empty query matches nothing rather than everything.

The prompt takes the whole footer row, since the key list it replaces
describes nothing that works while every key goes into the buffer. The real
terminal cursor sits after the query: ratatui shows it only for a frame that
asked, so it is also what says "you are typing" on an empty query. Both
closed footers now name / search.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
2026-08-22 13:29:30 +02:00
Ansho ReiandClaude Opus 5 4502de7ee3 (e7612de) Close the detail overlay on q instead of quitting, and bump to 0.13.5
q set should_quit outright, so a reader who pressed it to put a ticket away
lost the whole board instead. That is not what q means anywhere else that
lays a document over a list, and esc two arms below already did the right
thing.

The rule is Board::dismiss: close what is open, quit when there is nothing
left to close. On Board rather than in the match arm because the dispatch in
main.rs is not reachable from a test, so a rule written there is a rule
nothing can check. q and esc now share one arm, since two arms carrying one
rule is how a later edit changes it for one key and not the other.

The footer is the other half. Its last slot answers the same question in
both states, how to get out, and with a ticket open the honest answer is
ctrl-c: it is the only key left that quits in one press. Going on saying
q quit there would be 1b78a24 in the other direction, a footer describing a
key by what it used to do. The close entry names both keys as enter/q close
rather than repeating close twice.

Criteria 3 and 7 live in a dispatch no test can reach, so
the_dispatch_gives_q_and_esc_one_arm_and_leaves_ctrl_c_quitting scans
main.rs for them, over whitespace-collapsed source so rustfmt cannot fail
it, the way util.rs is already scanned for colour_text callers.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
2026-08-22 13:13:58 +02:00
Ansho ReiandClaude Opus 5 a16169ce8c (b8ce18c) Show a blocked marker on the tui card, and bump to 0.13.4
A ticket held up by an open blocker looked exactly like one that is ready,
and the board is where the next thing to pick up is chosen.

The mark is × in brightred, after the short id. Not a fourth Geometric
Shapes glyph: those are the priority meter's, two cells away, and another
circle there reads as part of that ramp. × is Latin-1, like the middle dot
the unset priority draws, so it renders wherever the meter does.

After the id rather than before it, because ahead of it the mark would push
every id in the column out of line whenever one card was blocked. It is
measured before the project label and the due date, so both give way to it:
those are context for a ticket somebody can start, and this is the one thing
on a card that says not to. Dropped whole when the row cannot hold the
identity and the mark together.

No scan of the board per tick was needed after all. collect_ticket_items
also reads the ticket's own uuid and the targets of its blocked by lines,
off the file it is already holding, and mark_blocked walks the four columns
once for a uuid-to-status map and once to answer every card. The flag is on
Card rather than TicketItem: the answer is about two tickets at once, so no
card can reach it alone, and it is settled at reload the way project is.

The merge carries each card's flag from the board it came from. relate
resolves its target inside one .worklane, so a blocker in another project is
not a relation anything can record, and recomputing over the merged columns
would let one project's uuid match another project's ticket.

project_label now takes the width the row has actually spent, measured off
the spans, instead of adding up the widths those spans are supposed to have.
The hand-written sum left out the space after the priority mark, so a cut
label was handed one cell more than the column had.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
2026-08-22 13:02:13 +02:00
Ansho ReiandClaude Opus 5 3d6a74bc53 (daa0e79) Validate the due date at parse time, and bump to 0.13.3
A clap value_parser beside priority_level rather than a check inside cmd_add,
so a bad date is a usage error with nothing written at all rather than
written and then rejected.

On set --due as well as add --due, from one definition. The planning skill
sets dates through set and never through add, so validating only the command
that files a ticket would have left the path the validation exists to
protect still accepting "next friday".

The shape is checked before chrono sees it. %Y-%m-%d accepts an unpadded
2026-8-9, which would be stored as typed and sort before 2026-10-01. Strict
on the way in, tolerant on the way out: util::due_date still cuts a datetime
down to its date, since a file written earlier can hold one.

PLAN.md told the planner the value was not validated. That is corrected, and
the guard test that failed on the edit now pins the half of the warning that
is still true: a date cannot be cleared, only replaced.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
2026-08-22 03:22:04 +02:00
Ansho ReiandClaude Opus 5 7a0dd625ce (1e7b1a9) Colour a tag by its name, and bump to 0.13.2
FNV-1a over the tag bytes into an eight-colour reserved palette, so the same
tag is the same colour on every card and on every board with nothing stored.
The hash is written out rather than taken from std, whose output is not
promised stable across releases.

The index is multiply-shift, not `% len`. The length is a power of two, so a
modulus keeps the low three bits of the hash, and FNV-1a's low bits carry
only the low bits of the input bytes: nothing moves information downwards.
Every pair of tags differing above bit 2 landed in one slot, `bug` and `BUG`
among them. It looked like a good palette, two colliding cards in sixty-four
on this board, because the vocabulary had been folded into a handful of
slots. Using the whole hash gives 14/64, which is the real arithmetic for
eight colours.

The palette is reserved as a list and disjoint from the seven colours that
already mean something: a tag in red reads as a uuid, in green as a title.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
2026-08-22 03:13:56 +02:00
Ansho ReiandClaude Opus 5 8d8ae8abfe (822e8a1) Add a worklane-plan skill, and bump to 0.13.1
A third asset on the machinery 16c2bed settled, so the wiring is one entry in
install::SKILLS.

Four jobs, priorities, due dates, tags and campaigns, with propose-then-apply
stated once at the top rather than per section. Every job writes to many
tickets at once and no field can be cleared back to unset, so the document
leans on the two traps that make a sweep destructive rather than merely
wrong: set --tags replaces the whole field, and a due date is neither
validated nor clearable.

feature-planner-agent.md is deliberately not folded in. It decomposes a
request into new tickets, which is intake; this orders the tickets that
already exist, and one document holding both would fit neither.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
2026-08-22 02:58:50 +02:00
14 changed files with 1840 additions and 52 deletions
+37 -2
View File
@@ -10,6 +10,7 @@
- `src/install.rs` - the embedded agent assets and the compare-and-refuse install
- `assets/SKILL.md` - the agent skill for the CLI itself, embedded with `include_str!`
- `assets/REVIEW.md` - the agent skill for reviewing a finished ticket, shipped the same way. Assets are named after the role they teach; `SKILL.md` keeps its name because the role it teaches is the CLI
- `assets/PLAN.md` - the agent skill for grooming the whole board: priorities, due dates, tags and campaigns
- `tests/` - Integration tests using `assert_cmd` and `assert_fs`, one file per command
- Unit tests live beside the code in `#[cfg(test)] mod tests`, in `util.rs`, `handlers.rs` and `tui.rs`
- Ticket files stored as `.md` in `.worklane/<status>/` directories
@@ -52,6 +53,10 @@ and this file is for what someone changing worklane's own code needs.
### CLI Arguments
- The prose arguments carry `allow_hyphen_values`, via the `PROSE` constant in `command.rs`: `add --title`, `--description`, `--acceptance`, `--plan`, and the `comment` body. Ticket text quotes flag names constantly, and without it a criterion reading `--print is supported` is parsed as a flag and the whole ticket is refused with nothing written
- **The trade:** on those five arguments a genuinely mistyped flag now lands as content rather than raising a usage error. That is the right way round for prose and the wrong way round for anything else, which is why `due`, `priority`, `tags`, `owner` and `status` are deliberately left without it. A mistyped flag there is still a usage error, exit 2, and no ticket is written. Do not add `PROSE` to a new argument unless it holds prose
- **`--due` is validated at parse time by `iso_date`, the way `--priority` is by `priority_level`.** A date that is not real is a usage error, exit 2, with nothing written, which is the whole point of leaving the scalars without `PROSE`. One parser serves `add` and `set`: the field has one definition of what it accepts, and validating only `add` would leave `set` open, which is the command a grooming sweep actually uses
- **The shape is checked before chrono is asked.** `%Y-%m-%d` accepts an unpadded `2026-8-9`, which would be stored exactly as typed and sort before `2026-10-01` in any string comparison. Checking the length and the two dashes first is what lets a valid date be stored unchanged instead of normalised on the way in, which is the difference between validating and rewriting
- **Strict on the way in, tolerant on the way out.** `util::due_date` still cuts `2026-12-31T09:30:00Z` down to its date. A file written before the parser existed, or by hand, can hold one and still has to render; refusing to display what is already stored would punish the reader for the writer's mistake
- An empty `--due` keeps `non_empty`'s message about clearing rather than the date message. Somebody typing it is reaching for a way to clear the field, and the useful answer is that clearing is not supported yet
- The ticket positionals (`show <id>`, `mv <ticket>`, `comment <ticket>`) are also left alone, so a search term starting with a hyphen is a usage error. Reachable now that a hyphen-leading title can be stored: use the UUID, or put the flags first and separate with `--`, as in `mv --status committed -- -leading-title`
- A bare `--` is a value when it follows an option (`--title -- ` stores `--`) and clap's end-of-options marker when it sits in a positional. So a `comment` body of exactly `--` needs its own separator, `comment <ticket> -- --`. Without it the body is reported missing and nothing is written, which is a clear failure rather than a silent drop
- `add` has no positionals, so anything after a bare `--` is an unexpected argument and fails
@@ -93,7 +98,7 @@ and this file is for what someone changing worklane's own code needs.
- `ensure_section` inserts against `SECTION_ORDER`, before the first following section that is actually in the file, and adds no blank line that was not already there. A handwritten `## Notes` between the plan and the metadata therefore keeps its place, and Metadata is in that list as an anchor rather than as something anything appends to
- **The blocker check runs on every move**, after the already-in-that-status return and behind `force`. An open blocker is a reason not to start and a reason not to finish, and one rule is easier to hold than a table of which transitions care. A move to the status the ticket is already in is not a move, so it is not refused. `-f` now bypasses three rules, which is the right home for it: each one is a deliberate override of something the board would otherwise keep true
- **A blocker that is not on the board warns and allows the move.** Refusing would wedge the ticket with no way out but `-f`, and a uuid nothing carries is a bookkeeping fault rather than a dependency. The refusal names **every** open blocker, since clearing the one that happened to be printed would leave the ticket blocked
- Left out on purpose: removing a relation, which 4179958 assigns to 74904dc, and a blocked marker on the TUI card, which is its own ticket. Nothing on a card is worth a scan of the board per tick until the card is designed for it
- Left out on purpose: removing a relation, which 4179958 assigns to 74904dc. The blocked marker on the card landed in b8ce18c, and it cost no scan of the board: the blockers ride along on the read that already builds the cards. See The Board View
### Campaigns
@@ -108,7 +113,7 @@ and this file is for what someone changing worklane's own code needs.
- **`Resolved` carries what `content_trim` cannot render from the file.** The relations block and the campaign cell both come from elsewhere on the board. A struct rather than two more parameters, so the next such field is one entry here instead of an edit at every call site
- `campaign show` lists **done** members, unlike `ls`, which leaves the done column out of its listing. What is finished against what is left is the whole question a campaign asks, so hiding half the answer is not an option. `ls --campaign` is the other way round: it is the ordinary board filtered, and keeps every rule `ls` already has
- `campaign ls` scans the status directories **once per campaign** to count members. That is a scan per row rather than one walk reused, and it is deliberate: the map-from-uuid version is worth writing when a board has enough campaigns to notice
- **The TUI gets neither a campaign tab nor a card marker**, for now. The detail view resolves the field because it renders the body, and that is all. A marker on a card would want a campaigns read per reload and the four corners are already spent; same reasoning as the blocked marker, which is also its own ticket
- **The TUI gets neither a campaign tab nor a card marker**, for now. The detail view resolves the field because it renders the body, and that is all. A marker on a card would want a campaigns read per reload, which is more than the blocked mark cost: that one reads the ticket's own Relations section on the pass that already builds the card, and a campaign title is in another directory
- `campaign_body()` builds the file from `DESCRIPTION` and `METADATA_HEADING` rather than its own string literals, so the two file formats cannot drift apart on the spelling of a heading. A campaign has no acceptance criteria (its definition of done is derived), no implementation plan and no Status
- The campaigns directory is created by `init` and **on demand** by `campaign add`, since every board made before campaigns existed has none and a `worklane init` over a live board to get one would be a strange thing to have to do
@@ -130,6 +135,9 @@ and this file is for what someone changing worklane's own code needs.
- The draw aligns the focused column again on its own geometry, so a resize between keypress and frame cannot hide the selection, and caps every column against blank space past its last card. The stored value may go stale after a tick shrinks the column; that is fine, because what is drawn is corrected immediately and the next navigation writes the correction back
- Entering another column follows the selection rather than resetting to its top. The card index carries across columns, so a reset would open the column with the highlight below the fold whenever it was — the opposite of the detail view's reset-on-selection-move, where each ticket genuinely starts at its own top. The index is shared and clamps permanently when a shorter column pulls it down, so a column you return to follows the selection to where it now sits rather than holding your old place
- **The footer names only keys that work.** It read `↑↓ scroll` when nothing scrolled at all, which sends the reader looking for their own mistake. A UI that misdescribes itself is worse than one that is merely incomplete
- **`q` and `esc` are one key: close what is open, quit when there is nothing left to close.** `q` used to set `should_quit` outright, so a reader who pressed it to put a ticket away lost the board instead, which is not what `q` does anywhere else that lays a document over a list. One match arm in `main.rs`, not two: two arms carrying one rule is how a later edit changes it for one key and not the other
- **The rule is `Board::dismiss`, not the match arm.** The dispatch in `main.rs` is not reachable from a test, so anything decided there is undecidable by the suite. The arm is the line that names the keys and nothing else. `the_dispatch_gives_q_and_esc_one_arm_and_leaves_ctrl_c_quitting` scans `main.rs` for what the arm cannot say for itself, over whitespace-collapsed source so rustfmt cannot fail it
- **The footer's last slot always answers how to get out**, and with a ticket open the honest answer is `ctrl-c`, the only key left that quits in one press. Going on saying `q quit` there would be 1b78a24 in the other direction: a footer describing a key by what it used to do
- **The overlay names its ticket on the border, not at the head of the paragraph.** `Board::detail` is a `Detail` carrying the title, the id and the text, because the name has to travel beside the body rather than inside it: `content_trim` drops the `# ` heading on purpose, since `cmd_show` prints it, and anything in the paragraph scrolls away
- `detail_title` cuts the string itself instead of leaving it to ratatui, which truncates an overlong block title at whatever cell it reaches and would take the id with it. Cut against the inner width, so the id survives whole and the name ends in an ellipsis. The id goes first because that is how every other view addresses a ticket
- The detail view renders with colour off. ratatui draws styled spans, so an escape sequence in a paragraph would be printed as literal bytes. `content_trim` and `format_comments_with` take the colour decision for that reason
@@ -141,6 +149,12 @@ and this file is for what someone changing worklane's own code needs.
- The criteria count is a field on `TicketItem`, filled in `collect_ticket_items` where the file is already being read, and counted through `criteria()` so a checkbox in a description is not counted here or numbered by `show`. Do not count per card: that re-reads every ticket body on every draw instead of on the tick that changed something. `None` rather than `[0/0]` for a ticket with no criteria
- **The tags go under the title, dimmed, each prefixed with `#`.** The field was invisible on the board: nothing said a ticket was tagged `bug` without opening it. The marker is what stops the row reading as a third line of the title, since a tag is an ordinary word and the title sits directly above it. The row is dropped whole when the column will not hold it, the rule a corner follows, and an untagged ticket spends no row at all, the way a short title spends no second one
- `tags` is a field on `TicketItem`, filled in `collect_ticket_items` through `parse_tags`, for the reason the criteria count is. `parse_tags` splits the comma-separated field into whole trimmed values, so a caller asking for `bug` is not answered by `bugfix`, and reads absent, `_None_` and empty as the same answer
- **A held-up card carries `×` after its id, in brightred.** A ticket waiting on an open blocker looked exactly like one that is ready, and the board is where the next thing to pick up is chosen. Not a fourth circle from Geometric Shapes: those belong to the priority meter two cells away and would read as part of that ramp. The multiplication sign is Latin-1, like the middle dot the unset priority draws, so it renders wherever the meter does
- **The mark goes after the id, not before it.** Ahead of the id it would push every id in the column out of line whenever one card was blocked, which costs more than one card's state is worth. It is measured before the project label and the due date, so both give way to it: those are context for a ticket somebody can start, and this is the one thing on a card that says not to. Dropped whole when the row cannot hold the identity and the mark together, the rule a corner follows
- **`blocked` is on `Card`, not on `TicketItem`.** The answer lives on two tickets at once, so no card can reach it alone, and it is settled at reload the way `project` is. What `collect_ticket_items` fills is the ticket's own `uuid` and its `blockers`, both read off the file it is already holding; `mark_blocked` then walks the four columns once for a uuid-to-status map and once to answer every card. No file is read twice and nothing is asked per draw
- **A blocker the board does not hold marks nothing**, the answer `mv` already gives a dangling uuid. A Relations section that cannot be parsed reads as no blockers, the exception `detail_of` makes for the same reason: `show` and `mv` are where a hand-edited file is reported, and a board that will not draw because one ticket is malformed is the worse failure
- **The merge carries the flag rather than recomputing it.** `relate` resolves its target inside one `.worklane`, so a blocker in another project is not a relation anything can record; resolving over the merged columns would let one project's uuid match another project's ticket. That is b8ce18c's fourth plan step and the answer is no
- `project_label` takes the width the row has already spent, measured off the spans, rather than adding up the widths those spans are supposed to have. The hand-written version left out the space after the priority mark, so a cut label was handed one cell more than the column had; `the_project_label_leaves_the_row_inside_the_column` pins it
- `due_date` cuts a due value back to its date only when it has one. The field is not validated (daa0e79), so it can hold a time or free text, and taking the first word regardless would turn "next friday" into "next"
- **Done is hidden until `d` asks for it.** Not a new opinion: `ls` already counts done in its summary and leaves it out of the listing. Done only grows, so a quarter of the width was going to the column least often read. The footer carries its count while it is hidden, which is the board's version of that summary line
- **Hiding is a change to what is drawn, never to what is read.** `reload` still scans the done directory and `digest` still watches it, so the footer count is right and revealing the column needs no rescan. Do not "optimise" that into a conditional scan
@@ -149,6 +163,20 @@ and this file is for what someone changing worklane's own code needs.
- The choice is not remembered between runs. worklane has no config file and one flag is not a reason to start one; if it should persist, that is its own ticket
- **Assert a column heading against the top border row, not the whole screen.** The footer names done too, so `screen.contains("done (0)")` passes on the footer whether the column is drawn or not. Three tests went vacuous that way the moment done was hidden; `headings()` and `footer()` exist so the next one does not. `headings()` locates the row through `board_area()` rather than taking row zero, since the tab row sits above it when more than one board is monitored
### The Search Prompt
- **`search: Option<Search>` is the whole mode**, the shape `detail` uses: "the prompt is open" and "what is in it" cannot disagree, and closing it leaves nothing to reset. `Search` also carries `missed`, set when enter found nothing and cleared by the next edit, since the message is about the query that missed
- **The prompt swallows every key it is given.** `Board::search_key` runs ahead of the action arms in `main.rs` and reports what it took, rather than every arm below asking whether a search is open. Typing `d` into a query must not toggle done and `q` must not quit; with no prompt open it takes nothing, so the dispatch is unchanged for every other state. The rule is on `Board` for the reason `dismiss` is: the arm is not reachable from a test
- **`ctrl-c` is the one key it declines**, because a terminal application always honours it and a prompt that ate it would leave no way off the board. Every *other* control combination is swallowed and does nothing: it must not type its letter, and it must not fall through either, since the action arms match on the code alone and `ctrl-d` would reach the one bound to `d`
- **Esc is consumed by the search before it can mean anything else**, which is the collision e7612de left behind: `esc` and `q` close the overlay, and both have to lose to an open prompt. It falls out of the pre-branch rather than being ordered by hand
- **`first_match` searches the *visible columns*, every card in them, not the rows on screen.** A query that answered differently on a tall terminal and a short one is not a search, and the jump scrolls the match into view anyway. Hidden columns stay out: with done hidden, a match there would put the highlight on a ticket that is not on the board. Reading order is column by column, then top to bottom
- Id and title only, per 3b16540, both lowercased. The title has to be case insensitive to be worth typing, and giving the id the same treatment lets a pasted id match whatever case it was copied in. An empty or all-space query matches **nothing** rather than everything
- **The jump goes through `select_at`, the tail `select_card` already used.** `follow_selection` scrolls the column the card is in, and the offsets are per column and on the `Tab`, so a jump across columns moves the right one; `refresh_detail` keeps an open overlay on the ticket the selection names. A second version of either is how a jump comes to scroll differently from the arrow keys
- **A hit closes the prompt and a miss keeps it open**, marked, with the selection untouched. The query can then be corrected in place instead of retyped from `/`. Doing nothing visible is what makes a reader retype a query that was already right
- **The prompt takes the whole footer row**, because the key list it replaces describes nothing that currently works while every key is going into the buffer. The typed query is drawn in the default foreground and the keys in grey: one is content, the other is chrome. `no match` is brightred beside the query it is about, since grey chrome is what a reader skips
- **The real terminal cursor goes after the query**, not a glyph standing in for one. ratatui shows the cursor only for a frame that asked for it, so `set_cursor_position` is also what says "you are typing" while the query is still empty. Clamped to the row, so a query longer than the terminal leaves it on the last cell
- Both closed footers name `/`, since the jump works with a ticket open as well: it moves the selection and the overlay follows
- Out of scope on purpose, each its own ticket once the input mode exists: `n` and `N` for the next and previous match, searching the description, tags or owner, regex, and filtering the board down to matches rather than selecting one
### Monitoring Several Boards
- `worklane tui <path>...` takes any number of paths, each resolved through `find_worklane_dir` the way the working directory is: the first `.worklane` at or above it. No path is the working directory, so a bare `worklane` and `worklane tui` are unchanged
- The failure **names the path** that had no board, since with several arguments "No .worklane directory found" does not say which one was wrong. Only when a path was given: a bare `worklane` has no path to name and keeps the message every other command gives, which is what its integration test asserts
@@ -178,6 +206,8 @@ and this file is for what someone changing worklane's own code needs.
- **A refused document does not stop the ones behind it.** The loop reports an outcome per document and the "pick it up on their next session" line is printed once, and only when something was actually written
- **A role skill is its own document, not a section of `SKILL.md`.** The frontmatter description is the whole of what decides whether a skill loads, and one description cannot name both "anything touching a ticket" and "only when a review is asked for" without fitting neither. It is also why the review document does not restate the CLI: it says to read the `worklane` skill too
- The review skill's own rules are guarded by `the_review_skill_keeps_the_decisions_that_define_it`, because each of them is a line an edit could drop without breaking anything: **the reviewer never ticks a criterion** (a tick is the implementer's claim, unticking is the review disagreeing, and one mark for both loses the disagreement), **never moves the ticket** (`mv` belongs to whoever does the work, the reviewer's half is the recommendation), and **never reviews the working tree when no commit names the ticket** (it says what it searched for and stops, since an untraceable ticket in `reviewing` is itself the finding)
- **The plan skill is the one that can do damage, so its rules are the ones under test.** `set --tags` replaces the whole field, so a sweep that restates a ticket's tags incompletely deletes the rest, and a due date is neither validated nor clearable. `the_plan_skill_keeps_the_rules_that_bound_a_sweep` pins propose-then-apply and those two traps, because a document that loses them still reads like a plan
- `.opencode/agent/feature-planner-agent.md` is **deliberately not folded into `PLAN.md`**. It decomposes a feature request into new tickets, which is intake; `PLAN.md` orders the tickets that already exist. Merging them would give one document two jobs and a frontmatter description that fits neither, which is the same reason the review skill is its own document
- `every_agent_facing_subcommand_is_documented` stays on `SKILL` alone. It owns the CLI surface; a role document uses the handful of commands its job needs, and requiring the rest would fill a review document with `init` and campaigns to satisfy a test. The two checks that do run over every document are the frontmatter and that no document shows a command that does not exist
### Color and Output
@@ -198,6 +228,11 @@ and this file is for what someone changing worklane's own code needs.
- Title → green (32)
- Unknown values (`_None_`, `_Not set_`) → grey (38;5;8)
- Priority ramp → brightred (1), red (2), orange (3), cyan (4), grey (5). Green is deliberately absent: it means title
- **The palette splits in two: seven colours that each mean one thing, and `TAG_COLORS`, the eight a tag may be drawn in.** A tag in red would read as a uuid, in green as a title, in grey as an unset value, so the tag slots are reserved as a list rather than picked at the call site. Do not assign a new meaning to a colour in `TAG_COLORS`, and do not draw a tag in one outside it
- `tag_color()` is a pure function of the tag string, so the same tag is the same colour on every card, in every view and on every board, with nothing stored. Case sensitive, because `Bug` and `bug` are two different tags to the field and to every search
- **The hash is FNV-1a written out here, not `DefaultHasher`.** std does not promise its output is stable across releases, and a board that repaints itself on a toolchain upgrade has lost the only property the mapping is for. `the_tag_mapping_is_pinned` fails on any change to it, so a repaint is a decision rather than a surprise
- **The index is multiply-shift, not `% TAG_COLORS.len()`.** The length is a power of two, so a modulus keeps only the low three bits of the hash, and FNV-1a's low bits carry only the low bits of the input bytes: multiplication cannot move information downwards. Under a modulus every pair of tags differing above bit 2, `bug` and `BUG` among them, landed in one slot regardless of the rest of the string. It looked like a *good* palette on this board, two colliding cards out of sixty-four, because the vocabulary had been folded into a handful of slots. Taking the top bits of a 128-bit product uses the whole hash
- Eight tag colours means roughly one card in five shows two tags alike. That is arithmetic and is accepted: the colour groups a tag across cards, it does not tell two tags apart within one, and the tag text is beside it either way. Do not widen the list to chase the number on one board
- Grey is indexed colour 8 in the 256-colour form, not SGR 90 or 37. Both of those failed on a real palette: 90 leans on the bright-black slot and 37 can sit on top of the default foreground. `\x1b[38;5;8m` is byte for byte what crossterm emits for ratatui's `Color::DarkGray`, the grey frig and pantop use for dimmed rows
### Code Organization
Generated
+1 -1
View File
@@ -1494,7 +1494,7 @@ dependencies = [
[[package]]
name = "worklane"
version = "0.13.0"
version = "0.13.6"
dependencies = [
"anyhow",
"assert_cmd",
+1 -1
View File
@@ -1,6 +1,6 @@
[package]
name = "worklane"
version = "0.13.0"
version = "0.13.6"
edition = "2024"
[dependencies]
+2 -2
View File
@@ -7,7 +7,7 @@ Worklane is a local Kanban flow for agentic software development.
|---------|-------------|
| `worklane` or `worklane tui [path...]` | Opens the board: four status columns, redrawn when the tree changes. Read only. Opens on backlog, committed and reviewing; `d` shows or hides done, whose count stays in the footer either way. Arrows or `hjkl` to move, `enter` for detail, `pgup`/`pgdn` to scroll an open ticket, `q` to quit. Each path opens the first `.worklane` at or above it, the working directory by default. Several paths are monitored together, as a tab per project plus an `all` tab that merges them, with `tab` and `shift+tab` between them |
| `worklane init` | Creates `.worklane/` with backlog, committed, reviewing, done directories |
| `worklane add` | Creates a ticket in backlog with `--title`, `--description`, `--acceptance`, `--plan`, `--tags`, `--due`, `--owner`, `--priority` flags |
| `worklane add` | Creates a ticket in backlog with `--title`, `--description`, `--acceptance`, `--plan`, `--tags`, `--due`, `--owner`, `--priority` flags. `--due` takes `YYYY-MM-DD` and refuses anything else at parse time |
| `worklane ls [status]` | Lists tickets, sorted by priority then title. Optional positional status, and `--priority <1-5>` |
| `worklane show <id>` | Shows ticket by UUID prefix (4+ chars), title substring, or filename substring |
| `worklane mv <id> --status <target> [-f]` | Moves ticket between statuses. Default: forward only, one stage at a time. `-f` bypasses both restrictions |
@@ -18,7 +18,7 @@ Worklane is a local Kanban flow for agentic software development.
| `worklane check <ticket> [criterion]` | Ticks one acceptance criterion, by number as shown by `show` or by a substring. Prompts with the numbered list if omitted, or errors with it when there is no terminal |
| `worklane uncheck <ticket> [criterion]` | Unticks one acceptance criterion, addressed the same way |
| `worklane comment <ticket> <body>` | Adds a comment to a ticket by UUID or title |
| `worklane install-skill [skill]` | Writes the embedded agent skills to `~/.claude/skills/<skill>/SKILL.md`, which Claude Code and opencode both read. Two ship: `worklane` teaches the CLI, `worklane-review` reviews a finished ticket against the code that claims to close it. Every document unless one is named. Leaves a modified copy alone unless `--force`; `--print` writes one to stdout instead and needs the name |
| `worklane install-skill [skill]` | Writes the embedded agent skills to `~/.claude/skills/<skill>/SKILL.md`, which Claude Code and opencode both read. Three ship: `worklane` teaches the CLI, `worklane-review` reviews a finished ticket against the code that claims to close it, `worklane-plan` grooms the board as a whole, its priorities, due dates, tags and campaigns. Every document unless one is named. Leaves a modified copy alone unless `--force`; `--print` writes one to stdout instead and needs the name |
## Exit codes
| Code | Meaning |
+183
View File
@@ -0,0 +1,183 @@
---
name: worklane-plan
description: Groom a worklane board as a whole rather than one ticket at a time: review whether the priorities are right relative to each other, plan work by setting due dates, check the tags for consistency, and find the tickets that belong together in a campaign. Use for questions about the backlog as a body of work, what to do next week, what is mis-prioritised or mis-tagged, and what could become one goal. Not for filing or working a single ticket.
---
# Planning a worklane board
For "are the backlog priorities right", "plan in tickets for next week", "check the
tagging", "which of these could be one campaign". The subject is the board, not a
ticket. Filing one, working one and reviewing one are other jobs.
The CLI itself is the `worklane` skill: the statuses, how a ticket is addressed and
which command owns which field. Read it too. This document is the judgement.
## The one rule
**Propose the whole set of edits, wait, then apply exactly what was approved.**
Every job here writes to many tickets at once, and no field can be cleared back to unset
yet, so a date written onto the wrong ticket can only be overwritten, never taken off. A wrong
edit to one ticket is a mistake; a wrong sweep is thirty of them with no undo. So a
proposal is a list, one line per intended edit, each naming the ticket and the command
that would make it:
```
(1b78a24) priority 3 -> 1 worklane set 1b78a24 --priority 1
(4179958) due -> 2026-08-29 worklane set 4179958 --due 2026-08-29
```
Then apply what was approved and nothing else. Not "and a few obvious ones while I was
there": an approval is for the list that was shown.
## Who writes what
Every field has exactly one command that writes it, and a sweep that reaches for any
other way is editing the file by hand:
| Field | Writer |
|-------|--------|
| Priority, Due, Tags | `worklane set <ticket> --priority` / `--due` / `--tags` |
| Relations | `worklane relate <ticket> --blocked-by` / `--regression-of` / `--relates-to` |
| Campaign membership | `worklane assign <campaign> <ticket>` |
| Owner | `worklane chown <user> <ticket>` |
| Status | `worklane mv <ticket> --status <target>` |
**Never edit a ticket file directly.** The filename, the `Status` field and the directory
have to agree, and the commands are what keep them agreeing. A hand-written Relations
line is worse still: it is the one section read back by machine, and a target that does
not resolve to a uuid is an error on every later read of that ticket.
The last two rows are in the table to be recognised, not used. See the closing section.
## Read the board first
```
worklane ls # every status, counts then tickets
worklane ls backlog # one status
worklane ls --priority 1 # the top of the pile
worklane show 1b78a24 # one ticket, with its relations and comments
worklane campaign ls # the goals that already exist
```
`ls` prints the mark, the id, the title, the owner and the due date. It does **not**
print tags, and there is no tag filter yet, so any judgement about tags means reading the
tickets themselves. On a board of a few dozen that is a `show` per ticket and is worth
doing rather than guessing from titles.
Read `done` too when the question is about what to do next. What was finished last is the
best evidence of what this board actually moves at, and a plan that ignores it is a wish.
## Priorities
Priority runs **1 most urgent to 5 least**, and may be unset. `worklane set <ticket>
--priority <n>` is the only writer.
Priority is relative. A ticket is never urgent by itself, it is urgent above something
else, so every proposed change has to name what it now sits above and below. "This looks
important" is not a reason; "this blocks three tickets that are all dated before it" is.
What to look for:
- **A blocker priced below what it blocks.** Read the Relations. A ticket that others are
`blocked by` cannot be less urgent than the most urgent of them, or the board is asking
for work in an order it will not allow.
- **A flat board.** If almost everything is 3, the field is carrying no information and
the answer is not to renumber everything at once. Propose the few that are genuinely 1
and the few that are genuinely 5, and leave the middle alone.
- **Too many 1s.** If everything is urgent, nothing is. Say how many there are before
proposing another.
- **A low priority already in `committed`.** Either the priority is wrong or starting it
was, and which one it is decides whether the fix is a `set` or a conversation.
- **A priority nobody has touched since the ticket was filed.** It is the filer's first
guess, not a decision. That is the pile worth reading.
## Due dates
`worklane set <ticket> --due 2026-08-29`, format `YYYY-MM-DD`.
A value that is not a real calendar date in that exact form is refused before anything
is written, so a typo costs nothing. `2026-8-9` is refused too: the padding is part of
the format. What is still true is that a date, once written, **cannot be cleared**, only
replaced by another date, so a plan applied to the wrong ticket has no undo.
Ask the system what today is rather than assuming it. A plan built on a guessed date is
wrong by however much the guess was wrong.
The rules a dating plan has to keep:
- **Nothing is dated before the ticket it is blocked by.** Read the Relations first and
date blockers ahead of their dependents. A dependent dated before its blocker is a date
`mv` will refuse to honour anyway.
- **A blocker left undated makes its dependent's date a fiction.** Either date both or
neither.
- **Date what fits, not what exists.** Ask how much capacity the week holds, or take the
answer from what `done` shows the board finishing in a comparable stretch. Dating the
whole backlog produces a board where every ticket is late, which is the same as no
dates at all.
- **Do not date `done`.** It is finished; a date on it is noise in every listing.
- Leave the rest unset. An unset due date is honest about what has not been planned.
## Tags
`worklane set <ticket> --tags bug,cli` is the writer, and it **replaces the whole
field**. Restate every tag the ticket should keep, or the ones you left out are gone.
This is the single most destructive thing in this document.
Derive the vocabulary from the board rather than inventing one. Read the tickets, count
what is actually used, and show the count before proposing anything. What to report:
- **Two spellings of one idea.** `bug` and `bugfix`, `tui` and `ui`. Pick the one already
used more and say so.
- **A tag used exactly once.** Either it is the start of a category and should be applied
to its siblings, or it is a private note and should go. Do not leave it as it is without
saying which.
- **A tag that restates a field.** A `p1` tag beside a Priority field, an `open` tag
beside a Status, an owner's name as a tag. The field is the writer; the tag is a copy
that will disagree with it. This board already made that mistake once with priority and
undid it deliberately.
- **An untagged ticket** in a board where everything else is tagged. It is invisible to
every question asked by tag.
Tags are for kind, not for state and not for goal. State is the status directory and the
fields; a goal is a campaign.
## Campaigns
```
worklane campaign ls
worklane campaign show "v1 release"
worklane campaign add --title "..." --description "..."
worklane assign "v1 release" 1b78a24
```
A campaign is the tickets that have to be finished **together** for one outcome. The test
is whether you can name the outcome in a single line without listing the members. "The
tui is usable on a narrow terminal" is a campaign. "The tui tickets" is a tag.
- **Do not group by tag.** Ten tickets tagged `bug` share a kind, not a goal, and putting
them in a container says nothing that the tag did not already say.
- **Check what exists first.** `campaign ls` before proposing a new one, or you will
propose a second container for a goal that already has one.
- **A ticket is in at most one campaign**, and `assign` moves it rather than adding a
second. So two proposed campaigns that overlap are really one proposal to take members
out of the other, and it has to say so.
- **A campaign's state is derived**, open until every member is done. There is nothing to
close and nothing to move. A campaign whose members are all done is finished already.
- `assign` takes the **campaign first and the ticket second**, like `chown`.
Proposing a campaign means naming the goal, the members, and what is deliberately left
out of it. The last part is what makes it a goal rather than a pile.
## What a planner does not touch
- **Descriptions, acceptance criteria and implementation plans.** They are the ticket
author's account of the work, and grooming is about how the work is ordered, not what
it is. Something wrong in there is a comment on that ticket.
- **Status.** `mv` belongs to whoever does the work. A plan that moves tickets between
columns is reporting progress that did not happen.
- **Owner.** `chown` records a commitment a person made. Propose it, do not write it,
unless you were asked to assign the work.
- **New tickets.** Grooming is about what is on the board. Something genuinely missing is
worth filing, by the rules in the `worklane` skill, but say it is a new ticket rather
than folding it into a grooming sweep.
+3
View File
@@ -85,6 +85,9 @@ worklane add \
checked off as true or false.
- **`--plan`** takes one step per flag, numbered for you.
- **`--priority`** runs 1 (most urgent) to 5 (least), and is left unset if omitted.
- **`--due`** takes `YYYY-MM-DD` and nothing else. Anything that is not a real calendar
date in that exact form, `2026-8-9` and `2026-02-30` included, is a usage error with
nothing written. The same parser guards `set --due`.
Editing afterwards, on a ticket in any status:
+44 -2
View File
@@ -2,6 +2,8 @@ use clap::Parser;
use std::sync::LazyLock;
use chrono::NaiveDate;
use crate::util::{PRIORITY_RANGE, RelationKind, priority_legend};
/// clap wants a `&str` with a long enough lifetime, and the legend is built from
@@ -53,6 +55,42 @@ fn non_empty(raw: &str) -> Result<String, String> {
Ok(raw.to_string())
}
/// Reject a due date that is not a real calendar date in the promised form.
///
/// At parse time, like `priority_level`, so a mistyped date is a usage error with
/// nothing written rather than a value the board goes on showing. `--due` is one of the
/// scalars deliberately left without `PROSE`, so this is the same bargain: nothing here
/// holds prose, and a wrong value should stop the command.
///
/// **The shape is checked before chrono sees it.** `%Y-%m-%d` accepts an unpadded
/// `2026-8-9`, which would then be stored exactly as typed and sort before `2026-10-01`
/// in any comparison of the strings. Checking the length and the two dashes first is
/// what lets a valid date be stored unchanged rather than normalised on the way in.
///
/// Strict on the way in, tolerant on the way out: `util::due_date` still cuts a
/// datetime down to its date, because a file written before this existed, or by hand,
/// can hold one and still has to render.
fn iso_date(raw: &str) -> Result<String, String> {
// An empty value keeps the message that explains why it is refused, since somebody
// typing it is reaching for a way to clear the field rather than mistyping a date.
non_empty(raw)?;
let bytes = raw.as_bytes();
let shaped = raw.len() == 10 && bytes[4] == b'-' && bytes[7] == b'-';
if !shaped || NaiveDate::parse_from_str(raw, "%Y-%m-%d").is_err() {
// Not echoing the value: clap has already printed `invalid value '...' for
// '--due <DUE>'` above this line, and `priority_level` says its piece the same
// way.
return Err(
"due date must be a real calendar date written as YYYY-MM-DD, for example 2026-08-29"
.to_string(),
);
}
Ok(raw.to_string())
}
/// Arguments that carry prose, and therefore have to accept a value starting with
/// a hyphen.
///
@@ -275,7 +313,7 @@ pub struct AddArgs {
pub tags: Vec<String>,
/// Due date (YYYY-MM-DD)
#[arg(long)]
#[arg(long, value_parser = iso_date)]
pub due: Option<String>,
/// Owner
@@ -324,7 +362,11 @@ pub struct SetArgs {
pub tags: Vec<String>,
/// Replace the due date (YYYY-MM-DD)
#[arg(long, value_parser = non_empty)]
///
/// The same parser as `add`: one field, one definition of what a due date is. The
/// planning skill sets dates through `set` rather than `add`, so validating only
/// the one that files a ticket would leave the path that is actually used open.
#[arg(long, value_parser = iso_date)]
pub due: Option<String>,
/// Replace the priority, 1 (most urgent) to 5 (least)
+37 -1
View File
@@ -54,11 +54,24 @@ pub const REVIEW_SKILL: Asset = Asset {
content: include_str!("../assets/REVIEW.md"),
};
/// The skill that grooms the board as a whole rather than a ticket at a time.
///
/// Its own document for the reason `REVIEW_SKILL` is: it is wanted for questions about
/// the backlog as a body of work, and loading it for every ticket touched would be a
/// description that fits nothing. It is also the document where the destructive edits
/// live, since every job in it writes to many tickets at once.
pub const PLAN_SKILL: Asset = Asset {
name: "worklane-plan",
what: "skill",
relative: "worklane-plan/SKILL.md",
content: include_str!("../assets/PLAN.md"),
};
/// Every skill this binary carries, in the order they install.
///
/// A `static` rather than a `const` so the slice borrowed from it outlives the
/// statement that took it: a `const` is inlined at each use and the borrow dies there.
pub static SKILLS: [Asset; 2] = [SKILL, REVIEW_SKILL];
pub static SKILLS: [Asset; 3] = [SKILL, REVIEW_SKILL, PLAN_SKILL];
/// The skill a name on the command line asks for.
pub fn skill_named(name: &str) -> Result<&'static Asset> {
@@ -363,6 +376,29 @@ mod tests {
}
}
/// The rules that keep a grooming sweep from being a silent rewrite of the board.
///
/// Every one of these is a line an edit could drop while leaving a document that
/// still reads like a plan: `set --tags` replacing the whole field is how thirty
/// tickets quietly lose their tags, and propose-then-apply is the only thing
/// standing between a wrong judgement and thirty wrong tickets.
#[test]
fn the_plan_skill_keeps_the_rules_that_bound_a_sweep() {
for required in [
"Propose the whole set of edits",
"replaces the whole\nfield", // `set --tags` is the destructive one
"cannot be cleared", // and a due date cannot be taken back
"blocked by", // ordering constrains any dating plan
"worklane campaign ls",
"does not touch",
] {
assert!(
PLAN_SKILL.content.contains(required),
"the plan skill no longer says {required:?}"
);
}
}
/// The decisions that make the review document a review rather than a rewrite.
///
/// Each of these is a rule an edit would drop without breaking anything else: a
+22 -7
View File
@@ -163,17 +163,27 @@ fn run_tui(paths: &[std::path::PathBuf], start: &std::path::Path) -> Result<()>
continue;
}
// Ahead of the arms, because a prompt has to swallow every key it is
// given: typing `d` into a query must not toggle the done column and `q`
// must not quit. It reports what it took, so the arms below stay a plain
// match on the keys it did not, and it takes nothing when no prompt is open.
// The rule is `Board::search_key`, where a test can reach it.
if board.search_key(key, screen) {
continue;
}
match key.code {
KeyCode::Char('q') => board.should_quit = true,
// One arm, because the two keys mean one thing: close what is open, and
// quit when there is nothing left to close. Two arms carrying one rule
// is how a later edit changes it for one key and not the other, which is
// what `q` quitting out from under an open ticket already was. The rule
// itself is `Board::dismiss`, where a test can reach it.
KeyCode::Esc | KeyCode::Char('q') => board.dismiss(),
// The only key that leaves the board from an open ticket, which is why
// the footer names it there.
KeyCode::Char('c') if key.modifiers.contains(KeyModifiers::CONTROL) => {
board.should_quit = true
}
// Esc closes the detail view, and only quits when there is nothing
// left to dismiss.
KeyCode::Esc => match board.detail {
Some(_) => board.toggle_detail(),
None => board.should_quit = true,
},
KeyCode::Enter | KeyCode::Char(' ') => board.toggle_detail(),
KeyCode::Left | KeyCode::Char('h') => board.select_column(-1, screen),
KeyCode::Right | KeyCode::Char('l') => board.select_column(1, screen),
@@ -191,6 +201,11 @@ fn run_tui(paths: &[std::path::PathBuf], start: &std::path::Path) -> Result<()>
KeyCode::BackTab => board.select_tab(-1, screen),
// Free of the other bindings, and the footer names it in both states.
KeyCode::Char('d') => board.toggle_done(screen),
// An ordinary single-shot action like the rest: it opens the prompt, and
// from the next keypress on `search_key` above has the keyboard. A `/`
// typed into an open prompt is taken there as a character, so this arm
// is only ever the way in.
KeyCode::Char('/') => board.open_search(),
_ => {}
}
}
+1012 -35
View File
File diff suppressed because it is too large Load Diff
+331 -1
View File
@@ -68,6 +68,17 @@ pub enum Color {
Grey,
Magenta,
BrightRed,
// The eight the tag palette draws from. Named as colours rather than as `TagBlue`,
// because the enum is the palette and `TAG_COLORS` is what reserves them: a use
// belongs to the list that claims it, not to the name of the colour it claims.
Blue,
Sky,
Violet,
Pink,
Turquoise,
Olive,
Tan,
Steel,
}
impl Color {
@@ -88,11 +99,23 @@ impl Color {
Color::Magenta => "\x1b[1;35m",
// Indexed, for the same reason grey is: this is the spelling that renders.
Color::BrightRed => "\x1b[38;5;9m",
// The tag palette, indexed throughout. The basic slots are themed by the
// terminal and drift towards each other on a real palette, which is fine
// for seven colours that each mean something and useless for six that have
// to stay apart from those seven and from one another.
Color::Blue => "\x1b[38;5;33m",
Color::Sky => "\x1b[38;5;117m",
Color::Violet => "\x1b[38;5;99m",
Color::Pink => "\x1b[38;5;205m",
Color::Turquoise => "\x1b[38;5;43m",
Color::Olive => "\x1b[38;5;106m",
Color::Tan => "\x1b[38;5;137m",
Color::Steel => "\x1b[38;5;67m",
}
}
/// Every colour in the palette, so a test can walk them without listing them.
pub const ALL: [Color; 7] = [
pub const ALL: [Color; 15] = [
Color::Red,
Color::Cyan,
Color::Orange,
@@ -100,9 +123,95 @@ impl Color {
Color::Grey,
Color::Magenta,
Color::BrightRed,
Color::Blue,
Color::Sky,
Color::Violet,
Color::Pink,
Color::Turquoise,
Color::Olive,
Color::Tan,
Color::Steel,
];
}
/// The colours a tag may be drawn in.
///
/// Deliberately disjoint from the seven that already carry a meaning, per the guideline
/// in AGENTS.md: a tag in red reads as a uuid, in green as a title, in grey as an unset
/// value. Reserving slots here rather than picking at the call site is what keeps the
/// next colour someone assigns from landing on top of the tags.
///
/// Eight, and a real board carries more tags than that, so two tags will share a
/// colour. That is accepted rather than designed around: the colour groups one tag
/// across cards, it does not identify it, and the tag is written out beside it either
/// way. Nothing pure can do better, since a function of the tag alone cannot know what
/// else sits on the card.
///
/// Eight rather than six because two tags on one card collide at roughly `1 / n`, so
/// the only lever is the size of the list. It stops here because these are the slots
/// the assigned meanings leave: red, orange, green, cyan, magenta and grey are spoken
/// for, and a ninth would have to be a shade of one of the eight. Two colours nobody
/// can tell apart are a collision by another name.
///
/// At eight, about a fifth of the cards on this board show two tags in one colour. That
/// is the arithmetic, not a fault to fix: the colour groups one tag *across* cards, so
/// a repeat within a card costs nothing that the tag text beside it does not answer.
///
/// Do not tune this against the tags on one board. The count of collisions on any given
/// board swings either side of the average on the luck of the hash, and picking the
/// length that flatters today's vocabulary would be fitting to noise. An earlier draft
/// scored two collisions in sixty-four here, which looked like a good palette and was
/// really a broken index folding the whole vocabulary into a handful of slots.
pub const TAG_COLORS: [Color; 8] = [
Color::Blue,
Color::Sky,
Color::Violet,
Color::Pink,
Color::Turquoise,
Color::Olive,
Color::Tan,
Color::Steel,
];
/// FNV-1a, 64 bit, over the bytes of the tag.
///
/// Written out rather than taken from `std`: `DefaultHasher` is explicitly not promised
/// to keep its output stable across releases, and a board that repaints itself on a
/// toolchain upgrade has lost the one property this is for. Nine lines and no
/// dependency buys a mapping that is the same on every machine and every version.
fn fnv1a(bytes: &[u8]) -> u64 {
const OFFSET: u64 = 0xcbf2_9ce4_8422_2325;
const PRIME: u64 = 0x0000_0100_0000_01b3;
let mut hash = OFFSET;
for byte in bytes {
hash ^= u64::from(*byte);
hash = hash.wrapping_mul(PRIME);
}
hash
}
/// The colour a tag is drawn in, derived from the tag itself.
///
/// A pure function of the string, so the same tag is the same colour on every card, in
/// every view and on every board, with nothing stored and nothing to keep in step. Two
/// boards that have never met agree about `bug`.
///
/// Case sensitive, because `Bug` and `bug` are two different tags everywhere else in
/// worklane. Colouring them alike would be the display claiming a sameness the filter
/// and the field do not have.
pub fn tag_color(tag: &str) -> Color {
// Multiply-shift, not `% len`. The palette length is a power of two, so a modulus
// would keep the low three bits of the hash, and FNV-1a's low bits carry only the
// low bits of the input bytes: the multiply cannot move information downwards and
// the xor never does. `bug` and `BUG` differ in bit 5 of every letter, so under a
// modulus they landed in the same slot no matter what else the strings held, as did
// every other pair differing only above bit 2. Taking the top bits of the product
// uses the whole hash, which is where the avalanche is.
let index = (u128::from(fnv1a(tag.as_bytes())) * TAG_COLORS.len() as u128) >> 64;
TAG_COLORS[index as usize]
}
/// The same palette as ratatui sees it.
///
/// Chosen to match what crossterm emits for the escape above, so a card in the TUI and
@@ -119,6 +228,16 @@ impl From<Color> for ratatui::style::Color {
Color::Grey => Tui::DarkGray,
Color::Magenta => Tui::Magenta,
Color::BrightRed => Tui::LightRed,
// Indexed on both sides, so the card and the listing are the same colour
// by construction rather than by two guesses that happen to agree.
Color::Blue => Tui::Indexed(33),
Color::Sky => Tui::Indexed(117),
Color::Violet => Tui::Indexed(99),
Color::Pink => Tui::Indexed(205),
Color::Turquoise => Tui::Indexed(43),
Color::Olive => Tui::Indexed(106),
Color::Tan => Tui::Indexed(137),
Color::Steel => Tui::Indexed(67),
}
}
}
@@ -673,9 +792,40 @@ fn metadata_value_cell(name: &str, value: &str, colored: bool, campaign: &str) -
return paint(value, Color::Grey, colored);
}
if name == "Tags" {
return paint_tags(value, colored);
}
value.to_string()
}
/// The stored tag list with each tag in its own colour.
///
/// Painted in place rather than split and rejoined, so whatever separators the file
/// holds come back unchanged. `bug, cli` and `bug,cli` are both written by hand at some
/// point, and a cell that normalised them would be the display quietly disagreeing with
/// the file it is showing.
fn paint_tags(value: &str, colored: bool) -> String {
value
.split(',')
.map(|piece| {
let tag = piece.trim();
if tag.is_empty() {
return piece.to_string();
}
let lead = piece.len() - piece.trim_start().len();
format!(
"{}{}{}",
&piece[..lead],
paint(tag, tag_color(tag), colored),
&piece[lead + tag.len()..]
)
})
.collect::<Vec<_>>()
.join(",")
}
/// Render the Metadata section as two aligned columns.
///
/// Taken as a block rather than a line at a time because the field column cannot be
@@ -1836,6 +1986,27 @@ pub struct TicketItem {
/// asking per card would re-read every ticket body on every draw rather than on the
/// tick that changed something.
pub tags: Vec<String>,
/// The full uuid from the ticket's own ID field, as a relation stores it.
///
/// `id` is the seven characters a listing prints; a relation names the whole uuid,
/// so pairing a stored blocker with the ticket it points at needs the whole thing.
/// Absent or unset reads as `_Not set_`, the way every other field does, and the
/// board guards for it rather than matching on it.
pub uuid: String,
/// The uuids of the tickets this one records a `blocked by` against, empty when it
/// records none.
///
/// Read here for the reason `criteria` is: the board marks every held-up card on
/// every tick, and asking per card would re-read every ticket body on every draw.
/// The uuids only, never the answer: whether a blocker is still open is a fact
/// about another ticket, so it belongs to whoever holds the whole board.
///
/// A Relations section that cannot be parsed reads as no blockers rather than as a
/// ticket that cannot be listed. `show` and `mv` still refuse it, which is where a
/// hand-edited file has to be reported; a board or a listing that stops on one
/// malformed ticket is the worse failure, and is the same exception `detail_of`
/// already makes.
pub blockers: Vec<String>,
/// The file this came from. The listing ignores it; the TUI opens it for the
/// detail view rather than resolving the ticket a second time.
pub path: std::path::PathBuf,
@@ -1971,6 +2142,13 @@ pub fn collect_ticket_items(status_path: impl AsRef<Path>) -> Result<Vec<TicketI
let filename = e.path().file_stem()?.to_string_lossy().to_string();
let created_at = parse_ticket_field(&content, "Created At");
let blockers = parse_relations(&content, &title)
.unwrap_or_default()
.into_iter()
.filter(|relation| relation.kind == RelationKind::BlockedBy)
.map(|relation| relation.target)
.collect();
// Through `criteria()`, so the card and the numbers `show` prints cannot
// disagree: a checkbox written into a description is not a criterion there
// and is not counted here.
@@ -1993,6 +2171,8 @@ pub fn collect_ticket_items(status_path: impl AsRef<Path>) -> Result<Vec<TicketI
criteria: progress,
campaign: parse_campaign(&content),
tags: parse_tags(&content),
uuid: parse_ticket_field(&content, "ID"),
blockers,
path: e.path(),
})
})
@@ -2405,6 +2585,45 @@ mod tests {
fs::remove_dir_all(&dir).unwrap();
}
/// The blockers come off the read that builds the item, so the board pays no second
/// pass for them, and only the `blocked by` kind is one: the other two record no
/// dependency and gate nothing.
///
/// A section that cannot be parsed reads as no blockers rather than as a ticket that
/// cannot be listed. `show` and `mv` are where a hand-edited file is reported; a
/// listing that stops on one malformed ticket is the worse failure.
#[test]
fn collect_ticket_items_reads_the_uuid_and_the_blockers_it_records() {
let dir = std::env::temp_dir().join(format!("worklane-blocked-{}", uuid::Uuid::new_v4()));
fs::create_dir_all(&dir).unwrap();
let uuid = |tail: &str| format!("11111111-0000-4000-8000-00000000000{tail}");
let write = |name: &str, relations: &str| {
fs::write(
dir.join(format!("{}.md", uuid(name))),
format!(
"# T{name}\n\n## Relations\n{relations}\n## Metadata\n\n- **ID**: {}\n",
uuid(name)
),
)
.unwrap();
};
write("1", &format!("\n- blocked by {}\n- relates to {}\n", uuid("2"), uuid("3")));
write("2", "\n- regression of 99999999-0000-4000-8000-000000000000\n");
write("3", "\n- waits for the other one\n");
let items = collect_ticket_items(&dir).unwrap();
let of = |title: &str| items.iter().find(|item| item.title == title).unwrap();
assert_eq!(of("T1").uuid, uuid("1"));
assert_eq!(of("T1").blockers, vec![uuid("2")]);
assert!(of("T2").blockers.is_empty(), "a regression was read as a blocker");
assert!(of("T3").blockers.is_empty(), "an unreadable section was not survived");
fs::remove_dir_all(&dir).unwrap();
}
/// Whole values, so a filter or a card cannot confuse two tags that share a prefix.
#[test]
fn parse_tags_splits_on_commas_and_keeps_whole_values() {
@@ -2801,6 +3020,117 @@ mod tests {
assert_eq!(seen.len(), Color::ALL.len());
}
/// The text a cell holds once its colour is taken off, so a test can assert the
/// separators survived without spelling out the escapes around them.
fn strip_escapes(text: &str) -> String {
let mut out = String::with_capacity(text.len());
let mut rest = text;
while let Some(at) = rest.find('\x1b') {
out.push_str(&rest[..at]);
match rest[at..].find('m') {
Some(end) => rest = &rest[at + end + 1..],
None => return out,
}
}
out.push_str(rest);
out
}
#[test]
fn a_tag_keeps_its_colour_and_different_tags_do_not_all_share_one() {
assert_eq!(tag_color("bug"), tag_color("bug"));
assert_eq!(tag_color("frontend"), tag_color("frontend"));
let spread: std::collections::HashSet<Color> =
["bug", "feature", "cli", "tui", "docs", "chore", "output", "skills"]
.iter()
.map(|tag| tag_color(tag))
.collect();
assert!(spread.len() > 3, "the mapping collapses the vocabulary: {spread:?}");
}
/// Case sensitive on purpose: `Bug` and `bug` are two different tags to the field
/// and to every search, so one colour for both would be the display claiming a
/// sameness nothing else has.
///
/// Over a set rather than one pair. Any single pair can land in the same slot by
/// luck, one time in `TAG_COLORS.len()`, and a test that reads that accident as
/// case folding would be asserting the hash rather than the rule.
#[test]
fn tag_colour_does_not_fold_case() {
let folded = ["bug", "cli", "tui", "docs", "chore"]
.iter()
.all(|tag| tag_color(tag) == tag_color(&tag.to_uppercase()));
assert!(!folded, "tag_color lowercases before hashing");
}
/// Pinned so that a change to the hash is a failing test rather than a board that
/// quietly repaints itself. If this fails, the mapping moved: decide whether that
/// was intended before rewriting the expectations.
#[test]
fn the_tag_mapping_is_pinned() {
assert_eq!(tag_color("bug"), Color::Blue);
assert_eq!(tag_color("feature"), Color::Blue);
assert_eq!(tag_color("cli"), Color::Steel);
assert_eq!(tag_color("tui"), Color::Violet);
assert_eq!(tag_color("docs"), Color::Tan);
assert_eq!(tag_color("chore"), Color::Sky);
assert_eq!(tag_color("skills"), Color::Tan);
assert_eq!(tag_color("output"), Color::Blue);
}
/// The whole reason the tag palette is a reserved list rather than a pick at the
/// call site: a tag drawn in red reads as a uuid, in green as a title, in grey as
/// an unset value.
#[test]
fn no_tag_colour_carries_another_meaning() {
for assigned in [
Color::Red,
Color::Orange,
Color::Cyan,
Color::Green,
Color::Grey,
Color::Magenta,
Color::BrightRed,
] {
assert!(
!TAG_COLORS.contains(&assigned),
"{assigned:?} means something else already"
);
}
// The priority ramp is the other list that claims colours, and it is built from
// the assigned seven rather than named here, so ask it directly.
for level in PRIORITY_RANGE {
let ramp = priority_mark(Priority::Level(level)).1;
assert!(!TAG_COLORS.contains(&ramp), "{ramp:?} is a priority colour");
}
}
#[test]
fn the_tags_cell_paints_each_tag_and_leaves_the_separators_alone() {
let plain = metadata_value_cell("Tags", "bug, cli", false, "");
assert_eq!(plain, "bug, cli", "colour off must be the stored value");
let painted = metadata_value_cell("Tags", "bug, cli", true, "");
assert!(painted.contains(&paint("bug", tag_color("bug"), true)));
assert!(painted.contains(&paint("cli", tag_color("cli"), true)));
// The separator the file holds comes back as it went in, spacing and all.
assert_eq!(strip_escapes(&painted), "bug, cli");
assert_eq!(strip_escapes(&metadata_value_cell("Tags", "bug,cli", true, "")), "bug,cli");
assert_eq!(strip_escapes(&metadata_value_cell("Tags", " bug , cli ", true, "")), " bug , cli ");
}
/// An unset value stays grey, since the Tags branch sits behind the unknown check.
#[test]
fn an_unset_tags_cell_is_still_grey() {
assert_eq!(
metadata_value_cell("Tags", "_None_", true, ""),
paint("_None_", Color::Grey, true)
);
}
/// Pinned deliberately. Both SGR spellings of grey failed on a real palette,
/// 90 reading nearly as light as the foreground and 37 sitting on top of it.
/// This is the exact sequence crossterm emits for ratatui's Color::DarkGray,
+104
View File
@@ -457,3 +457,107 @@ fn add_treats_an_all_blank_description_as_none() {
"was {content:?}"
);
}
/// The help, the README and the skill all promise `YYYY-MM-DD`, and until this the
/// value was written to the ticket whatever it said.
#[test]
fn add_stores_a_valid_due_date_unchanged() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(temp.path())
.arg("add")
.args(["--title", "Dated"])
.args(["--due", "2026-08-29"])
.assert()
.success();
let content = read_only_ticket(&worklane.join("backlog"));
assert!(content.contains("- **Due**: 2026-08-29"), "{content}");
}
/// Every one of these is refused at parse time, so the exit code is 2 and nothing is
/// written. A date that cannot happen is as wrong as a word: `2026-02-30` has the shape
/// and is not a day.
#[test]
fn add_refuses_a_due_date_that_is_not_a_real_iso_date() {
for value in ["next friday", "29-08-2026", "2026-13-01", "2026-02-30", "2026/08/29", ""] {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
let out = cmd
.current_dir(temp.path())
.arg("add")
.args(["--title", "Dated"])
.args(["--due", value])
.assert()
.failure()
.get_output()
.clone();
assert_eq!(out.status.code(), Some(2), "{value:?} was not a usage error");
assert_eq!(
fs::read_dir(worklane.join("backlog")).unwrap().count(),
0,
"{value:?} wrote a ticket anyway"
);
}
}
/// An unpadded date parses as a date and would be stored as typed, which sorts before
/// `2026-10-01` and is not the format anything promises.
#[test]
fn add_refuses_an_unpadded_due_date_rather_than_padding_it() {
let temp = TempDir::new().unwrap();
setup_worklane(&temp);
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
let stderr = String::from_utf8_lossy(
&cmd.current_dir(temp.path())
.arg("add")
.args(["--title", "Dated"])
.args(["--due", "2026-8-9"])
.assert()
.failure()
.get_output()
.stderr,
)
.to_string();
assert!(stderr.contains("YYYY-MM-DD"), "the error never names the format: {stderr}");
}
/// An empty value keeps the message about clearing, since that is what somebody typing
/// it is reaching for.
#[test]
fn an_empty_due_date_says_clearing_is_not_supported() {
let temp = TempDir::new().unwrap();
setup_worklane(&temp);
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
let stderr = String::from_utf8_lossy(
&cmd.current_dir(temp.path())
.arg("add")
.args(["--title", "Dated"])
.args(["--due", ""])
.assert()
.failure()
.get_output()
.stderr,
)
.to_string();
assert!(stderr.contains("clearing a field is not supported"), "{stderr}");
}
fn read_only_ticket(dir: &Path) -> String {
let file = fs::read_dir(dir)
.unwrap()
.filter_map(|e| e.ok())
.find(|e| e.path().extension().is_some_and(|ext| ext == "md"))
.expect("no ticket written");
fs::read_to_string(file.path()).unwrap()
}
+16
View File
@@ -7,6 +7,7 @@ const BIN_NAME: &str = env!("CARGO_BIN_EXE_worklane");
/// files in the repo rather than to a description of them.
const SKILL: &str = include_str!("../assets/SKILL.md");
const REVIEW: &str = include_str!("../assets/REVIEW.md");
const PLAN: &str = include_str!("../assets/PLAN.md");
/// `HOME` is redirected, so the suite never writes into the home of whoever runs it.
/// A temp directory rather than the real one is also what makes the already-installed
@@ -25,6 +26,10 @@ fn installed_review(home: &TempDir) -> std::path::PathBuf {
home.path().join(".claude/skills/worklane-review/SKILL.md")
}
fn installed_plan(home: &TempDir) -> std::path::PathBuf {
home.path().join(".claude/skills/worklane-plan/SKILL.md")
}
/// Nothing about the skills needs a board, and they are wanted before there is one.
///
/// One invocation writes every document. A person who learned the command before the
@@ -42,8 +47,11 @@ fn every_skill_installs_outside_a_worklane_directory() {
assert!(stdout.contains(".claude/skills/worklane/SKILL.md"), "{stdout}");
assert!(stdout.contains("Installed the worklane-review skill"), "{stdout}");
assert!(stdout.contains(".claude/skills/worklane-review/SKILL.md"), "{stdout}");
assert!(stdout.contains("Installed the worklane-plan skill"), "{stdout}");
assert!(stdout.contains(".claude/skills/worklane-plan/SKILL.md"), "{stdout}");
assert_eq!(std::fs::read_to_string(installed(&home)).unwrap(), SKILL);
assert_eq!(std::fs::read_to_string(installed_review(&home)).unwrap(), REVIEW);
assert_eq!(std::fs::read_to_string(installed_plan(&home)).unwrap(), PLAN);
// Once, not per document: it is the one thing to do next, not part of an outcome.
assert_eq!(
@@ -64,6 +72,7 @@ fn a_named_skill_installs_only_that_one() {
assert_eq!(out.status.code(), Some(0), "{stdout}");
assert_eq!(std::fs::read_to_string(installed_review(&home)).unwrap(), REVIEW);
assert!(!installed(&home).exists(), "a named install wrote the other document too");
assert!(!installed_plan(&home).exists(), "a named install wrote the other document too");
}
/// A name nothing ships is a stop, with the choices in the message: guessing at the
@@ -80,6 +89,7 @@ fn an_unknown_skill_name_is_refused_and_lists_what_there_is() {
assert!(stderr.contains("worklane-review"), "{stderr}");
assert!(!installed(&home).exists());
assert!(!installed_review(&home).exists());
assert!(!installed_plan(&home).exists());
}
#[test]
@@ -138,6 +148,7 @@ fn a_modified_copy_does_not_stop_the_other_documents() {
assert!(stdout.contains("install-skill worklane --print"), "{stdout}");
assert_eq!(std::fs::read_to_string(installed(&home)).unwrap(), "hand written\n");
assert_eq!(std::fs::read_to_string(installed_review(&home)).unwrap(), REVIEW);
assert_eq!(std::fs::read_to_string(installed_plan(&home)).unwrap(), PLAN);
}
/// The print path is what makes a modified copy diffable, so it has to be the document
@@ -154,8 +165,13 @@ fn print_writes_the_named_document_to_stdout_and_installs_nothing() {
assert_eq!(out.status.code(), Some(0));
assert_eq!(String::from_utf8_lossy(&out.stdout), REVIEW);
let out = run(&home, &["install-skill", "worklane-plan", "--print"]);
assert_eq!(out.status.code(), Some(0));
assert_eq!(String::from_utf8_lossy(&out.stdout), PLAN);
assert!(!installed(&home).exists(), "--print installed the skill anyway");
assert!(!installed_review(&home).exists(), "--print installed the skill anyway");
assert!(!installed_plan(&home).exists(), "--print installed the skill anyway");
}
/// A diff is against one document. Printing them all run together would be neither of
+47
View File
@@ -415,3 +415,50 @@ fn neither_command_can_write_owner_or_status() {
assert!(content.contains("- **Owner**: alice"));
assert!(content.contains("- **Status**: backlog"));
}
/// The same parser `add` uses, from one definition. Grooming a board sets dates through
/// `set`, so validating only the command that files a ticket would leave the path that
/// is actually used wide open.
#[test]
fn set_refuses_a_due_date_that_is_not_a_real_iso_date() {
for value in ["next friday", "2026-02-30", "2026-8-9"] {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
let filename = create_ticket(&worklane);
let before = fs::read_to_string(worklane.join("backlog").join(&filename)).unwrap();
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
let out = cmd
.current_dir(temp.path())
.args(["set", UUID])
.args(["--due", value])
.assert()
.failure()
.get_output()
.clone();
assert_eq!(out.status.code(), Some(2), "{value:?} was not a usage error");
assert_eq!(
fs::read_to_string(worklane.join("backlog").join(&filename)).unwrap(),
before,
"{value:?} changed the ticket anyway"
);
}
}
#[test]
fn set_stores_a_valid_due_date_unchanged() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
let filename = create_ticket(&worklane);
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(temp.path())
.args(["set", UUID])
.args(["--due", "2026-12-31"])
.assert()
.success();
let content = fs::read_to_string(worklane.join("backlog").join(&filename)).unwrap();
assert!(content.contains("- **Due**: 2026-12-31"), "{content}");
}