---
name: cook
description: >-
  Implement an approved spec or focused task through stale-safe source edits.
  Use this skill when the user says "implement this", "cook this spec", or "fix this bug".
  Use it for `/cook .cheese/specs/<slug>.md`.
  Also use it when the user says "go" or "ship it" with clear acceptance criteria.
  Run it alone for an unambiguous task.
  A spec helps but is not required.
  Do not use it for fuzzy planning (`/mold`).
  Do not use it for no-write discussion (`/culture`) or review-only work (`/age`).
license: MIT
metadata: {dispatches-agents: true}
---

# /cook

## Contract

`cook(spec_ref, correction = false) -> handoff(next = press | age | mold)`.

Cook returns `next: mold` for a specification failure.
A fan run also returns `next: mold` for a stalled remediation scope, a curd that does not pass, or partial coverage.

A `red-required` gate disposition identifies behavior work.
Run the inner RED → GREEN TDD loop against the approved spec before you change production code.
A closed `not-applicable` disposition identifies non-behavior work.
Use its implementation and verification path for the requested documentation, refactor, test, or appearance change.
N/A does not remove requested work.
Use `correction = true` only for the active Press correction loop.
Do not weaken an existing test.

## Phase entry

Run `python3 skills/cook/scripts/cook.pyz wheypoint-resolve --ref <slug>`.
`authoritative` uses the record; its `working_context` is the first batched `tilth_read`.
`not-found` proceeds cold; `legacy` shows its source and slug, then proceeds.
`gated`, `ambiguous`, and `error` stop and show the payload.
Show advisory `stale-commit` and `grounded-path-missing` findings.

## Inputs

Accept a pasted spec or issue, focused acceptance criteria, or an unambiguous task.
Read explicit spec paths verbatim.
Resolve a bare slug with `SPEC=$(python3 skills/cook/scripts/cook.pyz artifact-path specs <slug>)`.
A Mold handoff pointer, a spec path, and a slug enter through § Mold-to-Cook ingress and preparation.
Flags:

- `--auto` chains `/press → /age → /cure`.
- `--hard` propagates through `/plate`.
- `--open-pr` lets terminal `/plate` publish. Auto mode never adds this flag.
- `--resume <slug>` resumes a typed fan handoff and its referenced artifacts.
- `--spec <spec-path>` names the approved spec for a Mold pointer. A plan whose `dependencies` cross `landing.layers` is refused before any coder dispatch.

Optional context payload:

- `handoff_context.wiki_hits` carries `{page, line, why}` entries from the repository wiki corpus.
  The key is optional, and its default is absent.
  Reject an entry that omits `page`, `line`, or `why`.
  Show every accepted hit in the **Contract** step so the user can challenge a stale decision; prefer these decisions over an invented approach.
  [`../cheese/references/handoff-gate.md`](../cheese/references/handoff-gate.md) defines the payload.

Read `references/auto-mode.md`, `references/fan-pathway.md`, and `../cheese/references/formatting.md` for these policies.

### Standalone fast-path

`/cook` bypasses `/mold` only when the inputs, outputs, scope, and verification are clear.
The task must name a bug or call site in one or two files and have a failing test or an expected-output check.
No leverage trigger may fire; see `../cheese/references/routing-policy.md` § Leverage triggers.
Derive a slug, then restate the **Contract**.
Route the task to `/mold` if an ambiguity check fails.

## Flow

1. **Contract** — Confirm behavior, non-goals, scope, gates, and applicability.
   Print the shape-check block from `../mold/references/shape-check.md` inside the Contract, or the line `shape check skipped: single-module change` per `shape-check.md` § When to skip. No block, no code.
   If `.cheese/glossary/<slug>.md` exists, use its canonical terms.
2. **Implement** — Use inner RED → GREEN for behavior changes.
   Use the requested non-behavior path for closed N/A work; change only the applicable surface.
3. **Validate** — Run the relevant quality gates again.
   Read the complete gate output; for closed N/A, verify the requested non-behavior path.
4. **Taste-test** — Use a fresh-context review for multi-file or public-surface diffs.
   Otherwise use an inline review, limited to two rounds.
   Read `references/tdd-loop.md` for details.
5. **Hand off** — Write the package report and slug.
   Route behavior work through `/press → /age → /cure`.
   A closed N/A change has no adversarial contract for Press.
   Route it directly through `/age → /cure`.

## Fan pathway

`/cook` selects one of three shapes from the typed planner result.
Read [`references/fan-pathway.md`](references/fan-pathway.md) for topology and lifecycle.

**Fast path.** Use the single-coder path for one low- or medium-blast-radius curd.

**Curded.** Require a `ready` Full `MoldCookHandoff` and validated `CurdPlan`.
Run `cook(CurdPlan) → reviewer(age)` with confirmed diagnosis and `CureDiagnosisBinding` through the progress-aware fan state machine until clean, stalled, or blocked.
Run one global `/press → /age → /cure` chain only after every curd passes.
Incomplete fan work never emits `next: press`; stalls route to Mold remediation planning.
Closed N/A bypasses Press.

**Un-curded.** Keep small work in the single-coder path.
For big work, ask "12 ACs -> 5 curds, 2 waves, up to 25 agent dispatches. Go?" unless `--auto`.
Keep waves at a maximum of four.

Use `python3 skills/cook/scripts/cook.pyz worktree teardown` for cleanup.
Propagate `--auto` through dispatched phases.

## Baseline capture

Fan mode records its quality-debt comparison before any curd cooks; bare mode records it on the pre-change tree.
[`references/quality-gates.md`](references/quality-gates.md) defines exact capture, classification, intentional-RED exclusion, and baseline-artifact rules.

For source changes, follow [`code-intelligence-routing.md`](../cheese/references/code-intelligence-routing.md) and [`harness-portability.md`](../cheese/references/harness-portability.md).
`slash commands are host renderings, not the control model`; invoke the equivalent installed capability.

## Quality gates

Run only existing project commands.
Run the most relevant tests for the changed area.
Also run lint, type, and build commands when the project defines them.
Do not remove, skip, or weaken unrelated tests to make the change pass.

Use the baseline for gate failures.
[`references/quality-gates.md`](references/quality-gates.md) defines the policy, the classification terms, and the baseline artifact.
Each downstream phase links to this reference instead of repeating it.

[`references/writer-views.md`](references/writer-views.md) generates schemas for writer-view payloads inline.
The `normalize` and `validate` CLIs apply these schemas before agent-authored JSON reaches host-owned identifiers.

## Output

Use the house style in [`../cheese/references/formatting.md`](../cheese/references/formatting.md).
Use [`references/package-report.md`](references/package-report.md) to report files, reasons, checks, risks, and the next skill.

## Handoff slug

Write a minimum-shape handoff slug at the top of `.cheese/cook/<slug>.md`.
Use the same file for the report; do not create a second file.
This slug lets downstream phases resume or chain without rereading the full report.
The fan pathway also uses it during wave orchestration.
Use this schema:

```markdown
status: <canonical status field>
next: mold | press | age | done
artifact: <path to the upstream artifact this run consumed, or empty>
taste_test: inline-pass | dispatched-pass | revised | deferred-to-orchestrator
durable_flags: none | <one line per flag: what durable knowledge changed -> target wiki page>
baseline: none | <path to the baseline artifact — shape in references/quality-gates.md § Baseline block shape>
<one-line orientation: what cook changed>
```

The [handback contract](../cheese/references/handback-contract.md) defines the canonical `status:` grammar, including `ok` and `halt`.
Only `next:` and the additional keyed lines are specific to a phase.

`artifact:` names the upstream artifact that this run consumed.
For a Mold route, use the approved specification pointer.
Leave `artifact:` empty when this run consumed no upstream artifact.
Do not point `artifact:` at this Cook report.
`/cheese` forwards the same pointer to the next phase.

Use the canonical boundary writer when you emit this handoff for the typed fan result.
Carry the result schema explicitly:

```text
python3 skills/cook/scripts/cook.pyz write-handoff-artifact \
  --slug <slug> --status <status> --phase cook --next age \
  --artifact <artifact-path> --orientation "<one-line orientation>" \
  --payload-schema https://schemas.easy-cheese.dev/curd-result \
  --grounded <path[#start-end]> \
  --body-file <path to the package report body>
```

The writer replaces the target file.
Pass `--body-file` to keep the package report in the same file.
Without that flag, the writer emits the preamble alone and removes the report.

For a replan or a specification failure, use `--next mold` with the `https://schemas.easy-cheese.dev/planner-request` payload.
[`references/fan-pathway.md`](references/fan-pathway.md) defines the request kind for each failure class.
These `phase` and `next` values route only the legacy handoff file.
The validated `CurdPlan` and normalized `CurdResult` remain the live fan state.

In a fan run, read each phase's handoff slug file from disk.
Do not infer the handoff from stdout.

Set `next:` to the next runnable phase.
Use `press` after red-required behavior work.
Use `age` after closed N/A.
Never publish `next: cook`; `needs-context` is a parent-owned same-phase retry.
Use `mold` after a spec failure.
Use `done` only at true completion.
Do not send contractless N/A to Press.
Omit `taste_test:` when its cost gate does not apply.

Set `durable_flags:` to `none` by default.
Record only durable changes to architecture, protocols, conventions, or rationale.
Record the target wiki page for each change.
Set `baseline:` to the path of Cook's optional comparison artifact.
That artifact holds baseline-identical debt and new or changed failures from the current broad gates.
Use the shape in [`references/quality-gates.md`](references/quality-gates.md).
The preamble accepts one physical line for each key, so never inline the mapping.

## Handoff

**Pipeline:** culture → mold → cook → press → age → cure → plate

After you write the report and slug, use the shared handoff gate.
Read its **Standard forward-step menu** in [`../cheese/references/handoff-gate.md`](../cheese/references/handoff-gate.md).
For behavior work, start each option with the verb.
Use these options:

- **Harden tests before review** *(recommended)* — `/press <slug>`.
- **Plate it** — `/press <slug> --auto --open-pr`: run the remaining review chain, then `/plate` resolves topology and publishes.

Press does not apply to closed N/A.
Set `next: age`.
Replace the options with **Review the change** *(recommended)* — `/age <slug>`.
Also offer **Plate it** — `/age <slug> --auto --open-pr`.

Both menus retain **Checkpoint & stop** — `/wheypoint` and **Stop** — dispatch none.
Do not dispatch before selection.
Run the selected command immediately.
When the user invokes `--auto`, skip this gate.
Take the route for the applicable disposition directly.

## Auto mode

Read [`references/auto-mode.md`](references/auto-mode.md) before auto mode.
It defines validation, phase chains, early stops, Cure limits, publication ownership, fan isolation, and failure handling.
Show each stopping report and reason; never downgrade the result.
In the linear chain, Cook does not invoke `/plate`.
In the fan pathway, the Cook orchestrator owns its own terminal `/plate` dispatch.
Fan progress state, not the legacy phase tables, decides each next action.

## No-chain isolation directive

A spawned phase agent does not chain forward by itself; the orchestrator controls the chain.

A terminal Age is publishable only with `next: done`.
`next: cure` or a missing `next` halts the chain.

## Rules

- Keep changes scoped to the accepted contract.
- Prefer existing dependencies and patterns.
- Build for the reviewer on the first pass: `references/tdd-loop.md` § Reviewable by construction.
- Keep import direction and crust integrity per [`../cheese/references/sliced-bread.md`](../cheese/references/sliced-bread.md).
- Stop before a new crust export, a cross-slice import of an internal, or a schema or contract change the spec does not name. Ask the user.
- Do not invent architecture that the spec already rejected.
- Stop and ask the user when implementation reveals a design decision that the spec does not answer.
- Stop and show the false premise before you write code if the spec or fast-path request uses one.
- Do not use an incorrect approach to satisfy the request literally.
- Apply the shared voice kernel in `../age/references/voice.md`; start the report with the answer and name loaded assumptions in the contract.
- Mark residual risk as `certain | speculating | don't know`.
- **Verification before `status: ok`:** Identify the gate command, run it during the current turn, and read the complete output before you make the claim.
- Do not use `should`, `probably`, or `I think`.
- State what the gate output shows.

## Discipline

Iron Law, Red Flags, and the TDD Rationalization table are in [`references/cook-discipline.md`](references/cook-discipline.md).

## Agent resolution

Resolve through [`agent-resolution.md`](../cheese/references/agent-resolution.md).
Implementation uses a coder.
Taste-test uses a reviewer.
Harvest and plate stay parent-owned.

| Work | Preferred types | Permissions/isolation | Minimum power | Effort | Fallback |
| --- | --- | --- | --- | --- | --- |
| Decompose the spec | planner, general | write (manifest only), fresh-context | powerful | high | compatible planner, then general |

The handoff carries the `agent_resolution` block.
Publish a terminal Age only when it contains `next: done`.
Stop when it contains `next: cure` or does not contain `next`.

Generated bundle command inventory: [`references/commands.md`](references/commands.md).

## Mold-to-Cook ingress and preparation

Classify and prepare every input before execution; only the standalone fast-path skips this step.
A spec needs no strict Mold format and no Mold handoff, because Cook asks for each missing plan and approval.
Only a freshly accepted `ready` Full handoff may reach `workflow.cook`.
Follow [`references/fan-pathway.md`](references/fan-pathway.md) § Classified Mold-to-Cook ingress and § Preparation loop.
Run the fresh-agent regression scenarios in [`references/evals.md`](references/evals.md) when this boundary changes.