00a64adca818e2e95e6f1331fe513cf51934fc4e
89
Commits
| Author | SHA1 | Message | Date | |
|---|---|---|---|---|
|
|
00a64adca8 |
(03bdc76) Draw a symmetric relation once, and refuse the mirror, and bump to 0.32.1
`relate` refused a relation the ticket already held but never looked at what the target held, so both ends of a `relates to` could store a line. `show` then drew the same neighbour twice under the same label, since `RelatesTo` maps to itself in `inverse_label`: one row from the stored line and one derived from the far ticket's mirror of it, indistinguishable. Live on this board, where 8556048 and 8c8a520 each stored the other. Both ends of the fix, because they do different jobs. `relation_rows` drops a derived row that reads exactly like a stored one, which repairs the boards that already hold both directions without an edit. `cmd_relate` refuses to store the mirror in the first place, reporting no change since the edge is already recorded at the far end, which stops it recurring. Neither alone closes it. The dedupe keys on the **label** and the target, not the kind and the target. Two tickets each blocking the other is two facts and the block has to say both, `blocked by` from this end and `blocks` from the other; keying on the kind would fold them into one row and lose half of what the ticket says. Only a symmetric kind can collide with its own stored line, and `RelationKind::is_symmetric` derives that from `label() == inverse_label()` rather than naming `RelatesTo`, so a kind added later answers by construction. The same gate is what keeps the refusal off a cycle: a target holding `blocked by <this>` is not a duplicate. The stored row is the survivor, not the derived one, because it is the line `relate --clear` can address. The consequence is worth knowing and is written down: with both ends holding a line, clearing one leaves the other's, which then draws as the derived row. Correct, since the far end still asserts the relation. 4179958 decided that `relates to` is symmetric and "written once, not onto both files". Nothing enforced it until now. The board's own data is left alone. 8556048 and 8c8a520 still both store the line and the block now draws it once, which is what the criterion asked for. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> |
||
|
|
0f0767ac00 |
(8556048) Take a relation off with relate --clear, and bump to 0.32.0
`relate` only added. A `--blocked-by` pointed at the wrong ticket was on that ticket forever, refusing every move it made until the target was done or `-f` was passed again, and a target that was deleted did not clean up either: the board carried a dead edge that nothing could clear and every later read of the ticket paid for. `--clear <kind> <target>` takes one off. It is on `relate` rather than on `set` for the reason `RELATIONS` is out of `section_args`: a relation names a target that has to be resolved first, so one writer owns both directions, the way `chown` owns setting an owner and clearing one. It names the target and not just the kind, because a ticket can hold several relations of one kind and emptying all of them is not what anybody is asking for. That is also why it is not spelled the way `set --clear` is, which names a field and empties it whole. Both spellings of the kind are taken, `blocked-by` from the flag and `blocked by` from the label: both are in front of the reader, the flag being what recorded the relation and the label what `show` prints and the file stores, so refusing the printed form would trap anyone clearing a row they had just read. `RelationKind::flag` is a match rather than a `replace` on the label, so the flag, the `--clear` value and the completion list cannot drift. `find_relation` searches the ticket's own edges by id prefix before it searches the board, and that order is the feature rather than an optimisation: no search of the board reaches a target whose ticket is gone, so the stored-target tier is the only thing that can clear a dangling edge, which is the case most likely to need clearing. Two stored targets under one prefix name the candidates instead of guessing, as an ambiguous ticket search already does. An edge the ticket does not hold reports no change, and a target naming nothing at all is an error. The two are different facts: the first is the state the caller asked for, and the second is a typo that a no-op would swallow. The resolver's own reason is carried through, so an ambiguous search says it is ambiguous rather than being reported as nothing found. Recording and clearing the same relation in one call is refused, and the check runs on what was *asked* for and not on what would be written. A relation already in the file is not among the additions, so comparing against those would have let `--blocked-by X --clear blocked-by X` quietly remove it. Removals rewrite the section from what is left and additions are appended to that, in that order and in two passes: a call with no `--clear` then takes exactly the path it always took. The last edge leaves the placeholder, which is the line `append` treats as no content, so the next `relate` replaces it rather than writing underneath it. The two values are one flag, so clap cannot type them apart. `num_args = 2` is per occurrence, which makes an odd number a usage error and every chunk a full pair, and `cleared` parses the kind before the ticket is resolved. Nothing is logged, in either direction, since `relate` never has: a log recording only the destructive half would read as though the additions had never happened. `chowns_clear_is_completed_with_tickets_and_sets_is_not` found the first rule carrying `-l clear` and there are now three, on three commands, each taking something different. It is `each_clear_flag_is_completed_for_its_own_command`, scoped per command, and `relate --clear` offers the kinds rather than a board listing, since tickets where the kind goes would be candidates it refuses. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> |
||
|
|
7994d98913 |
(76d10d7) Strike through a relation to a discarded ticket, and bump to 0.31.5
The relations block marked a target `○ ◐ ●` or `?`, and none of those can say the target was discarded: the status mark is one cell in a column of five states, and `●` in grey against `●` in green is a colour a pipe does not get. A row pointing at abandoned work therefore read as a live dependency, which is exactly what it is not. The row is struck through instead, the whole of it, gutter and padding included, so the line runs unbroken from the label to the end of the title. The relation stays recorded, for completeness and for the case the target is moved back out of discarded, and reads at a glance as no longer standing for anything. The mark column is untouched: 451fb83 already gave a discarded target the full circle of done in the grey of the untouched pile, and the strike is additive on top of that. `Cell` learns a modifier, the first style on it that is not a colour. Same trick as the palette, one step further: `Modifier::ansi()` is SGR 9 and `From<Modifier> for ratatui::style::Modifier` is `CROSSED_OUT`, so a style that exists for one renderer and not the other is a compile error. Bold stays out of it, because bold rides inside `Color::Magenta.ansi()` and `span_from` adds it back from the colour alone; a second modifier goes beside this one. `paint_cell` opens the modifier ahead of the colour and closes both with one reset, which is why the reset is now a constant the two writers share rather than a literal in `paint`. `span_from` takes the modifier too and has no early return for the uncoloured case any more: a struck plain run is a styled span with no foreground. `Cell::struck` is a builder, because the strike is decided a whole row at a time by the layout that already chose the colours. `Body::push_cell` merges on the whole style rather than the colour alone. Nothing outside the relations block carries a modifier today, and a merge keyed on the colour would silently strike a plain run through the moment one did. The strike is under the same flag every other escape is, so a piped `show` carries none of it. That is the bargain committed and reviewing already take for being told apart by colour alone, and `assets/SKILL.md` says so outright rather than leaving an agent to infer that a plain-looking row may point at abandoned work. Tests are paired both ways, and both halves are load bearing: a renderer that struck nothing fails the presence, and one that struck every row fails the absence. `the_status_marks_are_pinned` had never listed discarded, so it does. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> |
||
|
|
d1a0f0ee27 |
(2a83bd4) Frame the tag-filtered board with the tag's annotation, and bump to 0.31.4
A board filtered to a tag now says which tag, the way a board filtered to a campaign says which campaign. The frame slot above the columns is shared, not doubled: one filter is on at a time, per `Filter`, so the row and the geometry `Chrome` computes stay as they are and only what is drawn into them changes. `FrameContent` is what the two are told apart into, and `frame_content` is the one place they are told apart at all. Everything below it is the campaign frame's: the borders, the colour, `q board`, the page indicator, the scroll, the focus and `enter`. A second match on the filter under there is how the two frames would come to behave differently in a way nobody decided. The tag goes on the top border as `#tag`, in the colour a card draws it in, because `~v1` against `#bug` is what says at a glance which filter emptied the columns. How many tickets carry it goes on the bottom right where the standing goes, counted off every column, drawn or not. The annotation fills the prose rows, wrapped and scrolled the way ebad2fa made the description. An undeclared tag draws `NO_ANNOTATION` in grey rather than a blank row, which is also the frame saying the word was never agreed on. The vocabulary file's own placeholder and not the description section's, so the frame and `tags.md` say the same thing about the same tag. Nothing in the geometry is named after campaigns any more. `Chrome::campaign` is `Chrome::frame`, `CAMPAIGN_ROW` is `FRAME_ROW`, and `Chrome::campaign_rows` is `Chrome::frame_rows` — which collided with the free `frame_rows` that lays out the whole screen, so that one is `screen_rows`. `y` on a tag frame copies the tag, since a tag is its own id and the hash the border draws is not part of what `--tag` matches. The footer's tag span and its `q board` slot are gone: 0fd1ddc put them there for want of a frame to say it. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> |
||
|
|
45b513bdce |
(2733b10) Colour the history block, and indent a comment's body deeper, and bump to 0.31.3
The block shipped with three painted things: the heading, the kind label and the actor with its timestamp as one cyan span. Every value in it was plain, so a status entry drew two status names in no colour while the same names are orange in the metadata table three lines above, and a tags entry drew its tags without the slots every other view gives them. The kind label is now grey, as chrome that names a row. It was orange, which means Status everywhere else, so an `owner` or `tags` label claimed a meaning belonging to the value beside it. `From` on a comment's author line goes grey for the same reason. Each value takes the meaning its field carries in the metadata table: status orange, tags through the same `tag_cells` the Tags field uses, a campaign codename through `tag_color` bare the way `Codename` is, an owner plain, and `_Not set_`, `_None_` and `_missing_` grey. The separator is a constant beside `change`, with `split_change` next to it, so the writer and the reader cannot disagree about what divides the two halves. The actor is drawn through `tag_color`, so one writer is one colour in every entry it wrote, and cyan goes back to meaning the timestamp alone. A comment's body moves to four spaces and the author line stays at column 0, so an indented line is somebody's own words and a line of values at column 0 is the tool reporting itself. The padding is still measured on the unpainted label, now pinned with the alignment test running both ways. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> |
||
|
|
60b43a682e | (a136d13) Draw the discarded column behind a three-state visibility rotation, and bump to 0.31.1 | ||
|
|
5bf0fd1bfe |
(451fb83) Add a discarded status for work that will not be done, and bump to 0.31.0
The flow ended at done, so a ticket that turned out to be a duplicate or obsolete had nowhere to go: it sat in the backlog or was deleted by hand, which destroyed the record and left every relation to it dangling. Discarded is a fifth status with its own directory, keeping the invariant that the filename, the Status field and the directory agree, and keeping done meaning the work landed. Entering it is allowed from any status without -f, because discarding is not a stage of work. Discarded sits last in Status::ALL, which is what makes the rest fall out rather than needing cases: nothing follows it, so a discard clears no stamp and a ticket abandoned from reviewing keeps the journey it made, and every move out is a backward move, so un-discarding needs -f. The two dependency guards now look opposite ways. check_blockers asks what a ticket waits on and gates work moves; check_dependents asks who waits on it and gates the discard, because those plans depended on work about to be declared never-happening. Both skip targets that are themselves terminal. Status::FLOW is the four stages the board draws, so a discarded column on screen stays a136d13's ticket and done stays the last drawn column. Every tree walker keeps using Status::ALL, or a discarded ticket would be unaddressable. util::is_open replaces three spellings of "not done and not discarded", across mv, ls and the campaign standing. The board's blocked mark goes through it as well: that path was only accidentally correct, since a discarded blocker is absent from the FLOW columns, and drawing the column later would have diverged it from what mv allows. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> |
||
|
|
c03f47c52d |
(f774a33) Record a campaign move in the history log, and bump to 0.30.0
assign was the only field writer without an entry: a ticket could leave one campaign for another with nothing recording it. Kind gains Campaign, assign gains the --actor flag the other four writers carry, and the entry is written after the save and behind the no-change return, the rule every writer follows. The entry records Campaign::name, the codename or failing that the title, settled when the entry is written so a rename cannot change what an old entry means. The uuid the field holds says nothing in a log line, and a before-uuid the board no longer has reads _missing_, the way the Campaign field itself renders a dangling one. campaign is the longest mechanical label, so LABEL_WIDTH widens from 6 to 8 and every mechanical row moves two columns right, a deliberate output change that makes this a minor alongside the new flag. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> |
||
|
|
9d17f55860 |
(f3e099e) Colour the history block in the detail overlay, and bump to 0.29.1
The board appended the block as a pre-rendered string with colour off, the last flat piece of a body e4d0bb7 had fully styled. history_cells lays the block out once: format_history is those cells painted for the CLI, and detail_of pushes the same ones as a Cells part, so the overlay styles them and no escape can enter. The CLI's output is pinned byte for byte, and the overlay test pairs the presence of the colours with the absence of escapes. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> |
||
|
|
f454d212a4 |
(d4ce964) Record status, owner and tag changes in a history log, and bump to 0.29.0
The comments directory was already an append-only log with one event kind. It is now .worklane/history/<uuid>/, with the kind in the entry and in the filename after the stamp, so a ticket says how it got where it is and not only what was said about it. mv, chown and set --tags each write an entry after their own save and behind their own no-change return, so a refused or no-op edit records nothing. --actor is on all four writers now. An old comments directory is adopted on first access and a file with no marker reads as the comment it is, so nothing is migrated or rewritten. The log moves to src/history.rs, out of util.rs and handlers.rs, and the card's counter counts comments only: a ticket that has moved three times has not been talked about. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> |
||
|
|
a1bdb5df49 |
(87862df) Attribute an entry to WORKLANE_ACTOR, not to the git user, and bump to 0.28.0
Every comment the CLI wrote was attributed to the git user, so a board several agents write to read as a list of things one human had done. resolve_actor is now the single source: flag, then WORKLANE_ACTOR, then get_git_user(), then unknown. comment --owner is renamed to --actor with no alias, since it names the writer of the entry and not the ticket's assignee, which is chown's. add --owner and campaign add --owner still default to the git user. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> |
||
|
|
c2ee165108 |
(e4d0bb7) Colour the whole detail overlay body, not just its relations, and bump to 0.27.3
The block was the only coloured part because it arrived as rows while everything else arrived as a painted string, and the board had to ask for the unpainted one: an escape in a ratatui paragraph is drawn as literal bytes. content_parts now paints nothing. BodyPart::Text becomes BodyPart::Cells, so content_trim is the cells through paint_cells and the board is the same cells through span_from. push_heading, ordered_cells, inline_cells, metadata_cells, metadata_value_cells and tag_cells replace the painters they were. Resolved.campaign is cells too, which made reference_cell dead at its last caller. The colored flag still reaches content_parts and no longer means paint. It says whether this renderer can carry a colour at all, and one thing turns on it: **bold** gives its markers up to the colour that replaces them, so a renderer with none has to keep them. Color::Magenta.ansi() is \x1b[1;35m, so span_from adds the bold modifier on the board's side, since From<Color> carries only the colour and the same cell must not be painted two ways. show's output is pinned byte for byte against what it printed before, both by a fixture holding one of every painted run and by diffing the old binary against the new one over every ticket and campaign on this board, coloured and piped. |
||
|
|
407cb14fe6 |
(e6e3a1b) Guard the README command table against a missing row
The campaign and assign rows landed with
|
||
|
|
108e21ad7f |
(25d3018) Fix the markdown link colorization branch, and bump to 0.27.2
The branch searched for a closing square bracket after the ]( sequence instead of a closing parenthesis, so it fired only on text that was not a link, and when it fired it pushed the matched span and dropped the rest of the line. Folded into colorize_bold, now colorize_inline: one walk over the source line recognising both **bold** and [text](url). A second pass over the first one's output would be scanning text that already holds escape sequences, and \x1b[36m carries an opening bracket, so the link scan would take the escape for markup. Unterminated markup of either kind falls through to the ordinary character push, so the rest of the line survives as literal text. Criteria text and hand-written metadata rows get links too, since they already went through this function. The whole span is painted, markers and url kept: show prints to a terminal worklane cannot assume will make a link clickable. |
||
|
|
26b93f8f53 | Add Makefile | ||
|
|
3592584747 |
Edit a campaign's description, and bump to 0.27.0
`campaign set` reached the title and the codename, so the description a campaign was filed with was the description it kept: fixing a typo in the one field nothing could edit meant a hand edit of the file, or refiling the campaign and reassigning every member. Both halves arrive together, which is why d637288 left this out rather than adding the flag. `campaign set --description` replaces the section and `campaign append --description` adds a paragraph to it, because a `set` with no `append` is the half that is easy to reach for and wrong: replacing a description to add a sentence is how the rest of it gets lost. `append` is a campaign's own subcommand rather than the top-level one, which resolves a ticket. `resolve_in`'s tiers are the same over both directories, so one positional naming either object could resolve in each with nothing but a flag to say which was meant, and it would make a liar of the explanation `resolve_ticket` gives a ticket search that names a campaign. The section is the `DESCRIPTION` entry and the surgery is `set_section_body`, `append_section_body` and `Section::normalise`, not a copy scoped to campaigns. `SECTION_ORDER` needs no campaign variant: a campaign holds one section where a ticket holds four, and the followers a campaign does not have are simply not in the file, so its description anchors against `## Metadata`, where `campaign_body` writes it. Still no `--clear`, and that is now a decision rather than a deferral: a campaign's description has no cleared form, so an empty `--description ""` is a paragraph break here as it is everywhere else, and the refusal for an all-blank value says there is nowhere to go back to instead of naming a flag that does not exist. `replaced_items` and `appended_items` hold that check once for both objects, with the way out as the caller's argument. The section refusal no longer says "Ticket", since a campaign reaches it too. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> |
||
|
|
07c783410c |
(b74dc5a) Remove a test's fixture directory with a guard, not a trailing line
Every unit test here built its board under the system temp directory, and the ones that remembered a `remove_dir_all` at the end only cleaned up when their assertions passed. Most had no such line at all. /tmp reached 18363 of these and filled the disk, which failed a link step and then a `git add` with "No space left on device": an error naming neither the tests nor what they had left behind. `util::Fixture` is a uuid-named directory whose `Drop` removes it, which is the only shape that also runs when an assertion fails, since unwinding runs destructors. It derefs to `Path` and implements `AsRef<Path>`, because the two reach different call sites: a parameter typed `&Path` is a coercion site and one bound by `impl AsRef<Path>` is not. So nothing changed at the ~160 call sites but the type, and the 85 trailing cleanup lines are gone. Five leaking prefixes, not the two the ticket names. `worklane-project-*` from `project_tree` and `worklane-bare-*` never cleaned up at all, and the four `worklane-count/blocked/stray/stamps-*` sites in `util.rs` cleaned up only on the passing path. `Fixture::child` is what covers `project_tree`, which needs the fixture to point at the project and remove the directory above it. `assert_fs::TempDir` is a dev-dependency already and was still not the answer: it names its directories `.tmpXXXXXX`, which says nothing about whose they are for the one case that matters, the one left on disk on purpose. Wrapping it to add a prefix and a printed path is more code than the guard. `WORKLANE_KEEP_FIXTURES=1` keeps them and prints each path, opt-in rather than kept-automatically-on-failure: the assertions here carry the state they are about, so a path printed on every failure would be noise on almost all of them. Read once when a fixture is made rather than at drop time, so the answer cannot change mid-test, and `Fixture::swept()` turns it off for the three tests that are about the guard itself and must not be failed by a reader's environment. Verified against a clean temp dir rather than against /tmp, which still holds the historical leak: `TMPDIR=/tmp/scratch cargo test` leaves zero directories behind, with the variable set and unset, 383 green either way. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> |
||
|
|
dd2b457bff |
(9b7fa7d) Expand the campaign frame with enter
Three rows of prose was the right default and the wrong ceiling. enter while the frame holds the selection gives it half the board, enter again gives the rows back, and pgup and pgdn go on doing what they do against whichever height it is at. Half of what the frame and the columns divide, which is the screen less the tab row and the footer. Half rather than most of it for the same reason the frame is not an overlay: the columns below are the campaign's members, and a reader inspecting the campaign has to go on seeing what it is made of. So `Chrome::campaign` is an `Option<FrameSize>` rather than a bool and `campaign_rows` takes a height, resolved in `frame_rows` because that is the one place that already has an area to take a share of, which keeps `Chrome` itself pure. Bounded at both ends, and the upper bound is the one that matters: `Constraint::Min(COLUMN_MIN_ROWS)` would take rows back from a frame that asked for too many, silently, and the frame's own measurement would then disagree with what is drawn. Floored at the collapsed height, since expanding must never shrink the frame, so a board too short to divide gives the collapsed height back rather than one nothing measured. Swept over every height from 4 to 60, tabbed and not. q does not gain a layer and the arrow keys do not take the height back. The expanded frame is the frame at its other height, not a thing laid over the board, so q goes on taking the campaign filter off from either and enter is the only key that undoes what enter did. The height outlives the selection for the same reason: it is a view of the campaign the reader chose, so the columns stay short with the selection on a card. `dismiss` and `select_card` are untouched, and two tests pin that. `enter` routes through `Board::toggle_focused` rather than in the `main.rs` arm, the rule `dismiss` and `scroll_page` follow. It was inert on the frame for free before, because `Tab::selected` hands back nothing there and `toggle_detail` had nothing to open; that answer is now the thing in the way, and AGENTS.md and `Tab::selected`'s doc are amended rather than left describing the key by what it used to do. The toggle re-clamps the frame offset through `scroll_frame(0, screen)`. A taller viewport has a smaller last offset, so where the reader was can end up past the end of the frame they just asked for, and the next pgup would count down from a number the frame never showed. Criterion 13 is not done: 2a83bd4 has not landed, so there is no tag frame to give a second height to. What it inherits is on the ticket, and all of it is generic rather than campaign-specific. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> |
||
|
|
af1ef1f97f |
(ebad2fa) Scroll the campaign description in the frame above the board
The frame showed the opening line of a description and the rest was only readable through `campaign show`, which means leaving the board. It now holds three rows of prose and pages through the remainder on `pgup` and `pgdn`, reached by going up past the top card of a column. Four decisions rather than four edits: `section_prose` replaces `section_opening`. The campaign file is only in hand while the campaigns directory is being read, so that read carries the whole description and `CampaignRow::summary` takes the picker's one line back off it. Two fields, one cut from the other, would be two strings free to come from different reads of the same file. `CAMPAIGN_PROSE_ROWS` is a constant. Fitting the frame to the description would resize every column whenever the filter changed, so the height is fixed at three rows and scrolling covers the rest. Two more rows of cards spent than the one row cost. `Focus` is the third place the selection can be, held on `Tab` beside the filter and the new `frame_offset`. Every key that acts on a card answers for it: `enter` is inert because `Tab::selected` hands back nothing there, `left` and `right` are inert because the frame spans the board, and `y` copies the campaign's short id, so `y copy id` means the id of the selected thing in every state. No card is drawn reversed while the frame holds the selection, since that highlight is what says which ticket a key is about. The frame is out of reach from under an open ticket, where up and down step through tickets and the overlay follows. `Board::scroll_page` holds the precedence, not the `main.rs` arm: an open ticket keeps both keys whatever holds the selection behind it, the rule `dismiss` follows for the same reason. The page indicator, the step and the clamp are the overlay's `page_indicator`, `scroll_step` and `last_offset`, so the two places a reader presses these keys behave the same. The indicator sits beside `q board` rather than up beside the title, which would shorten a long campaign name whenever its description grew. Criterion 11 is not done: 2a83bd4 has not landed, so there is no tag frame to give the same treatment. The model it inherits is in place and named on the ticket. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> |
||
|
|
8e2ab6332c |
(8c8a520) Ship a board administration skill, and bump to 0.26.1
Three skills taught the CLI, the review and the grooming sweep. Nothing taught the board itself, and two jobs fell in the gap: deciding what the tags are, now that `tags add` and `tags set` exist to declare them, and putting a board back together when its files and fields disagree. `worklane-admin` is the fourth. It is the one asset written to hold for a board that tracks no software, since a vocabulary skill built around `bug` and `cli` teaches nothing to a board tracking a household, so its worked examples span a tool, a product strategy and a house. Tags as axes rather than as a pile of words, what an annotation has to say to stop drift, which is the boundary against the neighbouring tag and not the definition, and the fact that renaming a tag means rewriting the Tags field of every ticket carrying it. The repairs are by symptom and every one was run against a scratch board rather than reasoned from the source, which is what the ticket demanded and what turned up the one that matters: a ticket whose file sits in `done` while its Status field says `backlog` cannot be repaired by one `mv`, because `mv` reads the current status from the directory and refuses the target it is already in. Two moves fix it. That is 7f772a7. Verifying also turned up that nothing removes a relation, 8556048. The line against `worklane-plan` is drawn in both documents: this one decides the vocabulary, that one applies it across tickets. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> |
||
|
|
b1dbf3ed75 |
(4e4d88d) Split and search the campaign picker, and bump to 0.24.2
One flat list ordered by title put the completed campaigns among the open ones forever. The tail only grows, so on a board that has run for a while the campaigns worth picking were pushed towards the bottom of the box and eventually off it, and nothing in the picker helped find one. The rows are now two sections, open above completed, with completed by Created At newest first and truncated to a couple behind a grey line naming how many older ones are hidden. `/` starts a query, the key that already searches the board's cards, filtering case insensitively on short id, codename and title, and a query turns the truncation off: the campaign a reader is searching for is exactly the one it hid. `picker_list` is the one place that decides what a row is, so `Picker::row` counts drawn rows and `stepped_picker_row` walks past the headings and the truncation line rather than stopping on one. The highlight is placed by uuid, the answer `Tab::campaign` already gives for the filter, so typing, clearing the query and a tick that finishes a campaign all move it with its campaign instead of leaving it at a number that now names another. Every campaign's standing is settled at reload, counted by `standings_of` in one pass over the cards the reload already holds rather than the walk per campaign `campaign ls` pays. `Tab::standing` goes with it: the frame reads the row's, since two counts of one number are two numbers free to drift. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> |
||
|
|
154ffbdeb3 |
(001b639) Show the comment count on a board card, and bump to 0.24.1
A card had four corners and none of them said whether anybody had written anything on the ticket. Finding out meant opening the detail view or running `show`, which is the question the board exists to answer before you commit to a card rather than after. The count goes in the bottom right, left of the criteria count. Both are about the ticket rather than about the reader, and the criteria count is what that corner has always been: this is what has been added beside it, so it is what sits further from the edge and what goes first when the column is narrow. How far along a ticket is outranks whether somebody has said something about it. `corner_line` takes the whole right-hand group now instead of one span, and the group gives up its items from the front until what is left fits. With one item that is exactly the old behaviour, which is what the top row still wants, so `due_span` returns a `Span` rather than the `Option<Span>` it only ever had to satisfy the signature. The single space between items lives in `corner_line` beside the gap arithmetic, not in the caller: the same reason `column_areas` is shared between the draw and `follow_selection`, that geometry reproduced by hand drifts from the draw. `comments` is a field on `TicketItem`, filled where `criteria` and `tags` already are, and it is the one entry on that pass that costs a directory listing rather than coming off content in hand. So it is counted, never read: `.md` only, the filter `read_comments` applies, and no body is opened, because a count needs none of them. The alternative was a `read_dir` per ticket per frame. `collect_ticket_items` derives the board from `status_path.parent()` rather than taking it as a second argument. Every caller joins a status onto a board it already holds, and two arguments would let a status directory from one board arrive with the comments of another. `comments_dir` now spells that path once for the writer, the reader and the counter, the way `campaigns_dir` does for its directory. Zero draws nothing, not a `0` and not a blank cell held open. An uncommented card is the row it has always been, down to the spacing, which is pinned exactly rather than by a `contains`. The mark is U+275E, a Dingbat, and the choice is about arithmetic as much as reading. U+1F4AC SPEECH BALLOON is emoji presentation and East Asian Width Wide, so it draws two cells where `spans_width` counts one character and every corner on the card lands a cell out. U+1F5E8 LEFT SPEECH BUBBLE is text presentation and Neutral but sits in a pictograph block most terminal fonts leave as tofu. This one has the coverage the priority meter's Geometric Shapes have. Cyan, and the only coloured thing on a row whose owner and criteria count are grey: two counts side by side otherwise read as one number in brackets and another that lost its brackets. The no-per-draw test takes the comments directory away after the board is built, and is paired with one that adds a comment and reloads, because a count that never asked the filesystem again would pass the first by never changing at all. The digest already moved on a new comment, so the reload is what recounts. Patch rather than minor: the corner was already two numbers and a mark, and this settles what it says rather than adding a view. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> |
||
|
|
50e67483d8 |
(b2c5531) Delete the stale copy of the worklane skill, and bump to 0.24.0
`.opencode/skill/worklane-kanban-skill/SKILL.md` was 223 lines of the same
document `assets/SKILL.md` holds, shipped by nothing and checked by no test.
It drifted the way a copy nobody reads does: its frontmatter still called the
skill `worklane_kanban`, its examples still used short flags, and it knew
nothing about `relate`, `campaign`, `chown`, `check` or the four-status flow.
It was not inert while it existed, and that was worth confirming rather than
assuming. `opencode debug skill` listed it by path, so an agent working in
this repo saw two worklane skills and could load either: the current one out
of `~/.claude/skills` or this one. After the delete the same command lists
`worklane`, `worklane-review` and `worklane-plan` and nothing else of ours.
The two agent files named it in their skill permission blocks,
`"worklane_kanban": "allow"`, an id only the deleted file defined, so the
permission granted access to nothing. Repointed at `worklane`, which is the
surviving document and what the grant meant. The files themselves stay: they
are the user's, and `reviewing-agent.md` is the prior art `assets/REVIEW.md`
grew out of. Neither was given `worklane-review` or `worklane-plan`, which
would be redesigning somebody else's agent rather than fixing a dead id.
`.opencode/skill/testing-skill` is untouched for the same reason. It is not a
copy of anything this repo ships.
8cc254c fixed the add example in the file this deletes, and it is moot rather
than reopened, recorded in a comment there. The fix was real: the example did
pass `-t` where `-g` was meant, gave `-p` three bare positionals, and clap
did reject it with exit 2. Nothing carries over, because `assets/SKILL.md`
never had either defect. Its examples are long flags throughout, one value
per flag, and it carries no "(or --due)" filler. Checked against the file.
AGENTS.md now says the surviving document is the only one and names this copy
as what happened last time, since the rule on its own does not say why it is
there.
The bump is the body of work's, not this commit's: `install-tool` in
|
||
|
|
11145b228e |
(c092ea7) Ship the opencode tool definitions with the binary, behind install-tool
`.opencode/tools/worklane.ts` was the second agent asset and the only one that existed nowhere but a checkout. `cargo install` places binaries and nothing else, so anyone who installed worklane got the skills and never the tools, and the copy that did exist was reachable only from this repo. It is now `assets/TOOL.ts`, embedded with `include_str!` like every other asset, and `install-tool` writes it where opencode looks. Its own command rather than a flag on `install-skill`, because the two artifacts are not alike. A skill is inert markdown and one path serves both agents. The tool is executable TypeScript and serves one: Claude Code has no directory it scans for a tool definition, `claude mcp add` is the only way a tool enters its list, and its plugin system adopts agents, hooks, monitors, workflows, output-styles and themes and nothing named tools. Reaching it would mean an MCP server, which is a different artifact and not this file. So somebody on Claude Code takes the documents and never the wrapper, which is the choice this command exists to give them. The path was measured rather than guessed, as the ticket asked. 1.15.10 loads `~/.config/opencode/tool/` and `~/.config/opencode/tools/` both: each was served in turn from a directory outside any project and `/experimental/tool/ids` came back with all eleven worklane tools. Singular is the target, the spelling opencode's own documentation puts first the way it writes `agent(s)` and `skill(s)`. `tools_root()` follows `XDG_CONFIG_HOME` where `skills_root()` does not, because opencode's config root is an XDG path and `~/.claude` is not; `opencode debug paths` reports `$XDG_CONFIG_HOME/opencode` with it set. An empty value counts as unset, the convention `colors_wanted` already follows. `opencode_tool_dir` takes both variables as arguments for the reason `colors_wanted` does: a threaded test binary cannot mutate the process environment to reach one branch at a time. The file name is load bearing and now pinned by a test. opencode builds each tool id as the file name then the export, so `worklane.ts` plus eleven `export const` lines is what makes them `worklane_add` through `worklane_uncheck`. Renaming the file renames every tool and every permission rule naming one. The closing line is not the skills' "on their next session". opencode reads its config once at startup and never reloads it, so a running one keeps the tools it began with and the honest instruction is to restart it. Nothing else has to be installed, which is worth saying because the file is executable and reads as though it wants a toolchain. Criterion 6 asked the command to name the plugin package and Bun as runtime requirements and both are wrong: a copy in a project with no `node_modules` above it registered all eleven tools on a machine with no `bun` on `PATH`. opencode is a Bun binary and the import resolves inside it. The message says the opposite, and the reasoning is on the ticket. `install_each` is the outcome loop both commands now share, with the compare-and-refuse invocation passed in: that line is the only part of an outcome that has to name the command it came from. What each command says after the loop stays with the command. `every_tool_the_wrapper_exports_is_a_real_subcommand` guards the direction that breaks at call time, a tool wrapping a command that has been renamed or dropped. Deliberately not the reverse: the wrapper has no tool for `relate`, `campaign`, `assign` or `tags`, so an agent holding the tools cannot reach campaigns or relations at all, and a test asserting that gap would fail on a decision nobody has taken rather than on a mistake. Its own ticket. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> |
||
|
|
2ddd0addf6 |
(59b23b7) Stop the board walk on a link that does not resolve, and bump to 0.23.1
`find_worklane_dir` asked `exists()`, which follows a symlink. A `.worklane` that was a dangling link therefore answered exactly as no `.worklane` at all: the walk carried on up the tree, the first board above the project became the board, and every write landed in it. Silently, and in the board belonging to someone else's project. Latent while a board is a real directory inside the project it belongs to. Once boards live in one shared directory and `.worklane` is a link into it, a dangling link stops being a corrupted tree and becomes an ordinary state: it is what you have before the boards repo is cloned, and after a board directory is renamed. So this is reachable on an ordinary day rather than only with a hand-made link. `classify` reads `symlink_metadata` first, so the answer is about the entry rather than about its target, and it is one of four: `Absent`, `Board`, `Dangling` or `NotADirectory`. `Absent` is the only one the walk carries on from. A `.worklane` that is there but unusable is this project's board and is reported here, not handed to whatever sits above it. Anything other than `NotFound` out of `symlink_metadata` is an error too, since reading a filesystem that could not answer as nothing-there is how the walk-past worked in the first place. The failure names the target and says the boards repo may not be cloned. The old message, no board found and run `worklane init`, was wrong twice over even with no board above: it describes an empty tree, and it points at creating a board when the cause is an unsynced machine, which is the one action that produces two boards with one name. A regular file at that path is an error as well. It is a plausible future pointer form and reading it as one is that change's decision to make; stepping over it and writing above is the answer that is wrong today. A link that resolves is still indistinguishable from a real directory, and what comes back is the link rather than its target, so `.worklane/backlog/*.md` reads the same either way and nothing downstream learns whether the board is local. Every writing command resolves the board before it writes, so the refusal costs nothing halfway. `add` is where that is pinned end to end, against an empty board above the project that stays empty. `init` is untouched: it does not go through this walk, it writes nothing on a dangling link today, and its symlink cases belong to the layout change. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> |
||
|
|
cbc20848f6 |
(1845355) Order each status column by its entry stamp, and bump to 0.23.0
Every view read its rows out of `collect_ticket_items`, which sorts by `by_priority_then_title` because it sees one directory and no status. That is the right order for the backlog, where priority is the clock. Past the backlog the question changes: committed asks what has waited longest, reviewing what was handed over first, done what just landed. All four columns answering the first question is why a finished p5 sat above the p1 nobody had read yet. So each column takes its own order, through one `by_status_order` keyed on the `Status` rather than four comparators at four call sites. Backlog delegates to the comparator it already used. Committed sorts by `Committed On` ascending and reviewing by `Submitted On` ascending, so the longest wait is at the head where the reader picks next from; done sorts by `Completed On` descending, newest first, the way a changelog reads. Ascending twice and once descending is one rule said three ways: the head of every column is what the reader acts on next. A ticket carrying no stamp sinks below every stamped one in its column and falls back to priority then title among its own kind, as do equal stamps -- `mv` writes whole seconds, so a tie is real. A missing time is unknown, not ancient, and unknown must not claim the head of a queue ahead of a wait somebody can point at. Reading absence as the epoch would have come free from the comparison and put every ticket filed before f460853 first. The comparison is a string comparison. `%Y-%m-%d %H:%M:%S` is lexicographic in chronological order, the property `Due` already relies on, so nothing parses a date at sort time. The stamps are read on the pass `collect_ticket_items` already makes over each file, the rule `criteria` and `tags` already hold, and never per comparison. Both `cmd_ls` branches, `list_ids`, `columns_of` and `campaign::members` take it, which is why those loops walk `Status::ALL` rather than `status_dirs()`: the directory name does not say which stamp governs it. The merge tab keeps priority then title outright and is pinned there -- it spans statuses, so no single stamp governs it. `cmd_tags` is left alone; it counts into a `BTreeMap` and never reads an order. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> |
||
|
|
eae411ab50 |
(f460853) Let the flow timestamps accumulate, and bump to 0.22.0
a6023e2 made the three stamps mutually exclusive: entering a status wrote its field and leaving removed it, so a finished ticket carried exactly one of the three and the journey behind it was invisible. A reader asking when this was filed, when it was picked up, when it went out for review and when it finished got one answer and three absences, and nothing could tell that committed had ever happened. So the removal rule is replaced by an accumulation rule. `mv` stamps the target's field on entry, re-entering restamps, and arriving anywhere removes the fields of every status *after* the target. That is one arrival rule off the flow order `Status::ALL` already holds, not a case per move, and it is also what a forward skip under `-f` wants: backlog straight to done stamps `Completed On` alone and leaves the stages it jumped unwritten rather than fabricated. A backward move truncates the journey at the target, so done back to reviewing drops `Completed On` and keeps the two before it, and anything back to backlog drops all three. Presence therefore changes meaning. A field no longer says the ticket sits in that status now, it says the ticket got that far and has not been sent back past it. `Status` is what says where it is. This is still not d4ce964's history log. These answer how far and when, once per stage; every status change, every owner and every tag along the way is the log's job. The placement a6023e2 chose already holds: the three sit directly after `Created At` in `METADATA_ORDER`, so a ticket that has walked the whole flow reads as one block of four timestamps in flow order ahead of Campaign and Status. Nothing but `mv` writes them, pinned by a test over `add`, `set`, `append` and `chown`. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> |
||
|
|
95426e87be |
(d637288) Guard an existing codename behind --force, and bump to 0.21.1
`campaign set --codename` replaced whatever was there. Once a campaign has a codename it is referred to by it -- on every card in the campaign, at the command line, and in somebody's shell history -- so changing it silently is the mistake `install-skill --force` exists to prevent. So it is refused, and the refusal names both words and the flag rather than leaving it to be found. Checked before any edit is applied, like `SetArgs::contested`, so a call also carrying `--title` writes neither field rather than half of what was asked for. Setting the codename a campaign already carries stays a no-op rather than becoming a refusal: `--force` is about overwriting a *different* word, and there is nothing to overwrite. That is the division `install::Outcome` already draws between `Unchanged` and `Refused`. `--force` guards the codename alone. A campaign always has a title, so guarding that would mean the flag was always required, which is a tax rather than a guard. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> |
||
|
|
72dbdec2ec |
(d637288) Add campaign set, and bump to 0.21.0
`campaign add --codename` was the only writer of the field, so a campaign already on the board could not be given one without editing the file by hand -- which is every campaign filed before 0.20.0. A `campaign set`, not a flag on something narrower: the file has more than one editable thing, and the moment somebody wants to fix a typo in a title there would be a second command to design. It carries `--title`, which renames the file the way `set --title` does, and `--codename`, through the same parser `campaign add` takes. Built out of `set`'s own parts -- `set_title`, `apply`, `report`, and the whole-file no-op comparison -- so nothing about writing a field lives twice. The codename goes through `set_or_insert_metadata_field` rather than `set_metadata_field`: a campaign filed before the field existed has no such line, and those are exactly the campaigns this is for. That exposed a second thing -- `Codename` was not in `METADATA_ORDER`, so an inserted line landed at the end of the block while `campaign_body` writes it under the ID, two shapes of one file. It is in the list now, directly after ID. `save_ticket` split into `save_entry` with `save_ticket` and `save_campaign` as named wrappers, so a campaign gets the same write-then- rename a ticket has rather than a second copy of it. `write_then_replace` and `find_entry_file` take the noun, so a failure says "campaign" where it is one. No `--description`, filed as 32e98ab: `set` and `append` are a pair for a prose section, and replacing a description with no way to add a paragraph is the half that loses the rest of it. No `--owner` and no `--clear`, each for a reason recorded on the ticket. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> |
||
|
|
528566d103 |
(61879a4) Surface campaigns on the board, and bump to 0.20.0
A card label and a frame, not a campaign tab. A tab had to say what its columns are, and a campaign groups across the flow rather than within one status, so the answer is the four columns filtered: a filter on the board it already has, not a fifth tab. So a card names its campaign on the label row, before the tags, marked ~ and bold, and the row drops the tags whole before it drops the campaign. `c` opens a picker; taking a campaign filters every column to its members and draws a frame above them carrying the id, the codename, the name, the opening line of the description and the standing. The standing comes from the columns, since while a campaign is selected the columns are its members. `q` takes off one layer at a time: the overlay, the filter, the board. The label needs something to say, which the stored uuid is not, so campaigns gained `Codename`: one word, `v1` or `beaver`, written by `campaign add --codename` and validated at parse time. `campaign ls` prints it and `resolve_in` gained an exact-codename tier above the uuid prefix, or it would be a field you can read and cannot type. Only campaigns carry the field, so the tier is empty for a ticket and ticket resolution is unchanged. The campaigns index is read once per project in `columns_of`, on the pass that already builds the cards, and `digest` now watches the campaigns directory: without it a campaign filed elsewhere never reached the picker. `frame_rows` grew a row, so the two bools deciding the geometry became one `Chrome` and the row indices are named. Left out and filed as d637288: nothing can give a codename to a campaign that is already on the board. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> |
||
|
|
c65e1b4ed7 |
(55ee6e3) Complete campaigns and tags, and bump to 0.19.0
Every argument naming a campaign or a tag fell through to nothing: `campaign show <TAB>`, `assign <TAB>`, `ls --campaign <TAB>` and `ls --tag <TAB>`. Neither value had a listing a completion could parse. `campaign ls --ids` is the same flag and the same two fields as `ls --ids`, since it answers the same question about a different object. It skips the member counting the decorated listing does, because `members()` reads every ticket on the board and the caller is a shell on a keypress, and it prints nothing on an empty board where the decorated listing prints a sentence. Tags get a command rather than a mode on `ls`. `ls --tag <tag>` answers what carries a tag and cannot answer what tags exist, which is the question a grooming sweep starts from, and a `--tags` beside a `--tag` is one letter from a filter that means something else. `worklane tags` prints the tag, a tab and the count, alphabetical and case sensitive like the filter, so `bug` and `Bug` list separately and land next to each other. assets/PLAN.md used to tell the agent to count the vocabulary with a `show` per ticket; it now points here. The fish half gains `__worklane_nested_arg_of`, which matches a parent and a child, because `campaign show <TAB>` and `chown alice <TAB>` sit at the same token count and the two counting helpers cannot tell them apart. It also gains `__worklane_command_is`, which fixes a leak the campaign and tag rules would have joined. A bare `complete -c worklane -l tag` does not only complete that option's values, it tells fish the whole tool accepts `--tag`: `worklane init --<TAB>` offered `--blocked-by`, `--regression-of`, `--relates-to` and three others. `relate`'s three were already leaking that way, so all of them are scoped now rather than leaving a correctly scoped twin beside a wrong one. `__fish_seen_subcommand_from ls` is not the scope to use, since `campaign ls` is an `ls` fish has seen. The honesty tests grow to five lists and one walker, `every_argument`, since they differ only in the id they look for. Each asserts how many arguments it found, so a walker that stopped finding them fails rather than passing every assertion by never running it. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> |
||
|
|
6a800fb385 |
(bdddc09) Read only the underscore markers as unset, and bump to 0.18.1
`is_unknown_value` accepted `-None-` and `-Not set-` alongside the real
`_None_` and `_Not set_`. The ticket had them down as corrupted output handled
downstream instead of at the source, but the source never existed: `git log -S`
finds both spellings in exactly one commit,
|
||
|
|
4ae7ef03ff |
Let git blame look through the reformat
`.git-blame-ignore-revs` names
|
||
|
|
964ca342d8 |
(83d31cd) Make rustfmt the formatter, with a config measured against the tree
cargo fmt --check failed in about 160 places and rustfmt was neither run nor switched off, so anyone who ran it once produced a diff that buried the change it was run alongside. It is the formatter now, and the config is what makes that affordable. The default config wanted 305 hunks and would have added 1418 lines of pure layout: its sub-widths (fn_call_width and chain_width at 60) sit far below the 100 columns this tree is written to, so 276 of those hunks were rustfmt expanding lines that already fit. `use_small_heuristics = "Max"` went the other way, 308 hunks and 796 lines removed, one-lining if/else and collapsing struct literals that were split on purpose. Coordinate descent over the stable width knobs lands at four settings and 161 hunks, 98 of them rustfmt joining calls that fit rather than breaking them. Sweeping any one of the four in either direction makes the diff bigger, which is recorded beside them so the next reader measures instead of adjusting by eye. The reformat itself is the commit after this one, so neither is mixed with the other. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> |
||
|
|
cc5f9b8a46 |
(74904dc) Let a ticket field be cleared back to unset, and bump to 0.18.0
`set --clear <field>` is the one way to take a value away, repeatable, with the field as a `ValueEnum` value: an unknown one is a usage error listing the six that are not, and the shells complete them for free. Not a per-field `--clear-due`, which is a flag per field to keep in step with the one it undoes, and not an empty value, which is already a paragraph break for a section and would make an accidentally empty variable a silent delete. What goes back is what `add` writes for a field it was never given, through the new `NOT_SET` and `NONE` constants and each section's placeholder, so a cleared ticket and one filed without the field read the same. Sections are in scope and go back through `clear_section_body` rather than `set_section_body`: the latter runs its items through `Section::render`, which would have written `- [ ] _No acceptance criteria provided._`. Owner is `chown --clear <ticket>`, so the field keeps its one writer. The flag carries the ticket because the ticket is chown's second positional and a bare flag would land it in the user's slot for the handler to read back out, which is hand-parsing what clap can state. It writes `_Not set_` rather than the git user: `add` falls back to the git user because it is filing something new, and an owner taken away says nobody owns this. The empty-value error split in two rather than being reworded. `non_empty` says only that the value cannot be empty, for the arguments with no empty form; `clearable` names `--clear`, for the arguments whose field has one. One message for both would have lied about `ls --tag`. Replacing and clearing one field in a single call is refused rather than resolved by whichever was applied last, and cleared fields are reported as `Cleared due on '...'` beside `Updated priority on '...'`, since one list would say `Updated` of a field that was emptied. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> |
||
|
|
139c9b012f |
(a6023e2) Stamp the time a ticket entered its status, and bump to 0.17.1
mv writes Committed On, Submitted On or Completed On for the status it enters, so the board answers how long a ticket has been where it is without guessing from file mtimes. The three are mutually exclusive: entering stamps, leaving removes and re-entering restamps, so a backward move under -f leaves no stale Completed On behind. These fields are current state, like Status itself; the trail of how the ticket got there belongs to the history log. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> |
||
|
|
373ba519b3 |
Add a worklane completions command, and bump to 0.17.0
Every argument worklane takes names a ticket, a status, a shell or a skill, and the shell offered a directory listing for all of them. `completions <shell>` prints a script for fish, bash, zsh, elvish and powershell, following what frig does, which is where the shape of this comes from. Two halves, because neither alone is enough. `clap_complete` generates the structure from the clap definition, so a flag added to `command.rs` is completed without anyone touching `completions.rs`, and fish gets a hand-written block appended for what only the board knows. That block runs `worklane ls --ids` in a command substitution, one run per keypress, 2.5ms in release on a board of seventy-five tickets. A status is a `util::Status` value enum now rather than a string, which was the plan's third step and pays for itself three ways. clap refuses an unknown one at parse time naming the four, so `cmd_mv`'s `valid_statuses` and the status half of `cmd_ls`'s error are gone and exit 2 is what an unreal status gets, the bargain `--due` and `--priority` already take. `status_dirs()` and `DONE` are derived from `Status::ALL`, so the flow is written once. And clap emits the four for `mv --status` itself. Only half free: the fish generator emits nothing for the possible values of a *positional*, so `ls <status>` and `completions <shell>` are listed in the appended half after all, read off the enums with `possible_values` rather than by hand. `ls --ids` is the machine-readable listing, and prints the short id, a tab and the title rather than the id alone. Both readers want both fields: fish takes what follows a tab as the description, which is what makes `worklane show <TAB>` a list of titles instead of hex, and a script takes the id back with `cut -f1`. It includes done, where the decorated listing leaves done out, because a completion has to be able to name a finished ticket and `show` is most often pointed at one. It skips a missing status directory rather than refusing, since an error printed over a shell prompt is worse than no candidates, and the listing still refuses one so a person can act on it. The filters all still apply, and an unknown `--campaign` is still refused ahead of everything. Adding the mode tipped `cmd_ls` over the boundary AGENTS.md names, so it takes an `LsArgs`, the way `add` took `AddArgs`. More than the criteria asked, since the cost of each was a name in a list: tickets are completed for `set`, `append`, `relate`, `check`, `uncheck`, the second argument of `chown` and `assign`, and `relate`'s three target flags, plus the skill names read off `install::SKILLS`. The three lists are kept honest by tests that walk the clap definition and fail on a ticket-taking subcommand missing from them, or listed at the wrong position. Nested subcommands are not walked: `campaign` is the only one, none of its three takes a ticket, and the token counting could not tell them apart if one did. Position is counted rather than inferred. `__worklane_first_arg_of` reads `$tokens[2]` and the token count instead of `__fish_seen_subcommand_from`, because `campaign ls` and `campaign show` are also an `ls` and a `show` that fish has seen, and matching against the ticket list to find the position would run worklane again inside the condition. Files are turned off for the command and back on for `tui`, which is the one argument that really is a path. The ticket said worklane takes no file arguments; it takes those. Campaigns and tags are completed nowhere, which needs a listing they do not have: 55ee6e3. And since fish runs whatever is on PATH, the completions are only as current as the installed binary, an older one without `--ids` completing nothing. That is in the README beside the install line. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> |
||
|
|
88918b2f8a |
(c628759) Show a page indicator on the detail overlay's border, and bump to 0.16.1
The overlay has scrolled since 1b78a24 and nothing said where you were: a long ticket opened looking exactly like a short one, so the only way to learn there was more below was to press pgdn and watch whether anything moved. `pg 2/8` now sits on the bottom right of the border, through `Block::title_bottom` with a right-aligned line, which spends no text row. That is the trade the title already makes on the top border, and the two cannot crowd each other because they are on opposite borders. Both of the things this had to get right are arithmetic. `wrapped_height` is now the one measurement: `last_offset` is it less the viewport and `page_indicator` takes the same two numbers, so the clamp and the indicator cannot disagree. A second `line_count` call would be a number free to drift, and an indicator claiming there is more to read where the scroll refuses to move is worse than none. The furthest offset is the last page by definition rather than by division. The clamp stops at the wrapped height less the viewport, which is not a page boundary, so the final screenful is partial and dividing reads `pg 2/3` at the bottom of the ticket. The pages are counted in `scroll_step`, a screenful less the overlap line, because that is the step the keys take: counting whole screenfuls names a page pgdn cannot land on, and puts a 30 row ticket in a 10 row viewport at `pg 3/3` two rows short of its end. Grey, the colour the footer keys and a rendered checkbox take, since this says where you are in the ticket rather than anything about the ticket. Dropped whole on an overlay too narrow for it and absent entirely when nothing scrolls, the rules a corner and the tags row already follow. `page_indicator` is four numbers in and an `Option<String>` out, so the arithmetic is pinned without a terminal. The drawn tests answer the two things it cannot: which border it landed on and what colour it reached the screen in. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> |
||
|
|
6784d80324 |
Let check and uncheck take several criteria, and bump to 0.16.0
Finishing a ticket means ticking every box, and that was one invocation per box: each one resolved the ticket, spliced one line and rewrote the file. The criterion positional is now variadic, so numbers and substrings mix in a single call, and `all` stands for every criterion on the ticket. `all` is a keyword checked before the text, the way the index already is, so a criterion whose own words include "all" is reached by its number or by a longer substring. `is_all_criteria` sits beside `is_index` for that reason. `resolve_criteria` resolves every term before a byte is written and refuses the whole batch on the first term it cannot place, naming it. A call that ticked what it understood and then failed would leave the ticket half-marked with nothing in the file to say which half was meant. The offsets are sorted and deduped, so the report reads in `show`'s order and a criterion named twice, or by both `all` and its number, is marked once. `set_criterion` becomes `set_criteria` and takes every line in one pass. Each named criterion gets a line, printed after the write. One already in the target state reads `Already checked 2: text` and does not count towards the write, so a batch where every box is already ticked writes nothing. The opencode wrapper takes the terms one per line, like the other list arguments. REVIEW.md gains the one thing a reviewer must not do with this: reach for `all`, which would erase the implementer's claim on the criteria the review agreed with. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> |
||
|
|
ae3ee1bb9e |
Show the target's status beside the relation kind, and bump to 0.15.2
A row now carries two marks, kind then status: what sort of edge this is, then
how far the ticket at the other end has got. `blocked by × ◐ (6ce2c47) Title`.
Two questions are asked of this block, which rows hold this ticket up and
whether the ones that do are finished, and one glyph could not answer both.
○ not started, ◐ under way, ● finished, in grey, orange, cyan and green: the
shape says how far the target has got and the colour tells the two middle
stages apart, since committed and reviewing are both half circles. Green is the
colour the priority ramp deliberately leaves out because it means a title; on a
one-cell mark with no title behind it nothing else wants it, and it is the
obvious colour for done. Orange keeps the meaning it already has, Status.
These are the priority meter's own circles, and what keeps a status from
reading as a level is width: the meter is always two cells, a status mark is
one. the_status_mark_is_one_cell_where_the_meter_is_two pins both halves, and a
card carries the meter and never a status mark while the block carries the
status mark and never a meter.
The kind mark survives a target the board cannot find and the status mark
cannot, since a kind is read from the ticket's own file and a status from the
board. ? holds the column so the id does not move when one target has gone, and
_missing_ is what says it is gone.
Committed and reviewing are told apart by colour alone, so a pipe cannot tell
them apart: both read as under way. Accepted, since ● and ○ are the two answers
usually wanted and show on the target settles the rest, and assets/SKILL.md now
says so outright rather than leaving an agent to work it out from a colourless
half circle.
RelationTarget is back, carrying the title and the status in one Option because
they come from the same lookup. It went out in
|
||
|
|
5ae9c7fe00 |
Mark a relation by its kind rather than its target's status, and bump to 0.15.1
A column of ▁▄▆█ read as undifferentiated blocks. What is worth seeing at a glance is which kind of edge a row is: × for blocked by and blocks, → for relates to, ← for regression of and regressed by. The labels are five long words that blur when one ticket carries several, and the rows holding it up are now the crosses. Both directions of a kind carry one mark, since blocked by and blocks are the same edge read from two ends and the label is what says which end you are on. × is BLOCKED_MARK, the constant a held-up card already draws, in the same brightred. On a card it says this ticket is held up, in the block that this edge is what holds one, which is one word, so one glyph and one definition: the constant moved to util.rs, where both renderers can reach it. Brightred rather than the red asked for, because the id one cell to the right is red and the two would have blended. The arrows are the ones the footer already draws, so they render wherever it does, and no_relation_mark_is_a_priority_glyph pins all three against every level of the meter: the circles belong to priority. The mark now survives a target the board cannot find, because a kind is read from the ticket's own file rather than from the board. Only the name is gone, and `_missing_` in grey is what says so. That is one case fewer than the status mark had, which needed a `?` for a target with no status to show. What this gives up is the status: 6ce2c47's motivation was reading whether a blocker is finished without leaving the overlay, and nothing in the block shows that now. Its criteria 1 and 3 describe the commit before this one, and the ticket says so. RelationTarget went with it. Nothing read the status field once the mark stopped keying on it, and a field written but never shown is a field that goes stale unnoticed, so RelationRow carries the kind and the title and the status is one lookup away on the index if a later ticket wants it. A patch, not a second minor: 0.15.0 was the arrival of a mark and settling which glyph it is belongs to that, where a second minor would read as two features. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> |
||
|
|
ce32b42ae4 |
(dbf7b61) Guard the overlay's relation colours, and bump to 0.15.0
The mechanism arrived with 6ce2c47, as this ticket said it would: the block is
laid out once as cells, the id carries the red the guideline gives a uuid, and
the board turns the same cells into spans. So the id is red in the overlay
without anything here asking the terminal for a decision, and the three
criteria about what is drawn were true the moment
|
||
|
|
ece201e3ab |
(6ce2c47) Mark each relation with the status of the ticket it names
The Relations block named each target and said nothing about where it was, so the question actually asked of it, whether a blocker is finished, meant closing the overlay and going to find the other ticket. Each row now carries a mark for its target's status, ahead of the id, where it describes the target rather than the row. A rising bar, U+2581 through U+2588 for backlog to done, and ? for a target the board no longer holds. Not a circle: the cards spend those on the priority meter two cells from nothing at all, and another circle would be read as a level. The ramp is also the meaning, so the shape says which status it is. The colour could not. Every colour in the guideline already means one thing and the eight tag slots are reserved, so four status colours could only have come out of something else's meaning. So the shape carries the status and the colour says only that it is one: orange, which is what Status already means, and grey on the missing mark, beside the _missing_ that grey already spells. An unrecognised status reads as missing rather than as a fifth stage, and every_status_has_a_mark pins the pairing against status_dirs so a status added later fails a test instead of quietly reading as ?. The plain text was the real cost. Detail.text was one String drawn by a Paragraph, deliberately uncoloured because an escape sequence there is drawn as literal bytes, which is 6d327df. So the block cannot arrive pre-painted. Resolved.relations is now rows, content_parts returns the body as BodyPart::Text and BodyPart::Relations with the text painted and the rows untouched, and the two renderers take it from there: content_trim paints the rows into escapes, and the board styles the same cells as spans. One builder, two painters. relation_rows decides which edges there are, what they are called and which direction leads; relation_cells decides the layout, the mark and the colours; paint_cells and span_of are the only things that differ. Cell is the unit both take, the same shape the palette uses to stop a colour existing for one renderer and not the other. reference_cells is now the one spelling of a cross reference, shared with the Campaign field. Detail.body is a ratatui Text and is the only thing measured, so last_offset and the Paragraph cannot wrap the body two ways. Detail::plain() flattens it for the suite and is cfg(test): a second representation carried beside the spans is a second thing to disagree. show carries the same mark, decided here rather than discovered later. The rows are one builder so it was free, and two views disagreeing about what a relation shows is a difference nobody can explain afterwards. That is a change to what the CLI prints, so the minor goes on the last commit of this pair. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> |
||
|
|
c437d87e9e |
(2f3796e) Add a --tag filter to worklane ls, and bump to 0.14.0
Tickets carry a Tags field, but ls could not select on it: finding what is tagged bug meant reading the board. Step 1 of the plan was already done by e41802b, which put tags: Vec<String> on TicketItem through parse_tags, so this is the flag, the filter and the tests. Whole values, not the field. parse_tags has already split and trimmed the comma-separated field, so filter_by_tag compares against those values: --tag bug is not answered by a ticket tagged bugfix, --tag "cli, filter" matches nothing because the field as written is not itself a tag, and a ticket with no tags matches none, however it spells it. Case sensitive, which is the opinion the field already takes everywhere else. tag_color draws Bug and bug in two colours because they are two tags to the field, and a filter that folded them would list tickets carrying a tag nobody asked for while hiding exactly the split a grooming sweep is looking for. One tag per invocation. Several would have to decide between and and or, and that decision is its own ticket, along with substring or regex matching and a tag filter on the board. A tag nothing carries lists nothing rather than being refused, deliberately the opposite of --campaign. A campaign is an object that exists or does not, so it is resolved before anything is read; a tag is free text with no registry, and refusing an unknown one would mean maintaining a vocabulary the format does not have. An emptied status keeps the message ls already gives rather than one per filter naming what excluded them, which is what --priority and --campaign already do. The filter goes through filtered, the one call the three collect sites share, so the counts are filtered by the same set as the rows. Every filter is an Option and none asked for keeps everything, which is what makes them compose in any combination. cmd_ls is now at four filters and the directory, two of them adjacent &Option<String> parameters a caller can swap silently: left as positionals rather than refactored mid-feature, with AGENTS.md recording that the next filter takes an LsArgs struct the way add took AddArgs. assets/PLAN.md said in as many words that there was no tag filter yet, so it would have been actively wrong. It now says what --tag can and cannot answer: it finds what is tagged bug, it does not enumerate the vocabulary, which is the question a grooming sweep starts from. The README's ls row also gained --campaign, which had never been documented there. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> |
||
|
|
0ce3fdb246 |
(0546fc5) Copy the selected id with y in the tui, and bump to 0.13.7
The board is where a ticket is found and the CLI is where it is acted on, and the only thing joining them was seven characters retyped off the screen. y reads as yank to the readers a keyboard board is for, and was the letter left after q, esc, enter, space, hjkl, the arrows, pgup, pgdn, tab, backtab, d and / took theirs. The mechanism was chosen against ssh, which is where a board is often read. OSC 52 crosses the connection, because it is the terminal at the reader's own end that owns the clipboard. A crate wants X11 and Wayland libraries at build time and, on X11, hands the selection to the process that set it: copy an id, quit, and the paste buffer is empty, which is precisely the flow this key exists for. Shelling out to wl-copy, xclip or pbcopy is platform sniffing plus a spawn, and does nothing where none of them is installed. crossterm 0.28 is what ratatui 0.29 pins and ships no clipboard command, so the sequence and its base64 are twenty lines in src/clipboard.rs, pinned on the RFC 4648 vectors. The cost is recorded rather than hidden, in AGENTS.md under The Copy Key: a terminal that ignores OSC 52 ignores it silently, and tmux needs set-clipboard on. What clipboard::copy reports is whether the sequence was written, and the footer says no more than that. There is no reply to read either, since the query form is refused by most emulators. What is copied is ticket.id, the seven characters the card already prints and every command already resolves, decided by Board::copy_text so the string is a question the suite can ask without a clipboard. None on an empty column: an empty string would take away whatever the reader had there and give nothing back. The project is left off even on the merge tab, since a second word would have to be deleted out of every paste. Board::copy_selected_id takes the clipboard as an argument, clipboard::copy from the dispatch and a closure from a test, which is what makes the hit and the refusal both drivable. A failure is said in the footer rather than returned: there is nobody above it to handle one, and an error swallowed there would look exactly like a copy that worked until the paste came out wrong. Notice is the board's first channel for saying something in words, and it has to be, because a copy leaves nothing on screen to look at. failed means nothing reached the clipboard, so an empty column and a refused write are one answer to the reader, both in brightred like the search's no match. It takes the whole footer row, since a message squeezed in beside the keys would move every key in it. Cleared by the next keypress rather than on a timer: no clock on the board, no wakeup in the loop, and never in tick, which runs four times a second. clear_notice goes ahead of search_key as well as the arms, because a key typed into a query is still a key. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> |
||
|
|
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> |
||
|
|
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> |
||
|
|
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> |
||
|
|
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> |
||
|
|
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> |