Claude Cursor opencode Skill

fold-findings

Repair persisted fix-now findings in compatible atomic batches: root-cause fixes, green gate, commit/push, and per-row `folded: yes` updates. Never reclassify or substitute backlog notes. Triggers: "fold-findings", "fix the review findings", "repair audit blockers".

LLM Mart · 0 points · 1 views 0 listing impressions 0 install-command copies
Virus-scanned Reviewed automatically before listing.

Full trust report

Download gtrabanco-agentic-workflow-skills_fold-findings-4b3a56b.zip · 8 KB
gtrabanco/agentic-workflow 21 5 forks MIT Updated 7d ago
Part of gtrabanco/agentic-workflow — 33 skills

Install

skills CLI npx skills add https://github.com/gtrabanco/agentic-workflow/tree/main/skills/fold-findings
Claude Code claude plugin marketplace add https://llmmart.ai/marketplace.json && claude plugin install gtrabanco-agentic-workflow@llmmart
Git git clone https://github.com/gtrabanco/agentic-workflow.git

The skills CLI installs just this skill, for any of its supported agents. Claude Code installs the whole gtrabanco/agentic-workflow collection as a plugin from our marketplace. Git is the plain clone.

Skill manifest

Fold Findings

Repair persisted fix-now findings. review-change and audit-pr classify; this skill fixes each root cause, never relabeling, deferring, or weakening its check.

Turn contract — verify before ending the turn

✓ 1. Every finding taken up this turn produced its fixed per-finding output
     line (FOLDED <sha> | DISPUTED <reason> | BLOCKED <missing input> |
     REPLAN <proposed phase(s)>) — no finding silently skipped.
✓ 2. For each FOLDED batch: the gate was RUN (not assumed) and green, one
     atomic commit was RUN with its sha pasted, and (if the branch has an open PR)
     `git push` was RUN immediately after that commit.
✓ 3. The ledger row for each FOLDED finding was flipped `folded: no → yes`
     in the same commit — never a bare code fix with the ledger left stale.
✓ 4. No finding was reclassified: no severity downgrade, no fix-now →
     non-fix-now, no "actually this is fine" — a genuine objection produced
     `DISPUTED` with evidence for a user decision, never a silent drop/issue.
✓ 5. The closing `Folded: n/m · Disputed: k · Blocked: j[ · Replan: r]` tally
     and outcome-branched `→ Next:` block are printed as the ABSOLUTE last output.
     Every affected finding ID is named in that block, joined with ` + `.

Any unchecked box means the turn is not done.

When to use

After /review-change reports REVIEW-FAIL with fix-now rows, or /audit-pr reports VERDICT: BLOCKED (every blocker is fix-now). If the ledger is absent or incomplete, reconstruct rows from the verdict in Step 0. Never process postpone/wontfix/promote/documented-tradeoff rows; those belong to /triage-issue.

Step 0 — Discover the project (always first)

Per Workflow conventions, read:

  1. The unit's review-findings.md under docs/features/<NN>-<slug>/ or docs/fix/<n>-<topic>/; schema is owned by review-change/audit-pr:

    | id | file:line | axis | severity | class | route | folded |

    After VERDICT: BLOCKED, append missing rows (class: fix-now, folded: no, next free Fn, dedupe file:line+axis), commit as docs(<unit>): reconstruct fold ledger from audit-pr blockers, then fold; never report “no findings”.

  2. Queue folded: no rows; explicit IDs restrict it and leave other rows untouched. Group by root cause, verifier and rollback boundary.

  3. The project's verification gate and forge CLI (use the declared forge).

  4. Whether the branch has an open PR; this decides immediate push after commit.

Progressive loading — fold queue

The allowlist is exactly these two paths; read both, in order, before changing code or the ledger:

  1. frozen classification, definition of fixed, and forbidden actions
  2. per-finding fold process

Both are normative and one hop from this file. Missing resource → stop; never infer a classification or fold procedure.

Report — return exactly this structure (fixed output contract)

Per finding, in processing order:

| <finding-id> | verdict: FOLDED <sha> | DISPUTED <reason → user decision> | BLOCKED <missing input> | REPLAN <proposed phase(s) → /execute-phase> |

Then exactly:

Folded: n/m · Disputed: k · Blocked: j · Replan: r

Omit · Replan: r when r = 0 (preserves the existing three-field format).

Then print the REPAIR-RECEIPT as the ABSOLUTE-last output, together with the branching → Next: block below. The receipt is immutable once printed; a later fold prints a new receipt (append-only output history — no ledger row, no schema field). Six fields, always present:

## REPAIR-RECEIPT
- Repaired: <F-ids with (VF-<n>) refs, joined ` + `, or `none`>
- Refuted/open: <F-ids joined ` + `, or `none`>
- Gate: <command> → exit <n> at head <40-hex sha> · n/a when nothing was folded
- Batch class: <all-repair-in-place | frozen (replan present) | none>
- Fold diff: <shortstat from a real `git diff` run> · none when nothing was folded
- Branch: <RE-REVIEW-REQUIRED (delta) | RE-REVIEW-OPTIONAL | RE-REVIEW-SKIPPED | REPLAN-ROUTE>
  • The Gate line carries the actual exit codes observed at the head the gate ran on — green or red. A failed gate never silences the receipt: the batch is reported with the observed exit codes and nothing folded (a red gate is not a silent gap).
  • The Fold diff shortstat comes from a real git diff run over the batch's commits.
  • The Batch class derives from the taken queue's frozen rows only — the fold never reclassifies (all-repair-in-place, frozen (replan present), or none for an empty queue); the vocabulary comes from review-implementation's closed class set.

Freeze-batch (replan present). When the taken queue contains any row whose frozen class is replan-in-unit or decision-required, nothing folds: no folded: yes flips, no commits. The receipt records the REPLAN-ROUTE branch and every retained (unfolded) row id, and the loop stops and routes to node scripts/unit-route.mjs <unit>, whose route: replan line names the planner that re-cuts the plan.

Guardrails

Scope is the ledger (or explicit ID subset); unlisted discoveries are proposals for user triage. Batch only when one root-cause correction, validator set and rollback boundary own the rows: one commit/push, individual ticks/lines. Split otherwise. Do not widen beyond a finding's file/line/axis unless its root cause requires it; explain that in the commit. Artifact language follows user instruction > project docs language > English; conversation language never decides.

Portability (agents other than Claude Code)

Use explicit fallbacks when a primitive is absent: open named SKILL.md files in a fresh context; use the strongest model for subtle logic/security and never weaker than the author; process the compatible queue once and re-run only after new review evidence.

Relationship to other skills

review-change ──FAIL──┐
audit-pr ──BLOCKED─────┼──▶ fold-findings ──FOLDED──▶ re-run review-change / audit-pr
                       │                  ──DISPUTED─▶ user decision
                       │                  ──BLOCKED──▶ user supplies missing input

review-change/audit-pr classify and persist; this skill only flips folded: no to yes after a real fix. execute-phase's embedded fold checklist is the inline fallback; this standalone path keeps frozen classification and its forbidden list and never runs above its tier. DISPUTED stops for user evidence; no issue is created.

Done when

Every queued finding has its per-finding verdict and tally; every FOLDED finding belongs to a pushed atomic batch and ticked row. Nothing is reclassified or touched outside the queue.

→ Next: (branches on outcome; list every affected finding ID once as `F1 + F2 + …`)
  · all FOLDED (<F1> + <F2> + …) → /review-change — re-review the branch now that all listed findings are fixed
  · any DISPUTED (<F1> + <F2> + …) → user decision — resolve every evidenced dispute without creating backlog
  · any BLOCKED (<F1> + <F2> + …) → supply the listed missing inputs, then re-run /fold-findings
  · any REPLAN (<F1> + <F2> + …) → confirm all proposed SPEC phases, then /execute-phase on this same branch

Replace placeholders with every actual affected finding ID before printing; never print <F2>, …, or a single representative ID in a live hand-off.

Closing-block decision branch (choose one, at emission)

The closing block picks exactly one of four outcomes. The no-decision → re-review default holds whenever the turn carries no recorded prior consumer decision to skip.

Batch state Branch → Next: (consumer)
freeze-batch (≥ 1 replan-class row) REPLAN-ROUTE node scripts/unit-route.mjs <unit> → the planner it names re-cuts the plan, then /review-plan before /execute-phase on this unit
all-repair-in-place + docs-only + no folded row severity high + prior consumer skip decision RE-REVIEW-SKIPPED skip — consumer has explicitly decided to skip the re-review
all-repair-in-place + docs-only + no folded row severity high RE-REVIEW-OPTIONAL /review-change (default, delta mode) — or the consumer's recorded skip decision
empty batch (class none) RE-REVIEW-OPTIONAL /review-change by default — safe: the head is unchanged
anything else (behavioral surface or any folded row high) RE-REVIEW-REQUIRED (delta) /review-change — delta mode mandatory default

Branch-selection decision inputs.

  • Docs-only test (E-D3). RE-REVIEW-OPTIONAL requires every fold-diff file to be a Markdown/documentation file; otherwise the batch is behavioral (→ RE-REVIEW-REQUIRED (delta)).
  • Frozen-severity-high override. A folded row whose frozen severity is high forces RE-REVIEW-REQUIRED (delta) even on a docs-only diff. Frozen fields are never edited to reach a branch.
  • SKIPPED requires prior consumer decision (E-D2). RE-REVIEW-SKIPPED is printed only by a turn carrying an explicit prior consumer decision to skip. A turn with no recorded prior consumer decision prints RE-REVIEW-OPTIONAL + the re-review default, never RE-REVIEW-SKIPPED.
Files (agentic-workflow)
  • references
    • FOLD_POLICY.md 3.3 KB 
      ## Frozen classification (hard rule, never relaxed)

This skill **never** edits a finding's `severity`, `class`, or `route`, and
never moves a finding out of fix-now. Those fields belong to `review-change` /
`audit-pr`, the skills that produced the verdict — reopening them here would
let a fix turn into a reclassification. If, while investigating, the finding
genuinely looks wrong (not reproducible, already fixed elsewhere, or the
axis/severity is mistaken), that is **evidence for a dispute**, not a
license to edit the row: mark it `DISPUTED` with the evidence and stop for a
user decision — the row's `severity`/`class`/`route` stay exactly as written.

## Definition of fixed (checklist — every box, every finding)

A finding is `FOLDED` only when **all** of these hold:

```
✓ A root-cause diff exists — the actual defect is fixed, not worked around
✓ The gate is green (type-check + tests + build actually RUN, exit codes
  pasted — never assumed)
✓ If the finding was behavioral (a bug, not a style/debt nit): a test or
  check was added/updated that fails without the fix and passes with it
✓ The ledger row is ticked `folded: yes`, in the same commit as the fix
✓ The commit is made AND pushed — an unpushed fix does not exist for CI, the
  reviewer, or the merge gate (skip the push only if the branch has no PR yet
  and the unit's own workflow says push happens later, at the PR step)
```

## Forbidden (never — even if it "would resolve the finding")

```
✗ Adding a known-issues.md / backlog entry instead of fixing the code
✗ A decisions.md tradeoff note that accepts the defect as-is
✗ Deleting, skipping (.skip, .only elsewhere), or loosening a test to make it pass
✗ Editing an existing test's expectation to match behaviour — a setup repair
  may only keep assertions at least as strong and never touch expectations
✗ eslint-disable / @ts-ignore / equivalent suppression AS the fix
✗ A TODO/FIXME stub left in place of the actual fix
✗ Ticking `folded: yes` without a reviewer-mappable diff behind it
✗ Fixing anything NOT on the ledger (or not in the explicit finding-ID
  scope this turn was given) — record an independent proposal for explicit
  user triage, never bundle it silently or create an issue
```

Something forbidden looks like the only option → stop, do not apply it, and
mark the finding `DISPUTED` or `BLOCKED` with the reason instead.

Never edit an existing test's expectation to match behaviour: a setup repair may
only keep assertions at least as strong and never touch expectations; the
test-immutability contract (`verification-contract`) owns the sole amendment
path.

## Reproducer handoff (materialize, never re-derive)

Before repairing a **behavioral** finding, read the row's `finding-mark@1`
`recheck` cell (method + reproducer, written by `review-change` at verification
time) and materialize it as the regression check — the method as written (red
test first, reproducible command output, or direct read). The fold runner
**never invents or re-derives** the reproducer; it consumes the cell as the
allowed materialization.

- A `recheck` cell that cannot be materialized as a runnable check yields
  `BLOCKED <missing input>` and names the missing input.
- Never substitute a weaker re-derived check for the recorded reproducer.
    • FOLD_PROCESS.md 4.6 KB 
      ## Process

1. **Build the queue.** Take every `folded: no` fix-now row, or the explicit ID
   subset, in severity/id order. `replan-in-unit` rows emit `REPLAN`; they stay
   on the same SPEC/branch/PR and never become issues. **Empty batch:** an
   empty queue (zero findings taken) prints a REPAIR-RECEIPT with batch class `none`
   and nothing folded — a receipt only, no flips, no commits.
2. **Form the fewest atomic correction groups.** Findings may share one group
   only when all boxes pass:

   - one root cause or one homogeneous mechanical correction owns them;
   - one validator set proves every member fixed;
   - they can ship and roll back together without partial correctness;
   - no member needs a separate product/architecture decision or stronger
     release sequence;
   - the combined diff remains reviewable and inside the current unit.

   Shared files are neither required nor sufficient. A cross-file auth repair
   may group; two unrelated nits in one file may not. Record each group's IDs,
   shared cause, validators, and rollback boundary before editing.
3. **Repair one group at a time.** Diagnose the shared cause, implement the
   smallest complete correction, and add/update regression coverage for every
   behavioral member. Use the strongest tier required by the most subtle member.
4. **Verify.** Run the group's validators plus the normal project gate. Red →
   continue repairing only this group. Same failure with no diff twice →
   `BLOCKED NO-PROGRESS`; never commit red or weaken a check.
5. **Persist atomically.** Flip every group row `folded: no → yes`; stage the
   group diff + ledger; commit:

   ```text
   fix(<scope>): fold <F1+F2+…> — <shared correction>
   ```

   If the PR is open, push immediately. Emit one `FOLDED <same-sha>` line per
   member so no finding disappears inside the batch.
6. **Continue groups.** A blocked/disputed group does not prevent independent
   groups from folding. Leave its rows `no` and emit individual outcomes.
   **Failed gate:** if the group's gate is red, do not fold the group — the
   receipt records the observed gate exit codes and nothing is folded for it;
   never silence the receipt and never commit red.
7. **Batch classification.** The batch class derives from the taken queue's
   frozen rows only, and the fold never reclassifies:

   | Condition over the taken batch | Batch class | Fold behavior |
   |---|---|---|
   | ≥ 1 row with frozen class `replan-in-unit` or `decision-required` | `frozen (replan present)` | **freeze-batch** — nothing folds, no `folded: yes` flips, no commits; the receipt records the REPLAN-ROUTE and every retained (unfolded) row id; the loop stops and routes to `node scripts/unit-route.mjs <unit>`, whose `route: replan` line names the planner |
   | all taken rows foldable, none replan-class | `all-repair-in-place` | fold as today (group → fix → gate → commit → flip) |
   | empty queue (zero findings taken) | `none` | receipt only |

   The batch-class vocabulary references only `review-implementation`'s closed
   class set (`CLASSIFY.md`); the receipt invents no parallel vocabulary.

   The emitted branch follows the closing-block decision inputs in the skill:
   a freeze-batch always selects `REPLAN-ROUTE`; otherwise the docs-only
   file-set test (E-D3) and the frozen-severity-`high` override (E-D2) select
   `RE-REVIEW-OPTIONAL` vs `RE-REVIEW-REQUIRED (delta)`.
8. **Disputes.** Non-reproducible/already-fixed/wrong findings become
   `DISPUTED <evidence → user decision>`; never edit classification or create an
   issue.
9. **Replan.** If the smallest correct group exceeds a reviewable correction,
   run `node scripts/unit-route.mjs <unit>` — its `route: replan` line names the
   planner (`/plan-feature <unit>` or `/plan-fix <n>`) that appends the proposed
   phases to the unit's SPEC. After the user confirms and a fresh
   `/review-plan <unit>` passes, `/execute-phase <unit>` completes them and ticks
   the rows.

## REPAIR-RECEIPT — fixed printed block (verbatim copy)

Printed after the per-finding table and tally, as part of the ABSOLUTE-last
output together with the branching `→ Next:` block. Six fields, always
present:

```text
## REPAIR-RECEIPT
- Repaired: <F-ids with (VF-<n>) refs, joined ` + `, or `none`>
- Refuted/open: <F-ids joined ` + `, or `none`>
- Gate: <command> → exit <n> at head <40-hex sha> · n/a when nothing was folded
- Batch class: <all-repair-in-place | frozen (replan present) | none>
- Fold diff: <shortstat from a real `git diff` run> · none when nothing was folded
- Branch: <RE-REVIEW-REQUIRED (delta) | RE-REVIEW-OPTIONAL | RE-REVIEW-SKIPPED | REPLAN-ROUTE>
```
  • SKILL.md 9.6 KB 
    ---
name: fold-findings
user-invocable: true
version: 1.5.0
argument-hint: [finding-id …]
author: "Gabriel Trabanco <gtrabanco@users.noreply.github.com>"
license: MIT
description: >
  Repair persisted fix-now findings in compatible atomic batches: root-cause
  fixes, green gate, commit/push, and per-row `folded: yes` updates. Never
  reclassify or substitute backlog notes. Triggers: "fold-findings", "fix the
  review findings", "repair audit blockers".
---

# Fold Findings

Repair persisted fix-now findings. `review-change` and `audit-pr` classify; this
skill fixes each root cause, never relabeling, deferring, or weakening its check.

## Turn contract — verify before ending the turn

```
✓ 1. Every finding taken up this turn produced its fixed per-finding output
     line (FOLDED <sha> | DISPUTED <reason> | BLOCKED <missing input> |
     REPLAN <proposed phase(s)>) — no finding silently skipped.
✓ 2. For each FOLDED batch: the gate was RUN (not assumed) and green, one
     atomic commit was RUN with its sha pasted, and (if the branch has an open PR)
     `git push` was RUN immediately after that commit.
✓ 3. The ledger row for each FOLDED finding was flipped `folded: no → yes`
     in the same commit — never a bare code fix with the ledger left stale.
✓ 4. No finding was reclassified: no severity downgrade, no fix-now →
     non-fix-now, no "actually this is fine" — a genuine objection produced
     `DISPUTED` with evidence for a user decision, never a silent drop/issue.
✓ 5. The closing `Folded: n/m · Disputed: k · Blocked: j[ · Replan: r]` tally
     and outcome-branched `→ Next:` block are printed as the ABSOLUTE last output.
     Every affected finding ID is named in that block, joined with ` + `.
```

Any unchecked box means the turn is not done.

## When to use

After `/review-change` reports `REVIEW-FAIL` with fix-now rows, or `/audit-pr`
reports `VERDICT: BLOCKED` (every blocker is fix-now). If the ledger is absent or
incomplete, reconstruct rows from the verdict in Step 0. Never process
postpone/wontfix/promote/documented-tradeoff rows; those belong to `/triage-issue`.

## Step 0 — Discover the project (always first)

Per Workflow conventions, read:

1. The unit's `review-findings.md` under `docs/features/<NN>-<slug>/` or
   `docs/fix/<n>-<topic>/`; schema is owned by `review-change`/`audit-pr`:

   ```
   | id | file:line | axis | severity | class | route | folded |
   ```

   After `VERDICT: BLOCKED`, append missing rows (`class: fix-now`, `folded: no`,
   next free `Fn`, dedupe `file:line`+axis), commit as
   `docs(<unit>): reconstruct fold ledger from audit-pr blockers`, then fold;
   never report “no findings”.
2. Queue `folded: no` rows; explicit IDs restrict it and leave other rows
   untouched. Group by root cause, verifier and rollback boundary.
3. The project's verification gate and forge CLI (use the declared forge).
4. Whether the branch has an open PR; this decides immediate push after commit.

## Progressive loading — fold queue

The allowlist is exactly these two paths; read both, in order, before changing
code or the ledger:

1. [frozen classification, definition of fixed, and forbidden actions](references/FOLD_POLICY.md)
2. [per-finding fold process](references/FOLD_PROCESS.md)

Both are normative and one hop from this file. Missing resource → stop; never
infer a classification or fold procedure.

## Report — return exactly this structure (fixed output contract)

Per finding, in processing order:

```
| <finding-id> | verdict: FOLDED <sha> | DISPUTED <reason → user decision> | BLOCKED <missing input> | REPLAN <proposed phase(s) → /execute-phase> |
```

Then exactly:

```
Folded: n/m · Disputed: k · Blocked: j · Replan: r
```

Omit `· Replan: r` when `r = 0` (preserves the existing three-field format).

Then print the REPAIR-RECEIPT as the ABSOLUTE-last output, together with the
branching `→ Next:` block below. The receipt is immutable once printed; a
later fold prints a new receipt (append-only output history — no ledger row,
no schema field). Six fields, always present:

```
## REPAIR-RECEIPT
- Repaired: <F-ids with (VF-<n>) refs, joined ` + `, or `none`>
- Refuted/open: <F-ids joined ` + `, or `none`>
- Gate: <command> → exit <n> at head <40-hex sha> · n/a when nothing was folded
- Batch class: <all-repair-in-place | frozen (replan present) | none>
- Fold diff: <shortstat from a real `git diff` run> · none when nothing was folded
- Branch: <RE-REVIEW-REQUIRED (delta) | RE-REVIEW-OPTIONAL | RE-REVIEW-SKIPPED | REPLAN-ROUTE>
```

- The `Gate` line carries the actual exit codes observed at the head the gate
  ran on — green or red. A **failed gate never silences the receipt**: the
  batch is reported with the observed exit codes and nothing folded (a red gate
  is not a silent gap).
- The `Fold diff` shortstat comes from a real `git diff` run over the batch's
  commits.
- The `Batch class` derives from the taken queue's frozen rows only — the fold
  never reclassifies (`all-repair-in-place`, `frozen (replan present)`, or
  `none` for an empty queue); the vocabulary comes from
  `review-implementation`'s closed class set.

**Freeze-batch (replan present).** When the taken queue contains any row whose
frozen class is `replan-in-unit` or `decision-required`, nothing folds: no
`folded: yes` flips, no commits. The receipt records the `REPLAN-ROUTE` branch
and every retained (unfolded) row id, and the loop stops and routes to
`node scripts/unit-route.mjs <unit>`, whose `route: replan` line names the
planner that re-cuts the plan.

## Guardrails

Scope is the ledger (or explicit ID subset); unlisted discoveries are proposals
for user triage. Batch only when one root-cause correction, validator set and
rollback boundary own the rows: one commit/push, individual ticks/lines. Split
otherwise. Do not widen beyond a finding's file/line/axis unless its root cause
requires it; explain that in the commit. Artifact language follows user
instruction > project docs language > English; conversation language never decides.

## Portability (agents other than Claude Code)

Use explicit fallbacks when a primitive is absent: open named `SKILL.md` files in
a fresh context; use the strongest model for subtle logic/security and never
weaker than the author; process the compatible queue once and re-run only after
new review evidence.

## Relationship to other skills

```
review-change ──FAIL──┐
audit-pr ──BLOCKED─────┼──▶ fold-findings ──FOLDED──▶ re-run review-change / audit-pr
                       │                  ──DISPUTED─▶ user decision
                       │                  ──BLOCKED──▶ user supplies missing input
```

`review-change`/`audit-pr` classify and persist; this skill only flips
`folded: no` to `yes` after a real fix. `execute-phase`'s embedded fold checklist
is the inline fallback; this standalone path keeps frozen classification and its
forbidden list and never runs above its tier. `DISPUTED` stops for user evidence;
no issue is created.

## Done when

Every queued finding has its per-finding verdict and tally; every `FOLDED`
finding belongs to a pushed atomic batch and ticked row. Nothing is reclassified
or touched outside the queue.

```
→ Next: (branches on outcome; list every affected finding ID once as `F1 + F2 + …`)
  · all FOLDED (<F1> + <F2> + …) → /review-change — re-review the branch now that all listed findings are fixed
  · any DISPUTED (<F1> + <F2> + …) → user decision — resolve every evidenced dispute without creating backlog
  · any BLOCKED (<F1> + <F2> + …) → supply the listed missing inputs, then re-run /fold-findings
  · any REPLAN (<F1> + <F2> + …) → confirm all proposed SPEC phases, then /execute-phase on this same branch
```

Replace placeholders with every actual affected finding ID before printing; never
print `<F2>`, `…`, or a single representative ID in a live hand-off.

## Closing-block decision branch (choose one, at emission)

The closing block picks exactly one of four outcomes. The **no-decision →
re-review default** holds whenever the turn carries no recorded prior consumer
decision to skip.

| Batch state | Branch | `→ Next:` (consumer) |
|---|---|---|
| freeze-batch (≥ 1 replan-class row) | `REPLAN-ROUTE` | `node scripts/unit-route.mjs <unit>` → the planner it names re-cuts the plan, then `/review-plan` before `/execute-phase` on this unit |
| `all-repair-in-place` + docs-only + no folded row severity `high` + prior consumer skip decision | `RE-REVIEW-SKIPPED` | skip — consumer has explicitly decided to skip the re-review |
| `all-repair-in-place` + docs-only + no folded row severity `high` | `RE-REVIEW-OPTIONAL` | `/review-change` (default, delta mode) — or the consumer's recorded skip decision |
| empty batch (class `none`) | `RE-REVIEW-OPTIONAL` | `/review-change` by default — safe: the head is unchanged |
| anything else (behavioral surface or any folded row `high`) | `RE-REVIEW-REQUIRED (delta)` | `/review-change` — delta mode mandatory default |

**Branch-selection decision inputs.**

- **Docs-only test (E-D3).** ``RE-REVIEW-OPTIONAL`` requires every fold-diff
  file to be a Markdown/documentation file; otherwise the batch is behavioral
  (→ `RE-REVIEW-REQUIRED (delta)`).
- **Frozen-severity-`high` override.** A folded row whose frozen severity is
  `high` forces `RE-REVIEW-REQUIRED (delta)` even on a docs-only diff. Frozen
  fields are never edited to reach a branch.
- **SKIPPED requires prior consumer decision (E-D2).** `RE-REVIEW-SKIPPED`
  is printed only by a turn carrying an explicit prior consumer decision to
  skip. A turn with no recorded prior consumer decision prints
  `RE-REVIEW-OPTIONAL` + the re-review default, **never** `RE-REVIEW-SKIPPED`.

Comments (0)

Sign in to join the conversation.

No comments yet.

Reviews (0)

No reviews yet.

Related

Claude Prompt
Tighten-my-prose editing prompt
Claude Skill
Adversarial code-review skill for Claude
Claude Workflow
Deep-research workflow (fan-out + verify)
Claude Skill
Conventional-commit writer for Claude