Every check over the completions read the script as text. A `contains`
cannot tell a rule that fires from one whose condition stopped matching,
and that is how a completion actually breaks: the clap definition moves,
a list or a `__worklane_command_is` scope stops naming anything, and the
rule sits in the file offering nothing while every assertion passes.
So the generated script is sourced into a throwaway fish standing in a
real board, with this build's directory on the front of PATH, and
`complete -C` is compared against the ticket and the tag that board was
given. Four deliberate breakages were used to size it: renaming the `ls`
status scope, dropping `append` from `TAG_FLAGS`, renaming a flag in
`TICKET_FLAGS` and dropping `show` from `TICKET_COMMANDS`. All four now
fail, each naming the list at fault.
**Assert the values, not the flag names.** clap emits every option's name
on its own, so `--tags` and `--blocked-by` are offered with the whole
dynamic half deleted; the first draft asserted those names and caught
only one of the four. What the hand-written rules add is the candidates
after the flag, and that is what a board under the shell makes checkable.
Two traps, both paid for once. `complete -C` autoloads
`~/.config/fish/completions/worklane.fish`, so the first draft passed
against a deliberately broken scope because the copy installed in August
still had the working rule: `set fish_complete_path` with no value is
what makes the sourced script the only source, and without that line the
test cannot fail. And the script is written beside the board rather than
in it, since a rule that fires nothing falls back to listing the
directory and the script would read as an answer.
`fish --no-execute` comes with it as the floor: it catches a script that
does not parse. Narrower than it sounds, and measured rather than
assumed, so the limit is written on the test. An apostrophe in a `-d`
description partway down re-balances against the next quote and parses,
corrupting every rule in between; the same apostrophe in the last rule
reaches the end unbalanced and is caught.
`every_listed_command_is_a_real_subcommand` widens to every list that
names a command, `CAMPAIGN_COMMANDS`, `TAG_FLAGS` and the two nested
lists, so a stale entry fails by name instead of through a rule count.
The counts themselves stay hardcoded and now say why: the walkers go
clap → list and never see an extra entry, so the count is what catches
one, and deriving it from the lists it checks would grow with the bogus
entry and pass.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
`set --tags` writes the whole field, so adding one tag to a ticket that
already carries some meant reading it first and retyping every one of
them. 30a2b34 wrote that down in the skill as the way to do it; this is
the flag that makes it unnecessary.
The merge is idempotent and ordered. A tag the ticket already carries is
reported as no change rather than added twice, which is the point of the
flag: the caller does not have to know what is there. A new one goes on
the end in the order it was given rather than sorting the field under
whoever last touched it. Values are split on commas the way the stored
field is, so `--tags "bug, tui"` names two tags and matches the two a
ticket carrying them already holds; without that the pair would land as
a single tag nothing can filter by and would not match itself on the
next call. `split_tags` is that rule, lifted out of `parse_tags` so the
argument and the field are separated by the same code.
It writes the same `Kind::Tags` entry `set --tags` writes, so `--actor`
and `--actor-from-git` come with it. Tags are logged wherever they move,
and the one command that adds to them without replacing them would
otherwise be the one tag change the log missed. The before and after are
read off the field rather than off the flag, so an append of `beta` onto
`alpha` reads as the pair and not as what the call asked for.
`non_empty` rather than the `clearable` that `set --tags` takes: that
message names `--clear`, and `append` has none, so it would send the
caller looking here for a flag that is `set`'s. A value that is only
separators reaches the handler and is refused there, in the words
`appended_items` refuses an all-blank section with. Emptying the field
stays `set --clear tags`.
`TAG_FLAGS` becomes pairs of command and flag, because `ls --tag` and
`append --tags` are spelled differently and one rule naming both options
would tell fish that each command accepts the other's. `add --tags` and
`set --tags` deliberately get no value rule and are recorded in the
test's `TAG_LIST_FLAGS` instead: they take the whole list, so the token
at the cursor is `bug,tui` and fish replaces a token entire, throwing
away what is already typed. The honesty test now walks `tag` and `tags`
both, so the next tag argument has to say which of the two it is.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
The lines typed at the command prompt are walked with up and down and kept
in .wlhistory in the board's own folder, so a recall spans runs rather than
one opening of the prompt.
One Recall per tab, parallel to Board::tabs, so the tab in view decides
which list up walks: a project's lines are the ones naming its ticket ids.
The merge tab is no board, so it keeps its lines for the run and writes no
file, the answer current_project already gives a command typed there.
The position sits on Prompt and the lines on Recall, so closing the prompt
forgets the position and not the lines. A failed write is silent and an
unreadable file is an empty recall: the line is in memory either way.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
The prompt parsed a line and named what it resolved to. This is the half
that does it: the parsed command goes to the same cmd_* handler main.rs
hands it to, against the selected tab's own .worklane, with a Sink over a
buffer collecting what the handler says instead of stdout.
One dispatch table, not two. main.rs's match on Command is lifted into
`dispatch`, over the command, the start path and the sink, and both
callers go through it. A second copy in tui.rs would drift the first time
a command was added and would drift silently, since both halves go on
compiling; the match is exhaustive so a new verb cannot fall into an `_`
arm either. Only `tui` is matched outside it, in main, because the board
is that table's caller rather than an entry in it, and reached from the
prompt it is refused in those words.
Two things the board has to do that the CLI never had to. It reloads
unconditionally after a command returns rather than waiting for the
digest, so a reader does not watch their own mv take up to a poll
interval to appear, and either way, since a handler that failed part way
through has still written. And the selection is restored by uuid across
that reload: mv puts the card in another column, set --title renames its
file, and a filter can drop it out of view, so the slot is not the
ticket. Where the board cannot follow it, the notice says so and which
key shows it.
What the handler says is what the board reports, word for word. Notice
therefore holds as many lines as the command used, and notice_on_row is
the one rule for where they go: one line on the footer row where a copy's
notice has always gone, anything else as a box at the foot of the
columns. A box rather than more rows of footer, because a footer that
grew and shrank as notices came and went would reflow the columns on
every keypress. A handler that errors leaves the prompt open with the
line intact, the usual cause being an ambiguous id.
`without_escapes` in util.rs is the guard at the seam. A handler's own
output is plain because the sink is, but an error message is built with
color_text, which asks the process about its stdout and under the board
answers yes about a terminal the message is not going to; a ratatui
paragraph prints an escape rather than obeying it. That is 6d327df's
fault on a new path.
The merge tab is refused for now, resolved by index rather than by the
tab's name, which is a label two projects can share. Routing by the card
a command names is ebc5755.
Not done here, and both tracked: check with no criterion still reaches
ask_which_criterion and reads a raw-mode stdin, which is 6d37042's
criterion 4 and commented there; and check_blockers warns about a
dangling blocker with eprintln!, which reaches the alternate screen
because it never passes through dispatch's result, filed as c680e24.
The board reads. Changing anything meant quitting it and retyping an id
that was already selected. So `:` opens a one line editor in the footer
and the line is a worklane command, spelled exactly as the shell spells
it.
This is the mode and the grammar check, not the doing. Enter tokenises
the line with split_line, prepends the binary's own name and hands the
arguments to the same Cli definition the shell reaches, so a flag added
to a command is typeable here the day it is added and no list of verbs
lives on the board to go stale. A line that resolves is named and the
prompt closes; a line that does not keeps the prompt open with the line
intact and clap's own message, cut back to what fits a row. Running it
is 53ffb94, and the notice and the `↵ check` key both say so rather than
reading like a move that happened.
The prompt owns the keyboard while it is open, the contract search_key
and picker_key already keep, and declines ctrl-c for the same reason
they do. A line that ends inside a quote never reaches clap, which is
what the splitter's Unclosed state is for. --help is caught, or clap's
page lands on the alternate screen the way an unsunk println! would.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
The command prompt reads one string and clap reads an argv, so a line has
to be tokenised before anything can parse it: `comment 1b78a24 the offset
was never passed` split on whitespace is five arguments and `comment`
takes two.
One pure function over the line and the cursor, in a module of its own
rather than in tui.rs. The rules are the shell's, because that is what
the prompt promises. Two answers a shell's own splitter does not owe
anybody come out of the same scan: what a half-typed line is still
inside, as a state to report rather than an error to raise, and which
argument the cursor is in with whether it begins one.
Nothing calls it yet. The prompt that will is 3686dd6, and the dead_code
allow on the module goes when it lands.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Every key hint on the board was one flat grey string, `←→ column ↑↓ card
/ search y copy id enter detail d show done (3) q quit`, so nothing
separated a key from what it does and a reader looking for one read the row word
by word. frig and pantop both colour the key, and the three are read side by
side.
`key_hint` is the only thing that draws a hint now: the key cyan and bold, the
description in the terminal's default foreground, one span each. The three
footer states, the prompt's two keys, the picker's row and the `q board` on the
frame's border all go through it, so the shape is learnt once and cannot drift
between rows. Cyan here and magenta in pantop is the rule and not an
inconsistency: one accent per tool, the one that tool already uses.
**A key that is its description's first letter is merged into it.** `q quit` is
drawn `quit` with the `q` coloured, `c campaign` is `campaign`, `t tag` is
`tag`. `y copy id`, `ctrl-c quit`, `d show done (2)` and every arrow row stay
split, so the row carries both forms at once, which is what the two cells are
worth on a row already at its width naming eight keys. The prefix test is case
sensitive, and that is not fussiness: a row naming both `r` and `R` would draw
one word for the two of them, and the merged form can only say which key it is
while the letter it colours is that key. frig has such a pair and needs it.
`enter` is written `↵` everywhere it is named, which is the other two cells.
The rows are lists of `(key, description)` pairs rather than format strings, so
the tab slot, the two filter keys and the `d` slot come and go by pushing a pair
or not. They were fragments carrying their own trailing spaces, spliced into
three format strings that had to agree about the spacing between them.
The frame's border hint is measured over its spans instead of one string, since
it is three of them now. It still drops the indicator first and then itself,
whole either way.
The grey was argued for in comments, and the argument is reversed rather than
deleted: the row is still chrome, but a key nobody can pick out of it is chrome
that has to be read word by word to be used. What that costs is on the prompt,
where the query now sits in the same foreground as the descriptions beside it.
The cursor is what says which half is an input, and it does that in a terminal
with no colour at all.
**The footer tests read cells, not text.** Three of the guards that keep
1b78a24 out were `!contains("q quit")`, and once `q quit` is spelled `quit`
every one of them passes whatever the row says, because the split `ctrl-c quit`
contains the merged form. `keys_on` answers with how many cells the word opens
with in the key colour: `Some(1)` is `q` quitting, `Some(0)` is the word sitting
in the tail of `ctrl-c quit`, and `None` is a key the row does not name at all.
`!contains("enter detail")` on the frame row would have joined them the moment
the spelling changed, and is now `↵ detail`.
AGENTS.md carries the rule, the merge and the case sensitivity, and the palette
gains the one colour it spends on something that is not a value.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
`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>
`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>
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>
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>
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>
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>
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>
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>
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>
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>
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.
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.
The board could be cut by campaign and not by the axis `ls --tag` has answered
since 2f3796e. `t` opens a picker of every tag the board declares or carries,
and taking one filters every column to the cards carrying it, matched whole and
case sensitively the way the listing matches.
The picker is one piece of machinery over two lists rather than a second
picker. `PickerRow::key` is what made that cheap: a campaign is keyed by its
uuid and a tag by itself, both strings, so stepping over selectable rows,
keeping the highlight across a rebuild and taking a row with `enter` are
written once. Only the list and what the answer filters differ.
`Tab::campaign` became `Tab::filter`, an enum of whole, campaign or tag, with
`select_filter` its only writer. Picking either clears the other because they
are one field rather than because two setters remember to, which is also what
the shared frame slot needs: it holds one frame and can now only be asked to
name one thing.
The tag sections are declared above undeclared and neither is truncated, where
the completed campaigns are: a finished campaign is done with and that tail
only grows, while an undeclared tag is the row a reader most wants to see.
`campaign` and `campaigns` would have sat one under the other here the day the
second was invented.
The digest stamps `tags.md`, or a tag declared elsewhere would never reach an
open picker. The footer names the tag in its own colour beside `q board`,
because a tag draws no frame until 2a83bd4 and nothing else would say why the
cards are missing.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
`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>
Since tags.md there are two vocabularies, the one the file declares and the one
the tickets carry, and the listing reported only the second. A tag declared and
never applied was invisible, and a word somebody invented in a hurry read
exactly like one the board had agreed on. Those two cases are the whole reason
to declare tags at all.
The listing is now the union: still alphabetical, still case sensitive, with the
annotation's opening line as a third tab-separated field and a count of zero for
a tag nothing carries.
**The absence of the third field is what marks a carried but undeclared tag.**
Nothing could be appended to the first field without a completion offering a tag
that does not exist, and nothing could be added to the second without it
stopping being a number. Absence costs neither, and it buys the property a
marker could not have: a board with no tags.md has every tag undeclared, so it
prints two fields a line, which is byte for byte what this printed before the
file existed. An older completion script on a newer binary keeps working, which
is the same compatibility 1db02e5 kept for the bare form.
A declared tag with nothing said about it answers the placeholder rather than an
empty string. An empty third field is a trailing tab and nothing else, so the
one difference between declared and not would have been invisible in a terminal
and in a completion alike. It is also what the file itself holds under that
heading, so the field is the section's opening line either way.
`TagIndex::summary` does the cut to one line, the way `CampaignRow::summary`
takes one line off a description the read carries whole: the annotation is prose
with paragraphs in it, and how much of it a view wants is the view's business.
The two fish rules pipe through `cut -f1,3`, since fish takes everything after
the *first* tab as one description and the count would otherwise land in the
middle of the prose. What is left is the annotation, and a tag the board has
never declared is offered with no description at all, which says what the count
used to say more weakly. `cut` rather than `string replace` because columns are
what is being picked, and `cut -f1` is how a script reads this listing anyway.
A test pins both rules rather than the script as a whole, so a rule added later
that reads `worklane tags` raw is caught.
`assets/ADMIN.md` claimed a declared and unapplied tag does not appear in the
listing, which is now the opposite of the truth; it lists at zero. Fixed here
rather than left to f7dd1a1, which does not list that file. The same stale
sentence in SKILL.md and PLAN.md is recorded on that ticket.
Filed on the way past: an annotation carrying a tab splits the listing into a
fourth field, 8f650fc, and the `tags set` completion offers the undeclared tags
it refuses, which only became filterable now that the listing tells them apart,
193f9be.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
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>
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>
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>
A tag declared with the wrong annotation was stuck with it, which is 32e98ab's
hole arriving before the writer rather than after. The campaigns entry on this
board was already in that state: it reserved the singular for the campaign
command, and stopped being true the moment that tag was rolled in.
`worklane tags set <tag> --annotation` replaces the whole annotation.
`--annotation` is required, so a bare call is a usage error rather than a
silent no-op, and an empty one writes the placeholder, which is why there is
no `--clear`. `add` and `set` refuse what the other is for, each naming the
other, so which one wrote a line is never a question of which was typed.
No `--force`: a codename is guarded because a campaign is addressed by it,
where an annotation is prose written to be revised. No rename: the tag is the
key, so changing it means rewriting the Tags field of every ticket carrying
it.
`report` grew `report_in`, which takes the colour. `report` paints its subject
green and green means title, so a tag could not reuse it: a tag is drawn in a
`TAG_COLORS` slot or it is drawn wrong. Same wording, decision passed in,
which is the trade `paint` makes with `color_text`.
The no-op compares the rendered file rather than the annotation, the way
`apply` compares content for a ticket field.
`tags set` takes a tag the board already has, so it joins the new
`TAG_NESTED_COMMANDS` and gets a fish rule offering `worklane tags`; `tags
add` stays ruleless in `TAG_NEW_COMMANDS`. The guard now names both lists, so
the next tag positional has to pick one.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
The board carried twenty-four tags and defined none of them. `campaign` and
`campaigns` were both on it, one ticket each side, and nothing on disk could
have caught that.
`.worklane/tags.md` is the vocabulary: one level-two heading per tag, its
annotation as the prose under it, alphabetical by byte so a near-duplicate
lands next to what it duplicates. `worklane tags add <tag> --annotation`
writes it, `init` creates it empty, and `tags add` creates it on demand for a
board that predates it.
Declaring a tag tags no ticket, and tagging a ticket declares nothing. The
counts stay derived from the status directories, so the file and the board can
disagree; reporting that disagreement is 9564ac9.
`tags` becomes a group with an optional subcommand. The bare form is still the
listing, byte for byte, because the shipped fish completion calls it that way
to fill in `ls --tag`; `tags ls` is the same arm.
Every write re-renders the whole file from the parsed vocabulary rather than
splicing one section, which is why an unreadable file is an error in
`TagIndex::load` where an unreadable campaigns directory is an empty index:
empty here would mean erased.
`no_tag_taking_option_is_missing` used to panic on any tag positional. It now
allows what `TAG_NEW_COMMANDS` records, which is `tags add` alone: the tag it
takes does not exist yet, so completing it from `worklane tags` would offer
exactly the values it refuses.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
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>
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>
`.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 11145b2
is the new command, and one bump on the last commit is what this tree does
when work spans several.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
`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>
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>
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>
`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>
`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>
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>
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>