/press

When to invoke: Run the tests-only adversarial gate after /cook. Route bounded corrective Cook continuations. Use this skill when the user says “press the changes”, “harden this”, “press before /age”, or “/press”. Do not edit production code. Do not dispatch a global Cook repair from Press.

Press is the tests-only adversarial gate after /cook. Its skill contract is:

press(spec_ref)
  -> Continue("press-corrective-cook")
   | Dispatch("/age")
   | Stop(reason)

Press never owns first coverage. Press never edits production code. Cook owns the implementation. Press attacks the approved contract and preserves failure evidence for a bounded Cook repair.

Phase entry

Run python3 skills/press/scripts/press.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

Press accepts this invocation:

/press <slug> [--auto] [--hard] [--open-pr]

After phase entry, Press reads .cheese/cook/<slug>.md for the Cook handoff.

--auto selects the autonomous chain. See ## Auto mode.

--hard requests the optional final gate. Press forwards this flag to Age.

--open-pr is publication permission. Only the user supplies it. Press forwards this flag to Age. Press never adds it.

Press preserves the Cook durable_flags: value without change. Press ignores the Cook taste_test: value.

Packaged commands

Run this command for boundary routing:

python3 skills/press/scripts/press.pyz press-route \
  .cheese/press/<slug>.attempt-N.route.json

The request contains only outcome and repair_cycles:

{
  "outcome": "green",
  "repair_cycles": 0
}

Set outcome to green, in_contract_red, invalid_evidence, or production_changed.

Set repair_cycles to the number of completed corrective Cook continuations. Use 0 for the first attempt.

Use the command JSON action as the authority. Stop if the bundle does not exist.

Use separate append-only artifact names for each Press attempt. Use the same <slug> for all three attempts. Never reuse an attempt number.

Use these paths:

Attack candidate: .cheese/press/candidates/<slug>.attempt-N.json
Route request: .cheese/press/<slug>.attempt-N.route.json
Telemetry request: .cheese/press/<slug>.attempt-N.telemetry-request.json
Telemetry record: .cheese/press/<slug>.attempt-N.telemetry.json

A third in-contract RED returns Stop("third-red"). Do not create attempt-4 paths. Do not overwrite an earlier path.

Execution telemetry

Run this command after routing:

python3 skills/press/scripts/press.pyz press-telemetry \
  .cheese/press/<slug>.attempt-N.telemetry-request.json

The request carries only what the attempt observed. Run press-route for the attempt first: the command reads outcome and repair_cycles from that route request.

Save the output at .cheese/press/<slug>.attempt-N.telemetry.json. The record contains these values:

Attempt outcome
Retry count
Tool errors for each phase
Purpose for each delegated agent
Class for each changed file

Telemetry never controls the route. See references/telemetry.md.

Adversarial loop

Attack — Add or run only tests, fixtures, and test-only harness support. Use the approved seam and witness. Keep the attack identity and test digest stable.
Classify — Use in_contract_red for an in-contract failure. Use green for a clean pass. Use production_changed when the attempt changed production paths. Use invalid_evidence when you cannot verify the evidence.
Repair — Route in_contract_red with the completed corrective count. Counts 0 and 1 return Continue("press-corrective-cook"). Count 2 returns Stop("third-red").
Replay — Replay the same attack after the corrective Cook returns. Use the same attack and test digest. Then classify the result again.
Terminate — Return Dispatch("/age") only after GREEN.

Invalid evidence returns a stop. A production tree change also returns a stop. These outcomes never return a continuation.

Press has no global dispatch: /cook action. Press owns the corrective Cook Continue action.

Baseline-aware gates

Press preserves baseline-aware readiness for project gates. The Cook baseline: line names one artifact. That artifact holds the settled state.

Read the artifact through the baseline: path. Do not re-flag a failure when its test and signature match the artifact. New or changed failures block the route.

See ../cook/references/quality-gates.md. Also see references/gap-analysis.md.

Flow

Read — Load the approved spec, Cook handoff, and baseline block. Use canonical terms from .cheese/glossary/<slug>.md when that file exists.
Attack — Add or run only adversarial tests. Do not add first-coverage tests. Do not change production paths.
Classify — Select green, in_contract_red, invalid_evidence, or production_changed from the adversarial run.
Continue or stop — Run python3 skills/press/scripts/press.pyz press-route with outcome and repair_cycles. Only Continue, Dispatch, and Stop action shapes are public.
Report — Write .cheese/press/<slug>.md at a terminal result. Include the attempts, evidence, and review follow-ups.
Hand off — Send only a GREEN Dispatch("/age") to the global Age route.

Use code-intelligence-routing.md for source changes.

Use ../cheese/references/harness-portability.md for portability. The reference states that slash commands are host renderings, not the control model.

Press reports one readiness value. Map ready for /age to status: ok and next: age.

Map follow-up recommended to status: ok-with-concerns: <concern> and next: age. Use this status for a GREEN pass that also records a review follow-up. Age owns each recorded concern.

Map blocked to status: gated: <decision> and next: done. Stop after that status.

Auto mode

--auto runs the same adversarial loop. It also selects the next phase without a user prompt.

Dispatch /age <slug> --auto after ready for /age or follow-up recommended. Add --hard when the user supplied it. Add --open-pr when the user supplied it.

Stop after blocked. Do not dispatch Age.

Honor the no-chain directive when the caller supplies it. Write the Press handoff and stop. Do not start another phase. Cook’s fan pathway owns this directive. The retired /ultracook orchestrator previously owned it. Test for the directive itself. Do not test for the source name. See ../cook/references/auto-mode.md.

Output

Write .cheese/press/<slug>.md only at a terminal Press result. A corrective Continue stays inside the Press phase. It writes no durable handoff.

Write the file with python3 skills/press/scripts/press.pyz write-handoff-artifact; include one or more --grounded <path[#start-end]> arguments. Use the canonical preamble:

python3 skills/press/scripts/press.pyz write-handoff-artifact \
  --slug <slug> --status <status> --phase press --next <next> \
  --artifact .cheese/cook/<slug>.md --orientation "<one-line orientation>" \
  --durable-flags "<preserved Cook value>" --baseline "<baseline artifact path>" \
  --grounded <path[#start-end]> --body-file <body-path>

status: <canonical status field>
next: age | done
artifact: .cheese/cook/<slug>.md
durable_flags: <preserved Cook value>
baseline: none | <baseline artifact path>
<one-line orientation>

The handback contract defines the status: grammar. The preamble accepts no other keys. Put every Press value in the report body.

artifact: names the consumed Cook report. Do not put attack evidence on this line.

baseline: names the one artifact that Cook recorded. See ../cook/references/quality-gates.md.

Write these body sections under the preamble:

## Attempts — one row for each attempt. Give the attempt number, outcome, router action, candidate path, route path, and telemetry record path.
## Evidence — the stable attack identity and the test digest.
## Review follow-ups — each out-of-contract concern. Write none when the run records no concern. Age reads this section.

Map the router action to the terminal preamble:

router action	status	next
`Dispatch("/age")` after GREEN	`ok`	`age`
`Dispatch("/age")` after GREEN with a recorded concern	`ok-with-concerns: <concern>`	`age`
`Continue("press-corrective-cook")` on repair cycle 0 or 1	no handoff	no handoff
`Stop("third-red")`	`ok`	`done`
invalid evidence or production change	`halt: <reason>`	`done`

next: done is terminal. It never starts another phase.

A valid third-RED stop is ready for terminal reporting. It does not dispatch Age. It can offer a later Cook handoff that the user selects.

Reserve next: age for a GREEN Dispatch("/age"). The corrective Continue belongs to Press. It is not a global phase handoff. Do not write next: press.

Handoff

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

After a GREEN Press report, use the shared handoff gate. Start the review with /age <slug>.

The Press owner controls a corrective Cook continuation. Do not offer that continuation as a second global route.

Forward --hard, --auto, and --open-pr to /age when the caller supplied them. Never add --open-pr.

Rules

Do not edit production code, production fixtures, or production adapters.
Do not dispatch a global Cook repair from Press.
Do not use more than two corrective continuations.
Do not change the attack between retries.
Do not treat out-of-contract behavior as an implementation request. Record it under ## Review follow-ups. Report the run as ok-with-concerns on a GREEN pass.
Preserve baseline-aware readiness unless these route rules replace it.

Discipline

Press uses evidence first. An unverified failure is not a RED.

Name the outcome before each route decision. Name the attack digest and completed repair_cycles count. Stop if one value is missing. Do not guess.

Generated bundle command inventory: references/commands.md.

`/press` bundle commands

scripts/render_generated_regions.py generates this file from the static COMMANDS manifest in src/easy_cheese/skills/press/commands.py. Do not edit this file. Run each command as python3 skills/press/scripts/press.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
`press-route`	Return the Press action: continue, dispatch /age, or stop (JSON in, JSON out)
`press-telemetry`	Build the Press attempt telemetry record (JSON in, JSON out)
`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

Press adversarial gap analysis

Ownership boundary

Press is not a second first-coverage phase. Cook owns the implementation and the inner RED→GREEN loop.

Press attacks the approved contract after Cook. Press writes only tests, fixtures, or test-only harness support.

Treat a missing production implementation as an in-contract RED. Request a bounded corrective Cook continuation.

What Press may expose

Gap type	Evidence	Action
In-contract defect	The approved seam fails on an adversarial input or transition	Preserve the same failing test and digest. Route as `in_contract_red`.
Invalid evidence	The recorded run does not verify the attack outcome	Stop without a repair action.
Production mutation	A production path changes during a Press interval	Stop.
Out-of-contract behavior	The approved Test Contracts omit a desired behavior	Record it under `## Review follow-ups`. Report `ok-with-concerns` on a GREEN pass. Do not implement it.

Evidence sequence

Complete these steps at each Press entry and after each Cook continuation:

Run the same adversarial attack. Do not change its test or fixture digest.
Select green, in_contract_red, invalid_evidence, or production_changed.
For an in-contract RED, record the failed test and its digest before you select a route.

The failed-test digest is part of the evidence chain. A corrective Cook continuation can change production code to make the attack GREEN.

Do not rewrite or weaken the attack. Do not change its expected witness or the tests that it uses.

Priority order

Press closes only adversarial gaps in the approved Cook contract:

Keep the production tree unchanged during the Press interval.
Attack approved boundaries, invalid inputs, state transitions, integrations, and error paths.
Verify assertion sensitivity. The attack must fail for an incorrect value, state, or error.

Cook owns first coverage. Do not create one hardening test for each changed behavior.

Do not add tests for unchanged or out-of-contract code.

Repair bound and readiness

The packaged boundary uses the classified outcome and completed corrective count. The request contains only these fields:

{
  "outcome": "in_contract_red",
  "repair_cycles": 0
}

repair_cycles counts completed corrective Cook continuations for this slug. Use 0 for attempt 1, 1 for attempt 2, and 2 for attempt 3.

Each attempt uses separate candidate and route paths. Never reuse or overwrite an earlier attempt artifact.

Run this command from the project root. Use the route request for the current attempt:

python3 skills/press/scripts/press.pyz press-route \
  .cheese/press/outer-tdd-gates.attempt-1.route.json

The packaged boundary applies these rules:

GREEN returns Dispatch("/age").
An in-contract RED at repair_cycles 0 or 1 returns Continue("press-corrective-cook").
The third RED at repair_cycles 2 returns Stop("third-red").
Invalid evidence and production changes stop.

A valid GREEN result is ready for review. Press dispatches Age after that result.

A complete third-RED evidence chain is ready for terminal reporting. Press does not dispatch Age after that result.

Invalid evidence blocks the route. A production mutation also blocks the route.

Baseline failures do not become new Press findings when their tests and signatures match the Cook handoff.

New or changed failures block the route.

When to fix or follow up

Situation	Action
An approved adversarial test exposes a defect in Cook behavior	Preserve the RED evidence. Request a bounded corrective Cook continuation.
The evidence chain, digest, or production snapshot is invalid	Stop. Report the exact integrity failure.
The attack targets behavior outside approved contracts	Record it under `## Review follow-ups` for `/age`. Do not edit production code. Do not continue.

Hard rule — preserve evidence

Never weaken the attack to obtain GREEN. Never reset a digest or change the attack between replays.

Never turn a Press continuation into a global Cook dispatch.

Press execution telemetry

Press provides a clean workflow gate for measurement. This record shows what happened. It never changes the Press decision.

The record gives evidence for a route that press-route already selected.

Request

Run the command once for each attempt. Run it from the project root after press-route:

python3 skills/press/scripts/press.pyz press-telemetry \
  .cheese/press/outer-tdd-gates.attempt-1.telemetry-request.json

Include every field. Use an empty list to record no items.

{
  "slug": "outer-tdd-gates",
  "attempt": 1,
  "tool_errors": [
    {"phase": "attack", "operation": "pytest"},
    {"phase": "attack", "operation": "pytest"}
  ],
  "delegations": [
    {"role": "reviewer", "purpose": "assertion sensitivity sweep"}
  ],
  "changed_files": ["tests/fanout/python/test_press_route.py"]
}

Use the slug from the route request filename.
Set attempt to repair_cycles + 1. Do not use a value greater than 3.
The command reads outcome and repair_cycles from .cheese/press/<slug>.attempt-N.route.json. Run press-route for the attempt first.
Do not repeat outcome or repair_cycles in the request. The command rejects them as unknown keys.
The command stops when the route request is missing, malformed, or names a repair_cycles value that contradicts attempt.
Set phase to read, attack, classify, route, report, or handoff. These values match the Flow steps.
Set operation to the failed tool or command. Use the same name for repeated operations.
Set role to the delegated agent.
Include a purpose for each delegation. Do not record a delegation without a reason.
Use repository-relative paths from git status --porcelain for changed_files. Include only paths from the Press interval.

Record

Save the JSON at .cheese/press/<slug>.attempt-N.telemetry.json. Use an append-only file, as you do for candidate and route artifacts.

Cite the telemetry file from the Press report.

{
  "slug": "outer-tdd-gates",
  "attempt": 1,
  "outcome": "in_contract_red",
  "repair_cycles": 0,
  "changed_file_count": 1,
  "changed_file_classes": ["tests"],
  "production_source_files": [],
  "boundary_consistent": true,
  "tool_error_count": 2,
  "operations": [
    {"phase": "attack", "operation": "pytest", "errors": 2, "recurring": true}
  ],
  "delegations": [
    {"role": "reviewer", "purpose": "assertion sensitivity sweep"}
  ]
}

recurring is true after the same phase and operation fail twice during one attempt. This result marks an operation failure, not a temporary tool failure.
Each changed path has the class tests, metadata, or production_source. An unknown path has the production_source class. This rule exposes unfamiliar paths.
boundary_consistent is false when an outcome other than production_changed reports production source paths. This audit flag does not control the route. press-route still selects the action.
The metadata class does not make a path boundary-safe. Press writes only tests, fixtures, and test-only harness support. Review each metadata path by hand. Classify the attempt as production_changed when a metadata path is not test support.

Read the records

Treat one attempt as one sample. Wait for 20 top-level invocations or four weeks of records before reassessment.

Change Press behavior only after a repeated cluster occurs. One recurring operation or one coder delegation is an audit point, not a defect.