Fix loops and test scopes

A node's own view, opened from An item's page, draws the tasks inside the node. This page names the two specialist drawings there: a node with a fix loop and a changed-test-scope task.

A node with a fix loop

A node's own view draws the loop as a dashed arc under the steps, and once the loop has run, its repair tasks and the judge sit on it as tasks of their own: click one to open it. A loop with several repair steps, such as a repair and then a sync, shows each in order, left to right, with the judge last.

A step that runs its tasks in parallel

A loop step with more than one task runs them together, so it is one box on the loop, captioned n in parallel and in the worst state among its tasks. Click it, or press Enter on it, to select it. Its panel lists its tasks as the round shown ran them, and each row opens that task.

The step opens in place while it, or one of its tasks, is selected: a frame holds the step's tasks, and the loop forks to each of them and joins again. The frame's head is the step itself. Esc from inside the frame, or its ✕, folds it back to its box, and so does picking anything else. A link to the step or to one of its tasks opens it.

A loop with such a step is drawn as a level lane and not an arc: down from the node's end, along the bottom, and up into its start, with every stop on one line. A loop whose steps each have one task keeps the arc.

Picking a round

Beside the zoom, round n of m says which round the canvas shows. It starts on the newest. Open it to pick an earlier round, newest first, with what became of each; the canvas then shows every task as that round ran it, the repair that went on from it and the judge that came after it. latest ↩ goes back.

The round picked is in the page's address (?round=), so a link you copy opens on it, on a phone too. Another node starts on its own newest round.

Picking a pass

The chain can run a node again: a gate rejection sends the item back, a retry reruns the node, or its base branch moves. Each time is a pass. A pass counts its own rounds and keeps its own tasks, logs and scopes.

On a node the chain ran more than once, pass n of m sits beside the round. It starts on the newest. Open it to pick an earlier pass, newest first. The canvas and every panel then show that pass, and the round menu lists its rounds. latest ↩ goes back. A node that ran once shows no pass.

Each pass in the menu says what started it:

The pass picked is in the address too (?pass=).

Retry in a panel runs on the node as it stands now, whichever pass you are reading. Its confirmation says so when the pass on screen is an earlier one.

A gate's reviewer and an escalation turn are in no pass, so their runs stay together. A pass that an agent's retry started keeps the count of the one before it, so its rounds start where that one stopped. A retry of one task you ask for yourself starts a pass only when it starts the node's rounds over: on a node whose fix loop had gone past its first round.

A task in a round

A repair or judge that has not run in a round is drawn dashed and faded: the judge never runs before the first repair, so round 1's reads skipped · first repair.

A task's panel in such a node names the round in its subtitle (agent task · round 2 of 3 · running 41s) and shows that round's run, so the attempt n of m ▾ menu appears only when the round itself ran the task more than once.

The panel of a repair or judge that has no run says why. On the newest round it uses its box's words, not yet, last round or stopped by judge, since it may still run. On an earlier round it says not run in this round. The judge of round 1 says it was skipped, because the first repair runs without it.

A changed-test-scope task

A changed-test-scope task (kraft.verify_changed_test_scopes) opens in place while it, or one of its scopes, is selected: its box becomes a frame with one row per repository, in the order the task visits them (a workspace's root first, then its members), and each repository's scopes as chips. A reduced-motion setting skips the move and crossfades instead.

The task is all of its scopes. Its box and its panel read failed when one of the round's scopes failed, even if a later scope passed, and running while one still runs. Its log then opens on that scope's.

The frame

• Scopes that run one after another are joined in a line by arrows, and a task set to execution: parallel stacks them in a fork.
• An item in one repository has one row, drawn as its chips alone: no number, no repository name and no status under it, and a heading that says nothing of repos. While it has no chips, the row says waiting or not reached.
• The frame is as wide as its heading or its longest row, whichever is wider, and the steps after it move over to make room, so no row scrolls where the scroll wheel pans the canvas.

What a chip says

A chip says how that scope went and how long it took, and reads as the scope's command (an area's setup reads setup · area); hover it for the whole command and the paths it covers.

A chip's panel

A chip opens the scope's own panel:

• its command and the paths it covers;
• its repository, when the item has more than one;
• how it went in every other round (passed, failed, running, waiting, not picked, or repo not reached);
• its log.

When the round ran a scope more than once, the panel's subtitle has an attempt n of m ▾ menu. Pick an earlier run to read its result and its log.

A link to a scope the round has no chip for opens a panel that says why:

The open task's own Overview says how many of the round's scopes passed and how its scopes run, with a key to new and not picked. For an item in several repositories it also says how many were reached, and explains the dashed ring.

Stepping back and closing

Esc steps back one: from a scope to its task, from the open task back to its box, then the panel folds as usual. Picking anything else, clicking the canvas, or the frame's close also folds it.

Related

• An item's page: the chain graph and the inspector that a node's view opens from.
• Fix loop: what a fix loop is, and the repair and the judge in it.