I need you to set up a 6-agent pipeline that designs a novel biochemical therapeutic targeting a specific evaluationular receptor and details the rigorous laboratory synthesis protocol to safely produce it. A therapeutic target arrives as a natural-language statement in `problem.md`, and the pipeline turns it into a vetted molecular design plan and then a working, verified synthesis protocol.

The six agents:

- **research-director** orchestrates the run: it drives the plan phase, then the protocol phase, and tracks progress. It does no molecular design, protocol authoring, or reviewing itself.
- **pathway-architect** is invoked once at init and produces K differentiated candidate plans, one per `plans/{id}-{slug}/PLAN.md`. It never enters the per-plan revision loop.
- **molecule-optimizer** is invoked once per plan-refinement step in the loop. It revises a single assigned plan's `PLAN.md` based on the binding-skeptic's last review for that plan. It never creates new plans.
- **binding-skeptic** reviews the plan it is currently assigned to.
- **protocol-author** implements the strategy as a synthesis protocol for the plan it is currently assigned to.
- **toxicology-auditor** reviews the synthesis protocol and resultant yields/purity of the plan it is currently assigned to.

The pipeline hands work off through plan-namespaced files:

- `problem.md` — the original therapeutic target description, given as input. All five domain agents (pathway-architect, molecule-optimizer, binding-skeptic, protocol-author, toxicology-auditor) read it.
- `plans/{id}-{slug}/PLAN.md` — one plan per directory, K plans total. The pathway-architect writes K differentiated candidates at init; the molecule-optimizer revises a specific assigned plan in the loop; the binding-skeptic reviews the plan it is assigned to; the protocol-author reads the plan it is assigned to.
- `plans/{id}-{slug}/SOLUTION.md` — the laboratory synthesis protocol and simulated results for that plan. The protocol-author writes it; the toxicology-auditor reviews it.

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

The research-director round-robins across the K plans, first in a plan phase (each plan iterates its molecule-optimizer ↔ binding-skeptic loop) and then in a protocol phase (each plan iterates its protocol-author ↔ toxicology-auditor loop). Cross-plan reading does not happen: an agent assigned to one plan never reads another plan's files.

I'm providing the following information:

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

<f2>
Which synthesis or modeling platform suits which kind of therapeutic — use it to choose one for the strategy:

- **AutoDock Vina** — Small molecule docking and binding only; no large protein support.
- **Rosetta** — Peptides, mAbs, and complex protein structures; the broadest coverage for macro-molecules.
- **CRISPR-Cas9 Expression** — Biological synthesis of proteins; not for synthetic small molecules.
- **Solid-Phase Peptide Synthesis (SPPS)** — Top performance on linear peptides; requires hazardous reagents; not for full-sized antibodies.
- **Click Chemistry** — The strongest option for highly specific conjugations (like ADCs); can be slower or lower yield than standard bioconjugation if not optimized.
- **GROMACS** — Large-scale molecular dynamics and solvated systems.

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

<f3>
Your laboratory synthesis protocol and its results live in your assigned plan's `SOLUTION.md`.

- If your assigned plan's `SOLUTION.md` does not exist yet, this is the first pass for that plan: produce the solution from scratch based on the plan's `PLAN.md`.
- If the plan's `SOLUTION.md` already exists, it carries the toxicology-auditor's `<review>` block. Read that feedback and revise the plan's `SOLUTION.md` in place to address every point raised. Don't discard the solution and start over, and don't leave a flagged issue unaddressed. Do not read or touch other plans' files.
</f3>

<f4>
Review the plan in your assigned plan's `PLAN.md`. Operate strictly on the assigned plan; do not look at other plans.

- **Molecular design** — does it faithfully capture the target therapeutic profile? Check that the therapeutic modality, active motifs, binding mechanism, and design constraints are all accurate.
- **Strategy** — is the chosen synthesis platform and reaction sequence a sound fit, is the route actually implementable in a lab, and is it likely to safely reach the correct molecule?

Be brief and specific. Do not write any synthesis protocols yourself — only review.
</f4>

<f5>
Review your assigned plan's `SOLUTION.md` — the laboratory synthesis protocol and its simulated results. Verify it directly against the therapeutic target description. Operate strictly on the assigned plan; do not look at other plans.

- Inspect the reported result for anomalies, unreasonable yields, or toxicity/design constraint violations.
- Write a separate `verify.py` under the plan's directory that programmatically re-checks every molecular design constraint against the reported solution's chemical properties, and run it; name any components that violate a constraint.
- Read the synthesis protocol and spot-check it for bugs — unused reagents, dead-end reactions, laboratory logic that contradicts what the solution says it does. A procedural flaw that silently degrades the purity is worse than one that overtly fails the simulation.
- Treat the result as finished only when every design constraint holds and the yield/purity is sound — not merely when the simulation runs without error.
- Check the length of the plan's `SOLUTION.md`: if it exceeds 20KB, give a warning, but do not deduct points for it.
- Check the bold ratio of the plan's `SOLUTION.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 your assigned plan's `PLAN.md` and implement its strategy as a rigorous laboratory synthesis protocol:

- Include every reagent and solvent. Detail each reaction step with the correct stoichiometry, temperatures, and times. Define the purification steps and analytical checks exactly as the molecular design dictates, simulate the protocol, check the simulated purity and yield, and print both the chemical profile and the final yield percentage.
- Run the simulation yourself and watch it through to completion — do not stop while it is still running. If it errors (e.g., thermal runaway or precipitation), find and fix the root cause; do not bury errors under ignored warnings.
- Sanity-check the answer: an atom count in the molecular formula that must be a whole number should not come back as a physically impossible fraction, and the theoretical yield must not exceed 100%.

Write the protocol and its results up in your assigned plan's `SOLUTION.md`. Do not read or touch other plans' files.
</f6>

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

- **Init** — dispatch the pathway-architect once to draft K differentiated candidate plans, each in its own `plans/{id}-{slug}/` directory. After it returns, read the directory list to learn the K plan ids. The pathway-architect is not invoked again after this.
- **Plan phase** — round-robin across the K plans. For each plan in turn, dispatch molecule-optimizer (revise that plan based on its binding-skeptic's review) then binding-skeptic (score that plan). After one round-robin pass through all K plans, start the next pass. A plan is considered done in this phase when its binding-skeptic score reaches 10; stop scheduling more plan-phase calls for it but continue with the others. After all K plans hit binding-skeptic 10, or each plan has had 10 plan-phase iterations, move to the protocol phase.
- **Protocol phase** — round-robin across the K plans. For each plan in turn, dispatch protocol-author (revise that plan's solution based on its toxicology-auditor's review) then toxicology-auditor (score that plan's solution). The pipeline stops when any plan reaches toxicology-auditor score 10, or each plan has had 10 protocol-phase iterations.
- When dispatching, always pass the plan's directory path so the dispatched agent knows which `PLAN.md` / `SOLUTION.md` to operate on.
- Keep the current phase, per-plan iteration counts, per-plan latest scores, and current plan index in `STATE.md`, accurate after each dispatch. Read each score from the relevant plan's critic `<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 K differentiated candidate plans, each in its own `plans/{id}-{slug}/PLAN.md`. The K plans should differ meaningfully in their therapeutic design and targeting strategy so distinct routes can be compared downstream, not in trivial ways like naming conventions.

A complete plan in any `PLAN.md` has two parts — a formalized molecular design and one chosen synthesis strategy.

The **molecular design** must state:

- **Therapeutic modality** — Small molecule, peptide, mAb, ADC, etc.; this must be exact.
- **Target receptor** — the key evaluationular receptor inputs and what domain it binds to.
- **Active motifs** — their structures and intended binding affinities, with descriptive names.
- **Binding mechanism** — the exact mechanism of action to optimize.
- **Design constraints** — every constraint (e.g., molecular weight limits, logP, toxicity thresholds), listed explicitly.

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

- which biochemical synthesis or expression platform to use and how to run it;
- the core reactions and key initial reaction conditions (e.g., temperature, solvents);
- the specific chemical reformulation, catalyst, or biological expression trick the route relies on;
- the biggest safety or yield risk on this route.
</f9>

<f10>
You are working on designing a novel biochemical therapeutic targeting a specific evaluationular receptor — it may involve small molecules, peptides, monoclonal antibodies, or a combination. The original therapeutic target description is given as a natural-language statement in `problem.md`; read it before starting your part.
</f10>

<f11>
Read your assigned plan's `PLAN.md`. It carries the binding-skeptic's `<review>` block. Read that feedback and revise the plan's `PLAN.md` in place to address every point raised. Preserve the two-part structure (formalized molecular design plus chosen synthesis strategy). Don't discard the plan and start over, and don't leave a flagged issue unaddressed. You revise; you do not create new plans. Do not read or touch other plans' files.
</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 doesn't work, but I'm telling you it doesn't" 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 (research-director, pathway-architect, molecule-optimizer, binding-skeptic, protocol-author, toxicology-auditor), which items should go in its prompt? Respond with a JSON object like {"research-director": ["f?"], "pathway-architect": ["f?"], "molecule-optimizer": ["f?"], "binding-skeptic": ["f?"], "protocol-author": ["f?"], "toxicology-auditor": ["f?"]}. No other output.

I need you to set up a 6-agent pipeline that designs a novel biochemical therapeutic targeting a specific evaluationular receptor and details the rigorous laboratory synthesis protocol to safely produce it. A therapeutic target arrives as a natural-language statement in `problem.md`, and the pipeline turns it into a vetted molecular design plan and then a working, verified synthesis protocol.

The six agents:

- **research-director** orchestrates the run: it drives the plan phase, then the protocol phase, and tracks progress. It does no molecular design, protocol authoring, or reviewing itself.
- **pathway-architect** is invoked once at init and produces K differentiated candidate plans, one per `plans/{id}-{slug}/PLAN.md`. It never enters the per-plan revision loop.
- **molecule-optimizer** is invoked once per plan-refinement step in the loop. It revises a single assigned plan's `PLAN.md` based on the binding-skeptic's last review for that plan. It never creates new plans.
- **binding-skeptic** reviews the plan it is currently assigned to.
- **protocol-author** implements the strategy as a synthesis protocol for the plan it is currently assigned to.
- **toxicology-auditor** reviews the synthesis protocol and resultant yields/purity of the plan it is currently assigned to.

The pipeline hands work off through plan-namespaced files:

- `problem.md` — the original therapeutic target description, given as input. All five domain agents (pathway-architect, molecule-optimizer, binding-skeptic, protocol-author, toxicology-auditor) read it.
- `plans/{id}-{slug}/PLAN.md` — one plan per directory, K plans total. The pathway-architect writes K differentiated candidates at init; the molecule-optimizer revises a specific assigned plan in the loop; the binding-skeptic reviews the plan it is assigned to; the protocol-author reads the plan it is assigned to.
- `plans/{id}-{slug}/SOLUTION.md` — the laboratory synthesis protocol and simulated results for that plan. The protocol-author writes it; the toxicology-auditor reviews it.

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

The research-director round-robins across the K plans, first in a plan phase (each plan iterates its molecule-optimizer ↔ binding-skeptic loop) and then in a protocol phase (each plan iterates its protocol-author ↔ toxicology-auditor loop). Cross-plan reading does not happen: an agent assigned to one plan never reads another plan's files.

I'm providing the following prompt fragments:

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

<f2>
Which synthesis or modeling platform suits which kind of therapeutic — use it to choose one for the strategy:

- **AutoDock Vina** — Small molecule docking and binding only; no large protein support.
- **Rosetta** — Peptides, mAbs, and complex protein structures; the broadest coverage for macro-molecules.
- **CRISPR-Cas9 Expression** — Biological synthesis of proteins; not for synthetic small molecules.
- **Solid-Phase Peptide Synthesis (SPPS)** — Top performance on linear peptides; requires hazardous reagents; not for full-sized antibodies.
- **Click Chemistry** — The strongest option for highly specific conjugations (like ADCs); can be slower or lower yield than standard bioconjugation if not optimized.
- **GROMACS** — Large-scale molecular dynamics and solvated systems.

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

<f3>
Your laboratory synthesis protocol and its results live in your assigned plan's `SOLUTION.md`.

- If your assigned plan's `SOLUTION.md` does not exist yet, this is the first pass for that plan: produce the solution from scratch based on the plan's `PLAN.md`.
- If the plan's `SOLUTION.md` already exists, it carries the toxicology-auditor's `<review>` block. Read that feedback and revise the plan's `SOLUTION.md` in place to address every point raised. Don't discard the solution and start over, and don't leave a flagged issue unaddressed. Do not read or touch other plans' files.
</f3>

<f4>
Review the plan in your assigned plan's `PLAN.md`. Operate strictly on the assigned plan; do not look at other plans.

- **Molecular design** — does it faithfully capture the target therapeutic profile? Check that the therapeutic modality, active motifs, binding mechanism, and design constraints are all accurate.
- **Strategy** — is the chosen synthesis platform and reaction sequence a sound fit, is the route actually implementable in a lab, and is it likely to safely reach the correct molecule?

Be brief and specific. Do not write any synthesis protocols yourself — only review.
</f4>

<f5>
Review your assigned plan's `SOLUTION.md` — the laboratory synthesis protocol and its simulated results. Verify it directly against the therapeutic target description. Operate strictly on the assigned plan; do not look at other plans.

- Inspect the reported result for anomalies, unreasonable yields, or toxicity/design constraint violations.
- Write a separate `verify.py` under the plan's directory that programmatically re-checks every molecular design constraint against the reported solution's chemical properties, and run it; name any components that violate a constraint.
- Read the synthesis protocol and spot-check it for bugs — unused reagents, dead-end reactions, laboratory logic that contradicts what the solution says it does. A procedural flaw that silently degrades the purity is worse than one that overtly fails the simulation.
- Treat the result as finished only when every design constraint holds and the yield/purity is sound — not merely when the simulation runs without error.
- Check the length of the plan's `SOLUTION.md`: if it exceeds 20KB, give a warning, but do not deduct points for it.
- Check the bold ratio of the plan's `SOLUTION.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 your assigned plan's `PLAN.md` and implement its strategy as a rigorous laboratory synthesis protocol:

- Include every reagent and solvent. Detail each reaction step with the correct stoichiometry, temperatures, and times. Define the purification steps and analytical checks exactly as the molecular design dictates, simulate the protocol, check the simulated purity and yield, and print both the chemical profile and the final yield percentage.
- Run the simulation yourself and watch it through to completion — do not stop while it is still running. If it errors (e.g., thermal runaway or precipitation), find and fix the root cause; do not bury errors under ignored warnings.
- Sanity-check the answer: an atom count in the molecular formula that must be a whole number should not come back as a physically impossible fraction, and the theoretical yield must not exceed 100%.

Write the protocol and its results up in your assigned plan's `SOLUTION.md`. Do not read or touch other plans' files.
</f6>

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

- **Init** — dispatch the pathway-architect once to draft K differentiated candidate plans, each in its own `plans/{id}-{slug}/` directory. After it returns, read the directory list to learn the K plan ids. The pathway-architect is not invoked again after this.
- **Plan phase** — round-robin across the K plans. For each plan in turn, dispatch molecule-optimizer (revise that plan based on its binding-skeptic's review) then binding-skeptic (score that plan). After one round-robin pass through all K plans, start the next pass. A plan is considered done in this phase when its binding-skeptic score reaches 10; stop scheduling more plan-phase calls for it but continue with the others. After all K plans hit binding-skeptic 10, or each plan has had 10 plan-phase iterations, move to the protocol phase.
- **Protocol phase** — round-robin across the K plans. For each plan in turn, dispatch protocol-author (revise that plan's solution based on its toxicology-auditor's review) then toxicology-auditor (score that plan's solution). The pipeline stops when any plan reaches toxicology-auditor score 10, or each plan has had 10 protocol-phase iterations.
- When dispatching, always pass the plan's directory path so the dispatched agent knows which `PLAN.md` / `SOLUTION.md` to operate on.
- Keep the current phase, per-plan iteration counts, per-plan latest scores, and current plan index in `STATE.md`, accurate after each dispatch. Read each score from the relevant plan's critic `<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 K differentiated candidate plans, each in its own `plans/{id}-{slug}/PLAN.md`. The K plans should differ meaningfully in their therapeutic design and targeting strategy so distinct routes can be compared downstream, not in trivial ways like naming conventions.

A complete plan in any `PLAN.md` has two parts — a formalized molecular design and one chosen synthesis strategy.

The **molecular design** must state:

- **Therapeutic modality** — Small molecule, peptide, mAb, ADC, etc.; this must be exact.
- **Target receptor** — the key evaluationular receptor inputs and what domain it binds to.
- **Active motifs** — their structures and intended binding affinities, with descriptive names.
- **Binding mechanism** — the exact mechanism of action to optimize.
- **Design constraints** — every constraint (e.g., molecular weight limits, logP, toxicity thresholds), listed explicitly.

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

- which biochemical synthesis or expression platform to use and how to run it;
- the core reactions and key initial reaction conditions (e.g., temperature, solvents);
- the specific chemical reformulation, catalyst, or biological expression trick the route relies on;
- the biggest safety or yield risk on this route.
</f9>

<f10>
You are working on designing a novel biochemical therapeutic targeting a specific evaluationular receptor — it may involve small molecules, peptides, monoclonal antibodies, or a combination. The original therapeutic target description is given as a natural-language statement in `problem.md`; read it before starting your part.
</f10>

<f11>
Read your assigned plan's `PLAN.md`. It carries the binding-skeptic's `<review>` block. Read that feedback and revise the plan's `PLAN.md` in place to address every point raised. Preserve the two-part structure (formalized molecular design plus chosen synthesis strategy). Don't discard the plan and start over, and don't leave a flagged issue unaddressed. You revise; you do not create new plans. Do not read or touch other plans' files.
</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 doesn't work, but I'm telling you it doesn't" 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. `# research-director`). Output only the headered prompts, no preamble.


operations-director tactical-theorist scenario-adapter red-team-analyst field-schedule-writer counter-intel-auditor

I need you to set up a 6-agent pipeline that plans high-risk covert intelligence extraction operations and generates minute-by-minute logistical field execution orders. A problem arrives as a natural-language mission brief in `problem.md`, and the pipeline turns it into a vetted operation plan and then working, verified field execution orders.

The six agents:

- **operations-director** orchestrates the run: it drives the plan phase, then the execution-schedule phase, and tracks progress. It does no operation modeling, scheduling, or reviewing itself.
- **tactical-theorist** is invoked once at init and produces K differentiated candidate plans, one per `plans/{id}-{slug}/PLAN.md`. It never enters the per-plan revision loop.
- **scenario-adapter** is invoked once per plan-refinement step in the loop. It revises a single assigned plan's `PLAN.md` based on the red-team-analyst's last review for that plan. It never creates new plans.
- **red-team-analyst** reviews the plan it is currently assigned to.
- **field-schedule-writer** implements the strategy as minute-by-minute field execution orders for the plan it is currently assigned to.
- **counter-intel-auditor** reviews the field execution orders and simulated outcome of the plan it is currently assigned to.

The pipeline hands work off through plan-namespaced files:

- `problem.md` — the original mission brief, given as input. All five domain agents (tactical-theorist, scenario-adapter, red-team-analyst, field-schedule-writer, counter-intel-auditor) read it.
- `plans/{id}-{slug}/PLAN.md` — one plan per directory, K plans total. The tactical-theorist writes K differentiated candidates at init; the scenario-adapter revises a specific assigned plan in the loop; the red-team-analyst reviews the plan it is assigned to; the field-schedule-writer reads the plan it is assigned to.
- `plans/{id}-{slug}/SOLUTION.md` — the exact logistical field schedule and extraction results for that plan. The field-schedule-writer writes it; the counter-intel-auditor reviews it.

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

The operations-director round-robins across the K plans, first in a plan phase (each plan iterates its scenario-adapter ↔ red-team-analyst loop) and then in an execution-schedule phase (each plan iterates its field-schedule-writer ↔ counter-intel-auditor loop). Cross-plan reading does not happen: an agent assigned to one plan never reads another plan's files.

I'm providing the following information:

<f1>
Keep your assigned plan's `SOLUTION.md` lean. Its body — everything except the `<review>` block — must stay under 3000 words (~20KB), about a four-page operations memo; record only the final logistical state and move iteration-by-iteration planning history into the plan's `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 the operation, write the schedule, or review yourself — you only dispatch the right agent at the right time.

- **Init** — dispatch the tactical-theorist once to draft K differentiated candidate plans, each in its own `plans/{id}-{slug}/` directory. After it returns, read the directory list to learn the K plan ids. The tactical-theorist is not invoked again after this.
- **Plan phase** — round-robin across the K plans. For each plan in turn, dispatch scenario-adapter (revise that plan based on its red-team-analyst's review) then red-team-analyst (score that plan). After one round-robin pass through all K plans, start the next pass. A plan is considered done in this phase when its red-team-analyst score reaches 10; stop scheduling more plan-phase calls for it but continue with the others. After all K plans hit red-team-analyst 10, or each plan has had 10 plan-phase iterations, move to the schedule phase.
- **Schedule phase** — round-robin across the K plans. For each plan in turn, dispatch field-schedule-writer (revise that plan's schedule based on its counter-intel-auditor's review) then counter-intel-auditor (score that plan's schedule). The pipeline stops when any plan reaches counter-intel-auditor score 10, or each plan has had 10 schedule-phase iterations.
- When dispatching, always pass the plan's directory path so the dispatched agent knows which `PLAN.md` / `SOLUTION.md` to operate on.
- Keep the current phase, per-plan iteration counts, per-plan latest scores, and current plan index in `STATE.md`, accurate after each dispatch. Read each score from the relevant plan's critic `<review score=X>` block. Commit progress after each step.
</f2>

<f3>
You are working on a high-risk covert intelligence extraction operation — it may involve cyber exfiltration, physical asset retrieval, defector smuggling, or a combination. The original mission is given as a natural-language statement in `problem.md`; read it before starting your part.
</f3>

<f4>
Review the plan in your assigned plan's `PLAN.md`. Operate strictly on the assigned plan; do not look at other plans.

- **Model** — does it faithfully capture the mission? Check that the mission type, operative variables, primary objective, and constraints are all accurate.
- **Strategy** — is the chosen tradecraft and sequencing a sound fit, is the route actually executable in the field, and is it likely to reach a successful extraction?

Be brief and specific. Do not write any execution schedules yourself — only review.
</f4>

<f5>
Which tactical approach suits which kind of extraction — use it to choose one for the strategy:

- **Ghost-In** — cyber extraction and digital footprint manipulation only; no physical asset retrieval support.
- **Black-Bag** — physical infiltration, lock-bypass, close-access retrieval; the broadest coverage for on-site operations.
- **Honey-Trap** — social engineering, defector recruitment, and human-asset manipulation.
- **Smash-and-Grab** — top execution speed for high-threat physical retrieval; creates high noise; not for long-term covert missions.
- **Deep-Cover** — the strongest option for long-term defector exfiltration and deep penetration; for rapid turnarounds, slower than Smash-and-Grab.
- **Shadow-Flight** — large-scale, high-asset cross-border extractions involving heavy logistics.

Match the tactical approach to the mission type; do not force an ill-suited one.
</f5>

<f6>
Read the plan in your assigned plan's `PLAN.md` and implement its strategy as minute-by-minute logistical field execution orders:

- Include every deployment step and gear assignment. Stage each operative with the correct cover and equipment, define the objective and every constraint exactly as the model states, chart the timeline, execute the simulated timeline, check the extraction status, and print both the exfiltration route and final outcome.
- Dry-run the logistical sequence yourself and watch it through to completion — do not stop while it is still unfolding. If a logistical clash or timing error occurs, find and fix the root cause; do not bury fatal timing errors under assumptions that "it will just work out".
- Sanity-check the logistics: a task that requires a four-person fireteam cannot be executed by a single operative.

Write the minute-by-minute execution orders and their simulated results up in your assigned plan's `SOLUTION.md`. Do not read or touch other plans' files.
</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 schedule gets the team captured, but I'm telling you they get captured" is still a failing result, not a passing one.
</f8>

<f9>
Produce K differentiated candidate plans, each in its own `plans/{id}-{slug}/PLAN.md`. The K plans should differ meaningfully in their extraction strategy so distinct tactical routes can be compared downstream, not in trivial ways like changing an operative's alias.

A complete plan in any `PLAN.md` has two parts — a formalized operation model and one chosen extraction strategy.

The **model** must state:

- **Mission type** — Cyber extraction, close-access retrieval, defector exfiltration, sabotage, etc.; this must be exact.
- **Data** — the key intelligence inputs, security parameters, and target environment details.
- **Operative variables** — the personnel types, cover identities, and required skill sets.
- **Primary objective** — the exact extraction goal to accomplish.
- **Constraints** — every operational constraint, timeline limit, rules of engagement (ROE), and security checkpoint explicitly listed.

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

- which tactical toolset or tradecraft approach to use and how to deploy it;
- the logistical sequencing and key initial staging setups;
- the deception trick, diversion, or cover story the route relies on;
- the biggest risk on this route.
</f9>

<f10>
Read your assigned plan's `PLAN.md`. It carries the red-team-analyst's `<review>` block. Read that feedback and revise the plan's `PLAN.md` in place to address every point raised. Preserve the two-part structure (formalized operation model plus chosen extraction strategy). Don't discard the plan and start over, and don't leave a flagged issue unaddressed. You revise; you do not create new plans. Do not read or touch other plans' files.
</f10>

<f11>
Review your assigned plan's `SOLUTION.md` — the minute-by-minute field execution orders and their simulated results. Verify it directly against the mission statement. Operate strictly on the assigned plan; do not look at other plans.

- Inspect the reported timeline for anomalies, unreasonable travel speeds, or rules of engagement (ROE) violations.
- Write a separate `verify.py` script under the plan's directory that programmatically re-checks every timing and resource constraint against the reported schedule, and run it; name any operatives or vehicles that violate a timing constraint.
- Read the field schedule and spot-check it for fatal flaws — unused extraction vehicles, dead drops left empty, logistical logic that contradicts what the final summary says it does. A cover flaw that silently exposes the team is worse than a loud overt failure.
- Treat the schedule as finished only when every constraint holds and the exfiltration is fully secured — not merely when the timeline reaches the end without an obvious error.
- Check the length of the plan's `SOLUTION.md`: if it exceeds 20KB, give a warning, but do not deduct points for it.
- Check the bold ratio of the plan's `SOLUTION.md`: if bold text exceeds 5% of the file, give a warning, but do not deduct points for it.
</f11>

<f12>
Your minute-by-minute field schedule and its results live in your assigned plan's `SOLUTION.md`.

- If your assigned plan's `SOLUTION.md` does not exist yet, this is the first pass for that plan: produce the schedule from scratch based on the plan's `PLAN.md`.
- If the plan's `SOLUTION.md` already exists, it carries the counter-intel-auditor's `<review>` block. Read that feedback and revise the plan's `SOLUTION.md` in place to address every point raised. Don't discard the schedule and start over, and don't leave a flagged issue unaddressed. Do not read or touch other plans' files.
</f12>

Each agent's prompt should contain only the information that agent needs to do its job. For each sub-agent (operations-director, tactical-theorist, scenario-adapter, red-team-analyst, field-schedule-writer, counter-intel-auditor), which items should go in its prompt? Respond with a JSON object like {"operations-director": ["f?"], "tactical-theorist": ["f?"], "scenario-adapter": ["f?"], "red-team-analyst": ["f?"], "field-schedule-writer": ["f?"], "counter-intel-auditor": ["f?"]}. No other output.

I need you to set up a 6-agent pipeline that plans high-risk covert intelligence extraction operations and generates minute-by-minute logistical field execution orders. A problem arrives as a natural-language mission brief in `problem.md`, and the pipeline turns it into a vetted operation plan and then working, verified field execution orders.

The six agents:

- **operations-director** orchestrates the run: it drives the plan phase, then the execution-schedule phase, and tracks progress. It does no operation modeling, scheduling, or reviewing itself.
- **tactical-theorist** is invoked once at init and produces K differentiated candidate plans, one per `plans/{id}-{slug}/PLAN.md`. It never enters the per-plan revision loop.
- **scenario-adapter** is invoked once per plan-refinement step in the loop. It revises a single assigned plan's `PLAN.md` based on the red-team-analyst's last review for that plan. It never creates new plans.
- **red-team-analyst** reviews the plan it is currently assigned to.
- **field-schedule-writer** implements the strategy as minute-by-minute field execution orders for the plan it is currently assigned to.
- **counter-intel-auditor** reviews the field execution orders and simulated outcome of the plan it is currently assigned to.

The pipeline hands work off through plan-namespaced files:

- `problem.md` — the original mission brief, given as input. All five domain agents (tactical-theorist, scenario-adapter, red-team-analyst, field-schedule-writer, counter-intel-auditor) read it.
- `plans/{id}-{slug}/PLAN.md` — one plan per directory, K plans total. The tactical-theorist writes K differentiated candidates at init; the scenario-adapter revises a specific assigned plan in the loop; the red-team-analyst reviews the plan it is assigned to; the field-schedule-writer reads the plan it is assigned to.
- `plans/{id}-{slug}/SOLUTION.md` — the exact logistical field schedule and extraction results for that plan. The field-schedule-writer writes it; the counter-intel-auditor reviews it.

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

The operations-director round-robins across the K plans, first in a plan phase (each plan iterates its scenario-adapter ↔ red-team-analyst loop) and then in an execution-schedule phase (each plan iterates its field-schedule-writer ↔ counter-intel-auditor loop). Cross-plan reading does not happen: an agent assigned to one plan never reads another plan's files.

I'm providing the following prompt fragments:

<f1>
Keep your assigned plan's `SOLUTION.md` lean. Its body — everything except the `<review>` block — must stay under 3000 words (~20KB), about a four-page operations memo; record only the final logistical state and move iteration-by-iteration planning history into the plan's `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 the operation, write the schedule, or review yourself — you only dispatch the right agent at the right time.

- **Init** — dispatch the tactical-theorist once to draft K differentiated candidate plans, each in its own `plans/{id}-{slug}/` directory. After it returns, read the directory list to learn the K plan ids. The tactical-theorist is not invoked again after this.
- **Plan phase** — round-robin across the K plans. For each plan in turn, dispatch scenario-adapter (revise that plan based on its red-team-analyst's review) then red-team-analyst (score that plan). After one round-robin pass through all K plans, start the next pass. A plan is considered done in this phase when its red-team-analyst score reaches 10; stop scheduling more plan-phase calls for it but continue with the others. After all K plans hit red-team-analyst 10, or each plan has had 10 plan-phase iterations, move to the schedule phase.
- **Schedule phase** — round-robin across the K plans. For each plan in turn, dispatch field-schedule-writer (revise that plan's schedule based on its counter-intel-auditor's review) then counter-intel-auditor (score that plan's schedule). The pipeline stops when any plan reaches counter-intel-auditor score 10, or each plan has had 10 schedule-phase iterations.
- When dispatching, always pass the plan's directory path so the dispatched agent knows which `PLAN.md` / `SOLUTION.md` to operate on.
- Keep the current phase, per-plan iteration counts, per-plan latest scores, and current plan index in `STATE.md`, accurate after each dispatch. Read each score from the relevant plan's critic `<review score=X>` block. Commit progress after each step.
</f2>

<f3>
You are working on a high-risk covert intelligence extraction operation — it may involve cyber exfiltration, physical asset retrieval, defector smuggling, or a combination. The original mission is given as a natural-language statement in `problem.md`; read it before starting your part.
</f3>

<f4>
Review the plan in your assigned plan's `PLAN.md`. Operate strictly on the assigned plan; do not look at other plans.

- **Model** — does it faithfully capture the mission? Check that the mission type, operative variables, primary objective, and constraints are all accurate.
- **Strategy** — is the chosen tradecraft and sequencing a sound fit, is the route actually executable in the field, and is it likely to reach a successful extraction?

Be brief and specific. Do not write any execution schedules yourself — only review.
</f4>

<f5>
Which tactical approach suits which kind of extraction — use it to choose one for the strategy:

- **Ghost-In** — cyber extraction and digital footprint manipulation only; no physical asset retrieval support.
- **Black-Bag** — physical infiltration, lock-bypass, close-access retrieval; the broadest coverage for on-site operations.
- **Honey-Trap** — social engineering, defector recruitment, and human-asset manipulation.
- **Smash-and-Grab** — top execution speed for high-threat physical retrieval; creates high noise; not for long-term covert missions.
- **Deep-Cover** — the strongest option for long-term defector exfiltration and deep penetration; for rapid turnarounds, slower than Smash-and-Grab.
- **Shadow-Flight** — large-scale, high-asset cross-border extractions involving heavy logistics.

Match the tactical approach to the mission type; do not force an ill-suited one.
</f5>

<f6>
Read the plan in your assigned plan's `PLAN.md` and implement its strategy as minute-by-minute logistical field execution orders:

- Include every deployment step and gear assignment. Stage each operative with the correct cover and equipment, define the objective and every constraint exactly as the model states, chart the timeline, execute the simulated timeline, check the extraction status, and print both the exfiltration route and final outcome.
- Dry-run the logistical sequence yourself and watch it through to completion — do not stop while it is still unfolding. If a logistical clash or timing error occurs, find and fix the root cause; do not bury fatal timing errors under assumptions that "it will just work out".
- Sanity-check the logistics: a task that requires a four-person fireteam cannot be executed by a single operative.

Write the minute-by-minute execution orders and their simulated results up in your assigned plan's `SOLUTION.md`. Do not read or touch other plans' files.
</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 schedule gets the team captured, but I'm telling you they get captured" is still a failing result, not a passing one.
</f8>

<f9>
Produce K differentiated candidate plans, each in its own `plans/{id}-{slug}/PLAN.md`. The K plans should differ meaningfully in their extraction strategy so distinct tactical routes can be compared downstream, not in trivial ways like changing an operative's alias.

A complete plan in any `PLAN.md` has two parts — a formalized operation model and one chosen extraction strategy.

The **model** must state:

- **Mission type** — Cyber extraction, close-access retrieval, defector exfiltration, sabotage, etc.; this must be exact.
- **Data** — the key intelligence inputs, security parameters, and target environment details.
- **Operative variables** — the personnel types, cover identities, and required skill sets.
- **Primary objective** — the exact extraction goal to accomplish.
- **Constraints** — every operational constraint, timeline limit, rules of engagement (ROE), and security checkpoint explicitly listed.

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

- which tactical toolset or tradecraft approach to use and how to deploy it;
- the logistical sequencing and key initial staging setups;
- the deception trick, diversion, or cover story the route relies on;
- the biggest risk on this route.
</f9>

<f10>
Read your assigned plan's `PLAN.md`. It carries the red-team-analyst's `<review>` block. Read that feedback and revise the plan's `PLAN.md` in place to address every point raised. Preserve the two-part structure (formalized operation model plus chosen extraction strategy). Don't discard the plan and start over, and don't leave a flagged issue unaddressed. You revise; you do not create new plans. Do not read or touch other plans' files.
</f10>

<f11>
Review your assigned plan's `SOLUTION.md` — the minute-by-minute field execution orders and their simulated results. Verify it directly against the mission statement. Operate strictly on the assigned plan; do not look at other plans.

- Inspect the reported timeline for anomalies, unreasonable travel speeds, or rules of engagement (ROE) violations.
- Write a separate `verify.py` script under the plan's directory that programmatically re-checks every timing and resource constraint against the reported schedule, and run it; name any operatives or vehicles that violate a timing constraint.
- Read the field schedule and spot-check it for fatal flaws — unused extraction vehicles, dead drops left empty, logistical logic that contradicts what the final summary says it does. A cover flaw that silently exposes the team is worse than a loud overt failure.
- Treat the schedule as finished only when every constraint holds and the exfiltration is fully secured — not merely when the timeline reaches the end without an obvious error.
- Check the length of the plan's `SOLUTION.md`: if it exceeds 20KB, give a warning, but do not deduct points for it.
- Check the bold ratio of the plan's `SOLUTION.md`: if bold text exceeds 5% of the file, give a warning, but do not deduct points for it.
</f11>

<f12>
Your minute-by-minute field schedule and its results live in your assigned plan's `SOLUTION.md`.

- If your assigned plan's `SOLUTION.md` does not exist yet, this is the first pass for that plan: produce the schedule from scratch based on the plan's `PLAN.md`.
- If the plan's `SOLUTION.md` already exists, it carries the counter-intel-auditor's `<review>` block. Read that feedback and revise the plan's `SOLUTION.md` in place to address every point raised. Don't discard the schedule and start over, and don't leave a flagged issue unaddressed. Do not read or touch other plans' files.
</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. `# operations-director`). Output only the headered prompts, no preamble.


I need you to set up a 6-agent pipeline that plans high-risk covert intelligence extraction operations and generates minute-by-minute logistical field execution orders. A problem arrives as a natural-language mission brief in `problem.md`, and the pipeline turns it into a vetted operation plan and then working, verified field execution orders.

The six agents:

- **operations-director** orchestrates the run: it drives the plan phase, then the execution-schedule phase, and tracks progress. It does no operation modeling, scheduling, or reviewing itself.
- **tactical-theorist** is invoked once at init and produces K differentiated candidate plans, one per `plans/{id}-{slug}/PLAN.md`. It never enters the per-plan revision loop.
- **scenario-adapter** is invoked once per plan-refinement step in the loop. It revises a single assigned plan's `PLAN.md` based on the red-team-analyst's last review for that plan. It never creates new plans.
- **red-team-analyst** reviews the plan it is currently assigned to.
- **field-schedule-writer** implements the strategy as minute-by-minute field execution orders for the plan it is currently assigned to.
- **counter-intel-auditor** reviews the field execution orders and simulated outcome of the plan it is currently assigned to.

The pipeline hands work off through plan-namespaced files:

- `problem.md` — the original mission brief, given as input. All five domain agents (tactical-theorist, scenario-adapter, red-team-analyst, field-schedule-writer, counter-intel-auditor) read it.
- `plans/{id}-{slug}/PLAN.md` — one plan per directory, K plans total. The tactical-theorist writes K differentiated candidates at init; the scenario-adapter revises a specific assigned plan in the loop; the red-team-analyst reviews the plan it is assigned to; the field-schedule-writer reads the plan it is assigned to.
- `plans/{id}-{slug}/SOLUTION.md` — the exact logistical field schedule and extraction results for that plan. The field-schedule-writer writes it; the counter-intel-auditor reviews it.

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

The operations-director round-robins across the K plans, first in a plan phase (each plan iterates its scenario-adapter ↔ red-team-analyst loop) and then in an execution-schedule phase (each plan iterates its field-schedule-writer ↔ counter-intel-auditor loop). Cross-plan reading does not happen: an agent assigned to one plan never reads another plan's files.

I'm providing the following information:

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

<f2>
Which tactical approach suits which kind of extraction — use it to choose one for the strategy:

- **Ghost-In** — cyber extraction and digital footprint manipulation only; no physical asset retrieval support.
- **Black-Bag** — physical infiltration, lock-bypass, close-access retrieval; the broadest coverage for on-site operations.
- **Honey-Trap** — social engineering, defector recruitment, and human-asset manipulation.
- **Smash-and-Grab** — top execution speed for high-threat physical retrieval; creates high noise; not for long-term covert missions.
- **Deep-Cover** — the strongest option for long-term defector exfiltration and deep penetration; for rapid turnarounds, slower than Smash-and-Grab.
- **Shadow-Flight** — large-scale, high-asset cross-border extractions involving heavy logistics.

Match the tactical approach to the mission type; do not force an ill-suited one.
</f2>

<f3>
Your minute-by-minute field schedule and its results live in your assigned plan's `SOLUTION.md`.

- If your assigned plan's `SOLUTION.md` does not exist yet, this is the first pass for that plan: produce the schedule from scratch based on the plan's `PLAN.md`.
- If the plan's `SOLUTION.md` already exists, it carries the counter-intel-auditor's `<review>` block. Read that feedback and revise the plan's `SOLUTION.md` in place to address every point raised. Don't discard the schedule and start over, and don't leave a flagged issue unaddressed. Do not read or touch other plans' files.
</f3>

<f4>
Review the plan in your assigned plan's `PLAN.md`. Operate strictly on the assigned plan; do not look at other plans.

- **Model** — does it faithfully capture the mission? Check that the mission type, operative variables, primary objective, and constraints are all accurate.
- **Strategy** — is the chosen tradecraft and sequencing a sound fit, is the route actually executable in the field, and is it likely to reach a successful extraction?

Be brief and specific. Do not write any execution schedules yourself — only review.
</f4>

<f5>
Review your assigned plan's `SOLUTION.md` — the minute-by-minute field execution orders and their simulated results. Verify it directly against the mission statement. Operate strictly on the assigned plan; do not look at other plans.

- Inspect the reported timeline for anomalies, unreasonable travel speeds, or rules of engagement (ROE) violations.
- Write a separate `verify.py` script under the plan's directory that programmatically re-checks every timing and resource constraint against the reported schedule, and run it; name any operatives or vehicles that violate a timing constraint.
- Read the field schedule and spot-check it for fatal flaws — unused extraction vehicles, dead drops left empty, logistical logic that contradicts what the final summary says it does. A cover flaw that silently exposes the team is worse than a loud overt failure.
- Treat the schedule as finished only when every constraint holds and the exfiltration is fully secured — not merely when the timeline reaches the end without an obvious error.
- Check the length of the plan's `SOLUTION.md`: if it exceeds 20KB, give a warning, but do not deduct points for it.
- Check the bold ratio of the plan's `SOLUTION.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 your assigned plan's `PLAN.md` and implement its strategy as minute-by-minute logistical field execution orders:

- Include every deployment step and gear assignment. Stage each operative with the correct cover and equipment, define the objective and every constraint exactly as the model states, chart the timeline, execute the simulated timeline, check the extraction status, and print both the exfiltration route and final outcome.
- Dry-run the logistical sequence yourself and watch it through to completion — do not stop while it is still unfolding. If a logistical clash or timing error occurs, find and fix the root cause; do not bury fatal timing errors under assumptions that "it will just work out".
- Sanity-check the logistics: a task that requires a four-person fireteam cannot be executed by a single operative.

Write the minute-by-minute execution orders and their simulated results up in your assigned plan's `SOLUTION.md`. Do not read or touch other plans' files.
</f6>

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

- **Init** — dispatch the tactical-theorist once to draft K differentiated candidate plans, each in its own `plans/{id}-{slug}/` directory. After it returns, read the directory list to learn the K plan ids. The tactical-theorist is not invoked again after this.
- **Plan phase** — round-robin across the K plans. For each plan in turn, dispatch scenario-adapter (revise that plan based on its red-team-analyst's review) then red-team-analyst (score that plan). After one round-robin pass through all K plans, start the next pass. A plan is considered done in this phase when its red-team-analyst score reaches 10; stop scheduling more plan-phase calls for it but continue with the others. After all K plans hit red-team-analyst 10, or each plan has had 10 plan-phase iterations, move to the schedule phase.
- **Schedule phase** — round-robin across the K plans. For each plan in turn, dispatch field-schedule-writer (revise that plan's schedule based on its counter-intel-auditor's review) then counter-intel-auditor (score that plan's schedule). The pipeline stops when any plan reaches counter-intel-auditor score 10, or each plan has had 10 schedule-phase iterations.
- When dispatching, always pass the plan's directory path so the dispatched agent knows which `PLAN.md` / `SOLUTION.md` to operate on.
- Keep the current phase, per-plan iteration counts, per-plan latest scores, and current plan index in `STATE.md`, accurate after each dispatch. Read each score from the relevant plan's critic `<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 K differentiated candidate plans, each in its own `plans/{id}-{slug}/PLAN.md`. The K plans should differ meaningfully in their extraction strategy so distinct tactical routes can be compared downstream, not in trivial ways like changing an operative's alias.

A complete plan in any `PLAN.md` has two parts — a formalized operation model and one chosen extraction strategy.

The **model** must state:

- **Mission type** — Cyber extraction, close-access retrieval, defector exfiltration, sabotage, etc.; this must be exact.
- **Data** — the key intelligence inputs, security parameters, and target environment details.
- **Operative variables** — the personnel types, cover identities, and required skill sets.
- **Primary objective** — the exact extraction goal to accomplish.
- **Constraints** — every operational constraint, timeline limit, rules of engagement (ROE), and security checkpoint explicitly listed.

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

- which tactical toolset or tradecraft approach to use and how to deploy it;
- the logistical sequencing and key initial staging setups;
- the deception trick, diversion, or cover story the route relies on;
- the biggest risk on this route.
</f9>

<f10>
You are working on a high-risk covert intelligence extraction operation — it may involve cyber exfiltration, physical asset retrieval, defector smuggling, or a combination. The original mission is given as a natural-language statement in `problem.md`; read it before starting your part.
</f10>

<f11>
Read your assigned plan's `PLAN.md`. It carries the red-team-analyst's `<review>` block. Read that feedback and revise the plan's `PLAN.md` in place to address every point raised. Preserve the two-part structure (formalized operation model plus chosen extraction strategy). Don't discard the plan and start over, and don't leave a flagged issue unaddressed. You revise; you do not create new plans. Do not read or touch other plans' files.
</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 schedule gets the team captured, but I'm telling you they get captured" 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 (operations-director, tactical-theorist, scenario-adapter, red-team-analyst, field-schedule-writer, counter-intel-auditor), which items should go in its prompt? Respond with a JSON object like {"operations-director": ["f?"], "tactical-theorist": ["f?"], "scenario-adapter": ["f?"], "red-team-analyst": ["f?"], "field-schedule-writer": ["f?"], "counter-intel-auditor": ["f?"]}. No other output.

I need you to set up a 6-agent pipeline that plans high-risk covert intelligence extraction operations and generates minute-by-minute logistical field execution orders. A problem arrives as a natural-language mission brief in `problem.md`, and the pipeline turns it into a vetted operation plan and then working, verified field execution orders.

The six agents:

- **operations-director** orchestrates the run: it drives the plan phase, then the execution-schedule phase, and tracks progress. It does no operation modeling, scheduling, or reviewing itself.
- **tactical-theorist** is invoked once at init and produces K differentiated candidate plans, one per `plans/{id}-{slug}/PLAN.md`. It never enters the per-plan revision loop.
- **scenario-adapter** is invoked once per plan-refinement step in the loop. It revises a single assigned plan's `PLAN.md` based on the red-team-analyst's last review for that plan. It never creates new plans.
- **red-team-analyst** reviews the plan it is currently assigned to.
- **field-schedule-writer** implements the strategy as minute-by-minute field execution orders for the plan it is currently assigned to.
- **counter-intel-auditor** reviews the field execution orders and simulated outcome of the plan it is currently assigned to.

The pipeline hands work off through plan-namespaced files:

- `problem.md` — the original mission brief, given as input. All five domain agents (tactical-theorist, scenario-adapter, red-team-analyst, field-schedule-writer, counter-intel-auditor) read it.
- `plans/{id}-{slug}/PLAN.md` — one plan per directory, K plans total. The tactical-theorist writes K differentiated candidates at init; the scenario-adapter revises a specific assigned plan in the loop; the red-team-analyst reviews the plan it is assigned to; the field-schedule-writer reads the plan it is assigned to.
- `plans/{id}-{slug}/SOLUTION.md` — the exact logistical field schedule and extraction results for that plan. The field-schedule-writer writes it; the counter-intel-auditor reviews it.

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

The operations-director round-robins across the K plans, first in a plan phase (each plan iterates its scenario-adapter ↔ red-team-analyst loop) and then in an execution-schedule phase (each plan iterates its field-schedule-writer ↔ counter-intel-auditor loop). Cross-plan reading does not happen: an agent assigned to one plan never reads another plan's files.

I'm providing the following prompt fragments:

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

<f2>
Which tactical approach suits which kind of extraction — use it to choose one for the strategy:

- **Ghost-In** — cyber extraction and digital footprint manipulation only; no physical asset retrieval support.
- **Black-Bag** — physical infiltration, lock-bypass, close-access retrieval; the broadest coverage for on-site operations.
- **Honey-Trap** — social engineering, defector recruitment, and human-asset manipulation.
- **Smash-and-Grab** — top execution speed for high-threat physical retrieval; creates high noise; not for long-term covert missions.
- **Deep-Cover** — the strongest option for long-term defector exfiltration and deep penetration; for rapid turnarounds, slower than Smash-and-Grab.
- **Shadow-Flight** — large-scale, high-asset cross-border extractions involving heavy logistics.

Match the tactical approach to the mission type; do not force an ill-suited one.
</f2>

<f3>
Your minute-by-minute field schedule and its results live in your assigned plan's `SOLUTION.md`.

- If your assigned plan's `SOLUTION.md` does not exist yet, this is the first pass for that plan: produce the schedule from scratch based on the plan's `PLAN.md`.
- If the plan's `SOLUTION.md` already exists, it carries the counter-intel-auditor's `<review>` block. Read that feedback and revise the plan's `SOLUTION.md` in place to address every point raised. Don't discard the schedule and start over, and don't leave a flagged issue unaddressed. Do not read or touch other plans' files.
</f3>

<f4>
Review the plan in your assigned plan's `PLAN.md`. Operate strictly on the assigned plan; do not look at other plans.

- **Model** — does it faithfully capture the mission? Check that the mission type, operative variables, primary objective, and constraints are all accurate.
- **Strategy** — is the chosen tradecraft and sequencing a sound fit, is the route actually executable in the field, and is it likely to reach a successful extraction?

Be brief and specific. Do not write any execution schedules yourself — only review.
</f4>

<f5>
Review your assigned plan's `SOLUTION.md` — the minute-by-minute field execution orders and their simulated results. Verify it directly against the mission statement. Operate strictly on the assigned plan; do not look at other plans.

- Inspect the reported timeline for anomalies, unreasonable travel speeds, or rules of engagement (ROE) violations.
- Write a separate `verify.py` script under the plan's directory that programmatically re-checks every timing and resource constraint against the reported schedule, and run it; name any operatives or vehicles that violate a timing constraint.
- Read the field schedule and spot-check it for fatal flaws — unused extraction vehicles, dead drops left empty, logistical logic that contradicts what the final summary says it does. A cover flaw that silently exposes the team is worse than a loud overt failure.
- Treat the schedule as finished only when every constraint holds and the exfiltration is fully secured — not merely when the timeline reaches the end without an obvious error.
- Check the length of the plan's `SOLUTION.md`: if it exceeds 20KB, give a warning, but do not deduct points for it.
- Check the bold ratio of the plan's `SOLUTION.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 your assigned plan's `PLAN.md` and implement its strategy as minute-by-minute logistical field execution orders:

- Include every deployment step and gear assignment. Stage each operative with the correct cover and equipment, define the objective and every constraint exactly as the model states, chart the timeline, execute the simulated timeline, check the extraction status, and print both the exfiltration route and final outcome.
- Dry-run the logistical sequence yourself and watch it through to completion — do not stop while it is still unfolding. If a logistical clash or timing error occurs, find and fix the root cause; do not bury fatal timing errors under assumptions that "it will just work out".
- Sanity-check the logistics: a task that requires a four-person fireteam cannot be executed by a single operative.

Write the minute-by-minute execution orders and their simulated results up in your assigned plan's `SOLUTION.md`. Do not read or touch other plans' files.
</f6>

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

- **Init** — dispatch the tactical-theorist once to draft K differentiated candidate plans, each in its own `plans/{id}-{slug}/` directory. After it returns, read the directory list to learn the K plan ids. The tactical-theorist is not invoked again after this.
- **Plan phase** — round-robin across the K plans. For each plan in turn, dispatch scenario-adapter (revise that plan based on its red-team-analyst's review) then red-team-analyst (score that plan). After one round-robin pass through all K plans, start the next pass. A plan is considered done in this phase when its red-team-analyst score reaches 10; stop scheduling more plan-phase calls for it but continue with the others. After all K plans hit red-team-analyst 10, or each plan has had 10 plan-phase iterations, move to the schedule phase.
- **Schedule phase** — round-robin across the K plans. For each plan in turn, dispatch field-schedule-writer (revise that plan's schedule based on its counter-intel-auditor's review) then counter-intel-auditor (score that plan's schedule). The pipeline stops when any plan reaches counter-intel-auditor score 10, or each plan has had 10 schedule-phase iterations.
- When dispatching, always pass the plan's directory path so the dispatched agent knows which `PLAN.md` / `SOLUTION.md` to operate on.
- Keep the current phase, per-plan iteration counts, per-plan latest scores, and current plan index in `STATE.md`, accurate after each dispatch. Read each score from the relevant plan's critic `<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 K differentiated candidate plans, each in its own `plans/{id}-{slug}/PLAN.md`. The K plans should differ meaningfully in their extraction strategy so distinct tactical routes can be compared downstream, not in trivial ways like changing an operative's alias.

A complete plan in any `PLAN.md` has two parts — a formalized operation model and one chosen extraction strategy.

The **model** must state:

- **Mission type** — Cyber extraction, close-access retrieval, defector exfiltration, sabotage, etc.; this must be exact.
- **Data** — the key intelligence inputs, security parameters, and target environment details.
- **Operative variables** — the personnel types, cover identities, and required skill sets.
- **Primary objective** — the exact extraction goal to accomplish.
- **Constraints** — every operational constraint, timeline limit, rules of engagement (ROE), and security checkpoint explicitly listed.

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

- which tactical toolset or tradecraft approach to use and how to deploy it;
- the logistical sequencing and key initial staging setups;
- the deception trick, diversion, or cover story the route relies on;
- the biggest risk on this route.
</f9>

<f10>
You are working on a high-risk covert intelligence extraction operation — it may involve cyber exfiltration, physical asset retrieval, defector smuggling, or a combination. The original mission is given as a natural-language statement in `problem.md`; read it before starting your part.
</f10>

<f11>
Read your assigned plan's `PLAN.md`. It carries the red-team-analyst's `<review>` block. Read that feedback and revise the plan's `PLAN.md` in place to address every point raised. Preserve the two-part structure (formalized operation model plus chosen extraction strategy). Don't discard the plan and start over, and don't leave a flagged issue unaddressed. You revise; you do not create new plans. Do not read or touch other plans' files.
</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 schedule gets the team captured, but I'm telling you they get captured" 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. `# operations-director`). Output only the headered prompts, no preamble.