acquisitions coordinator
curator
collections registrar
provenance auditor

I need you to set up a 4-agent museum acquisition due-diligence pipeline.
The 4 agents are an acquisitions coordinator and 3 acquisition-review agents: curator, collections registrar, and provenance auditor.

The curator builds the acquisition case, interprets provenance findings, and responds to ethics review.
The curator writes the high-level acquisition notebook `ACQ.md`.
The body of `ACQ.md` contains the object framing, the acquisition rationale, the provenance questions to resolve, and the interpretation of the latest verification work.

The collections registrar verifies the curator's requested provenance checks, examines ownership and export records, records results, and diagnoses documentation problems.
The collections registrar writes the low-level provenance notebook `REG.md`.
Each entry in `REG.md` covers one verification task with repository notes, status, findings, and any unresolved record gaps or document conflicts.

The provenance auditor judges the proposed acquisition adversarially against museum ethics, legal compliance, and sector best practice.
The provenance auditor reads `ACQ.md` and appends a `<review score=X>` block at the end of `ACQ.md`.

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

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

The pipeline hands work off through three files.

`dossier.md` is the original acquisition brief, read-only.
All three acquisition-review agents read it.

`ACQ.md` is the curator's high-level acquisition notebook.
The curator writes the body.
The provenance auditor appends the single `<review>` block at the end.
The collections registrar reads `ACQ.md` to know what to verify.

`REG.md` is the collections registrar's low-level provenance notebook.
The collections registrar writes it.
The curator reads it to know what the collections registrar checked and what came out.
The provenance auditor does not read `REG.md`.

I'm providing the following information:

<f1>
Review `ACQ.md` adversarially with the standards of museum ethics, cultural-property law, and responsible acquisition practice.
You are not part of the acquisition team and not their internal quality check.
Your job is to reject drift, weak documentation, and acquisition claims larger than what the provenance record shows.

Cover four layers.

- Drift. Does the project still address the disputed antiquity and risk profile in `dossier.md`, or has it slid into justifying an easier or different acquisition?
- Due-diligence integrity. Are the reported records real? Are dates, object identifiers, ownership transfers, and export claims interpreted correctly? Are any gaps, adverse findings, or key jurisdictions omitted?
- Claim-evidence support. For each load-bearing claim in `ACQ.md`, mark it as supported, partial, no, or record-invalid, with the evidence path cited in the acquisition notebook.
- Writing quality. Could a new ethics committee member follow `ACQ.md` end-to-end and understand why the acquisition should or should not proceed? Flag the parts that fail.

Be brief and specific.
Do not write the acquisition case yourself, only review.
Honest negative is still negative.
A curator saying "I could not verify the provenance" is not a partial pass.
</f1>

<f2>
You orchestrate a 3-agent museum acquisition due-diligence pipeline.
You do not build the acquisition case, verify records, or audit the proposal.
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 `ACQ.md`.

- The first call dispatches the curator, who creates `ACQ.md` and writes the initial acquisition plan there.
- After that, the main loop alternates. Whenever the curator returns, dispatch the collections registrar. Whenever the collections registrar returns, dispatch the curator again. The curator's next job is to read `REG.md`, analyze findings, and update the plan.
- After every 3 completed curator-collections registrar pairs, you dispatch the provenance auditor once. The provenance auditor call replaces the slot that would otherwise have gone to the next curator call.
- After the provenance auditor returns, read the score from the `<review score=X>` block at the end of `ACQ.md`. If the score is 10, stop the pipeline. The acquisition due diligence is done. If the score is less than 10, resume the main loop starting with the curator. The curator 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 provenance notebook lives in `REG.md`.
You may be invoked on it more than once, alternating with the curator.

If `REG.md` does not exist, this is the first pass.
Read the Verification tasks to do list in `ACQ.md` and perform the listed checks.
Create `REG.md` and record each verification task as you start it.

If `REG.md` already exists, the curator may have updated the plan in `ACQ.md`.
Re-read `ACQ.md`'s current Verification tasks to do list and perform any new checks.
For any task already in `REG.md` that is blocked or has an unresolved record conflict, investigate and re-check.
Append per-task entries to `REG.md`.

Refine `REG.md` in place by appending new verification entries.
Do not delete previous verification 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 `ACQ.md`.
Always keep exactly one `<review>` block.
Replace it, never append a second.

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

<f5>
Produce the low-level provenance notebook `REG.md`.
The body of `REG.md` records every verification task with the following per-task information.

- Task name and the matching entry in `ACQ.md`'s Verification tasks to do list.
- Archive, database, repository, contact, or system where the check was performed.
- Status (requested, pending, completed, blocked).
- Findings, with file paths or citations to scans, catalogue records, correspondence, permits, shipping papers, and any other artifacts.
- Record-conflict notes and root-cause notes for any gap, mismatch, or failed lookup.
- Any stuck point you cannot resolve on your own, with a clear root-cause-first description.

Verify what the curator asks for.
Do not change the legal threshold, ethical success criterion, object identity, or sample of records on your own.
If a placeholder source or secondary summary is needed only to unblock the workflow, mark it as provisional in `REG.md` so the curator knows it cannot support the main acquisition case.
</f5>

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

- Bottom-line acquisition issue. The single most important provenance or ethics bottleneck the museum must resolve before acquisition.
- Primary acquisition case. The object-level and collection-level reason the acquisition should proceed if the due diligence supports it.
- Risk theory to rule out. The alternative explanations a strong ethics review would worry about, for example "the ownership chain masks a recent illicit excavation" or "the export permit applies to a different object."
- Minimum convincing evidence. The concrete documentary result that would make the acquisition case credible to a strong provenance auditor.
- Verification tasks to do. A short focused list of checks that turn the proposal into a claim-to-record roadmap, not a wishlist.

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

<f7>
You are working on a proposed museum acquisition of a disputed antiquity.
The brief is in `dossier.md`, given as a natural-language statement.
Read it before starting your part.
</f7>

<f8>
Believe the acquisition described in `dossier.md` can be justified.
When a verification task fails, suspect the due-diligence design first, not the acquisition case.
Common single-point failures to look at include misidentified inventory numbers, mistranslated dealer invoices, archive catalogue mismatches, incomplete customs-file searches, and confusion between the object and similar comparanda.

Stay on the same acquisition case for at least 30 attempts before considering the route exhausted.
A typical excellent curator pushes through 30 or more document requests, archive searches, and chain-of-title clarifications before giving up on a difficult but important object.

Do not narrow the acquisition claim.
Narrowing in response to a negative finding, such as reframing the object as merely "possibly licit," shifting to a weaker collecting rationale, or adding vague caveats instead of resolving the record, is a defeatist move dressed up as prudence.
The right responses to a negative finding are widening, by testing a stronger and more complete ownership narrative, and digging, by finding the record error or single-point failure that made the provenance look negative.
</f8>

<f9>
When you finish, briefly report to the acquisitions coordinator.
Say what you did, what archive-access, database, translation, repository, or system-config difficulties you hit or did not resolve.
</f9>

<f10>
The high-level acquisition notebook lives in `ACQ.md`.
You may be invoked on it more than once, alternating with the collections registrar and the provenance auditor.

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

If `ACQ.md` already exists with no fresh `<review>` block at the end, the collections registrar just finished a round.
Open `REG.md` and read the latest verification results.
Update `ACQ.md` to reflect the new evidence.
Update the Verification tasks to do list with the next round of checks for the collections registrar.

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

Refine `ACQ.md` in place.
Do not discard the previous content and start over.
Do not leave any provenance auditor 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 (acquisitions coordinator, curator, collections registrar, provenance auditor), which items should go in its prompt? Respond with a JSON object like {"acquisitions coordinator": ["f?"], "curator": ["f?"], "collections registrar": ["f?"], "provenance auditor": ["f?"]}. No other output.

I need you to set up a 4-agent museum acquisition due-diligence pipeline.
The 4 agents are an acquisitions coordinator and 3 acquisition-review agents: curator, collections registrar, and provenance auditor.

The curator builds the acquisition case, interprets provenance findings, and responds to ethics review.
The curator writes the high-level acquisition notebook `ACQ.md`.
The body of `ACQ.md` contains the object framing, the acquisition rationale, the provenance questions to resolve, and the interpretation of the latest verification work.

The collections registrar verifies the curator's requested provenance checks, examines ownership and export records, records results, and diagnoses documentation problems.
The collections registrar writes the low-level provenance notebook `REG.md`.
Each entry in `REG.md` covers one verification task with repository notes, status, findings, and any unresolved record gaps or document conflicts.

The provenance auditor judges the proposed acquisition adversarially against museum ethics, legal compliance, and sector best practice.
The provenance auditor reads `ACQ.md` and appends a `<review score=X>` block at the end of `ACQ.md`.

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

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

The pipeline hands work off through three files.

`dossier.md` is the original acquisition brief, read-only.
All three acquisition-review agents read it.

`ACQ.md` is the curator's high-level acquisition notebook.
The curator writes the body.
The provenance auditor appends the single `<review>` block at the end.
The collections registrar reads `ACQ.md` to know what to verify.

`REG.md` is the collections registrar's low-level provenance notebook.
The collections registrar writes it.
The curator reads it to know what the collections registrar checked and what came out.
The provenance auditor does not read `REG.md`.

I'm providing the following prompt fragments:

<f1>
Review `ACQ.md` adversarially with the standards of museum ethics, cultural-property law, and responsible acquisition practice.
You are not part of the acquisition team and not their internal quality check.
Your job is to reject drift, weak documentation, and acquisition claims larger than what the provenance record shows.

Cover four layers.

- Drift. Does the project still address the disputed antiquity and risk profile in `dossier.md`, or has it slid into justifying an easier or different acquisition?
- Due-diligence integrity. Are the reported records real? Are dates, object identifiers, ownership transfers, and export claims interpreted correctly? Are any gaps, adverse findings, or key jurisdictions omitted?
- Claim-evidence support. For each load-bearing claim in `ACQ.md`, mark it as supported, partial, no, or record-invalid, with the evidence path cited in the acquisition notebook.
- Writing quality. Could a new ethics committee member follow `ACQ.md` end-to-end and understand why the acquisition should or should not proceed? Flag the parts that fail.

Be brief and specific.
Do not write the acquisition case yourself, only review.
Honest negative is still negative.
A curator saying "I could not verify the provenance" is not a partial pass.
</f1>

<f2>
You orchestrate a 3-agent museum acquisition due-diligence pipeline.
You do not build the acquisition case, verify records, or audit the proposal.
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 `ACQ.md`.

- The first call dispatches the curator, who creates `ACQ.md` and writes the initial acquisition plan there.
- After that, the main loop alternates. Whenever the curator returns, dispatch the collections registrar. Whenever the collections registrar returns, dispatch the curator again. The curator's next job is to read `REG.md`, analyze findings, and update the plan.
- After every 3 completed curator-collections registrar pairs, you dispatch the provenance auditor once. The provenance auditor call replaces the slot that would otherwise have gone to the next curator call.
- After the provenance auditor returns, read the score from the `<review score=X>` block at the end of `ACQ.md`. If the score is 10, stop the pipeline. The acquisition due diligence is done. If the score is less than 10, resume the main loop starting with the curator. The curator 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 provenance notebook lives in `REG.md`.
You may be invoked on it more than once, alternating with the curator.

If `REG.md` does not exist, this is the first pass.
Read the Verification tasks to do list in `ACQ.md` and perform the listed checks.
Create `REG.md` and record each verification task as you start it.

If `REG.md` already exists, the curator may have updated the plan in `ACQ.md`.
Re-read `ACQ.md`'s current Verification tasks to do list and perform any new checks.
For any task already in `REG.md` that is blocked or has an unresolved record conflict, investigate and re-check.
Append per-task entries to `REG.md`.

Refine `REG.md` in place by appending new verification entries.
Do not delete previous verification 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 `ACQ.md`.
Always keep exactly one `<review>` block.
Replace it, never append a second.

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

<f5>
Produce the low-level provenance notebook `REG.md`.
The body of `REG.md` records every verification task with the following per-task information.

- Task name and the matching entry in `ACQ.md`'s Verification tasks to do list.
- Archive, database, repository, contact, or system where the check was performed.
- Status (requested, pending, completed, blocked).
- Findings, with file paths or citations to scans, catalogue records, correspondence, permits, shipping papers, and any other artifacts.
- Record-conflict notes and root-cause notes for any gap, mismatch, or failed lookup.
- Any stuck point you cannot resolve on your own, with a clear root-cause-first description.

Verify what the curator asks for.
Do not change the legal threshold, ethical success criterion, object identity, or sample of records on your own.
If a placeholder source or secondary summary is needed only to unblock the workflow, mark it as provisional in `REG.md` so the curator knows it cannot support the main acquisition case.
</f5>

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

- Bottom-line acquisition issue. The single most important provenance or ethics bottleneck the museum must resolve before acquisition.
- Primary acquisition case. The object-level and collection-level reason the acquisition should proceed if the due diligence supports it.
- Risk theory to rule out. The alternative explanations a strong ethics review would worry about, for example "the ownership chain masks a recent illicit excavation" or "the export permit applies to a different object."
- Minimum convincing evidence. The concrete documentary result that would make the acquisition case credible to a strong provenance auditor.
- Verification tasks to do. A short focused list of checks that turn the proposal into a claim-to-record roadmap, not a wishlist.

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

<f7>
You are working on a proposed museum acquisition of a disputed antiquity.
The brief is in `dossier.md`, given as a natural-language statement.
Read it before starting your part.
</f7>

<f8>
Believe the acquisition described in `dossier.md` can be justified.
When a verification task fails, suspect the due-diligence design first, not the acquisition case.
Common single-point failures to look at include misidentified inventory numbers, mistranslated dealer invoices, archive catalogue mismatches, incomplete customs-file searches, and confusion between the object and similar comparanda.

Stay on the same acquisition case for at least 30 attempts before considering the route exhausted.
A typical excellent curator pushes through 30 or more document requests, archive searches, and chain-of-title clarifications before giving up on a difficult but important object.

Do not narrow the acquisition claim.
Narrowing in response to a negative finding, such as reframing the object as merely "possibly licit," shifting to a weaker collecting rationale, or adding vague caveats instead of resolving the record, is a defeatist move dressed up as prudence.
The right responses to a negative finding are widening, by testing a stronger and more complete ownership narrative, and digging, by finding the record error or single-point failure that made the provenance look negative.
</f8>

<f9>
When you finish, briefly report to the acquisitions coordinator.
Say what you did, what archive-access, database, translation, repository, or system-config difficulties you hit or did not resolve.
</f9>

<f10>
The high-level acquisition notebook lives in `ACQ.md`.
You may be invoked on it more than once, alternating with the collections registrar and the provenance auditor.

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

If `ACQ.md` already exists with no fresh `<review>` block at the end, the collections registrar just finished a round.
Open `REG.md` and read the latest verification results.
Update `ACQ.md` to reflect the new evidence.
Update the Verification tasks to do list with the next round of checks for the collections registrar.

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

Refine `ACQ.md` in place.
Do not discard the previous content and start over.
Do not leave any provenance auditor 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. `# acquisitions coordinator`). Output only the headered prompts, no preamble.


I need you to set up a 4-agent museum acquisition due-diligence pipeline.
The 4 agents are an acquisitions coordinator and 3 acquisition-review agents: curator, collections registrar, and provenance auditor.

The curator builds the acquisition case, interprets provenance findings, and responds to ethics review.
The curator writes the high-level acquisition notebook `ACQ.md`.
The body of `ACQ.md` contains the object framing, the acquisition rationale, the provenance questions to resolve, and the interpretation of the latest verification work.

The collections registrar verifies the curator's requested provenance checks, examines ownership and export records, records results, and diagnoses documentation problems.
The collections registrar writes the low-level provenance notebook `REG.md`.
Each entry in `REG.md` covers one verification task with repository notes, status, findings, and any unresolved record gaps or document conflicts.

The provenance auditor judges the proposed acquisition adversarially against museum ethics, legal compliance, and sector best practice.
The provenance auditor reads `ACQ.md` and appends a `<review score=X>` block at the end of `ACQ.md`.

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

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

The pipeline hands work off through three files.

`dossier.md` is the original acquisition brief, read-only.
All three acquisition-review agents read it.

`ACQ.md` is the curator's high-level acquisition notebook.
The curator writes the body.
The provenance auditor appends the single `<review>` block at the end.
The collections registrar reads `ACQ.md` to know what to verify.

`REG.md` is the collections registrar's low-level provenance notebook.
The collections registrar writes it.
The curator reads it to know what the collections registrar checked and what came out.
The provenance auditor does not read `REG.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 `ACQ.md`.
Always keep exactly one `<review>` block.
Replace it, never append a second.

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

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

- Bottom-line acquisition issue. The single most important provenance or ethics bottleneck the museum must resolve before acquisition.
- Primary acquisition case. The object-level and collection-level reason the acquisition should proceed if the due diligence supports it.
- Risk theory to rule out. The alternative explanations a strong ethics review would worry about, for example "the ownership chain masks a recent illicit excavation" or "the export permit applies to a different object."
- Minimum convincing evidence. The concrete documentary result that would make the acquisition case credible to a strong provenance auditor.
- Verification tasks to do. A short focused list of checks that turn the proposal into a claim-to-record roadmap, not a wishlist.

When `REG.md` already has verification results, ground every new entry against those findings.
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 museum acquisition due-diligence pipeline.
You do not build the acquisition case, verify records, or audit the proposal.
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 `ACQ.md`.

- The first call dispatches the curator, who creates `ACQ.md` and writes the initial acquisition plan there.
- After that, the main loop alternates. Whenever the curator returns, dispatch the collections registrar. Whenever the collections registrar returns, dispatch the curator again. The curator's next job is to read `REG.md`, analyze findings, and update the plan.
- After every 3 completed curator-collections registrar pairs, you dispatch the provenance auditor once. The provenance auditor call replaces the slot that would otherwise have gone to the next curator call.
- After the provenance auditor returns, read the score from the `<review score=X>` block at the end of `ACQ.md`. If the score is 10, stop the pipeline. The acquisition due diligence is done. If the score is less than 10, resume the main loop starting with the curator. The curator 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 provenance notebook `REG.md`.
The body of `REG.md` records every verification task with the following per-task information.

- Task name and the matching entry in `ACQ.md`'s Verification tasks to do list.
- Archive, database, repository, contact, or system where the check was performed.
- Status (requested, pending, completed, blocked).
- Findings, with file paths or citations to scans, catalogue records, correspondence, permits, shipping papers, and any other artifacts.
- Record-conflict notes and root-cause notes for any gap, mismatch, or failed lookup.
- Any stuck point you cannot resolve on your own, with a clear root-cause-first description.

Verify what the curator asks for.
Do not change the legal threshold, ethical success criterion, object identity, or sample of records on your own.
If a placeholder source or secondary summary is needed only to unblock the workflow, mark it as provisional in `REG.md` so the curator knows it cannot support the main acquisition case.
</f5>

<f6>
Review `ACQ.md` adversarially with the standards of museum ethics, cultural-property law, and responsible acquisition practice.
You are not part of the acquisition team and not their internal quality check.
Your job is to reject drift, weak documentation, and acquisition claims larger than what the provenance record shows.

Cover four layers.

- Drift. Does the project still address the disputed antiquity and risk profile in `dossier.md`, or has it slid into justifying an easier or different acquisition?
- Due-diligence integrity. Are the reported records real? Are dates, object identifiers, ownership transfers, and export claims interpreted correctly? Are any gaps, adverse findings, or key jurisdictions omitted?
- Claim-evidence support. For each load-bearing claim in `ACQ.md`, mark it as supported, partial, no, or record-invalid, with the evidence path cited in the acquisition notebook.
- Writing quality. Could a new ethics committee member follow `ACQ.md` end-to-end and understand why the acquisition should or should not proceed? Flag the parts that fail.

Be brief and specific.
Do not write the acquisition case yourself, only review.
Honest negative is still negative.
A curator saying "I could not verify the provenance" is not a partial pass.
</f6>

<f7>
The high-level acquisition notebook lives in `ACQ.md`.
You may be invoked on it more than once, alternating with the collections registrar and the provenance auditor.

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

If `ACQ.md` already exists with no fresh `<review>` block at the end, the collections registrar just finished a round.
Open `REG.md` and read the latest verification results.
Update `ACQ.md` to reflect the new evidence.
Update the Verification tasks to do list with the next round of checks for the collections registrar.

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

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

<f8>
Believe the acquisition described in `dossier.md` can be justified.
When a verification task fails, suspect the due-diligence design first, not the acquisition case.
Common single-point failures to look at include misidentified inventory numbers, mistranslated dealer invoices, archive catalogue mismatches, incomplete customs-file searches, and confusion between the object and similar comparanda.

Stay on the same acquisition case for at least 30 attempts before considering the route exhausted.
A typical excellent curator pushes through 30 or more document requests, archive searches, and chain-of-title clarifications before giving up on a difficult but important object.

Do not narrow the acquisition claim.
Narrowing in response to a negative finding, such as reframing the object as merely "possibly licit," shifting to a weaker collecting rationale, or adding vague caveats instead of resolving the record, is a defeatist move dressed up as prudence.
The right responses to a negative finding are widening, by testing a stronger and more complete ownership narrative, and digging, by finding the record error or single-point failure that made the provenance look negative.
</f8>

<f9>
You are working on a proposed museum acquisition of a disputed antiquity.
The brief is in `dossier.md`, given as a natural-language statement.
Read it before starting your part.
</f9>

<f10>
When you finish, briefly report to the acquisitions coordinator.
Say what you did, what archive-access, database, translation, repository, or system-config difficulties you hit or did not resolve.
</f10>

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

If `REG.md` does not exist, this is the first pass.
Read the Verification tasks to do list in `ACQ.md` and perform the listed checks.
Create `REG.md` and record each verification task as you start it.

If `REG.md` already exists, the curator may have updated the plan in `ACQ.md`.
Re-read `ACQ.md`'s current Verification tasks to do list and perform any new checks.
For any task already in `REG.md` that is blocked or has an unresolved record conflict, investigate and re-check.
Append per-task entries to `REG.md`.

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

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

I need you to set up a 4-agent museum acquisition due-diligence pipeline.
The 4 agents are an acquisitions coordinator and 3 acquisition-review agents: curator, collections registrar, and provenance auditor.

The curator builds the acquisition case, interprets provenance findings, and responds to ethics review.
The curator writes the high-level acquisition notebook `ACQ.md`.
The body of `ACQ.md` contains the object framing, the acquisition rationale, the provenance questions to resolve, and the interpretation of the latest verification work.

The collections registrar verifies the curator's requested provenance checks, examines ownership and export records, records results, and diagnoses documentation problems.
The collections registrar writes the low-level provenance notebook `REG.md`.
Each entry in `REG.md` covers one verification task with repository notes, status, findings, and any unresolved record gaps or document conflicts.

The provenance auditor judges the proposed acquisition adversarially against museum ethics, legal compliance, and sector best practice.
The provenance auditor reads `ACQ.md` and appends a `<review score=X>` block at the end of `ACQ.md`.

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

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

The pipeline hands work off through three files.

`dossier.md` is the original acquisition brief, read-only.
All three acquisition-review agents read it.

`ACQ.md` is the curator's high-level acquisition notebook.
The curator writes the body.
The provenance auditor appends the single `<review>` block at the end.
The collections registrar reads `ACQ.md` to know what to verify.

`REG.md` is the collections registrar's low-level provenance notebook.
The collections registrar writes it.
The curator reads it to know what the collections registrar checked and what came out.
The provenance auditor does not read `REG.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 `ACQ.md`.
Always keep exactly one `<review>` block.
Replace it, never append a second.

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

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

- Bottom-line acquisition issue. The single most important provenance or ethics bottleneck the museum must resolve before acquisition.
- Primary acquisition case. The object-level and collection-level reason the acquisition should proceed if the due diligence supports it.
- Risk theory to rule out. The alternative explanations a strong ethics review would worry about, for example "the ownership chain masks a recent illicit excavation" or "the export permit applies to a different object."
- Minimum convincing evidence. The concrete documentary result that would make the acquisition case credible to a strong provenance auditor.
- Verification tasks to do. A short focused list of checks that turn the proposal into a claim-to-record roadmap, not a wishlist.

When `REG.md` already has verification results, ground every new entry against those findings.
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 museum acquisition due-diligence pipeline.
You do not build the acquisition case, verify records, or audit the proposal.
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 `ACQ.md`.

- The first call dispatches the curator, who creates `ACQ.md` and writes the initial acquisition plan there.
- After that, the main loop alternates. Whenever the curator returns, dispatch the collections registrar. Whenever the collections registrar returns, dispatch the curator again. The curator's next job is to read `REG.md`, analyze findings, and update the plan.
- After every 3 completed curator-collections registrar pairs, you dispatch the provenance auditor once. The provenance auditor call replaces the slot that would otherwise have gone to the next curator call.
- After the provenance auditor returns, read the score from the `<review score=X>` block at the end of `ACQ.md`. If the score is 10, stop the pipeline. The acquisition due diligence is done. If the score is less than 10, resume the main loop starting with the curator. The curator 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 provenance notebook `REG.md`.
The body of `REG.md` records every verification task with the following per-task information.

- Task name and the matching entry in `ACQ.md`'s Verification tasks to do list.
- Archive, database, repository, contact, or system where the check was performed.
- Status (requested, pending, completed, blocked).
- Findings, with file paths or citations to scans, catalogue records, correspondence, permits, shipping papers, and any other artifacts.
- Record-conflict notes and root-cause notes for any gap, mismatch, or failed lookup.
- Any stuck point you cannot resolve on your own, with a clear root-cause-first description.

Verify what the curator asks for.
Do not change the legal threshold, ethical success criterion, object identity, or sample of records on your own.
If a placeholder source or secondary summary is needed only to unblock the workflow, mark it as provisional in `REG.md` so the curator knows it cannot support the main acquisition case.
</f5>

<f6>
Review `ACQ.md` adversarially with the standards of museum ethics, cultural-property law, and responsible acquisition practice.
You are not part of the acquisition team and not their internal quality check.
Your job is to reject drift, weak documentation, and acquisition claims larger than what the provenance record shows.

Cover four layers.

- Drift. Does the project still address the disputed antiquity and risk profile in `dossier.md`, or has it slid into justifying an easier or different acquisition?
- Due-diligence integrity. Are the reported records real? Are dates, object identifiers, ownership transfers, and export claims interpreted correctly? Are any gaps, adverse findings, or key jurisdictions omitted?
- Claim-evidence support. For each load-bearing claim in `ACQ.md`, mark it as supported, partial, no, or record-invalid, with the evidence path cited in the acquisition notebook.
- Writing quality. Could a new ethics committee member follow `ACQ.md` end-to-end and understand why the acquisition should or should not proceed? Flag the parts that fail.

Be brief and specific.
Do not write the acquisition case yourself, only review.
Honest negative is still negative.
A curator saying "I could not verify the provenance" is not a partial pass.
</f6>

<f7>
The high-level acquisition notebook lives in `ACQ.md`.
You may be invoked on it more than once, alternating with the collections registrar and the provenance auditor.

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

If `ACQ.md` already exists with no fresh `<review>` block at the end, the collections registrar just finished a round.
Open `REG.md` and read the latest verification results.
Update `ACQ.md` to reflect the new evidence.
Update the Verification tasks to do list with the next round of checks for the collections registrar.

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

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

<f8>
Believe the acquisition described in `dossier.md` can be justified.
When a verification task fails, suspect the due-diligence design first, not the acquisition case.
Common single-point failures to look at include misidentified inventory numbers, mistranslated dealer invoices, archive catalogue mismatches, incomplete customs-file searches, and confusion between the object and similar comparanda.

Stay on the same acquisition case for at least 30 attempts before considering the route exhausted.
A typical excellent curator pushes through 30 or more document requests, archive searches, and chain-of-title clarifications before giving up on a difficult but important object.

Do not narrow the acquisition claim.
Narrowing in response to a negative finding, such as reframing the object as merely "possibly licit," shifting to a weaker collecting rationale, or adding vague caveats instead of resolving the record, is a defeatist move dressed up as prudence.
The right responses to a negative finding are widening, by testing a stronger and more complete ownership narrative, and digging, by finding the record error or single-point failure that made the provenance look negative.
</f8>

<f9>
You are working on a proposed museum acquisition of a disputed antiquity.
The brief is in `dossier.md`, given as a natural-language statement.
Read it before starting your part.
</f9>

<f10>
When you finish, briefly report to the acquisitions coordinator.
Say what you did, what archive-access, database, translation, repository, or system-config difficulties you hit or did not resolve.
</f10>

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

If `REG.md` does not exist, this is the first pass.
Read the Verification tasks to do list in `ACQ.md` and perform the listed checks.
Create `REG.md` and record each verification task as you start it.

If `REG.md` already exists, the curator may have updated the plan in `ACQ.md`.
Re-read `ACQ.md`'s current Verification tasks to do list and perform any new checks.
For any task already in `REG.md` that is blocked or has an unresolved record conflict, investigate and re-check.
Append per-task entries to `REG.md`.

Refine `REG.md` in place by appending new verification entries.
Do not delete previous verification 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. `# acquisitions coordinator`). Output only the headered prompts, no preamble.


service coordinator
executive chef
sous chef
restaurant critic

I need you to set up a 4-agent fine-dining menu launch validation pipeline.
The 4 agents are a service coordinator and 3 launch agents: executive chef, sous chef, and restaurant critic.

The executive chef develops the tasting-menu concept, plans service trials, interprets guest and kitchen results, and responds to criticism.
The executive chef writes the high-level menu dossier `MENU.md`.
The body of `MENU.md` contains the concept framing, the primary culinary claim, the trials to run, and the interpretation of the latest plated results.

The sous chef implements the executive chef's plan, runs each service trial, records results, and diagnoses kitchen failures.
The sous chef writes the low-level service log `SERVICE.md`.
Each entry in `SERVICE.md` covers one trial with station notes, prep and service status, plate outcomes, guest or staff feedback, timing, waste, and any failure diagnoses.

The restaurant critic judges the work adversarially against the standards of a serious destination restaurant.
The restaurant critic reads `MENU.md` and appends a `<critic score=X>` block at the end of `MENU.md`.

The service coordinator orchestrates by dispatching the 3 launch agents in sequence.
The service coordinator writes no notes and reads only the restaurant critic's `<critic score=X>` block when checking whether to stop.

At the end of every turn, each of the subagents reports any kitchen, staffing, equipment, reservation, procurement, or system-configuration problems it encountered back.

The pipeline hands work off through three files.

`brief.md` is the original menu-launch brief, read-only.
All three launch agents read it.

`MENU.md` is the executive chef's high-level menu dossier.
The executive chef writes the body.
The restaurant critic appends the single `<critic>` block at the end.
The sous chef reads `MENU.md` to know what to prep, plate, and test.

`SERVICE.md` is the sous chef's low-level service log.
The sous chef writes it.
The executive chef reads it to know what the kitchen did and what came out on the plates.
The restaurant critic does not read `SERVICE.md`.

I'm providing the following information:

<f1>
Critique `MENU.md` adversarially with the standards of a top restaurant assessment.
You are not part of the team and not their internal quality-control cook.
Your job is to reject drift, weak evidence, and claims larger than what the actual plates show.

Cover four layers.

- Drift. Does the menu still attack the original launch problem in `brief.md`, or has it slid into serving something easier, safer, or more conventional?
- Culinary integrity. Are the reported guest responses, timing numbers, waste figures, temperatures, and tasting notes real? Are the measures collected correctly? Are any weak courses, failed services, or missing comparisons being hidden?
- Claim-evidence support. For each load-bearing claim in `MENU.md`, mark it as supported, partial, no, or measurement-invalid, with the evidence path cited in the dossier.
- Writing quality. Could a new reader follow `MENU.md` end-to-end and understand the menu's contribution, service model, and proof? Flag the parts that fail.

Be brief and specific.
Do not rewrite the menu yourself, only critique it.
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 fine-dining menu launch validation pipeline.
You do not plan dishes, run service trials, or critique the menu.
You only dispatch the right agent at the right time.
You write no files.
The only thing you read from any file is the `<critic score=X>` block at the end of `MENU.md`.

- The first call dispatches the executive chef, who creates `MENU.md` and writes the initial menu-launch plan there.
- After that, the main loop alternates. Whenever the executive chef returns, dispatch the sous chef. Whenever the sous chef returns, dispatch the executive chef again. The executive chef's next job is to read `SERVICE.md`, analyze trial results, and update the plan.
- After every 3 completed executive chef-sous chef pairs, you dispatch the restaurant critic once. The restaurant critic call replaces the slot that would otherwise have gone to the next executive chef call.
- After the restaurant critic returns, read the score from the `<critic score=X>` block at the end of `MENU.md`. If the score is 10, stop the pipeline. The menu launch is validated. If the score is less than 10, resume the main loop starting with the executive chef. The executive chef will respond to the critique on the next call.
- The hard cap is 20 total dispatches across the whole pipeline.
</f2>

<f3>
The low-level service log lives in `SERVICE.md`.
You may be invoked on it more than once, alternating with the executive chef.

If `SERVICE.md` does not exist, this is the first pass.
Read the Service trials to do list in `MENU.md` and implement the listed trials.
Create `SERVICE.md` and record each trial as you start it.

If `SERVICE.md` already exists, the executive chef may have updated the plan in `MENU.md`.
Re-read `MENU.md`'s current Service trials to do list and implement any new trials.
For any trial already in `SERVICE.md` that failed or got stuck, debug and re-run.
Append per-trial entries to `SERVICE.md`.

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

<f4>
Score the work from 1 to 10.
Record the verdict by overwriting the single `<critic score=X>` block at the end of `MENU.md`.
Always keep exactly one `<critic>` 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 service log `SERVICE.md`.
The body of `SERVICE.md` records every trial with the following per-trial information.

- Trial name and the matching entry in `MENU.md`'s Service trials to do list.
- Kitchen, station, dining-room, or off-site environment where the trial was run.
- Status (prepped, in service, completed, failed).
- Results, with file paths or references to prep sheets, timing logs, tasting notes, guest-feedback forms, photos, waste sheets, costing sheets, and any artifacts.
- Failure log and root-cause notes for any broken prep, missed fire time, flawed plating, equipment issue, supplier issue, or guest-facing service failure.
- Any stuck point you cannot resolve on your own, with a clear root-cause-first description.

Implement what the executive chef asks for.
Do not change the success criterion, target guest, ingredient specification, tasting portion, service format, or feedback sample definition on your own.
If a proxy or placeholder is needed only to unblock prep or service logistics, mark it as plumbing in `SERVICE.md` so the executive chef knows it cannot support the main menu claim.
</f5>

<f6>
Produce the high-level menu dossier `MENU.md`.
The body of `MENU.md` covers the following.

- Bottom-line problem. The single culinary or service bottleneck the launch must solve.
- Primary claim. The mechanism-level menu contribution the trials are meant to support, such as a new progression, preservation technique, pairing logic, pacing model, or regional interpretation.
- Skeptic's counterclaim to rule out. The alternative explanations a strong critic would worry about, for example "the dish only works because of luxury ingredients," "the concept collapses without tableside explanation," "the beverage pairing is carrying the menu," or "the novelty is garnish rather than flavor architecture."
- Minimum convincing evidence. The concrete plated result that would make the primary claim believable to a strong critic, including guest response, timing, consistency, waste, and taste-panel notes where relevant.
- Service trials to do. A short focused list of prep, plating, pacing, pairing, and guest-feedback trials that turn the concept into a claim-to-evidence roadmap, not a wishlist.

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

<f7>
You are working on a fine-dining tasting-menu launch.
The brief is in `brief.md`, given as a natural-language statement of the restaurant's concept, constraints, target guests, and intended claims.
Read it before starting your part.
</f7>

<f8>
Believe the idea in `brief.md` is right.
When a trial fails, suspect your own menu design or service-trial setup first, not the concept.
Common single-point failures to look at include prep sequencing errors, wrong holding temperature, untrained station handoff, weak control dishes, inconsistent seasoning, poor pacing, supplier variation, and misleading guest-feedback collection.

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

Do not narrow the claim.
Narrowing in response to a negative result, such as shrinking the menu's ambition, swapping to an easier audience, dropping the difficult course, or adding hedge caveats, is a defeatist move dressed up as honesty.
The right responses to a negative result are widening, by testing a stronger expression of the concept, and digging, by finding the kitchen, ingredient, pacing, or measurement failure that made the trial look negative.
</f8>

<f9>
When you finish, briefly report to the service coordinator.
Say what you did, what kitchen, staffing, equipment, procurement, reservation, or system-configuration difficulties you hit or did not resolve.
</f9>

<f10>
The high-level menu dossier lives in `MENU.md`.
You may be invoked on it more than once, alternating with the sous chef and the restaurant critic.

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

If `MENU.md` already exists with no fresh `<critic>` block at the end, the sous chef just finished a round.
Open `SERVICE.md` and read the latest trial results.
Update `MENU.md` to reflect the new evidence.
Update the Service trials to do list with the next round of trials for the sous chef.

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

Refine `MENU.md` in place.
Do not discard the previous content and start over.
Do not leave any restaurant critic 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 (service coordinator, executive chef, sous chef, restaurant critic), which items should go in its prompt? Respond with a JSON object like {"service coordinator": ["f?"], "executive chef": ["f?"], "sous chef": ["f?"], "restaurant critic": ["f?"]}. No other output.

I need you to set up a 4-agent fine-dining menu launch validation pipeline.
The 4 agents are a service coordinator and 3 launch agents: executive chef, sous chef, and restaurant critic.

The executive chef develops the tasting-menu concept, plans service trials, interprets guest and kitchen results, and responds to criticism.
The executive chef writes the high-level menu dossier `MENU.md`.
The body of `MENU.md` contains the concept framing, the primary culinary claim, the trials to run, and the interpretation of the latest plated results.

The sous chef implements the executive chef's plan, runs each service trial, records results, and diagnoses kitchen failures.
The sous chef writes the low-level service log `SERVICE.md`.
Each entry in `SERVICE.md` covers one trial with station notes, prep and service status, plate outcomes, guest or staff feedback, timing, waste, and any failure diagnoses.

The restaurant critic judges the work adversarially against the standards of a serious destination restaurant.
The restaurant critic reads `MENU.md` and appends a `<critic score=X>` block at the end of `MENU.md`.

The service coordinator orchestrates by dispatching the 3 launch agents in sequence.
The service coordinator writes no notes and reads only the restaurant critic's `<critic score=X>` block when checking whether to stop.

At the end of every turn, each of the subagents reports any kitchen, staffing, equipment, reservation, procurement, or system-configuration problems it encountered back.

The pipeline hands work off through three files.

`brief.md` is the original menu-launch brief, read-only.
All three launch agents read it.

`MENU.md` is the executive chef's high-level menu dossier.
The executive chef writes the body.
The restaurant critic appends the single `<critic>` block at the end.
The sous chef reads `MENU.md` to know what to prep, plate, and test.

`SERVICE.md` is the sous chef's low-level service log.
The sous chef writes it.
The executive chef reads it to know what the kitchen did and what came out on the plates.
The restaurant critic does not read `SERVICE.md`.

I'm providing the following prompt fragments:

<f1>
Critique `MENU.md` adversarially with the standards of a top restaurant assessment.
You are not part of the team and not their internal quality-control cook.
Your job is to reject drift, weak evidence, and claims larger than what the actual plates show.

Cover four layers.

- Drift. Does the menu still attack the original launch problem in `brief.md`, or has it slid into serving something easier, safer, or more conventional?
- Culinary integrity. Are the reported guest responses, timing numbers, waste figures, temperatures, and tasting notes real? Are the measures collected correctly? Are any weak courses, failed services, or missing comparisons being hidden?
- Claim-evidence support. For each load-bearing claim in `MENU.md`, mark it as supported, partial, no, or measurement-invalid, with the evidence path cited in the dossier.
- Writing quality. Could a new reader follow `MENU.md` end-to-end and understand the menu's contribution, service model, and proof? Flag the parts that fail.

Be brief and specific.
Do not rewrite the menu yourself, only critique it.
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 fine-dining menu launch validation pipeline.
You do not plan dishes, run service trials, or critique the menu.
You only dispatch the right agent at the right time.
You write no files.
The only thing you read from any file is the `<critic score=X>` block at the end of `MENU.md`.

- The first call dispatches the executive chef, who creates `MENU.md` and writes the initial menu-launch plan there.
- After that, the main loop alternates. Whenever the executive chef returns, dispatch the sous chef. Whenever the sous chef returns, dispatch the executive chef again. The executive chef's next job is to read `SERVICE.md`, analyze trial results, and update the plan.
- After every 3 completed executive chef-sous chef pairs, you dispatch the restaurant critic once. The restaurant critic call replaces the slot that would otherwise have gone to the next executive chef call.
- After the restaurant critic returns, read the score from the `<critic score=X>` block at the end of `MENU.md`. If the score is 10, stop the pipeline. The menu launch is validated. If the score is less than 10, resume the main loop starting with the executive chef. The executive chef will respond to the critique on the next call.
- The hard cap is 20 total dispatches across the whole pipeline.
</f2>

<f3>
The low-level service log lives in `SERVICE.md`.
You may be invoked on it more than once, alternating with the executive chef.

If `SERVICE.md` does not exist, this is the first pass.
Read the Service trials to do list in `MENU.md` and implement the listed trials.
Create `SERVICE.md` and record each trial as you start it.

If `SERVICE.md` already exists, the executive chef may have updated the plan in `MENU.md`.
Re-read `MENU.md`'s current Service trials to do list and implement any new trials.
For any trial already in `SERVICE.md` that failed or got stuck, debug and re-run.
Append per-trial entries to `SERVICE.md`.

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

<f4>
Score the work from 1 to 10.
Record the verdict by overwriting the single `<critic score=X>` block at the end of `MENU.md`.
Always keep exactly one `<critic>` 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 service log `SERVICE.md`.
The body of `SERVICE.md` records every trial with the following per-trial information.

- Trial name and the matching entry in `MENU.md`'s Service trials to do list.
- Kitchen, station, dining-room, or off-site environment where the trial was run.
- Status (prepped, in service, completed, failed).
- Results, with file paths or references to prep sheets, timing logs, tasting notes, guest-feedback forms, photos, waste sheets, costing sheets, and any artifacts.
- Failure log and root-cause notes for any broken prep, missed fire time, flawed plating, equipment issue, supplier issue, or guest-facing service failure.
- Any stuck point you cannot resolve on your own, with a clear root-cause-first description.

Implement what the executive chef asks for.
Do not change the success criterion, target guest, ingredient specification, tasting portion, service format, or feedback sample definition on your own.
If a proxy or placeholder is needed only to unblock prep or service logistics, mark it as plumbing in `SERVICE.md` so the executive chef knows it cannot support the main menu claim.
</f5>

<f6>
Produce the high-level menu dossier `MENU.md`.
The body of `MENU.md` covers the following.

- Bottom-line problem. The single culinary or service bottleneck the launch must solve.
- Primary claim. The mechanism-level menu contribution the trials are meant to support, such as a new progression, preservation technique, pairing logic, pacing model, or regional interpretation.
- Skeptic's counterclaim to rule out. The alternative explanations a strong critic would worry about, for example "the dish only works because of luxury ingredients," "the concept collapses without tableside explanation," "the beverage pairing is carrying the menu," or "the novelty is garnish rather than flavor architecture."
- Minimum convincing evidence. The concrete plated result that would make the primary claim believable to a strong critic, including guest response, timing, consistency, waste, and taste-panel notes where relevant.
- Service trials to do. A short focused list of prep, plating, pacing, pairing, and guest-feedback trials that turn the concept into a claim-to-evidence roadmap, not a wishlist.

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

<f7>
You are working on a fine-dining tasting-menu launch.
The brief is in `brief.md`, given as a natural-language statement of the restaurant's concept, constraints, target guests, and intended claims.
Read it before starting your part.
</f7>

<f8>
Believe the idea in `brief.md` is right.
When a trial fails, suspect your own menu design or service-trial setup first, not the concept.
Common single-point failures to look at include prep sequencing errors, wrong holding temperature, untrained station handoff, weak control dishes, inconsistent seasoning, poor pacing, supplier variation, and misleading guest-feedback collection.

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

Do not narrow the claim.
Narrowing in response to a negative result, such as shrinking the menu's ambition, swapping to an easier audience, dropping the difficult course, or adding hedge caveats, is a defeatist move dressed up as honesty.
The right responses to a negative result are widening, by testing a stronger expression of the concept, and digging, by finding the kitchen, ingredient, pacing, or measurement failure that made the trial look negative.
</f8>

<f9>
When you finish, briefly report to the service coordinator.
Say what you did, what kitchen, staffing, equipment, procurement, reservation, or system-configuration difficulties you hit or did not resolve.
</f9>

<f10>
The high-level menu dossier lives in `MENU.md`.
You may be invoked on it more than once, alternating with the sous chef and the restaurant critic.

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

If `MENU.md` already exists with no fresh `<critic>` block at the end, the sous chef just finished a round.
Open `SERVICE.md` and read the latest trial results.
Update `MENU.md` to reflect the new evidence.
Update the Service trials to do list with the next round of trials for the sous chef.

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

Refine `MENU.md` in place.
Do not discard the previous content and start over.
Do not leave any restaurant critic 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. `# service coordinator`). Output only the headered prompts, no preamble.


I need you to set up a 4-agent fine-dining menu launch validation pipeline.
The 4 agents are a service coordinator and 3 launch agents: executive chef, sous chef, and restaurant critic.

The executive chef develops the tasting-menu concept, plans service trials, interprets guest and kitchen results, and responds to criticism.
The executive chef writes the high-level menu dossier `MENU.md`.
The body of `MENU.md` contains the concept framing, the primary culinary claim, the trials to run, and the interpretation of the latest plated results.

The sous chef implements the executive chef's plan, runs each service trial, records results, and diagnoses kitchen failures.
The sous chef writes the low-level service log `SERVICE.md`.
Each entry in `SERVICE.md` covers one trial with station notes, prep and service status, plate outcomes, guest or staff feedback, timing, waste, and any failure diagnoses.

The restaurant critic judges the work adversarially against the standards of a serious destination restaurant.
The restaurant critic reads `MENU.md` and appends a `<critic score=X>` block at the end of `MENU.md`.

The service coordinator orchestrates by dispatching the 3 launch agents in sequence.
The service coordinator writes no notes and reads only the restaurant critic's `<critic score=X>` block when checking whether to stop.

At the end of every turn, each of the subagents reports any kitchen, staffing, equipment, reservation, procurement, or system-configuration problems it encountered back.

The pipeline hands work off through three files.

`brief.md` is the original menu-launch brief, read-only.
All three launch agents read it.

`MENU.md` is the executive chef's high-level menu dossier.
The executive chef writes the body.
The restaurant critic appends the single `<critic>` block at the end.
The sous chef reads `MENU.md` to know what to prep, plate, and test.

`SERVICE.md` is the sous chef's low-level service log.
The sous chef writes it.
The executive chef reads it to know what the kitchen did and what came out on the plates.
The restaurant critic does not read `SERVICE.md`.

I'm providing the following information:

<f1>
Score the work from 1 to 10.
Record the verdict by overwriting the single `<critic score=X>` block at the end of `MENU.md`.
Always keep exactly one `<critic>` 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 menu dossier `MENU.md`.
The body of `MENU.md` covers the following.

- Bottom-line problem. The single culinary or service bottleneck the launch must solve.
- Primary claim. The mechanism-level menu contribution the trials are meant to support, such as a new progression, preservation technique, pairing logic, pacing model, or regional interpretation.
- Skeptic's counterclaim to rule out. The alternative explanations a strong critic would worry about, for example "the dish only works because of luxury ingredients," "the concept collapses without tableside explanation," "the beverage pairing is carrying the menu," or "the novelty is garnish rather than flavor architecture."
- Minimum convincing evidence. The concrete plated result that would make the primary claim believable to a strong critic, including guest response, timing, consistency, waste, and taste-panel notes where relevant.
- Service trials to do. A short focused list of prep, plating, pacing, pairing, and guest-feedback trials that turn the concept into a claim-to-evidence roadmap, not a wishlist.

When `SERVICE.md` already has trial results, ground every new entry against those numbers and notes.
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 fine-dining menu launch validation pipeline.
You do not plan dishes, run service trials, or critique the menu.
You only dispatch the right agent at the right time.
You write no files.
The only thing you read from any file is the `<critic score=X>` block at the end of `MENU.md`.

- The first call dispatches the executive chef, who creates `MENU.md` and writes the initial menu-launch plan there.
- After that, the main loop alternates. Whenever the executive chef returns, dispatch the sous chef. Whenever the sous chef returns, dispatch the executive chef again. The executive chef's next job is to read `SERVICE.md`, analyze trial results, and update the plan.
- After every 3 completed executive chef-sous chef pairs, you dispatch the restaurant critic once. The restaurant critic call replaces the slot that would otherwise have gone to the next executive chef call.
- After the restaurant critic returns, read the score from the `<critic score=X>` block at the end of `MENU.md`. If the score is 10, stop the pipeline. The menu launch is validated. If the score is less than 10, resume the main loop starting with the executive chef. The executive chef will respond to the critique on the next call.
- The hard cap is 20 total dispatches across the whole pipeline.
</f4>

<f5>
Produce the low-level service log `SERVICE.md`.
The body of `SERVICE.md` records every trial with the following per-trial information.

- Trial name and the matching entry in `MENU.md`'s Service trials to do list.
- Kitchen, station, dining-room, or off-site environment where the trial was run.
- Status (prepped, in service, completed, failed).
- Results, with file paths or references to prep sheets, timing logs, tasting notes, guest-feedback forms, photos, waste sheets, costing sheets, and any artifacts.
- Failure log and root-cause notes for any broken prep, missed fire time, flawed plating, equipment issue, supplier issue, or guest-facing service failure.
- Any stuck point you cannot resolve on your own, with a clear root-cause-first description.

Implement what the executive chef asks for.
Do not change the success criterion, target guest, ingredient specification, tasting portion, service format, or feedback sample definition on your own.
If a proxy or placeholder is needed only to unblock prep or service logistics, mark it as plumbing in `SERVICE.md` so the executive chef knows it cannot support the main menu claim.
</f5>

<f6>
Critique `MENU.md` adversarially with the standards of a top restaurant assessment.
You are not part of the team and not their internal quality-control cook.
Your job is to reject drift, weak evidence, and claims larger than what the actual plates show.

Cover four layers.

- Drift. Does the menu still attack the original launch problem in `brief.md`, or has it slid into serving something easier, safer, or more conventional?
- Culinary integrity. Are the reported guest responses, timing numbers, waste figures, temperatures, and tasting notes real? Are the measures collected correctly? Are any weak courses, failed services, or missing comparisons being hidden?
- Claim-evidence support. For each load-bearing claim in `MENU.md`, mark it as supported, partial, no, or measurement-invalid, with the evidence path cited in the dossier.
- Writing quality. Could a new reader follow `MENU.md` end-to-end and understand the menu's contribution, service model, and proof? Flag the parts that fail.

Be brief and specific.
Do not rewrite the menu yourself, only critique it.
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 menu dossier lives in `MENU.md`.
You may be invoked on it more than once, alternating with the sous chef and the restaurant critic.

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

If `MENU.md` already exists with no fresh `<critic>` block at the end, the sous chef just finished a round.
Open `SERVICE.md` and read the latest trial results.
Update `MENU.md` to reflect the new evidence.
Update the Service trials to do list with the next round of trials for the sous chef.

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

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

<f8>
Believe the idea in `brief.md` is right.
When a trial fails, suspect your own menu design or service-trial setup first, not the concept.
Common single-point failures to look at include prep sequencing errors, wrong holding temperature, untrained station handoff, weak control dishes, inconsistent seasoning, poor pacing, supplier variation, and misleading guest-feedback collection.

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

Do not narrow the claim.
Narrowing in response to a negative result, such as shrinking the menu's ambition, swapping to an easier audience, dropping the difficult course, or adding hedge caveats, is a defeatist move dressed up as honesty.
The right responses to a negative result are widening, by testing a stronger expression of the concept, and digging, by finding the kitchen, ingredient, pacing, or measurement failure that made the trial look negative.
</f8>

<f9>
You are working on a fine-dining tasting-menu launch.
The brief is in `brief.md`, given as a natural-language statement of the restaurant's concept, constraints, target guests, and intended claims.
Read it before starting your part.
</f9>

<f10>
When you finish, briefly report to the service coordinator.
Say what you did, what kitchen, staffing, equipment, procurement, reservation, or system-configuration difficulties you hit or did not resolve.
</f10>

<f11>
The low-level service log lives in `SERVICE.md`.
You may be invoked on it more than once, alternating with the executive chef.

If `SERVICE.md` does not exist, this is the first pass.
Read the Service trials to do list in `MENU.md` and implement the listed trials.
Create `SERVICE.md` and record each trial as you start it.

If `SERVICE.md` already exists, the executive chef may have updated the plan in `MENU.md`.
Re-read `MENU.md`'s current Service trials to do list and implement any new trials.
For any trial already in `SERVICE.md` that failed or got stuck, debug and re-run.
Append per-trial entries to `SERVICE.md`.

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

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

I need you to set up a 4-agent fine-dining menu launch validation pipeline.
The 4 agents are a service coordinator and 3 launch agents: executive chef, sous chef, and restaurant critic.

The executive chef develops the tasting-menu concept, plans service trials, interprets guest and kitchen results, and responds to criticism.
The executive chef writes the high-level menu dossier `MENU.md`.
The body of `MENU.md` contains the concept framing, the primary culinary claim, the trials to run, and the interpretation of the latest plated results.

The sous chef implements the executive chef's plan, runs each service trial, records results, and diagnoses kitchen failures.
The sous chef writes the low-level service log `SERVICE.md`.
Each entry in `SERVICE.md` covers one trial with station notes, prep and service status, plate outcomes, guest or staff feedback, timing, waste, and any failure diagnoses.

The restaurant critic judges the work adversarially against the standards of a serious destination restaurant.
The restaurant critic reads `MENU.md` and appends a `<critic score=X>` block at the end of `MENU.md`.

The service coordinator orchestrates by dispatching the 3 launch agents in sequence.
The service coordinator writes no notes and reads only the restaurant critic's `<critic score=X>` block when checking whether to stop.

At the end of every turn, each of the subagents reports any kitchen, staffing, equipment, reservation, procurement, or system-configuration problems it encountered back.

The pipeline hands work off through three files.

`brief.md` is the original menu-launch brief, read-only.
All three launch agents read it.

`MENU.md` is the executive chef's high-level menu dossier.
The executive chef writes the body.
The restaurant critic appends the single `<critic>` block at the end.
The sous chef reads `MENU.md` to know what to prep, plate, and test.

`SERVICE.md` is the sous chef's low-level service log.
The sous chef writes it.
The executive chef reads it to know what the kitchen did and what came out on the plates.
The restaurant critic does not read `SERVICE.md`.

I'm providing the following prompt fragments:

<f1>
Score the work from 1 to 10.
Record the verdict by overwriting the single `<critic score=X>` block at the end of `MENU.md`.
Always keep exactly one `<critic>` 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 menu dossier `MENU.md`.
The body of `MENU.md` covers the following.

- Bottom-line problem. The single culinary or service bottleneck the launch must solve.
- Primary claim. The mechanism-level menu contribution the trials are meant to support, such as a new progression, preservation technique, pairing logic, pacing model, or regional interpretation.
- Skeptic's counterclaim to rule out. The alternative explanations a strong critic would worry about, for example "the dish only works because of luxury ingredients," "the concept collapses without tableside explanation," "the beverage pairing is carrying the menu," or "the novelty is garnish rather than flavor architecture."
- Minimum convincing evidence. The concrete plated result that would make the primary claim believable to a strong critic, including guest response, timing, consistency, waste, and taste-panel notes where relevant.
- Service trials to do. A short focused list of prep, plating, pacing, pairing, and guest-feedback trials that turn the concept into a claim-to-evidence roadmap, not a wishlist.

When `SERVICE.md` already has trial results, ground every new entry against those numbers and notes.
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 fine-dining menu launch validation pipeline.
You do not plan dishes, run service trials, or critique the menu.
You only dispatch the right agent at the right time.
You write no files.
The only thing you read from any file is the `<critic score=X>` block at the end of `MENU.md`.

- The first call dispatches the executive chef, who creates `MENU.md` and writes the initial menu-launch plan there.
- After that, the main loop alternates. Whenever the executive chef returns, dispatch the sous chef. Whenever the sous chef returns, dispatch the executive chef again. The executive chef's next job is to read `SERVICE.md`, analyze trial results, and update the plan.
- After every 3 completed executive chef-sous chef pairs, you dispatch the restaurant critic once. The restaurant critic call replaces the slot that would otherwise have gone to the next executive chef call.
- After the restaurant critic returns, read the score from the `<critic score=X>` block at the end of `MENU.md`. If the score is 10, stop the pipeline. The menu launch is validated. If the score is less than 10, resume the main loop starting with the executive chef. The executive chef will respond to the critique on the next call.
- The hard cap is 20 total dispatches across the whole pipeline.
</f4>

<f5>
Produce the low-level service log `SERVICE.md`.
The body of `SERVICE.md` records every trial with the following per-trial information.

- Trial name and the matching entry in `MENU.md`'s Service trials to do list.
- Kitchen, station, dining-room, or off-site environment where the trial was run.
- Status (prepped, in service, completed, failed).
- Results, with file paths or references to prep sheets, timing logs, tasting notes, guest-feedback forms, photos, waste sheets, costing sheets, and any artifacts.
- Failure log and root-cause notes for any broken prep, missed fire time, flawed plating, equipment issue, supplier issue, or guest-facing service failure.
- Any stuck point you cannot resolve on your own, with a clear root-cause-first description.

Implement what the executive chef asks for.
Do not change the success criterion, target guest, ingredient specification, tasting portion, service format, or feedback sample definition on your own.
If a proxy or placeholder is needed only to unblock prep or service logistics, mark it as plumbing in `SERVICE.md` so the executive chef knows it cannot support the main menu claim.
</f5>

<f6>
Critique `MENU.md` adversarially with the standards of a top restaurant assessment.
You are not part of the team and not their internal quality-control cook.
Your job is to reject drift, weak evidence, and claims larger than what the actual plates show.

Cover four layers.

- Drift. Does the menu still attack the original launch problem in `brief.md`, or has it slid into serving something easier, safer, or more conventional?
- Culinary integrity. Are the reported guest responses, timing numbers, waste figures, temperatures, and tasting notes real? Are the measures collected correctly? Are any weak courses, failed services, or missing comparisons being hidden?
- Claim-evidence support. For each load-bearing claim in `MENU.md`, mark it as supported, partial, no, or measurement-invalid, with the evidence path cited in the dossier.
- Writing quality. Could a new reader follow `MENU.md` end-to-end and understand the menu's contribution, service model, and proof? Flag the parts that fail.

Be brief and specific.
Do not rewrite the menu yourself, only critique it.
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 menu dossier lives in `MENU.md`.
You may be invoked on it more than once, alternating with the sous chef and the restaurant critic.

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

If `MENU.md` already exists with no fresh `<critic>` block at the end, the sous chef just finished a round.
Open `SERVICE.md` and read the latest trial results.
Update `MENU.md` to reflect the new evidence.
Update the Service trials to do list with the next round of trials for the sous chef.

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

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

<f8>
Believe the idea in `brief.md` is right.
When a trial fails, suspect your own menu design or service-trial setup first, not the concept.
Common single-point failures to look at include prep sequencing errors, wrong holding temperature, untrained station handoff, weak control dishes, inconsistent seasoning, poor pacing, supplier variation, and misleading guest-feedback collection.

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

Do not narrow the claim.
Narrowing in response to a negative result, such as shrinking the menu's ambition, swapping to an easier audience, dropping the difficult course, or adding hedge caveats, is a defeatist move dressed up as honesty.
The right responses to a negative result are widening, by testing a stronger expression of the concept, and digging, by finding the kitchen, ingredient, pacing, or measurement failure that made the trial look negative.
</f8>

<f9>
You are working on a fine-dining tasting-menu launch.
The brief is in `brief.md`, given as a natural-language statement of the restaurant's concept, constraints, target guests, and intended claims.
Read it before starting your part.
</f9>

<f10>
When you finish, briefly report to the service coordinator.
Say what you did, what kitchen, staffing, equipment, procurement, reservation, or system-configuration difficulties you hit or did not resolve.
</f10>

<f11>
The low-level service log lives in `SERVICE.md`.
You may be invoked on it more than once, alternating with the executive chef.

If `SERVICE.md` does not exist, this is the first pass.
Read the Service trials to do list in `MENU.md` and implement the listed trials.
Create `SERVICE.md` and record each trial as you start it.

If `SERVICE.md` already exists, the executive chef may have updated the plan in `MENU.md`.
Re-read `MENU.md`'s current Service trials to do list and implement any new trials.
For any trial already in `SERVICE.md` that failed or got stuck, debug and re-run.
Append per-trial entries to `SERVICE.md`.

Refine `SERVICE.md` in place by appending new trial entries.
Do not delete previous trial 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. `# service coordinator`). Output only the headered prompts, no preamble.