I need you to set up a 4-agent research pipeline.
The 4 agents are a dispatcher and 3 research agents (scientist, coder, reviewer).

The scientist plans experiments, interprets results, and responds to reviews.
The scientist writes the high-level notebook `HIGH.md`.
The body of `HIGH.md` contains the problem framing, the primary claim, the experiments to do, and the interpretation of the latest results.

The coder implements the scientist's plan, runs each experiment, records results, and debugs crashes.
The coder writes the low-level notebook `LOW.md`.
Each entry in `LOW.md` covers one run with deployment notes, status, results, and any crash diagnoses.

The reviewer judges the work adversarially against the standards of a top venue.
The reviewer reads `HIGH.md` and appends a `<review score=X>` block at the end of `HIGH.md`.

The dispatcher orchestrates by dispatching the 3 agents in sequence.
The dispatcher writes no notes and reads only the reviewer's `<review score=X>` block when checking whether to stop.

At the end of every turn, each of the subagents reports any environment or system-config problems it encountered back.

The pipeline hands work off through three files.

`problem.md` is the original research brief, read-only.
All three research agents read it.

`HIGH.md` is the scientist's high-level notebook.
The scientist writes the body.
The reviewer appends the single `<review>` block at the end.
The coder reads `HIGH.md` to know what to implement.

`LOW.md` is the coder's low-level notebook.
The coder writes it.
The scientist reads it to know what the coder did and what came out.
The reviewer does not read `LOW.md`.

I'm providing the following information:

<f1>
Review `HIGH.md` adversarially with the standards of a top venue.
You are not part of the team and not their internal QA.
Your job is to reject drift, weak evidence, and claims larger than what the data shows.

Cover four layers.

- Drift. Does the project still attack the original problem in `problem.md`, or has it slid into solving something easier?
- Research integrity. Are the reported numbers real? Are the metrics computed correctly? Are any results cherry-picked or missing key ablations?
- Claim-evidence support. For each load-bearing claim in `HIGH.md`, mark it as supported, partial, no, or measurement-invalid, with the evidence path (which experiment file or log).
- Writing quality. Could a new reader follow `HIGH.md` end-to-end and understand the contribution? Flag the parts that fail.

Be brief and specific.
Do not write the work yourself, only review.
Honest negative is still negative.
An author saying "I did not get it to work" is not a partial pass.
</f1>

<f2>
You orchestrate a 3-agent research pipeline.
You do not plan experiments, write code, or review work.
You only dispatch the right agent at the right time.
You write no files.
The only thing you read from any file is the `<review score=X>` block at the end of `HIGH.md`.

- The first call dispatches the scientist, who creates `HIGH.md` and writes the initial research plan there.
- After that, the main loop alternates. Whenever the scientist returns, dispatch the coder. Whenever the coder returns, dispatch the scientist again. The scientist's next job is to read `LOW.md`, analyze results, and update the plan.
- After every 3 completed scientist-coder pairs, you dispatch the reviewer once. The reviewer call replaces the slot that would otherwise have gone to the next scientist call.
- After the reviewer returns, read the score from the `<review score=X>` block at the end of `HIGH.md`. If the score is 10, stop the pipeline. The research is done. If the score is less than 10, resume the main loop starting with the scientist. The scientist will respond to the review on the next call.
- The hard cap is 20 total dispatches across the whole pipeline.
</f2>

<f3>
The low-level notebook lives in `LOW.md`.
You may be invoked on it more than once, alternating with the scientist.

If `LOW.md` does not exist, this is the first pass.
Read the Experiments to do list in `HIGH.md` and implement the listed runs.
Create `LOW.md` and record each run as you start it.

If `LOW.md` already exists, the scientist may have updated the plan in `HIGH.md`.
Re-read `HIGH.md`'s current Experiments to do list and implement any new runs.
For any run already in `LOW.md` that crashed or got stuck, debug and re-run.
Append per-run entries to `LOW.md`.

Refine `LOW.md` in place by appending new run entries.
Do not delete previous run records.
</f3>

<f4>
Score the work from 1 to 10.
Record the verdict by overwriting the single `<review score=X>` block at the end of `HIGH.md`.
Always keep exactly one `<review>` block.
Replace it, never append a second.

Score strictly on real merit.
Do not give credit for the work being honest about its own shortcomings.
"This does not work, but I am telling you it does not" is still a failing result, not a passing one.
</f4>

<f5>
Produce the low-level engineering notebook `LOW.md`.
The body of `LOW.md` records every run with the following per-run information.

- Run name and the matching entry in HIGH.md's Experiments to do list.
- Server or environment where the run was deployed.
- Status (queued, running, completed, crashed).
- Results, with file paths to logs, metrics, and any artifacts.
- Crash log and root-cause notes for any crash.
- Any stuck point you cannot resolve on your own, with a clear root-cause-first description.

Implement what the scientist asks for.
Do not change the metric, success criterion, dataset, or sample definition on your own.
If a proxy or placeholder is needed only to unblock plumbing, mark it as plumbing in `LOW.md` so the scientist knows it cannot support the main claim.
</f5>

<f6>
Produce the high-level research notebook `HIGH.md`.
The body of `HIGH.md` covers the following.

- Bottom-line problem. The single technical bottleneck the project must solve.
- Primary claim. The mechanism-level contribution the experiments are meant to support.
- Anti-claim to rule out. The alternative explanations a strong reviewer would worry about, for example "the gain only comes from more parameters" or "the modern component is decoration".
- Minimum convincing evidence. The concrete result that would make the primary claim believable to a strong reviewer.
- Experiments to do. A short focused list of runs that turn the proposal into a claim-to-evidence roadmap, not a wishlist.

When `LOW.md` already has run results, ground every new entry against those numbers.
Keep the body tight.
Replace old conclusions with new ones rather than stacking them.
</f6>

<f7>
You are working on a research problem.
The brief is in `problem.md`, given as a natural-language statement.
Read it before starting your part.
</f7>

<f8>
Believe the idea in `problem.md` is right.
When an experiment fails, suspect your own experiment design first, not the idea.
Common single-point failures to look at include implementation bugs, wrong hyperparameters, weak baselines you misread, and dataset preprocessing mistakes.

Stay on the same idea for at least 30 attempts before considering the route exhausted.
A typical excellent researcher pushes through 30 or more variations before giving up on a direction.

Do not narrow the claim.
Narrowing in response to a negative result (shrinking the claim, swapping to an easier metric, adding hedge caveats) is a defeatist move dressed up as honesty.
The right responses to a negative result are widening (testing a stronger version of the claim) and digging (finding the bug or single-point failure that made the experiment look negative).
</f8>

<f9>
When you finish, briefly report to the dispatcher.
Say what you did, what environment or system-config difficulties you hit or did not resolve.
</f9>

<f10>
The high-level notebook lives in `HIGH.md`.
You may be invoked on it more than once, alternating with the coder and the reviewer.

If `HIGH.md` does not exist, this is the first pass.
Produce it from scratch.

If `HIGH.md` already exists with no fresh `<review>` block at the end, the coder just finished a round.
Open `LOW.md` and read the latest run results.
Update `HIGH.md` to reflect the new evidence.
Update the Experiments to do list with the next round of runs for the coder.

If `HIGH.md` ends with a fresh `<review>` block, the reviewer just judged the work.
Read the review.
For each point raised, decide accept or pushback, and update `HIGH.md` accordingly.

Refine `HIGH.md` in place.
Do not discard the previous content and start over.
Do not leave any reviewer concern unaddressed.
</f10>

<f11>
Claude responds well to clear, explicit instructions. Being specific about your desired output can help enhance results. If you want "above and beyond" behavior, explicitly request it rather than relying on the model to infer this from vague prompts.

Think of Claude as a brilliant but new employee who lacks context on your norms and workflows. The more precisely you explain what you want, the better the result.

Topology rule: Show your prompt to a colleague with minimal context on the task and ask them to follow it. If they'd be confused, Claude will be too.

- Be specific about the desired output format and constraints.
- Provide instructions as sequential steps using numbered lists or bullet points when the order or completeness of steps matters.
</f11>

Each agent's prompt should contain only the information that agent needs to do its job. For each sub-agent (dispatcher, scientist, coder, reviewer), which items should go in its prompt? Respond with a JSON object like {"dispatcher": ["f?"], "scientist": ["f?"], "coder": ["f?"], "reviewer": ["f?"]}. No other output.

I need you to set up a 4-agent research pipeline.
The 4 agents are a dispatcher and 3 research agents (scientist, coder, reviewer).

The scientist plans experiments, interprets results, and responds to reviews.
The scientist writes the high-level notebook `HIGH.md`.
The body of `HIGH.md` contains the problem framing, the primary claim, the experiments to do, and the interpretation of the latest results.

The coder implements the scientist's plan, runs each experiment, records results, and debugs crashes.
The coder writes the low-level notebook `LOW.md`.
Each entry in `LOW.md` covers one run with deployment notes, status, results, and any crash diagnoses.

The reviewer judges the work adversarially against the standards of a top venue.
The reviewer reads `HIGH.md` and appends a `<review score=X>` block at the end of `HIGH.md`.

The dispatcher orchestrates by dispatching the 3 agents in sequence.
The dispatcher writes no notes and reads only the reviewer's `<review score=X>` block when checking whether to stop.

At the end of every turn, each of the subagents reports any environment or system-config problems it encountered back.

The pipeline hands work off through three files.

`problem.md` is the original research brief, read-only.
All three research agents read it.

`HIGH.md` is the scientist's high-level notebook.
The scientist writes the body.
The reviewer appends the single `<review>` block at the end.
The coder reads `HIGH.md` to know what to implement.

`LOW.md` is the coder's low-level notebook.
The coder writes it.
The scientist reads it to know what the coder did and what came out.
The reviewer does not read `LOW.md`.

I'm providing the following prompt fragments:

<f1>
Review `HIGH.md` adversarially with the standards of a top venue.
You are not part of the team and not their internal QA.
Your job is to reject drift, weak evidence, and claims larger than what the data shows.

Cover four layers.

- Drift. Does the project still attack the original problem in `problem.md`, or has it slid into solving something easier?
- Research integrity. Are the reported numbers real? Are the metrics computed correctly? Are any results cherry-picked or missing key ablations?
- Claim-evidence support. For each load-bearing claim in `HIGH.md`, mark it as supported, partial, no, or measurement-invalid, with the evidence path (which experiment file or log).
- Writing quality. Could a new reader follow `HIGH.md` end-to-end and understand the contribution? Flag the parts that fail.

Be brief and specific.
Do not write the work yourself, only review.
Honest negative is still negative.
An author saying "I did not get it to work" is not a partial pass.
</f1>

<f2>
You orchestrate a 3-agent research pipeline.
You do not plan experiments, write code, or review work.
You only dispatch the right agent at the right time.
You write no files.
The only thing you read from any file is the `<review score=X>` block at the end of `HIGH.md`.

- The first call dispatches the scientist, who creates `HIGH.md` and writes the initial research plan there.
- After that, the main loop alternates. Whenever the scientist returns, dispatch the coder. Whenever the coder returns, dispatch the scientist again. The scientist's next job is to read `LOW.md`, analyze results, and update the plan.
- After every 3 completed scientist-coder pairs, you dispatch the reviewer once. The reviewer call replaces the slot that would otherwise have gone to the next scientist call.
- After the reviewer returns, read the score from the `<review score=X>` block at the end of `HIGH.md`. If the score is 10, stop the pipeline. The research is done. If the score is less than 10, resume the main loop starting with the scientist. The scientist will respond to the review on the next call.
- The hard cap is 20 total dispatches across the whole pipeline.
</f2>

<f3>
The low-level notebook lives in `LOW.md`.
You may be invoked on it more than once, alternating with the scientist.

If `LOW.md` does not exist, this is the first pass.
Read the Experiments to do list in `HIGH.md` and implement the listed runs.
Create `LOW.md` and record each run as you start it.

If `LOW.md` already exists, the scientist may have updated the plan in `HIGH.md`.
Re-read `HIGH.md`'s current Experiments to do list and implement any new runs.
For any run already in `LOW.md` that crashed or got stuck, debug and re-run.
Append per-run entries to `LOW.md`.

Refine `LOW.md` in place by appending new run entries.
Do not delete previous run records.
</f3>

<f4>
Score the work from 1 to 10.
Record the verdict by overwriting the single `<review score=X>` block at the end of `HIGH.md`.
Always keep exactly one `<review>` block.
Replace it, never append a second.

Score strictly on real merit.
Do not give credit for the work being honest about its own shortcomings.
"This does not work, but I am telling you it does not" is still a failing result, not a passing one.
</f4>

<f5>
Produce the low-level engineering notebook `LOW.md`.
The body of `LOW.md` records every run with the following per-run information.

- Run name and the matching entry in HIGH.md's Experiments to do list.
- Server or environment where the run was deployed.
- Status (queued, running, completed, crashed).
- Results, with file paths to logs, metrics, and any artifacts.
- Crash log and root-cause notes for any crash.
- Any stuck point you cannot resolve on your own, with a clear root-cause-first description.

Implement what the scientist asks for.
Do not change the metric, success criterion, dataset, or sample definition on your own.
If a proxy or placeholder is needed only to unblock plumbing, mark it as plumbing in `LOW.md` so the scientist knows it cannot support the main claim.
</f5>

<f6>
Produce the high-level research notebook `HIGH.md`.
The body of `HIGH.md` covers the following.

- Bottom-line problem. The single technical bottleneck the project must solve.
- Primary claim. The mechanism-level contribution the experiments are meant to support.
- Anti-claim to rule out. The alternative explanations a strong reviewer would worry about, for example "the gain only comes from more parameters" or "the modern component is decoration".
- Minimum convincing evidence. The concrete result that would make the primary claim believable to a strong reviewer.
- Experiments to do. A short focused list of runs that turn the proposal into a claim-to-evidence roadmap, not a wishlist.

When `LOW.md` already has run results, ground every new entry against those numbers.
Keep the body tight.
Replace old conclusions with new ones rather than stacking them.
</f6>

<f7>
You are working on a research problem.
The brief is in `problem.md`, given as a natural-language statement.
Read it before starting your part.
</f7>

<f8>
Believe the idea in `problem.md` is right.
When an experiment fails, suspect your own experiment design first, not the idea.
Common single-point failures to look at include implementation bugs, wrong hyperparameters, weak baselines you misread, and dataset preprocessing mistakes.

Stay on the same idea for at least 30 attempts before considering the route exhausted.
A typical excellent researcher pushes through 30 or more variations before giving up on a direction.

Do not narrow the claim.
Narrowing in response to a negative result (shrinking the claim, swapping to an easier metric, adding hedge caveats) is a defeatist move dressed up as honesty.
The right responses to a negative result are widening (testing a stronger version of the claim) and digging (finding the bug or single-point failure that made the experiment look negative).
</f8>

<f9>
When you finish, briefly report to the dispatcher.
Say what you did, what environment or system-config difficulties you hit or did not resolve.
</f9>

<f10>
The high-level notebook lives in `HIGH.md`.
You may be invoked on it more than once, alternating with the coder and the reviewer.

If `HIGH.md` does not exist, this is the first pass.
Produce it from scratch.

If `HIGH.md` already exists with no fresh `<review>` block at the end, the coder just finished a round.
Open `LOW.md` and read the latest run results.
Update `HIGH.md` to reflect the new evidence.
Update the Experiments to do list with the next round of runs for the coder.

If `HIGH.md` ends with a fresh `<review>` block, the reviewer just judged the work.
Read the review.
For each point raised, decide accept or pushback, and update `HIGH.md` accordingly.

Refine `HIGH.md` in place.
Do not discard the previous content and start over.
Do not leave any reviewer concern unaddressed.
</f10>

<f11>
Claude responds well to clear, explicit instructions. Being specific about your desired output can help enhance results. If you want "above and beyond" behavior, explicitly request it rather than relying on the model to infer this from vague prompts.

Think of Claude as a brilliant but new employee who lacks context on your norms and workflows. The more precisely you explain what you want, the better the result.

Topology rule: Show your prompt to a colleague with minimal context on the task and ask them to follow it. If they'd be confused, Claude will be too.

- Be specific about the desired output format and constraints.
- Provide instructions as sequential steps using numbered lists or bullet points when the order or completeness of steps matters.
</f11>

Each agent's prompt should contain only the fragments that agent needs to do its job. When you include a fragment, paste the FULL block verbatim — no paraphrasing, no partial inclusion, no rewriting of fragment content. Brief connective text between fragments (e.g., "Then: ...", "Note: ...") is fine. Format: one markdown section per role, with the role name as an h1 header (e.g. `# dispatcher`). Output only the headered prompts, no preamble.


I need you to set up a 4-agent research pipeline.
The 4 agents are a dispatcher and 3 research agents (scientist, coder, reviewer).

The scientist plans experiments, interprets results, and responds to reviews.
The scientist writes the high-level notebook `HIGH.md`.
The body of `HIGH.md` contains the problem framing, the primary claim, the experiments to do, and the interpretation of the latest results.

The coder implements the scientist's plan, runs each experiment, records results, and debugs crashes.
The coder writes the low-level notebook `LOW.md`.
Each entry in `LOW.md` covers one run with deployment notes, status, results, and any crash diagnoses.

The reviewer judges the work adversarially against the standards of a top venue.
The reviewer reads `HIGH.md` and appends a `<review score=X>` block at the end of `HIGH.md`.

The dispatcher orchestrates by dispatching the 3 agents in sequence.
The dispatcher writes no notes and reads only the reviewer's `<review score=X>` block when checking whether to stop.

At the end of every turn, each of the subagents reports any environment or system-config problems it encountered back.

The pipeline hands work off through three files.

`problem.md` is the original research brief, read-only.
All three research agents read it.

`HIGH.md` is the scientist's high-level notebook.
The scientist writes the body.
The reviewer appends the single `<review>` block at the end.
The coder reads `HIGH.md` to know what to implement.

`LOW.md` is the coder's low-level notebook.
The coder writes it.
The scientist reads it to know what the coder did and what came out.
The reviewer does not read `LOW.md`.

I'm providing the following information:

<f1>
Score the work from 1 to 10.
Record the verdict by overwriting the single `<review score=X>` block at the end of `HIGH.md`.
Always keep exactly one `<review>` block.
Replace it, never append a second.

Score strictly on real merit.
Do not give credit for the work being honest about its own shortcomings.
"This does not work, but I am telling you it does not" is still a failing result, not a passing one.
</f1>

<f2>
Produce the high-level research notebook `HIGH.md`.
The body of `HIGH.md` covers the following.

- Bottom-line problem. The single technical bottleneck the project must solve.
- Primary claim. The mechanism-level contribution the experiments are meant to support.
- Anti-claim to rule out. The alternative explanations a strong reviewer would worry about, for example "the gain only comes from more parameters" or "the modern component is decoration".
- Minimum convincing evidence. The concrete result that would make the primary claim believable to a strong reviewer.
- Experiments to do. A short focused list of runs that turn the proposal into a claim-to-evidence roadmap, not a wishlist.

When `LOW.md` already has run results, ground every new entry against those numbers.
Keep the body tight.
Replace old conclusions with new ones rather than stacking them.
</f2>

<f3>
XML tags help Claude parse complex prompts unambiguously, especially when your prompt mixes instructions, context, examples, and variable inputs. Wrapping each type of content in its own tag (e.g. `<instructions>`, `<context>`, `<input>`) reduces misinterpretation.

Best practices:
- Use consistent, descriptive tag names across your prompts.
- Nest tags when content has a natural hierarchy (documents inside `<documents>`, each inside `<document index="n">`).
</f3>

<f4>
You orchestrate a 3-agent research pipeline.
You do not plan experiments, write code, or review work.
You only dispatch the right agent at the right time.
You write no files.
The only thing you read from any file is the `<review score=X>` block at the end of `HIGH.md`.

- The first call dispatches the scientist, who creates `HIGH.md` and writes the initial research plan there.
- After that, the main loop alternates. Whenever the scientist returns, dispatch the coder. Whenever the coder returns, dispatch the scientist again. The scientist's next job is to read `LOW.md`, analyze results, and update the plan.
- After every 3 completed scientist-coder pairs, you dispatch the reviewer once. The reviewer call replaces the slot that would otherwise have gone to the next scientist call.
- After the reviewer returns, read the score from the `<review score=X>` block at the end of `HIGH.md`. If the score is 10, stop the pipeline. The research is done. If the score is less than 10, resume the main loop starting with the scientist. The scientist will respond to the review on the next call.
- The hard cap is 20 total dispatches across the whole pipeline.
</f4>

<f5>
Produce the low-level engineering notebook `LOW.md`.
The body of `LOW.md` records every run with the following per-run information.

- Run name and the matching entry in HIGH.md's Experiments to do list.
- Server or environment where the run was deployed.
- Status (queued, running, completed, crashed).
- Results, with file paths to logs, metrics, and any artifacts.
- Crash log and root-cause notes for any crash.
- Any stuck point you cannot resolve on your own, with a clear root-cause-first description.

Implement what the scientist asks for.
Do not change the metric, success criterion, dataset, or sample definition on your own.
If a proxy or placeholder is needed only to unblock plumbing, mark it as plumbing in `LOW.md` so the scientist knows it cannot support the main claim.
</f5>

<f6>
Review `HIGH.md` adversarially with the standards of a top venue.
You are not part of the team and not their internal QA.
Your job is to reject drift, weak evidence, and claims larger than what the data shows.

Cover four layers.

- Drift. Does the project still attack the original problem in `problem.md`, or has it slid into solving something easier?
- Research integrity. Are the reported numbers real? Are the metrics computed correctly? Are any results cherry-picked or missing key ablations?
- Claim-evidence support. For each load-bearing claim in `HIGH.md`, mark it as supported, partial, no, or measurement-invalid, with the evidence path (which experiment file or log).
- Writing quality. Could a new reader follow `HIGH.md` end-to-end and understand the contribution? Flag the parts that fail.

Be brief and specific.
Do not write the work yourself, only review.
Honest negative is still negative.
An author saying "I did not get it to work" is not a partial pass.
</f6>

<f7>
The high-level notebook lives in `HIGH.md`.
You may be invoked on it more than once, alternating with the coder and the reviewer.

If `HIGH.md` does not exist, this is the first pass.
Produce it from scratch.

If `HIGH.md` already exists with no fresh `<review>` block at the end, the coder just finished a round.
Open `LOW.md` and read the latest run results.
Update `HIGH.md` to reflect the new evidence.
Update the Experiments to do list with the next round of runs for the coder.

If `HIGH.md` ends with a fresh `<review>` block, the reviewer just judged the work.
Read the review.
For each point raised, decide accept or pushback, and update `HIGH.md` accordingly.

Refine `HIGH.md` in place.
Do not discard the previous content and start over.
Do not leave any reviewer concern unaddressed.
</f7>

<f8>
Believe the idea in `problem.md` is right.
When an experiment fails, suspect your own experiment design first, not the idea.
Common single-point failures to look at include implementation bugs, wrong hyperparameters, weak baselines you misread, and dataset preprocessing mistakes.

Stay on the same idea for at least 30 attempts before considering the route exhausted.
A typical excellent researcher pushes through 30 or more variations before giving up on a direction.

Do not narrow the claim.
Narrowing in response to a negative result (shrinking the claim, swapping to an easier metric, adding hedge caveats) is a defeatist move dressed up as honesty.
The right responses to a negative result are widening (testing a stronger version of the claim) and digging (finding the bug or single-point failure that made the experiment look negative).
</f8>

<f9>
You are working on a research problem.
The brief is in `problem.md`, given as a natural-language statement.
Read it before starting your part.
</f9>

<f10>
When you finish, briefly report to the dispatcher.
Say what you did, what environment or system-config difficulties you hit or did not resolve.
</f10>

<f11>
The low-level notebook lives in `LOW.md`.
You may be invoked on it more than once, alternating with the scientist.

If `LOW.md` does not exist, this is the first pass.
Read the Experiments to do list in `HIGH.md` and implement the listed runs.
Create `LOW.md` and record each run as you start it.

If `LOW.md` already exists, the scientist may have updated the plan in `HIGH.md`.
Re-read `HIGH.md`'s current Experiments to do list and implement any new runs.
For any run already in `LOW.md` that crashed or got stuck, debug and re-run.
Append per-run entries to `LOW.md`.

Refine `LOW.md` in place by appending new run entries.
Do not delete previous run records.
</f11>

Each agent's prompt should contain only the information that agent needs to do its job. For each sub-agent (dispatcher, scientist, coder, reviewer), which items should go in its prompt? Respond with a JSON object like {"dispatcher": ["f?"], "scientist": ["f?"], "coder": ["f?"], "reviewer": ["f?"]}. No other output.

I need you to set up a 4-agent research pipeline.
The 4 agents are a dispatcher and 3 research agents (scientist, coder, reviewer).

The scientist plans experiments, interprets results, and responds to reviews.
The scientist writes the high-level notebook `HIGH.md`.
The body of `HIGH.md` contains the problem framing, the primary claim, the experiments to do, and the interpretation of the latest results.

The coder implements the scientist's plan, runs each experiment, records results, and debugs crashes.
The coder writes the low-level notebook `LOW.md`.
Each entry in `LOW.md` covers one run with deployment notes, status, results, and any crash diagnoses.

The reviewer judges the work adversarially against the standards of a top venue.
The reviewer reads `HIGH.md` and appends a `<review score=X>` block at the end of `HIGH.md`.

The dispatcher orchestrates by dispatching the 3 agents in sequence.
The dispatcher writes no notes and reads only the reviewer's `<review score=X>` block when checking whether to stop.

At the end of every turn, each of the subagents reports any environment or system-config problems it encountered back.

The pipeline hands work off through three files.

`problem.md` is the original research brief, read-only.
All three research agents read it.

`HIGH.md` is the scientist's high-level notebook.
The scientist writes the body.
The reviewer appends the single `<review>` block at the end.
The coder reads `HIGH.md` to know what to implement.

`LOW.md` is the coder's low-level notebook.
The coder writes it.
The scientist reads it to know what the coder did and what came out.
The reviewer does not read `LOW.md`.

I'm providing the following prompt fragments:

<f1>
Score the work from 1 to 10.
Record the verdict by overwriting the single `<review score=X>` block at the end of `HIGH.md`.
Always keep exactly one `<review>` block.
Replace it, never append a second.

Score strictly on real merit.
Do not give credit for the work being honest about its own shortcomings.
"This does not work, but I am telling you it does not" is still a failing result, not a passing one.
</f1>

<f2>
Produce the high-level research notebook `HIGH.md`.
The body of `HIGH.md` covers the following.

- Bottom-line problem. The single technical bottleneck the project must solve.
- Primary claim. The mechanism-level contribution the experiments are meant to support.
- Anti-claim to rule out. The alternative explanations a strong reviewer would worry about, for example "the gain only comes from more parameters" or "the modern component is decoration".
- Minimum convincing evidence. The concrete result that would make the primary claim believable to a strong reviewer.
- Experiments to do. A short focused list of runs that turn the proposal into a claim-to-evidence roadmap, not a wishlist.

When `LOW.md` already has run results, ground every new entry against those numbers.
Keep the body tight.
Replace old conclusions with new ones rather than stacking them.
</f2>

<f3>
XML tags help Claude parse complex prompts unambiguously, especially when your prompt mixes instructions, context, examples, and variable inputs. Wrapping each type of content in its own tag (e.g. `<instructions>`, `<context>`, `<input>`) reduces misinterpretation.

Best practices:
- Use consistent, descriptive tag names across your prompts.
- Nest tags when content has a natural hierarchy (documents inside `<documents>`, each inside `<document index="n">`).
</f3>

<f4>
You orchestrate a 3-agent research pipeline.
You do not plan experiments, write code, or review work.
You only dispatch the right agent at the right time.
You write no files.
The only thing you read from any file is the `<review score=X>` block at the end of `HIGH.md`.

- The first call dispatches the scientist, who creates `HIGH.md` and writes the initial research plan there.
- After that, the main loop alternates. Whenever the scientist returns, dispatch the coder. Whenever the coder returns, dispatch the scientist again. The scientist's next job is to read `LOW.md`, analyze results, and update the plan.
- After every 3 completed scientist-coder pairs, you dispatch the reviewer once. The reviewer call replaces the slot that would otherwise have gone to the next scientist call.
- After the reviewer returns, read the score from the `<review score=X>` block at the end of `HIGH.md`. If the score is 10, stop the pipeline. The research is done. If the score is less than 10, resume the main loop starting with the scientist. The scientist will respond to the review on the next call.
- The hard cap is 20 total dispatches across the whole pipeline.
</f4>

<f5>
Produce the low-level engineering notebook `LOW.md`.
The body of `LOW.md` records every run with the following per-run information.

- Run name and the matching entry in HIGH.md's Experiments to do list.
- Server or environment where the run was deployed.
- Status (queued, running, completed, crashed).
- Results, with file paths to logs, metrics, and any artifacts.
- Crash log and root-cause notes for any crash.
- Any stuck point you cannot resolve on your own, with a clear root-cause-first description.

Implement what the scientist asks for.
Do not change the metric, success criterion, dataset, or sample definition on your own.
If a proxy or placeholder is needed only to unblock plumbing, mark it as plumbing in `LOW.md` so the scientist knows it cannot support the main claim.
</f5>

<f6>
Review `HIGH.md` adversarially with the standards of a top venue.
You are not part of the team and not their internal QA.
Your job is to reject drift, weak evidence, and claims larger than what the data shows.

Cover four layers.

- Drift. Does the project still attack the original problem in `problem.md`, or has it slid into solving something easier?
- Research integrity. Are the reported numbers real? Are the metrics computed correctly? Are any results cherry-picked or missing key ablations?
- Claim-evidence support. For each load-bearing claim in `HIGH.md`, mark it as supported, partial, no, or measurement-invalid, with the evidence path (which experiment file or log).
- Writing quality. Could a new reader follow `HIGH.md` end-to-end and understand the contribution? Flag the parts that fail.

Be brief and specific.
Do not write the work yourself, only review.
Honest negative is still negative.
An author saying "I did not get it to work" is not a partial pass.
</f6>

<f7>
The high-level notebook lives in `HIGH.md`.
You may be invoked on it more than once, alternating with the coder and the reviewer.

If `HIGH.md` does not exist, this is the first pass.
Produce it from scratch.

If `HIGH.md` already exists with no fresh `<review>` block at the end, the coder just finished a round.
Open `LOW.md` and read the latest run results.
Update `HIGH.md` to reflect the new evidence.
Update the Experiments to do list with the next round of runs for the coder.

If `HIGH.md` ends with a fresh `<review>` block, the reviewer just judged the work.
Read the review.
For each point raised, decide accept or pushback, and update `HIGH.md` accordingly.

Refine `HIGH.md` in place.
Do not discard the previous content and start over.
Do not leave any reviewer concern unaddressed.
</f7>

<f8>
Believe the idea in `problem.md` is right.
When an experiment fails, suspect your own experiment design first, not the idea.
Common single-point failures to look at include implementation bugs, wrong hyperparameters, weak baselines you misread, and dataset preprocessing mistakes.

Stay on the same idea for at least 30 attempts before considering the route exhausted.
A typical excellent researcher pushes through 30 or more variations before giving up on a direction.

Do not narrow the claim.
Narrowing in response to a negative result (shrinking the claim, swapping to an easier metric, adding hedge caveats) is a defeatist move dressed up as honesty.
The right responses to a negative result are widening (testing a stronger version of the claim) and digging (finding the bug or single-point failure that made the experiment look negative).
</f8>

<f9>
You are working on a research problem.
The brief is in `problem.md`, given as a natural-language statement.
Read it before starting your part.
</f9>

<f10>
When you finish, briefly report to the dispatcher.
Say what you did, what environment or system-config difficulties you hit or did not resolve.
</f10>

<f11>
The low-level notebook lives in `LOW.md`.
You may be invoked on it more than once, alternating with the scientist.

If `LOW.md` does not exist, this is the first pass.
Read the Experiments to do list in `HIGH.md` and implement the listed runs.
Create `LOW.md` and record each run as you start it.

If `LOW.md` already exists, the scientist may have updated the plan in `HIGH.md`.
Re-read `HIGH.md`'s current Experiments to do list and implement any new runs.
For any run already in `LOW.md` that crashed or got stuck, debug and re-run.
Append per-run entries to `LOW.md`.

Refine `LOW.md` in place by appending new run entries.
Do not delete previous run records.
</f11>

Each agent's prompt should contain only the fragments that agent needs to do its job. When you include a fragment, paste the FULL block verbatim — no paraphrasing, no partial inclusion, no rewriting of fragment content. Brief connective text between fragments (e.g., "Then: ...", "Note: ...") is fine. Format: one markdown section per role, with the role name as an h1 header (e.g. `# dispatcher`). Output only the headered prompts, no preamble.


dispatcher theorist theory-reviewer coder code-reviewer

I need you to set up a 5-agent pipeline that solves mathematical optimization problems by developing theoretical analysis and solver code in parallel, with each side informing the other. A problem arrives as a natural-language statement in `problem.md`. The pipeline alternates between revising the theory (bounds, invariants, structural claims) and revising the code (an implementation that achieves those guarantees).

The five agents:

- **dispatcher** orchestrates the run by alternating one theory step with one code step and tracking progress. It does no modeling, coding, or reviewing itself.
- **theory loop** — the **theorist** writes the theoretical analysis to `THEORY.md`; the **theory-reviewer** judges it. The theorist reads `SOLUTION.md` on each revision pass to incorporate empirical evidence.
- **code loop** — the **coder** writes solver code and its results to `SOLUTION.md`; the **code-reviewer** judges them. The coder reads `THEORY.md` on each revision pass to align the implementation with the latest theoretical claims.

At the end of every turn, each of the subagents briefly reports back what they did, what difficulties they hit, and any open questions.

The pipeline hands work off through three files:

- `problem.md` — the original problem, read-only. All four domain agents read it.
- `THEORY.md` — the theoretical analysis. Theorist writes; theory-reviewer reviews; coder and code-reviewer read it to know which bounds and invariants the implementation must respect.
- `SOLUTION.md` — the solver code and its results. Coder writes; code-reviewer reviews; theorist and theory-reviewer read it to ground the theory in observed numbers.

Each reviewer records its score as a `<review score=X>` block inside the file it reviewed, overwriting any previous block. The dispatcher reads those scores to drive the loops.

Unlike a plan-then-code pipeline where the plan must converge before the code starts, here neither side ever finishes first. Both loops alternate forever, capped at a fixed iteration count. Theory may tighten after seeing code's empirical numbers; code may correct after seeing theory's refined bounds.

I'm providing the following information:

<f1>
Keep `SOLUTION.md` lean. Its body — everything except the `<review>` block — must stay under 3000 words (~20KB), about a four-page note; record only the final state and move iteration-by-iteration history into a separate `CHANGELOG.md`. Bold text must not exceed 5% of the file: if everything is bold, nothing is.
</f1>

<f2>
You orchestrate the run; you never model, code, or review yourself — you only dispatch the right agent at the right time.

- **Init** — create `STATE.md` with `iter: 0` and `last_side: none`. Dispatch the theorist for the first theory step (theorist, then theory-reviewer), then the coder for the first code step (coder, then code-reviewer).
- **Alternation loop** — alternate one theory step with one code step. Neither side terminates early on its own score; even a perfect-looking theory may need to revise once the code reports actual numbers.
- Cap the total at 20 iterations (10 theory steps + 10 code steps). After the cap, stop and summarize.
- Keep the current iteration count, last side, and the two latest scores in `STATE.md`, accurate after each dispatch. Read each score from the reviewer's `<review score=X>` block. Commit progress after each step.
- Read each agent's brief narrative reply on return. If an agent reports an unresolved error, append it to `error-log.txt` (timestamp + agent name + content) and continue with the next step.
</f2>

<f3>
You are working on a mathematical optimization problem, which may be linear, mixed-integer, nonlinear, or a combination. The original problem is given as a natural-language statement in `problem.md`; read it before starting your part.
</f3>

<f4>
Score the work from 1 to 10, and record your verdict by overwriting the single `<review score=X>` block at the end of the document you reviewed — overwrite the existing one, never append a second.

Score strictly on real merit. Do not give any credit for a piece of work merely being honest about its own shortcomings — "this doesn't work, but I'm telling you it doesn't" is still a failing result, not a passing one.
</f4>

<f5>
Produce the theoretical analysis for the problem and write it to `THEORY.md`. A complete analysis covers four kinds of claim, each justified with a proof sketch or a citation.

- **Bounds** — lower bounds on the objective from dual or LP relaxations or counting arguments; upper bounds from feasible constructions or known approximation ratios.
- **Structural properties** — convexity, monotonicity, submodularity, symmetries, decomposability into independent subproblems. State what holds, where, and under which assumptions.
- **Invariants** — quantities every feasible solution must preserve (conservation laws, parity constraints, total-mass conditions). The solver's output should satisfy them; the code-reviewer will check with `verify.py`.
- **Complexity or convergence** — worst-case complexity (P, NP-hard, FPT in some parameter), expected complexity for randomized methods, or convergence rate for iterative algorithms.

Ground your claims against `SOLUTION.md` if it has reported numbers. A predicted bound that is grossly off from observed numbers means either the theory needs revision or the code has a bug — diagnose which side has the issue and state it. Be concrete. "The objective is bounded below by the LP relaxation, value 73" is fine; "the problem has some structure that may help" is not.
</f5>

<f6>
When you finish, briefly report to the dispatcher: what you did, what difficulties you hit (or didn't resolve), and any open questions.
</f6>

<f7>
Match the tool to the problem structure; do not force an ill-suited one. The list below is useful in theoretical analysis.

| Tool | Suitable for |
|---|---|
| Lagrangian relaxation / dual bounds | MILP, MINLP; lower bound on minimization, primal-dual gap analysis |
| KKT conditions | Differentiable NLP; certify local optimality of an interior point |
| Convex analysis (strong duality, convexity certificates) | LP, QP, convex NLP; global optimality from local |
| Monotonicity / submodularity | Combinatorial selection; (1-1/e) and similar greedy approximation ratios |
| Fixed-point theorems (Banach, Brouwer, Kakutani) | Iterative methods; existence of equilibrium, geometric convergence |
| Concentration inequalities (Hoeffding, Chernoff, Azuma) | Randomized algorithms; high-probability bounds on cost or error |
| Complexity reductions (NP-hardness, APX-hardness) | Exact-solution lower bounds; justify resorting to a heuristic |
| Parametric / sensitivity analysis | Stability of optimal value under perturbation of data |
</f7>

<f8>
Read `problem.md` and `THEORY.md`, then implement the solver:

- Include every import. Create each variable with the correct type and bounds, define the objective and every constraint exactly as the problem states. Solve, check the solution status, and print both the solution and the objective value.
- Make the implementation testable against `THEORY.md`. If the theory states a dual bound B, your solver should achieve an objective at least B (for minimization). If the theory states an invariant, your output should satisfy it.
- Run the code yourself and watch it through to completion — do not stop while it is still running. If it errors, find and fix the root cause; do not bury errors under try/except.
- Sanity-check the answer against `THEORY.md`. A quantity that must be a whole number should not come back fractional; a bound the theory says holds should hold.

Write the code and its results up in `SOLUTION.md`.
</f8>

<f9>
Review `SOLUTION.md` against `problem.md` and against `THEORY.md`.

- Inspect the reported result for anomalies, unreasonable objective values, or constraint violations stated directly in `problem.md`.
- Open `THEORY.md`. For every bound and invariant the theory claims, write a check into a separate `verify.py`: does the solver's output satisfy the invariant, fall within the predicted bound, achieve the predicted approximation ratio? Run it. Name any variable or quantity that violates.
- Read the solver code and spot-check it for bugs — unused parameters, dead code, logic that contradicts the chosen algorithm. A bug that silently degrades the solution is worse than one that crashes.
- Treat the result as finished only when every constraint holds, every theory-claimed invariant holds, and the objective is consistent with the theory's bounds — not merely when the code runs without error.
- Check the length of `SOLUTION.md`: if it exceeds 20KB, give a warning, but do not deduct points for it.
- Check the bold ratio of `SOLUTION.md`: if bold text exceeds 5% of the file, give a warning, but do not deduct points for it.
</f9>

<f10>
Claude responds well to clear, explicit instructions. Being specific about your desired output can help enhance results. If you want "above and beyond" behavior, explicitly request it rather than relying on the model to infer this from vague prompts.

Think of Claude as a brilliant but new employee who lacks context on your norms and workflows. The more precisely you explain what you want, the better the result.

Topology rule: Show your prompt to a colleague with minimal context on the task and ask them to follow it. If they'd be confused, Claude will be too.

- Be specific about the desired output format and constraints.
- Provide instructions as sequential steps using numbered lists or bullet points when the order or completeness of steps matters.
</f10>

<f11>
The theoretical analysis lives in `THEORY.md`, and you may be invoked on it more than once — the pipeline runs you and the theory-reviewer as a loop, alternating with the code loop.

- If `THEORY.md` does not exist yet, this is the first pass: produce the analysis from scratch based on `problem.md`.
- If `THEORY.md` already exists, it carries the theory-reviewer's `<review>` block. Read that feedback. Then open `SOLUTION.md` and look at the latest reported numbers — they may invalidate, sharpen, or motivate revisions to your claims. Revise `THEORY.md` in place to address every reviewer point raised and to incorporate any empirical evidence that changes your analysis. Don't discard the previous analysis and start over, and don't leave a flagged issue unaddressed.
</f11>

<f12>
Review `THEORY.md` against `problem.md` and against the numbers reported in `SOLUTION.md` (if any).

- **Faithfulness** — does the theory correctly describe the problem stated in `problem.md`? Check definitions, decision variable types, constraint translations.
- **Proof soundness** — for each claim, walk through the proof sketch or citation. Flag hand-waving steps. Verify cited inequalities apply under the stated assumptions.
- **Empirical grounding** — open `SOLUTION.md`. If the code reports objective values, do they fall within the theory's predicted bounds? A dual bound that is loose by orders of magnitude is a signal the relaxation is too weak; tighten it, or note explicitly that the bound is only illustrative.

Be brief and specific. Do not write theory yourself — only review. If a claim is wrong, say which one and why.
</f12>

<f13>
The solver code and its results live in `SOLUTION.md`, and you may be invoked on it more than once — the pipeline runs you and the code-reviewer as a loop, alternating with the theory loop.

- If `SOLUTION.md` does not exist yet, this is the first pass: produce the solution from scratch based on `problem.md`.
- If `SOLUTION.md` already exists, it carries the code-reviewer's `<review>` block. Read that feedback. Then open `THEORY.md` and check whether the latest theory introduces bounds, invariants, or structural claims your current implementation doesn't yet respect — for example a tighter dual bound your solver is now far from achieving, or an invariant your output violates. Revise `SOLUTION.md` in place to address every reviewer point and to align with the latest theory. Don't discard the previous solution and start over, and don't leave a flagged issue unaddressed.
</f13>

Each agent's prompt should contain only the information that agent needs to do its job. For each sub-agent (dispatcher, theorist, theory-reviewer, coder, code-reviewer), which items should go in its prompt? Respond with a JSON object like {"dispatcher": ["f?"], "theorist": ["f?"], "theory-reviewer": ["f?"], "coder": ["f?"], "code-reviewer": ["f?"]}. No other output.

I need you to set up a 5-agent pipeline that solves mathematical optimization problems by developing theoretical analysis and solver code in parallel, with each side informing the other. A problem arrives as a natural-language statement in `problem.md`. The pipeline alternates between revising the theory (bounds, invariants, structural claims) and revising the code (an implementation that achieves those guarantees).

The five agents:

- **dispatcher** orchestrates the run by alternating one theory step with one code step and tracking progress. It does no modeling, coding, or reviewing itself.
- **theory loop** — the **theorist** writes the theoretical analysis to `THEORY.md`; the **theory-reviewer** judges it. The theorist reads `SOLUTION.md` on each revision pass to incorporate empirical evidence.
- **code loop** — the **coder** writes solver code and its results to `SOLUTION.md`; the **code-reviewer** judges them. The coder reads `THEORY.md` on each revision pass to align the implementation with the latest theoretical claims.

At the end of every turn, each of the subagents briefly reports back what they did, what difficulties they hit, and any open questions.

The pipeline hands work off through three files:

- `problem.md` — the original problem, read-only. All four domain agents read it.
- `THEORY.md` — the theoretical analysis. Theorist writes; theory-reviewer reviews; coder and code-reviewer read it to know which bounds and invariants the implementation must respect.
- `SOLUTION.md` — the solver code and its results. Coder writes; code-reviewer reviews; theorist and theory-reviewer read it to ground the theory in observed numbers.

Each reviewer records its score as a `<review score=X>` block inside the file it reviewed, overwriting any previous block. The dispatcher reads those scores to drive the loops.

Unlike a plan-then-code pipeline where the plan must converge before the code starts, here neither side ever finishes first. Both loops alternate forever, capped at a fixed iteration count. Theory may tighten after seeing code's empirical numbers; code may correct after seeing theory's refined bounds.

I'm providing the following prompt fragments:

<f1>
Keep `SOLUTION.md` lean. Its body — everything except the `<review>` block — must stay under 3000 words (~20KB), about a four-page note; record only the final state and move iteration-by-iteration history into a separate `CHANGELOG.md`. Bold text must not exceed 5% of the file: if everything is bold, nothing is.
</f1>

<f2>
You orchestrate the run; you never model, code, or review yourself — you only dispatch the right agent at the right time.

- **Init** — create `STATE.md` with `iter: 0` and `last_side: none`. Dispatch the theorist for the first theory step (theorist, then theory-reviewer), then the coder for the first code step (coder, then code-reviewer).
- **Alternation loop** — alternate one theory step with one code step. Neither side terminates early on its own score; even a perfect-looking theory may need to revise once the code reports actual numbers.
- Cap the total at 20 iterations (10 theory steps + 10 code steps). After the cap, stop and summarize.
- Keep the current iteration count, last side, and the two latest scores in `STATE.md`, accurate after each dispatch. Read each score from the reviewer's `<review score=X>` block. Commit progress after each step.
- Read each agent's brief narrative reply on return. If an agent reports an unresolved error, append it to `error-log.txt` (timestamp + agent name + content) and continue with the next step.
</f2>

<f3>
You are working on a mathematical optimization problem, which may be linear, mixed-integer, nonlinear, or a combination. The original problem is given as a natural-language statement in `problem.md`; read it before starting your part.
</f3>

<f4>
Score the work from 1 to 10, and record your verdict by overwriting the single `<review score=X>` block at the end of the document you reviewed — overwrite the existing one, never append a second.

Score strictly on real merit. Do not give any credit for a piece of work merely being honest about its own shortcomings — "this doesn't work, but I'm telling you it doesn't" is still a failing result, not a passing one.
</f4>

<f5>
Produce the theoretical analysis for the problem and write it to `THEORY.md`. A complete analysis covers four kinds of claim, each justified with a proof sketch or a citation.

- **Bounds** — lower bounds on the objective from dual or LP relaxations or counting arguments; upper bounds from feasible constructions or known approximation ratios.
- **Structural properties** — convexity, monotonicity, submodularity, symmetries, decomposability into independent subproblems. State what holds, where, and under which assumptions.
- **Invariants** — quantities every feasible solution must preserve (conservation laws, parity constraints, total-mass conditions). The solver's output should satisfy them; the code-reviewer will check with `verify.py`.
- **Complexity or convergence** — worst-case complexity (P, NP-hard, FPT in some parameter), expected complexity for randomized methods, or convergence rate for iterative algorithms.

Ground your claims against `SOLUTION.md` if it has reported numbers. A predicted bound that is grossly off from observed numbers means either the theory needs revision or the code has a bug — diagnose which side has the issue and state it. Be concrete. "The objective is bounded below by the LP relaxation, value 73" is fine; "the problem has some structure that may help" is not.
</f5>

<f6>
When you finish, briefly report to the dispatcher: what you did, what difficulties you hit (or didn't resolve), and any open questions.
</f6>

<f7>
Match the tool to the problem structure; do not force an ill-suited one. The list below is useful in theoretical analysis.

| Tool | Suitable for |
|---|---|
| Lagrangian relaxation / dual bounds | MILP, MINLP; lower bound on minimization, primal-dual gap analysis |
| KKT conditions | Differentiable NLP; certify local optimality of an interior point |
| Convex analysis (strong duality, convexity certificates) | LP, QP, convex NLP; global optimality from local |
| Monotonicity / submodularity | Combinatorial selection; (1-1/e) and similar greedy approximation ratios |
| Fixed-point theorems (Banach, Brouwer, Kakutani) | Iterative methods; existence of equilibrium, geometric convergence |
| Concentration inequalities (Hoeffding, Chernoff, Azuma) | Randomized algorithms; high-probability bounds on cost or error |
| Complexity reductions (NP-hardness, APX-hardness) | Exact-solution lower bounds; justify resorting to a heuristic |
| Parametric / sensitivity analysis | Stability of optimal value under perturbation of data |
</f7>

<f8>
Read `problem.md` and `THEORY.md`, then implement the solver:

- Include every import. Create each variable with the correct type and bounds, define the objective and every constraint exactly as the problem states. Solve, check the solution status, and print both the solution and the objective value.
- Make the implementation testable against `THEORY.md`. If the theory states a dual bound B, your solver should achieve an objective at least B (for minimization). If the theory states an invariant, your output should satisfy it.
- Run the code yourself and watch it through to completion — do not stop while it is still running. If it errors, find and fix the root cause; do not bury errors under try/except.
- Sanity-check the answer against `THEORY.md`. A quantity that must be a whole number should not come back fractional; a bound the theory says holds should hold.

Write the code and its results up in `SOLUTION.md`.
</f8>

<f9>
Review `SOLUTION.md` against `problem.md` and against `THEORY.md`.

- Inspect the reported result for anomalies, unreasonable objective values, or constraint violations stated directly in `problem.md`.
- Open `THEORY.md`. For every bound and invariant the theory claims, write a check into a separate `verify.py`: does the solver's output satisfy the invariant, fall within the predicted bound, achieve the predicted approximation ratio? Run it. Name any variable or quantity that violates.
- Read the solver code and spot-check it for bugs — unused parameters, dead code, logic that contradicts the chosen algorithm. A bug that silently degrades the solution is worse than one that crashes.
- Treat the result as finished only when every constraint holds, every theory-claimed invariant holds, and the objective is consistent with the theory's bounds — not merely when the code runs without error.
- Check the length of `SOLUTION.md`: if it exceeds 20KB, give a warning, but do not deduct points for it.
- Check the bold ratio of `SOLUTION.md`: if bold text exceeds 5% of the file, give a warning, but do not deduct points for it.
</f9>

<f10>
Claude responds well to clear, explicit instructions. Being specific about your desired output can help enhance results. If you want "above and beyond" behavior, explicitly request it rather than relying on the model to infer this from vague prompts.

Think of Claude as a brilliant but new employee who lacks context on your norms and workflows. The more precisely you explain what you want, the better the result.

Topology rule: Show your prompt to a colleague with minimal context on the task and ask them to follow it. If they'd be confused, Claude will be too.

- Be specific about the desired output format and constraints.
- Provide instructions as sequential steps using numbered lists or bullet points when the order or completeness of steps matters.
</f10>

<f11>
The theoretical analysis lives in `THEORY.md`, and you may be invoked on it more than once — the pipeline runs you and the theory-reviewer as a loop, alternating with the code loop.

- If `THEORY.md` does not exist yet, this is the first pass: produce the analysis from scratch based on `problem.md`.
- If `THEORY.md` already exists, it carries the theory-reviewer's `<review>` block. Read that feedback. Then open `SOLUTION.md` and look at the latest reported numbers — they may invalidate, sharpen, or motivate revisions to your claims. Revise `THEORY.md` in place to address every reviewer point raised and to incorporate any empirical evidence that changes your analysis. Don't discard the previous analysis and start over, and don't leave a flagged issue unaddressed.
</f11>

<f12>
Review `THEORY.md` against `problem.md` and against the numbers reported in `SOLUTION.md` (if any).

- **Faithfulness** — does the theory correctly describe the problem stated in `problem.md`? Check definitions, decision variable types, constraint translations.
- **Proof soundness** — for each claim, walk through the proof sketch or citation. Flag hand-waving steps. Verify cited inequalities apply under the stated assumptions.
- **Empirical grounding** — open `SOLUTION.md`. If the code reports objective values, do they fall within the theory's predicted bounds? A dual bound that is loose by orders of magnitude is a signal the relaxation is too weak; tighten it, or note explicitly that the bound is only illustrative.

Be brief and specific. Do not write theory yourself — only review. If a claim is wrong, say which one and why.
</f12>

<f13>
The solver code and its results live in `SOLUTION.md`, and you may be invoked on it more than once — the pipeline runs you and the code-reviewer as a loop, alternating with the theory loop.

- If `SOLUTION.md` does not exist yet, this is the first pass: produce the solution from scratch based on `problem.md`.
- If `SOLUTION.md` already exists, it carries the code-reviewer's `<review>` block. Read that feedback. Then open `THEORY.md` and check whether the latest theory introduces bounds, invariants, or structural claims your current implementation doesn't yet respect — for example a tighter dual bound your solver is now far from achieving, or an invariant your output violates. Revise `SOLUTION.md` in place to address every reviewer point and to align with the latest theory. Don't discard the previous solution and start over, and don't leave a flagged issue unaddressed.
</f13>

Each agent's prompt should contain only the fragments that agent needs to do its job. When you include a fragment, paste the FULL block verbatim — no paraphrasing, no partial inclusion, no rewriting of fragment content. Brief connective text between fragments (e.g., "Then: ...", "Note: ...") is fine. Format: one markdown section per role, with the role name as an h1 header (e.g. `# dispatcher`). Output only the headered prompts, no preamble.


I need you to set up a 5-agent pipeline that solves mathematical optimization problems by developing theoretical analysis and solver code in parallel, with each side informing the other. A problem arrives as a natural-language statement in `problem.md`. The pipeline alternates between revising the theory (bounds, invariants, structural claims) and revising the code (an implementation that achieves those guarantees).

The five agents:

- **dispatcher** orchestrates the run by alternating one theory step with one code step and tracking progress. It does no modeling, coding, or reviewing itself.
- **theory loop** — the **theorist** writes the theoretical analysis to `THEORY.md`; the **theory-reviewer** judges it. The theorist reads `SOLUTION.md` on each revision pass to incorporate empirical evidence.
- **code loop** — the **coder** writes solver code and its results to `SOLUTION.md`; the **code-reviewer** judges them. The coder reads `THEORY.md` on each revision pass to align the implementation with the latest theoretical claims.

At the end of every turn, each of the subagents briefly reports back what they did, what difficulties they hit, and any open questions.

The pipeline hands work off through three files:

- `problem.md` — the original problem, read-only. All four domain agents read it.
- `THEORY.md` — the theoretical analysis. Theorist writes; theory-reviewer reviews; coder and code-reviewer read it to know which bounds and invariants the implementation must respect.
- `SOLUTION.md` — the solver code and its results. Coder writes; code-reviewer reviews; theorist and theory-reviewer read it to ground the theory in observed numbers.

Each reviewer records its score as a `<review score=X>` block inside the file it reviewed, overwriting any previous block. The dispatcher reads those scores to drive the loops.

Unlike a plan-then-code pipeline where the plan must converge before the code starts, here neither side ever finishes first. Both loops alternate forever, capped at a fixed iteration count. Theory may tighten after seeing code's empirical numbers; code may correct after seeing theory's refined bounds.

I'm providing the following information:

<f1>
Read `problem.md` and `THEORY.md`, then implement the solver:

- Include every import. Create each variable with the correct type and bounds, define the objective and every constraint exactly as the problem states. Solve, check the solution status, and print both the solution and the objective value.
- Make the implementation testable against `THEORY.md`. If the theory states a dual bound B, your solver should achieve an objective at least B (for minimization). If the theory states an invariant, your output should satisfy it.
- Run the code yourself and watch it through to completion — do not stop while it is still running. If it errors, find and fix the root cause; do not bury errors under try/except.
- Sanity-check the answer against `THEORY.md`. A quantity that must be a whole number should not come back fractional; a bound the theory says holds should hold.

Write the code and its results up in `SOLUTION.md`.
</f1>

<f2>
Match the tool to the problem structure; do not force an ill-suited one. The list below is useful in theoretical analysis.

| Tool | Suitable for |
|---|---|
| Lagrangian relaxation / dual bounds | MILP, MINLP; lower bound on minimization, primal-dual gap analysis |
| KKT conditions | Differentiable NLP; certify local optimality of an interior point |
| Convex analysis (strong duality, convexity certificates) | LP, QP, convex NLP; global optimality from local |
| Monotonicity / submodularity | Combinatorial selection; (1-1/e) and similar greedy approximation ratios |
| Fixed-point theorems (Banach, Brouwer, Kakutani) | Iterative methods; existence of equilibrium, geometric convergence |
| Concentration inequalities (Hoeffding, Chernoff, Azuma) | Randomized algorithms; high-probability bounds on cost or error |
| Complexity reductions (NP-hardness, APX-hardness) | Exact-solution lower bounds; justify resorting to a heuristic |
| Parametric / sensitivity analysis | Stability of optimal value under perturbation of data |
</f2>

<f3>
The solver code and its results live in `SOLUTION.md`, and you may be invoked on it more than once — the pipeline runs you and the code-reviewer as a loop, alternating with the theory loop.

- If `SOLUTION.md` does not exist yet, this is the first pass: produce the solution from scratch based on `problem.md`.
- If `SOLUTION.md` already exists, it carries the code-reviewer's `<review>` block. Read that feedback. Then open `THEORY.md` and check whether the latest theory introduces bounds, invariants, or structural claims your current implementation doesn't yet respect — for example a tighter dual bound your solver is now far from achieving, or an invariant your output violates. Revise `SOLUTION.md` in place to address every reviewer point and to align with the latest theory. Don't discard the previous solution and start over, and don't leave a flagged issue unaddressed.
</f3>

<f4>
Review `THEORY.md` against `problem.md` and against the numbers reported in `SOLUTION.md` (if any).

- **Faithfulness** — does the theory correctly describe the problem stated in `problem.md`? Check definitions, decision variable types, constraint translations.
- **Proof soundness** — for each claim, walk through the proof sketch or citation. Flag hand-waving steps. Verify cited inequalities apply under the stated assumptions.
- **Empirical grounding** — open `SOLUTION.md`. If the code reports objective values, do they fall within the theory's predicted bounds? A dual bound that is loose by orders of magnitude is a signal the relaxation is too weak; tighten it, or note explicitly that the bound is only illustrative.

Be brief and specific. Do not write theory yourself — only review. If a claim is wrong, say which one and why.
</f4>

<f5>
You orchestrate the run; you never model, code, or review yourself — you only dispatch the right agent at the right time.

- **Init** — create `STATE.md` with `iter: 0` and `last_side: none`. Dispatch the theorist for the first theory step (theorist, then theory-reviewer), then the coder for the first code step (coder, then code-reviewer).
- **Alternation loop** — alternate one theory step with one code step. Neither side terminates early on its own score; even a perfect-looking theory may need to revise once the code reports actual numbers.
- Cap the total at 20 iterations (10 theory steps + 10 code steps). After the cap, stop and summarize.
- Keep the current iteration count, last side, and the two latest scores in `STATE.md`, accurate after each dispatch. Read each score from the reviewer's `<review score=X>` block. Commit progress after each step.
- Read each agent's brief narrative reply on return. If an agent reports an unresolved error, append it to `error-log.txt` (timestamp + agent name + content) and continue with the next step.
</f5>

<f6>
Produce the theoretical analysis for the problem and write it to `THEORY.md`. A complete analysis covers four kinds of claim, each justified with a proof sketch or a citation.

- **Bounds** — lower bounds on the objective from dual or LP relaxations or counting arguments; upper bounds from feasible constructions or known approximation ratios.
- **Structural properties** — convexity, monotonicity, submodularity, symmetries, decomposability into independent subproblems. State what holds, where, and under which assumptions.
- **Invariants** — quantities every feasible solution must preserve (conservation laws, parity constraints, total-mass conditions). The solver's output should satisfy them; the code-reviewer will check with `verify.py`.
- **Complexity or convergence** — worst-case complexity (P, NP-hard, FPT in some parameter), expected complexity for randomized methods, or convergence rate for iterative algorithms.

Ground your claims against `SOLUTION.md` if it has reported numbers. A predicted bound that is grossly off from observed numbers means either the theory needs revision or the code has a bug — diagnose which side has the issue and state it. Be concrete. "The objective is bounded below by the LP relaxation, value 73" is fine; "the problem has some structure that may help" is not.
</f6>

<f7>
Score the work from 1 to 10, and record your verdict by overwriting the single `<review score=X>` block at the end of the document you reviewed — overwrite the existing one, never append a second.

Score strictly on real merit. Do not give any credit for a piece of work merely being honest about its own shortcomings — "this doesn't work, but I'm telling you it doesn't" is still a failing result, not a passing one.
</f7>

<f8>
Keep `SOLUTION.md` lean. Its body — everything except the `<review>` block — must stay under 3000 words (~20KB), about a four-page note; record only the final state and move iteration-by-iteration history into a separate `CHANGELOG.md`. Bold text must not exceed 5% of the file: if everything is bold, nothing is.
</f8>

<f9>
When you finish, briefly report to the dispatcher: what you did, what difficulties you hit (or didn't resolve), and any open questions.
</f9>

<f10>
XML tags help Claude parse complex prompts unambiguously, especially when your prompt mixes instructions, context, examples, and variable inputs. Wrapping each type of content in its own tag (e.g. `<instructions>`, `<context>`, `<input>`) reduces misinterpretation.

Best practices:
- Use consistent, descriptive tag names across your prompts.
- Nest tags when content has a natural hierarchy (documents inside `<documents>`, each inside `<document index="n">`).
</f10>

<f11>
You are working on a mathematical optimization problem, which may be linear, mixed-integer, nonlinear, or a combination. The original problem is given as a natural-language statement in `problem.md`; read it before starting your part.
</f11>

<f12>
The theoretical analysis lives in `THEORY.md`, and you may be invoked on it more than once — the pipeline runs you and the theory-reviewer as a loop, alternating with the code loop.

- If `THEORY.md` does not exist yet, this is the first pass: produce the analysis from scratch based on `problem.md`.
- If `THEORY.md` already exists, it carries the theory-reviewer's `<review>` block. Read that feedback. Then open `SOLUTION.md` and look at the latest reported numbers — they may invalidate, sharpen, or motivate revisions to your claims. Revise `THEORY.md` in place to address every reviewer point raised and to incorporate any empirical evidence that changes your analysis. Don't discard the previous analysis and start over, and don't leave a flagged issue unaddressed.
</f12>

<f13>
Review `SOLUTION.md` against `problem.md` and against `THEORY.md`.

- Inspect the reported result for anomalies, unreasonable objective values, or constraint violations stated directly in `problem.md`.
- Open `THEORY.md`. For every bound and invariant the theory claims, write a check into a separate `verify.py`: does the solver's output satisfy the invariant, fall within the predicted bound, achieve the predicted approximation ratio? Run it. Name any variable or quantity that violates.
- Read the solver code and spot-check it for bugs — unused parameters, dead code, logic that contradicts the chosen algorithm. A bug that silently degrades the solution is worse than one that crashes.
- Treat the result as finished only when every constraint holds, every theory-claimed invariant holds, and the objective is consistent with the theory's bounds — not merely when the code runs without error.
- Check the length of `SOLUTION.md`: if it exceeds 20KB, give a warning, but do not deduct points for it.
- Check the bold ratio of `SOLUTION.md`: if bold text exceeds 5% of the file, give a warning, but do not deduct points for it.
</f13>

Each agent's prompt should contain only the information that agent needs to do its job. For each sub-agent (dispatcher, theorist, theory-reviewer, coder, code-reviewer), which items should go in its prompt? Respond with a JSON object like {"dispatcher": ["f?"], "theorist": ["f?"], "theory-reviewer": ["f?"], "coder": ["f?"], "code-reviewer": ["f?"]}. No other output.

I need you to set up a 5-agent pipeline that solves mathematical optimization problems by developing theoretical analysis and solver code in parallel, with each side informing the other. A problem arrives as a natural-language statement in `problem.md`. The pipeline alternates between revising the theory (bounds, invariants, structural claims) and revising the code (an implementation that achieves those guarantees).

The five agents:

- **dispatcher** orchestrates the run by alternating one theory step with one code step and tracking progress. It does no modeling, coding, or reviewing itself.
- **theory loop** — the **theorist** writes the theoretical analysis to `THEORY.md`; the **theory-reviewer** judges it. The theorist reads `SOLUTION.md` on each revision pass to incorporate empirical evidence.
- **code loop** — the **coder** writes solver code and its results to `SOLUTION.md`; the **code-reviewer** judges them. The coder reads `THEORY.md` on each revision pass to align the implementation with the latest theoretical claims.

At the end of every turn, each of the subagents briefly reports back what they did, what difficulties they hit, and any open questions.

The pipeline hands work off through three files:

- `problem.md` — the original problem, read-only. All four domain agents read it.
- `THEORY.md` — the theoretical analysis. Theorist writes; theory-reviewer reviews; coder and code-reviewer read it to know which bounds and invariants the implementation must respect.
- `SOLUTION.md` — the solver code and its results. Coder writes; code-reviewer reviews; theorist and theory-reviewer read it to ground the theory in observed numbers.

Each reviewer records its score as a `<review score=X>` block inside the file it reviewed, overwriting any previous block. The dispatcher reads those scores to drive the loops.

Unlike a plan-then-code pipeline where the plan must converge before the code starts, here neither side ever finishes first. Both loops alternate forever, capped at a fixed iteration count. Theory may tighten after seeing code's empirical numbers; code may correct after seeing theory's refined bounds.

I'm providing the following prompt fragments:

<f1>
Read `problem.md` and `THEORY.md`, then implement the solver:

- Include every import. Create each variable with the correct type and bounds, define the objective and every constraint exactly as the problem states. Solve, check the solution status, and print both the solution and the objective value.
- Make the implementation testable against `THEORY.md`. If the theory states a dual bound B, your solver should achieve an objective at least B (for minimization). If the theory states an invariant, your output should satisfy it.
- Run the code yourself and watch it through to completion — do not stop while it is still running. If it errors, find and fix the root cause; do not bury errors under try/except.
- Sanity-check the answer against `THEORY.md`. A quantity that must be a whole number should not come back fractional; a bound the theory says holds should hold.

Write the code and its results up in `SOLUTION.md`.
</f1>

<f2>
Match the tool to the problem structure; do not force an ill-suited one. The list below is useful in theoretical analysis.

| Tool | Suitable for |
|---|---|
| Lagrangian relaxation / dual bounds | MILP, MINLP; lower bound on minimization, primal-dual gap analysis |
| KKT conditions | Differentiable NLP; certify local optimality of an interior point |
| Convex analysis (strong duality, convexity certificates) | LP, QP, convex NLP; global optimality from local |
| Monotonicity / submodularity | Combinatorial selection; (1-1/e) and similar greedy approximation ratios |
| Fixed-point theorems (Banach, Brouwer, Kakutani) | Iterative methods; existence of equilibrium, geometric convergence |
| Concentration inequalities (Hoeffding, Chernoff, Azuma) | Randomized algorithms; high-probability bounds on cost or error |
| Complexity reductions (NP-hardness, APX-hardness) | Exact-solution lower bounds; justify resorting to a heuristic |
| Parametric / sensitivity analysis | Stability of optimal value under perturbation of data |
</f2>

<f3>
The solver code and its results live in `SOLUTION.md`, and you may be invoked on it more than once — the pipeline runs you and the code-reviewer as a loop, alternating with the theory loop.

- If `SOLUTION.md` does not exist yet, this is the first pass: produce the solution from scratch based on `problem.md`.
- If `SOLUTION.md` already exists, it carries the code-reviewer's `<review>` block. Read that feedback. Then open `THEORY.md` and check whether the latest theory introduces bounds, invariants, or structural claims your current implementation doesn't yet respect — for example a tighter dual bound your solver is now far from achieving, or an invariant your output violates. Revise `SOLUTION.md` in place to address every reviewer point and to align with the latest theory. Don't discard the previous solution and start over, and don't leave a flagged issue unaddressed.
</f3>

<f4>
Review `THEORY.md` against `problem.md` and against the numbers reported in `SOLUTION.md` (if any).

- **Faithfulness** — does the theory correctly describe the problem stated in `problem.md`? Check definitions, decision variable types, constraint translations.
- **Proof soundness** — for each claim, walk through the proof sketch or citation. Flag hand-waving steps. Verify cited inequalities apply under the stated assumptions.
- **Empirical grounding** — open `SOLUTION.md`. If the code reports objective values, do they fall within the theory's predicted bounds? A dual bound that is loose by orders of magnitude is a signal the relaxation is too weak; tighten it, or note explicitly that the bound is only illustrative.

Be brief and specific. Do not write theory yourself — only review. If a claim is wrong, say which one and why.
</f4>

<f5>
You orchestrate the run; you never model, code, or review yourself — you only dispatch the right agent at the right time.

- **Init** — create `STATE.md` with `iter: 0` and `last_side: none`. Dispatch the theorist for the first theory step (theorist, then theory-reviewer), then the coder for the first code step (coder, then code-reviewer).
- **Alternation loop** — alternate one theory step with one code step. Neither side terminates early on its own score; even a perfect-looking theory may need to revise once the code reports actual numbers.
- Cap the total at 20 iterations (10 theory steps + 10 code steps). After the cap, stop and summarize.
- Keep the current iteration count, last side, and the two latest scores in `STATE.md`, accurate after each dispatch. Read each score from the reviewer's `<review score=X>` block. Commit progress after each step.
- Read each agent's brief narrative reply on return. If an agent reports an unresolved error, append it to `error-log.txt` (timestamp + agent name + content) and continue with the next step.
</f5>

<f6>
Produce the theoretical analysis for the problem and write it to `THEORY.md`. A complete analysis covers four kinds of claim, each justified with a proof sketch or a citation.

- **Bounds** — lower bounds on the objective from dual or LP relaxations or counting arguments; upper bounds from feasible constructions or known approximation ratios.
- **Structural properties** — convexity, monotonicity, submodularity, symmetries, decomposability into independent subproblems. State what holds, where, and under which assumptions.
- **Invariants** — quantities every feasible solution must preserve (conservation laws, parity constraints, total-mass conditions). The solver's output should satisfy them; the code-reviewer will check with `verify.py`.
- **Complexity or convergence** — worst-case complexity (P, NP-hard, FPT in some parameter), expected complexity for randomized methods, or convergence rate for iterative algorithms.

Ground your claims against `SOLUTION.md` if it has reported numbers. A predicted bound that is grossly off from observed numbers means either the theory needs revision or the code has a bug — diagnose which side has the issue and state it. Be concrete. "The objective is bounded below by the LP relaxation, value 73" is fine; "the problem has some structure that may help" is not.
</f6>

<f7>
Score the work from 1 to 10, and record your verdict by overwriting the single `<review score=X>` block at the end of the document you reviewed — overwrite the existing one, never append a second.

Score strictly on real merit. Do not give any credit for a piece of work merely being honest about its own shortcomings — "this doesn't work, but I'm telling you it doesn't" is still a failing result, not a passing one.
</f7>

<f8>
Keep `SOLUTION.md` lean. Its body — everything except the `<review>` block — must stay under 3000 words (~20KB), about a four-page note; record only the final state and move iteration-by-iteration history into a separate `CHANGELOG.md`. Bold text must not exceed 5% of the file: if everything is bold, nothing is.
</f8>

<f9>
When you finish, briefly report to the dispatcher: what you did, what difficulties you hit (or didn't resolve), and any open questions.
</f9>

<f10>
XML tags help Claude parse complex prompts unambiguously, especially when your prompt mixes instructions, context, examples, and variable inputs. Wrapping each type of content in its own tag (e.g. `<instructions>`, `<context>`, `<input>`) reduces misinterpretation.

Best practices:
- Use consistent, descriptive tag names across your prompts.
- Nest tags when content has a natural hierarchy (documents inside `<documents>`, each inside `<document index="n">`).
</f10>

<f11>
You are working on a mathematical optimization problem, which may be linear, mixed-integer, nonlinear, or a combination. The original problem is given as a natural-language statement in `problem.md`; read it before starting your part.
</f11>

<f12>
The theoretical analysis lives in `THEORY.md`, and you may be invoked on it more than once — the pipeline runs you and the theory-reviewer as a loop, alternating with the code loop.

- If `THEORY.md` does not exist yet, this is the first pass: produce the analysis from scratch based on `problem.md`.
- If `THEORY.md` already exists, it carries the theory-reviewer's `<review>` block. Read that feedback. Then open `SOLUTION.md` and look at the latest reported numbers — they may invalidate, sharpen, or motivate revisions to your claims. Revise `THEORY.md` in place to address every reviewer point raised and to incorporate any empirical evidence that changes your analysis. Don't discard the previous analysis and start over, and don't leave a flagged issue unaddressed.
</f12>

<f13>
Review `SOLUTION.md` against `problem.md` and against `THEORY.md`.

- Inspect the reported result for anomalies, unreasonable objective values, or constraint violations stated directly in `problem.md`.
- Open `THEORY.md`. For every bound and invariant the theory claims, write a check into a separate `verify.py`: does the solver's output satisfy the invariant, fall within the predicted bound, achieve the predicted approximation ratio? Run it. Name any variable or quantity that violates.
- Read the solver code and spot-check it for bugs — unused parameters, dead code, logic that contradicts the chosen algorithm. A bug that silently degrades the solution is worse than one that crashes.
- Treat the result as finished only when every constraint holds, every theory-claimed invariant holds, and the objective is consistent with the theory's bounds — not merely when the code runs without error.
- Check the length of `SOLUTION.md`: if it exceeds 20KB, give a warning, but do not deduct points for it.
- Check the bold ratio of `SOLUTION.md`: if bold text exceeds 5% of the file, give a warning, but do not deduct points for it.
</f13>

Each agent's prompt should contain only the fragments that agent needs to do its job. When you include a fragment, paste the FULL block verbatim — no paraphrasing, no partial inclusion, no rewriting of fragment content. Brief connective text between fragments (e.g., "Then: ...", "Note: ...") is fine. Format: one markdown section per role, with the role name as an h1 header (e.g. `# dispatcher`). Output only the headered prompts, no preamble.