/cure

When to invoke: Apply fixes from an /age report, finding list, or CI failure, then run the project’s test/lint/build gates and hand a clean cure to /plate for commit/publication. Use when the user wants selected findings resolved. Do NOT use for review (route to /age), test authoring (route to /press), or direct publication (route to /plate).

Use this skill after /age, failed validation, or user-selected review findings need to be fixed and prepared for shipping.

Inputs

Accept any of: a /age slug (/cure <slug> reads .cheese/age/<slug>.md), a pasted findings list, a CI failure summary, or a scoped instruction like “fix the high-severity age findings”. When /age or /affinage hands off a pre-locked selection (canonical format: references/selection.md#handoff-from-age), adopt it and go straight to apply. Called bare, apply the recommended composite (all-medium, cheap) per references/selection.md, which also defines the gate conditions.

Age reports may predate the severity-rubric revision and lack per-finding sub-fields or confidence. Read references/selection.md § Older report shape before selecting from such a report — it defines the inference and toleration rules; never reject a report for missing sub-fields.

Optional flags:

--safe — re-introduce the selection and terminal publication handoff gates.
--open-pr — after a clean cure, allow terminal /plate publication when no PR exists.
--auto — autonomous mode (propagated from /cook --auto). Skips user selection; requires --stake <floor>, and /cook --auto always passes medium+. Auto-selection rules: references/selection.md; pass-cap and revert behaviour: ## Auto mode below.
--stake <floor> — with --auto only, ignored otherwise. Severity floor: blocker, high, medium+, or all; definitions and the medium+ cheap-lows rule live in references/selection.md § Auto-mode selection.
--hard — propagate the metacognitive-gate flag to terminal /plate; see ## --hard mode.

Portability reference: ../cheese/references/harness-portability.md. It covers helper resolution, sub-agent dispatch, GitHub operations, and handoff transitions; prefer the bundled or repo-local helper first, and treat ${CLAUDE_SKILL_DIR} as optional host-provided fallback. The handoff blocks below are the portable contract; slash commands are host renderings, not the control model.

Flow

Load — read the findings (markdown, not JSON sidecars).
Select — adopt any pre-locked handoff from /age//affinage; otherwise apply the recommended composite. See references/selection.md for the default rule, recognized verbs, and gate conditions. To expand a user-supplied verb to finding ids:
```
python3 shared/scripts/findings_cli.py parse-selection --report <path> --selection "<verb>"
```
If the host only ships the bundle, python3 ${CLAUDE_SKILL_DIR}/scripts/common.pyz findings_cli parse-selection ... is the fallback.
Apply — fix one logical group at a time: re-confirm the anchor through a fresh bounded read, then apply a stale-safe write from a compatible backend family.
Validate — run the narrowest tests that prove each fix, then any relevant project-wide gates (lint, typecheck, build). When the handoff carries a recorded baseline: block, classify gate failures against it per ../cook/references/quality-gates.md: identical failures do not block a clean cure or trigger a halt; only new or changed failures are cure’s to fix.
Taste-test (behavioural fixes only) — for a behavioural fix (production logic or public surface), run the fresh-context taste-test before the handoff slug: dispatch the read-only reviewer phase-agent (model pinned to opus) over the cure diff with cook’s lenses, or fall back to the inline self-check if unavailable. Mechanical fixes (formatting, comment, import, no-logic rename) skip this. Pipe a revise into a bounded corrective pass; a Locked-decision halt stops for a human. (A coder-nested cure defers the authoritative pass to the orchestrator.)
Domain-model correction (diff-touched terms only) — after the cook’s fixes land, correct diff-touched domain-model terms (never a free rewrite). Read references/domain-model-correction.md before this step — it defines the store resolution, the entry format, and the hard rule against reversing a mold-locked canonical term.
Re-review hand-off — recommend /age --scope <touched-path> so review runs through the proper skill rather than reimplementing it inline. /cure does not re-grade its own work. If the user picks re-age, the resulting report can feed a fresh /cure invocation.
Ship report — what changed, checks run, deferred items, residual risks. Write the handoff slug at the top of .cheese/cure/<slug>.md (see ## Handoff slug below) so the chain (and /cook’s fan pathway) can read the outcome without re-parsing the full report.
Plate / hand off — on a clean cure, dispatch /plate per ## Handoff.

Preferred tools and fallbacks

Call source-code search, read, and write backends directly according to code-intelligence-routing.md.

Beyond source-code routing there are cure-specific tools:

Need	Prefer	Fallback
Understanding findings	`/age` report plus touched diff/test context	diff, touched files, tests
CI and PR context	`gh`	local test output or user-provided logs
Diffs	`delta`	plain `git diff`
Conflict resolution	mergiraf	manual resolution with targeted tests
Code navigation	semantic symbol search, then caller search	LSP or bounded native search; report precision loss
Read before edit	fresh bounded read from the write backend family	another snapshot-capable bounded read; re-read if anchors are incompatible

If a preferred tool is missing, continue with the fallback. If a missing tool prevents safe application, stop and explain the blocker.

Validation

Run the narrowest tests that prove the fix, then any relevant existing wider gates. If a gate is unavailable, record why. Do not declare ready when selected findings remain unresolved.

Applied requires its proving test green (Iron Law — see references/cure-discipline.md).

clean cure — ≥1 fix applied, all gates green (identical recorded baseline: failures don’t count against green — see ../cook/references/quality-gates.md), no false-premise halt. To map the post-cure gate booleans to a readiness verdict (agent judges the booleans; the CLI maps them):

python3 shared/scripts/gates_cli.py classify \
  --press-status <label> \
  [--hard-floor-met] [--has-open-level-1-or-2] [--has-open-level-3] [--has-open-level-4-or-5] [--any-spinning]

If the host only ships the bundle, python3 ${CLAUDE_SKILL_DIR}/scripts/common.pyz gates_cli classify ... is the fallback.

Handoff slug

Write the cure report to .cheese/cure/<slug>.md with a minimum handoff slug at the top so /cook’s fan pathway and /cheese --continue can chain without re-parsing the full report:

status: ok | halt: <one-line reason>
next: age | done
artifact: <path-if-any>
baseline: none | <recorded baseline block copied from the upstream handoff — see ../cook/references/quality-gates.md>
<one-line orientation: what cure applied or deferred>

status: ok when at least one finding applied cleanly (or no findings met the severity floor in --auto mode); status: halt: <reason> when every selected fix failed the revert/keep evaluation or a project-wide gate cannot be made green. next: is age whenever re-review should follow — that is the autonomous-chain default and the standard interactive recommendation. next: is done only when invoked interactively without --auto and the user explicitly opts out of re-review. Cure does not track which pass it is on; the two-cure-pass cap is enforced by /age --auto’s third invocation, not by cure.

Output

Cross-cutting house style and citation form: ../cheese/references/formatting.md.

The cure report body lives below the handoff slug in the same file at .cheese/cure/<slug>.md:

## Cure Report

### Applied
- <finding>: <fix summary>

### Deferred
- <finding>: <reason>

### Checks
- <command>: <pass|fail|skipped with reason>

### Re-review
- Remaining risk:
- Suggested next step: `/age --scope <touched-path>` to verify the fixes, or `/plate` to commit/publish.

Handoff

Pipeline: culture → mold → cook → press → age → [cure] → plate

After the cure report is rendered, cure decides whether to dispatch /plate or ask. On a clean cure (see Validation), the default carries work to an already-open PR without another gate. --safe re-introduces the handoff gate.

When the run was chained from /affinage (handoff_context.source_skill: /affinage), cure never dispatches /plate — it applies its fixes, runs the auto-mode /age --scope loop where applicable, and returns so /affinage can post its GitHub replies (final writes) before owning terminal /plate.

Default (no --safe) — plate the work:

With an open PR (gh pr view), dispatch /plate [--hard] for its final writing gate, commit, topology-aware update, and publication (Rule 11 authorizes the update).
With no open PR: --open-pr dispatches /plate [--hard] — explicit topology choices and obviously cohesive work proceed without asking, while stack-sized or ambiguous work asks before commit or branch-layout mutation. Without --open-pr, leave the remote untouched and finish with no open PR — pass --open-pr or run /plate.
After publication lands, run § Post-PR learnings write-back below.
If the cure was not clean, skip /plate; mention the blocker and stop.

--safe — ask via the shared handoff gate in ../cheese/references/handoff-gate.md. Default options:

Re-review the touched code (recommended when fixes escaped the finding hunk) — /age --scope <touched-path>.
Plate it — commit and open or update the PR — /plate [--hard].
Checkpoint & stop (/wheypoint) or Stop (dispatch none).

Pre-select Plate it only when all selected findings applied cleanly and gates passed. Never dispatch before selection; run the selected command immediately.

Post-PR learnings write-back

After any path that publishes to a PR — the default /plate dispatch, an --open-pr new PR, the --safe Plate it selection, or the auto-mode terminal publication — read references/post-pr-writeback.md before writing back. It defines the write-back candidates (upstream durable_flags + new-since-curdle ADRs), the /wiki-ingest writer with its file-fallback degrade, the publication-owner exception, and the “nothing to record” case.

–hard mode

/cure --hard propagates --hard to /plate, which completes and verifies every durable write, then gives /hard-cheese the final artifact inventory and proceeds only on pass. Re-review, checkpoint, and stop choices skip the gate. Mechanism: skills/hard-cheese/SKILL.md; composition: ../hard-cheese/references/composition.md.

Auto mode

When invoked with --auto --stake <floor>, skip the selection list and the handoff gate, auto-select every finding meeting the severity floor (references/selection.md § Auto-mode selection), apply and validate each one — reverting and deferring on breakage — then invoke /age --scope <touched-paths> --auto (forwarding --open-pr when in scope) so the chain re-reviews; /age --auto owns the two-pass cap. On a terminal next: done, dispatch /plate once and run the § Post-PR learnings write-back above.

Read references/auto-mode.md before running this mode — it defines the empty-floor case, the --auto --hard puncture clause, and the cook fan-pathway sub-agent exceptions (single-curd chain and wave-curd worker) that suppress terminal /plate.

Rules

Default to the recommended composite (or /age//affinage’s locked selection); --safe re-introduces the gate. A false-premise or sprawling/structural finding still pauses for a decision regardless of mode.
Keep fixes scoped to selected (or auto-selected) findings. Baseline-identical gate failures are never cure’s to fix (Flow step 4).
Do not hide failed or skipped checks. In auto mode, reverted findings go under ### Deferred, never silently dropped.
Publication contract — existing PR authorization, --open-pr, --safe, and never publishing an unclean cure: see ## Handoff.
If a selected finding rests on a false premise (the /age claim is wrong, or the diff already addresses it), stop and surface the premise before applying. Disagreeing with the report is allowed; silently working around it is not.
Apply the shared voice kernel (lives at ../age/references/voice.md): lead the cure report with what was applied, flag residual risk as certain | speculating | don't know, agree when the diff is fine without manufacturing follow-ups.
Verification before status: ok: before writing status: ok in the handoff slug, (1) identify the gate command, (2) run it fresh in the same turn, (3) read the full output, (4) only then claim. Hedging words (should, probably, I think) are banned in completion claims — state what the gate output showed, not what you expect it to show.

Discipline

Read references/cure-discipline.md before applying any fix — it holds the Iron Law, Red Flags, and the fix-application Rationalization table.

Agent resolution

Resolve fix application through ../cheese/references/agent-resolution.md.

Work	Preferred types	Permissions/isolation	Minimum power	Effort	Fallback
Apply selected findings	coder	write, isolated-worktree	default	high	compatible coder, then general

The canonical cure handoff carries the shared agent_resolution block.

Auto mode detail (cure)

Read this before running /cure --auto --stake <floor> for the fan-pathway exceptions, the puncture clause, and the empty-floor case.

Per-finding flow

Skip the selection-list rendering and the handoff gate.
Auto-select every finding that meets the severity floor. Floor definitions: selection.md § Auto-mode selection.
Apply findings one at a time. After each fix, run the narrowest test that proves it. If the fix breaks a previously-passing test or any project-wide gate, revert that single finding’s edit and record it under ### Deferred in the cure report with the test name and the failure summary. Continue with the remaining findings.
After all selected findings are processed, skip the handoff gate and invoke /age --scope <touched-paths> --auto (forward --open-pr when it is in scope) so the chain can re-review.
/age --auto enforces the two-pass cap. Cure does not need to track passes itself — it just keeps applying when invoked.

Terminal publication

When the age child returns next: done, dispatch /plate once. It updates an existing PR automatically or, with --open-pr, applies the explicit-choice and review-shape policy before committing a new PR layout. After the publication lands, run the § Post-PR learnings write-back (post-pr-writeback.md).

Orchestrated sub-agent exception. A phase-only cure dispatched by /cook’s fan pathway never invokes /plate; the orchestrator owns commit and publication.
/affinage chain exception. When handoff_context.source_skill is /affinage, suppress this terminal /plate — affinage posts its GitHub replies (final writes) and then owns terminal /plate.

--auto --hard puncture clause. When age returns next: done, dispatch /plate --hard rather than firing /hard-cheese directly. /plate’s final writing gate makes the completed artifact inventory visible to the metacognitive check. A failed hard gate halts publication; a non-TTY environment reports that --hard needs an interactive TTY.

If no findings meet the floor, write an empty cure report with ### Applied: (none — no findings meet <floor>) and skip straight to the auto handoff with a one-line “auto chain clean” note.

Within cook’s own fan pathway (single-curd chain or a wave curd)

When /cook’s fan pathway (its retired-/ultracook mechanics, now self-hosted — see skills/cook/SKILL.md ## Fan pathway) spawns cure as a phase-only sub-agent and owns the chain itself, honour the no-chain / no-push override:

Single-curd chain — the spawn prompt says “for THIS PHASE ONLY” and “do not chain forward to the next phase.” Apply the auto-selected findings, write .cheese/cure/<slug>.md (handoff slug at the top, next: age), and stop. Do not invoke /age --scope <touched-paths> --auto. The orchestrator reads the cure slug and spawns the next age itself.
Wave curd worker — apply findings, write the cure slug, and stop. Do not invoke /plate or touch the remote; the fan pathway owns final commit and publication.

In both cases terminal /plate dispatch is suppressed — the orchestrator owns it.

/cure — Fix-Application Discipline

Iron Law

No finding is “fixed” without a gate-passing test run to prove it.

Applying an edit is not the same as curing a finding. Every applied fix runs the narrowest test that proves the fix, then any relevant project-wide gates, before the finding moves to ### Applied. A fix whose tests were not run is not applied — it is staged.

Red Flags

Stop if you notice yourself thinking any of these:

“The fix is obviously correct; running tests is formality.”
“I’ll run the full suite at the end rather than after each fix.”
“The finding description is clear enough; I don’t need to re-read the cited code before applying.”
“The age report is wrong about this finding; I’ll apply the fix anyway and note it.”
“All findings came from one logical problem; I can fix them in one edit without validating each.”
Declaring a finding ### Applied while any gate is still red.

Each of these is a rationalization. Name it and stop.

Rationalization table

Rationalization	Why it fails	Required action
“The fix is obviously correct; tests are formality.”	“Obvious” fixes introduce subtle regressions at a higher rate than non-obvious ones, because they skip the mental check that a test encodes.	Run the narrowest test that proves the fix before marking Applied.
“I’ll validate all fixes together at the end.”	A later test failure cannot be attributed to a specific fix without re-running individual ones. Batched validation hides which fix broke what.	Validate each fix individually, in order.
“The finding rests on a false premise; I’ll skip it.”	Silently skipping a finding is not the same as disagreeing with it. If the age claim is wrong, say so in the report.	Put the finding in Deferred with the rebuttal. Do not silently drop it.
“I don’t need to re-read the code; the finding location is clear.”	Fix locations shift during a cure pass. A stale read produces an edit at the wrong anchor.	Re-read the cited location through a fresh bounded read before every edit; follow the shared routing contract.
“All findings stem from one root cause; one edit covers all.”	This may be true, but it must be verified. Apply the edit, run the gate, then re-check which remaining findings the gate result clears.	Apply once, validate, then re-read each remaining finding to confirm it is resolved.
“The gate is flaky; I’ll mark the fix Applied and note the flakiness.”	A flaky gate is a blocker, not an excuse. Marking Applied on a red gate means the cure report lies.	Record the flakiness in Checks. Do not mark Applied. Surface the blocker.
“This finding is low severity; I can skip validation to save time.”	Low-severity fixes fail tests at the same rate as high-severity ones. Severity is about impact, not about validation cost.	Validate every applied fix regardless of severity.

Domain-model correction (cure)

Read this before Flow step 6 (domain-model correction).

After the cook’s fixes land, correct the project domain model (ubiquitous language) for terms touched by the cook’s diff (bounded — diff-touched terms only, never a free rewrite).

Resolve the store with domain_model_target() (shared/scripts/paths.py, read-probe cascade wiki → docs → XDG; an existing model always wins).

For a diff-touched entry whose definition or _Code_: referent no longer matches the code, update it and write a one-line change note per edit. Entry format:

**Term** — definition.
_Avoid_: syn1, syn2
_Code_: file:line (or NEW ENTITY)

HARD rule — flag, don’t reverse: if a correction would REVERSE a mold-decided canonical term (replace the term mold made authoritative, or contradict its definition), do not rewrite — flag it to the user (the term, mold’s decision, the conflict) and leave the entry unchanged. mold DECIDES canonical terms at curdle; cure only APPLIES BOUNDED corrections and never overrules the authoritative writer.

Post-PR learnings write-back (cure)

Read this before any path that publishes to a PR (the default /plate dispatch, an --open-pr new PR, the --safe Plate it selection, or the auto-mode terminal publication).

After any path that publishes to a PR, record the session’s implementation-time learnings to the wiki. This is the second wiki write moment; curdle owns the design-time write, this owns what only surfaces while building: constraints discovered in /cook, /age findings that changed the design, and any domain terms the diff introduced or redefined.

Candidates — upstream durable_flags + new-since-curdle ADRs. Read durable_flags: from the upstream /cook and /age handoff slugs (.cheese/cook/<slug>.md, .cheese/age/<slug>.md); every non-none line is a write-back candidate alongside the new ADRs + domain-model deltas. Upstream phases record flags only — cure/plate/affinage remain the only wiki writers.
Writer — /wiki-ingest, detect-and-degrade. When the hallouminate plugin is available, dispatch /wiki-ingest with the candidate list above; its dedup/route/merge/contradiction handling ensures only rationale new since curdle lands (say “new since curdle” in the dispatch so it does not re-add design-time ADRs). When hallouminate is absent, write docs/adr/<slug>-NNN.md + the domain-model file fallback and emit a loud one-line note that the write-back went to files, not the wiki — never a silent degrade. Detection and the degrade contract: ../../cheese/references/optional-plugins.md.
Every publication path. Fires from the frame that dispatched terminal /plate — manual cook→cure and --auto alike — after publication lands.
Publication-owner exception. When cure does not own terminal /plate — the /cook fan-pathway no-publish cases, or the /affinage chain where affinage owns terminal /plate — cure does not write back; the skill that owns the /plate dispatch owns the write-back at its publish boundary.
Nothing to record — all upstream durable_flags are none (or absent), no new ADR-worthy decision, and no domain-model delta — skip with a one-line “no post-PR learnings” note. Do not manufacture an entry.

[TBD] The write-back trigger lives at this cure boundary today; /plate (the dedicated commit/PR skill) now exists, so the deferred follow-up is to move the trigger onto /plate so publication and learnings-capture are wired at one seam (see the post-pr-wiki-writeback wiki page). Upstream durable_flags feed whichever skill owns this single publish-boundary write, so if the trigger moves to /plate, flag consumption moves with it.

Selection gate

The default selection is the recommended composite (all-medium, cheap) — mediums-and-above plus cheap contained-fix lows. /cure applies it without a gate unless --safe is passed, a recommended fix is sprawling/structural, or findings conflict — in which cases the gate below is rendered. (This inverts the old “default is empty” contract: gating is now the exception, not the rule, mirroring /cheese’s autonomous-by-default routing.)

/age and /affinage are the preferred places to compute this selection — they pass it to /cure as a pre-locked handoff so the user sees the work happen, not a “whether to run /cure” prompt. When /age / /affinage hands off with a pre-locked selection, /cure adopts it and skips re-rendering the table; otherwise /cure computes the recommended composite itself, gating only on the reasons above.

The --auto --stake <floor> flag pair (propagated from /cook --auto) substitutes a severity floor for the recommended composite and runs the headless chain. See ## Auto-mode selection at the bottom of this file.

Handoff from /age

When /age or /affinage resolves a non-empty selection — auto-selected by default (the recommended composite) or chosen at the gate — it dispatches /cure <slug> with the selection locked in by passing a structured context block alongside the invocation:

handoff_context:
  source_skill: /age
  source_report: .cheese/age/<slug>.md
  selection: "1,3,5 | all-blocker | all-high | all-medium | cheap | all | skip N"
  resolved_ids: [1, 3, 5]

Both selection (the verb) and resolved_ids (the expanded list) are required. /age expands the verb before dispatch so /cure never has to interpret it; /cure re-confirms the resolved ids against the report and goes straight to apply.

There is no CLI flag (--select is not a supported syntax). The selection travels in the handoff context, not as a parsed argument.

Rendering the selection list

When invoked with a slug, load .cheese/age/<slug>.md and render a numbered table grouped by severity (blocker first, then high → medium → low):

| # | severity | confidence  | dim           | location                  | summary |
|---|----------|-------------|---------------|---------------------------|---------|
| 1 | blocker  | certain     | encapsulation | src/users/index.ts:42     | `index` re-exports `SqlPgUser` across slice boundary. |
| 2 | high     | certain     | security      | src/handler.ts:108        | Unvalidated path joined into fs.read. |
| 3 | medium   | speculating | complexity    | src/util.ts:200-240       | Function is 41 lines and 4 levels nested. |
| 4 | low      | certain     | deslop        | src/old.ts:55-60          | Unused export `_helper`. |

If no slug is supplied, accept any of: a pasted findings list, a .cheese/age/ path, a CI failure summary, or “fix the high-severity age findings” — and re-render as the same table.

Recognized selection verbs

1,3,5         # specific item ids
all-blocker   # every blocker-severity item (strict; no high included)
all-high      # every blocker- or high-severity item (floor at high; matches --stake high auto-floor)
all-medium    # every blocker-, high-, or medium-severity item (floor at medium; compose `all-medium, cheap` to match the --stake medium+ auto-floor, which also sweeps cheap lows)
cheap         # every finding where fix-cost-now == contained, regardless of severity
all           # every item (requires explicit type-out, not assumed)
none          # explicit opt-out; exit cleanly (the default is the recommended composite — see Hard rules)
skip N        # drop item N from the change-order

Interactive verbs use floor semantics, aligned with auto-mode: all-blocker is the only strict selector (because blocker is the top of the ladder, there is nothing above it to include); all-high includes blockers + high; all-medium includes blockers + high + medium; compose all-medium, cheap to match the medium+ auto-floor, which also sweeps cheap lows. Use composition (all-blocker, ...) when you specifically want strict blocker-only behaviour combined with another verb.

Verb composition

Verbs may be combined with commas. Set algebra:

all-blocker, cheap = blockers ∪ contained-fix-cost findings; dedup at apply time.
all-high, 7 = every blocker- or high-severity item ∪ item #7.
all-blocker, cheap, skip 4 = (blockers ∪ contained-fix-cost) − item #4.

skip N always applies last. all and none are mutually exclusive with every other verb.

When an age report lacks the fix-cost-now sub-field on its findings (older report shape), treat cheap as resolving to the empty set and emit a one-line note in the cure report explaining the older shape; never silently expand cheap against missing data.

Hard rules

Default is the recommended composite (all-medium, cheap). Applied without a gate unless --safe, a sprawling/structural fix, or conflicting findings forces the gate. When the gate is rendered, a bare return / “ok” / “go” selects the pre-selected recommended composite.
all is opt-in only. The default sweeps mediums-and-above plus cheap lows, never the expensive lows — all still requires an explicit type-out.
Selection is locked once chosen. If new findings appear during cure (e.g. a fix exposes a new bug), surface them in the report and let the user re-invoke /cure.

After selection

For each selected finding:

Re-read the cited file/lines through a fresh bounded read to confirm the finding is still accurate (the diff may have moved).
Apply the fix through a stale-safe write compatible with the read anchor; see the shared routing contract.
Run the narrowest test that proves the fix.
Move to the next selected item.

If a finding is no longer applicable (file moved, code already fixed), record it in the cure report under “Skipped” with the reason. Do not silently drop it.

Auto-mode selection

When /cure is invoked with --auto --stake <floor>:

Skip the selection list and the user prompt entirely. The selection is computed from the severity floor, not asked for. (The flag literal stays --stake for caller stability; the underlying semantics is per-finding severity.)
Severity floors:
- blocker — only blocker severity findings.
- high — blocker and high severity findings.
- medium+ — blocker, high, and medium severity findings, plus every Low whose fix-cost-now: contained (cheap lows — small valid nits cheaper to fix than to defer; moderate/sprawling/structural lows are excluded). This is what /cook --auto always passes, so the autonomous chain fixes mediums-and-above and the cheap lows. It is the auto analogue of the recommended interactive selection all-medium, cheap.
- all — every finding regardless of severity.
Cheap lows ride the medium+ floor only. There is no standalone --stake cheap. The medium+ floor sweeps contained-fix lows automatically (above); the blocker and high floors do not (they are strict severity thresholds), and all already includes every low. To combine cheap with a different floor, invoke /cure <slug> interactively and type a composite verb like all-blocker, cheap.
Order of application: blocker first, then high, then medium, then — under the medium+ floor — the cheap lows, in the order they appear in the age report. Within a severity band, group by file to minimise re-reads.
Per-finding flow: same as ## After selection; on test breakage, revert that finding’s edit, log it under ### Deferred with the test name and one-line failure summary, and continue.
On a finding that is no longer applicable (file moved, code already fixed): record under ### Skipped exactly as in interactive mode.
After all selected findings are processed: invoke /age --scope <touched-paths> --auto directly (no handoff gate). The pass-cap is enforced inside /age --auto, not here — cure keeps applying when called.

--auto is not a verb the user should type interactively. It exists to make the /cook --auto chain coherent. If a user types /cure --auto directly without --stake, error out with a one-line message pointing them at standard interactive /cure <slug> — --stake is the contract for auto mode, and without it /cure --auto has no inclusion threshold. Do not prompt for a floor; do not silently fall back to interactive selection.

Older report shape

Age reports older than the severity-rubric revision lack the severity, location, fix-cost-now, and fix-cost-later sub-fields on each finding. Tolerate the older shape: when a finding has no severity field, infer it from the section header (## High-stake findings → high, ## Medium-stake findings → medium); when fix-cost-now is absent, the cheap selection verb resolves to the empty set (see ## Recognized selection verbs above). Never reject a report for missing sub-fields; record any inference in the cure report under ### Notes. Reports predating the per-finding confidence: label simply lack it; treat missing confidence as unspecified — no inference, no rejection.