---
name: persistent-review
description: >
  Run concurrent persistent reviewers over functional groups with compact delivery audits and immediate findings logs. Use for
  explicit persistent-review invocation or a request for persistent adversarial review. Discussing, assessing, or
  editing the skill does not launch a reviewer; ordinary review requests do not activate this protocol.
---

# persistent-review

Run persistent reviewers under the caller's charter. The orchestrator divides the scope into functional groups, reviews
them concurrently, checks which required content reached each reviewer, repairs gaps in that reviewer's session, and
requires later-turn synthesis. Delivery evidence establishes neither attention nor understanding, correctness, or
saturation. Do not inspect or require hidden chain of thought.

Loading this skill authorizes no launch by itself and creates no session-wide policy. Apply it to the requested review
only. Codex and Claude are the supported reviewer backends; report other reviewer backends as unsupported. This does not
restrict which harness may orchestrate the review. Do not import lenses, panels, finding taxonomies, automatic fixes, or
VCS ranges from another review workflow.

## Set the review contract

Recover settled inputs from the caller's request and session context. Ask only for missing choices that affect the work:

- The review charter and relevant constraints.
- Exact required scope: files, ranges, diff sides, or other text, including mandatory context.
- Reviewer backend, model, and effort; preserve all three without substitution.
- Result destination and any caller-required reporting format.
- Any selected launch mechanism or explicit caller constraints on execution or further searching.

Keep reviewed inputs read-only unless the caller separately authorizes edits; writing the requested result and private
run artifacts is allowed. A finding is not permission to fix it.

Reviewers do not load this skill. Write each reviewer a self-contained brief file: the charter, its group's scope and
interfaces, constraints, the caller's finding format, the exact `evidence read` and `evidence record` commands with
absolute paths, the finding-event format and the reviewer-facing read rules from `tooling.md`, its own findings log and
progress file, and the persistence and investigation requirements below. Copy the immediate-recording instruction below
into every initial and continuation prompt. Tell each reviewer to finish its assigned pass after recording a finding;
finding an issue or reaching a particular count is not a reason to end the pass early. A same-session continuation
carries only what is new for that turn (named gaps, questions, cross-group input, the next pass's instruction), the
immediate-recording instruction, and the brief's absolute path with an instruction to reread it if the reviewer's
context was compacted. Do not paste the brief again.

Include this instruction in every initial and continuation prompt: validate findings through source and contract
analysis. Do not reproduce bugs or write reproductions unless the caller explicitly requests that work. Existing tests
and builds remain allowed, but execution is not required to substantiate a finding. Distinguish conclusions supported by
source from behavior observed during execution. The same rule applies to the orchestrator's candidate checks.

This protocol imposes no elapsed-time limit. Continue while the review makes progress under the charter and the stopping
rules below. Do not ask the caller for a time budget or invent an overall or per-turn deadline. The delegation and
shellout defaults requiring a hard deadline do not apply to this protocol; retain their monitoring and termination
mechanics for failed or stuck runs. Honor a time limit only when the caller explicitly supplies one.

## Stabilize the required input

Make a compact inventory of mandatory text with stable identities and range boundaries. Reuse immutable revisions and
caller artifacts where possible; otherwise retain the exact text in private scratch space. For a diff, preserve the
agreed old and new content, not a moving working-tree command. Full files are mandatory only when the agreed scope
requires them. Context the reviewer explores on its own does not silently expand the mandatory inventory.

Record the run's unique identity, absolute artifact paths, reviewer session handle, findings, and coverage notes in
session-private scratch space. Use the per-reviewer manifests and finding events described in `tooling.md`, and keep the
other coordination state in the current-state file described under "Keep the run moving and visible". Avoid fixed paths
that concurrent reviews could overwrite. Keep the raw evidence available behind compact references so the audit can be
checked without copying whole transcripts into the report.

Do not combine delivery evidence from different text versions. If the input changes, continue against the retained
version or explicitly reconcile the inventory and re-audit affected material; never silently claim the new version was
covered.

## Group by behavior and launch concurrently

This protocol governs review groups: delegated work that must deliver a mandatory inventory of reviewed text. A focused
task that judges named claims from the review's own output, such as verifying a finding or adjudicating a proposed
exclusion, using only the excerpts needed for those claims, is not a group. It inherits no persistence, delivery audit,
synthesis, or discovery requirement unless the caller explicitly asks for one; put its inputs in its prompt and follow
the caller's process for it. Work asked to search for new defects or assigned a range to cover is a group, whatever it
is called, and a group launched as a review group stays one. Record a focused task's verdicts durably when it returns; a
new defect it reports goes to the owning group's reviewer as cross-group input.

The orchestrator chooses coherent functional groups: a subsystem, feature path, state transition, or lifecycle, with the
contracts, callers, and tests needed to understand it. Record each group's purpose, required ranges, and interfaces with
other groups. Do not distribute arbitrary file counts or consecutive directory listings. Every mandatory range must
belong to a group; necessary context may overlap.

Default to at most 2,000 mandatory source lines and 64 KiB of source text per group, whichever is reached first,
including required context. Split larger subsystems at meaningful behavior boundaries; use named phases within a large
file when necessary. Do not pad a group to reach the ceilings, and do not split one behavior below them. If essential
context cannot fit, explain the boundary issue and obtain a caller-approved adjustment rather than silently assigning an
enormous group.

Every group costs at least three turns, the reviewer's setup reading, and an audit and parent decision per turn,
whatever its size. Keep adjacent phases of one behavior in one group. Many small self-contained changes may share a
group when the group notes list each with its purpose.

Before launching, report a launch plan to the caller in an interim message: group count against the minimum the ceilings
imply (total mandatory lines divided by 2,000), the distribution of mandatory lines, the minimum turn count (three per
group), concurrency, and any reading every reviewer must do besides its source, which is paid once per group. Give a
reason when the group count is well above that minimum. Launch without waiting for a reply unless the caller asked to
approve the plan.

Launch all independent ready groups concurrently by default, subject to actual harness slots and resource capacity.
Honor an explicitly requested concurrency restriction. Each group gets a separate resumable reviewer identity, manifest,
findings log, progress file, and transcript paths. Reviewers share stable inputs read-only and never write another
reviewer's artifacts. A large scope creates more bounded groups, not one enormous first pass.

Run every reviewer turn through the bundled scheduler; read `scheduling.md` before the first launch. It holds the queue,
the concurrency limit (change it with `schedule cap` when capacity changes, never by starting a second runner), and the
one-live-turn rule, and it starts queued turns as slots free up. You write each turn's launch script from the shellout
harness file and queue it with `schedule ready` only after judging the previous turn; the scheduler never advances a
group on its own. Learn of ended turns from `schedule wait`, and read `schedule status` for run state instead of
reconstructing it from reply files. Do not hand-roll batch runners or fixed identity lists.

The persistence, coverage, and discovery requirements apply independently to every group, and each group advances on its
own. Move a group from initial review to synthesis as soon as its own audit allows, and from synthesis to discovery
without waiting for unrelated groups. A group's discovery waits for synthesis, or an incomplete stop, in the interface
groups recorded in its group notes, and for nothing else. Track each group as queued, running, awaiting a parent
decision, complete, or stopped incomplete.

Deduplicate equivalent findings by underlying defect and location as results arrive, retaining all original reviewer IDs
and evidence. Keep distinct defects separate. Reconcile conflicting claims and send concrete cross-group interface
questions to the relevant existing reviewers for synthesis, batched into each reviewer's next continuation rather than
one turn per question. Do not assume isolated group completion proves integration correctness. Send new evidence or
findings to every group whose behavior or interfaces they bear on; until sent, they count as pending cross-group input.
Input that reaches a group after its discovery pass reopens it: one continuation synthesizes the input and then searches
again. An earlier empty pass does not close questions introduced later. The overall review is complete when it is
quiescent: every group meets its completion requirements, no cross-group input is pending, and each group's last
discovery pass ran after the last cross-group input sent to it. Any incomplete group keeps the overall review
incomplete.

## Record findings immediately

Tell every reviewer: **Your findings log is your complete record. As soon as you have a substantive finding, decide not
to report something you considered, or find a lead you cannot settle yet, append it as a `finding`, `candidate`, or
`lead` before any further analysis or read. Do not buffer records until a batch ends, a turn ends, a checkpoint, a final
response, or anticipated compaction; anything that exists only in your reply is lost.** Preserve the caller's finding
format in the record's detail. Do not invent findings to show activity.

Before reading source, create an empty findings log and a progress file naming the assigned group and current state. Use
the event format and append command in `tooling.md`. Each record has a stable reviewer-local ID, kind, summary,
location, detail, and open/withdrawn state. A `candidate` holds the reason it was not reported (refuted, covered by an
accepted limitation, or proposed for dropping) and the cited text. A `lead` is closed by a later event under the same ID
that changes its kind: to `finding`, or to `candidate` with what the checks showed. Append revisions with the same ID
and the reason; `withdrawn` retracts a record entirely; never erase the original. At each group/turn boundary, save
interface assumptions and the next action in the progress file before returning. This boundary summary never delays a
completed record.

Reviewers' first replies follow the caller's reporting format. Later replies report only what changed in that turn: the
checks run and their results, the IDs appended or revised, the IDs of leads still open, and, for a discovery pass, an
explicit statement of whether it found anything new. Unchanged records are referenced by ID, not restated. Put this
reply contract in the brief. Honor a caller format that requires cumulative replies, and state its cost in the launch
plan.

The orchestrator polls findings/progress artifacts while reviewers run and reports observed active findings separately
from the deduplicated total. Use `evidence findings` for counts and pointers. After each turn, read that turn's records
with `evidence events` from the offset the previous turn ended at, together with the delta reply. A reply that mentions
a new or revised record, or a closed lead, with no matching event in that range needs a continuation asking the reviewer
to record it. Inspect record details from the findings logs, not transcripts or earlier replies. An initialized empty
log means zero findings so far, not a clean review. Missing logs, stale progress, and unfinished writes require
investigation; do not credit advertised counts without records.

Create an empty disposition log at run start and register each reviewer's findings log in it with `evidence register`
when its group is created. Record every disposition the orchestrator decides there with `evidence dispose`, naming the
reviewer record, the log line it judged, and a deduplication group. Keep a consolidated draft of the result current with
`evidence consolidate` as decisions are made rather than assembling it at the end; it stays private until the caller's
recording checks. Its report of undecided, stale, and conflicting records and open leads is the list of decisions still
owed. Keep each reviewer's current offset and the disposition log's path in the current-state file.

## Establish observable delegation

Before choosing native delegation, establish that the parent can retrieve the child's actual delivered input and tool
results in a supported format, distinguish omissions, and continue the same session. A native tool's support for the
requested model does not establish those capabilities. A human-visible UI or parent-only activity log does not establish
them either.

Use native delegation only when those capabilities are available and verified. Otherwise use the requested backend's
observable shellout path, even if its model is available natively. Honor an explicitly selected mechanism; if it cannot
meet this contract, report the limitation instead of silently changing it. If neither an authorized native path nor a
usable shellout path meets the evidence and continuation requirements, report an incomplete review.

For shellout, load the dependency below. Before choosing an external evidence source, read its relevant harness file:
`harness/codex.md` for `codex exec`, or `harness/claude.md` for `claude -p`. Those files own launch, capture, transcript
access, resume, monitoring, and termination mechanics. Use their verified delivery semantics, not an assumed JSON shape
or the largest available output dump. When the local tools differ, verify the relevant semantics before crediting
evidence. Do not duplicate launch templates here. Read `tooling.md` and use its `evidence` launcher for normal coverage
audits and helper failure handling. The helper checks actual delivered read packets against pinned source text and
returns ranges and evidence references, without pulling code or unrelated transcript content into the orchestrator's
context.

A tool failure is not an empty or successful audit. Report its diagnostic and preserve findings. Retry a known clipped
read with smaller packets, or an unfinished log after the writer reaches a turn boundary. The audit does not fail on
transcript shapes it does not know; it skips them without credit and names them under `unrecognized`. Judging those is
your job: when missing ranges match reads the reviewer reports making and an `unrecognized` kind could plausibly carry
tool output, treat it as a changed log format. For a changed format or another helper failure, stop coverage credit and
ask whether the user permits direct transcript inspection, explicitly warning that it loads code into the orchestrator's
context and uses more tokens. Do not silently fall back to bulk reads or guess schema fields. Without permission, retain
partial results and report the affected groups incomplete.

<!-- dependency: scode-harness-shellout -->

> Load the exact skill `scode-harness-shellout` through the current harness's authorized skill mechanism. Use its skill
> loader or resource resolver; when it provides no dedicated loader, read the exact `SKILL.md` location supplied by its
> skill catalog or instructions. Known interfaces include the Skill tool on Claude Code, `skill` on OpenCode, and
> `read_skill` on Muse Code. On Oh My Pi (omp), use `read` at `skill://scode-harness-shellout` and
> `skill://scode-harness-shellout/<relative-path>` for sidecars. On Codex, if no skill location is supplied, read
> `${CODEX_HOME:-$HOME/.codex}/skills/scode-harness-shellout/SKILL.md` (the root verified for Codex 0.152). These are
> known interfaces, not a harness allowlist. Do not ask permission merely because the harness is unfamiliar or returns
> no filesystem base-directory metadata; actual tool permissions still apply. Confirm the name is
> `scode-harness-shellout` from the returned frontmatter, or from the loader's reported identity if frontmatter is not
> exposed. Missing or conflicting identity is a load failure. Read the skill in full and every sidecar the current step
> needs. Resolve sidecars through the harness's resolver for that same skill, or relative to its reported base directory
> or the directory containing its supplied `SKILL.md` path. No base directory is required unless needed to address a
> required resource. If output is truncated or elided, retrieve the omitted content through the tool's continuation,
> range reads, or full-output artifact tied to that same resource or result; do not act on incomplete instructions. If
> complete retrieval cannot be established, stop the affected operation. Stop and report `scode-harness-shellout` and
> the failing path, URI, or tool when the skill is unknown, access is denied, identity does not match, or required
> content cannot be resolved or fully read. Do not bypass a denial, guess paths or URI schemes, search other skill
> roots, substitute another copy or similar skill, or continue from memory.

<!-- /dependency -->

## Review, audit, continue

A completed group review requires an initial turn, later-turn synthesis after required delivery, and a subsequent
discovery turn on the same recorded reviewer identity: at least three actual turns. Coverage repairs and productive
discovery continuations can require more. The orchestrator receives results, audits evidence, and sends concrete
continuations between turns. Several sweeps inside one prompt are still one turn. Neither a finding nor an empty first
result skips these requirements.

1. Start each reviewer with only its bounded functional group, the overall charter, interface context, and immediate
   findings instructions. Require small source reads through `evidence read` and return after the assigned group; do not
   let a reviewer consume queued groups on its own. Tell it to read source itself rather than through subagents: what a
   subagent reads is delivered to the subagent, not the reviewer, earns no coverage, and leaves the reviewer with a
   summary instead of the code. Subagents are fine for work that is not reading, such as running tests or builds; the
   groups are sized so reading needs no help. Preserve its findings, progress, result, and session handle.
2. Audit delivered content against that group's pinned manifest after each turn using `evidence audit`. Read the compact
   report: checked session, matched ranges, gaps, rejected packets, unfinished calls, `unrecognized` record kinds, and
   transcript references. The tool must compare actual delivered text to the snapshot; receipts or a checksum alone are
   insufficient. Leave uncertain ranges open. Keep the raw evidence on disk and inspect payloads directly only under the
   explicit fallback approval above.
3. When gaps remain, resume that same reviewer with named gaps: exact source and ranges, the observed truncation or
   uncertainty, and a manageable next batch. Preserve existing findings and pursue unresolved substantive leads. Ask for
   smaller bounded reads when earlier output was clipped. Repair is required regardless of the number of findings. If no
   gaps remain after the first turn, continue directly to later-turn synthesis.
4. Require synthesis in a later turn than the initial review, after delivery of the required material. It revisits
   interactions across batches and unresolved assumptions under the original charter, preserving, correcting, or
   withdrawing earlier findings with reasons. The continuation may repair the final gaps and then synthesize in that
   same turn; no extra turn solely for coverage approval is required. This also applies when the initial findings were
   empty.
5. Audit again after that turn. If gaps remain, resume for targeted repair and updated synthesis within the stopping
   limits. A synthesis claiming complete coverage never overrides missing evidence.
6. Once delivery and later-turn synthesis are verified, run the discovery cycle below. Coverage alone never skips that
   search, including when all findings so far are empty.

An attempted read, successful exit, filename list, search hits, tool count, checksum, or reviewer receipt is not proof
of delivery. Raw stdout is insufficient when the reviewer received a shortened result. Inspect truncation metadata as
well as literal omission markers according to the harness's evidence semantics. Credit only the ranges actually
delivered; leave missing or ambiguous ranges open. Search snippets may satisfy an agreed snippet scope, but cannot stand
in for mandatory full ranges. Evidence pointers help locate the content; they do not replace the helper's payload
comparison or an approved manual audit.

The orchestrator judges the compact evidence and completion. The bundled tool verifies text delivery, not review
quality. Do not extend it into a general transcript adapter framework or treat a complete coverage report as a completed
review without findings persistence and later-turn synthesis.

## Continue productive discovery

After verified coverage and synthesis, require a separate search turn from each group's same reviewer. This is required
even without a concrete unresolved lead. Reuse its context and durable findings/progress artifacts. Give it its own
recorded findings and those of its named interface neighbours so it can distinguish a new defect from a restatement. Do
not send every reviewer a catalog of the whole run.

Use a continuation with this substance, plus the immediate-recording instruction:

> Your earlier findings are recorded. Reuse your existing context and review the assigned group again under the original
> charter, looking beyond the issues already found. Record new verified findings, things you considered and ruled out,
> and concrete leads that need investigation in your findings log as you reach them, and cite their IDs in your reply;
> do not repeat or rephrase known findings, broaden the scope, or invent issues to keep producing. An empty result is
> valid. At the end, briefly identify what you checked and the IDs of any leads still open. A concern that remains
> unverified after actual investigation needs that label and a record of the checks and missing premise; an
> uninvestigated lead still needs work. Do not provide private reasoning.

After each search turn, inspect the findings log and the short work/lead summary. Verify new records against the pinned
source and applicable contract, using focused source excerpts as needed. Check novelty against findings already known
across the run, not merely that reviewer's local IDs. A new item that duplicates a finding the reviewer was never shown
is a duplicate, not new progress; when that finding came from a group outside its recorded interfaces, add the interface
to both groups' notes. Record a disposition for each new record in the disposition log: verified, unverified after
investigation, duplicate, rejected with a reason, excluded (a `candidate` whose reason for not being reported the
orchestrator accepts), or still under investigation; preserve its original log and identity. When the orchestrator
disagrees with a `candidate`'s reason, it asks the owning reviewer to revise the record, or, if another reviewer already
reports the defect, records the candidate as a duplicate in that group with the disagreement in the reason. New IDs,
extra event records, restatements, speculation without a concrete source basis, and findings outside the charter do not
count as discovery progress. Do not impose a severity threshold from another review workflow; actionability follows the
caller's charter.

### Investigate before retaining uncertainty

Apply these dispositions to possible findings from every review phase, including initial review, synthesis, and
cross-group questions.

Pursue missing premises and substantive leads with focused source checks and targeted clarification from the same
reviewer. Continue while concrete next checks can establish the suspected defect, refute it, or narrow the missing
premise. Do not require proof of a suspicion's absence before rejecting it, and do not treat an uninvestigated suspicion
as a completed finding.

Available evidence includes readable context and permitted tests under the charter, even outside the mandatory
inventory; exploratory context does not expand mandatory scope. Pursue relevant accessible evidence, including through
existing reviewers for cross-group questions, before calling a premise unavailable. Assess the investigation record
against source and observable check results. A list of claimed checks without useful results, or a premise that remains
readily checkable, needs a targeted continuation rather than acceptance of the label.

When available checks cannot establish or refute a concrete concern and further work would repeat those checks or
require unavailable evidence, record it as **unverified after investigation**. This requires actual verification work,
not a disclaimer attached to a first impression. Record the source basis, suspected consequence, checks actually
performed and their results, the exact premise still missing, why available checks cannot resolve it, and what evidence
would settle it. Use that label in the findings log and caller-visible result; a private progress note alone is
insufficient. If the caller's format cannot hold it, provide an accompanying note. Preserve the same finding ID when
revising an existing claim, and distinguish observed behavior from the suspected consequence.

The orchestrator decides the disposition and asks the owning reviewer to append any required finding or revision under
the original ID; it does not write that reviewer's log. Confirm the append before crediting the disposition as recorded.
Cross-group duplicates keep their original owners and IDs; reconcile conflicting verification claims through the
existing synthesis step and record the reconciled disposition in the disposition log.

This disposition finishes the investigation for this review without declaring the suspicion true or false. It does not
make the group or overall review incomplete or require failure status under this protocol. A caller's requirement for a
complete review therefore does not by itself require these concerns to be settled before advancing its checkpoint; honor
an explicitly stricter caller acceptance condition. An open lead that has not received this investigation still needs
work. Missing required source delivery, unusable continuation, or an unperformed review pass remains a protocol gap;
labeling a concern cannot repair those gaps.

If a pass produces a genuinely new verified finding or a distinct concrete concern retained as unverified after
investigation, save it and send another search continuation to that same reviewer. Name both kinds of recorded findings
and direct attention beyond them. Repeating a known uncertainty is not new progress; reopen it only when new evidence
offers a useful check. Continue while these passes produce new findings of either kind; there is no default pass cap or
elapsed-time limit. Independent groups' searches remain concurrent within actual capacity.

Finish discovery only after a properly executed search pass explicitly reports no new findings of either kind, with a
credible work summary and every substantive lead verified, rejected, deduplicated, or recorded as unverified after
investigation. Known findings of either kind may remain. A pass whose only new items are confirmed duplicates of
findings the reviewer was not shown counts as reporting no new findings; its work summary and leads must still meet this
condition. A bare empty list, refusal, unreadable required input, blocked review pass, reply that only restates findings
it was shown, or drift is not that stopping condition. Distinguish an investigation that has reached the documented
uncertainty disposition from a reviewer that cannot perform its assigned pass. The latter stops the affected group
incomplete, as does a reviewer that only repeats findings, produces unsupported claims without useful progress, or
leaves its charter instead of performing the requested search. Preserve findings and the reason. Do not keep demanding a
higher count or renewed proof of known uncertainties. A caller-imposed limit may also stop a run; if it prevents the
final empty search pass or required investigation, disclose the unfinished work.

Keep search-pass counts, newly verified and unverified-after-investigation finding IDs separately, and the final
empty-pass or failure reason in the group's progress notes. An observed empty pass establishes this stopping condition,
not proof that every defect has been found.

## Keep the run moving and visible

A caller's question about progress, cost, or problems is not a request to stop, and neither is a side request made
during the run. Do not end the coordinating turn while work can advance and the harness will not wake you when a
reviewer turn ends: answer in an interim message and keep coordinating. A question this protocol requires you to ask the
caller also goes in an interim message where the harness allows one, while unaffected groups keep running. End the turn
at completion, at an incomplete stop, on the caller's explicit pause or cancel, or when nothing can advance until the
caller answers.

Progress updates report groups by state, idle capacity against the concurrency limit, the oldest pending parent
decision, completed turns against the planned minimum, and reviewer and orchestrator token totals when the backend
exposes them. Before summing a backend's per-turn usage, check whether it already includes the earlier turns of a
resumed session; if it does, use each session's latest value. Cost is reported as a fact; it does not license ending a
progressing review early.

Keep one current-state file in the run directory, rewritten in place before you act on each decision. It holds pending
parent decisions, pending cross-group input, and the paths of the run's records, including the schedule directory, whose
`schedule status` is the authority on group states. After a compaction or resume, read it and `schedule status` first
instead of reconstructing state from notes, replies, or the transcript; the scheduler, not your memory, says which turns
are running.

## Stop and report

Stop incomplete on loss of usable transcript access or same-session continuation, or after two consecutive repair turns
add no verified delivery of previously missing required material. A successful repair resets that counter; a new finding
does not. Retain the existing findings and last verified coverage. Do not start a replacement reviewer identity and
describe it as the same persistent review. Apply this rule per group; keep other progressing groups running.

Coverage repair and finding discovery have separate progress criteria. Delivery of previously missing required text
advances coverage repair; new verified findings or concrete concerns retained after investigation advance discovery.
Neither substitutes for the other. Do not turn a search limit, an empty search, or productive finding count into
evidence that unread scope was covered.

At the caller's result destination, preserve the findings in the requested format and include a compact completion
record (or an accompanying note if the format cannot hold it):

- Complete or incomplete, with the stopping reason and any remaining substantive uncertainty.
- Stable scope references, group assignments, reviewer backend/model/effort, session identities, and actual turn counts.
- Verified delivery with evidence references; exact missing or uncertain material on an incomplete run.
- Whether later-turn synthesis occurred and which evidence supports the final audit.
- Active and deduplicated findings counts, original findings-log references, and cross-group synthesis status, including
  whether the run was quiescent.
- Separate verified and unverified-after-investigation findings and counts, with the investigation record for each
  uncertainty. Derive these counts from the per-group dispositions `evidence consolidate` reports, never from a missing
  label or by subtracting from the helper's raw active count. Open reviewer records may also be rejected, excluded,
  duplicate, or still under investigation; a run with undecided, stale, or conflicting records has decisions owed.
- Discovery pass counts, new findings of each kind per pass, and evidence of the final empty search or incomplete stop.

“Complete” means this protocol's delivery, persistence, synthesis, and final empty-search requirements were met and the
run was quiescent, with no cross-group input pending. It does not certify the findings or prove attention,
understanding, correctness, or saturation. A review may be complete with unverified-after-investigation findings; say so
and surface them alongside verified findings. An incomplete run with no findings is not a clean review; say both that it
returned no findings and why it remains incomplete.
