The board is one list of tasks and one chat. The header on top says whose tasks show, and the filter row under it how many stand in each status. The list sorts the tasks by what they need from you. The chat at the bottom talks to the Coordinator, or to the selected task's agent.
herdr-projects proj · PRJ
All 48 Coordinators 4 Needs you 3 Working 2 Ready 1 To do 12 Done 30 Automations 0
○ ▾ vm-str 1 project · 48 tasks 5m ago
▾ needs you
! HSW-98 Add an undo for clear R#2 PR#18 12m ago
Review failed · 1 critical, 1 major
▾ ready to approve
◆ HSW-99 Max length for task titles R#3 PR#60 2m ago
Pass · 1 minor
▾ working
◐ HSW-134 Tidy the first-run questions ███░░░░░ 40% 12m left R#1 PR#17 5m
Running the tests
▾ to do
○ HSW-9 Rename the hint line 2h ago
╭─ vm-str ─────────────────────────────────────────────────────────────────────────────────╮
│ Added proj/4: Add an undo. An agent is on it. │
│ │
│ ❯ Send message to vm-str's coordinator │
╰────────────────────────────────────────────────────────────────────────────────────────────╯
alt+c hide the latest message · ? all keys
↑↓select a task.Alt+Ogoes into its agent.Spacetalks to its agent instead of the Coordinator.Tabshows the next filter: only the tasks that need you, those at work, and so on (below).- Type and press
Enterto send. The Coordinator decides what to start: ask it to in your words.Ctrl+Sputs an agent on the selected task. Alt+Pshows the task panel beside the list.?lists every key (keys).
One line: the board's name and the repo new tasks go to (herdr-projects proj · PRJ), with no folder path. Whose
board shows and how many tasks stand in each group are on the filter row under it.
- In the archive it says how many tasks are archived (
archive · 7 archived), and there is no filter row. - A find (
Ctrl+F) has a line of its own under the filter row, in the accent colour, saying what it is, how many tasks match, and the key that clears it:filter "import" · 1 of 33 · esc clears. With nothing found, the list saysNothing matches "zzz".
vm-str │ All 420 Coordinators 12 Needs you 0 Working 1 Ready 0 To do 4 Done 415 Automations 2 Pinned 3,
each filter with its count, as in an agents command center, with plain room between them. The one shown is lit in its own colour, the one its rows and marks have: Needs you red,
Working amber, Ready green, Coordinators the accent, Automations the automations' colour, the others plain, with
a cell of the highlight on each side; every filter keeps that room, so the row does not move when another is lit. The
others are greyed, a count of tasks that need you in red.
Whose board comes first, wherever there is another machine: All machines (plain), or the one machine shown (lit, as the filter shown is), in the base colour with no caret (in yellow
while it does not answer). Alt+M goes round: all machines, then each machine by itself in the order of Herdr's
sidebar (other machines); a click on it does the same. Every count is the machine's shown.
| Filter | The list shows |
|---|---|
All |
every task in its group and the automations, as always |
Coordinators |
only the coordinators that run (started and not stopped: working, idle, needs you; on autopilot; or failed, so you can fix it): each such machine's row and project's row (machine and project coordinators). A stopped or never started one is not there, nor in the count; its row stays in the other filters, with no mark. The main Coordinator has no row |
Needs you, Working, Ready, To do |
only the tasks of that group (Ready is ready to approve) |
Done |
every done task, which the other filters hide |
Automations |
only the automations' rows, in their places |
Pinned |
only what you pinned, in its places: a pinned task, a pinned project with its tasks, a pinned machine with its projects and tasks (pins). Its count is each pin once: the pinned machines, projects and tasks, not the other rows under them |
Tabshows the next filter,Shift+Tabthe one before, round and round. A click on one shows it. The filter shown is kept with the board's view. Each filter keeps the grouping (Alt+S) and the headings of what it shows; a machine or a repo with nothing that matches has none.- A machine's row and a project's row are their coordinator's, read as a task's row: the same marks (
○idle,◐working,?asks you,✗could not start), the time on the right, what it does or asks under it; on autopilot,[autopilot]after its name and what autopilot does under it. The top row isAll machinesor the one machine shown. The list reads all machines → machine → project → task by how far in each row stands.Spacetalks to it,Alt+Ogoes into it,Enter(or←→) folds and unfolds it,Ctrl+S/Ctrl+Xstart and stop it,Ctrl+Ois its autopilot (machine and project coordinators). - Where the window is narrow the names are shorter (
Coords,Needs,Autos), then shortest (Co,Need,Work), then the filters with nothing in them go; narrower still, only the one shown stands, withtab next.
Alt+S groups the list one way after the other: by status (the five groups below), by repo (each repo under its
row, its project coordinator's), by machine (each machine under its row, its machine coordinator's, its tasks under
it by how much they need you, with no status headings), and by status again.
Tasks stand in five groups, in the order they need you:
| Group | Holds |
|---|---|
needs you |
a question, something that went wrong, a merge that failed, finished work whose review failed |
ready to approve |
finished work that passed its review (or had none) and waits for your yes |
working |
an agent or the reviewer is on it |
to do |
nobody has started it |
done |
finished, newest first |
- First what waits for you, then what is being worked on (the agent, the reviewer, the board's check), then to do, then done. Done is history, so it is last: however long it grows, it never pushes the to-dos down.
- A pinned task (or project, or machine) stays where it is, with a yellow pin mark
★after its name; thePinnedfilter shows only what is pinned (pins). - Grouped by repo or by machine (
Alt+S), each repo's or machine's rows follow the same order, so a repo's done rows are below its to-dos. - No done task shows, a pinned or a selected one neither. One line where they would stand counts them
(
↓ 73 done (alt+d shows them)), andAlt+Dshows them all. With none done, there is no such line. A project whose tasks are all done shows its heading and that line. The selection on a done task that goes out of view (Alt+Dagain) goes to the heading it stood under; while you talk to its agent or read it whole, it stays. - Moving:
↑and↓follow the order shown;PgUpandPgDngo ten tasks at a time. Changing the grouping keeps the selected task selected. - Headings: the arrows stop on them too, and
Enteron one folds it to one line, and unfolds it. With every machine shown, each machine has a heading of its own: list headings. - The archive (
Alt+A) is a list of its own, newest first, outside this order.Ctrl+Aarchives the selected task, and restores it there. Archiving closes the task's own space (its agent ends) and frees its temporary files; its worktree, branch and history stay. Restoring starts nothing.- A whole project: archiving a project, below.
- A repo's done tasks in one go, from the shell: when a round of work is over, its done tasks are clutter.
herdr-projects archive --done --repo mstars(Archived 50 done tasks of mstars. Left out: 1 done but pinned, 2 working.) archives every done task of that repo; without--repo, every repo's. A task that works, waits, is to do or is pinned stays. Each goes as one archive does: its space closes, its worktree stays. - Done tasks by themselves, once they have been done for
archive.doneAfter(none, the built-in value: never).herdr-projects set archive.doneAfter 3darchives a task three days after it was done (or after you restored it), with no key pressed;--reposets it for one repo,--taskfor one task (settings). It takes whatarchive --donetakes, each as one archive does. A done task waits while its clean-up is still to come or its space is in use (a command of yours, its agent at work), and goes once that is over. The housekeeping pass does it, about once a minute, whether the board is open or not. Its space is closed first, by the pass of the herdr session it is in, and only then is the task archived: a space herdr does not close keeps it for the next pass, and a task you pin meanwhile stays.
- Automations are a group of their own after the task groups, inside their machine's part of the list (by repo: under their repo) (below).
A project you are done with for now leaves the board whole, and comes back as it was.
Ctrl+Aon a project's row (a repo's heading, grouped by repo,Alt+S) archives the project with every task of it. When one of them works, waits or is to do, it asks first and says what happens to them:Archive mstars and its 6 tasks?1 working, 1 waiting and 4 done: all 6 go to the archive with it, as they are, and come back with it; an agent on one stops.With only done tasks (or none), it goes at once. A merge under way holds it up: the key says which task merges.- What goes: its row and its tasks leave the board (each archived as one task is: its space closes, its worktree
stays), an agent at work or waiting for you is stopped first, its project coordinator stops (its autopilot goes
off), and its automations are turned off. An empty repo used lately no longer keeps a row for it. A new task in it
is refused (
mstars is archived. herdr-projects restore --repo mstars brings it back, with its tasks.), and so is a message to its coordinator. - Nothing is deleted: not its folder, its worktrees, its branches, its pull requests, its settings or its tasks.
- In the archive (
Alt+A) it has its own heading, with the tasks archived with it under it, whatever the grouping; the header counts it (archive · 1 project, 8 archived).Ctrl+Aon that heading restores it at once: every task archived with it comes back as it was (to do is to do again, done is done; one that was stopped stays stopped until you start it), and its automations are on again. Its coordinator starts with your next message to it, as a stopped one does. A task you had archived on its own before stays in the archive. - Another machine's project goes the same way, from the board on every machine (
Alt+M):Ctrl+Aon its row asks that machine to archive it, and that machine does it itself, so its coordinator stops and its automations go off there. The question is the same (Archive autopilot-tictactoe and its 3 tasks on vm-str?), worked out from that machine's tasks as the board last read them; that machine reads them again before it acts, and refuses one that changed in a way that would have changed the question (a task of it works now where the board asked nothing, or it holds more tasks than the board counted):… changed on vm-str since your board read it: … Nothing was archived: look again, then archive it.In the archive its heading stands under its machine, andCtrl+Athere restores it. A machine that cannot be reached changes nothing, and the board says so (vm-str did not answer: …); one on an older version says to update it there first. - From the shell:
herdr-projects archive --repo mstars(Archived mstars and its 6 tasks. Stopped first: MST-4.) andherdr-projects restore --repo mstars(Restored mstars and its 6 tasks.). They do not ask.--on vm-strdoes it on another machine (vm-str: Archived autopilot-tictactoe and its 3 tasks.), asadd --onadds a task there. - The web board does the same: select the project's row, then Archive among its coordinator's buttons (Open) or in More…; in the archive its row, selected, has Restore this project under it. Another machine's projects too.
A list longer than its room keeps its last line to say how many tasks are not on screen, folded ones included:
↓ 11 more, and ↑ 4 more once you have scrolled. Automations that do not show are counted apart, by name:
↓ 3 more, 2 automations, ↓ 7 automations, ↑ 4 more, 1 automation. A heading never stands alone at the bottom of
the screen with nothing under it. (A list of fewer than eight lines keeps every line for tasks.)
- The done rows take no room: the list shows none of them, only the line that counts them (see above).
- The to-dos give way, from the last one up, down to the first, with a line under them that counts the rest
(
… 4 more to do).
So the live tasks, the ones that need your eye, stay on screen, also on a phone where each takes three to five lines.
- Nothing is folded away while you search or have asked for all done; the selected to-do never gives way.
- A to-do that gave way is still one
↓away: the arrows go through every to-do, and the ones that show are then those that end at the selected task. - To-dos give way only on a list that has live tasks. With none, the list just scrolls, with no line spent on a count.
- Only when the list is still too tall does it scroll, and then by whole rows: a row of more than one line is never shown in part. Its lines come into view together; where only some would fit at the bottom, those lines are left empty. (In a list squeezed to a single line, the selected task shows its name.)
Each state has a mark of its own, so no two are told apart by colour alone:
| Mark | Means |
|---|---|
◐ |
the agent is working |
◑ |
the reviewer is working |
◇ |
the board's own step |
◷ |
queued (a clock, in magenta): it waits for a free slot, or for the tasks it is tabbed to start after (one task after another) |
✗ |
went wrong |
◆ |
ready to approve |
✓ |
done |
○ |
to do |
The ? menu has the list too.
-
A machine's row and a project's row (and
All machines) carry their coordinator's state with these same marks:○idle (also never ran, or stopped),◐it works,?it asks you (!it wants your OK),✗it could not start. On autopilot it keeps that mark, with[autopilot]after its name. The others (◑ ◆ ✓ ◷ ◇) are never a coordinator's (machine and project coordinators). -
Only a moon says someone works:
◐and◑, an agent or its reviewer. -
Every mark is one column wide, and a character every monospace font has. The web board draws the same ones.
-
Herdr's
status_indicators = "dots"brings its dots back for working (the agent's and the reviewer's) and done. The board's◇, the◷of a wait for a slot, and what a waiting task needs keep their marks with dots too, since no dot means those.
A task that waits for you has not failed, so its mark is never a cross. It says what the task needs: the kind of the
terminal program-status spec (OSC 7501).
| Mark | It needs | Its State line |
|---|---|---|
? |
an answer: the agent asks something and waits | asks you |
! |
a yes or no: a permission dialog, a merge that did not go through | asks for your OK |
! |
your call on finished work whose last review failed: send the review back, or merge it anyway | review failed |
@ |
a sign-in: the agent's program is logged out | needs a login |
! |
you, and the board cannot tell for what (the kind is not known) | needs you |
✗ |
nothing of these: it went wrong | needs you |
- All of them are under
needs you, in its colour, red. With colour off (NO_COLOR), the mark alone tells a task that waits from one that went wrong. - Finished work that passed and waits for your yes is none of these: its mark is
◆, in green, underready to approve(an exclamation mark there would read as "something is wrong", and nothing is). - The words for where a task stands are one list (
crates/core/src/status_words.rs), which the rows, the State line, Herdr's sidebar and the web page all read. - The records the board writes to the terminal carry no mark: they name the state and the kind
(
state=blocked:kind=question), and the terminal draws its own.
A row reads: the mark, the task's tag, greyed (HSW-134: its repo's short key and its number,
task numbers and repo keys), the name, then on the right two groups with a wider gap between them:
the progress (the bar, the percent, the minutes left), and then the review, the pull request and the time.
needs you
! #98 Add an undo for clear R#2 PR#18 12m ago
Review failed · 1 critical, 1 major
ready to approve
◆ #99 Max length for task titles R#3 PR#60 2m ago
Pass · 1 minor
working
◐ #134 Tidy the first-run questions ███░░░░░ 40% 12m left R#1 PR#17 5m
Running the tests
done
✓ #76 Blue while the reviewer works R#1 PR#76 1h ago
R#2is the review the task is on, or the last one it had.PR#18is the pull request.- The minutes left say what they are (
25h left). The time after them is how long the task has worked;agois how long since it stopped. - A row never repeats what its heading says.
One cell between two things, and one wider gap of two cells, right of the progress. So the wider gap says where the progress ends, and no other gap competes with it.
- Each thing is a column down the whole list, as wide as its widest value in view and no wider. The percent is at least
three cells (
45%), so it does not move when9%turns10%. - The numbers end under each other, so the only other blank cells are before a shorter one:
5munder12m,R#1underR#12. - A pull request starts under the others, and a column a row has nothing for is left blank.
- The last line of a row on a narrow screen (below) follows the same rule.
Live is every task under needs you, ready to approve and working: an agent, the reviewer or the board's own check
is on it, or it waits for you.
- Line 1: the mark, the name and the columns.
- Line 2: what the task says, greyed, starting where the name starts. That is what it is doing now; or how its review
came out, with a short tally (
Pass · 2 minor,Review failed · 1 critical, 1 major, the result in its own colour); or what it waits for. While the reviewer works, it says only what the reviewer is doing. - Line 2 is in the brighter of the board's two greys, Herdr's
subtext0, because it must be read (the fainter one,overlay0, is for what may be missed: times, counts, tags). What a task asks of you (its question, the OK it wants, the login it needs: a?,!or@row) is in its mark's needs-you colour, Herdr'sred, so it stands out as the mark does; on the selected row too, and on the web board in its needs-you colour. - In the all-machines view the machine is the heading above its tasks, never in a row (list headings), so line 2 starts under the task's name as everywhere.
- Line 2 has the row's whole width, so it is rarely cut. One longer than the window is cut at its end with
…, never wrapped (on a narrow screen it wraps: below). - Line 2 is there from the start, so a row does not grow, and nothing under it moves, when its words arrive. It is
never empty and never a bare
…: a task with no words of its own says something true and quiet (Just started,Yours: no agent on itfor a task you marked as your own,Not reviewedfor finished work nobody reviewed, or the plain word for where it stands).
Done and to-do tasks keep one line, so that many of them show at once. (A to-do with a note says it after its name, on that one line.)
The highlight of the selected task covers all its lines. ↑ and ↓ go task by task, never onto a second line.
Each colour has one meaning. Amber: the agent is working. Blue: the reviewer is working. Green: it passed and is ready for you. Red: it failed, or it needs you. Grey: the board's own step, queued, or to do. Which colours are Herdr's and which the board's, and how the board follows Herdr's theme: colours.
- While the reviewer works, the row's mark, bar, percent, minutes left and
R#tag are blue, and so are the same things in the task panel, on the details screen and on the chat line. The mark says it without colour too: the half moon faces the other way,◑, and is the agent's◐again once the task goes back to its agent. - The board's own steps are no moon but a
◇: starting, setting up, running the check, pushing and merging, and the waits on the way: for the check's turn, for its turn to merge, and for GitHub's checks on its pull request (Waiting for GitHub checks · 2 of 3 passed). - A task waiting for a free slot has a clock,
◷, in a magenta no other state has (below). - An agent or reviewer whose turn was cut off, waiting to try again, keeps its moon: it is still the one on the task.
- So: a blue
◑with a bar is a running review, an amber◐the agent at work, a◇the board on it, a magenta◷waiting for its turn, and a green◆ready for your yes. - A group's heading keeps its group's colour: a task under review is filed under
working. - To do (its heading and its
○) is a dim grey of its own, never the plain text colour, and always readable: every grey on the board is held to a floor of contrast with the background.
The blue is the theme's own blue where that is told apart from everything it sits beside: the theme's green, red,
amber, the light blue of Herdr's own dot for done and idle (its teal), muted text, plain text and the background. In
many themes it is not (Dracula's blue is its teal, Rosé Pine's its green, Catppuccin's a pale one near its muted text):
there the board uses a blue of its own, #3b82f6, which reads on dark and light backgrounds alike. Colours you set
yourself ([theme.custom]) are held to the same rule: a blue that is your red, or no blue at all (a green, a purple, a
grey), is not used, and where the board's blue is too near one of your colours it takes another blue that is not. With
the terminal's own colours it is the terminal's blue.
R#2 belongs to the pull request, not to the progress: it sits one cell left of the PR#, and the tags end under
each other down the list. Its colour says how that review went, with no mark beside it:
- green: it passed;
- red: it failed, and it stays so while the agent fixes what the review found;
- blue: the reviewer is on it right now, whatever the review before it said.
The three are told apart in light and dark themes alike. A review from before the gate goes by its advice. Once the task
is merged (through its pull request, or here with none), the tag goes quiet, the same grey as its merged PR# tag:
nearly every done task passed its review, and a column of green says nothing. One stays red: a task merged although its
last review failed (you approved it anyway), the only one worth noticing later. The task panel, the details page and the
archive do the same. A task never reviewed has no tag. Every row that has had a review keeps it: under review, back with
the agent, waiting for your yes, done.
PR#18's colour says how its checks went, by the same rule and with no mark: green, they pass; red, they fail;
plain, no result yet (running, or none). A merged pull request goes quiet, grey like the time beside it, so a list of
done tasks is not a wall of green. The greens and reds are the theme's own, the ones the R# tag uses. The task panel and
the details page colour it the same way.
The time of a finished task is quiet like its merged tags, in the very same grey: a done task has nothing live about it, so its whole right-hand side (review tag, pull request, time) is quiet, and a bright colour on the board means "this is happening now". That grey is the theme's own for greyed-out words, made readable where the theme's is too near the background (colours). The time of a task that is not done is drawn as it always was.
At most board.agents agents work at once. A task started while every slot is taken waits its turn: its row has the
mark ◷ (a clock) in magenta, says Waiting for a free slot on its second line, and shows its place in the queue where a working
task has its percent: Q#1 gets the next free slot, Q#2 the one after.
working
◐ HSW-151 Rewrite the board in Rust on Ratatui █████░░░ 65% 3m 9m
Reading the list code
◷ HSW-152 Show automations in the main list Q#1 2m
Waiting for a free slot
◷ #153 Fix the footer Q#2 40s
Waiting for a free slot
- The order is the order the board starts them in: first to wait, first to start. When a slot frees,
Q#1starts and the others move up. A task's attempts each wait for a slot of their own and are counted the same way. - They stand last under
working, in that order, not under a heading of their own. You started them and they start by themselves, soworkingis where they belong. A heading of their own would hold one or two rows for a minute and move them under another heading each time a slot frees. Their mark, colour andQ#tell them from the tasks at work, and the order says which is next. (Grouped by repo there is no status heading: they stand among their repo's tasks.) - The same place is said everywhere: the task panel's State line (
◷ waiting for a free slot, Q#2),list(· waiting for a free slot, Q#2;--jsonhasqueue: 2),details(queue: { place, words }), the message when you start it, Herdr's sidebar (sidebar) and the web Board. - A narrow board keeps it too: there
Q#2stands with the time at the end of the row's second line, so a waiting task's row is two lines, not three.
At the finish line, and again after a catch-up with main, the row shows real progress, not the Watcher's guess: the bar and percent are the count the check reports, and the minutes left come from how long its last full runs took on this machine. How a check reports, and what a repo's own check can do: the check's progress.
◇ Add a greeting █████░░░ 65% 3m 9m
running the check · tests 31 of 47
◇ Fix the footer 6m 2m
waiting for its turn · 2 ahead
- Waiting its turn (one test run at a time on a machine): the row says how many are ahead and shows the minutes, with no bar, since nothing of its own moves yet.
- Code that passed already is answered at once:
the check already passed for this exact code, no bar, and on it goes. - A check that reports no count shows the time it has run against last time (
running the check · 2m of about 5m), and never a percent. - When nothing moves for far longer than a run takes, the row says so:
the check stands still · nothing finished for 13m · tests 31 of 47,waiting for its turn unusually long · …,the check runs far longer than usual · …. - Its colour is its own: the mark, bar, percent and minutes left are a plain light grey (the theme's
subtext0) while the board checks, so the agent's amber, the reviewer's blue and the board's grey read apart.
The same line, bar, percent and minutes show in the task panel, on the details page, on the chat line and in Herdr's sidebar, and the rows of a section still give the same things up together.
On the chat line, for the task whose agent you talk to, the bar, percent and minutes left stand right after the words, in the row's colour, while the board runs its check. They are never cut: when the line is short, the words are cut first (down to twenty cells), then the bar goes, then the numbers.
Rows hide the same things together. What is shown is decided for one group at a time (the rows under one heading:
working, done, …), never row by row: each thing is on every row of the group that has it, or on none. So if one name
under working leaves no room for a bar, no row under working has a bar. A long name under done costs working
nothing, and the columns still start at the same place down the whole list. (On a screen under 80 columns a live row's
columns are on its last line, below: what follows is then about the one-line rows, which have no time
there.)
Things give way in this order, first to last. The name wins over all of them:
- what one-line rows say after their name (a to-do's note): each is cut to its own room, and when one of them has not even 20 cells (or its whole length, when that is less), none of the group's rows says anything. A live task's words are on its second line and take no part in this;
- the bar;
- the word
ago, on the whole list at once, since it sits right of every column: it goes when that keeps a column other than a bar, or cuts a name less, somewhere on the list; - the end of a name longer than 40 cells: cut with
…, down to 40, before its group loses a column; - the percent and the minutes left, together;
- the
R#tag and the pull request, together: a review is never shown without its pull request, nor the other way round; - the time;
- the task's number, on the whole list at once, so the names stay in one column: it goes when it would leave a row's name fewer than 16 cells with nothing else beside it;
- the rest of the name.
- Step 4 is why one long title does not cost a whole group its columns. A title is at most 60 characters (titles), so it loses a third at the very most, and a name of 40 cells or fewer is never cut while a column shows. A name is never cut for a bar.
- With a live task's words on a line of their own, its name is alone beside the columns, so they fit far more often. From 110 columns on, every live row has all of them, the bar too, whatever its name. (Before, a bar needed a short name or a much wider window, and what the row said was nearly always cut.) The order above was looked at again with that in mind and is unchanged: the bar is still what a row can best do without, since the percent beside it says the same.
- Nothing jumps as the numbers tick. The minutes left are counted at their widest, four cells, when this is decided,
so
9mturning into10mhides nothing. They are never wider: from a thousand minutes on, a row shows hours (17h). A name is drawn in the room counted that way too, so it is not cut at another place from one minute to the next.
Under 80 columns, a live task's row is three lines. On a phone (about 50 columns) the name leaves no room beside it, so the bar, percent, minutes left, review tag and pull request used to be hidden. Now they have a line of their own, the last of the row:
working
◐ Third row line on narrow screens for progress
Writing the tests for the third line
██████████████░░░░░░░░ 35% 14m left 9m
◐ Show progress while the board runs the check
Reviewing progress display fix against earli…
█████████░░░░░░░ 62% 4m left R#2 PR#82 38m
◐ Grey out review tag and time once merged
Just started 20s
- Line 1: the mark and the name, with the whole width.
- Line 2: what the task says, as on a wide screen.
- The last line: the bar, the percent, the minutes left, the
R#tag, the pull request and the time, in that order and in their usual colours. It starts where the title starts (right of the mark and the tasks' numbers, so a row has one left edge) and ends at the right edge. Each is as wide as the widest of its kind on the list, so they start under each other on every live row, and the bar takes all the room left: every bar is the same length, and the line fills the width. The time ends at the edge, with or withoutago. - A task with nothing for that line but a time (no progress, no review, no pull request) has no such line: its time stands at the end of what it says, and the row is two lines. So a screen of rows that need you is not half made of lines that hold one time.
- Done and to-do rows stay one line.
Long rows wrap instead of being cut. A phone has about 45 cells for a name, and a name cut there with … often does
not say which task it is. So under 80 columns:
working
◐ Research capy.ai and other coding agents for
ideas we could use on the board
Researching coding agents and harnesses for
ideas, reading their docs and changelogs one …
█░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 3% 34s
to do
○ Check herdr-projects /autoproject for ideas w…
○ Bring the board to herdr's web UI
○ Rethink how the Coordinator works, restarts
and remembers what it was told before
- A live task's name takes up to two lines, and so does what it says. Each is cut with
…only after its second line. What fits one line takes one: a row is three lines at least and five at most, with the line of the bar and the time always last. - The selected task shows its whole name, on as many lines as it needs, whichever group it is in (the third to-do above). It gives up the tags beside its name for that. Move on, and it is one line again.
- Done and to-do rows stay one line, without their time (
5h): the name has that room, and the tags (R#,PR#) still show where there is room beside it. A task's time is in its panel. - Wrapped lines start under the name, never under the mark, so the marks stay a column of their own. In the all-machines view a name that wraps has the line to itself, without the machine's name before it; and what a task says starts under the machine's name when a long one would leave it fewer than 20 cells a line.
- No limit on how long a name or a sentence may be has changed: this is only how they are drawn.
- The highlight covers every line of the selected row, the arrows still go task by task, and the list counts each row at the height it has: what gives way in a list taller than the window, and the scroll, work as above.
From 80 columns on, nothing wraps and every row is as it was.
Why 80 columns. At 80, a name of 40 cells (what a name keeps before a column goes) sits beside every column at its
widest: the mark (3), the name (40), the bar (8), the percent (4, 100%), the minutes left (4), R#12 (4), PR#123 (6),
the time (3) and the gaps between them (8). Narrower than that, line 1 always goes without something, so the columns
move down. It is the screen's width that is counted, never the names or numbers on it: all live rows switch together, and
no row gets or loses that line when a task is renamed or gets a pull request. And it is the whole screen, not the list: a
list made narrow by the task panel beside it, on a wide screen, keeps two-line rows (the panel shows the rest).
Very narrow (under 38 columns, with every column there): the word ago goes first, then the bar, the R# tag with
the pull request, and the percent with the minutes left. The time stays.
It has a mark. Every line of it starts with a bar in the gutter (▌), in every list (tasks and automations, the
archive, the settings page, the ? menu), on the theme's own tint. Where no background can be painted (NO_COLOR, or a
theme with none for it), the row is in inverse video instead, so which task the keys act on never depends on colour. A
click on a row selects it (the mouse).
The selection stays where you were working. When an action (put an agent on it, say yes, send it back, stop, pin, archive) moves the selected task to another group, elsewhere in the list or out of it, the selection does not follow:
- it goes to the next task below in the same group, or the one above when the task was the last there;
- when the group is left empty, to the next group's first task (its heading, when that group is folded), else to the group above.
So you go through tasks one after another without arrowing back.
- A folded group a task moves into stays folded.
- Under a filter, it is the next task that matches. Grouped by repo, the same holds inside the repo.
- When the task leaves the list (archived), the message says which task the selection is on now.
- An action that does not move the task leaves the selection on it.
- With the task open whole (the panel), while you talk to its agent, or while you are in its agent, the selection stays on that task.
The automations are a group of their own, under the heading automations, after the task groups: each machine's in
its own part of the list, as its tasks are, and they fold as any group does. Grouped by repo, each stands under its
repo's heading, after that repo's tasks (automations). With none, there is no heading. The heading and each row's mark are in a colour of their own, a purple
no status has (colours). One row per automation, in the list's own columns, drawn by the code that draws
a task's row:
▾ to do
○ HSW-2 Write the changelog 1d ago
○ HSW-1 Fix the footer on the pricing page 3h ago
▾ automations
⟳ on Look for old dependencies every 2h ✓ HSW-4 next in 4m
⟳ on Release note after a merge when a task is merged, in every repo skipped 5h ago
⟳ off Nightly audit daily 03:00 never fired
it fired 30 times in an hour
| Where a task's row has | An automation's row has |
|---|---|
| its mark | ⟳ (U+27F3), in the automations' colour while it is on and the same one dimmed while it is off: an arrow going round, where every task's mark is round, a diamond or a sign |
its tag (HSW-12) |
the word on or off, in the same grey. It fills the numbers' column, so every name starts where the titles start |
| its title | its name, plain as a to-do's title; greyed while it is off |
| what it says, after the title | its trigger in plain words (every 2h, when a task is merged, in every repo), in the same grey; then its repo when that is not the one the board shows (and not the heading it stands under). Never its machine: the heading above names that |
| its review tag and pull request | the task its last firing made, by that task's own mark and number (✓ HSW-4: done; ◐ HSW-7: an agent is on it), and the word that goes with the time (next in, fired, skipped) |
| its time | how long until it fires (4m), or how long ago it last did (2h ago), in the list's time column, under the tasks' times. never fired stands there for one that never did |
| a second line, for a live task | a second line only when it has something to say: why the board turned it off. Where the trigger has no room beside the names it stands there too, on every row of the group at once |
What gives way when room is short works as on a task's row, by the same code (the order is under when the window is narrow): what the row says (to the line under the name, never cut: half a trigger is no trigger), then the part of a long name past 40 cells, the last task, the firing, the numbers' column, then the rest of the name.
- Where the numbers' column goes, the word
onoroffgoes with it, so every name still starts where the titles start. It then becomes the first word of what the row says (on · every 2h): on or off is a word at every width, never colour alone. - Under 80 columns a row is its name, with the trigger under it and the firing at the end of that line, as a live task's
row has its time there. A long name wraps on the selected row and is cut with
…on the others. - The selected row has the same bar and tint, a click selects it, and
↓ 3 automationssays how many do not fit.
Not on the row, so it stays as calm as a task's: the prompt, the settings, the folder, the list of firings and why
one was skipped, the hour a schedule is next due, and how many times it fired (only the last 200 firings are kept, and 20
are sent from another machine, so a count would not be true). All of that is in the automation, whole (Enter).
↑and↓go from the last task on to their heading, then to them. On such a row no task is selected, so the keys that act on a task do nothing, and the row has keys of its own (open it, turn it on or off, fire it now, remove it, its settings), which the hint line shows: automations.- One that is off is drawn as quietly as a done task: its mark dimmed, its words greyed.
- Find (
Ctrl+F) matches them too, by name, trigger or repo. The archive has none. - No task gives way for them: where the list is longer than its room, the tasks fold as they always do, and the automations scroll with the rest.
One chat, at the bottom. It is the same chat whoever you talk to. It always talks to someone, and always says who.
- The Coordinator, until
Space(on an empty text box) flips it to the selected task's agent.Spaceagain flips it back. Ask it something, tell it to do something, or just say what needs doing. - The arrows only move the selection; they never change who you talk to. While you talk to a task's agent, the chat follows the selection: move to another task and you talk to that task's agent, with its latest message shown.
- A task with no agent to talk to is still named, with where your message goes instead: it starts an agent on a task
that is to do; it goes to the top row's coordinator about that task otherwise (
no agent on it: your message goes to vm-str's coordinator, about this task). An archived task is read-only. - With no task selected (words on their way to another machine, an empty list), the chat names the Coordinator until a task is selected again.
- If the task you talk to goes away (removed), you are back with the top row's coordinator, never on a neighbour's agent.
- On a machine's or a project's row,
Spacetalks to that machine's or that project's own coordinator (machine and project coordinators). - Type
/to pick one of their skills or commands from a list over the box (skills in the chat).
It looks the same for a coordinator and for a task's agent, at every window width:
╭─ All machines › vm-str ─────────────────────────────────────────────── alt+k more ↑ ─╮
│ Added proj/4: Add an undo. An agent is on it. │
│ │
│ ❯ Send message to vm-str's coordinator │
╰────────────────────────────────────────────────────────────────────────────────────────────╯
alt+c hide the latest message · ? all keys
- Its top edge names who you talk to: a ladder from the top row down (
All machines › vm-str › gtm › GTM-14), the current step lit, and after it, dimmed, the kind of agent (· Agent,· Reviewer,· Project coordinator,· Machine coordinator), and the edge in the status colour of whoever it talks to (colours) (machine and project coordinators). One that never ran invites a first message.- One thing gets a greyed line of its own above the box: a default that changed while a coordinator runs, with the command that starts a new one on it.
- One rounded box, with room to breathe: an empty line under its top edge and over its bottom one, and two cells
left and right of the text (one in a narrow box; no empty lines where the window is short). In it the newest thing
said in that conversation. No label on either side: what you wrote is in the
bright colour you type in, what the one the box talks to said in grey (its edge names it). Only someone else is
named: a reviewer under
Reviewer:, a wake underAutopilot:, the board underBoard:. Then an empty line; then the line you type on (the prompt is only❯).- A picture you paste stands on it as
[Image 1], not as its path; what is sent has the path (pictures pasted). - While that line is empty, it says in grey who gets your message, by the name of their tab:
Send message to Coordinator, orSend message to Agent. Nothing else is in it. - The box's frame and its
❯say it by colour too: the plain text colour for the Coordinator, the task's status colour for its agent (colours). - It grows with a long message, up to two thirds of the window, and shrinks back for a short one. The list above
gives up those rows and keeps the selected task in view. (Under the whole task,
Alt+T, and the?menu, which are there to be read themselves, the message keeps to a third of the window.) Alt+Chides the message and shows it again. With nothing else to step back from (a draft, find, the whole task, the filter, the archive),Eschides it too, before it does anything about closing the board. On the web boardEscdoes the same, while nothing is typed and find is closed.
- A picture you paste stands on it as
- One greyed hint line under the box, with only the keys that do something right now. While you type, it says what
the keys do with your words (
enter send to the Coordinator · shift+enter new line · esc put away). What each hint says, and what gives way in a narrow window: the hint line.
The box holds what the Coordinator, the agent or the reviewer said, and what was sent to it. Nothing of the program's own screen: no tool call or its output, no spinner, timing or token count, no tip, no input box, rule or footer, no start screen or logo.
- The board reads the words from the conversation the program itself saves (Claude Code, Codex and pi each keep one), not from its screen. So a new program version that draws its screen differently changes nothing here.
- Herdr's other programs, whose conversation the board does not read (agents), show the words on their
screen instead, under
Agent, on its screen now:, with what is drawn there (rules, boxes, a logo, a bar) left out by its shape. - Markdown reads as text: a list item's next lines stand under its words, code keeps its lines, and the marks of a headline, of bold and of a code block are left out.
- A command you typed to it (
/clear,/compact,/model…) shows as you typed it, and then in plain words what it did:Chat reset: a fresh session started.,Conversation compacted: …,Model switched to …. A stop shows asStopped: interrupted before it finished.The program's own markup for these (<command-name>,<local-command-stdout>…) never shows. - While it works and has said nothing new, its last words stay, and the line above the box says what it is doing now.
One that has said nothing yet says so:
The agent has just started: nothing to show yet. - A dialog that is only on its screen (a permission prompt, a question with choices) is said in a line of its own,
with the way to it:
The agent shows a dialog on its screen that waits for your answer: enter opens it.The Coordinator's is in Herdr'sCoordinatortab, a reviewer's in itsReviewer #2tab in the task's space. - Going into the agent (
Alt+O) is its real terminal, untouched.
From the moment the review starts until it ends, the box shows what the reviewer says (Reviewer:), kept fresh as it
goes, for every program a reviewer can be. Before it has said anything: The reviewer has just started: nothing to show yet.
A reviewer takes no messages (it judges the work as it is), so what you type still goes to the task's agent. The review
goes on while you chat, as it does when you type in the agent's own pane, and stops only when the agent changes the code
(chatting with a finished task). The
empty line says both: Send message to Agent: the review goes on unless the code changes. When the review ends, the chat
is the agent's again, and the review's result is where it always is: on the row and in the task panel.
What you just sent shows the moment you send it, with no label, in the bright text colour, where the agent's message was, over an empty line to type on. It stays until the answer comes; then the answer alone, with no label, in grey, for the Coordinator and a task's agent alike (also when it answers in the very same words as before). The old message is never shown under your words: it is above, with the rest of the conversation.
"The moment you send it" means before the words have reached anyone, whoever the chat talks to: the Coordinator, a
task's agent here or on another machine, a machine's or a repo's coordinator, another machine's Coordinator. Until
their own conversation has the words, the line over the box says so (Sending… for a task's agent, sending… for a
coordinator), and nothing else of them stands over the chat: a send to another machine has no row "on its way" over the
box, only one that failed, with why (nor do the ones you sent just before). Words that did not get there leave the box;
on this machine they go back to the line you type on. An earlier turn the agent ends while your words are still on
their way does not take them away. The web board's page draws them in its conversation as you send them, before the
board has answered it.
That holds also for words you send while the agent works: Claude Code queues them and they go in during its turn, and the board reads them there. For the Coordinator this holds when the board is closed and opened again; for a task's agent, for as long as the board stays open.
╭────────────────────────────────────────────────────────────────────────────────────────────╮
│ Agent: │
│ Made g. │
│ │
│ ❯ Send message to Agent │
╰────────────────────────────────────────────────────────────────────────────────────────────╯
The box opens on the newest thing said, and holds only that. What came before is above it:
Alt+Kopens the box to the conversation and scrolls up through it;Alt+Jscrolls down, half a box at a time (K and J, as up and down in vim).Alt+Jonce more from its end closes it to the newest message alone again, from its start.- That holds wherever the box was opened, whoever you talk to, and also after new messages came while it was open.
- The last dozen things said are there, as in a coordinator's chat: your words (typed in the box, with
tell, or in the agent's own pane) bright and its answers grey, with no label;Reviewer:for what a reviewer said,Coordinator:for what the Coordinator sent it, andBoard:for what the board sent on its own (its brief, a review's findings, the word to go on). A long text sent, such as a brief, shows only its beginning. - The mouse wheel does the same with the pointer over the chat (the mouse). Both work while you type, and neither touches the draft.
- The box says where there is more and names the key:
alt+k more ↑on its top edge,alt+j more ↓at the right of the line under the message (in a narrow window onlymore ↓, then only the arrow).
● Coordinator idle
╭───────────────────────────────────────────────────────────────────────────── alt+k more ↑ ─╮
│ 3. The check fails on main too: it is not this task's change. │
│ 4. I filed proj/7 for it and put an agent on it. │
│ alt+j more ↓ │
│ ❯ Send message to vm-str's coordinator │
╰────────────────────────────────────────────────────────────────────────────────────────────╯
- A new message starts at its beginning: an answer is read from its first line down, and one key goes on from there. Only a screen (for a program whose conversation cannot be read) starts at its end, where a terminal has what is new.
- Opened to the conversation, the chat stays open until you close it. Whatever happens meanwhile (the Coordinator at
work, a new message, the list read again, tasks changing), it stays on the lines you were reading, found again where
they moved as the oldest messages drop off (also in a reply said twice: the one you read). Scrolled to its end, it shows
each new message as it comes.
Alt+Kgoes further up with each press. It goes back to the newest message only when you take it there:Alt+Jonce more from its end, hiding the chat (Alt+C, or esc) and showing it again, or talking to another (the task's agent, another task's, back to the top row's coordinator). - A tall draft never takes the message away. In a window too small for both, the draft gives rows back and scrolls inside what it keeps, so three lines of the message stay, and they still scroll.
╭─ vm-str ─────────────────────────────────────────────────────────────────────────────────╮
│ ❯ Send message to vm-str's coordinator │
╰────────────────────────────────────────────────────────────────────────────────────────────╯
alt+c show the latest message · ? all keys
- One key shows and hides the message:
Alt+C(on an empty text box, likeAlt+Pfor the side panel), the same both ways and for the Coordinator and a task's agent alike. The hint line names it, and the board remembers your choice. - Hidden, there is only the box's edge that says who you talk to, and the line you type on: a message is never sent blind.
- Nothing else shows or hides it:
Escnever does. - A Coordinator that could not be started says why even while the message is hidden.
Alt+Cputs that error away too, until the next one. - The board with no coordinator (
coordinator.agent none) gets the plain line between two rules, whether the chat is hidden or not: what you type is added as a task. - The whole chat of a task's agent is its own pane:
Alt+Ogoes into it. - The text box and its hints are never pushed off the window: the message gives way first. In a very narrow window the box
stays whole: the message wraps inside it, and a placeholder that does not fit is cut with
….
The chat folds where its lines are needed elsewhere. On a page that is read (the whole task, the settings page, the
? menu), and in a window of fewer than 14 rows, the chat is its head line and the plain text box, as Alt+C folds it,
and is back when you return: the page, or the list, gets those lines. The whole task says what its agent said itself. A
start that failed still says why.
While the box holds text, the hint line under it says who gets it (enter send to HSW-34's agent,
enter send to the Coordinator, enter add it as a task), naming the task by its tag, also while the list is scrolled to
other tasks. The box's edge names no one. That does not change until the words are sent or put away: the arrows are the
draft's, the mouse wheel moves only the view of the list, and a click selects nothing. So an answer typed for one task's
agent can never be sent to another's.
While the text box holds text, it owns the keyboard: only Enter, Ctrl+S, Esc and Ctrl+C act on the board, so no
shortcut fires in the middle of a draft.
Escputs a draft away.Ctrl+Zbrings it back only to whoever it was for, so a reply stays a reply.- It never changes who you talk to. When the chat names somebody else, it says who the words were for (the Coordinator:
Spacegoes back to it; a task's agent: select that task, andSpaceif you talk to the Coordinator), and the words stay put away until you are there.
Going into an agent never ends the board. Alt+O on a task moves Herdr to that agent's real pane:
from the row, with the chat hidden, or while the chat talks to that agent. The board keeps running.
- Come back to it, or press the board key, and it is as you left it: the same repo, the same task selected, the same filter and draft.
- While you are away, the selection stays on that task, also when its agent stops or finishes and the task moves to another group or no longer matches your search (its row stays until you move on).
- Outside a Herdr client (plain SSH), the terminal becomes the agent's until you detach, and then the board is back.
The key opens the board in a Herdr tab of its own, named board, in the space you are in. From then on it goes to
that running board from anywhere, instead of opening a second one.
- A board you started yourself in a pane (
herdr-projectstyped there) is found the same way. The key puts the keyboard on it, also when an agent's pane is split beside it in the same tab. - Pressed on the board itself, the key takes you back to the pane you came from: a way there and a way back. When that pane is closed, or you started the board by hand, the board says on its message line that it is the board already.
- Closing the board (
Ctrl+Ctwice) closes its tab. The Coordinator keeps running, and the line that asks for the secondCtrl+Csays so while it runs: it is not this board's but the machine's, the same one the popup, the web board andcoordinator telltalk to, and it may be at work on what you asked.herdr-projects coordinator stopends it (the Coordinator).
A board you start with herdr-projects names its tab herdr-projects, for as long as the board is open, so you can
tell it from your other tabs.
- Only that one tab is renamed. When the board closes (also when it closes to take you into an agent), the tab gets back the name it had. A name you gave it yourself while the board was open is kept.
- A board that was killed leaves the name; the next board that opens and closes in that tab puts the old one back.
- Nothing is renamed by the popup (it has no tab of its own), in the tab the board key opens (that one is named
board), outside Herdr, in a tmux inside the pane, or by a command that opens no board (add,list,showand the rest). - The code is
name_board_tabincrates/board/src/board/run/place.rs.
herdr-projects set board.open popup makes the same key open the board as a popup, and close it again
(settings). unset board.open brings the tab back.
It is Herdr's own popup: a framed window with the board's name, in the middle of Herdr's screen, nine tenths of its width and height. It is no pane and no tab: Herdr draws it over whatever is there and changes nothing under it, so the panes, their sizes and a zoomed pane are as they were when it closes. While it shows, it has the keyboard and the mouse, as Herdr's own menu does: nothing behind it takes a key or a click.
- The key again closes it, and so does
Esconce there is nothing left to step back from (a draft, the whole task, the filter, the archive and a chat message that shows come first, as on every board), andCtrl+Ctwice. What you typed, the task you were on and the filter are there when it opens again. Alt+Oon a task closes the popup and lands in that task's agent. The first three times it says for a moment how to get back.- It is showing or closed, never left behind. Nothing in Herdr's own window can switch tab or space under it. If Herdr shows another tab all the same (a command moved it there, or a second window on the same session did), the popup closes at that moment, with what you typed saved. The key opens it there.
- It opens on the task you were looking at. Pressed in the pane of a task's agent or reviewer, that task is selected, even if the filter left from last time would hide it. A view of one other machine gives way to this machine's tasks, so the task shows and the chat talks to this machine. Anywhere else it opens where it was.
- Words left in its box stay with their repo. The popup opens in the repo of the pane you are in, and what you type is
sent from there. With a draft waiting from last time, it opens in the repo the draft was typed for and says so, so
Enternever sends it from another one. Once it is sent or put away, the popup opens where you are again. Words put away withEsckeep their repo too:Ctrl+Zin a popup that opened elsewhere takes the board to the repo they were typed for, and says so. If that folder is gone, the board stays where it is and says which repo the words would be sent from now. - A board in a tab keeps running beside it. Each has its own note of where it is, and its own selection, filter and
words (the popup's are in
view-popup.json; the first popup starts from the tab's view, without its draft). There is one keeper, one Watcher and one Coordinator, whichever board you look at. The approve action for the focused pane is answered by the board that was shown for it. - When Herdr will not open it, the board opens in a tab and says why on its message line. Herdr has one popup for
everybody: while another plugin's popup, or a
type = "popup"command of your own config, is open, the board's cannot open.
popup meant something else before: a pane in Herdr's overlay, which filled the tab it opened over and stayed with that
tab. That is gone, and popup is this one; there is no third value. A setting that says popup already needs no change.
All of it is Herdr 0.9.3 (and its newest build, 2026-10-12), where a plugin has no other way to draw over the window (checked on Herdr):
- Herdr's own keys do not work while it shows. Herdr hands its popup every key, the prefix and the board key
included, and starts no action. So the board reads its own key itself: it knows the key from Herdr's
config.toml(the prefix key, then the key) and closes on it. No other Herdr key does anything in the popup; close it first. A prefix key pressed by itself does nothing, as in Herdr. - The same in another popup: while another plugin's popup shows, the board key is typed into that one. Herdr starts no action, so no code of the board runs: it cannot open, and it cannot say why. Close that popup first.
- It covers the panes, not Herdr's sidebar and tab bar: Herdr centres its popup on the panes' part of the window. Those two take no click while it shows.
- Herdr ties it to the tab it opened over, and hides it, still running, when another tab shows. The board closes it at that moment instead, so that is never seen. That is why the popup closes, and does not follow, when a command moves Herdr elsewhere.
- Nothing behind it is dimmed, and its size is the board's choice, not Herdr's menu's.
What Herdr would need for the real thing is in checked on Herdr.
What changes the board's size at all, and why a size that lasts a moment is not drawn: the board's size.
- A view somebody is looking through (the board open in the web UI's terminal view) keeps the terminal, and the board's first line says so.
- From any other view, the board takes its pane's size back by itself within a few seconds: the remote view described here is disconnected. Until then the board draws inside what Herdr's window shows, so its text box and hints are never cut off.
What follows is what you see until then, and when the board could not take the size back.
A remote view of the board's pane (a herdr terminal attach, which Herdr's web UI starts for each pane it shows) sets
that pane's size to its own, and holds it for as long as it runs, also after its browser tab is gone. Herdr's own window
then shows a cut-out of a board drawn for another size. The board notices within ten seconds, and says so on its first
line, top left, where a cut-out still shows it, with what frees the size first, so a narrow window keeps it:
! Shown cut off: a remote view holds this pane at 435×58 (herdr's own window: 184×78). ctrl+k ends that view
(open 40m); closing it where it runs does the same.
- It is a sentence, wrapped and never cut, and names no process to kill.
Ctrl+Kends that view from the board. That key is the board's only while such a view holds the pane.- Closing the view where it runs gives the pane its own size back at once too.
- The line is not shown outside Herdr, in a tmux inside the pane, or in Herdr's popup (which has no pane of its own).