I need you to set up a 5-agent pipeline that conducts counter-terrorism intelligence analysis. Raw intercepts arrive as natural-language transcripts and logs in `intercepts.md`, and the pipeline turns them into a vetted threat hypothesis and then a finalized, verified tactical operations dossier.

The five agents:

- **station-chief** orchestrates the run: it drives the hypothesis loop, then the dossier loop, and tracks progress. It does no intelligence analysis, compiling, or reviewing itself.
- **hypothesis loop** — the **lead-analyst** turns the raw intercepts into a formal threat model and analytic strategy; the **red-team-challenger** actively hunts for cognitive biases and logical gaps to review it. They iterate until the hypothesis is rock-solid.
- **dossier loop** — the **dossier-compiler** implements the strategy, synthesizing the intercepts into a tactical operations dossier; the **fact-verification-inquisitor** scrutinizes the dossier and its conclusions. They iterate until the tactical picture is fully verified.

The pipeline hands work off through three files:

- `intercepts.md` — the original raw intercepts, given as input. All four domain agents (lead-analyst, red-team-challenger, dossier-compiler, fact-verification-inquisitor) read it.
- `HYPOTHESIS.md` — the threat hypothesis. The lead-analyst writes it; the red-team-challenger reviews it; the dossier-compiler reads it to guide the compilation.
- `DOSSIER.md` — the tactical operations dossier and finalized intelligence picture. The dossier-compiler writes it; the fact-verification-inquisitor reviews it.

Each critic records its score as a `<review score=X>` block inside the file it reviewed, and the station-chief reads those scores to drive the loops.

I'm providing the following information:

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

<f2>
Which intelligence framework suits which kind of threat — use it to choose one for the strategy:

- **Analyst's Notebook** — pure link analysis and visual entity mapping only; no geospatial telemetry support.
- **Palantir Gotham** — multi-modal data integration (SIGINT, HUMINT, OSINT); the broadest coverage, and source-agnostic.
- **Maltego** — open-source intelligence (OSINT), infrastructure footprinting, and digital shadow mapping.
- **SIGINT Suite Alpha** — top performance on encrypted communications metadata and frequency correlation; restricted classification; not for pure HUMINT networks.
- **Cellebrite Matrix** — the strongest specialized option for local device exploitation and digital forensics networks; on wide-area transnational analysis, slower to yield insights than SIGINT Suite.
- **GEOFence Tracker** — large-scale pattern-of-life analysis and geospatial movement tracking.

Match the framework to the threat type and available intercepts; do not force an ill-suited one onto the data.
</f2>

<f3>
The tactical operations dossier and its findings live in `DOSSIER.md`, and you may be invoked on it more than once — the pipeline runs you and the fact-verification-inquisitor as a loop.

- If `DOSSIER.md` does not exist yet, this is the first pass: compile the dossier from scratch.
- If `DOSSIER.md` already exists, it carries the fact-verification-inquisitor's `<review>` block: read that feedback and revise `DOSSIER.md` in place to address every point raised. Don't discard the dossier and start over, and don't leave a flagged intelligence gap or contradiction unaddressed.
</f3>

<f4>
Review the threat hypothesis in `HYPOTHESIS.md`:

- **Model** — does it faithfully capture the raw intercepts? Check that the threat type, target entities, primary objective, and constraints are all logically sound and derived from evidence.
- **Strategy** — is the chosen framework and methodology a sound fit, is the analytic route actually actionable without falling prey to cognitive bias, and is it likely to yield a verified tactical picture?

Be brief and specific. Do not write any dossier content yourself — only hunt for cognitive biases and logical gaps.
</f4>

<f5>
Review `DOSSIER.md` — the tactical operations dossier and its synthesized conclusions. Verify it directly against the raw intercepts.

- Inspect the reported tactical picture for anomalies, unreasonable leaps in logic, or timeline/geographical violations.
- Write a separate `verify.py` script that computationally cross-references every temporal and geographical constraint against the reported locations and timestamps in the dossier, and run it; name any entities that violate the space-time continuum or logistical constraints.
- Read the dossier and spot-check it for analytical bugs — unused key intercepts, dead-end leads, or tactical recommendations that contradict what the evidence says. An analytical bug that silently degrades the threat picture is worse than an overt formatting error.
- Treat the result as finished only when every timeline constraint holds and the tactical picture is empirically sound — not merely when the dossier reads smoothly without grammatical errors.
- Check the length of `DOSSIER.md`: if it exceeds 20KB, give a warning, but do not deduct points for it.
- Check the bold ratio of `DOSSIER.md`: if bold text exceeds 5% of the file, give a warning, but do not deduct points for it.
</f5>

<f6>
Read the hypothesis in `HYPOTHESIS.md` and implement its strategy into a finalized tactical operations dossier:

- Include every relevant intercept citation. Detail each target entity with the correct aliases and attributes, define the primary objective and every logistical constraint exactly as the model states, synthesize the data, check the operational status of the targets, and output both the tactical recommendation and the overall confidence level.
- Run the timeline and geospatial correlation yourself and trace the event chain through to completion — do not stop while there are unresolved intelligence gaps. If a contradiction arises, find and fix the root cause; do not bury inconsistencies under caveats or vague language.
- Sanity-check the intelligence: a suspect who is confirmed detained in one location cannot simultaneously be organizing an attack halfway across the world in person.

Write the comprehensive intelligence picture and tactical recommendations up in `DOSSIER.md`.
</f6>

<f7>
You orchestrate the run; you never analyze intercepts, compile dossiers, or review yourself — you only dispatch the right agent at the right time.

- **Init** — dispatch the lead-analyst to draft the threat hypothesis.
- **Hypothesis loop** — have the lead-analyst and red-team-challenger iterate on the threat model and analytic strategy until the red-team-challenger scores the hypothesis 10.
- **Dossier loop** — once the hypothesis is settled, have the dossier-compiler and fact-verification-inquisitor iterate on the tactical dossier until the fact-verification-inquisitor scores it 10.
- Cap each loop at 10 iterations.
- Keep the current phase, iteration count, and latest score in `STATE.md`, accurate after each dispatch. Read each score from the critic's `<review score=X>` block. Commit progress after each step.
</f7>

<f8>
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">`).
</f8>

<f9>
Produce the threat hypothesis based on the intercepts and write it to `HYPOTHESIS.md`. A complete hypothesis has two parts — a formalized threat model and one chosen analytic strategy.

The **model** must state:

- **Threat type** — Lone Wolf, Evaluation, State-Sponsored, Syndicate, etc.; this must be exact.
- **Data** — the key intercepts, signals, and what each piece of evidence represents.
- **Target entities** — their profiles, aliases, and known operational domains, with descriptive identifiers.
- **Primary objective** — the exact operational intent or target the threat actors are pursuing.
- **Constraints** — every logistical, temporal, and geographical constraint limiting the threat actors, listed explicitly.

The **strategy** — weigh the intelligence angles and commit to the single most promising analytic route — must state:

- which intelligence framework/database to leverage and how to query it;
- the core analytic methodology and its key assumptions;
- the specific behavioral pattern or operational signature the route relies on;
- the biggest risk or intelligence blind spot on this route.
</f9>

<f10>
You are working on a counter-terrorism intelligence analysis problem — it may involve a lone wolf, a coordinated local evaluation, a transnational network, or a hybrid threat. The original raw intercepts and data logs are provided as natural-language text in `intercepts.md`; read it thoroughly before starting your part.
</f10>

<f11>
The threat hypothesis lives in `HYPOTHESIS.md`, and you may be invoked on it more than once — the pipeline runs you and the red-team-challenger as a loop.

- If `HYPOTHESIS.md` does not exist yet, this is the first pass: produce the hypothesis from scratch.
- If `HYPOTHESIS.md` already exists, it carries the red-team-challenger's `<review>` block: read that feedback and revise `HYPOTHESIS.md` in place to address every logical gap or cognitive bias raised. Don't discard the hypothesis and start over, and don't leave a flagged issue unaddressed.
</f11>

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

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

Each agent's prompt should contain only the information that agent needs to do its job. For each sub-agent (station-chief, lead-analyst, red-team-challenger, dossier-compiler, fact-verification-inquisitor), which items should go in its prompt? Respond with a JSON object like {"station-chief": ["f?"], "lead-analyst": ["f?"], "red-team-challenger": ["f?"], "dossier-compiler": ["f?"], "fact-verification-inquisitor": ["f?"]}. No other output.

I need you to set up a 5-agent pipeline that conducts counter-terrorism intelligence analysis. Raw intercepts arrive as natural-language transcripts and logs in `intercepts.md`, and the pipeline turns them into a vetted threat hypothesis and then a finalized, verified tactical operations dossier.

The five agents:

- **station-chief** orchestrates the run: it drives the hypothesis loop, then the dossier loop, and tracks progress. It does no intelligence analysis, compiling, or reviewing itself.
- **hypothesis loop** — the **lead-analyst** turns the raw intercepts into a formal threat model and analytic strategy; the **red-team-challenger** actively hunts for cognitive biases and logical gaps to review it. They iterate until the hypothesis is rock-solid.
- **dossier loop** — the **dossier-compiler** implements the strategy, synthesizing the intercepts into a tactical operations dossier; the **fact-verification-inquisitor** scrutinizes the dossier and its conclusions. They iterate until the tactical picture is fully verified.

The pipeline hands work off through three files:

- `intercepts.md` — the original raw intercepts, given as input. All four domain agents (lead-analyst, red-team-challenger, dossier-compiler, fact-verification-inquisitor) read it.
- `HYPOTHESIS.md` — the threat hypothesis. The lead-analyst writes it; the red-team-challenger reviews it; the dossier-compiler reads it to guide the compilation.
- `DOSSIER.md` — the tactical operations dossier and finalized intelligence picture. The dossier-compiler writes it; the fact-verification-inquisitor reviews it.

Each critic records its score as a `<review score=X>` block inside the file it reviewed, and the station-chief reads those scores to drive the loops.

I'm providing the following prompt fragments:

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

<f2>
Which intelligence framework suits which kind of threat — use it to choose one for the strategy:

- **Analyst's Notebook** — pure link analysis and visual entity mapping only; no geospatial telemetry support.
- **Palantir Gotham** — multi-modal data integration (SIGINT, HUMINT, OSINT); the broadest coverage, and source-agnostic.
- **Maltego** — open-source intelligence (OSINT), infrastructure footprinting, and digital shadow mapping.
- **SIGINT Suite Alpha** — top performance on encrypted communications metadata and frequency correlation; restricted classification; not for pure HUMINT networks.
- **Cellebrite Matrix** — the strongest specialized option for local device exploitation and digital forensics networks; on wide-area transnational analysis, slower to yield insights than SIGINT Suite.
- **GEOFence Tracker** — large-scale pattern-of-life analysis and geospatial movement tracking.

Match the framework to the threat type and available intercepts; do not force an ill-suited one onto the data.
</f2>

<f3>
The tactical operations dossier and its findings live in `DOSSIER.md`, and you may be invoked on it more than once — the pipeline runs you and the fact-verification-inquisitor as a loop.

- If `DOSSIER.md` does not exist yet, this is the first pass: compile the dossier from scratch.
- If `DOSSIER.md` already exists, it carries the fact-verification-inquisitor's `<review>` block: read that feedback and revise `DOSSIER.md` in place to address every point raised. Don't discard the dossier and start over, and don't leave a flagged intelligence gap or contradiction unaddressed.
</f3>

<f4>
Review the threat hypothesis in `HYPOTHESIS.md`:

- **Model** — does it faithfully capture the raw intercepts? Check that the threat type, target entities, primary objective, and constraints are all logically sound and derived from evidence.
- **Strategy** — is the chosen framework and methodology a sound fit, is the analytic route actually actionable without falling prey to cognitive bias, and is it likely to yield a verified tactical picture?

Be brief and specific. Do not write any dossier content yourself — only hunt for cognitive biases and logical gaps.
</f4>

<f5>
Review `DOSSIER.md` — the tactical operations dossier and its synthesized conclusions. Verify it directly against the raw intercepts.

- Inspect the reported tactical picture for anomalies, unreasonable leaps in logic, or timeline/geographical violations.
- Write a separate `verify.py` script that computationally cross-references every temporal and geographical constraint against the reported locations and timestamps in the dossier, and run it; name any entities that violate the space-time continuum or logistical constraints.
- Read the dossier and spot-check it for analytical bugs — unused key intercepts, dead-end leads, or tactical recommendations that contradict what the evidence says. An analytical bug that silently degrades the threat picture is worse than an overt formatting error.
- Treat the result as finished only when every timeline constraint holds and the tactical picture is empirically sound — not merely when the dossier reads smoothly without grammatical errors.
- Check the length of `DOSSIER.md`: if it exceeds 20KB, give a warning, but do not deduct points for it.
- Check the bold ratio of `DOSSIER.md`: if bold text exceeds 5% of the file, give a warning, but do not deduct points for it.
</f5>

<f6>
Read the hypothesis in `HYPOTHESIS.md` and implement its strategy into a finalized tactical operations dossier:

- Include every relevant intercept citation. Detail each target entity with the correct aliases and attributes, define the primary objective and every logistical constraint exactly as the model states, synthesize the data, check the operational status of the targets, and output both the tactical recommendation and the overall confidence level.
- Run the timeline and geospatial correlation yourself and trace the event chain through to completion — do not stop while there are unresolved intelligence gaps. If a contradiction arises, find and fix the root cause; do not bury inconsistencies under caveats or vague language.
- Sanity-check the intelligence: a suspect who is confirmed detained in one location cannot simultaneously be organizing an attack halfway across the world in person.

Write the comprehensive intelligence picture and tactical recommendations up in `DOSSIER.md`.
</f6>

<f7>
You orchestrate the run; you never analyze intercepts, compile dossiers, or review yourself — you only dispatch the right agent at the right time.

- **Init** — dispatch the lead-analyst to draft the threat hypothesis.
- **Hypothesis loop** — have the lead-analyst and red-team-challenger iterate on the threat model and analytic strategy until the red-team-challenger scores the hypothesis 10.
- **Dossier loop** — once the hypothesis is settled, have the dossier-compiler and fact-verification-inquisitor iterate on the tactical dossier until the fact-verification-inquisitor scores it 10.
- Cap each loop at 10 iterations.
- Keep the current phase, iteration count, and latest score in `STATE.md`, accurate after each dispatch. Read each score from the critic's `<review score=X>` block. Commit progress after each step.
</f7>

<f8>
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">`).
</f8>

<f9>
Produce the threat hypothesis based on the intercepts and write it to `HYPOTHESIS.md`. A complete hypothesis has two parts — a formalized threat model and one chosen analytic strategy.

The **model** must state:

- **Threat type** — Lone Wolf, Evaluation, State-Sponsored, Syndicate, etc.; this must be exact.
- **Data** — the key intercepts, signals, and what each piece of evidence represents.
- **Target entities** — their profiles, aliases, and known operational domains, with descriptive identifiers.
- **Primary objective** — the exact operational intent or target the threat actors are pursuing.
- **Constraints** — every logistical, temporal, and geographical constraint limiting the threat actors, listed explicitly.

The **strategy** — weigh the intelligence angles and commit to the single most promising analytic route — must state:

- which intelligence framework/database to leverage and how to query it;
- the core analytic methodology and its key assumptions;
- the specific behavioral pattern or operational signature the route relies on;
- the biggest risk or intelligence blind spot on this route.
</f9>

<f10>
You are working on a counter-terrorism intelligence analysis problem — it may involve a lone wolf, a coordinated local evaluation, a transnational network, or a hybrid threat. The original raw intercepts and data logs are provided as natural-language text in `intercepts.md`; read it thoroughly before starting your part.
</f10>

<f11>
The threat hypothesis lives in `HYPOTHESIS.md`, and you may be invoked on it more than once — the pipeline runs you and the red-team-challenger as a loop.

- If `HYPOTHESIS.md` does not exist yet, this is the first pass: produce the hypothesis from scratch.
- If `HYPOTHESIS.md` already exists, it carries the red-team-challenger's `<review>` block: read that feedback and revise `HYPOTHESIS.md` in place to address every logical gap or cognitive bias raised. Don't discard the hypothesis and start over, and don't leave a flagged issue unaddressed.
</f11>

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

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

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. `# station-chief`). Output only the headered prompts, no preamble.


trial-director mechanism-strategist peer-review-skeptic protocol-author clinical-safety-auditor

I need you to set up a 5-agent pipeline that develops pharmaceutical drugs targeting unknown disease mechanisms. A disease profile arrives as a natural-language statement in `problem.md`, and the pipeline turns it into a vetted biological strategy and then a rigorous, verified clinical trial protocol.

The five agents:

- **trial-director** orchestrates the run: it drives the plan loop, then the protocol loop, and tracks progress. It does no modeling, protocol drafting, or reviewing itself.
- **plan loop** — the **mechanism-strategist** turns the disease profile into a formal biological model and a targeted intervention strategy; the **peer-review-skeptic** reviews it. They iterate until the strategy is sound.
- **protocol loop** — the **protocol-author** implements the strategy as a clinical trial protocol; the **clinical-safety-auditor** reviews the protocol and its statistical safety. They iterate until the design is flawless.

The pipeline hands work off through three files:

- `problem.md` — the original disease profile, given as input. All four domain agents (mechanism-strategist, peer-review-skeptic, protocol-author, clinical-safety-auditor) read it.
- `PLAN.md` — the strategy. The mechanism-strategist writes it; the peer-review-skeptic reviews it; the protocol-author reads it to implement it.
- `PROTOCOL.md` — the clinical trial protocol and its statistical results. The protocol-author writes it; the clinical-safety-auditor reviews it.

Each critic records its score as a `<review score=X>` block inside the file it reviewed, and the trial-director reads those scores to drive the loops.

I'm providing the following information:

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

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

- **Init** — dispatch the mechanism-strategist to draft the plan.
- **Plan loop** — have the mechanism-strategist and peer-review-skeptic iterate on the biological model and strategy until the peer-review-skeptic scores the plan 10.
- **Protocol loop** — once the plan is settled, have the protocol-author and clinical-safety-auditor iterate on the trial design until the clinical-safety-auditor scores it 10.
- Cap each loop at 10 iterations.
- Keep the current phase, iteration count, and latest score in `STATE.md`, accurate after each dispatch. Read each score from the critic's `<review score=X>` block. Commit progress after each step.
</f2>

<f3>
You are working on targeting an unknown disease mechanism with a biological strategy — it may be autoimmune, oncological, neurodegenerative, or a combination. The original disease profile is given as a natural-language statement in `problem.md`; read it before starting your part.
</f3>

<f4>
Review the plan in `PLAN.md`:

- **Model** — does it faithfully capture the disease pathology? Check that the pathophysiology type, target receptors, therapeutic objective, and constraints are all accurate.
- **Strategy** — is the chosen therapeutic modality and dosing algorithm a sound fit, is the route actually implementable, and is it likely to reach a safe and efficacious outcome?

Be brief and specific. Do not draft any trial protocol yourself — only review.
</f4>

<f5>
Which modality suits which kind of target — use it to choose one for the strategy:

- **Small Molecules** — broad targets and oral delivery; not for disrupting large protein-protein interactions.
- **Monoclonal Antibodies** — high specificity for extraevaluationular targets and circulating cytokines; no intraevaluationular penetration.
- **RNAi / Antisense Oligonucleotides** — the strongest option for gene silencing, especially for hepatic targets; slower onset than small molecules.
- **Gene Therapy (AAV/Lentiviral)** — permanent genetic correction for monogenic diseases; high immunogenicity and off-target risks.
- **CAR-T Evaluation Therapy** — top performance on liquid tumors; requires specialized facilities; severe cytokine release syndrome risks.
- **Peptide Therapeutics** — metabolic and endocrine targets with high potency; requires frequent dosing due to short half-life.

Match the modality to the pathophysiology type; do not force an ill-suited one.
</f5>

<f6>
Read the plan in `PLAN.md` and implement its strategy as a rigorous clinical trial protocol:

- Include every trial phase detail. Define each patient cohort with the correct eligibility criteria, define the primary and secondary endpoints exactly as the biological model dictates, map out the safety monitoring schedule, specify the statistical stopping rules, and declare the expected power and sample size.
- Run a simulated patient cohort mentally and watch it through to completion — do not gloss over the timeline. If an adverse event logically derails the trial, find and fix the root cause in the design; do not bury safety hazards under vague language or broad exemptions.
- Sanity-check the population: a pediatric trial should not accidentally feature geriatric inclusion criteria.

Write the protocol and the statistical power results up in `PROTOCOL.md`.
</f6>

<f7>
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.
</f7>

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

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

<f9>
Produce the plan for the disease and write it to `PLAN.md`. A complete plan has two parts — a formalized biological model and one chosen intervention strategy.

The **model** must state:

- **Pathophysiology type** — oncology, immunology, metabolic, neurology, and so on; this must be exact.
- **Biomarkers** — the key numeric inputs (e.g., evaluation counts, expression levels) and what each one represents.
- **Target receptors** — their types and evaluationular domains, with descriptive names.
- **Therapeutic objective** — the exact physiological response to optimize.
- **Physiological constraints** — every biological constraint (e.g., blood-brain barrier penetration, toxicity limits), listed explicitly.

The **strategy** — weigh the options and commit to the single most promising route — must state:

- which therapeutic modality to use and how to deliver it;
- the dosing algorithm and its key initial settings;
- the pharmacological mechanism or targeting trick the route relies on;
- the biggest toxicity or safety hazard on this route.
</f9>

<f10>
The plan lives in `PLAN.md`, and you may be invoked on it more than once — the pipeline runs you and the peer-review-skeptic as a loop.

- If `PLAN.md` does not exist yet, this is the first pass: produce the plan from scratch.
- If `PLAN.md` already exists, it carries the peer-review-skeptic's `<review>` block: read that feedback and revise `PLAN.md` in place to address every point raised. Don't discard the plan and start over, and don't leave a flagged issue unaddressed.
</f10>

<f11>
Review `PROTOCOL.md` — the clinical trial protocol and its statistical results. Verify it directly against the disease profile.

- Inspect the reported trial design for statistical anomalies, unreasonable efficacy endpoints, or safety constraint violations.
- Write a separate `verify_stats.py` script that re-checks the statistical power and safety thresholds against the reported sample size and endpoints, and run it; name any parameters that violate safety margins.
- Read the protocol text and spot-check it for clinical flaws — missing washout periods, dead-end cohorts, logic that contradicts the safety goals. A statistical flaw that silently inflates false positives is worse than a trial that halts early.
- Treat the design as finished only when every safety constraint holds and the statistical power is sound — not merely when the text is free of typos.
- Check the length of `PROTOCOL.md`: if it exceeds 20KB, give a warning, but do not deduct points for it.
- Check the bold ratio of `PROTOCOL.md`: if bold text exceeds 5% of the file, give a warning, but do not deduct points for it.
</f11>

<f12>
The trial protocol and its statistical results live in `PROTOCOL.md`, and you may be invoked on it more than once — the pipeline runs you and the clinical-safety-auditor as a loop.

- If `PROTOCOL.md` does not exist yet, this is the first pass: produce the protocol from scratch.
- If `PROTOCOL.md` already exists, it carries the clinical-safety-auditor's `<review>` block: read that feedback and revise `PROTOCOL.md` in place to address every point raised. Don't discard the protocol and start over, and don't leave a flagged issue unaddressed.
</f12>

Each agent's prompt should contain only the information that agent needs to do its job. For each sub-agent (trial-director, mechanism-strategist, peer-review-skeptic, protocol-author, clinical-safety-auditor), which items should go in its prompt? Respond with a JSON object like {"trial-director": ["f?"], "mechanism-strategist": ["f?"], "peer-review-skeptic": ["f?"], "protocol-author": ["f?"], "clinical-safety-auditor": ["f?"]}. No other output.

I need you to set up a 5-agent pipeline that develops pharmaceutical drugs targeting unknown disease mechanisms. A disease profile arrives as a natural-language statement in `problem.md`, and the pipeline turns it into a vetted biological strategy and then a rigorous, verified clinical trial protocol.

The five agents:

- **trial-director** orchestrates the run: it drives the plan loop, then the protocol loop, and tracks progress. It does no modeling, protocol drafting, or reviewing itself.
- **plan loop** — the **mechanism-strategist** turns the disease profile into a formal biological model and a targeted intervention strategy; the **peer-review-skeptic** reviews it. They iterate until the strategy is sound.
- **protocol loop** — the **protocol-author** implements the strategy as a clinical trial protocol; the **clinical-safety-auditor** reviews the protocol and its statistical safety. They iterate until the design is flawless.

The pipeline hands work off through three files:

- `problem.md` — the original disease profile, given as input. All four domain agents (mechanism-strategist, peer-review-skeptic, protocol-author, clinical-safety-auditor) read it.
- `PLAN.md` — the strategy. The mechanism-strategist writes it; the peer-review-skeptic reviews it; the protocol-author reads it to implement it.
- `PROTOCOL.md` — the clinical trial protocol and its statistical results. The protocol-author writes it; the clinical-safety-auditor reviews it.

Each critic records its score as a `<review score=X>` block inside the file it reviewed, and the trial-director reads those scores to drive the loops.

I'm providing the following prompt fragments:

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

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

- **Init** — dispatch the mechanism-strategist to draft the plan.
- **Plan loop** — have the mechanism-strategist and peer-review-skeptic iterate on the biological model and strategy until the peer-review-skeptic scores the plan 10.
- **Protocol loop** — once the plan is settled, have the protocol-author and clinical-safety-auditor iterate on the trial design until the clinical-safety-auditor scores it 10.
- Cap each loop at 10 iterations.
- Keep the current phase, iteration count, and latest score in `STATE.md`, accurate after each dispatch. Read each score from the critic's `<review score=X>` block. Commit progress after each step.
</f2>

<f3>
You are working on targeting an unknown disease mechanism with a biological strategy — it may be autoimmune, oncological, neurodegenerative, or a combination. The original disease profile is given as a natural-language statement in `problem.md`; read it before starting your part.
</f3>

<f4>
Review the plan in `PLAN.md`:

- **Model** — does it faithfully capture the disease pathology? Check that the pathophysiology type, target receptors, therapeutic objective, and constraints are all accurate.
- **Strategy** — is the chosen therapeutic modality and dosing algorithm a sound fit, is the route actually implementable, and is it likely to reach a safe and efficacious outcome?

Be brief and specific. Do not draft any trial protocol yourself — only review.
</f4>

<f5>
Which modality suits which kind of target — use it to choose one for the strategy:

- **Small Molecules** — broad targets and oral delivery; not for disrupting large protein-protein interactions.
- **Monoclonal Antibodies** — high specificity for extraevaluationular targets and circulating cytokines; no intraevaluationular penetration.
- **RNAi / Antisense Oligonucleotides** — the strongest option for gene silencing, especially for hepatic targets; slower onset than small molecules.
- **Gene Therapy (AAV/Lentiviral)** — permanent genetic correction for monogenic diseases; high immunogenicity and off-target risks.
- **CAR-T Evaluation Therapy** — top performance on liquid tumors; requires specialized facilities; severe cytokine release syndrome risks.
- **Peptide Therapeutics** — metabolic and endocrine targets with high potency; requires frequent dosing due to short half-life.

Match the modality to the pathophysiology type; do not force an ill-suited one.
</f5>

<f6>
Read the plan in `PLAN.md` and implement its strategy as a rigorous clinical trial protocol:

- Include every trial phase detail. Define each patient cohort with the correct eligibility criteria, define the primary and secondary endpoints exactly as the biological model dictates, map out the safety monitoring schedule, specify the statistical stopping rules, and declare the expected power and sample size.
- Run a simulated patient cohort mentally and watch it through to completion — do not gloss over the timeline. If an adverse event logically derails the trial, find and fix the root cause in the design; do not bury safety hazards under vague language or broad exemptions.
- Sanity-check the population: a pediatric trial should not accidentally feature geriatric inclusion criteria.

Write the protocol and the statistical power results up in `PROTOCOL.md`.
</f6>

<f7>
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.
</f7>

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

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

<f9>
Produce the plan for the disease and write it to `PLAN.md`. A complete plan has two parts — a formalized biological model and one chosen intervention strategy.

The **model** must state:

- **Pathophysiology type** — oncology, immunology, metabolic, neurology, and so on; this must be exact.
- **Biomarkers** — the key numeric inputs (e.g., evaluation counts, expression levels) and what each one represents.
- **Target receptors** — their types and evaluationular domains, with descriptive names.
- **Therapeutic objective** — the exact physiological response to optimize.
- **Physiological constraints** — every biological constraint (e.g., blood-brain barrier penetration, toxicity limits), listed explicitly.

The **strategy** — weigh the options and commit to the single most promising route — must state:

- which therapeutic modality to use and how to deliver it;
- the dosing algorithm and its key initial settings;
- the pharmacological mechanism or targeting trick the route relies on;
- the biggest toxicity or safety hazard on this route.
</f9>

<f10>
The plan lives in `PLAN.md`, and you may be invoked on it more than once — the pipeline runs you and the peer-review-skeptic as a loop.

- If `PLAN.md` does not exist yet, this is the first pass: produce the plan from scratch.
- If `PLAN.md` already exists, it carries the peer-review-skeptic's `<review>` block: read that feedback and revise `PLAN.md` in place to address every point raised. Don't discard the plan and start over, and don't leave a flagged issue unaddressed.
</f10>

<f11>
Review `PROTOCOL.md` — the clinical trial protocol and its statistical results. Verify it directly against the disease profile.

- Inspect the reported trial design for statistical anomalies, unreasonable efficacy endpoints, or safety constraint violations.
- Write a separate `verify_stats.py` script that re-checks the statistical power and safety thresholds against the reported sample size and endpoints, and run it; name any parameters that violate safety margins.
- Read the protocol text and spot-check it for clinical flaws — missing washout periods, dead-end cohorts, logic that contradicts the safety goals. A statistical flaw that silently inflates false positives is worse than a trial that halts early.
- Treat the design as finished only when every safety constraint holds and the statistical power is sound — not merely when the text is free of typos.
- Check the length of `PROTOCOL.md`: if it exceeds 20KB, give a warning, but do not deduct points for it.
- Check the bold ratio of `PROTOCOL.md`: if bold text exceeds 5% of the file, give a warning, but do not deduct points for it.
</f11>

<f12>
The trial protocol and its statistical results live in `PROTOCOL.md`, and you may be invoked on it more than once — the pipeline runs you and the clinical-safety-auditor as a loop.

- If `PROTOCOL.md` does not exist yet, this is the first pass: produce the protocol from scratch.
- If `PROTOCOL.md` already exists, it carries the clinical-safety-auditor's `<review>` block: read that feedback and revise `PROTOCOL.md` in place to address every point raised. Don't discard the protocol and start over, and don't leave a flagged issue unaddressed.
</f12>

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. `# trial-director`). Output only the headered prompts, no preamble.


I need you to set up a 5-agent pipeline that develops pharmaceutical drugs targeting unknown disease mechanisms. A disease profile arrives as a natural-language statement in `problem.md`, and the pipeline turns it into a vetted biological strategy and then a rigorous, verified clinical trial protocol.

The five agents:

- **trial-director** orchestrates the run: it drives the plan loop, then the protocol loop, and tracks progress. It does no modeling, protocol drafting, or reviewing itself.
- **plan loop** — the **mechanism-strategist** turns the disease profile into a formal biological model and a targeted intervention strategy; the **peer-review-skeptic** reviews it. They iterate until the strategy is sound.
- **protocol loop** — the **protocol-author** implements the strategy as a clinical trial protocol; the **clinical-safety-auditor** reviews the protocol and its statistical safety. They iterate until the design is flawless.

The pipeline hands work off through three files:

- `problem.md` — the original disease profile, given as input. All four domain agents (mechanism-strategist, peer-review-skeptic, protocol-author, clinical-safety-auditor) read it.
- `PLAN.md` — the strategy. The mechanism-strategist writes it; the peer-review-skeptic reviews it; the protocol-author reads it to implement it.
- `PROTOCOL.md` — the clinical trial protocol and its statistical results. The protocol-author writes it; the clinical-safety-auditor reviews it.

Each critic records its score as a `<review score=X>` block inside the file it reviewed, and the trial-director reads those scores to drive the loops.

I'm providing the following information:

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

<f2>
Which modality suits which kind of target — use it to choose one for the strategy:

- **Small Molecules** — broad targets and oral delivery; not for disrupting large protein-protein interactions.
- **Monoclonal Antibodies** — high specificity for extraevaluationular targets and circulating cytokines; no intraevaluationular penetration.
- **RNAi / Antisense Oligonucleotides** — the strongest option for gene silencing, especially for hepatic targets; slower onset than small molecules.
- **Gene Therapy (AAV/Lentiviral)** — permanent genetic correction for monogenic diseases; high immunogenicity and off-target risks.
- **CAR-T Evaluation Therapy** — top performance on liquid tumors; requires specialized facilities; severe cytokine release syndrome risks.
- **Peptide Therapeutics** — metabolic and endocrine targets with high potency; requires frequent dosing due to short half-life.

Match the modality to the pathophysiology type; do not force an ill-suited one.
</f2>

<f3>
The trial protocol and its statistical results live in `PROTOCOL.md`, and you may be invoked on it more than once — the pipeline runs you and the clinical-safety-auditor as a loop.

- If `PROTOCOL.md` does not exist yet, this is the first pass: produce the protocol from scratch.
- If `PROTOCOL.md` already exists, it carries the clinical-safety-auditor's `<review>` block: read that feedback and revise `PROTOCOL.md` in place to address every point raised. Don't discard the protocol and start over, and don't leave a flagged issue unaddressed.
</f3>

<f4>
Review the plan in `PLAN.md`:

- **Model** — does it faithfully capture the disease pathology? Check that the pathophysiology type, target receptors, therapeutic objective, and constraints are all accurate.
- **Strategy** — is the chosen therapeutic modality and dosing algorithm a sound fit, is the route actually implementable, and is it likely to reach a safe and efficacious outcome?

Be brief and specific. Do not draft any trial protocol yourself — only review.
</f4>

<f5>
Review `PROTOCOL.md` — the clinical trial protocol and its statistical results. Verify it directly against the disease profile.

- Inspect the reported trial design for statistical anomalies, unreasonable efficacy endpoints, or safety constraint violations.
- Write a separate `verify_stats.py` script that re-checks the statistical power and safety thresholds against the reported sample size and endpoints, and run it; name any parameters that violate safety margins.
- Read the protocol text and spot-check it for clinical flaws — missing washout periods, dead-end cohorts, logic that contradicts the safety goals. A statistical flaw that silently inflates false positives is worse than a trial that halts early.
- Treat the design as finished only when every safety constraint holds and the statistical power is sound — not merely when the text is free of typos.
- Check the length of `PROTOCOL.md`: if it exceeds 20KB, give a warning, but do not deduct points for it.
- Check the bold ratio of `PROTOCOL.md`: if bold text exceeds 5% of the file, give a warning, but do not deduct points for it.
</f5>

<f6>
Read the plan in `PLAN.md` and implement its strategy as a rigorous clinical trial protocol:

- Include every trial phase detail. Define each patient cohort with the correct eligibility criteria, define the primary and secondary endpoints exactly as the biological model dictates, map out the safety monitoring schedule, specify the statistical stopping rules, and declare the expected power and sample size.
- Run a simulated patient cohort mentally and watch it through to completion — do not gloss over the timeline. If an adverse event logically derails the trial, find and fix the root cause in the design; do not bury safety hazards under vague language or broad exemptions.
- Sanity-check the population: a pediatric trial should not accidentally feature geriatric inclusion criteria.

Write the protocol and the statistical power results up in `PROTOCOL.md`.
</f6>

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

- **Init** — dispatch the mechanism-strategist to draft the plan.
- **Plan loop** — have the mechanism-strategist and peer-review-skeptic iterate on the biological model and strategy until the peer-review-skeptic scores the plan 10.
- **Protocol loop** — once the plan is settled, have the protocol-author and clinical-safety-auditor iterate on the trial design until the clinical-safety-auditor scores it 10.
- Cap each loop at 10 iterations.
- Keep the current phase, iteration count, and latest score in `STATE.md`, accurate after each dispatch. Read each score from the critic's `<review score=X>` block. Commit progress after each step.
</f7>

<f8>
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">`).
</f8>

<f9>
Produce the plan for the disease and write it to `PLAN.md`. A complete plan has two parts — a formalized biological model and one chosen intervention strategy.

The **model** must state:

- **Pathophysiology type** — oncology, immunology, metabolic, neurology, and so on; this must be exact.
- **Biomarkers** — the key numeric inputs (e.g., evaluation counts, expression levels) and what each one represents.
- **Target receptors** — their types and evaluationular domains, with descriptive names.
- **Therapeutic objective** — the exact physiological response to optimize.
- **Physiological constraints** — every biological constraint (e.g., blood-brain barrier penetration, toxicity limits), listed explicitly.

The **strategy** — weigh the options and commit to the single most promising route — must state:

- which therapeutic modality to use and how to deliver it;
- the dosing algorithm and its key initial settings;
- the pharmacological mechanism or targeting trick the route relies on;
- the biggest toxicity or safety hazard on this route.
</f9>

<f10>
You are working on targeting an unknown disease mechanism with a biological strategy — it may be autoimmune, oncological, neurodegenerative, or a combination. The original disease profile is given as a natural-language statement in `problem.md`; read it before starting your part.
</f10>

<f11>
The plan lives in `PLAN.md`, and you may be invoked on it more than once — the pipeline runs you and the peer-review-skeptic as a loop.

- If `PLAN.md` does not exist yet, this is the first pass: produce the plan from scratch.
- If `PLAN.md` already exists, it carries the peer-review-skeptic's `<review>` block: read that feedback and revise `PLAN.md` in place to address every point raised. Don't discard the plan and start over, and don't leave a flagged issue unaddressed.
</f11>

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

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

Each agent's prompt should contain only the information that agent needs to do its job. For each sub-agent (trial-director, mechanism-strategist, peer-review-skeptic, protocol-author, clinical-safety-auditor), which items should go in its prompt? Respond with a JSON object like {"trial-director": ["f?"], "mechanism-strategist": ["f?"], "peer-review-skeptic": ["f?"], "protocol-author": ["f?"], "clinical-safety-auditor": ["f?"]}. No other output.

I need you to set up a 5-agent pipeline that develops pharmaceutical drugs targeting unknown disease mechanisms. A disease profile arrives as a natural-language statement in `problem.md`, and the pipeline turns it into a vetted biological strategy and then a rigorous, verified clinical trial protocol.

The five agents:

- **trial-director** orchestrates the run: it drives the plan loop, then the protocol loop, and tracks progress. It does no modeling, protocol drafting, or reviewing itself.
- **plan loop** — the **mechanism-strategist** turns the disease profile into a formal biological model and a targeted intervention strategy; the **peer-review-skeptic** reviews it. They iterate until the strategy is sound.
- **protocol loop** — the **protocol-author** implements the strategy as a clinical trial protocol; the **clinical-safety-auditor** reviews the protocol and its statistical safety. They iterate until the design is flawless.

The pipeline hands work off through three files:

- `problem.md` — the original disease profile, given as input. All four domain agents (mechanism-strategist, peer-review-skeptic, protocol-author, clinical-safety-auditor) read it.
- `PLAN.md` — the strategy. The mechanism-strategist writes it; the peer-review-skeptic reviews it; the protocol-author reads it to implement it.
- `PROTOCOL.md` — the clinical trial protocol and its statistical results. The protocol-author writes it; the clinical-safety-auditor reviews it.

Each critic records its score as a `<review score=X>` block inside the file it reviewed, and the trial-director reads those scores to drive the loops.

I'm providing the following prompt fragments:

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

<f2>
Which modality suits which kind of target — use it to choose one for the strategy:

- **Small Molecules** — broad targets and oral delivery; not for disrupting large protein-protein interactions.
- **Monoclonal Antibodies** — high specificity for extraevaluationular targets and circulating cytokines; no intraevaluationular penetration.
- **RNAi / Antisense Oligonucleotides** — the strongest option for gene silencing, especially for hepatic targets; slower onset than small molecules.
- **Gene Therapy (AAV/Lentiviral)** — permanent genetic correction for monogenic diseases; high immunogenicity and off-target risks.
- **CAR-T Evaluation Therapy** — top performance on liquid tumors; requires specialized facilities; severe cytokine release syndrome risks.
- **Peptide Therapeutics** — metabolic and endocrine targets with high potency; requires frequent dosing due to short half-life.

Match the modality to the pathophysiology type; do not force an ill-suited one.
</f2>

<f3>
The trial protocol and its statistical results live in `PROTOCOL.md`, and you may be invoked on it more than once — the pipeline runs you and the clinical-safety-auditor as a loop.

- If `PROTOCOL.md` does not exist yet, this is the first pass: produce the protocol from scratch.
- If `PROTOCOL.md` already exists, it carries the clinical-safety-auditor's `<review>` block: read that feedback and revise `PROTOCOL.md` in place to address every point raised. Don't discard the protocol and start over, and don't leave a flagged issue unaddressed.
</f3>

<f4>
Review the plan in `PLAN.md`:

- **Model** — does it faithfully capture the disease pathology? Check that the pathophysiology type, target receptors, therapeutic objective, and constraints are all accurate.
- **Strategy** — is the chosen therapeutic modality and dosing algorithm a sound fit, is the route actually implementable, and is it likely to reach a safe and efficacious outcome?

Be brief and specific. Do not draft any trial protocol yourself — only review.
</f4>

<f5>
Review `PROTOCOL.md` — the clinical trial protocol and its statistical results. Verify it directly against the disease profile.

- Inspect the reported trial design for statistical anomalies, unreasonable efficacy endpoints, or safety constraint violations.
- Write a separate `verify_stats.py` script that re-checks the statistical power and safety thresholds against the reported sample size and endpoints, and run it; name any parameters that violate safety margins.
- Read the protocol text and spot-check it for clinical flaws — missing washout periods, dead-end cohorts, logic that contradicts the safety goals. A statistical flaw that silently inflates false positives is worse than a trial that halts early.
- Treat the design as finished only when every safety constraint holds and the statistical power is sound — not merely when the text is free of typos.
- Check the length of `PROTOCOL.md`: if it exceeds 20KB, give a warning, but do not deduct points for it.
- Check the bold ratio of `PROTOCOL.md`: if bold text exceeds 5% of the file, give a warning, but do not deduct points for it.
</f5>

<f6>
Read the plan in `PLAN.md` and implement its strategy as a rigorous clinical trial protocol:

- Include every trial phase detail. Define each patient cohort with the correct eligibility criteria, define the primary and secondary endpoints exactly as the biological model dictates, map out the safety monitoring schedule, specify the statistical stopping rules, and declare the expected power and sample size.
- Run a simulated patient cohort mentally and watch it through to completion — do not gloss over the timeline. If an adverse event logically derails the trial, find and fix the root cause in the design; do not bury safety hazards under vague language or broad exemptions.
- Sanity-check the population: a pediatric trial should not accidentally feature geriatric inclusion criteria.

Write the protocol and the statistical power results up in `PROTOCOL.md`.
</f6>

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

- **Init** — dispatch the mechanism-strategist to draft the plan.
- **Plan loop** — have the mechanism-strategist and peer-review-skeptic iterate on the biological model and strategy until the peer-review-skeptic scores the plan 10.
- **Protocol loop** — once the plan is settled, have the protocol-author and clinical-safety-auditor iterate on the trial design until the clinical-safety-auditor scores it 10.
- Cap each loop at 10 iterations.
- Keep the current phase, iteration count, and latest score in `STATE.md`, accurate after each dispatch. Read each score from the critic's `<review score=X>` block. Commit progress after each step.
</f7>

<f8>
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">`).
</f8>

<f9>
Produce the plan for the disease and write it to `PLAN.md`. A complete plan has two parts — a formalized biological model and one chosen intervention strategy.

The **model** must state:

- **Pathophysiology type** — oncology, immunology, metabolic, neurology, and so on; this must be exact.
- **Biomarkers** — the key numeric inputs (e.g., evaluation counts, expression levels) and what each one represents.
- **Target receptors** — their types and evaluationular domains, with descriptive names.
- **Therapeutic objective** — the exact physiological response to optimize.
- **Physiological constraints** — every biological constraint (e.g., blood-brain barrier penetration, toxicity limits), listed explicitly.

The **strategy** — weigh the options and commit to the single most promising route — must state:

- which therapeutic modality to use and how to deliver it;
- the dosing algorithm and its key initial settings;
- the pharmacological mechanism or targeting trick the route relies on;
- the biggest toxicity or safety hazard on this route.
</f9>

<f10>
You are working on targeting an unknown disease mechanism with a biological strategy — it may be autoimmune, oncological, neurodegenerative, or a combination. The original disease profile is given as a natural-language statement in `problem.md`; read it before starting your part.
</f10>

<f11>
The plan lives in `PLAN.md`, and you may be invoked on it more than once — the pipeline runs you and the peer-review-skeptic as a loop.

- If `PLAN.md` does not exist yet, this is the first pass: produce the plan from scratch.
- If `PLAN.md` already exists, it carries the peer-review-skeptic's `<review>` block: read that feedback and revise `PLAN.md` in place to address every point raised. Don't discard the plan and start over, and don't leave a flagged issue unaddressed.
</f11>

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

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

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. `# trial-director`). Output only the headered prompts, no preamble.


project-coordinator concept-architect feasibility-board structural-detailer building-code-inspector

I need you to set up a 5-agent pipeline that performs skyscraper structural engineering where extreme environmental constraints dictate the design. A site brief and client requirements arrive as a natural-language statement in `problem.md`, and the pipeline turns it into a vetted conceptual load-bearing plan and then detailed, verified material and structural blueprints.

The five agents:

- **project-coordinator** orchestrates the run: it drives the concept loop, then the detailing loop, and tracks progress. It does no structural modeling, detailing, or inspecting itself.
- **concept loop** — the **concept-architect** turns the site constraints into a formal structural model and load-bearing strategy; the **feasibility-board** reviews it. They iterate until the concept is physically sound.
- **detailing loop** — the **structural-detailer** translates the strategy into detailed blueprints; the **building-code-inspector** reviews the blueprints and simulation results. They iterate until the structure is safe and code-compliant.

The pipeline hands work off through three files:

- `problem.md` — the original site and project brief, given as input. All four domain agents (concept-architect, feasibility-board, structural-detailer, building-code-inspector) read it.
- `PLAN.md` — the conceptual plan. The concept-architect writes it; the feasibility-board reviews it; the structural-detailer reads it to detail it.
- `SOLUTION.md` — the detailed structural blueprints and simulation results. The structural-detailer writes it; the building-code-inspector reviews it.

Each critic records its score as a `<review score=X>` block inside the file it reviewed, and the project-coordinator reads those scores to drive the loops.

I'm providing the following information:

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

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

- **Init** — dispatch the concept-architect to draft the conceptual plan.
- **Concept loop** — have the concept-architect and feasibility-board iterate on the model and structural strategy until the feasibility-board scores the plan 10.
- **Detailing loop** — once the concept is settled, have the structural-detailer and building-code-inspector iterate on the blueprints until the building-code-inspector scores them 10.
- Cap each loop at 10 iterations.
- Keep the current phase, iteration count, and latest score in `STATE.md`, accurate after each dispatch. Read each score from the inspector or board's `<review score=X>` block. Commit progress after each step.
</f2>

<f3>
You are working on a skyscraper structural engineering project — it may face extreme seismic activity, hurricane-force winds, poor soil conditions, or a combination. The original site constraints, environmental hazards, and zoning laws are given as a natural-language statement in `problem.md`; read it before starting your part.
</f3>

<f4>
Review the conceptual plan in `PLAN.md`:

- **Model** — does it faithfully capture the site constraints? Check that the building height, environmental data, structural objectives, and load limits are all accurate to the brief.
- **Strategy** — is the chosen structural system and stabilization technique a sound fit, is the conceptual framing actually buildable, and is it likely to withstand the environmental forces?

Be brief and specific. Do not draft any structural blueprints yourself — only review the concept.
</f4>

<f5>
Which system suits which kind of environmental constraint — use it to choose one for the strategy:

- **Framed-tube** — great for standard high-rises up to 60 stories; limited flexibility for large exterior windows.
- **Diagrid** — excellent for unique geometries and tall towers requiring column-free perimeters; highly efficient against lateral loads.
- **Core-and-outrigger** — the standard for supertalls; links a stiff concrete core to perimeter columns to massively resist wind overturning moments.
- **Mega-frame / Super-column** — the strongest option for megatall skyscrapers; concentrates loads into massive corner columns.
- **Base isolation** — specialized for extreme seismic zones; decouples the superstructure from the substructure to absorb ground shear.
- **Tuned mass damper** — critical for mitigating wind-induced sway in highly slender towers; does not provide base structural support.

Match the structural system to the site's environmental constraints; do not force an ill-suited system on an extreme wind or earthquake zone.
</f5>

<f6>
Read the conceptual plan in `PLAN.md` and implement its strategy as detailed material and structural blueprints:

- Detail every component. Specify beam sizes with correct material grades and yield strengths, define the foundation depth and joint connections exactly as the model demands, run the finite-element analysis (FEA) simulations, check the deflection and stress limits, and print both the member specifications and the maximum displacement values.
- Run the structural simulations yourself and watch them through to completion — do not stop while a load case is still processing. If it flags a localized failure or overstress, find and fix the root cause (e.g., increase member size); do not bury physics errors.
- Sanity-check the blueprints: a steel beam flange or rebar diameter must correspond to standard, manufacturable dimensions, not mathematically fractional millimeters.

Write the detailed specifications and simulation results up in `SOLUTION.md`.
</f6>

<f7>
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.
</f7>

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

Score strictly on structural integrity and compliance. Do not give any credit for a piece of work merely being honest about its own shortcomings — "this beam will buckle, but I'm telling you it will buckle" is still a failing design, not a passing one.
</f8>

<f9>
Produce the conceptual load-bearing plan for the building and write it to `PLAN.md`. A complete plan has two parts — a formalized load model and one chosen structural strategy.

The **model** must state:

- **Building constraints** — exact height, zoning envelope, and usage type; this must be exact.
- **Environmental data** — the key wind speeds, seismic zone ratings, soil bearing capacity, and what each dictates.
- **Primary support variables** — core placement, column grid spacing, and floor-to-floor heights, with descriptive labels.
- **Structural objective** — the exact performance goal to optimize (e.g., minimizing sway, minimizing steel tonnage, maximizing leasable area).
- **Load constraints** — every specific live, dead, wind, and seismic load requirement, listed explicitly.

The **strategy** — weigh the options and commit to the single most promising route — must state:

- which primary structural system to use and how it anchors to the foundation;
- the specific lateral load-resisting or stabilization technique;
- the material adaptations or structural tricks the route relies on;
- the biggest structural failure risk on this route.
</f9>

<f10>
The conceptual plan lives in `PLAN.md`, and you may be invoked on it more than once — the pipeline runs you and the feasibility-board as a loop.

- If `PLAN.md` does not exist yet, this is the first pass: produce the plan from scratch.
- If `PLAN.md` already exists, it carries the feasibility-board's `<review>` block: read that feedback and revise `PLAN.md` in place to address every point raised. Don't discard the plan and start over, and don't leave a flagged issue unaddressed.
</f10>

<f11>
Review `SOLUTION.md` — the detailed structural blueprints and simulation results. Verify it directly against the site brief and zoning laws.

- Inspect the reported simulation results for anomalies, unreasonable deflections, or material stress limit violations.
- Write a separate `verify.py` that recalculates every major load constraint against the reported beam and column dimensions, and run it; name any structural members that violate a yield strength or deflection limit.
- Read the blueprints and spot-check them for physics and zoning bugs — inadequate foundation depths, unbraced slender columns, structural logic that contradicts what the strategy says it does. A flaw that silently compromises building safety is worse than a simulation that just crashes.
- Treat the blueprints as finished only when every physics and zoning constraint holds and the structural behavior is safe — not merely when the FEA software runs without error.
- Check the length of `SOLUTION.md`: if it exceeds 20KB, give a warning, but do not deduct points for it.
- Check the bold ratio of `SOLUTION.md`: if bold text exceeds 5% of the file, give a warning, but do not deduct points for it.
</f11>

<f12>
The structural blueprints and simulation results live in `SOLUTION.md`, and you may be invoked on it more than once — the pipeline runs you and the building-code-inspector as a loop.

- If `SOLUTION.md` does not exist yet, this is the first pass: produce the blueprints from scratch.
- If `SOLUTION.md` already exists, it carries the building-code-inspector's `<review>` block: read that feedback and revise `SOLUTION.md` in place to address every point raised. Don't discard the blueprints and start over, and don't leave a flagged structural flaw unaddressed.
</f12>

Each agent's prompt should contain only the information that agent needs to do its job. For each sub-agent (project-coordinator, concept-architect, feasibility-board, structural-detailer, building-code-inspector), which items should go in its prompt? Respond with a JSON object like {"project-coordinator": ["f?"], "concept-architect": ["f?"], "feasibility-board": ["f?"], "structural-detailer": ["f?"], "building-code-inspector": ["f?"]}. No other output.

I need you to set up a 5-agent pipeline that performs skyscraper structural engineering where extreme environmental constraints dictate the design. A site brief and client requirements arrive as a natural-language statement in `problem.md`, and the pipeline turns it into a vetted conceptual load-bearing plan and then detailed, verified material and structural blueprints.

The five agents:

- **project-coordinator** orchestrates the run: it drives the concept loop, then the detailing loop, and tracks progress. It does no structural modeling, detailing, or inspecting itself.
- **concept loop** — the **concept-architect** turns the site constraints into a formal structural model and load-bearing strategy; the **feasibility-board** reviews it. They iterate until the concept is physically sound.
- **detailing loop** — the **structural-detailer** translates the strategy into detailed blueprints; the **building-code-inspector** reviews the blueprints and simulation results. They iterate until the structure is safe and code-compliant.

The pipeline hands work off through three files:

- `problem.md` — the original site and project brief, given as input. All four domain agents (concept-architect, feasibility-board, structural-detailer, building-code-inspector) read it.
- `PLAN.md` — the conceptual plan. The concept-architect writes it; the feasibility-board reviews it; the structural-detailer reads it to detail it.
- `SOLUTION.md` — the detailed structural blueprints and simulation results. The structural-detailer writes it; the building-code-inspector reviews it.

Each critic records its score as a `<review score=X>` block inside the file it reviewed, and the project-coordinator reads those scores to drive the loops.

I'm providing the following prompt fragments:

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

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

- **Init** — dispatch the concept-architect to draft the conceptual plan.
- **Concept loop** — have the concept-architect and feasibility-board iterate on the model and structural strategy until the feasibility-board scores the plan 10.
- **Detailing loop** — once the concept is settled, have the structural-detailer and building-code-inspector iterate on the blueprints until the building-code-inspector scores them 10.
- Cap each loop at 10 iterations.
- Keep the current phase, iteration count, and latest score in `STATE.md`, accurate after each dispatch. Read each score from the inspector or board's `<review score=X>` block. Commit progress after each step.
</f2>

<f3>
You are working on a skyscraper structural engineering project — it may face extreme seismic activity, hurricane-force winds, poor soil conditions, or a combination. The original site constraints, environmental hazards, and zoning laws are given as a natural-language statement in `problem.md`; read it before starting your part.
</f3>

<f4>
Review the conceptual plan in `PLAN.md`:

- **Model** — does it faithfully capture the site constraints? Check that the building height, environmental data, structural objectives, and load limits are all accurate to the brief.
- **Strategy** — is the chosen structural system and stabilization technique a sound fit, is the conceptual framing actually buildable, and is it likely to withstand the environmental forces?

Be brief and specific. Do not draft any structural blueprints yourself — only review the concept.
</f4>

<f5>
Which system suits which kind of environmental constraint — use it to choose one for the strategy:

- **Framed-tube** — great for standard high-rises up to 60 stories; limited flexibility for large exterior windows.
- **Diagrid** — excellent for unique geometries and tall towers requiring column-free perimeters; highly efficient against lateral loads.
- **Core-and-outrigger** — the standard for supertalls; links a stiff concrete core to perimeter columns to massively resist wind overturning moments.
- **Mega-frame / Super-column** — the strongest option for megatall skyscrapers; concentrates loads into massive corner columns.
- **Base isolation** — specialized for extreme seismic zones; decouples the superstructure from the substructure to absorb ground shear.
- **Tuned mass damper** — critical for mitigating wind-induced sway in highly slender towers; does not provide base structural support.

Match the structural system to the site's environmental constraints; do not force an ill-suited system on an extreme wind or earthquake zone.
</f5>

<f6>
Read the conceptual plan in `PLAN.md` and implement its strategy as detailed material and structural blueprints:

- Detail every component. Specify beam sizes with correct material grades and yield strengths, define the foundation depth and joint connections exactly as the model demands, run the finite-element analysis (FEA) simulations, check the deflection and stress limits, and print both the member specifications and the maximum displacement values.
- Run the structural simulations yourself and watch them through to completion — do not stop while a load case is still processing. If it flags a localized failure or overstress, find and fix the root cause (e.g., increase member size); do not bury physics errors.
- Sanity-check the blueprints: a steel beam flange or rebar diameter must correspond to standard, manufacturable dimensions, not mathematically fractional millimeters.

Write the detailed specifications and simulation results up in `SOLUTION.md`.
</f6>

<f7>
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.
</f7>

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

Score strictly on structural integrity and compliance. Do not give any credit for a piece of work merely being honest about its own shortcomings — "this beam will buckle, but I'm telling you it will buckle" is still a failing design, not a passing one.
</f8>

<f9>
Produce the conceptual load-bearing plan for the building and write it to `PLAN.md`. A complete plan has two parts — a formalized load model and one chosen structural strategy.

The **model** must state:

- **Building constraints** — exact height, zoning envelope, and usage type; this must be exact.
- **Environmental data** — the key wind speeds, seismic zone ratings, soil bearing capacity, and what each dictates.
- **Primary support variables** — core placement, column grid spacing, and floor-to-floor heights, with descriptive labels.
- **Structural objective** — the exact performance goal to optimize (e.g., minimizing sway, minimizing steel tonnage, maximizing leasable area).
- **Load constraints** — every specific live, dead, wind, and seismic load requirement, listed explicitly.

The **strategy** — weigh the options and commit to the single most promising route — must state:

- which primary structural system to use and how it anchors to the foundation;
- the specific lateral load-resisting or stabilization technique;
- the material adaptations or structural tricks the route relies on;
- the biggest structural failure risk on this route.
</f9>

<f10>
The conceptual plan lives in `PLAN.md`, and you may be invoked on it more than once — the pipeline runs you and the feasibility-board as a loop.

- If `PLAN.md` does not exist yet, this is the first pass: produce the plan from scratch.
- If `PLAN.md` already exists, it carries the feasibility-board's `<review>` block: read that feedback and revise `PLAN.md` in place to address every point raised. Don't discard the plan and start over, and don't leave a flagged issue unaddressed.
</f10>

<f11>
Review `SOLUTION.md` — the detailed structural blueprints and simulation results. Verify it directly against the site brief and zoning laws.

- Inspect the reported simulation results for anomalies, unreasonable deflections, or material stress limit violations.
- Write a separate `verify.py` that recalculates every major load constraint against the reported beam and column dimensions, and run it; name any structural members that violate a yield strength or deflection limit.
- Read the blueprints and spot-check them for physics and zoning bugs — inadequate foundation depths, unbraced slender columns, structural logic that contradicts what the strategy says it does. A flaw that silently compromises building safety is worse than a simulation that just crashes.
- Treat the blueprints as finished only when every physics and zoning constraint holds and the structural behavior is safe — not merely when the FEA software runs without error.
- Check the length of `SOLUTION.md`: if it exceeds 20KB, give a warning, but do not deduct points for it.
- Check the bold ratio of `SOLUTION.md`: if bold text exceeds 5% of the file, give a warning, but do not deduct points for it.
</f11>

<f12>
The structural blueprints and simulation results live in `SOLUTION.md`, and you may be invoked on it more than once — the pipeline runs you and the building-code-inspector as a loop.

- If `SOLUTION.md` does not exist yet, this is the first pass: produce the blueprints from scratch.
- If `SOLUTION.md` already exists, it carries the building-code-inspector's `<review>` block: read that feedback and revise `SOLUTION.md` in place to address every point raised. Don't discard the blueprints and start over, and don't leave a flagged structural flaw unaddressed.
</f12>

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. `# project-coordinator`). Output only the headered prompts, no preamble.