• (8556048) Take a relation off with relate --clear, and bump to 0.32.0

    Ghost released this 2026-08-25 10:13:37 +00:00 | 41 commits to master since this release

    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

    Downloads