--- name: ultracook description: This skill should be used when the user has an approved spec or unambiguous task with a high-blast-radius footprint and wants the whole pipeline (cook → press → age → cure → age → cure → age, all `--auto`) to run forward in fresh-context isolation per phase — phrases like "/ultracook .cheese/specs/.md", "ultracook this", "run the full pipeline in isolation", "fresh-context auto chain", "send it through the cave", "pipeline with no contamination". Runs inline and spawns full-peer general-purpose sub-agents (one per phase), each invoking the phase skill with `--auto` and writing its handoff slug under `.cheese//.md`. Sub-agents inherit the parent's model and full tool / MCP / skill access. Use when the user wants `/cook --auto`'s autonomous chain semantics but with each phase reasoning blind to prior phases. After `/mold`; ends after the third age spawn (or earlier on halt / early-stop). license: MIT --- # /ultracook Use this skill when the user wants the whole `cook → press → age → cure → age → cure → age` chain to run forward without per-step approval, **and** wants each phase to reason in fresh context — blind to the previous phase's chain-of-thought. Do not use it for short focused changes (`/cook --auto` is cheaper and continuous), for fuzzy planning (`/mold`), or for review-only work (`/age`). `/ultracook` is the sub-agent-transport sibling of `/cook --auto`. Same seven spawns, same `--auto` semantics propagated end-to-end, same medium+ stake floor, same two-cure-pass cap. The only difference is that each phase runs inside its own freshly-spawned sub-agent, so the parent context never accumulates phase-internal reasoning and review is adversarial rather than continuous. ## Inputs Accept one of: - A spec path, usually `.cheese/specs/.md`. - A bare slug whose spec lives under `.cheese/specs/.md`. - A pasted spec, with a slug supplied alongside. `/ultracook` does not accept fuzzy or open-ended asks — those go to `/mold` first. The orchestrator assumes the contract is already locked. ## Flow 1. **Resolve slug** — derive `` from the input. If a spec path is given, the slug is the basename without `.md`; if a bare slug is given, confirm the spec exists at `.cheese/specs/.md`. 2. **Guard against re-entry** — if any of `.cheese/{cook,press,age,cure}/.md` already exist, stop with a one-line list of the existing handoffs and tell the user to either run `/cheese --continue ` to resume from the latest phase or `rm` the relevant files to start fresh. Never silently wipe. 3. **Phase loop** — for each phase in `cook, press, age, cure, age, cure, age`, spawn a fresh sub-agent (see `## Sub-agent contract` below), wait for it to return, read `.cheese//.md`, and decide: - `status:` starts with `halt` → surface the halt reason and stop. - `next:` is `done` and the phase is age → stop early with a clean summary (the diff is clean at the medium+ floor; cure has nothing to apply). - Otherwise → continue to the next phase. 4. **Final summary** — after the third age spawn (or any earlier stop), print a four-line summary: passes completed, total findings applied / deferred, the final age-report path, and the next-step nudge ("review the diff, then `/gh` when ready"). `/ultracook` never invokes `/gh`. PR creation stays user-triggered. ## Phases and slug paths The chain is fixed: seven spawns. The orchestrator walks the table top-to-bottom and stops after the last entry. Every spawn uses the canonical `/ --auto` form. Cook accepts a bare slug per its Inputs section; the other phases already resolve their paths from the slug. | # | Phase invocation | Handoff slug | |---|-------------------------------------------|-------------------------------| | 1 | `/cook --auto` | `.cheese/cook/.md` | | 2 | `/press --auto` | `.cheese/press/.md` | | 3 | `/age --auto` | `.cheese/age/.md` | | 4 | `/cure --auto --stake medium+` | `.cheese/cure/.md` | | 5 | `/age --auto` | `.cheese/age/.md` (overwritten) | | 6 | `/cure --auto --stake medium+` | `.cheese/cure/.md` (overwritten) | | 7 | `/age --auto` | `.cheese/age/.md` (final report) | ### Cap enforcement The two-cure-pass cap is enforced by **chain length, not by age**. Each age sub-agent boots in fresh context and cannot count prior cure passes, so the contract cannot rely on age tracking the count. Instead: - The chain table has exactly seven entries, with two cure spawns (#4 and #6) and three age spawns (#3, #5, #7). After spawn #7 completes, the orchestrator stops because the table is exhausted. - Each age spawn writes `next:` from what it observes on its own run: `next: cure` when at least one medium-or-above finding exists, `next: done` when none do. The field is **informational** under ultracook — it drives early-stop (when an age reports clean), but it does not gate cap enforcement. - `/ultracook` does not pass a pass-ordinal hint to age. Age has no need to know whether it is age₁, age₂, or age₃; the orchestrator owns the position. ## No-chain isolation directive Each phase's existing `--auto` contract chains forward in-session — `/cook --auto` invokes `/press --auto`, which invokes `/age --auto`, etc. `/ultracook` overrides that behaviour: every spawn must run only its own phase, write the slug, and stop. The orchestrator owns the chain. The override travels in the spawn prompt as the explicit no-chain directive: `Do not chain forward to the next phase even though your auto-mode contract documents that. Write your handoff slug and stop. The /ultracook orchestrator is driving the chain.` Each phase's SKILL.md `## Auto mode` section honours this directive — see `skills//SKILL.md` `### When invoked from /ultracook` for the per-phase contract amendment. Without the directive, sub-agent #1 would run the entire pipeline inside its own context and the per-phase fresh-context property would not be delivered. ## Sub-agent contract — inheritance, not diminution Each phase spawns a **full peer** sub-agent — same model as the parent, full tool access, full MCP access, full skill access. These are not focused mini-assistants: - `/cook` writes code across the changed files. - `/press` runs the project's test suite and adds tests. - `/age` reviews nine dimensions over the diff. - `/cure` applies fixes via `cheez-write` and re-runs test gates. Diminutive defaults (haiku model, restricted tools, `Explore`-style read-only workers) will choke phases that need to edit dozens of files or run real test suites. Concrete `Agent()` signature shape (harness-agnostic; adapt the keyword names to the host): ``` Agent( subagent_type: "general-purpose", # never specialised # model: omit — inherits parent's model. Do not pass haiku/sonnet here. prompt: "Run / --auto for THIS PHASE ONLY. Write .cheese//.md with the handoff schema and stop. Do not chain forward to the next phase even though your auto-mode contract documents that. The /ultracook orchestrator is driving the chain." ) ``` The sub-agent's stdout is operator-visible but **not** the chaining contract. The orchestrator must read `.cheese//.md` to decide what happens next; never infer success or `next:` from the sub-agent's last line. Asking the sub-agent to echo its status to stdout would tempt a future maintainer to wire stdout-driven chaining back in. Rules: - **Do not downgrade the model.** Omit the model parameter so the sub-agent inherits the parent's model. Never pass a smaller tier (haiku, lighter task workers) for ultracook phases. - **Do not narrow `subagent_type`.** Use `general-purpose` (or the harness equivalent that grants full tool access). Do not pass `Explore`, `lsp-probe`, or any other read-only / scoped worker type. - **Do not restrict tools or MCP access.** Each phase needs Bash, Edit, Write, Read, the cheez-* skills, and any MCP servers the parent has. Restricting them is the failure mode the contract exists to prevent. - **Do pass the slug.** The phase skill resolves its own paths from the slug; `/ultracook` does not pre-compute paths for the sub-agent. The contract is "inheritance, not diminution" because most sub-agent patterns in this ecosystem (Explore, lsp-probe, whey-drainer, ricotta-reducer) are deliberately scoped down for cheap focused queries. `/ultracook` does the opposite: it spawns workers that are full peers of the parent, doing major work in their own context window. ## Handoff slug schema Every phase writes its handoff slug to `.cheese//.md` with the following minimum shape (prepended as frontmatter or inline at the top of richer reports such as age and press): ```markdown status: ok | halt: next: artifact: ``` `status: ok` means the phase finished cleanly and `next` names the next phase the chain *would* run if the orchestrator chose to continue. `status: halt: ` means the chain stops; `/ultracook` surfaces the reason verbatim. `next: done` is informational: an age phase writes it when the diff is clean at the medium+ floor (early-stop signal). The two-cure-pass cap is enforced by chain length, not by `next: done` — see `### Cap enforcement` above. For phases that already write rich reports (`/age`, `/press`, `/cure` once extended, `/cook` once extended), the slug schema is prepended at the top of the same file — there is no second file. The schema is the contract; the body is whatever the phase normally writes. ## When auto mode stops early `/ultracook` stops and surfaces the report when: - A phase's slug file is missing after the sub-agent returns (the sub-agent did not write its handoff — print "phase did not write handoff — check sub-agent logs"). - A phase writes `status: halt: ` (a quality gate failed, press came back `blocked`, cure could not apply any finding). - An age phase writes `next: done` because the diff is clean at the medium+ floor (early-stop). Note: this only fires from age spawns; cure always writes `next: age` and cap-enforcement does not flow through `next: done` (the chain length handles that — see `### Cap enforcement` above). In every early-stop case, surface the slug file path so the user can read the full report. The natural terminal case (chain table exhausted after spawn #7) does not need an explicit early-stop signal — the orchestrator simply runs out of entries to spawn. ## Existing handoffs If any of `.cheese/{cook,press,age,cure}/.md` already exist when `/ultracook ` is invoked, stop. Do not silently wipe — the user may be mid-pipeline. Scan all four phase paths and print only the ones that exist: ``` Slug `` has existing handoffs: .cheese/cook/.md (when present) .cheese/press/.md (when present) .cheese/age/.md (when present) .cheese/cure/.md (when present) Use `/cheese --continue ` to resume from the latest phase, or `rm` the listed files to start fresh. ``` Removing the handoffs by hand is the only sanctioned reset path. The orchestrator does not accept a wipe flag — adding one would create a destructive default for what is intentionally a one-line `rm`. ## Output A short final summary, after the chain stops (success or early stop): ``` Ultracook summary — Passes completed: Findings: applied, deferred (cure-report path) Final age: .cheese/age/.md Next step: review the diff, then /gh when ready ``` If the chain stopped on a halt, replace "Next step" with the halt reason and the path of the phase that surfaced it. ## Preferred tools and fallbacks `/ultracook` is a thin orchestrator — it spawns sub-agents and reads the small handoff slug files they write. The preferred tools live inside each phase, not here. The orchestrator only needs: | Need | Prefer | Fallback | |-----------------------------------|-----------------------|-----------------------------------| | Spawning the per-phase worker | `Agent()` / harness sub-agent primitive | none — without sub-agent spawn, the fresh-context property cannot be honoured | | Reading the handoff slug | `cheez-read` / host file read | host file read | | Detecting existing handoffs | host file glob / list | `cheez-search` `tilth_files` glob | If the host harness does not expose a sub-agent primitive at all, `/ultracook` is the wrong skill — recommend `/cook --auto` instead, which uses the same flag semantics in the parent's own context. ## Rules - Sub-agents are full peers, not diminutive workers. Do not downgrade the model, do not narrow `subagent_type`, do not restrict tools or MCP access. - The chain is fixed: cook → press → age → cure → age → cure → age, all `--auto`, cure stake floor `medium+`. Do not invent extra phases or skip phases. - Read each phase's handoff slug after the sub-agent returns. Do not infer success from the sub-agent's last line — read the file. - Surface halts verbatim. Do not paraphrase, do not soften, do not "retry" a halted phase silently. - Never invoke `/gh`. PR creation stays user-triggered. - Never wipe existing handoffs. Stop and tell the user to use `/cheese --continue` or `rm` by hand. - Apply the shared voice kernel (lives at `skills/age/references/voice.md` in this repo): lead the final summary with what happened, flag residual risk as `certain | speculating | don't know`, do not manufacture follow-ups.