An agent sandbox bind-mounts /dev/null over protected paths such as
.bashrc and files inside .claude/, so make patch refused a tree that
was clean outside the sandbox. Untracked character devices cannot be
committed, so the check skips them and lists only what blocks the
release. Untracked files are listed one by one rather than with
--directory, since the collapsed .claude/ entry is not a device.
Work already on the default branch cannot go back to committed without
reopening shipped code. The reviewer files each remaining issue as a new
ticket, related issues together, comments why the ticket is closing, and
moves it to done.
`:mv --status ` offered the five statuses on the board and `:mv -s `
offered nothing: argument_at read the typed word with strip_prefix("--"),
so a word spelled with one hyphen was not a flag to it and fell through to
the positional arm, which counted a position that was not there.
long_name translates the letter through the command that holds the flag, so
the tables stay keyed on the long name and nothing here keeps a second list
of every option's letter. One letter, never a cluster: `mv -fs done` would
make the last letter the honest answer, but --title, --acceptance and a
comment body all take a leading hyphen on purpose, and a criterion typed as
`-fixes the offset` must not be answered with statuses.
The fish half had the same hole in its dynamic rules alone, which were
written as `-l <flag>`: `append -g <TAB>` offered nothing where
`append --tags <TAB>` offered the board's tags. fish_option reads the letter
off the definition per command, so an option given one tomorrow is offered
under it the day it is given. Clap's own generated rules already carried
both spellings, which is why a shell answered `mv -s ` and the board did
not.
a_short_flag_answers_what_its_long_spelling_answers walks every option with
both spellings on every command and nested command and pins that the two
answer the same, so this cannot come back one flag at a time.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
The reader knows the grammar approximately: that mv takes a status, not
whether it is a positional or --status, and that set has a flag per section,
not whether the criteria one is --acceptance or --criteria. In a shell fish
answers that as the line is typed. On the board there was nothing, and
getting it wrong cost a rejected line and a guess.
usage_of walks the typed verb against the clap definition and renders its
usage, so a flag added to a command is described here the day it is added.
A table of synopses kept beside it would be a second grammar, and it would
go stale silently: nothing but a reader typing that verb would ever see the
two disagree. The Usage: label is dropped, being the name of a block in a
help page of several where this is one line beside the line it describes.
It takes the keys' slot. esc and enter are two keys a reader learns once,
against a synopsis that is different for every verb; a refusal still wins
over both while it is up, being what was just said about the line that is
still on the row. refusal is the half that says what is wrong where this
says what would have been right.
A verb that resolves to nothing draws nothing and complains about nothing,
since the line is half typed most of the time the row is looked at. A
group's child is walked when the second word names one, so campaign set
describes set; while that word is half typed the group's own usage stands.
Grey, and cut with an ellipsis rather than wrapped: the footer is one row
and a second would reflow the columns every time a verb resolved. There is
always at least the keys' width to cut into, because that width comes off
the row before the line is windowed, so the usage never takes a cell from
what is being typed.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
campaign ls printed every campaign and offered no way to narrow it, and the
row was assembled by hand, so a long title pushed the standing out of line
with the row above it and the created date the file already carries was not
shown at all.
--state takes open, done or empty and matches against Standing::state(),
so the derived value keeps one definition: a campaign reads [open] in the
listing if and only if --state open lists it. --state rather than --status,
which names one of the five ticket statuses everywhere else and would
invite --state backlog here. empty is the third value because an empty
campaign derives None deliberately, and a filter that could not reach those
would leave what has been filed and forgotten answerable only by reading
the whole listing. A filter that matches nothing names the value back,
since a silent listing reads as the other empty case.
The filter reaches --ids as well, the way ls --ids keeps its own, and is
the only thing that makes that path count members: an unfiltered completion
is as cheap as it was.
The columns are measured on the raw values and padded before anything is
painted, the rule metadata_cells follows. The codename is measured with the
title rather than given a column of its own: a campaign filed without one
spends nothing on it, so a column for it would be one most rows pad into
and some leave empty, and what a reader lines up is where a name ends and
its progress begins.
A flag's possible values now come off the command that holds the flag, so
campaign ls --state reaches ls's own arguments rather than campaign's. The
prompt offered nothing there while fish offered the three values, which
made a liar of the rule that a ValueEnum added anywhere is typeable on the
board the day it is added.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
WORKLANE_ACTOR is set once in the environment an agent runs in, which is
right for an agent and wrong for the board: a person who exports it where
their own shell picks it up, the obvious way to configure it for the agents
on that machine, then moved a ticket with ':' and the board recorded the
move as the agent's.
Nothing but the reader can type that line, so the prompt asks for
--actor-from-git's precedence without the flag. An explicit --actor still
wins, which is how the reader puts somebody else's name on their own
keystrokes, and a machine with no git user configured reads unknown rather
than falling back to the variable, for the reason the flag does.
The attribution is a parameter of dispatch rather than a field the prompt
writes into what clap parsed: rewriting the arguments would need an arm per
entry-writing command, and the command added after it would be attributed
to the agent until somebody noticed. no_handler_decides_its_own_attribution
reads src for a handler naming an Attribution of its own, which the
compiler cannot catch because it compiles.
The same command typed in a shell is unchanged, which is what keeps a board
several agents write to saying which of them wrote what.
Also closes a code fence in the skill that e26e589 left open, duplicating
the mv --actor example under it.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
With the ticket suggested, the rest of the line was still typed blind. The
prompt now completes everything fish does: the verb and the verbs of a
group, the five statuses, the tags the board carries, the campaigns a
codename resolves against, and relate --clear's three kinds.
`ticket_argument` becomes `argument_at`, which answers what a position
names rather than whether it is a ticket. The tables say Ticket, Campaign
or Tag; clap says the rest, so the verbs, the statuses, `set --clear`'s
fields and the `completions` shells are never written down twice. Only
`relate --clear` needed a table of its own: the flag takes a kind and then
a target, so possible values on it would refuse every target.
The row draws the longest opening every candidate agrees on, which is
exactly what the next tab takes. One rule for one candidate and for many: a
ticket position has only the selected card, so the rest of its id is drawn
as before; the five statuses agree on nothing, so nothing is drawn and tab
steps through them one press at a time.
The walk holds the line as it stood before the first press, not the list
and not the candidate the last press chose, so every press re-derives the
candidates and stepping cannot narrow them to what it just typed. Every
edit ends it, beside `refused` and for the same reason.
193f9be is not inherited: `tags set` is offered only the tags the
vocabulary declares, and `tags add` and both `--tags` that take the whole
list are offered nothing.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
The reader has the ticket selected, which is the whole reason to type a
command on the board rather than in a shell, so where the line is naming a
ticket the selected card's short id is drawn after the cursor in grey and
tab takes it into the line.
Where a ticket goes is completions.rs's answer, through a new
`ticket_argument` over the three tables the fish half is generated from. A
copy of the positions on the board would go wrong the next time a command
grew a ticket argument, and silently, since the tests guarding the first
copy would not read the second.
TICKET_FLAGS holds (command, flag) pairs now, the shape TAG_FLAGS already
had, and the `chown --clear` rule the fish block wrote out by hand is
generated from it. Only chown's --clear names a ticket: relate's takes a
kind and set's a field, and the flag alone cannot tell the three apart.
The suggestion is derived on every call rather than held on the Prompt, so
what the row draws and what tab takes are one answer, and it is offered
only with the cursor at the end of the line, while a card is selected, and
while the id still starts with what is typed.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
check_blockers reported a blocker the board does not hold with eprintln!,
the one print site fa5662a left behind: a helper had no sink to reach, and
what it wrote was stderr rather than stdout. Harmless while main was the
only caller, and since 53ffb94 the command prompt runs the same handlers,
where stderr is the alternate screen with the columns on it. ratatui does
not repaint a cell it believes is unchanged, so the fragment stayed until
something else redrew them.
Sink carries two writers instead of one, because the CLI's two streams are
two: Sink::std hands the answer to stdout and an aside to stderr, so a
shell reads the same line on the same stream, and the integration test now
asserts that stderr whole rather than searching it. Sink::buffer holds its
warnings instead, and Board::run reads them back with Sink::warnings and
puts them above the answer on both outcomes -- a mv that warns about a
dangling blocker and is then refused by a real one wrote the aside first,
and it says why the refusal names one blocker and the ticket records two.
check_blockers and check_dependents both take the sink now, so their
refusals take the colour from it as well, rather than asking the process
about a stdout the board is not writing to.
no_handler_or_helper_reaches_a_print_macro walks src for the next print
site, each file cut at its own test module, since the rule is about every
future site rather than the one that broke.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
check_blockers refused every move while a blocked by target was still open, so a
dependent sat in backlog until its blocker landed even when the blocker was in
reviewing and its code was there to build on. The way out was -f, which also waives
the backward and skipping guard, on every move for as long as the pair existed.
The rule is now the columns: a ticket may stand level with what it waits on but never
ahead of it, so a blocker in reviewing lets the dependent be committed and reviewed
and gates only done. util::blocks_move is the one place it is decided, taking the
status moved into and the blocker's own, and mv passes the target through. A finished
blocker still holds up nothing, answered through is_open, and a target of discarded
is answered by name rather than by its place in Status::ALL, where it sits last.
The refusal now names the status moved into and only the blockers still behind it: a
dependent told to wait for work already ahead of it has nothing to act on. The board
asks the same function about the column one stage ahead, so the blocked mark means the
card cannot advance rather than that a dependency was ever recorded, which also takes
it off cards in the two terminal columns.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
The backlog was the one column priority governed alone, which sat a p1
nobody had promised above a p3 due tomorrow. It has no entry stamp, so it
now takes the due date as the date `by_status_order` keys on: soonest
first, undated below every dated one, and priority then title as the
tiebreak, which is still the whole order among the undated ones.
`TicketItem::due_key` is where a due becomes an orderable date. Only a
plain `YYYY-MM-DD` counts, which is all `--due` has accepted since
daa0e79, with `due_date` cutting a legacy datetime back to its date.
Free text answers `None` and sinks with the unset ones rather than
sorting on its spelling: a due nobody can place on a calendar is
unknown, the same reading a missing stamp already gets.
The comparator stays the single function keyed on `Status`, so `ls`,
`ls --ids`, the board's columns and `campaign::members` move together.
The All tab keeps `by_priority_then_title`: that merge spans statuses,
so no single date governs it.
`ls_listed_tickets_sorted_alphabetically` gave its three tickets three
different due dates while asserting title order. They share one now, so
the case still tests the tiebreak it names rather than the new order.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
AGENTS.md pins `cargo fmt --check` and `cargo clippy --all-targets` as
clean, and 83d31cd is what happens when only memory enforces that: fmt
drifted to about 160 places across every file with the tool installed and
configured by default the whole time.
The decision the ticket wanted, taken: mechanise it, as one command. Not
CI, which a single-author tool with no pipeline anywhere does not want,
and not a hook, which is a per-clone opt-in the way `blame.ignoreRevsFile`
is and so cannot be relied on either. What was missing was never a
mechanism, it was one name to type: "remember to run fmt, clippy and the
tests" becomes `make check`.
Cheapest first, so a formatting slip is reported in a second rather than
after the suite. `-D warnings` is what turns clippy's opinion into an exit
code, since a warning printed into a wall of cargo output is unread rather
than clean. Verified each gate fails on its own: a misformatted function
and a `&Vec<u8>` parameter each exit 2 before the tests run.
Completions are inside `cargo test` rather than a target of their own.
d93eca6 put the check that loads the generated script into a real fish
there, so "check tests, check completions" is already one command, and a
second target would be a second thing to remember, which is the problem
this is solving.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
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>