Watching a run
precept-dashboard is a page on your own machine that shows local test runs as they happen, and
keeps them. You can run a large suite headless and still follow which tests are running, what they
log, and the Chromium page a test drives. Afterwards the run is still there: its results, failures
and logs are kept for 90 days. The dashboard can also start runs for you.
The page has two tabs:
- Runs shows what is running now, and the runs of your listed projects from the last 90 days. A run shows its tests as they start and finish, their outcome and retries, and each test's log as it is written. While tests have browsers open, Watch browsers shows them all side by side. The page opens on this tab. See Runs, History and Grid.
- Projects lists the test projects on your machine. From there you read a test's source and run a test, a suite or a whole project. See Projects.
Install it#
It is a .NET tool, installed once per machine:
dotnet tool install --global Precept.Dashboard
A team that wants everyone on the same version can pin it in a tool manifest instead:
dotnet new tool-manifest
dotnet tool install Precept.Dashboard
Then start it with dotnet precept-dashboard.
Start it#
precept-dashboard
It prints a link and opens it in your browser. The link carries a key, like
http://127.0.0.1:5123/?key=…. The page works only with that key. If an editor opens instead of
a browser, open the printed link yourself: the dashboard opens it through a small .html file, so
whatever handles .html files gets it.
Leave the dashboard running, then run your tests as usual. Your test project needs no changes and knows nothing about the dashboard: every local run leaves a small record beside its built app, and the dashboard finds the runs of the projects on its list. See Projects for how a project gets on the list.
The top bar also holds:
| Control | What it does |
|---|---|
| ⚙ | Settings. Open tests in picks your editor. See The detail panel. |
| Sun and moon | Switches between light and dark. Your choice is remembered in this browser. |
If the page loses the dashboard, a banner says "Connection lost. Reconnecting…". Buttons wait until it is back, and the page then shows everything again.
Esc closes a dialog, the detail panel, and the Grid's focused view.
The dashboard answers only to the host and port in the link. It refuses any other hostname for the same machine.
A run is usually picked up within two seconds of starting, whether the dashboard was already open or not, and the page shows everything the run has done so far, logs included. The first run from a build output folder the dashboard has not seen yet, such as a first Release build, can take up to half a minute to appear. Runs that ended while the dashboard was closed are added to History when it next starts.
| Option | What it does |
|---|---|
--port <n> |
Listen on this port instead of a free one. |
--no-browser |
Do not open the page. |
--version |
Print the version. |
Starting it a second time prints the link of the one already running, key included, and opens it. Use it to open the page in another browser, or after you restart yours.
Keep it running#
You can start the dashboard when you log in, so every local run shows up without you starting anything first. Start it with two options:
| Option | Why |
|---|---|
--no-browser |
No browser tab opens at every login. |
--port <n> |
The page keeps the same address. Your browser keeps the theme, the editor and panel widths per address, so with a new port every time they would reset. |
Start it at login, as yourself, not as a Windows service or a system daemon. It runs your projects
and reads your ~/.precept folder, and it can reach only the runs of your own account.
On Windows, create a Task Scheduler task. Run this once in PowerShell:
$action = New-ScheduledTaskAction -Execute "$env:USERPROFILE\.dotnet\tools\precept-dashboard.exe" -Argument "--no-browser --port 5299"
$trigger = New-ScheduledTaskTrigger -AtLogOn -User $env:USERNAME
$settings = New-ScheduledTaskSettingsSet -ExecutionTimeLimit 0 -AllowStartIfOnBatteries -DontStopIfGoingOnBatteries
Register-ScheduledTask -TaskName "Precept dashboard" -Action $action -Trigger $trigger -Settings $settings
Keep -ExecutionTimeLimit 0. By default Task Scheduler stops a task after three days.
A simpler alternative is a shortcut in the Startup folder. Press Win+R, type shell:startup, and
create a shortcut with this target. Set its Run property to Minimized:
%USERPROFILE%\.dotnet\tools\precept-dashboard.exe --no-browser --port 5299
To open the page, run precept-dashboard. It finds the dashboard already running and opens the
page with the right key.
Good to know:
- The dashboard keeps a console window. Closing it stops the dashboard.
- The key changes every time the dashboard starts. An old bookmarked link shows the locked page.
Run
precept-dashboardto get in again. - Runs are kept on disk for 90 days. See History. The project list is kept on disk too. See Where it keeps the list.
How it finds runs#
Every local run writes a small record beside its built app and opens a pipe that only your account can use. See the run record. A run does this whether or not a dashboard is running, and never looks for one.
The dashboard looks in the output folders of the projects on its list. A run of a project that is not on the list is not shown. Add its folder under Projects.
A run on a build agent, or with IsContinuousIntegration set, opens no pipe and writes no record,
so the dashboard never sees it. To change that, or to turn both off on your own machine, see
Turning it off.
Turning it off#
The Dashboard setting in precept.json says whether a run opens its pipe and writes its record.
| Value | What it does |
|---|---|
Auto |
The default. On for a local run, off on a build agent. |
Never |
Off everywhere: no pipe and no record. |
Always |
On everywhere, a build agent too. |
{
"Dashboard": "Never"
}
Never suits a machine whose policy does not allow programs to open local pipes, or a suite that
does not want its test logs written down a second time. Like any setting, it can be set for one
run with an environment variable instead: PRECEPT_DASHBOARD=Never.
Runs#
The Runs tab shows every run of the projects on your list, whether you started it from a terminal, an IDE or the Projects tab.
- Now. The runs that are going, one card each. A card shows the project, the environment, when the run started and how long it has been going, how many tests are done, and the counts so far.
- History. Every run the dashboard keeps, in a table. See History.
A run you started from the Projects tab says so on its card, for example "from Projects · Checkout". Click that line to go to the project. Runs started from a terminal or an IDE have no such line.
Before the first run the tab says "No runs yet". Start one from Projects, or run your tests as usual.
If you ran tests and nothing appeared, the project is not on the list yet. See When a run does not appear.
Opening a run#
Click a card, or a row of the table, to open the run. A past run opens the same way as one that is running. Each run has its own address, so you can reload the page, use the browser's Back button, or send the link to yourself. The back arrow at the top takes you back to Runs.
- Header. The project, the environment, how the run stands, and when it started. While the run is going, a bar shows how far it has got.
- Tests. Running tests at the top, with their latest log line. Finished tests grouped by class, each with its status and duration. A retried test shows which attempt it is on.
- Detail. Click a test to open its panel: the log, live while the test runs, its failure and
stack trace, and its artifacts, which open from the page. See Artifacts.
↑and↓move between tests, andEsccloses the panel. - Browsers. A running test that drives Chromium shows a small live picture of its page. Open the test to watch it at full size. A test with several browser sessions gets a tab for each. Firefox and WebKit are not shown yet.
A past run is loaded when you open it. Until it arrives the page says "Loading the run…". If the dashboard no longer keeps the run, for example after you shortened how long runs are kept, it says "This run is no longer kept."
History#
Under History the tab lists the runs the dashboard keeps.
- Click a column's heading to sort by it, and again to reverse the order. The table sorts the runs it has loaded. Show older runs loads more.
- Project shows one project's runs, or every project's.
- A run that stopped before it finished says "The run ended without finishing", and shows the tests it got to.
Runs are kept in ~/.precept/dashboard.db, which only you can read, for 90 days. Keep runs for,
above the table, changes that to 30, 90 or 180 days, or a year. This is the dashboard's setting,
not the browser's: every page open on the dashboard shares it. Choosing a shorter time deletes the
older runs at once, and they cannot be brought back from the page.
What is kept for each test: its outcome, duration, failure and log, and the paths of its artifacts. Screenshots, videos and traces are not copied. They stay where the run wrote them. If one has been deleted since, for example by a clean build, its tile says "No longer on disk" and still offers the path.
If the file cannot be opened, the dashboard says why when it starts and on the Runs tab. It
then shows runs while it is open and keeps none. A file that is not a database is kept as
dashboard.db.bak. A file written by a newer dashboard is left alone.
A run written by a newer Precept than the dashboard reads is listed as "Written by a newer Precept", with no results. Update the tool.
Filtering tests#
The toolbar of an open run narrows the tests you see.
| Control | What it does |
|---|---|
| All, Failed, Passed, Skipped | Shows only tests with that outcome. Skipped includes inconclusive tests. Each button shows how many tests it would show. |
| Search | Shows only tests whose name or class contains the text. Press / to jump to it. |
Running tests always stay visible whatever outcome you pick, so a run in progress never looks empty. When nothing matches, Clear the filters resets both. The search also applies in the Grid.
Grid#
The Grid shows every Chromium browser that a running test has open, across all runs. Use it to watch a parallel run at a glance.
While any test has a browser open, Runs and an open run show a Watch browsers button with the number of live browsers. Click it to open the Grid, and the back arrow to go back. The Grid stays on screen when the last browser closes. It then says "No browsers open", and the back arrow takes you back.
Only Chromium browsers appear for now. Firefox and WebKit get no tile yet, as in Runs.
There is one tile per browser. A test with two browser sessions has two tiles.
| Part of a tile | What it shows |
|---|---|
| Picture | The browser's page, updated once a second. |
| Name | The test's name. |
| Run | The project and the time the run started. |
| Clock | How long the test has been running, or took. |
| Attempt | "attempt 2 of 3" when the test is being retried. |
| Session | The browser session's name, when it has one. |
| Left edge | Accent while running. Green, red or amber once the test passed, failed or was skipped. |
Hover over a tile, or move the focus to it, to see the test's latest log line.
Focus a tile. Click it to open it large, with the page at full size and the test's log beside
it. Open in results takes you to the test in its run. Press Esc or Close to
close it.
The Grid keeps the search box and hides the outcome buttons, because a finished tile fades within seconds. Its toolbar adds:
| Control | What it does |
|---|---|
| Run list | Shows all runs, or one run. |
| S, M, L | The tile size. M is the default. Your choice is remembered in this browser. |
| Keep finished | Keeps finished tests' tiles until their run ends. Without it, a finished tile stays 10 seconds, then fades out. |
| Count | How many browsers are live. |
The page asks for pictures for at most 48 tiles at a time, and only for tiles on screen. Scroll to bring others into view.
Projects#
The Projects tab lists the Precept test projects on your machine as cards. Open one to see its suites and tests, and run them without a terminal.
Adding projects#
- Add a folder. Press + Add folder and browse to the folder, or paste its path. See The Add folder dialog.
A run of a project that is not on the list is not shown. Add the project's folder first.
Adding a folder asks MSBuild to evaluate each project it finds, and that runs the project's own MSBuild files. Add only folders you trust. Nothing is built or run until you open a project or press Run. An evaluation that takes longer than 2 minutes is stopped, and the card shows why. While a project is being read, its card says "Reading project…".
Projects that are not test apps are left out without a note: libraries, and executables that set
IsTestingPlatformApplication to false. A project that has not been restored yet is listed until
a restore shows what it is.
The search skips bin, obj, .git, node_modules and hidden folders, goes 8 levels deep, and
stops after 500 projects in one folder.
To take a project off the list, press the bin button on its card and confirm with Remove. It stays hidden when the folder is searched again. Adding its folder again brings it back. To stop watching a folder, remove it in Manage folders. Its projects leave the list too, unless another folder you added still holds them. When a project leaves the list, or its project file is deleted, a run the dashboard started for it is stopped.
The Add folder dialog
+ Add folder opens a dialog that browses the folders of the machine the dashboard runs on.
| Part | What it does |
|---|---|
| Places | Home, Desktop and Documents when they exist, the file system's roots (the drives on Windows), and the folders already on the list. A click goes there. |
| Path | Where you are, one part per folder. A click on a part goes back up to it. |
| Path field | The same folder as text. Paste a path here instead of browsing; completions appear as you type. To copy a path, Shift+right-click the folder in Explorer and choose Copy as path, or select it in Finder and press ⌥⌘C. |
| Folders | The folders inside the one you are in. A click goes in; Up goes back. Hidden folders and links are not shown. A folder with more than 500 folders shows the first 500. |
| Found | The test projects in the folder you are in, searched as you arrive. |
Add folder adds the folder you are in, and says how many test projects it found. It is off when there are none. For a folder already on the list it reads Search again.
The dialog opens at your home folder. Arriving in a folder searches it for test projects, which reads folder names and project files up to eight folders deep. Home and the roots are not searched on arrival: go into a folder, or choose "search this one for test projects". The dashboard asks MSBuild about a project only once its folder is added, so add only folders you trust.
Add names the folder it will add, for example Add "samples" · 1 project. Pressing Enter in the path field adds a path you typed or pasted there, and never a folder you only browsed to.
The dialog tells you when there is no folder at that path, when it cannot read the folder, and when it found no test projects. If the search stops after 500 projects, the dialog says so. You can still add the folder, but a smaller one is better.
Once added, the dialog closes, a message confirms how many projects were added, and their cards appear.
Manage folders
Manage folders lists the folders you added. Each row shows its path, how many projects it holds and when it was last searched.
| Button | What it does |
|---|---|
| ↻ | Searches the folder again. The row shows how many folders it has looked at and how many projects it has found so far. |
| ✕ | Removes the folder. If the folder holds projects, the dialog asks first. |
The dialog also has + Add folder.
What a card shows#
| Part | What it shows |
|---|---|
| Name and path | The project and its folder. |
Precept x.y.z |
The Precept version the project uses. |
| Test count | How many tests the project has. The dashboard counts them when you open the project, and remembers the number. Until then the card shows "—". |
| Ring | The pass rate of the latest run: passed tests out of all its results. Green when nothing failed, red otherwise. |
| Latest run | Where and when it ran, and how long it took: the environment in its colour, then for example "12 min ago · 2 min 42 s". Then the passed, failed and skipped counts, each with a bar and a percentage. A run that covered only some tests says so, for example "6 of 38 run". A project never run shows "Not run yet". It is the latest run that finished, read from history, so it is still there after a restart. |
| Last runs | One small bar for each of the project's last runs the dashboard keeps, up to ten, oldest on the left. A bar is green for a run that passed, red for one with a failure, amber for one that only skipped, and short and grey for one that ended without finishing. Hover a bar for where and when it ran and its counts. Beside it, the average duration of the runs that finished. |
| "Building…", "Running n / m" | A run started from the dashboard is in progress. |
| "Reading project…" | The dashboard is asking MSBuild about the project. |
Error: … |
Why the project could not be read. Hover for the full message. |
The latest run includes runs started from a terminal or an IDE. A run saved by an older version of the dashboard shows no environment or duration.
A card starts nothing: open the project to run its tests, which is where the environment is chosen.
One line above the cards says how the projects stand, for example "6 projects · 1,176 tests · 3 passing · 3 not run yet". A project is passing when its latest run had no failure.
Search the list by name or path with the box at the top.
Opening a project#
Opening a card builds the project and lists its tests, grouped by suite. The first open takes a few seconds. The page says "Building and listing tests…" and shows how long it has taken. Each test shows its tags, its retries and its source file and line.
Each test's dot, duration and Log → come from its latest run in this project. That can be a run you started here, from a terminal or from an IDE. A run of a few tags or suites updates only the tests it ran. The dot of a suite or tag shows the worst status of its tests.
Press Refresh to build and list again after you change the code. If the build fails, the page keeps the tests from the last good build and says so. Output, at the bottom of the page, shows the build's messages. It opens by itself when a build fails.
Press / to jump to the filter box.
Suites and tags
The list on the left groups the tests. Suites and Tags above it switch between the two.
- Suites has one row per suite.
- Tags has one row per tag, such as
@smoke. A test with two tags is under both. No tag, at the end, holds the tests with none.
Click a row to see its tests. Tick the boxes of several rows to see them all, one after another. The panel above them then says how many tests they hold, and ▶ Run 3 tags runs every test in any of them. Clear goes back to one row.
A selected tag lists its suites beneath it, and its tests are grouped by those suites on the right. Click a suite under the tag to scroll to it. Its ▶ runs only the tests with that tag in that suite, for example "@smoke · Checkout".
A–Z sorts suites and tests by name. Without it they are in the order Precept finds them, which follows the source files. Tags are always in alphabetical order. The choice is remembered in this browser.
Drag the list's right edge to make it wider or narrower. The width is remembered in this browser. On a screen narrower than 900 px the list becomes a drop-down.
The detail panel
Click a test to open the detail panel on the right. With the list focused, ↑/↓ moves through the tests and Enter opens the panel. Drag the panel's left edge to resize it. On a screen narrower than 900 px it opens as a sheet over the list.
| Tab | What it shows |
|---|---|
| Source | A Gherkin test shows its scenario, the feature's Background, and the Examples row it ran. Show whole feature shows the whole file. A C# test shows its method. The file and line are shown with Copy path. |
| Last run | The test's latest run in this project: status, duration, attempts, the failure, the log, and the artifacts. The last run may be from days ago. Its log is loaded from history when you open the tab. |
The panel opens on Last run for a test that failed, and on Source otherwise.
Open in editor ↗ opens the test's file at its line in your editor. Pick the editor under ⚙ → Open tests in:
| Choice | Notes |
|---|---|
| VS Code | The default. |
| VS Code Insiders | |
| Cursor | |
| JetBrains Rider | |
| None | Hides the button. |
The choice is remembered in this browser. Your browser may ask before it opens the editor.
Artifacts
A finished test shows the files it recorded as tiles: screenshots, videos, traces and network logs. Click a tile to open it. A screenshot's tile shows the picture itself.
| File | What a click does |
|---|---|
Playwright trace (trace.zip) |
Opens it in Playwright's trace viewer, in a new browser tab. |
Image (.png, .jpg, .gif, .webp, .svg) |
Shows it fitted to the window. Click the image for actual size. |
Video (.webm, .mp4) |
Plays it. |
Text (.txt, .log, .json, .xml, .har, .csv, .md, .html, .htm) |
Shows it as text. An HTML file is shown as source. A file over 1 MB shows its first 1 MB. |
A file the dashboard cannot show, such as a PDF a test downloaded, is listed below the tiles. The copy button on every tile and row copies the file's path, so you can open it from disk. A retried test's files are labelled with the attempt that wrote them.
The trace viewer is Playwright's own, served by the dashboard. It works offline, and the trace
never leaves your machine. A trace from a newer Playwright than the dashboard's own may not open.
Copy its path and run pwsh bin/Debug/net10.0/playwright.ps1 show-trace <file> in the test
project, which uses the project's own Playwright.
The dashboard opens only files a run reported, for as long as it keeps that run and the file is still on disk.
Running#
| To run | Press |
|---|---|
| One test | ▶ on its row. |
| A suite or a tag | ▶ on its row in the list. |
| A tag within one suite | ▶ on the suite under the selected tag. |
| Several suites or tags | Tick them, then ▶ Run above the tests. |
| Every test | ▶ Run all. |
A suite or tag run starts every test the run finds in it, including tests added since the list was last built.
- Environment. Pick one from the list beside the buttons. It offers the default environment and
every
precept.{environment}.jsonin the project. - Output. The build and the run's console output, up to the last 5,000 lines.
- Log →. On a test that ran, opens it in the Runs tab with its full log.
When you press a Run button, a message confirms the launch, and a run bar appears under the header.
| The run bar says | Meaning |
|---|---|
| "Building…" | The dashboard is building the project. |
| "Starting…" | The build is done and the tests are about to start. |
| "Running 3 / 6" | Tests are running. The bar shows live counts and the elapsed time. |
| "Finished · 5 passed · 1 failed · 4.2 s" | The run is over. Press ✕ to close the bar. |
| "Stopped" | The run was stopped, usually with ■ Stop. |
| A red reason | The build failed. Show output has the details. |
If the dashboard refuses a run, the run does not start. A message and a notice on the project say why, for example that the project is still being listed.
While the run is going, ■ Stop ends it. Open live run →, on the bar and in the message, opens the run in the Runs tab.
Tests turn green or red in place as the run goes. The run also appears in Runs. Its results
are written to TestResults in the project folder. The page follows a run started here from its
first test. See What it costs a run.
The dashboard builds the project first, then runs it. A build may take up to 10 minutes and a listing up to 2 minutes before the dashboard cancels it.
One run per project#
Each project has one run at a time. While it runs, Refresh is disabled and a second run is refused. A run is also refused while the project is being built and listed. Different projects can run at the same time.
Where it keeps the list#
The folders and projects are saved in ~/.precept/dashboard-projects.json, which only you can read.
It sits beside dashboard.json, so PRECEPT_DASHBOARD_FILE moves it too. A project's latest run
is not in this file. It comes from history.
If the file cannot be read, the dashboard starts with an empty list and says why. A file that is not
valid JSON is kept as dashboard-projects.json.bak. A file it could not open is left alone, and
changes are not saved until the dashboard restarts, so your list is not overwritten.
When you close the dashboard#
Closing the dashboard stops the runs it started. It prints how many. Runs you started yourself keep going.
What it costs a run#
- Every local run: one small record file, written as tests finish, and one idle pipe that only your account can open. See the run record.
- Dashboard following the run: the run's events, and a batch of new log lines twice a second.
- On a build agent: nothing. No record and no pipe, unless
DashboardisAlways.
A run never looks for the dashboard and never waits for it. If the dashboard falls behind, the run drops events rather than slowing down, and the page says how many it missed.
Watching: frames only for the pages you are looking at. Thumbnails update once a second and the open test up to 15 times a second. A hidden or closed tab stops every stream.
No pictures are recorded. For a lasting record use the Web module's trace and video settings.
Security#
The dashboard listens on 127.0.0.1 only. An appsettings.json in the folder you start it from,
or a Kestrel__ environment variable, cannot add another address. When it starts it writes its
port and the page key to ~/.precept/dashboard.json, which only you can read.
- Runs are not reached over the network at all. The dashboard connects to a run through a pipe that only your account can open, and it finds the pipe's name in the run's record.
- History is one file,
~/.precept/dashboard.db, readable only by you. It holds what your tests logged. - The page needs the key. The link the dashboard prints carries it once. The page stores the key in the browser for this address and port only, and takes it out of the address bar. Other tabs on the same address use the stored key.
- The key changes each time the dashboard starts. A tab that holds an old key shows "Open the
link
precept-dashboardprinted". Open the new link and the tab works again. - Other people logged in to the same machine cannot use the page without the key. The dashboard
never puts the key on a command line: to open your browser it opens a small file that only you
can read,
dashboard-open.htmlnext todashboard.json, and that file forwards to the link. - Other websites open in your browser cannot connect to it.
The page can open a file only if a run reported it as a test's artifact. It cannot ask the dashboard for any other file on the machine.
- A run that is not being followed is read from its record. Its artifacts open only if they
are inside the test app's own folder, such as
bin/Debug/net10.0/PreceptArtifacts. Links are followed before that is checked, so a link that leads out of the folder does not open. - A run you follow live shows its artifacts wherever
ArtifactDirectoryputs them. - A file that has been replaced by a link since the run does not open.
The trace viewer runs on a second port that the dashboard picks at startup. A trace shows pages of the application under test, and on its own port nothing in them can reach the page key. The viewer gets a trace through a random link that works for one hour and opens only that file.
The dashboard builds and runs a project only when you open it or press Run. Adding a folder asks MSBuild to evaluate each project in it, which runs that project's MSBuild files. Add only folders you trust.
The page shows whatever your tests log, and whatever the application under test shows on screen, including any test credentials it displays.
To keep the file somewhere else, set PRECEPT_DASHBOARD_FILE to an absolute path where you start
the dashboard. A run does not read it.
When a run does not appear#
| What you see | What to do |
|---|---|
| The run is not in Runs at all | Add the project's folder under Projects. The dashboard only looks at the runs of projects on its list. |
| The run appears only when it has finished | The run could not open its pipe. Its console says "This run cannot be followed live" and why. |
The run prints A dashboard tried to follow this run but speaks protocol N |
Update whichever is older. The message says which: dotnet tool update --global Precept.Dashboard, or the project's Precept packages. |
| A run shows "The run ended without finishing" | Its process stopped before the run ended, or was killed. The page shows the tests it got to. |
| A running test has no picture | The test is not using Chromium, the session was opened outside a test, or the dashboard tab is hidden. |
| History shows a notice that it could not be opened | The dashboard could not open ~/.precept/dashboard.db. The message says why. Runs are shown while the dashboard is open and not kept. |
| A past run's screenshot says "No longer on disk" | The file was deleted after the run, often by a clean build. History keeps the path, not the file. |
| A past run has no artifacts, but showed them while it ran | Its ArtifactDirectory is outside the test app's folder. Artifacts of a past run are shown only from inside that folder. See Security. |
A run with IsContinuousIntegration set is not shown |
Such a run opens no pipe and writes no record, as on a build agent. Set Dashboard to Always to follow it. |
| No run is shown at all | Check that Dashboard is not Never in precept.json or PRECEPT_DASHBOARD. |
On the page itself:
| The page says | What to do |
|---|---|
Open the link precept-dashboard printed |
Open the full link, key included. Run precept-dashboard again to print it. A tab left open while the dashboard restarted shows this too. |
| Update Precept to see suites and tags | The project uses an older Precept. Its tests are listed by name only, and Run on a test runs every test with that name. Update its Precept packages. |
| Live status is unavailable | The run uses a Precept from before runs kept a record. Output still shows everything. Update the project's Precept packages. |