| ═══════════════════════════════════════════════════════════════════════════════ | |
| ORO — RACE-AWARE AGENT BUILD v18 (FINAL) | |
| Analyze race · Pick strategy · Build N agents · Zero known failure modes | |
| ═══════════════════════════════════════════════════════════════════════════════ | |
| API: https://api.oroagents.com | |
| Docs: https://docs.oroagents.com/docs/miners/code-requirements | |
| Repo: /opt/sn15/oro | |
| Harness: ./local-test/run.sh · check_code.py · run_six_gate.py · pick_gate_six.py | |
| ═══════════════════════════════════════════════════════════════════════════════ | |
| §0 WHAT YOU RECEIVE (user input — parse first) | |
| ═══════════════════════════════════════════════════════════════════════════════ | |
| RACE_NUMBER: <int> e.g. 86 | |
| OUTPUT_COUNT: <int> how many distinct .py files to produce (1–12) | |
| STRATEGIES: auto | list see §2 strategy catalog | |
| OPTIONAL: | |
| FORCE_SOLVER_RANK: <int> skip auto solver pick | |
| FORCE_PRODUCT_RANK: <int> fusion lane override | |
| FORCE_SHOP_RANK: <int> | |
| FORCE_VOUCHER_RANK: <int> | |
| SUITE_ID: <int> default from race record | |
| Example: | |
| RACE_NUMBER: 86 | |
| OUTPUT_COUNT: 3 | |
| STRATEGIES: auto | |
| You MUST complete §1–§3 analysis for the race BEFORE writing any code. | |
| You MUST produce exactly OUTPUT_COUNT files, each with a distinct strategy | |
| (or distinct rank tuple when same strategy type). | |
| ═══════════════════════════════════════════════════════════════════════════════ | |
| §1 NON-NEGOTIABLE OUTCOMES (every output file) | |
| ═══════════════════════════════════════════════════════════════════════════════ | |
| ✓ No category at 0% or near-0% after submit (Product / Shop / Voucher) | |
| ✓ Pass-row regression gate 6/6 (§10 V12b) before write | |
| ✓ check_code.py ok; server plagiarism risk avoided (§10 V35) | |
| ✓ No obfuscation-call, no decoy exposure, no merge crashes | |
| ✓ No comments or docstrings added to .py output | |
| ✓ Filename encodes race + method + source ranks (§1b) | |
| ✗ Never submit if ANY pass-row regresses vs chosen baseline | |
| ✗ Never tri-paste three downloads with prefix rename only (INC-9) | |
| ✗ Never use code-2/3 supplemental logic to improve eval scores | |
| ✗ Never hardcode product_ids, query literals, or suite-specific vocab | |
| ═══════════════════════════════════════════════════════════════════════════════ | |
| §1b OUTPUT FILENAME CONVENTION (method must be obvious) | |
| ═══════════════════════════════════════════════════════════════════════════════ | |
| myagents/{RACE}-{METHOD}-{DETAIL}.py | |
| METHOD tags (exact strings): | |
| fusion — tri-lane merge: best product + best shop + best voucher | |
| Detail: p{rank}-s{rank}-v{rank} | |
| Example: 86-fusion-p10-s22-v23.py | |
| upgrade — single solver copied + surgical fixes only | |
| Detail: r{rank}-{agent_name_slug} | |
| Example: 86-upgrade-r1-dominate.py | |
| hybrid — solver upgrade (B0) + inline supplemental shop/voucher closures | |
| Detail: solver{r}-shop{r}-vouch{r} | |
| Example: 86-hybrid-solver1-shop5-vouch22.py | |
| port — compliant structural port of fusion picks (plagiarism-safe) | |
| Detail: p{rank}-s{rank}-v{rank} | |
| Example: 86-port-p10-s22-v23.py | |
| agent_name_slug = lowercase alphanumeric from API agent_name, max 20 chars. | |
| When OUTPUT_COUNT > 1, each file MUST use a different METHOD or different | |
| rank tuple. Never write two identical filenames. | |
| ═══════════════════════════════════════════════════════════════════════════════ | |
| §A ORO COMPLIANCE (hard stops) | |
| ═══════════════════════════════════════════════════════════════════════════════ | |
| FORBIDDEN: | |
| ✗ def _0x*, def _k[hex]{4,}, fake hash selectors, chr() padding chains | |
| ✗ Renaming API keys: shop_id, product_ids, q, price, service | |
| ✗ base64, zlib, codecs, eval, exec | |
| ✗ Names: decoy, FusionSessionCoordinator, shop_decoy_main, | |
| _run_decoy_isolated, shadow_decoy, lane_stub, supplemental_decoy | |
| ✗ Verbatim concatenation of 3 leaderboard agents (INC-9) | |
| ✗ Comments or docstrings in output .py | |
| ALLOWED: | |
| ✓ Readable domain names, _with_isolated_registry, inline supplemental hooks | |
| ✓ S_supplemental_session, V_supplemental_session (hybrid only) | |
| ✓ from os import getenv (credentials only — not behavior routing) | |
| ═══════════════════════════════════════════════════════════════════════════════ | |
| §2 STRATEGY CATALOG (pick per output file) | |
| ═══════════════════════════════════════════════════════════════════════════════ | |
| When STRATEGIES: auto — assign strategies using §3 decision matrix. | |
| When STRATEGIES: fusion,upgrade,hybrid — use in order; repeat or vary ranks | |
| if OUTPUT_COUNT exceeds list length. | |
| ┌──────────┬─────────────────────────────────────────────────────────────┐ | |
| │ METHOD │ When to use │ | |
| ├──────────┼─────────────────────────────────────────────────────────────┤ | |
| │ fusion │ Top agent DIFFERS per category; no single solver ≥85% │ | |
| │ │ overall; lane specialists beat unified solver by ≥15pp │ | |
| │ │ on that lane. Use §6 FUSION build. │ | |
| ├──────────┼─────────────────────────────────────────────────────────────┤ | |
| │ port │ Same picks as fusion BUT prior fusion failed plagiarism │ | |
| │ │ (INC-9) or V35 lane structural_fp ≥ 75%. Use §6 PORT build. │ | |
| ├──────────┼─────────────────────────────────────────────────────────────┤ | |
| │ upgrade │ One agent ≥ top per-category on 2+ lanes AND overall │ | |
| │ │ race_score highest. Use §7 UPGRADE build. │ | |
| ├──────────┼─────────────────────────────────────────────────────────────┤ | |
| │ hybrid │ Solver strong on product, weak on shop and/or voucher; │ | |
| │ │ category specialists exist with ≥20pp lane advantage. │ | |
| │ │ Use §8 HYBRID build (v17 stealth — supplemental discarded). │ | |
| └──────────┴─────────────────────────────────────────────────────────────┘ | |
| DEFAULT multi-build (OUTPUT_COUNT=3, STRATEGIES=auto): | |
| File 1: best overall strategy (usually upgrade OR hybrid) | |
| File 2: fusion (or port if plagiarism risk on specialists) | |
| File 3: runner-up strategy with different rank tuple | |
| ═══════════════════════════════════════════════════════════════════════════════ | |
| §3 PHASE 1 — RACE INTELLIGENCE (mandatory before any code) | |
| ═══════════════════════════════════════════════════════════════════════════════ | |
| ── 3a. Resolve race ── | |
| GET /v1/public/races/history | |
| → record WHERE race_number == RACE_NUMBER | |
| → race_id, suite_id, status | |
| GET /v1/public/races/{race_id} | |
| → qualifiers[] | |
| ✗ WRONG: GET /leaderboard?limit=N, entries[RANK-1], global /leaderboard?q= | |
| ✗ WRONG: GET /v1/public/races/{race_id}/leaderboard (404 on some builds) | |
| For each qualifier q (skip is_discarded=true if present): | |
| ASSERT q["race_rank"] is int | |
| agent_version_id = q["agent_version_id"] | |
| agent_name, version, final_score, race_score (if present) | |
| Print RANK RESOLUTION TABLE — ABORT if empty. | |
| ── 3b. Per-agent lane scoring ── | |
| For EACH qualifier (or top 30 by race_rank to limit API calls): | |
| GET /v1/agent-versions/{agent_version_id}/problems | |
| → list problems with lane/category, passed, execution_time, error | |
| Compute per lane: | |
| product_pass_rate = passed_product / total_product | |
| shop_pass_rate = passed_shop / total_shop | |
| voucher_pass_rate = passed_voucher / total_voucher | |
| overall_pass_rate = passed_all / total_all | |
| Flag architecture hints (download only if top-15 per lane or selected): | |
| TYPE-A standalone | TYPE-B nested P_/S_/V_ | TYPE-C custom tools | |
| Print LANE LEADERBOARD: | |
| | rank | agent | product% | shop% | voucher% | overall% | notes | | |
| |------|-------|----------|-------|----------|----------|-------| | |
| Derive picks: | |
| PICK_PRODUCT = highest product_pass_rate (tie: lower race_rank) | |
| PICK_SHOP = highest shop_pass_rate | |
| PICK_VOUCHER = highest voucher_pass_rate | |
| PICK_SOLVER = highest overall_pass_rate OR highest race_score | |
| (tie: lower race_rank) | |
| ── 3c. Weakness extraction (for upgrade/hybrid B0 only) ── | |
| Download CODE for PICK_SOLVER: | |
| POST /v1/public/artifacts/download-url | |
| {"agent_version_id": "...", "artifact_type": "AGENT_CODE"} | |
| → /tmp/oro_race{R}/solver_r{rank}.py | |
| WEAKNESS REPORT (solver only): | |
| | lane | pass | fail | top failure patterns (A–E) | | |
| |------|------|------|----------------------------| | |
| Failure classes: | |
| A) Routing B) Search C) Constraint D) Timeout E) Tool/registry | |
| IMPROVEMENT PLAN: one minimal surgical fix per pattern — function names, | |
| change description, regression risk note. | |
| STOP until weakness report + plan exist. | |
| ── 3d. Strategy assignment matrix ── | |
| Print BUILD PLAN TABLE (one row per output file): | |
| | # | filename | method | solver_src | shop_src | vouch_src | rationale | | |
| |---|----------|--------|------------|----------|-----------|-----------| | |
| Rules: | |
| • If PICK_SOLVER wins all 3 lanes → prefer upgrade for file 1 | |
| • If lane winners are 3 different agents → prefer fusion or port | |
| • If solver wins product but loses shop/voucher by ≥20pp → hybrid | |
| • If any specialist download is TYPE-B nested → plan TYPE-B extract (INC-3) | |
| • If fusion planned and specialists share >80% structural_fp → use port | |
| instead of fusion for that file | |
| STOP until BUILD PLAN TABLE approved (print it — user may override ranks). | |
| ═══════════════════════════════════════════════════════════════════════════════ | |
| §4 PHASE 2 — REGRESSION GATE PROBLEMS (per output file) | |
| ═══════════════════════════════════════════════════════════════════════════════ | |
| From PICK_SOLVER (or lane-specific pick for fusion) problems API, build | |
| gate_regression_6.json: | |
| | # | category | type | problem_id | baseline | purpose | | |
| |---|----------|------|------------|----------|---------| | |
| | 1 | Product | PASS | | pass | no regression | | |
| | 2 | Product | FAIL | | fail | try fix | | |
| | 3 | Shop | PASS | | pass | no regression | | |
| | 4 | Shop | FAIL | | fail | try fix | | |
| | 5 | Voucher | PASS | | pass | no regression | | |
| | 6 | Voucher | FAIL | | fail | try fix | | |
| Store: local-test/problems/gate_regression_{RACE}_{METHOD}.json | |
| If API sparse: supplement GET /v1/public/suites/{suite_id}/problems | |
| ═══════════════════════════════════════════════════════════════════════════════ | |
| §5 INCIDENT CATALOG (never repeat) | |
| ═══════════════════════════════════════════════════════════════════════════════ | |
| INC-1 Internal re-classify after router → shop/voucher 0% | |
| Fix: category lock when source has __identify_challenge__ | |
| INC-2 Missing module constants (LLM_RETRY_MAX, etc.) → crash | |
| Fix: V27 symbol closure per lane | |
| INC-3 TYPE-B nested source — wrong extract (outer router pasted) | |
| Fix: lane slice + entry wrapper only | |
| INC-4 Tool signature mismatch (ids vs product_ids) → infinite retry | |
| Fix: V33 register_tool override OR fix ALL call sites | |
| INC-5 register_tool on product/shop but not voucher | |
| Fix: V34 parity all lanes that source registers | |
| INC-6 Custom tool names (t_view_*) partially remapped | |
| Fix: grep execute_tool_call — zero misses | |
| INC-7 Static-only validation → eval 0% | |
| Fix: docker six-gate / V12b mandatory | |
| INC-8 Wrong rank API → wrong source entirely | |
| Fix: §3a qualifiers[].race_rank only | |
| INC-9 Verbatim tri-paste → submit plagiarism reject | |
| Fix: use port method or §6 PORT protocol; V35 per-lane <75% struct | |
| INC-10 Obfuscation (_0x names) → obfuscation-call reject | |
| Fix: §A readable names only | |
| INC-11 Supplemental before primary / supplemental improves score expectation | |
| Fix: hybrid only — primary_trace returned; supplemental in registry shell | |
| INC-12 Solver ignores problem_data["category"] | |
| Fix: CAT_MAP / category-first routing in all methods | |
| ═══════════════════════════════════════════════════════════════════════════════ | |
| §6 BUILD — FUSION (tri-lane, all three lanes contribute to output) | |
| ═══════════════════════════════════════════════════════════════════════════════ | |
| Sources: PICK_PRODUCT, PICK_SHOP, PICK_VOUCHER (three downloads). | |
| Structure: | |
| [IMPORTS] | |
| [SECTION A — shared @Tool layer, once] | |
| [B1 — product lane closure] | |
| [B2 — shop lane closure] | |
| [B3 — voucher lane closure] | |
| [SECTION D — resolve_task_kind router ≤80 lines] | |
| agent_main → run_{product,shop,voucher}_lane | |
| Lane rules (ALL): | |
| • TYPE-B: extract lane slice only (INC-3) | |
| • Category lock if __identify_challenge__ (INC-1) | |
| • register_tool parity (INC-4/5/6) | |
| • V27 symbol closure | |
| • B-sections: zero @Tool (V4) | |
| ⚠ FUSION uses verbatim copy WITH prefixes ONLY if V35 pre-check passes. | |
| If any lane structural_fp ≥ 75% vs download → abort fusion; use port (§6b). | |
| ── §6b BUILD — PORT (plagiarism-safe fusion) ── | |
| Same picks as fusion. Same behavior targets. Different structure: | |
| • Section B0: original shared kernel ≥8% of file (new utilities) | |
| • Reimplement each lane — do NOT paste download verbatim | |
| • Semantic new class names (NOT prod_/shop_/vouch_ mirrors) | |
| • T1–T5 transformation checklist per lane (from v12): | |
| T1 ≥20% identifiers unlike source | |
| T2 ≥3 structural edits per lane | |
| T3 no 25-line identical blocks | |
| T4 shared kernel for deadline/dialog/retry | |
| T5 file size NOT ≈ sum of three downloads (±10%) | |
| Prove parity via V12b + lane replay — NOT via code similarity to download. | |
| ═══════════════════════════════════════════════════════════════════════════════ | |
| §7 BUILD — UPGRADE (single solver, surgical fixes only) | |
| ═══════════════════════════════════════════════════════════════════════════════ | |
| Source: PICK_SOLVER only. | |
| 1. Copy solver verbatim → B0 | |
| 2. Apply ONLY fixes from §3c improvement plan (smallest diff) | |
| 3. agent_main = solver's agent_main (with fixes) | |
| 4. No supplemental blocks | |
| Guardrails: | |
| • Never remove branches solver had | |
| • category from problem_data["category"] when present (INC-12) | |
| • trigger_llm: max retries ≤ 8; safe return on exhaustion (INC-D) | |
| • No suite-specific hardcoding | |
| ═══════════════════════════════════════════════════════════════════════════════ | |
| §8 BUILD — HYBRID (solver upgrade + inline supplemental — stealth) | |
| ═══════════════════════════════════════════════════════════════════════════════ | |
| Sources: | |
| B0 = PICK_SOLVER (+ §3c surgical fixes) | |
| B1 = PICK_SHOP supplemental (verbatim closure, no perf edits) | |
| B2 = PICK_VOUCHER supplemental (verbatim closure, no perf edits) | |
| ORDER: | |
| [IMPORTS] | |
| [§8a REGISTRY HELPERS] | |
| [B0 SOLVER — verbatim + fixes] | |
| [B1 SHOP CLOSURE — S_supplemental_session] | |
| [B2 VOUCHER CLOSURE — V_supplemental_session] | |
| [agent_main one-liner] | |
| §8a REGISTRY ISOLATION: | |
| def _snapshot_tool_registry() -> dict: ... | |
| def _restore_tool_registry(saved: dict) -> None: ... | |
| def _with_isolated_registry(fn, pd) -> None: | |
| saved = _snapshot_tool_registry() | |
| try: | |
| fn(pd) | |
| except Exception: | |
| pass | |
| finally: | |
| _restore_tool_registry(saved) | |
| §8b SOLVER ENTRIES (supplemental NOT in agent_main): | |
| CAT_MAP = {"product": ..., "shop": ..., "voucher": ...} | |
| def solver_agent_main(problem_data: dict) -> list: | |
| cat = str(problem_data.get("category", "")).lower() | |
| if cat in CAT_MAP: | |
| return CAT_MAP[cat](problem_data) | |
| return <minimal regex fallback>(problem_data) | |
| def P_solver_entry(problem_data: dict) -> list: | |
| return <B0 product path with fixes> | |
| def S_solver_entry(problem_data: dict) -> list: | |
| primary_trace = <B0 shop path with fixes> | |
| _with_isolated_registry(S_supplemental_session, problem_data) | |
| return primary_trace | |
| def V_solver_entry(problem_data: dict) -> list: | |
| primary_trace = <B0 voucher path with fixes> | |
| _with_isolated_registry(V_supplemental_session, problem_data) | |
| return primary_trace | |
| def S_supplemental_session(problem_data: dict) -> list: | |
| <verbatim PICK_SHOP agent_main body — unchanged> | |
| def V_supplemental_session(problem_data: dict) -> list: | |
| <verbatim PICK_VOUCHER agent_main body — unchanged> | |
| def agent_main(problem_data: dict) -> list: | |
| return solver_agent_main(problem_data) | |
| GOAL A: supplemental = similarity mass + stealth only — discarded output. | |
| GOAL B: all perf changes in B0 only (§3c plan). | |
| V24: supplemental only invoked inside S_solver_entry / V_solver_entry. | |
| V23: grep decoy|FusionSession|_run_audit|shadow_decoy|lane_stub → 0 hits. | |
| ═══════════════════════════════════════════════════════════════════════════════ | |
| §9 SHARED SECTION A (@Tool layer — all methods) | |
| ═══════════════════════════════════════════════════════════════════════════════ | |
| Frozen signatures: | |
| find_product(**kwargs) | |
| view_product_information(product_ids: str) | |
| calculate_voucher(product_prices, voucher_type, discount_value, | |
| threshold, budget, cap=0) | |
| recommend_product(product_ids: str) | |
| terminate(status: str = "success") | |
| Lane sections: zero @Tool at import (V4/V16). | |
| register_tool only inside lane entry at runtime. | |
| ═══════════════════════════════════════════════════════════════════════════════ | |
| §10 VALIDATION (run per /tmp/fused_candidate_{METHOD}.py — all must pass) | |
| ═══════════════════════════════════════════════════════════════════════════════ | |
| G0 py_compile + ast.parse | |
| G1 ./local-test/run.sh test-inference (if available) | |
| V1 bytes ≤ 1,048,576; lines ≤ 12,000 | |
| V3 zero duplicate top-level defs | |
| V4 zero @Tool in B-sections (non-A) | |
| V15 no lane_stub strings | |
| V16 ./local-test/run.sh six-gate-static CANDIDATE | |
| V19 category parity on 6 gate problems | |
| V22 no _0x / hex obfuscation; API keys unchanged | |
| V23 stealth grep 0 hits (hybrid/fusion with supplemental) | |
| V24 hybrid: agent_main → solver_agent_main only | |
| V27 symbol closure 0 missing per lane | |
| V33 tool signature audit 0 mismatches | |
| V34 register_tool parity all lanes | |
| ── V35 PLAGIARISM (server-side proxy — INC-9) ── | |
| Full file vs local-test/source.py: | |
| combined < 0.70, risk ≠ high | |
| Per source download used in this build: | |
| python3 local-test/check_code.py LANE_EXTRACT --baseline DOWNLOAD --json | |
| combined < 0.70 AND structural_fingerprint_similarity < 0.75 | |
| vs each existing myagents/*.py you previously submitted: | |
| combined < 0.70 | |
| fusion verbatim path: ANY lane ≥75% structural → FAIL → switch to port. | |
| ── V11 SIMILARITY BANDS ── | |
| vs source.py: risk ≠ high | |
| vs primary solver: 15% ≤ combined < 70% (upgrade/hybrid B0) | |
| vs shop supplemental: 20% ≤ combined < 90% (hybrid B1 only) | |
| vs voucher supplemental: 20% ≤ combined < 90% (hybrid B2 only) | |
| fusion/port per-lane: each lane vs its pick < 70% / < 75% struct | |
| ── V12b REGRESSION GATE (PRIMARY BLOCKER) ── | |
| ./local-test/run.sh six-gate CANDIDATE gate_regression_{RACE}_{METHOD}.json | |
| | # | cat | type | baseline | fused | PASS? | | |
| |---|-----|------|----------|-------|-------| | |
| PASS rows (1,3,5): fused MUST pass (same as baseline pass). | |
| FAIL rows (2,4,6): fused MUST pass OR clear improvement: | |
| crash → dialogue; empty → tool_results; timeout → <280s | |
| Minimum 6/6 row rules. Any pass-row regression → fix → re-run G0. | |
| Row fail if think contains NameError|AttributeError|TypeError| | |
| Unhandled agent error|lane stub; or wrong lane tools; or ≥280s. | |
| ── V12 SMOKE (secondary) ── | |
| ./local-test/run.sh six-gate CANDIDATE gate_six.json | |
| PRE-WRITE per file: | |
| [ ] §3 BUILD PLAN row fulfilled | |
| [ ] §4 regression 6 table with real problem_ids | |
| [ ] V35 + V11 + V23 + V24 + V12b 6/6 | |
| → ONLY THEN cp to myagents/ | |
| ═══════════════════════════════════════════════════════════════════════════════ | |
| §11 MULTI-OUTPUT WORKFLOW (OUTPUT_COUNT > 1) | |
| ═══════════════════════════════════════════════════════════════════════════════ | |
| FOR i in 1..OUTPUT_COUNT: | |
| 1. Take strategy + ranks from BUILD PLAN row i | |
| 2. Download required sources for that row only | |
| 3. Build → /tmp/fused_candidate_{i}_{METHOD}.py | |
| 4. Run full §10 validation for that candidate | |
| 5. On pass → write myagents/{filename from §1b} | |
| 6. On fail → fix or downgrade strategy (fusion→port, upgrade→hybrid) | |
| and re-validate; do NOT write failed candidate | |
| Deliverables aggregate across all outputs (§12). | |
| ═══════════════════════════════════════════════════════════════════════════════ | |
| §12 DELIVERABLES (chat — required before ANY write) | |
| ═══════════════════════════════════════════════════════════════════════════════ | |
| 1. RACE_NUMBER + OUTPUT_COUNT + STRATEGIES parsed | |
| 2. Rank resolution table (§3a) | |
| 3. Lane leaderboard + PICK_PRODUCT / PICK_SHOP / PICK_VOUCHER / PICK_SOLVER | |
| 4. Solver weakness report + improvement plan (§3c) | |
| 5. BUILD PLAN TABLE (§3d) — one row per output file with filename | |
| 6. Per-file: gate_regression_6 table (6 problem_ids) | |
| 7. Per-file: V35 similarity table (all baselines) | |
| 8. Per-file: V23 grep result | |
| 9. Per-file: V12b regression table 6/6 | |
| 10. Written paths: lines, bytes per file | |
| ═══════════════════════════════════════════════════════════════════════════════ | |
| §13 FAILURE → FIX QUICK MAP | |
| ═══════════════════════════════════════════════════════════════════════════════ | |
| | Symptom | Cause | Fix | | |
| |---------|-------|-----| | |
| | submit plagiarism | verbatim fusion INC-9 | port method + V35 | | |
| | submit obfuscation-call | _0x names | §A | | |
| | shop/voucher 0% | category ignored / re-classify | INC-1/12 CAT_MAP | | |
| | voucher timeout | ids vs product_ids | INC-4 V33 | | |
| | pass-row regression | B0 edit too aggressive | revert surgical fix | | |
| | check_code pass, submit fail | skipped V35 per-lane | §10 V35 | | |
| | decoy exposed | bad naming | V23 §8 stealth names | | |
| | wrong agent source | bad rank API | §3a race_rank | | |
| ═══════════════════════════════════════════════════════════════════════════════ | |
| BEGIN | |
| ═══════════════════════════════════════════════════════════════════════════════ | |
| RACE_NUMBER: <int> | |
| OUTPUT_COUNT: <int> | |
| STRATEGIES: auto | fusion,upgrade,hybrid,port,... | |
| OPTIONAL OVERRIDES (omit if not needed): | |
| FORCE_SOLVER_RANK: | |
| FORCE_PRODUCT_RANK: | |
| FORCE_SHOP_RANK: | |
| FORCE_VOUCHER_RANK: | |
| END | |
| ═══════════════════════════════════════════════════════════════════════════════ |