Oko
Oko/Docs

Command reference

oko defects recurrences

Lists every recurrence of an operator-reported class after its class repair, with the mechanism each passed; `check` runs every repaired class's completion probe at the head of its checkout and turns a probe that lists an instance into a recurrence without anyone recording it again.

Invocation#

Command
oko defects recurrences [check [--socket PATH]] [--json]

Inputs and options#

  • Without a verb the command reads the register. `check` runs, for every class (`--class`, not withdrawn) whose repair is recorded (repaired, claimed or closed) and which declares a completion probe, that probe at `<repository>@HEAD` of the checkout its repair names, and only when that head carries the repair (`git merge-base --is-ancestor`): a head without the repair says nothing about it. --socket names the broker the owner's notice goes through; without it the local broker is used.
  • A recurrence is found three ways, and each counts the same: a defect recorded with, or later given, the class's shape after the class repair (`oko defects record`, `oko defects shape`); a moment of the operator's frustration that intake places on a class carrying a repair, said after that repair (`oko defects intake`); and the class's own completion probe listing an instance at its checkout's head (`check`).
  • For example: `oko defects recurrences check --json` on the standing routine, `oko defects recurrences` to read what came back and which mechanism let it through.

Output and state effect#

  • Without a verb it prints one line per recurrence, newest first: `<at> <class> recurred after its repair at <revision> (found by <defect, moment or the class itself>); mechanism: <prevention or no prevention declared>`, then one line per mechanism: `mechanism <prevention> let <n> recurrence(s) through: <classes>`. --json prints `{recurrences: [{class, title, owner, defect, repair, at, probe, mechanism, reopened}], mechanisms: [{mechanism, recurrences, classes}]}`; `probe` is `{revision, instances, command}` for a recurrence the probe found, and `reopened` says the class no longer carries the repair it disproved.
  • `check` prints `recurred: class <id> at <revision> lists <instance>, <instance>…; claim <id> charged; owner notice sent to <owner>` (`no claim charged: the repair carries no recorded claim` when the repair has no claim, `owner notice not sent: <cause>` when the class records no owner or the broker refused the notice), `held: class <id> at <revision>` and `unread: class <id>: <cause>`; every value is printed as its text, a list as its items joined by commas. --json prints `{held, recurred, unread}`. Each recurrence puts the broken verdict `oko defects recurrences check: the class's completion probe at the head of its checkout` on the repair's claim at that revision, which charges the session and model the claim names; reopens a class whose record still carries a repair (`recurrence: the completion probe <command> of class <id> lists <n> instance(s) at <revision>, after its class repair at <repair>; mechanism <prevention> let the shape through: <instances>`); keeps the recurrence on the class with its probe and the prevention it passed (`passed`); and sends the class's owner the evidence through the broker. A notice the broker refused is kept in the receipt with its cause; it does not undo the recurrence.
  • `oko defects show` prints each recurrence as `recurred at <time> after the class repair at <revision>: <its completion probe listed <n> instance(s) at <revision> (<instances>) | <defect> was recorded with its shape>, <through mechanism <prevention> | with no prevention declared>`.
  • `oko sessions scorecard` charges each recurrence to the mechanism it passed as well as to the session and model: every charge carries `mechanism`, the card carries `mechanismCharges [{mechanism, recurrences, classes}]`, and the lines read `recurrence <defect> disproved the repair of operator-reported class <class> at <revision> (claim <id>) through mechanism <prevention>` and `mechanism <prevention> let <n> recurrence(s) through: <classes>`.
  • The improvement loop's rediscovered-causes signal counts each recurrence in its window beside the observations and blockers met on unrepaired defects: `<id> met <n> times (<a> observation(s) noted without a repair, <b> blocker(s) waiting on it, <c> recurrence(s) after its repair; recurred after its class repair: <how, through which mechanism>): <title>`.
  • The standing routine `defect-recurrences` (action `recurrences`) runs `check` on every machine Oko is installed on. The native API's defects actions `recurrences` and `recurrences_check` answer the same documents; Oko Desktop's Shapes section lists the recurrences and mechanisms, and its check button runs `recurrences_check`.

Refusals and safe exits#

  • `oko defects recurrences takes check or no verb; it was given <word>`; a flag outside --socket and --json is refused by name (exit 2).
  • A class whose checkout head cannot be read, does not carry the repair, names a home document or no `<repository>@<commit>`, or whose probe refuses, is listed under `unread` with that cause, never taken for the shape being gone or back.
  • A broken verdict, reopening or recurrence write that cannot be written refuses the whole check with its cause; the recurrences already kept stay.

CLI reference#