Index of every page on this site: llms.txt
All skills
scode avatar

/persistent-review

@03a9f7f
Run it yourself

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.

  • 9 files
  • 223.6 KB
  • Updated 2 weeks ago
  • GitHub
Use this Skill: https://skilld.dev/gh/scode/dotfiles/persistent-review

Nothing lands on disk. Nothing to clean up.

Fork this Skill

Edit a local copy. It keeps the author and licence.

SKILL.md

≈89 tokens for metadata: the name and description. ≈8.5k when used: this file. ≈17k more on demand in 4 files.

Description uses 4.5% of example budget

Before choosing a Skill, your Agent reads its name and description. All available Skills share that space.

  • A shorter description leaves more room for other Skills. This entry exceeds our 1% size suggestion.

In our Claude Code example, all Skill names and descriptions share 8,000 characters. This Skill uses ≈358 characters, or 4.5%.

The 1% threshold is a size suggestion. Longer descriptions can still fit.

Your model, settings, and other Skills decide how much text your Agent can read.

Example settings and source

The example uses a 200k-token context and default Claude Code settings. The count includes the name, description, separators, and when_to_use when present. Codex also counts local file paths.

Skit's source and limits: Codex 0.160.1, Claude Code 2.1.292.

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.

Source: SKILL.md on GitHub

skilld matched fixed text patterns in SKILL.md and file names. Patterns miss obfuscated code.

skilld run checks every file with the same patterns. It asks for approval before it loads a Skill with a behavior marked Needs approval.

No third-party reports yet.

Signed by skilld at 03a9f7f. This ties the file your Agent reads to that commit on GitHub. It does not review the instructions.

Last checked against GitHub yesterday.

Activeupdated 2 weeks ago

README badge

README badge for scode/dotfiles/persistent-review