Glossary¶
This page explains the terms that the docs use. The entries are in alphabetical order. Each entry says what the term is and why it is important. Then it links the page that explains the term in full. When the docs use more than one word for a concept, the entry has the preferred word, and a line "Not:" lists the other words. Each other word that you can look up has its own short entry, which says "See" and names the preferred word. For the kit at a glance, read the overview first.
ACCEPT¶
ACCEPT is the verdict that a verifier gives when the work does what the ticket asks. Only an ACCEPT moves the run branch, so work that nobody checked cannot reach it. See the verifier step.
Active run¶
An active run is a run that a live process works on now. Its journal has no run-end after its newest resume, and a process holds the lock of its run branch. delegate status and delegate watch with no run id choose the run from the active runs. A run that stopped, paused or ended is not active. See the run with no run id.
Adapter¶
An adapter is a Python object that drives one harness through the headless command line of that harness. The engine is the same for each harness, so a new harness needs only a new adapter. See the adapter interface.
ADR¶
An ADR (architecture decision record) is a short file that gives the context, the decision and the consequences of one design decision. A contributor can read the reason for a rule without access to a private tracker. See the decision records.
Agent pair¶
An agent pair is a specialist and its verifier, which one declaration renders for each harness. The two halves come from one file, so they cannot drift apart.
Not: pair, specialist-verifier pair. Write "agent pair" in full.
See why each specialist has its own verifier.
Allowlist¶
The allowlist is the file in the kit that names each permitted exception to the neutrality check. Each entry is a permanent exception with a reason, so the list stays short and visible. It is not the list of commands of the verifier guard. See the neutrality check and the format of the lists.
Anchoring¶
Anchoring is the effect of a report on a reviewer: the reviewer looks where the report points, and not at what the report omits. The verifier is blind to prevent anchoring. See why the verifier is blind.
ASD-STE100¶
ASD-STE100 Simplified Technical English is a standard of controlled English: short sentences, active voice, and one meaning for each word. A repository can select it as the output language of its agents, because ambiguous text from one agent causes a misparse in the next agent.
Not: STE. Use "STE" only for the option value ste.
See why the kit uses it and the output language.
assure¶
assure is the mode that verifies each ticket branch at once, before the next ticket builds on it. It finds a defect early, and it costs more tokens and more time than economy. See the mode trade-off.
Base branch¶
The base branch is the branch that a run starts from, for example main. The engine never merges into it, because the merge is an action of the coordinator. See the fields of a workflow.
Blind¶
A blind verifier gets the ticket and the diff, and never the report of the specialist. The report is a claim, and a verifier that reads it looks only where it points. See why the verifier is blind.
Blocker¶
A blocker is a ticket that must be built before another ticket can start. The engine builds the tickets in the order that the blockers set, and it skips a ticket whose blocker failed.
Not: blocking edge, dependency. Use blocked-by only for the field of a workflow.
See the tickets of a workflow.
Bootstrap¶
Bootstrap is the command delegate bootstrap, which writes the context skill, the declaration and the agent pair of a repository from one set of arguments. The docs and the agents come from the same answers, so they cannot drift apart. See the bootstrap command and the bootstrap rules.
Brief¶
A brief is the prompt that an agent gets for one task: the ticket, the file boundary, the gates and the report path. The engine writes each brief, so no agent gets a brief that a person wrote by hand. See the specialist brief.
Brief generator¶
The brief generator (delegate brief, or verifier-brief) builds the brief of a verifier from the task, the diff and the gates. It never puts a line of the specialist report in the brief, so the verifier stays blind. See the brief reference.
Built¶
Built is the state of a ticket that passed each part of its step. Together with the verdict ACCEPT, it tells you that the ticket is done and checked. See the states of delegate status.
Chain¶
A chain is the sequence of tickets in economy mode: each ticket branch starts from the branch of the previous ticket. One verifier checks each stack at the end of the chain, so a long chain costs fewer tokens. See the economy chain.
Command guard¶
See Verifier guard.
Context¶
A context is one of the two parts of the package that hold the domain: the run context and the definitions context. Neither imports the other, so a change in one cannot break the other. See the two contexts.
Context skill¶
A context skill is the skill that delegate bootstrap writes for a repository. It reads the reference documents of the repository when the agent loads it, so no copy of a document goes out of date.
Not: repo-context skill.
See the bootstrap command and the bootstrap rules.
Continuation¶
A continuation is a new run of a specialist in the same worktree, after the specialist stopped capped or failed, or left a red gate. A specialist that committed work with a report that is not valid also continues: it writes only a corrected report. The commits stay, so no finished work is lost, and each mode sets a limit. See the continuation.
Contract test¶
A contract test replays a recorded event stream through a stand-in harness command, and checks the result of the adapter. It shows that the adapter reads the stream of the real harness, with no model and no tokens. See the contract-test pattern.
Coordinator¶
The coordinator is the person who directs the work, from a terminal or from an interactive harness session. The coordinator owns each action that the engine never does: the merge, the push, and the close of a ticket. See the team and the roles.
Declaration¶
A declaration is a TOML file that describes an agent pair: the domain, the tier, the skills, the references and the gate commands. The renderer writes both halves of the pair from it, for each harness. See why one declaration renders the pair and what a declaration is.
Delegation doc¶
See Delegation document.
Delegation document¶
The delegation document is docs/agents/delegation.md in a repository: the gates, the hotspots and the rules that bind each agent. The brief generator reads the gates from it, so the verifier runs the gates of that repository.
Not: delegation doc.
See how to write it.
Delta¶
The delta is the diff from the rejected commit to the tip of the branch after a fix-up. The fix-up verifier reads only the delta, so it does not read again the work that the first verifier checked. See the fix-up round.
Denylist¶
The denylist is a private list of terms that must not appear in the kit, for example the names of persons and companies. It stays outside the repository, and the neutrality check reads it from a path. See the neutrality check and the format of the lists.
economy¶
economy is the mode that builds the tickets as a chain and verifies once for each stack at the end. It costs the fewest tokens, and a defect shows only at the end of the chain. See the mode trade-off.
End state¶
The end state is how an agent run stopped, as the adapter reads it from the event stream: finished, failed or capped. The engine uses it to decide whether the step goes on, continues the specialist, or fails. See the adapter interface.
Engine¶
The engine is the program behind delegate run. It makes the worktrees, spawns the agents through an adapter, runs the gates, writes the briefs, and records each step in the journal. The most important rules are in code, not in a model session that can forget them.
Not: workflow engine. Use the long form only in a title.
See the delegate run reference.
Event stream¶
The event stream is the line-delimited JSON that a harness writes in a headless run. The adapter keeps a copy beside the report. A recorded stream is an event stream that a test replays, and it is the base of each contract test.
Not: stream, fixture. Say "recorded stream" for a stream that a test replays.
See what an event stream is and the event stream of the claude-code adapter.
Fail closed¶
Fail closed is the behaviour of a guard that blocks a call that it cannot check, for example a call with no command text. The cost of a closed failure is a lost convenience, not a hole in the guard. See how I read the limits.
File boundary¶
The file boundary is the part of the brief that names where the specialist works and which paths it must not change. The ticket holds no file path, so the engine adds the boundary when it starts the step. See the specialist brief.
Finding¶
A finding is one defect that a verifier reports in its verdict. A REJECT needs at least one finding, and the fix-up specialist gets the findings verbatim. A finding is not a finding code of the validator, and not a hotspot finding. See the verdict report.
Finding code¶
A finding code is the code that the validator writes for one problem in a rendered agent file, for example MISSING_TWIN. Each code names one rule of a harness schema, so you know what to correct. See the finding codes.
Fix-up¶
A fix-up is the round that follows a REJECT, red gates after a fix-up, or red gates on the tip of an economy chain. In a fix-up, the specialist adds a new commit for the findings or the red gates, and a fresh verifier checks the delta. A fix-up never amends, because an amend destroys the delta. Each mode has a limit of rounds.
Not: fixup, fix-up pass, scoped fix-up. Use fixup only in the command delegate brief fixup.
See the fix-up round.
Fixup¶
See Fix-up.
Fleet¶
A fleet is the set of hosts that delegate runs reads, with the runs of each host. It has this machine and each other host that the run index or the configuration file names. One command shows the runs of all the hosts. See the fleet lines.
Frontmatter hook¶
See Harness hook.
Gate¶
A gate is a command that proves that a change is good in a repository, for example the test suite or the build. The engine runs each gate itself, so the evidence never comes from the agent that wrote the code. The verifier can run the gates of its repository, and no other build command.
Not: gate command. Use "gate command" only for the option --gate-command and the key gateCommands.
Gate command¶
See Gate.
Gateway¶
A gateway is a service that serves models under its own names, for example the LLM gateway of a company. A tier file points each tier at a model of the gateway, so no workflow changes. See what a gateway is and how to point the tiers at a gateway.
Generated section¶
A generated section is the part of a reference page between the generated:begin and generated:end markers, which delegate docs writes from the code. A test fails when a section differs from the code, so the reference cannot drift. See delegate docs.
GET-only command¶
A GET-only command is a command that the verifier can run only while it reads, for example a script that sends an HTTP GET. The guard denies it when an argument sets a method, a body or an output file. See the options of bootstrap and gate commands.
Git backend¶
The git backend is the code that implements the version-control port with real git commands. No other code starts git, so the engine names no git command. See the adapters.
grilling¶
grilling is a planning skill of mattpocock/skills that asks you questions, one round at a time, until each decision of a plan is made. The decisions are settled before a spec exists, so no agent guesses them. See the grilling skill and the idea.
Guard probe¶
A guard probe is a short session that the engine starts to show that the harness runs the guard of a sealed agent. It asks for one command that the guard must deny. The probe is denied only when the event stream shows a tool call of that command with an error result from the guard. A final text that tells of a denial is not enough, because a model can decline the command and write that it is not permitted. See the guard probe.
Not: canary, guard check.
Halted¶
Halted is the state of a run that a failure of the harness stopped, for example a harness that is not logged in. The journal holds halted and no run-end, and a resume goes on with the run. A run that cannot be resumed is not halted. See a failure of the harness and a run that cannot be resumed.
Harness¶
A harness is the tool that runs a coding agent, for example Claude Code or OpenCode. The engine drives each harness through an adapter, so the protocol is the same in every harness. See what a harness is and the adapters.
Harness hook¶
A harness hook is a guard in an agent file that the harness runs before a tool call: a push guard for the specialist, and the verifier guard. It is a second guard, because a hook does not always run in a headless run.
Not: frontmatter hook.
See why git, and not the harness.
Headless¶
A headless run is a harness run with no interactive terminal: the harness takes a prompt, writes its events, and exits. The engine drives each harness this way, so a run needs no person at the terminal of each agent.
Not: print mode.
Host reader¶
A host reader is the port that delegate runs drives to read the live runs of one other host. It gives the answer of the host, or the reason that the host is unreachable. The adapter that implements it uses ssh. See the other hosts.
Hosts key¶
The hosts key is the key hosts of the configuration file of the user, ~/.config/delegate/config.toml. It is a list of the ssh names of the other hosts that delegate runs reads on this machine. It is a setting of a machine and of a person, not of a repository, and an agent never writes it. See the configuration file.
Hotspot¶
A hotspot is a path that only the coordinator changes, for example the licence or the CI configuration. The engine stops a step whose diff touches a hotspot, and no verifier starts.
Not: single-writer file. A hotspot finding is the record of a diff that touches a hotspot.
See the hotspot guard.
Implementer¶
See Specialist.
Invariant¶
An invariant is one of the seven rules that hold in every mode, for example "the verifier is blind". No setting changes an invariant, so a cheaper mode never gives a weaker check. The worktree invariant is a different check. See what no mode gives up and the invariants of every mode.
Journal¶
The journal is the append-only JSONL file of a run, with one line for each event. The engine resumes a stopped run from it, and delegate status and delegate watch read it. See the journal.
Ladder¶
The ladder is the eight levels of agentic engineering of Bassim Eledath, from tab completion to autonomous agent teams. Its rule is that levels 3 to 5 must hold before more automation helps. delegate is one vertical slice through levels 2 to 7.
Not: levels of agentic engineering. Use the long form only for the title of the article.
See the ladder and the article.
Lane¶
A lane is the row of one run in delegate runs --timeline. It shows the time of the run across the last 6 hours, and on to its ETA. You see all the runs on one time scale. See the lanes.
Levels of agentic engineering¶
See Ladder.
Live smoke run¶
A live smoke run is one run of an adapter against the real harness on a real machine. The reference page records the harness version and the date. It shows what a recorded stream cannot show: that the real harness gives that stream. See the live smoke run.
Max turns¶
See Turn cap.
Mode¶
The mode of a run is assure or economy. It sets when the verifier runs, the tier of the specialist, and the limits, and it never changes an invariant. The verifier mode is a different term. See the mode trade-off.
Neutrality check¶
The neutrality check is a test that fails when a term of the denylist appears in the kit. The kit holds no personal or company value, so each repository keeps its own values in its own configuration. See the neutrality check and the format of the lists.
Pair¶
See Agent pair.
Pause¶
A pause (delegate pause) asks an active run to stop at its next step boundary. The engine cuts off no agent and no gate, so no work is lost. The journal gets paused and no run-end, and a resume goes on with the run. Ctrl-C stops a run at once, also inside a step. See the pause.
Permission mode¶
The permission mode is a setting of a harness session. It sets what the session does with a tool call that no allow rule permits. dontAsk is one permission mode of Claude Code: it denies such a call, because a headless session cannot ask. It is not the mode of a run. A host that runs agents in such a mode gives them a settings file with allow rules. See what the adapter does not set and the settings of a host.
Plan change¶
A plan change is a resume with a workflow whose tickets differ from the newest plan of the run. It can add tickets, and change or remove tickets that have not started. The built part of the run is fixed. The journal records the change in the event plan-change. A later ticket of the change needs --reviewed, and its brief gets the section "Plan change". See the plan change.
Port¶
A port is an interface that the run context drives: the harness port, the version-control port or the gate port. A port names no outside tool, so a test can pass a scripted object in its place.
The code that implements a port is an adapter for the harness port. For the other two ports, it is a backend.
See the ports.
Pre-push hook¶
See Push guard.
Print mode¶
See Headless.
Protocol¶
The protocol is the set of rules for delegation in the agent-delegation skill: the roles, the brief template, blind verification, fix-ups and hotspots. The engine applies the same rules, and you can apply them by hand for one task. See the parts of the kit and the agent-delegation skill.
Push guard¶
The push guard is a pre-push hook that the engine sets in each worktree that it makes, and the hook refuses each push. It uses git, so it holds in every harness, also in a headless run.
Not: pre-push hook, push hook. Say "push guard" for the guard, and pre-push for the git hook that holds it.
See the push guard.
Red proof¶
A red proof shows that a test can fail: the verifier breaks the code that the test covers, and the test goes red. A test that passes before and after a change protects nothing. See why the verifier runs the gates.
REJECT¶
REJECT is the verdict that a verifier gives when it finds at least one defect. The run branch does not move, and a fix-up round starts. See the fix-up round.
Renderer¶
The renderer (delegate render) writes the agent files of each harness from a declaration. Nobody writes an agent file by hand, so the two halves of a pair stay in step. See the render command and the rendering rules.
Report¶
The report is the JSON file that the specialist writes at the end of its run: its status, its commits, and its claim about the gates. The engine checks its form, and it never shows it to the verifier.
Not: specialist report. The file of the verifier is the verdict report.
Resume¶
A resume (delegate run --resume) goes on with a run that stopped or paused, from its journal. It never builds a step that ended again, unless --retry names it. A resume with a changed workflow is a plan change. An adapter can also resume a harness session for a continuation, which is a different use of the word. See the resume.
Reviewer¶
See Verifier.
Run¶
A run is one execution of delegate run over a workflow, with its own run id and its own journal. A run that stops or pauses goes on with a resume. See what a run does.
Run branch¶
The run branch is the branch that the engine owns, and only accepted work lands on it. The coordinator merges the run branch into the base branch. See the fields of a workflow.
Run context¶
The run context is the values that do not change during a run: the workflow, the adapter, the version control, the gate runner, the tiers and the paths. The engine makes it once and gives it to each function that needs it. See the layout of the package.
Run index¶
The run index is a list of runs, one record for each run. Each run writes its record there, with no setting. The journal stays the record of the run, so a failed write of the index loses nothing. The directory is DELEGATE_INDEX, else the key index of the configuration file of the user, else index/ in the state root of the machine. See the run index.
Run lock¶
The run lock is a kernel lock on a file that stops a second run on one run branch. The process of the run holds it, and the kernel releases it when that process ends, also after a kill. Two runs cannot race on one branch, and a lock file that no process holds is free. See the run lock.
Run state¶
The run state is the one fold of the journal of a run. It gives the outcome of each ticket and the state of the run. The engine and each view decide from it, so they cannot disagree. See one fold of the journal.
Run that cannot be resumed¶
A run that cannot be resumed is a run that an invariant violation or a moved run branch ended for good. The journal holds invariant-violation or run-branch-moved. No resume goes on with such a run, also not with --retry or a plan change. delegate status shows the reason in the note, and you start a new run. See the retry and the run branch check.
Sealed agent¶
The sealed agent is the copy of an agent file, its harness hooks and its project skills. The engine makes it from the main checkout at the start of a run, outside each tree. Each session of the run uses it, and only when the files of the seal match the record in the journal. See the agent check.
Not: bundle, plugin, snapshot.
Session¶
A session is one conversation of a harness with an agent, with a session id. The adapter resumes the session for a continuation when the harness supports it, so the agent keeps its context. See what a session is and the continuation.
Short run id¶
The short run id is the part of a run id after its last -: e9dc of 20261016T030000Z-e9dc. delegate status, delegate watch, delegate pause and --resume take it in place of the full id. A short id that more than one run has is an error, and the message names each run. See the reference of status and watch and the resume.
Skill¶
A skill is a directory with a SKILL.md file of instructions that an agent loads. The kit ships two skills, and each agent pair carries every skill of its stack. See what a skill is and how to write a skill.
Skip¶
A skip is the state of a ticket whose blocker is not built. The engine makes no worktree for the ticket and records the reason, so the journal shows why the ticket did not run. See the skip rule.
Slip¶
The slip is how much later the ETA of a run is now than it was 2 hours ago. delegate runs shows it from 30 minutes. A slip tells you that a run takes longer than planned. See the slip.
Snapshot¶
A snapshot is the state of a run at one time, as one JSON object. delegate status --json prints it. Other programs read it, so its fields do not change type or meaning. See the snapshot.
Spec¶
A spec is the plan of a piece of work: the problem, the solution and the decisions, from which the tickets come. The kit takes a spec and its tickets as input, and it replaces only the build step. See what a spec is and how to use the kit after to-spec and to-tickets.
Specialist¶
The specialist is the agent that builds one ticket, in its own worktree, inside its file boundary. It commits and never pushes, and its report is a claim that the engine checks.
Not: implementer. Use "implementer" only for the agent of another tool.
Specialist-verifier pair¶
See Agent pair.
Stack¶
A stack is one technology of a repository, for example a Python package or a web front end, with its own gates and hotspots. Each stack has its own agent pair, so each specialist carries every skill of its stack. See the stacks of a workflow.
State directory¶
The state directory is where the engine writes the journals, the reports, the worktrees and the locks of a repository. The working tree stays clean. By default it is <name>-<key> under $XDG_STATE_HOME/delegate, or under ~/.local/state/delegate, outside the git directory. DELEGATE_STATE_ROOT sets the root instead. The engine writes the path of the directory to the file delegate/state-root in the git directory, so a command finds the state without the variable. A run that started before the default changed (#200) stays in the directory delegate/ of the git directory. See where the engine writes.
STE¶
See ASD-STE100.
Step¶
A step is the work of the engine for one ticket: the worktree, the specialist, the checks, the gates and, in assure mode, the verifier. A failed step does not end the run. See what a step is and what a run does.
Step cap¶
See Turn cap.
Store of last answers¶
The store of last answers is the directory last-answers/ in the state root of a machine. It keeps the newest answer of each other host that delegate runs read. The command shows a host that is unreachable with its last-known runs. See the store of last answers.
Strength¶
See Tier.
Team contract¶
The team contract is what every agent gets, whatever its model: a role, the context, the tools, a definition of done, and an independent check. The model then changes only the quality of the code. See the idea.
Temporary copy¶
The temporary copy is a clone of the ticket branch that the engine makes for the verifier. Each verifier round gets a new copy, so no file of an earlier verifier stays. The verifier guard keeps the copy read-only, so for a red proof the verifier breaks a second copy in another temp directory. The real worktree stays as it was.
Not: verifier copy, copy.
See the verifier step.
Three-dot diff¶
A three-dot diff (git diff <base>...<branch>) shows the changes of a branch since the point where it left the base. The verifier then sees only the work of the ticket. See what a three-dot diff is and the verifier step.
Ticket¶
A ticket is one unit of work, written as behaviour, with the tickets that block it. It holds no file path, because the engine adds the file boundary when it starts the step.
Not: task, issue. Use "task" only for the section of a brief that holds the ticket text.
See the tickets of a workflow.
Tier¶
A tier is a strength that a workflow names in place of a model: strong, standard, cheap or verifier. The tier table maps it to a model for each harness, so a change of model changes no workflow.
Not: strength. The tier verifier is not the verifier agent.
See the tier overrides.
Tier file¶
A tier file is your own copy of the tier table, which you give with --tiers. It points each tier at the models that you can use, for example the models of a gateway. See how to point the tiers at a gateway.
Tier table¶
The tier table (tiers.toml) maps each tier to one model for each harness, and lists the models that the validator accepts. Each adapter reads its own column, so an adapter never chooses a model. See how to write a tier file and the tier table.
to-spec¶
to-spec is a planning skill of mattpocock/skills that writes a spec. The kit takes its output as input, and replaces only the build step. See how to use the kit after to-spec and to-tickets.
to-tickets¶
to-tickets is a planning skill of mattpocock/skills that writes tickets with blockers from a spec. The kit builds those tickets in the order that the blockers set. See how to use the kit after to-spec and to-tickets.
Tracer bullet¶
A tracer bullet is a narrow slice of work that goes through every layer and works from end to end. The to-tickets skill cuts tickets this way, and delegate is one tracer bullet through levels 2 to 7 of the ladder.
Not: vertical slice.
See the ladder.
Trend¶
The trend is how fast the tickets of a run end. It is a sparkline of the tickets that ended in each hour of the last 6 hours, and a word: speeding up, steady or slowing. See the trend.
Turn cap¶
A turn cap is the maximum number of turns of an agent run (maxTurns on Claude Code, steps on OpenCode). It is a stop for cost, not a lost deliverable, because the engine continues a capped specialist in the same worktree.
Not: step cap, max turns. Use "step cap" only for the OpenCode steps setting.
Twin¶
See Verifier.
Validator¶
The validator (delegate validate) checks rendered agent files against the schema of each harness, and writes a finding code for each problem. A harness skips some bad agent files with no error, so the validator makes the problem visible. See delegate validate.
Verdict¶
The verdict is the result of a verifier: ACCEPT or REJECT, with the evidence for each acceptance criterion, the gate output, the findings, and the items that it cannot verify. The engine reads it from the verdict report. See the verdict report.
Verifier¶
The verifier is the agent that checks the work of a specialist and gives a verdict. It holds the same skills as its specialist, it is blind and read-only, and it runs on the tier verifier in every mode.
Not: twin, verifier twin, reviewer. Say "verifier". Use "twin" only where the text is about the skills that the verifier shares with its specialist.
Verifier copy¶
See Temporary copy.
Verifier guard¶
The verifier guard is the hook in each rendered verifier that permits a fixed list of commands. The list holds read commands, the gates of the repository, and temp writes. A write must not be inside a git tree, or hold one. The verifier reports each refused command in the unverified list of its verdict. It does not run that command in another form, such as bash -c. It is a contract for the verifier, not a sandbox, so the engine also checks the worktree.
Not: command guard.
See the verifier guard and the verifier's shell.
Verifier mode¶
The verifier mode is full or fix-up, and the shape of the brief sets it. A full verifier reads the whole diff, and a fix-up verifier checks only the findings and the delta. See the brief command and the verifier modes.
Verifier twin¶
See Verifier.
Vertical slice¶
See Tracer bullet.
wayfinder¶
wayfinder is a planning skill of mattpocock/skills for work that is too large for one session. It charts the work as a map of decision tickets, and resolves them one at a time. See the wayfinder skill and the idea.
Workflow¶
A workflow is the TOML file that describes one run: the base branch, the run branch, the mode, the adapter, the stacks and the tickets. The coordinator writes it, and delegate run --dry-run checks it before a build. See the workflow file.
Workflow engine¶
See Engine.
Working copy¶
See Worktree.
Worktree¶
A worktree is a git working tree with its own branch, which shares the repository with the main checkout. Each specialist works in its own worktree, so its work stays apart from the main checkout and from the other tickets.
Not: working copy, checkout, clone. A clone is the temporary copy of the verifier.
See what a run does.
Worktree invariant¶
The worktree invariant is the check that the verifier left the real worktree as it was: the same HEAD and the same status. A difference is an invariant violation, and the run ends for good, whatever the verdict: it cannot be resumed.
Not: unchanged-worktree check, invariant check.