Skip to content

Reference: delegate runs

NAME
delegate-runs — list the runs of this machine
SYNOPSIS
delegate runs [--json | --watch] [--local] [--timeline]

delegate runs lists each run of this machine in one table, across each repository. It reads the journal of each run, and the lock of each run branch, from each state directory under the state root of this machine: DELEGATE_STATE_ROOT, or else $XDG_STATE_HOME/delegate (~/.local/state/delegate). Each repository has one directory there. The command needs no git repository, so you can run it from any directory.

delegate runs [--json | --watch] [--local] [--timeline]
Option Meaning
--json Print one object as JSON: the format, the host, the time, the window, and one object for each listed run; cannot be used with --watch.
--watch Redraw the table in place once a second, until Ctrl-C; it needs a terminal, and it cannot be used with --json.
--local Show only the runs of this machine and read no other host; it still writes the records of the runs of this machine that have none.
--timeline Draw one lane for each run over the last 6 hours, to the latest ETA, in place of the table; it cannot be used with --json.

Which runs the table lists

The table lists these runs:

  • Each run that has no run-end: a run that is running, pausing, paused, halted or stopped. A run that has no run-end is listed however old it is.
  • Each run whose run-end is in the window: the last 6 hours. Its state is the result of the run, for example built or failed.
  • Each run that failed at start in the window, with the state failed. Such a run has a run.log and no journal, and its time is the time of the last change of its log.

An older run that ended is not listed.

The table also lists the runs of the other hosts: each host that has a record in the run index, and each host of the key hosts of the configuration file. See The other hosts.

A journal that cannot be read is skipped. The command names it on stderr, as delegate status does, and lists the other runs. A lock file that cannot be read, in the search for the runs that failed at start, skips the failed starts of its state directory in the same way: one line on stderr names the runs directory of the state directory and the lock file, and the other repositories are listed.

The table

The first line is the header line. It names the settings that the command uses, so you can see them at once (#323):

config /home/me/.config/delegate/config.toml · the index of this machine only · hosts build-host, ci-runner
Part Meaning
config <path> The configuration file that the command read. It is no configuration file when the file does not exist.
index <directory> The shared directory of the run index, from DELEGATE_INDEX or the key index. It is the index of this machine only when no setting names a directory.
hosts <names> The other hosts that the command read: the hosts of the records of the index and the hosts of the key hosts. It is no other host when the command read none. With --local, it is --local: no other host is read.

The header line is followed by the two fleet lines, a blank line and the table. The table has one group for each host, this machine first. The first row of a group holds the name of the host, and the totals of its runs that have no run-end: the ended tickets summed, the latest ETA, and the tokens summed. Under it, each run that the totals count has a row, and the rail │ stands in the column host. A totals row is the sum of the rows under it: each number of the row is the sum of the same number on those rows, and the first fleet line is the sum of the totals rows.

The runs that ended in the window are not under their host. They are in one group after the hosts, with the header ended in dim. Each row of the group has its host in the column host, in place of the rail. The group has no totals row. A host that has only runs that ended has no group of its own.

The fleet lines

The two fleet lines sum the runs that have no run-end. A run that ended is out of each sum, and so is a run that failed at start, and so is a run of an unreachable host.

runs  4 of 4 reachable  █████░░░░░░░░░░░ 33%  3/9 ended  ETA 15:10 · 2 with no ETA  34k new · 126k cache
13:00–14:20  ⚠ 2 in trouble  trend: tickets ended an hour, last 6h · all      ▇ speeding up
Part Meaning
N of M reachable M is the runs that have no run-end, on this machine and on the other hosts of the run index. N is the runs of the hosts that this machine can read. Each run of this machine is reachable. See The other hosts.
The bar and N% The tickets that ended over the tickets of the plan, summed over the runs, and rounded down. It is never the mean of the percentages of the runs. The bar has the 16 cells of the run line of delegate watch, and it shows only on a terminal of 100 columns or more.
X/Y ended The two sums of the tickets that ended and the tickets of the plan.
ETA The latest ETA of the runs that have one, or - when no run has one. · N with no ETA counts the runs with no ETA, for example a run that is paused or stopped. It is left out when N is 0.
new and cache Two sums of the tokens. They are never added together, and the line shows no cost. They are left out when no run has a count.
HH:MM–HH:MM The local clock time of the earliest start of the runs in the sums, and the local clock time of now. It is not the sum of the times of the runs.
⚠ N in trouble The runs with an agent that is idle for 5 minutes or more (the idle time of delegate watch), the runs that are stopped or halted, and the runs that failed at start in the window. A paused run is not in trouble. It is left out when N is 0.
trend: tickets ended an hour, last 6h · all The sparkline of the tickets that ended in each hour of the window, summed over the runs in the sums, and then the trend word. See The trend.

With no run that has no run-end, the first line is runs 0 of 0 reachable, and the second line is not there.

Column Meaning
host The name of the host on the first row of its group, and the rail on each run row under it. In the group ended, the name of the host is on each run row. The name of this machine is DELEGATE_HOST when it is set, else the short host name.
repo The name of the repository: the name part of the name of its state directory.
run The short id of the run.
state The state of the run, as delegate status gives it. A run that failed at start is failed.
ended The tickets that ended, over the tickets of the plan, as X/Y. It is dim for a run that ended.
ETA The local clock time HH:MM of the end that the run is estimated to reach. It is - while the run runs and has no estimate. It is blank when the run is paused, halted, stopped or ended.
slip How much later the ETA of the run is now than it was 2 hours ago, as +55m, in warn. See The slip. It is blank otherwise.
new The new tokens of the run. It is blank when the command cannot read the streams of the run.
cache The cache tokens of the run. It is blank when the command cannot read the streams of the run.
trend The sparkline of the tickets of the run that ended in each hour of the window, in dim. See The trend. The row of the machine has none.
alert What is wrong, at most one value, in warn. ⚠ idle <time> when an agent of the run is idle for the stall time of delegate watch (5 minutes) or more. Else fix-up <round>/<limit> when a fix-up round of a ticket or of a chain runs. It is blank otherwise. A run that is not running or pausing has no such alert. A run in trouble shows why: stopped for a stopped run, halted for a halted run, and failed at start for a run that failed at start, in warn.
do The next command. watch when the run has an alert. Else resume when the run is paused, stopped or halted, retry when the run ended failed, and merge when the run ended built. It is blank otherwise. A run that failed at start has none: it has no journal to resume.

The order of the rows is fixed. In a group of a host, the runs that have no run-end are in order of their start, the newest first. The group ended follows the hosts, with the runs of this machine first, then the runs of each other host in the order of the names of the hosts, and in each host the newest end first.

When no run is listed, there is no table. The command prints three lines and exits 0:

no configuration file · the index of this machine only · no other host
runs  0 of 1 hosts have an active run
no run ended in the last 6h

The number of hosts is this machine and each other host that the command read. When a host that the command could not read has no listed run, its row and its reason still show, under these three lines and a blank line.

The other hosts

The other hosts are each host that has a record in the run index, and each host of the key hosts of the configuration file. A host that both name is read one time. The table has one more group for each other host, after the group of this machine, in the order of the names of the hosts, with a blank line between two groups. The runs of this machine come from its journals, as before: its own records in the index are not used. To set up the view, see see the runs of more than one host.

The command reads each other host. For each host it runs ssh -o BatchMode=yes -o ConnectTimeout=5 <host> delegate runs --local --json, and <host> is the name of the host in the index or in hosts. So ssh must reach each host with no password, and delegate 1.22.0 or later must be on the PATH of the login shell of that host. The host needs no setting. The hosts are read at the same time, and the read of one host ends after 10 seconds at the latest. This is the only process that delegate runs starts. No command writes a record of a run to another host.

A host that gives its document of format 1 shows its runs as live runs, as the runs of this machine show. They have the ETA, the slip, the tokens, the trend, the alert and the do word that the host worked out, and they are in the sums of the fleet lines and in ⚠ N in trouble. The rows of the group of the host are not dim, and the row of the host has its totals. The records of that host in the index are not used. In --timeline, such a lane has the life of the run and the projection to the ETA, but not the ● marks of the tickets, because the document holds the number of the tickets that ended in each hour, not their times.

This machine keeps the newest document of each host that it read in the store of last answers.

A host is unreachable when its read fails, when the read takes more than 10 seconds, and when the host gives a document that this version cannot read. The row under the row of the host gives the reason, in warn, from the column state:

Reason Why The fix
ssh cannot reach <host>: <line> ssh exited with 255: it cannot connect, or it needs a password or a passphrase. <line> is the last line that ssh wrote on stderr. Make ssh -o BatchMode=yes <host> true work with no prompt.
<host> has no delegate command on its PATH: <line> The login shell of the host exited with 127. Install delegate on the host, on the PATH of a shell that is not interactive.
delegate on <host> is older than 1.22.0 The delegate of the host has no delegate runs, or it gives a document with no format or an earlier one. Install delegate 1.22.0 or later on the host.
delegate on <host> is newer than this one (format <n>); update delegate on this machine The host gives a format later than 1. Install the same version on this machine.
delegate runs on <host> exited with status <n>: <line> delegate runs on the host failed, for example because its own configuration file has an error. <line> is its last line of stderr. Run delegate runs --local on the host and correct what it says.
no answer from <host> in 10 seconds The read took more than 10 seconds. Look at the network and the load of the host.
<host> gave no JSON document, <host> gave a document that is not an object, <host> gave a document that this version of delegate cannot read The output of the host is not the document of delegate runs --local --json. Look at what the login shell of the host prints.
ssh cannot start: <reason> This machine cannot start ssh. Install ssh on this machine.

This machine then shows the last-known runs of that host, and nothing else. They are the runs of its last answer in the store of last answers, or the runs of its records in the index, the newer of the two. A host with no last answer and no record has only its row and the row of its reason.

For example, a host build-host with one run a41e that was running at 3 of 6 tickets, last heard 47 minutes ago, has these three rows. The first row has unreachable in state, heard 47m ago in alert and check host in do. The second row has │ in host and the reason from the column state. The third row has │ in host, docs-site in repo, a41e in run, running in state and 3/6 in ended, and nothing else.

  • The row of the host has the name of the host, the state unreachable in warn, the alert heard <duration> ago in warn (the time since this machine heard its last answer, or since the host wrote its newest record, in whole minutes, as 47m, or 3h05m from an hour), and the do word check host. It has no totals. A host that was never heard from has no alert.
  • The rows of its runs are dim and hold the last-known state and ended. They have no ETA, no slip, no tokens, no trend, no alert and no do.
  • A run that ended is listed under its host, dim, while its end is in the window. A run that ended before the window is not listed.
  • The runs of an unreachable host are out of each sum of the fleet lines, and out of ⚠ N in trouble. The first line counts them in the total: runs 1 of 3 reachable.

In --timeline, each lane of such a run is dim from the start of the run to the time that its host was heard from. Its state is unreachable and its alert is heard <duration> ago. A host with no last-known run has no lane.

--local limits the view to this machine and reads no other host, and starts no ssh. --json always describes this machine only, reads no other host, and starts no ssh: this is the document that another host gives. With --watch, the command reads the other hosts at most each 30 seconds, and redraws with the last answers between two reads. The reads of --watch go on in the background: a redraw waits for them at most 0.3 seconds, so a slow or unreachable host does not stop the view. Until the first answer of a host comes, its row is unreachable with its last-known runs and heard <duration> ago, and the row under it says no answer from <host> yet. Until a new answer comes, the view shows the answer before. Without --watch, the command waits for each read, up to its time limit. Ctrl-C ends each ssh of a read at once, with and without --watch.

delegate clean forgets the record of each run that it cleans or abandons, so the other hosts list it no more.

The store of last answers

The store of last answers is the directory last-answers/ in the state root of this machine. It holds one file for each other host that delegate runs read, <host>.json, with the time that this machine heard the answer and the document of the host. The command writes a temporary file in the same directory and renames it, as the run index does, so a reader never sees half a file. A write that fails keeps the older answer, and the command says nothing: the next read of the host writes it again. Do not edit, copy or delete a file of the store.

The records of the runs that have none

Each form of the command (delegate runs, --local, --json and --watch) writes a record in the run index for each run of this machine that the table lists and that has no record, or an older one: a record written before the newest event of the journal, or a record whose host, state or ticket counts are not the values of the journal. So a run of an earlier version, and a run that started with no index, get a record. The record is the snapshot of the journal (ADR 0008), so the write is safe at any time. A run that failed at start has no journal and gets no record. A run that delegate clean cleaned gets none either: delegate clean forgot its record, and the journal that holds a cleanup event after its newest run-end or stop (or that ended abandoned) says so (#327). delegate run and delegate run --resume write the same records before the run starts.

A write that fails changes nothing else: the command prints one warning line on stderr, delegate runs: run index <directory>: ..., and goes on. Each read of a host over ssh runs delegate runs --local --json there, so it also brings the records of that host up to date.

The slip

The journal holds no ETA, so the command works out the ETA of 2 hours ago from the events of the journal. The snapshot of the run at that time is the events up to that time, that time, a live process, and no pause request. The slip is the ETA now minus the ETA of that snapshot.

It shows as +<duration> when it is 30 minutes or more: +55m, or +1h05m from an hour. It is blank when one of the two ETAs is missing (the run does not run now, or it had no ETA 2 hours ago), when the run started less than 2 hours ago, and when the slip is less than 30 minutes.

The trend

A ticket counts one time, at the time of its first step-end with the state built. A ticket that a retry revived has a later step-end with the state built, and that one does not count again.

The trend of a run is 6 cells, one for each hour of the window, oldest first. The last cell is the hour that ends now. Each cell is the number of tickets that ended built in that hour. A ticket that ended before the window is in no cell.

Each cell is one glyph, in dim. The glyphs are ▁▂▃▄▅▆▇, from the lowest level to the highest. The level is scaled to the largest cell of all the runs in the table, so one scale serves each run: a cell of the same size has the same glyph in two runs. A cell with no ticket is a space. When the locale is not UTF-8, the glyphs are .:-=+*#, and each takes the same cell.

The all sparkline of the second fleet line is the sum of the cells of the runs that have no run-end. Its scale is its own largest cell, because the sum can be larger than each cell of one run.

The trend word compares the tickets of the last 2 hours with the tickets of the 2 hours before them. More than 1.25 times as many is speeding up. Fewer than 0.75 times as many is slowing. Otherwise it is steady. When both counts are 0, there is no word.

The legend

Under the table is a blank line and the legend: one line for each word of the column do that the table holds, once, in the order watch, resume, retry, merge, check host. Each line has the word and its command. A word that is not in the table has no line, and a table with no word has no legend. The legend shows only on a terminal of 100 columns or more.

Word Command
watch delegate watch <run>
resume delegate run --resume <run>
retry delegate run --resume <run> --retry <ticket>
merge git merge --ff-only <run branch>
check host ssh <host>

When a host other than this machine has a do word in the table, the last line of the legend ends with ; on another host, put ssh <host> in front of each command. An unreachable host has the word check host, so the legend has it then.

Each command works from any directory of this machine: delegate watch and delegate run --resume find the run by its id, and the journal records the repository of the run. Put the short id of the run in <run>.

The configuration file

The configuration file holds the settings of a machine for the run index and the view. Each delegate process reads it, whatever its environment, so no setting of a shell, a service or an agent is necessary. A configuration manager can write it once for each machine. The file is optional: with no file, the defaults apply.

The path is $XDG_CONFIG_HOME/delegate/config.toml. When XDG_CONFIG_HOME is not set, is empty, or is not an absolute path, the path is ~/.config/delegate/config.toml. The file is TOML.

hosts = ["build-host", "ci-runner"]
Key Type Default Meaning
index text: an absolute path, ~ permitted index/ in the state root of this machine The directory of a run index that more than one host shares. See the run index.
hosts a list of text no host The ssh names of the other hosts that delegate runs reads on this machine. See The other hosts.

The run index of a process is, in this order:

  1. DELEGATE_INDEX, when it is set and not empty.
  2. The key index of the configuration file.
  3. The directory index/ in the state root of this machine: DELEGATE_STATE_ROOT, or else $XDG_STATE_HOME/delegate (~/.local/state/delegate).

hosts and index are settings of a machine and of a person, not of a repository. Do not put them in a file of a repository or in workflow.toml.

The errors of the configuration file

Each error is one line that names the file, the key and the expected form:

Error Example of the line
The file cannot be read. config <path>: cannot read the file: Is a directory
The file is not valid TOML. config <path>: the file is not valid TOML: Expected '=' after a key in a key/value pair (at line 1, column 6)
An unknown key, for example host in place of hosts. config <path>: unknown key 'host'; the keys are index = "/an/absolute/directory" (text: the path of a shared directory); hosts = ["build-host"] (a list of the ssh names of the other hosts)
A value of the wrong type, for example a string in place of a list. config <path>: hosts must be a list of host names, not 'far'; write hosts = ["build-host"] (a list of the ssh names of the other hosts)
index that is not an absolute path. config <path>: index is 'relative/dir', which is not an absolute path; write index = "/an/absolute/directory" (text: the path of a shared directory)
A host of hosts that is not an ssh host name: it starts with -, or it has / or a space at an end. config <path>: hosts has '-x', which is not an ssh host name; write hosts = ["build-host"] (a list of the ssh names of the other hosts)
A host of hosts that names this machine: its host name, its short host name, localhost or DELEGATE_HOST, in any case. The host would show two times. config <path>: hosts has 'localhost', which is this machine; remove it: delegate runs always shows the runs of this machine

delegate runs prints the line after delegate runs: on stderr and exits 2. delegate run --dry-run reports it as a problem of the setup check and exits 1. delegate run, --detach and --resume print it and exit 1 before they create a branch or write a journal event, so nothing of the run exists yet. delegate clean prints it and exits 1. The file is read one time, when the command starts: a file that changes or breaks while a run goes on does not change that run.

Fit to the terminal

The command reads the size of the terminal: COLUMNS and LINES, else the size of the terminal that is standard output. When the terminal gives no width, the width is 80. When it gives no height, no row folds.

Width. Under 100 columns, the bar and the legend drop. Then, while the widest line of the table is wider than the terminal, the columns drop in this order: new and cache, then trend, then slip, then repo. The first fleet line drops its token sums when it is wider than the terminal, and the second fleet line drops the words and the sparkline of the trend when it is wider than the terminal. The trend word stays. Each line is then cut to the width.

Height. When the lines are more than the lines of the terminal, less one line for the prompt, the rows fold in two stages. The command goes to the next stage only when the lines still do not fit:

  1. The group ended folds to one row for each host, with the glyph of the first state and the count of each state, for example ✓ 1 built or ✗ 1 failed. The name of the host is in the column host, and the text starts in the column state. A run that ended is out of the totals, so the totals do not change. The legend then holds only the words of the rows that show.
  2. When the runs that have no run-end of a host have no alert and no command, the host folds to its totals row: no run row shows, and no row of that host shows in the group ended.

A host with an alert or a command does not fold to its totals row. When the lines still do not fit, the command prints them all.

Colour and glyphs. With NO_COLOR set and not empty, or when standard output is not a terminal, the output has no colour code. When the locale is not UTF-8, each glyph is its ASCII glyph, and each ASCII glyph has the width of the Unicode glyph, so the columns are in the same positions. The title of the terminal is not a colour code: DELEGATE_NO_TITLE=1 turns it off.

The option --timeline

delegate runs --timeline shows the same two fleet lines, and then one lane for each run in place of the table. A lane shows the time of a run across the window, the last 6 hours, and on to the latest ETA of the runs. It shows the same runs in the same order as the table. --timeline can be used with --watch, and it cannot be used with --json.

The lanes

The legend is the end of the second fleet line, after the trend word. Under 100 columns it is only one cell is 12m. The header under the blank line holds the label last 6h, to the latest ETA and the headers ended, ETA, state and alert. The first lane is all (see below). Each lane row after it has the label host repo run (the host on the first row, the rail │ under it), the lane, and then ended, ETA, state and alert as in the table. Under the lanes, after a blank line, is the footer detail delegate watch <run>; on another host, ssh <host> delegate watch <run>.

The lane all is the sparkline of the tickets that ended built in each cell of the window, over all the runs that have no run-end, on a scale whose largest cell has the top level; then the column of now ┊, and ░ to the latest ETA. Its ended and ETA are the totals of those runs, as on the row of the host in the table. A run that ended is out of the lane all.

Under 100 columns the label of a lane is the run id only, and the host is a line over its lanes, under the lane all. The column ETA, the label last 6h, to the latest ETA and the footer drop, as the bar and the legend of the table drop.

One cell is 10 minutes on a terminal of 120 columns or more, and 12 minutes on a narrower one. Cell 0 starts at the start of the window, now minus 6 hours. The window has 36 cells of 10 minutes, or 30 cells of 12 minutes. The cell after them is the column of now, and the cells after that are the projection. The lane ends at the latest ETA of the runs, or at the column of now when no run has an ETA. A time is in the cell that holds it. A time before the window is in cell 0, and a time after now is in the last cell of the window.

Glyph ASCII Role Meaning
─ - none The life of the run, from the cell of its start.
● * ok A ticket that ended built, in the cell of its first step-end built (the rule of The trend).
✓ or ✗ + or x ok or bad The end of a run that ended, in the cell of its run-end: ✓ for built, ✗ for each other result. A run that is stopped or halted ends with ✗ in the cell of its newest event. A run that failed at start is one ✗ in the cell of its log. A paused run ends in the cell of its newest event, with no mark.
▶ > now, or warn Now, for a run that is running or pausing. It is warn when the run has an alert.
░ . dim The projection of a run that runs, from now to its ETA.
┊ : now The present, for each run that does not run. It is in the same column in each lane.

The command fits the lanes to the width of the terminal only as far as the cell size and the columns that drop under 100 columns. The folds of the rows to the height of the terminal do not apply to --timeline.

The option --watch

delegate runs --watch shows the same view (with --timeline, the lanes), and redraws it in place once a second, the poll rate of delegate watch. The command lists the state root again at each redraw, so a run that starts, or that is cleaned away, shows or goes at the next redraw. It reads each journal again only from the position where it stopped, not from the start.

  • The frame replaces itself in place. The command does not use the alternate screen, so the last frame stays in the scrollback. The first frame hides the cursor, and each end of the command shows it again.
  • A redraw writes only the lines that changed, and nothing when the frame is the frame before, as the live view of delegate watch does. The view has no spinner.
  • The command reads the size of the terminal at each redraw, so the frame follows a new size. It fits the width and the height as Fit to the terminal says.
  • A journal that cannot be read goes on stderr one time. The command names it before the first frame when the first read finds it. A journal that breaks later is named after the last frame, so no line of stderr breaks a frame.
  • Ctrl-C, SIGTERM and SIGHUP end the command. It prints delegate: interrupted on stderr and exits with 130, with no traceback.
  • When standard output is not a terminal, the command prints delegate runs: --watch needs a terminal on stderr and exits with 2. --watch and --json exclude each other.

The JSON object

--json prints one object. The object is a contract with a version: a later version can add a field, and a change to a field needs a new format.

{
  "format": 1,
  "host": "laptop",
  "time": "2026-11-14T14:20:00+00:00",
  "window_seconds": 21600,
  "runs": [
    {
      "run_id": "20261114T134000Z-aaaa",
      "repo": "alpha",
      "host": "laptop",
      "state": "running",
      "started": "2026-11-14T13:40:00+00:00",
      "ended": null,
      "tickets_ended": 1,
      "tickets_total": 2,
      "eta": null,
      "tokens_new": 12000,
      "tokens_cache": 340000,
      "alert": null,
      "do": null,
      "trend": [0, 0, 0, 0, 0, 1],
      "slip_seconds": null,
      "idle_seconds": null,
      "fixup_round": null,
      "fixup_limit": null,
      "failed_start": false
    }
  ]
}
Field Meaning
format The version of the contract. It is 1.
host The name of this machine.
time The time of the command, in UTC.
window_seconds The length of the window of the runs that ended: 21600, which is 6 hours.
runs One object for each listed run, in the order of the table.
run_id The full id of the run.
repo The name of the repository.
host The name of this machine.
state The state of the run.
started The time of the run-start of the run, in UTC. For a run that failed at start, the time of the last change of its log.
ended The time of the run-end of the run, or null for a run that has none. For a run that failed at start, the time of the last change of its log.
tickets_ended The tickets that ended.
tickets_total The tickets of the plan.
eta The estimated end of the run, or null when the run does not run or has no estimate.
tokens_new The new tokens of the run, or null when the command cannot read its streams.
tokens_cache The cache tokens of the run, or null when the command cannot read its streams.
alert The text of the column alert that an agent at work gives (⚠ idle <time> or fix-up <round>/<limit>), or null. The reasons stopped, halted and failed at start are in the table only. The glyph of ⚠ idle is always ⚠, also in a terminal that is not UTF-8.
do The word of the column do, or null.
trend The 6 counts of the trend of the run: the tickets that ended built in each hour of the window, oldest first.
slip_seconds The slip of the ETA in seconds, or null when the column slip is blank.
idle_seconds The seconds that the longest idle agent of the run has been idle, when alert is ⚠ idle <time>. Otherwise null.
fixup_round The round of the fix-up round that runs, when alert is fix-up <round>/<limit>. Otherwise null.
fixup_limit The limit of the rounds of the fix-up round that runs, when alert is fix-up <round>/<limit>. Otherwise null.
failed_start true for a run that failed at start, false for any other run. The table shows the alert failed at start for it, and alert is null.

A reader of the document takes the alert from idle_seconds, fixup_round, fixup_limit and failed_start, and parses no text. alert is the text for a person: a later version can change its words, its glyph or its duration format with no change of format. delegate runs reads the document of another host in this way, so each of the four fields must be in each run. A document without them is a document that this version cannot read, and its host is unreachable.

Exit codes

Code Condition
0 The command printed the table or the object, also when no run is listed.
2 The state root is not an absolute path, the configuration file has an error, or --watch has no terminal for standard output.
130 Ctrl-C ended --watch.

Version main