Skip to content

Manual runs

A manual run is a run a person executes in the dashboard — the model Testomat.io’s manual test runs use, taken as it is: the run lists the cases it expects, each gets Passed · Failed · Skipped with a message and, for a case with steps, a mark per step; Finish run closes it. A mixed run is the same report with both halves in it: the manual cases are marked in the dashboard, the automated ones are reported by CI through the reporter, and the verdict counts both.

Nothing new was invented for it. A mark is a result — the same POST /v1/runs/{id}/results a reporter sends — and a finish is the same finish event. What the feature adds is one right the reporter does not have: a person who pressed the wrong button corrects the mark in place instead of sending a second result that would count twice.

Three roads, one dialog:

  • From a plan. A plan of kind manual or mixed — Test plans — launched with Launch run expects every case the plan collects at that moment.
  • From Runs. New run ▾ › Manual run…: all manual cases, or a selection made with the same filter bar the cases screen has; Run the automated ones by hand too widens it the way a plan’s asManual does. The dialog counts what the run will expect as you narrow it, and will not start a run of nothing.
  • From the cases tree. Run manually in the bar over a selection, Run manually… in a suite’s or a folder’s ⋯, or Run manually after Clear all in a filtered list’s chips. The run takes the cases as they stand when the dialog opens: a case added to the suite later is not in it. A manual run takes the manual cases; when there are automated ones too, the dialog says how many, and Run the automated ones by hand too takes them as well. A reader sees none of the three.

The dialog then asks for a title — the plan’s, or a name with today’s date, «Manual · 2026-09-17» — an environment and the assignment, and ends with Cancel · Save · Launch.

Above those buttons a bar shows the project’s run quota: Runs in the last 24 hours: 4 of 1000 used, 996 left. Every run opened in the project counts — a reporter’s, the CLI’s, a plan’s, a manual one — and a run stops counting 24 hours after it was opened. Once the quota is spent, the bar adds New runs are refused until the oldest ones age out of the 24-hour window. and when the next slot frees, and a launch is refused with 429 (Quotas). When the quota cannot be read, the bar is not drawn and the dialog works as usual.

The Manual run dialog: Cases — All manual cases, picked, and Select cases; Run the automated ones by hand too, unticked; 5 cases → run «Manual · today's date»; Run title, Manual · today's date; Environment · optional, empty — Pick or type an environment…; Assignment — None, picked, and Prefer case assignee; a bar and Runs in the last 24 hours: 4 of 1000 used, 996 left.; Save keeps the run scheduled: its cases wait, more can be added, and nobody marks them until someone launches it. Launch starts it now. Then Cancel, Save and Launch. The Manual run dialog: Cases — All manual cases, picked, and Select cases; Run the automated ones by hand too, unticked; 5 cases → run «Manual · today's date»; Run title, Manual · today's date; Environment · optional, empty — Pick or type an environment…; Assignment — None, picked, and Prefer case assignee; a bar and Runs in the last 24 hours: 4 of 1000 used, 996 left.; Save keeps the run scheduled: its cases wait, more can be added, and nobody marks them until someone launches it. Launch starts it now. Then Cancel, Save and Launch.
New run ▾ › Manual run…: what the run takes, its name, and Cancel · Save · Launch.

On the wire the two roads without a plan are the start a reporter sends:

POST /v1/runs
{
"schemaVersion": 2,
"kind": "manual",
"title": "Manual · 2026-09-17",
"environment": "staging",
"configuration": { "expected": [{ "testCaseId": "6f1c2b3a-0000-4000-8000-0000000000c1" }] },
"assignment": "prefer-assignee"
}

Launch starts the run now and opens its page. Save creates the run without starting it: the run is scheduled, and you stay where you were. A notice names the run, with Open the run.

A scheduled run is a list of cases that waits for people:

  • On Runs its row says «scheduled · 12 cases» — what it will expect, since nothing has run.
  • On its page the head says Not launched yet, and To run says who saved it and when: «Saved by Alex Morgan · 2 hours ago — not launched: nobody marks a case until someone launches the run.» The cases are listed without buttons. Add tests works as on a launched run.
  • Launch run stands where Finish run will be. A run that never began cannot be finished (409). One nobody wants goes to the Bin: a scheduled run is not under way, so deleting several runs takes it as it takes a finished one.
A saved run: Checkout by hand · manual · scheduled, with Launch a copy, Clone with a filter, Export and Delete run, and the head Not launched yet; the tag staging · not in the list; Public report, off — the address answers 404; Add a description; Comments · 0 with Add a comment; the note that the platform recorded it, Pass rate — and Results 0, 0 passed · 0 failed · 0 broken · 0 blocked · 0 skipped · 0 in total. Then Saved by Alex Morgan · now — not launched: nobody marks a case until someone launches the run. To run · 5 cases · scheduled with Add tests and Launch run; five manual cases without buttons — Pay by card, Apply a voucher, Guest checkout, Change the address, Pick a delivery slot. A saved run: Checkout by hand · manual · scheduled, with Launch a copy, Clone with a filter, Export and Delete run, and the head Not launched yet; the tag staging · not in the list; Public report, off — the address answers 404; Add a description; Comments · 0 with Add a comment; the note that the platform recorded it, Pass rate — and Results 0, 0 passed · 0 failed · 0 broken · 0 blocked · 0 skipped · 0 in total. Then Saved by Alex Morgan · now — not launched: nobody marks a case until someone launches the run. To run · 5 cases · scheduled with Add tests and Launch run; five manual cases without buttons — Pay by card, Apply a voucher, Guest checkout, Change the address, Pick a delivery slot.
A saved run: its cases wait, unmarked, for Launch run.

On the wire, Save is "schedule": true on the same start — POST /v1/runs, or POST /v1/plans/{id}/launch for a plan. Launch run is an event:

POST /v1/runs/{id}/events
{ "event": "launch" }

launch on a run already under way changes nothing. A scheduled run also starts without the button: the first result that reaches it launches it — a reporter that joins it by its key, or one that posts to it directly.

Every launch dialog has an Assignment row — None or Prefer case assignee — and on the wire that is assignment on POST /v1/runs and on POST /v1/plans/{id}/launch. With prefer-assignee, the launch copies each expected case’s assignee into the run:

"configuration": { "expected": [ … ], "assignees": { "6f1c…c1": "6f1c…a2" } }

A copy, on purpose: the run holds who was to run what at launch, and a case that changes hands afterwards does not rewrite a run already under way. Cases nobody held are absent from the map; a launch with the strategy and nobody assigned anywhere records an empty map — the strategy was used, there was nobody to copy. none (the default) stores the configuration as it was sent, which for a reporter’s run is without the map at all.

On the run page the copy is what you see: the person on each «To run» row, prefer case assignee in the head, and a Mine · n / All · n toggle above the list — «Mine» keeps the rows assigned to the signed-in person, and the «x of n done» count follows the toggle. The toggle is there only when the launch made a copy; without one every row would be nobody’s and it would have nothing to say. GET /v1/runs/{id}/summary carries the same map as run.assignees, null when there is none.

While the run is launched, its page has a To run section: every expected case that has no result yet, in the order the run expected it. One case at a time is open for marking — the first one waiting, or the one whose name you press — with its timer running and —

  • the case’s steps (a manual case with steps): a toggle per step that turns with each click — passed → failed → skipped → blocked → not marked;
  • a Message, one line that grows;
  • Files — pictures, JSON and text the mark keeps (below);
  • Passed · Failed · Skipped — the button is the request. There is no separate Save: a mark with nothing else said is the common case.

Under the case’s name a badge says which version of the case the run shows:

BadgeWhat the run shows
LiveThe case as it is now. A case the run holds no result of yet is live: an edit made to it before you mark it is what you mark.
Frozen at vNThe case at version N, the one the run’s first result of it was written against. A later edit or revert, the Bin and a restore leave it as it was; (case is now vM) follows when the case has moved on. A manual case’s steps are that version’s.
In the BinBeside the other: the case was deleted since. The run still shows it.
Version not keptThe version tested was not kept, so it cannot be shown — a result from before Plune kept versions, of a case edited since. The steps under it are the live case’s, and the badge says so.

So the first mark freezes the case for this run: Change on a marked case shows the steps that were marked, not an edit made after. GET /v1/runs/{id}/cases/{caseId}/content answers the case as the run shows it — frozen, version, currentVersion, inBin, and snapshot, null when the version was not kept.

POST /v1/runs/{id}/results
{
"results": [
{
"resultKey": "manual:6f1c2b3a-0000-4000-8000-0000000000c1",
"testCaseId": "6f1c2b3a-0000-4000-8000-0000000000c1",
"source": "manual",
"status": "failed",
"errorContext": "Step 3: the coupon field accepted an expired code.",
"steps": [
{ "index": 0, "status": "passed" },
{ "index": 1, "status": "passed" },
{ "index": 2, "status": "failed" }
],
"execution": {
"startedAt": "2026-09-17T10:02:11.000Z",
"finishedAt": "2026-09-17T10:08:41.000Z",
"durationMs": 390000
}
}
]
}
field
resultKeymanual:<testCaseId> — unique within the run, so the run holds one mark per case. A second identical mark is a duplicate; a different one is a conflict that names the result already holding the key, and the dashboard patches that one instead.
sourcemanual — what tells the platform a person wrote this. A reporter names its runner here.
statusThe three a person gives: passed, failed, skipped. (broken and blocked are the reporter’s.)
errorContextThe message. Redacted and truncated like a reporter’s error text.
stepsUp to 200 { index, status } — the step’s position in the case’s steps, from 0, and passed, failed, skipped or blocked. Steps left unmarked are absent.
filesUp to 30 ids of the files added to the case while it was being marked (below). Absent when there are none.
executionThe time the case took — the timer’s, or the time typed — as a window that ends at the mark. The same field a reporter fills.

Accepted, the row collapses: the badge, the step marks as glyphs (✓ ✕ ○ ⊘), how many files it keeps, by kind, who marked it, the time it took, and Change, with the message under them. The counter in the section’s head — «3 of 12 done» — and the run’s own counts come from the platform after each mark, not from the page’s guess.

The open case’s clock starts as the case opens and runs beside its name — 02:14, past an hour 1:02:14 — with a pause button, Pause the timer. Paused, the row says paused and the button is Resume the timer. Opening another case pauses this one; back on it, the clock runs on, unless you paused it yourself.

The case open for marking: manual, Pay by card, and at the right its timer at 02:14 with the pause button; the Live badge under the name; its step, Open the checkout → The form is there, unmarked; an empty Message; Files with the zone — Drop files here or paste a screenshot, Add files, Pictures up to 2 MB · JSON and text up to 512 KB · 30 files a result; then passed, failed and skipped. The case open for marking: manual, Pay by card, and at the right its timer at 02:14 with the pause button; the Live badge under the name; its step, Open the checkout → The form is there, unmarked; an empty Message; Files with the zone — Drop files here or paste a screenshot, Add files, Pictures up to 2 MB · JSON and text up to 512 KB · 30 files a result; then passed, failed and skipped.
The open case's clock, running.
  • Type the time instead. Press the time: Time spent takes minutes and seconds — 6:30, or 6 for six minutes. Enter keeps it, Esc goes back. The clock waits while you type, and if it was running, it runs on from the time kept.
  • The mark stops it. Passed, Failed or Skipped sends the time with the result, as execution above. The marked row shows it after who marked it — «6 min 30 s». Change keeps it.
  • The run adds it up. Once a mark carries a time, the counts line under the cards ends with the sum: «… · 12 in total · 9 min 18 s spent».
  • The clock lives in the page. A reload starts the open case’s clock again from zero. A mark already given keeps its time.
The same case with its time pressed: the timer stopped at 02:14, paused, with the resume button; Time spent above the step, holding 6:30, and under it minutes:seconds · Enter keeps it, Esc goes back; then the step, Message, Files and passed, failed and skipped. The same case with its time pressed: the timer stopped at 02:14, paused, with the resume button; Time spent above the step, holding 6:30, and under it minutes:seconds · Enter keeps it, Esc goes back; then the step, Message, Files and passed, failed and skipped.
Time spent: the time typed instead, while the clock waits.

A run is walked without the mouse too. Under the list, Keyboard: press ? for the keys; ? opens Keyboard shortcuts, the list below, and ? again or Close shuts it.

key
PMark the open case passed
FMark the open case failed
SMark the open case skipped
1 – 9Turn the mark of step 1–9 of the open case
MGo to the message field
JOpen the next case to run
KOpen the previous case to run
?Show or hide this list
  • The keys act on the open case. P, F and S are its Passed, Failed and Skipped, with the steps, the message and the files as they stand; while a file is still going up they wait, as the buttons do. A number past the case’s last step does nothing.
  • J and K walk the cases still to run, in the list’s order — under Mine, the ones it shows.
  • Keys do not work while you type in a field. In the message, P is a letter. Nor do they work while a dialog is open, or with Ctrl, Cmd or Alt held: those belong to the browser.
  • The key is where it sits on the keyboard, not the letter it types, so another layout keeps the same keys. Only ? is read as typed.
  • A screen reader hears what a key did — «Step 2: failed», «Opened: Pay by card».

The keys that mark and walk work while the run is launched and you can mark: a saved run, and a reader, have nothing to mark.

Under the message of the case being marked is Files: a zone to drop files on, Add files to pick several at once, and a screenshot pasted anywhere on the page — it is named by the moment, «Pasted 13.10.2026 10.12.png». Each file goes up as soon as it is chosen, one after another, as a row with its percent; a row that did not get there says why and has Retry, and a file the page already knows will be refused — too big, or a kind only a bucket keeps — is refused on its row before it is sent.

The case being marked in a manual run: automated, gift wrap adds its fee, its timer at 00:00, and the Live badge under the name; an empty Message; Files with the zone — Drop files here or paste a screenshot, Add files, Pictures up to 2 MB · JSON and text up to 512 KB · 30 files a result — and one file under it, fee-twice.png, PNG · 5 KB, with its thumbnail and ✕; then passed, failed and skipped. The case being marked in a manual run: automated, gift wrap adds its fee, its timer at 00:00, and the Live badge under the name; an empty Message; Files with the zone — Drop files here or paste a screenshot, Add files, Pictures up to 2 MB · JSON and text up to 512 KB · 30 files a result — and one file under it, fee-twice.png, PNG · 5 KB, with its thumbnail and ✕; then passed, failed and skipped.
A picture added to the case being marked: the mark keeps it.
  • The mark takes them. Passed · Failed · Skipped sends the ids of the files in the same request, as files; while one is still going up, the marks stay off until it is there. Change does the same with the files added while it was open.
  • Until the mark, ✕ takes a file back at once. After it, the result keeps what it was marked with: DELETE /v1/files/{id} on it answers 409.
  • A case left unmarked loses its files — the night after its run is finished, or a week after they were added if the run stays open.
  • What one may be is what a result may hold: without a bucket, a picture (PNG, JPEG, WebP) up to 2 MB and a JSON or text file up to 512 KB; with one, the bucket’s ceilings. 30 files a result. Without a bucket they count against the project’s built-in storage.
  • A picture opens in the same window as a result’s screenshots on the run’s page, and a text in the same window as its text files.

On the wire, one request a file, its bytes as the body:

POST /v1/runs/{id}/cases/{caseId}/files?name=fee-twice.png
Content-Type: image/png

201 answers the file — id, name, contentType, size, storage, createdAt, createdBy — and the id goes into the mark’s files. GET on the same path lists the files waiting for the mark, and what adding one costs (budget). With a bucket the bytes go to it, as a reporter’s do: POST …/files/uploads signs a link for each, the browser PUTs the file to the bucket, and POST /v1/files/{id}/complete says it arrived.

Change opens the same editor with the mark as it stands, and the new verdict goes in place:

PATCH /v1/results/{id}
{ "status": "passed", "errorContext": null, "steps": [{ "index": 0, "status": "passed" }] }

Any of status, errorContext (null clears it), steps (null clears them), subStatus (below) and files (the ids of files added since — above), at least one. The result keeps its id and its place in the run; outcome is recomputed from the new status; the change is audited under the run with the status and the message before and after.

A marked row has Sub-status ▾ after its badge: one optional word for why — Product bug, Environment issue, or whatever the project set up under that status in Settings → Statuses (Sub-statuses). The menu opens by itself on the row you have just marked, under the button, or over it when the window has no room for it below. It says what it asks — «Why it failed — optional» — then the built-in names, the project’s own, and No sub-status. A click saves it; Esc or a click elsewhere leaves the result without one.

The menu opens by itself only while the row’s Sub-status ▾ button is fully inside the window. A marked row that lies above or below what the window shows keeps its mark, and its menu stays closed, so the page is not pulled away from the case you mark next. The button is on the row all the same: scroll to it and press it.

A marked row of a manual run: automated, gift wrap adds its fee, the message The fee is added twice at checkout., the failed badge, then Sub-status open by its button — Why it failed — optional; Product bug, Environment issue, Test is outdated, Flaky test; and No sub-status, ticked. Beside the button, by Alex Morgan · now, and Change. A marked row of a manual run: automated, gift wrap adds its fee, the message The fee is added twice at checkout., the failed badge, then Sub-status open by its button — Why it failed — optional; Product bug, Environment issue, Test is outdated, Flaky test; and No sub-status, ticked. Beside the button, by Alex Morgan · now, and Change.
The menu after a mark: the built-in names first, then the project's own, and No sub-status.
  • The name stands on the row in place of «Sub-status», and opens the menu again to change or clear it.
  • A status with nothing set up has no button. skipped and broken have no built-in one, so until the project adds its own, their rows have no Sub-status ▾ at all.
  • A new status starts without one. Change to another status drops the sub-status, since it was the old status’s; the menu opens again on the row, while its button is inside the window. The same status keeps it.
  • The name is kept as it was given. A sub-status renamed or removed in Settings afterwards stays on the result, and shows ticked in its menu until another is picked.
  • A reader sees the name as a tag on the row, and no button.

On the wire it is the same PATCH as a correction, with the sub-status alone:

{ "subStatus": "Product bug" }

null clears it. A name the result’s status does not offer now answers 400 with the ones it does — ‘Test is outdated’ is not a sub-status of passed — it has Minor issue. A closed run keeps its marks, so its sub-statuses too (409). The mark itself, POST /v1/runs/{id}/results, carries none: the status button stays the request, and the sub-status follows it.

Add tests, beside Launch run or Finish run, takes more cases into a run that is still open — scheduled or launched. Two roads, one at a time:

  • Cases — the tree, suite by suite, with a search by the case’s or the suite’s name. A suite’s box takes its cases; a case is ticked on its own. A case the run already holds says in the run and cannot be ticked.
  • Plans — several at once. A plan is read when you tick it, and what it matches then is what goes in.

Under both, the dialog says what it will do — «+ 4 cases → «Release regression» · 2 already in it» — and Add 4 cases does it. The cases join the run unmarked, after the ones it expected; with Prefer case assignee, each brings its assignee. A case is never in a run twice: one case, one result. If somebody added the same case a moment before you, the platform skips it and the page says so — «Added 2 cases. 2 already in the run were skipped — one case, one result.»

The Add tests dialog of the run Checkout release: Cases, picked, and Plans; Find a case or a suite, empty; the checkout suite open, 6, its box off, and its cases ticked in grey with in the run — Pay by card, Apply a voucher, Guest checkout, Change the address, card is charged once, voucher code ignores its case; the delivery suite, 3, ticked and folded; + 3 cases → «Checkout release»; Tick a suite to take its cases. A case already in the run is not added again — it keeps its one result. Then Cancel and Add 3 cases. The Add tests dialog of the run Checkout release: Cases, picked, and Plans; Find a case or a suite, empty; the checkout suite open, 6, its box off, and its cases ticked in grey with in the run — Pay by card, Apply a voucher, Guest checkout, Change the address, card is charged once, voucher code ignores its case; the delivery suite, 3, ticked and folded; + 3 cases → «Checkout release»; Tick a suite to take its cases. A case already in the run is not added again — it keeps its one result. Then Cancel and Add 3 cases.
Add tests over the tree: what the run holds says in the run, and a ticked suite brings its cases.
POST /v1/runs/{id}/cases
{ "testCaseIds": ["6f1c2b3a-0000-4000-8000-0000000000c4", "6f1c2b3a-0000-4000-8000-0000000000c5"] }

The answer is added, the ids the run now expects, and skipped, each with a reason: in_run — the run holds the case already, expected or marked — or not_found — no such case in the project, or it is in the Bin. Up to 10 000 ids a call. Only an open manual or mixed run takes cases: a finished or terminated run, or an automated one, answers 409; a reader, 403.

How a project walks its manual runs is six settings in Settings → General, under Execution: «How a manual run is walked. The server applies these when a mark is saved or a case is opened, so every client behaves the same.» Five are switches, off until someone turns them on; the sixth is a choice, Next case in the run until someone picks another.

settingwhat it does
Fast passA passed or skipped mark asks for no details.
Auto passEvery step of the case passed makes the case passed.
Fail case on step failA failed or blocked step makes the case failed.
Auto assigneeThe first person to open a case nobody holds becomes its assignee.
Assignee result lockOnly the assignee can submit or change the result of a case that has one.
Redirect after resultWhere the run goes after a result is saved: Next case in the run, The same case or Nowhere.

Plune applies them, not the page: the API takes a mark and decides by the project’s settings, so a script that marks through the API gets the same verdict as the dashboard. Each applies from the next mark or the next case opened, also in runs already under way. They judge a person’s marks only — a reporter’s results stand as the reporter sent them.

An owner or a member changes them; each change is saved at once. A reader sees them and cannot change them — the API answers 403. If someone saved the settings while you had them open, nothing is saved and the page says «The settings changed while you were editing them, so nothing was saved. Reload to see the current list, then repeat your change on it.», with Reload.

After a mark, the Sub-status ▾ menu opens by itself on the row, while the row’s button is inside the window. With Fast pass, a Passed or Skipped mark goes without it: the row is marked and the run moves on. The menu is still on the row’s button. A Failed mark opens it as before.

With every step of the case marked passed, the case is saved passed, whichever of Passed, Failed or Skipped was pressed. A step left unmarked, or marked anything else, leaves the mark as it was pressed, and so does a case without steps. Only the case’s own steps count.

With a step marked failed or blocked, the case is saved failed, whichever button was pressed. A skipped step does not fail it. This switch is looked at before Auto pass, and the two cannot meet: a case with a failed or blocked step does not have every step passed.

Without the switch, a blocked step changes nothing. A blocked case keeps its meaning — something outside it stopped it (statuses); it is the blocked step that this switch counts as a failure of its case.

Both step switches judge Change too, when it changes the status or the steps. A corrected message alone leaves the verdict as it was. The marked row shows the status Plune saved.

The first person to open a case that nobody holds in the run becomes its assignee in this run — on the run page a case opens as soon as it is the first waiting, or when you press its name — and so does the first to mark one. Two people opening it at once cannot both win, and a case that already has an assignee, from Prefer case assignee or from an earlier opening, is never taken over. The name shows on the case’s row.

A case that has an assignee in the run is marked, and its mark changed, by that person alone. Anybody else is refused, and nothing is written: 409 with code: "assignee_locked" — «case ’…’ is assigned to someone else - only they can mark it», or for Change, «the case is assigned to someone else - only they can change its mark». A batch of marks with one such case in it is refused whole. A case nobody holds is open to everybody, as without the switch.

  • Next case in the run — the next case the run expects that has no result yet opens, and after the last one the first that still waits. With none left, nothing opens.
  • The same case — the case just marked stays open: its Change opens on the row.
  • Nowhere — nothing opens; press a case’s name to mark the next one.

On the wire the six are executionToggles in the project’s settings:

PATCH /v1/settings
{
"executionToggles": {
"fastPass": true,
"autoPass": false,
"failOnStepFail": true,
"autoAssignee": true,
"assigneeResultLock": false,
"redirectAfterResult": "next"
}
}

PATCH /v1/settings replaces the whole document, so send it back as GET /v1/settings gave it, with the change; absent, all five are off and redirectAfterResult is next (or same, none). The answer to a person’s mark, POST /v1/runs/{id}/results, says what the switches decided: each item’s resultStatus is the status saved, and after carries skipDetails — Fast pass — and redirect with its mode and the testCaseId to open, null for none. Opening a case is POST /v1/runs/{id}/cases/{caseId}/open, which answers { "assignee", "claimed" } — who holds the case now, and whether this call made you its assignee.

A case marked already can be sent back to be run again, in the same run, while the run is launched. Each marked row has a box; tick the cases, and Retest 3 in the head sends them back.

  • The mark goes to the history. It is not deleted: it stays in the case’s history and no longer counts in the run.
  • The case waits. It comes back to To run, after the cases never run, with Awaiting retest on its row. It is in no count of the run and not among the cases not run.
  • A new mark ends the wait. Open it and mark it, as any case; the new result is the case’s answer in the run.
  • The run does not finish while a case waits. Finish run is refused with 409 and code: "retest_pending", which names the cases that wait — mark them first. Stop run ends a run with a wait in it.

A page opened before the retest may still show the old mark with Change. Changed while the case waits, that mark stays in the history and the case keeps waiting; changed after a new mark arrived, it is the case’s answer again, as of the change.

An automated run that is under way has Retest too, from a box on each result. Its cases wait under Awaiting retest — «These cases wait for the next result of the case from the reporter; the run does not finish until it arrives.» — and the reporter’s next result of the case ends the wait. Owners and members retest; a reader sees no box.

POST /v1/runs/{id}/retest
{ "testCaseIds": ["6f1c2b3a-0000-4000-8000-0000000000c1"] }

The answer is retested, the cases now waiting, and skipped, each with a reason: no_result — the run holds no result of it to send back — or awaiting — it waits already. A finished, terminated or saved run answers 409, as does an eval run. GET /v1/runs/{id}/summary lists the waiting cases as awaitingRetest.

Finish run sends POST /v1/runs/{id}/events with { "event": "finish" }. With cases still to run, the dashboard asks first and says how many will stand as not run — «3 of 12 done → finished · 9 cases not run». With a case awaiting retest, it does not ask: the run is refused and says which cases wait. Once closed, the To run section is gone, the head is the verdict of the counts, and the page names what never arrived: «9 expected cases produced no result» — the run’s notRun, which a reporter’s crashed shard leaves behind in exactly the same way.

A mixed run — from a plan of that kind, or started as one through POST /v1/runs — has both halves on one page. The manual cases are in To run; the automated ones wait below under Waiting for a reporter, with the command that starts them where your tests run — a terminal or a CI job. The reporter joins the run by its key (plune run start --key …, or the Playwright reporter’s PLUNE_RUN) and reports them, and its results take those cases out of both lists. The counts, the verdict and notRun are one set of numbers over both sources, and Finish closes the run for both — a reporter that reports afterwards is refused as it is today.

The command puts the run’s key in PLUNE_RUN and the run’s automated cases in --grep, with copy beside it. A run from a plan greps by the plan:

Terminal window
PLUNE_RUN=rk_4f7c2a9e1b PLUNE_SHARED_RUN=1 npx playwright test --grep "$(plune plan grep 6f1c2b3a-0000-4000-8000-0000000000f3)"
Waiting for a reporter on the run's page: Start them with this command — the reporter joins this run by its key, then the command PLUNE_RUN=rk_4f7c2a9e1b PLUNE_SHARED_RUN=1 npx playwright test --grep "$(plune plan grep …)" with the plan's id, and copy; the line Connect CI in Settings → Integrations — Plune starts them for you.; under it the two automated cases, card is charged once and voucher code ignores its case. Waiting for a reporter on the run's page: Start them with this command — the reporter joins this run by its key, then the command PLUNE_RUN=rk_4f7c2a9e1b PLUNE_SHARED_RUN=1 npx playwright test --grep "$(plune plan grep …)" with the plan's id, and copy; the line Connect CI in Settings → Integrations — Plune starts them for you.; under it the two automated cases, card is charged once and voucher code ignores its case.
A mixed run of a plan: the automated cases wait under the command that starts them.

A run of no plan greps by its own key, with plune run grep from CLI 0.21.0. It takes the run’s automated cases — the ones it expected, those added with Add tests among them, and the ones it holds a result of:

Terminal window
PLUNE_RUN=rk_4f7c2a9e1b PLUNE_SHARED_RUN=1 npx playwright test --grep "$(plune run grep rk_4f7c2a9e1b)"

The plan’s Launch a run dialog shows the same command before the run exists, under Automated cases · 5. Plune issues the key when the dialog opens (POST /v1/runs/keys), so the command there is the real one, and Save or Launch keeps that key as the run’s externalKey. A saved run starts when someone launches it, or when the command reports first.

PLUNE_SHARED_RUN=1 is there because Finish run closes this run, so the reporter leaves it open when its tests end. A plan of automated cases alone gets the command without it, and its reporter closes the run.

Only values Plune issued go into the command — a key as Plune makes it, rk_ and ten hex, and the plan’s id, a UUID — each checked against its shape. A key from anywhere else, such as a CI run’s id a reporter chose, never goes into a line you paste into a shell. A run of no plan names it in words instead: «Automated cases are marked by the reporter that joins this run by its key …». A run from a plan shows <run-key> in the command, with the same words under it.

A random distribution of cases among members (only «prefer case assignee» and Auto assignee exist), statuses of your own beside the five (a sub-status says why within one), starting the automated half in CI from Plune — it gives the command, and CI runs it — and a manual mark’s steps in the case page’s history — the history shows the mark’s status, not its steps.

Several environments at once are not one run, they are a group of runs, one per environment: Launch on several environments.