fix(task-board): every lane decision goes through the board, not a literal

[viktormarinho]

Finishes the mirrored-board arc. #6771 named the lanes, #6774 made sprint
two-way, #6778 made the status push work. This is the part that decides where
a card goes — and it was still spelling out Studio's own column names.

The problem

Roughly fifteen places asked or answered "which lane is this card in?" by
comparing against in_progress / in_review / todo. On a board mirrored from
a tracker the columns are called whatever that tracker calls them. Every one of
those comparisons missed — silently, because a predicate that matches nothing
looks exactly like a predicate with nothing to do.

The writers were the visible half: an agent picking up a card moved it to
in_progress, a column that does not exist there, so the card left the board.

The readers were worse:

fence	gates on	consequence on a mirrored board
claimConflictResolution	status = 'in_review'	automatic conflict resolution never claims; the caller reads it as losing a race
claimUnassignedForSuperAgent	status = 'todo'	the Jira auto-delegate never fires
openReviewCycleIfInProgress	status = 'in_progress'	the review cycle never opens

The shape

BoardHandler grows lanes(), answering all five at once. Together rather than
one method each for two reasons: it is one read instead of five, and the storage
layer needs them as values — its fences are SQL predicates, so "which column
means in-progress" has to be answered before the query is built, not asked from
inside it.

StudioBoardHandler returns exactly the literals that were spelled out at those
call sites. That is what makes this a no-op for every org that never opted into
mirroring, and there is a test asserting it, because it is the whole safety
argument.

boardForDb builds the same handler from a database handle, for the projector
wiring and the sweeper. Without it those callers would have to be told which
columns mean what, and one that forgot would put Studio's vocabulary back on
someone else's board.

Three judgement calls

intake is the leftmost column, not a role. A card has to be born
somewhere, and making that configurable would turn "create a card" into a setup
step. Every other lane is nullable, and null means the same thing throughout:
this board has no column that means this, so nothing happens.

The cross-org sweeper query keeps a lane predicate. It cannot take a
resolved lane — each row may belong to a different board — so its pre-filter
reads the same task_board_columns rows the handler reads. It is a superset;
inReviewPhase in the loop body, which now takes the board's review column, is
the authority.

todo and in_progress become assignable column roles, end to end. Without
them the board cannot be configured for any of this.

A bug this found in #6778, already merged

tracker_statuses is jsonb, and pg serialises a JS array as a Postgres ARRAY
literal. A populated one is rejected outright; an empty one is accepted as
{} — an empty OBJECT. The silent half is the dangerous one, and it only
surfaced when the new tests ran against real Postgres. Fixed, with a test that
asserts the shape read back rather than the value written.

Two robustness fixes the tests forced out

handTaskToHuman now parks best-effort. Parking needs to know the board, and a
card must still reach a person when that read fails — I had widened the failure
surface without noticing.

reactToFailedTaskRun and advanceTasksToReviewOnThreadFinish take lanes
rather than a database handle. Passing a handle made a pure-ish reaction
impossible to test without a database, which a unit test caught immediately.

Verification

Started a standalone Postgres and ran the storage and task-board suites against
it: 854 tests, 0 failures. That is what surfaced the jsonb bug.

check, lint, fmt, knip clean.

Not converted

The archive and merged-tag sweeps. Both are cross-org and would need the same
role join as the review sweeper's pre-filter, and neither is on the
execute-a-task path this arc exists to unblock.

Also noted while here: advanceToReviewIfInProgress has no caller outside its
own definition and an integration test. knip does not flag class methods, so
it has been dead for a while.

---

Summary by cubic

Routes task-board lane decisions through BoardHandler instead of hardcoded Studio column names, so mirrored tracker boards now move and gate cards using their configured columns. Boards missing required roles skip affected automation, or reject explicit conflict resolution, with an actionable warning logged once per org and role.

Refactors

• lanes() resolves intake, queue, progress, review, and archive in one read while canonical boards keep their existing values.
• Mirrored boards use the leftmost column for intake; todo and in_progress are now assignable roles in Jira settings.
• Database-backed callers and the review sweeper resolve lanes per organization; archive and merged-tag sweeps still use literals.
• boardCan distinguishes missing-role no-ops from lost races without repeating warnings.

Bug Fixes

• Conflict failures restore the board’s actual review lane instead of writing undefined and stranding the card.
• tracker_statuses now round-trips JSONB arrays correctly, including empty arrays.
• handTaskToHuman still hands a card to a person when parking cannot read the board.
• Verified with 854 storage and task-board tests against Postgres, with 0 failures.

^{Written for commit e12cf64. Summary will update on new commits.}