# Automatic mode for Cure

Read this file before `/cure --auto --stake <floor>`.
It defines worker exceptions, the puncture clause, and the empty selection case.

## Per-finding flow

- Skip the selection list and the handoff gate.
- Select every finding that meets the severity floor.
  Read `selection.md` § Auto-mode selection for floor definitions.
- Render the brief per `selection.md` § Coder brief after the floor resolves and before the first dispatch.
- Apply one finding at a time.
  Implement its `recommendation:` as the locked decision and keep its `invariants:` true.
  A rebuttal goes under `### Deferred`; auto mode never substitutes a fix silently.
  Run the narrowest proving test after each fix.
  Revert a fix that breaks a passing test or project gate.
  Put it under `### Deferred` with the test name and failure summary.
  Continue with the remaining findings.
- After all findings, invoke `/age <slug> --scope <touched-path> [--scope <touched-path>] --auto`.
  Repeat `--scope` once for each touched path.
  Forward `--open-pr` and `--hard` when they are in scope.
  Skip the handoff gate.
- Let `/age --auto` enforce the two-pass cap.
  Cure does not track the pass count.

## Final publication

When Age returns `next: done`, run § Post-PR write-back in `post-pr-writeback.md`.
Then dispatch `/plate` once.
It updates an open PR automatically.
With `--open-pr`, it applies the explicit layout and review rules before a new PR.

A Cure worker from the Cook fan pathway does not invoke `/plate`.
The orchestrator owns commit and publication.

When `handoff_context.source_skill` is `/affinage`, do not invoke `/plate`.
Affinage posts its GitHub replies and owns final publication.

With `--auto --hard`, dispatch `/plate --hard` when Age returns `next: done`.
Do not invoke `/hard-cheese` directly.
`/plate` gives the completed artifact list to the metacognitive gate.
A failed hard gate stops publication.
In a non-TTY environment, report that `--hard` requires an interactive TTY.

When no finding meets the floor, write an empty Cure report.
Use `### Applied: (none — no findings meet <floor>)`.
Then continue to the automatic handoff.
Report `auto chain clean`.

## Cook fan pathway

Cook can dispatch Cure as a phase-only worker.
`/ultracook` is retired, but its no-chain contract remains in this pathway.
This case includes one curd and a curd in a wave.
Honor the no-chain and no-push override.

For one curd, apply the selected findings and write `.cheese/cure/<slug>.md`.
Put the handoff slug first and set `next: age`.
Then stop.
Do not invoke `/age <slug> --scope <touched-path> --auto`.
The orchestrator reads the slug and dispatches Age.

For a wave curd, apply the findings and write the Cure slug.
Then stop.
Do not invoke `/plate` or change the remote.
The Cook fan pathway owns final commit and publication.

In both cases, suppress final `/plate` dispatch.

# `/cure` bundle commands

`scripts/render_generated_regions.py` generates this file from the static `COMMANDS` manifest in `src/easy_cheese/skills/cure/commands.py`. Do not edit this file. Run each command as `python3 skills/cure/scripts/cure.pyz <command> [args...]`. Each command returns an integer exit status. Pass `--help` to a command for its arguments and output format. Keep worked examples in the skill instructions.

| Command | Purpose | Subcommands |
| --- | --- | --- |
| `domain-model-target` | Resolve the domain-model store from explicit Hallouminate probe results |  |
| `findings` | Render an /age report's selection table or coder brief and resolve selection verbs | `render-table`, `parse-selection`, `render-brief` |
| `gates` | Map a quality-gate scoreboard's booleans to a readiness verdict | `classify` |
| `handoff` | Render, parse, and dispatch-split handoff preambles | `render`, `parse`, `dispatch` |
| `paths` | Slugify, validate, resolve, and list .cheese artifact paths | `slugify`, `validate`, `existing`, `resolve`, `list`, `domain-model-target` |
| `read-handoff-slug` | Read the handoff preamble back from a phase artifact |  |
| `render-html` | Render a markdown report into one self-contained offline HTML file |  |
| `slugify` | Derive a kebab-case slug and durable spec path from task text | `from-task` |
| `wheypoint-resolve` | Resolve a phase slug through the shared Wheypoint kernel (JSON out) |  |
| `write-handoff-artifact` | Write a handoff preamble plus optional body atomically; pass --grounded paths |  |

# /cure — Fix-Application Discipline

## Iron Law

**No finding is Applied until a passing gate proves the fix.**

An edit alone does not make a finding Applied.
Run the narrowest proving test after each fix.
Then run each relevant project gate.
Move a finding to `### Applied` only after these checks pass.
Keep an unvalidated fix in staged state.

---

## Red Flags

Stop when you notice one of these thoughts:

- "The fix is obvious, so I can skip its test."
- "I can test all fixes together at the end."
- "The finding gives enough context, so I can skip a fresh read."
- "The Age report is wrong, but I can apply its fix anyway."
- "One edit fixes all findings, so I can skip separate checks."
- "I know a better fix than the recommendation, so I'll do that instead."
- "I can mark this finding Applied while a gate remains red."

Each thought is a rationalization.
Name it and stop.

---

## Rationalization table

| Rationalization | Why it fails | Required action |
| --- | --- | --- |
| "The fix is obvious, so tests are unnecessary." | An unchecked fix can introduce a subtle regression. | Run the narrowest proving test before you mark Applied. |
| "I can validate all fixes at the end." | A later failure does not identify which fix caused it. | Validate each fix in order. |
| "The finding has a false premise, so I can skip it." | A silent skip hides a disagreement with the report. | Put the finding in Deferred with the rebuttal. |
| "The location is clear, so I can skip a fresh read." | A stale location can send an edit to the wrong anchor. | Read the cited location again before every edit. Follow the [shared routing contract](../../cheese/references/code-intelligence-routing.md). |
| "One root cause means one check is enough." | One edit can affect findings in different ways. | Apply once and validate. Then check every related finding again. |
| "The gate is flaky, so I can mark Applied." | A red gate cannot prove the fix. | Record the failure in Checks. Keep the finding out of Applied. |
| "A low severity lets me skip validation." | Severity measures impact, not validation need. | Validate every applied fix. |
| "The recommendation is only a hint, so I can pick my own fix." | A silent substitution hides a design change from the reviewer and the Locked-decision lens. | Implement the recommendation, or rebut it under Deferred and stop. |

---

## Stacked-layer fix write-back

When a fix targets a stacked PR, read the spec's `landing.review_fixes` before
committing it. `fold` (the default) folds the fix into the layer commit it
corrects, rewriting that layer in place. `top-up` instead adds the fix as a new
commit on top of the stack, leaving every existing layer commit untouched.

## Bounded responsibility on dispatch

A repair agent owns only the findings in its brief.
Do not add nearby cleanup, repeat the review, or expand the scope.
This limit makes another dispatch safe and specific.

Before a near-limit stop, return one structured handoff with these parts:

- **Completed.** List each Applied finding and its verification result.
  Keep an unvalidated fix in staged state.
- **Changed-file ownership.** List every file that the agent changed.
- **Remaining.** List each unfinished finding and its exact next action.
- **Blockers.** List each environment or tool failure.

The orchestrator must use this handoff for the next dispatch.
Give the next agent the completed set and the next action.
Do not restart the full finding set.

A limit stop keeps the `BLOCKED` disposition.
The first `unresolved_work` entry starts with `writer stopped at its budget:`.
Use `budget checkpoint invalid:` when checkpoint validation fails.
These prefixes distinguish a limit stop from an executor failure.

`easy_cheese.shared.workflow.WriterBudgetExceeded` defines this seam.
It carries a `WriterCheckpoint` with the four handoff parts.
The `reason` text carries the blocker and the limit cause.
The host finalizes the checkpoint as a partial curd result.
Completed criteria keep their disposition and evidence.
Unreached criteria receive the limit reason.
List completed criteria in criterion order.
List only finished criteria as completed.
A failed checkpoint can still preserve readable deliverables.
Reject a checkpoint that claims every criterion.
The limit path skips review, so full coverage has no review evidence.

# Domain-model correction for Cure

Read this file before Flow step 6.

After Cook fixes land, correct domain terms that the Cook diff touches.
Do not rewrite terms outside that diff.

After the Hallouminate probe, resolve the store with the Cure bundle command:

```text
python3 skills/cure/scripts/cure.pyz domain-model-target \
  --probe <unavailable|no-match|match> \
  [--corpus repo:<repo>:wiki --model <present|absent|unknown>]
```

Use the domain-model probe transport in [`../../cheese/references/optional-plugins.md`](../../cheese/references/optional-plugins.md).

Pass `unavailable` when Hallouminate is not loaded or the probe failed. Pass `no-match` when the listing completed but contained no `repo:*:wiki` corpus. Pass `match` with the exact corpus name and its model status when the listing found one. The command accepts only these explicit probe results; it does not import or invoke MCP machinery. It emits canonical JSON with `backend`, string `location`, and `wiki_reachable`. Preserve the resolver's wiki, docs, then XDG precedence. When `wiki_reachable` is false, report the degraded file fallback before correcting it; the wiki can contain the authoritative model.

Read and write each backend with these steps:

- **One file.** Read the whole file. Update the touched entry. Read the file again.
- **Split directory.** List the context pages. Select the page of the bounded context that owns the term.
  Read only that page. Update the touched entry there. Read that page again.
  Stop and report when two pages define the same term.
- **Hallouminate corpus.** Read the entry with `read_markdown`.
  Write the updated entry with `add_markdown` and `overwrite: true`.
  Read the entry again with `read_markdown`.

Report the backend and the exact location in the Cure report.

Update a touched entry when its definition or `_Code_:` target no longer matches the code.
Write one change note for each edit.
Use this format:

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

`_Avoid_` is optional.
Mold omits this line when the term has no synonym.
Keep that omission, and never create a placeholder synonym.

**Hard rule: Report a reversal, but do not apply it.**
Do not replace or contradict a canonical term that Mold made authoritative.
Report the term, the Mold decision, and the conflict.
Leave the entry unchanged.
Mold selects canonical terms during Curdle.
Cure applies only bounded corrections.

# Post-PR write-back for Cure

Read this file before any path publishes to a PR.
These paths include default `/plate`, `--open-pr`, safe **Plate it**, and automatic publication.

Run this write-back before Cure dispatches `/plate`.
`/plate` requires every durable write before its final gate and commit.
Give each written path to `/plate` for its artifact inventory.
Do not write a tracked file after `/plate` completes.

Record implementation facts that became known after Curdle.
This operation is the second wiki write point.
Curdle owns the design write point.

Record constraints found during `/cook`.
Record `/age` findings that changed the design.
Record domain terms that the diff introduced or changed.

## Candidates

Read `durable_flags:` from `.cheese/cook/<slug>.md` and `.cheese/age/<slug>.md`.
Treat each non-`none` entry as a candidate.
Also include new ADRs and domain model changes.
Upstream phases record flags only.
Cure, Plate, and Affinage remain the wiki writers.

## Writer

When Hallouminate is available, dispatch `/wiki-ingest` with the candidate list.
Tell it to record only facts that are new since Curdle.
Its routing and conflict rules prevent duplicate design facts.

When Hallouminate is unavailable, write `docs/adr/<slug>-NNN.md` and the domain model fallback.
Report that the write-back used files instead of the wiki.
Do not hide this fallback.
Read [`optional-plugins.md`](../../cheese/references/optional-plugins.md) for detection and fallback rules.

## Ownership

Run this write-back before every publication path.
The frame that dispatches final `/plate` owns the write-back.

Cure does not write back when another skill owns final `/plate`.
This exception includes Cook fan workers that cannot publish.
It also includes an Affinage chain.
The final publication owner performs the write-back.

## Empty case

When all `durable_flags` are `none` or absent, check for new ADRs and domain changes.
When no candidate exists, report `no post-PR write-back candidates`.
Do not create an entry.

# Selection gate

The default selection is the **recommended composite**: `all-medium, cheap`.
It includes medium and higher findings plus inexpensive contained low findings.
Apply it without a gate by default.

Render the gate when `--safe` is present.
Also render it for a structural fix, a wide fix, or conflicting findings.
A rendered gate preselects the recommended composite.
This rule replaces the old empty default.

`/age` and `/affinage` normally calculate the selection.
They pass a locked selection to `/cure`.
This handoff lets the user see the fix work without another prompt.
If no locked selection exists, Cure calculates the recommended composite.

`--auto --stake <floor>` replaces the composite with a severity floor.
`/cook --auto` passes this pair.
Read `## Auto-mode selection` for its rules.

## Handoff from /age

When `/age` or `/affinage` selects findings, it dispatches `/cure <slug>`.
It passes this block with the invocation:

```yaml
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` and `resolved_ids` are required.
`selection` stores the verb.
`resolved_ids` stores the expanded identifiers.
The source skill expands the verb before dispatch.
Cure checks the identifiers against the report and applies them.

Do not use a `--select` CLI flag.
The selection moves through the handoff context.

## Render the selection list

With a slug, read `.cheese/age/<slug>.md`.
Render a numbered table by severity.
Use blocker, high, medium, then low order.

```text
| # | 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`. |
```

Without a slug, accept a findings list, Age path, CI summary, or scoped fix request.
Render the same table.

## Recognized selection verbs

```text
1,3,5         # specific item ids
1-3           # an inclusive range of item ids
all-blocker   # every blocker item
all-high      # every blocker or high item
all-medium    # every blocker, high, or medium item
cheap         # every contained-cost item
all           # every item; requires explicit input
none          # explicit opt-out
skip N        # remove item N from the application order
```

Interactive selectors use floor semantics.
`all-blocker` contains only blockers because blocker is the highest level.
`all-high` includes blockers and high findings.
`all-medium` includes blockers, high findings, and medium findings.
Combine `all-medium, cheap` to match the `medium+` automatic floor.

### Verb composition

Combine verbs with commas:

- `all-blocker, cheap` selects blockers and contained-cost findings.
- `all-high, 7` selects blocker and high findings plus item 7.
- `all-blocker, cheap, skip 4` selects the first two groups without item 4.

Remove duplicates when you apply the selection.
Apply `skip N` last.
Do not combine `all` or `none` with another verb.

Older reports can lack `fix-cost-now`.
For these reports, resolve `cheap` to the empty set.
Add one note to the Cure report.
Do not infer cost from missing data.

## Hard rules

- Use `all-medium, cheap` by default.
  Apply it without a gate unless a gate condition exists.
  At a rendered gate, bare return, `ok`, or `go` selects it.
- Require explicit input for `all`.
  The default excludes costly low findings.
- Lock the selection after the user or source skill selects it.
  Report new findings and let the user start another `/cure` run.

## Coder brief

Render the brief from the locked ids before any dispatch:

```text
python3 skills/cure/scripts/cure.pyz findings render-brief --report <path> --selection "<ids>"
```

The brief carries each finding's location, claim, `recommendation (locked)`, and `invariants` line.
The brief also carries each finding's `confidence:` tier; treat a `speculating` locked decision as provisional.
Give it to the repair agent verbatim.
The recommendation is the locked decision for that fix.
Keep every `invariants:` clause true while you edit.
Deviate only with a `### Deferred` entry that names why the recommendation is wrong or obsolete.
The taste test takes the same recommendation and invariants as its locked decision.
The Locked-decision lens halts on a silent substitution.

## After selection

For each selected finding:

1. Read the cited location again and confirm that the finding still applies.
2. Implement the locked recommendation per § Coder brief.
3. Apply a stale-safe edit that matches the read anchor.
4. Follow the [shared routing contract](../../cheese/references/code-intelligence-routing.md).
5. Run the narrowest test that proves the fix.
6. Continue to the next finding.

When a finding no longer applies, put it under `Skipped` with the reason.
Do not remove it silently.

## Auto-mode selection

When `/cure` receives `--auto --stake <floor>`, skip the list and user prompt.
Calculate the selection from the floor.

Use these floors:

- `blocker` selects blocker findings.
- `high` selects blocker and high findings.
- `medium+` selects blocker, high, and medium findings.
  It also selects low findings with `fix-cost-now: contained`.
- `all` selects every finding.

`/cook --auto` always passes `medium+`.
This floor matches the interactive `all-medium, cheap` selection.
Do not support a separate `--stake cheap` value.
Use an interactive composite to combine cheap findings with another floor.

Apply blocker, high, medium, then inexpensive low findings.
Within one severity, group findings by file to reduce repeated reads.
For each finding, follow `## After selection`.

When a fix breaks a passing test or project gate, revert that finding's edit.
Put it under `### Deferred` with the test name and failure summary.
Continue with the remaining findings.

When a finding no longer applies, put it under `### Skipped`.
After all findings, invoke `/age <slug> --scope <touched-path> --auto` directly (no handoff gate).
Repeat `--scope` once for each touched path.
`/age --auto` enforces the pass cap.
Cure continues to apply findings when Age calls it.

`--auto` is not an interactive verb.
If `/cure --auto` lacks `--stake`, return one error line.
Direct the user to `/cure <slug>`.
Do not prompt for a floor or fall back to interactive selection.

## Older report shape

Older Age reports can lack `severity`, `location`, `fix-cost-now`, and `fix-cost-later`.
When `severity` is absent, infer it from the section heading.
For example, `## High-stake findings` maps to `high`.
When `fix-cost-now` is absent, resolve `cheap` to the empty set.
Record each inference under `### Notes` in the Cure report.
Treat missing `confidence:` as unspecified.
Do not infer confidence or reject the report.
When `recommendation:` is absent, the brief shows `(none in report)`. Read the claim and location, choose the fix yourself, and record that choice under `### Applied`.