@dzhechkov/skills-bto 1.0.0

package/templates/.claude/commands/bto-optimize.md

@@ -0,0 +1,208 @@
+# /bto-optimize — Evolutionary Prompt Optimization for Skills and Commands
+
+## Usage
+```
+/bto-optimize [path to skill or command to optimize]
+```
+
+## Parameters
+- $ARGUMENTS — Path to a skill directory (`.claude/skills/<name>/`) or artifact file to optimize. Optionally include a focus dimension (`METHODOLOGY`, `DEPTH`, `CORRECTNESS`, `USABILITY`, `ROBUSTNESS`) to bias mutation strategies toward a specific weakness. Optionally include "rounds N" (e.g., "rounds 5") to override the default 3 rounds.
+
+## Protocol
+
+### Step 1: Load Skill and Module
+
+Read `.claude/skills/bto/SKILL.md`
+Read `.claude/skills/bto/modules/optimize.md`
+
+### Step 2: Validate Input
+
+If $ARGUMENTS is empty:
+- Ask: "Provide a path to the skill or command you want to optimize."
+- Stop and wait.
+
+Resolve the artifact path from $ARGUMENTS:
+- If path does not exist → report "Path not found: [path]" and stop
+- If path is a directory → use `SKILL.md` inside it as the primary optimization target
+- Parse optional focus dimension from $ARGUMENTS (if provided)
+- Parse optional rounds override from $ARGUMENTS (default: 3, max: 5)
+
+### Step 3: Baseline Evaluation
+
+**Run TEST internally before generating any variants.**
+
+Read `.claude/skills/bto/modules/test.md`
+Read `.claude/skills/bto/references/judge-rubrics.md`
+
+Execute TEST at Layer 2 (full judge panel, 3 parallel sonnet agents):
+
+- Spawn 3 parallel agents (same as `/bto-test` Layer 2)
+- Aggregate scores with weights: Expert 0.40, Critic 0.30, Auditor 0.30
+- Record per-dimension baseline scores
+- Record overall `BASELINE_SCORE`
+- Record key weaknesses from each judge
+
+**Early exit condition:**
+If `BASELINE_SCORE` ≥ 8.0 → report:
+```
+Artifact already high quality (BASELINE_SCORE/10).
+Full optimization not recommended. Specific minor suggestions:
+[list top 3 suggestions from baseline judges]
+```
+Stop and wait for user to confirm they still want to proceed.
+
+**Identify target dimensions:** all dimensions with score < 7.0.
+If a focus dimension was specified in $ARGUMENTS → add it to target dimensions regardless of score.
+
+### Step 4: Round 1 — Generate 5 Variants
+
+Generate exactly 5 variants of the artifact. Each applies one mutation strategy from `optimize.md`:
+
+| Variant | Mutation Strategy | Prioritize When |
+|---------|-----------------|-----------------|
+| Variant 1 | Rephrase | CLARITY / USABILITY weak |
+| Variant 2 | Restructure | METHODOLOGY / USABILITY weak |
+| Variant 3 | Add Constraints | ROBUSTNESS / CORRECTNESS weak |
+| Variant 4 | Simplify | Artifact verbose or over-engineered |
+| Variant 5 | Specialize | DEPTH weak, needs domain context |
+
+If a focus dimension was specified, assign the 3 most relevant strategies to Variants 1-3 and use remaining strategies for Variants 4-5.
+
+Generate all 5 variants sequentially (opus-level generation). For each variant, apply ONLY its assigned mutation. Preserve original intent, scope, and artifact type.
+
+### Step 5: Evaluate Variants — Round 1
+
+**Spawn 5 parallel agents using Agent tool, one per variant:**
+
+Each agent runs Layer 1 evaluation (model: haiku) on its assigned variant.
+
+Agents:
+- Agent 1: "BTO Eval — Variant 1 (Rephrase)"
+- Agent 2: "BTO Eval — Variant 2 (Restructure)"
+- Agent 3: "BTO Eval — Variant 3 (Add Constraints)"
+- Agent 4: "BTO Eval — Variant 4 (Simplify)"
+- Agent 5: "BTO Eval — Variant 5 (Specialize)"
+
+Record scores for all 5. Select top 2 by overall score.
+
+### Step 6: Crossover — Generate Round 2 Variants
+
+Combine the best elements of the top 2 variants from Round 1:
+
+- Identify sections where Variant A scored higher → take from A
+- Identify sections where Variant B scored higher → take from B
+- Generate 3 crossover variants that combine strengths differently
+
+Use crossover prompt from `optimize.md`. Output COMPLETE artifacts.
+
+**Abort condition:** If any variant fails Layer 0 structural checks during crossover → discard that variant and continue with remaining.
+
+### Step 7: Evaluate Variants — Round 2
+
+**Spawn 3 parallel agents using Agent tool:**
+
+Each agent runs Layer 1 evaluation (model: haiku) on its assigned crossover variant.
+
+Agents:
+- Agent 1: "BTO Eval — Round 2 Crossover A"
+- Agent 2: "BTO Eval — Round 2 Crossover B"
+- Agent 3: "BTO Eval — Round 2 Crossover C"
+
+Record scores. Select top 2.
+
+### Step 8: Crossover — Generate Round 3 Variants
+
+Repeat crossover from Step 6 with the new top 2 from Round 2.
+Generate 3 final crossover variants.
+
+### Step 9: Final Evaluation — Round 3 (Full Panel)
+
+**Round 3 uses Layer 2 — full 3-judge panel per variant.**
+
+For each of the 3 final variants, spawn 3 parallel agents (model: sonnet):
+
+Total: up to 9 agents running in parallel (or in 3 sequential batches of 3).
+
+Select the single best variant as winner.
+
+If `max_score(all_variants_round3) < BASELINE_SCORE + 0.3`:
+- Report: "Optimization produced minimal improvement. Consider original."
+- Still present the best variant for review.
+
+**Abort conditions (from `optimize.md`):**
+- Any round shows overall regression > 0.5 from baseline → stop immediately
+- Artifact semantics change fundamentally → flag and stop
+- User requests stop
+
+### Step 10: Apply Winner
+
+1. Write the winning variant to the original artifact path (overwrite in place)
+2. Preserve original as `<filename>.pre-optimize.bak` in the same directory
+
+### Step 11: Generate Report
+
+Compute before/after delta per dimension.
+
+**Winning strategy:** name the mutation strategy (or crossover combination) that produced the winner.
+
+**Recommendation logic:**
+- Improvement > 1.0 → "Apply changes — significant improvement"
+- Improvement 0.5-1.0 → "Review changes before applying"
+- Improvement < 0.5 → "Minimal improvement — original may be preferred"
+
+---
+
+## Checkpoint
+
+```
+═══════════════════════════════════════════════════════
+CHECKPOINT: OPTIMIZE Complete
+Artifact: [path]
+Rounds run: [1-3]
+Total evaluations: [N] (baseline + variants)
+
+BEFORE → AFTER:
+  METHODOLOGY:  X.X → X.X  ([+/-]X.X)
+  DEPTH:        X.X → X.X  ([+/-]X.X)
+  CORRECTNESS:  X.X → X.X  ([+/-]X.X)
+  USABILITY:    X.X → X.X  ([+/-]X.X)
+  ROBUSTNESS:   X.X → X.X  ([+/-]X.X)
+
+  OVERALL:      X.X → X.X  ([+/-]X.X)
+
+Winning Strategy: [strategy name or crossover combination]
+
+CHANGELOG:
+- [specific change made]
+- [specific change made]
+- [specific change made]
+
+Recommendation: [Apply / Review / Original preferred]
+
+Backup saved: [path.pre-optimize.bak]
+
+• "ок" — done, keep optimized version
+• "ещё раунд" — run one additional optimization round
+• "откат" — restore original from backup
+• "покажи diff" — show before/after diff for review
+═══════════════════════════════════════════════════════
+```
+
+Wait for user confirmation.
+
+---
+
+## Modular Usage
+
+This command is also invoked internally by `/bto` as the final step (OPTIMIZE phase) of the full pipeline, receiving `TEST_SCORE` and the artifact path from the preceding TEST step.
+
+## Critical Rules
+
+- Always establish baseline with Layer 2 before generating variants
+- Never skip baseline — variants cannot be ranked without a reference point
+- Agent tool is REQUIRED for parallel variant evaluation in all rounds
+- Hard cap: 3 rounds by default, 5 maximum — never loop indefinitely
+- Do not optimize if baseline ≥ 8.0 without explicit user confirmation
+- Always save a `.pre-optimize.bak` backup before overwriting original
+- Round 3 evaluation must use Layer 2 (sonnet judges), not Layer 1 (haiku)
+- Preserve original artifact intent — optimization changes HOW, not WHAT

package/templates/.claude/commands/bto-test.md

@@ -0,0 +1,186 @@
+# /bto-test — Multi-Agent Evaluation of a Skill or Command
+
+## Usage
+```
+/bto-test [path to skill directory or file]
+```
+
+## Parameters
+- $ARGUMENTS — Path to a skill directory (`.claude/skills/<name>/`), a command file (`.claude/commands/<name>.md`), a rule file (`.claude/rules/<name>.md`), or any research artifact. Optionally include "full" to force Layer 2 panel regardless of Layer 1 score.
+
+## Protocol
+
+### Step 1: Load Skill and Module
+
+Read `.claude/skills/bto/SKILL.md`
+Read `.claude/skills/bto/modules/test.md`
+Read `.claude/skills/bto/references/judge-rubrics.md`
+
+### Step 2: Validate Input
+
+If $ARGUMENTS is empty:
+- Ask: "Provide a path to the skill directory or artifact file you want to evaluate."
+- Stop and wait.
+
+Resolve the artifact path from $ARGUMENTS:
+- Strip any trailing slash
+- If the path points to a directory → look for `SKILL.md` inside it as the primary file, but include all files in the directory for context
+- If the path points to a file → use that file directly
+- If the path does not exist → report "Path not found: [path]" and stop
+
+### Step 3: Detect Artifact Type
+
+Auto-detect from path pattern:
+
+| Path Pattern | Detected Type |
+|-------------|--------------|
+| `.claude/skills/*/SKILL.md` or `.claude/skills/*/` | skill |
+| `.claude/commands/*.md` | command |
+| `.claude/rules/*.md` | rule |
+| `.claude/agents/*.md` | agent |
+| `researches/**/*.md` | research artifact |
+
+If type cannot be determined from path → infer from file content structure.
+
+### Step 4: Layer 0 — Deterministic Pre-checks
+
+**Run Layer 0 first. Always. No exceptions. Zero cost.**
+
+Execute all applicable checks from `test.md` for the detected artifact type:
+
+- Universal checks (U1-U5): file exists, UTF-8, has headings, no excessive blanks, size in bounds
+- Type-specific checks: skill (S1-S10), command (C1-C5), rule (R1-R4), agent (A1-A4)
+
+Display Layer 0 output as a per-check PASS/FAIL table.
+
+**Gate:** If pass rate < 80% → stop here. Do NOT proceed to Layer 1 or Layer 2.
+Report all failures with specific line references where possible.
+
+### Step 5: Layer 1 — Single LLM Judge (Quick)
+
+Run if and only if Layer 0 gate passes.
+
+**Model:** haiku
+
+Execute the Layer 1 judge prompt from `test.md` against the artifact content.
+
+Rate on 5 dimensions (1-10 each):
+1. CLARITY
+2. COMPLETENESS
+3. ACTIONABILITY
+4. QUALITY
+5. ANTI-PATTERNS
+
+Display scores, one-line justification per dimension, top 3 improvement suggestions, and VERDICT.
+
+**Gate:**
+- Average ≥ 7.0 → PASS
+- Average 5.0-6.9 → NEEDS WORK (offer Layer 2)
+- Average < 5.0 → FAIL (Layer 2 recommended)
+
+Check $ARGUMENTS for "full":
+- If "full" present → proceed directly to Layer 2 without asking
+
+Otherwise, if Layer 1 score < 7.0 → automatically offer Layer 2.
+If Layer 1 score ≥ 7.0 → ask: "Run full 3-judge panel for comprehensive evaluation? (yes/no)"
+
+### Step 6: Layer 2 — Full Judge Panel (3 Parallel Agents)
+
+Run if triggered by score threshold or user request.
+
+**Spawn 3 agents in parallel using Agent tool:**
+
+- Agent 1: "BTO Judge — Domain Expert" (model: sonnet)
+  - Focus: methodology, depth, technical correctness, domain fit
+  - Uses Judge 1 prompt from `test.md`
+
+- Agent 2: "BTO Judge — Critic" (model: sonnet)
+  - Focus: gaps, weaknesses, anti-patterns, failure scenarios
+  - Uses Judge 2 prompt from `test.md`
+
+- Agent 3: "BTO Judge — Completeness Auditor" (model: sonnet)
+  - Focus: structural coverage, cross-references, section completeness
+  - Uses Judge 3 prompt from `test.md`
+
+**Isolation:** Each agent evaluates independently. No cross-communication.
+
+**Aggregate scores after all 3 return:**
+
+Weights: Expert 0.40, Critic 0.30, Auditor 0.30
+
+Per-dimension weighted score:
+```
+dim_score = expert[dim] * 0.4 + critic[dim] * 0.3 + auditor[dim] * 0.3
+```
+
+Overall score = mean of all dimension scores.
+
+**Disagreement detection:** For any dimension where `max(scores) - min(scores) > 3` → flag for meta-judge.
+
+**Meta-judge (if triggered):**
+- Model: default (opus)
+- Present all 3 evaluations for the flagged dimension
+- Reconcile to a single score with explicit reasoning
+- Flag for human review if still unresolvable
+
+### Step 7: Record TEST_SCORE
+
+Set `TEST_SCORE` = overall weighted average (Layer 2 if run, else Layer 1 average).
+
+This value is consumed by `/bto-optimize` and by the full `/bto` pipeline.
+
+---
+
+## Checkpoint
+
+```
+═══════════════════════════════════════════════════════
+CHECKPOINT: TEST Complete
+Artifact: [path]
+Type: [detected type]
+
+Layer 0: X/Y checks passed (Z%) — PASS / FAIL
+Layer 1: X.X/10 — PASS / NEEDS WORK / FAIL
+Layer 2: X.X/10 (weighted) — [if run, else "not run"]
+
+OVERALL SCORE: X.X/10
+
+Per-Dimension (Layer 2 or Layer 1):
+  METHODOLOGY:  X.X
+  DEPTH:        X.X
+  CORRECTNESS:  X.X
+  USABILITY:    X.X
+  ROBUSTNESS:   X.X
+
+[Flagged dimensions with judge disagreement, if any]
+
+Top Improvements:
+1. [specific suggestion]
+2. [specific suggestion]
+3. [specific suggestion]
+
+• "ок" — done
+• "покажи детали [expert/critic/auditor]" — expand judge feedback
+• "оптимизируй" — run /bto-optimize with this artifact
+• "запусти полный" — re-run with Layer 2 if only Layer 1 was run
+═══════════════════════════════════════════════════════
+```
+
+Wait for user confirmation.
+
+---
+
+## Modular Usage
+
+This command is also invoked internally by:
+- `/bto` — as Step 4 (TEST phase) of the full pipeline
+- `/bto-optimize` — as baseline evaluation before optimization rounds
+
+## Critical Rules
+
+- Always run Layer 0 before any LLM evaluation — it is free and fast
+- Never spawn Layer 2 agents if Layer 0 fails (< 80% pass rate)
+- Agent tool is REQUIRED for Layer 2 — do not run judges sequentially
+- Report `TEST_SCORE` explicitly so downstream commands can consume it
+- Rubrics from `judge-rubrics.md` govern scoring anchor points for all judges
+- If "full" is in $ARGUMENTS, skip the confirmation prompt and run Layer 2 automatically

package/templates/.claude/commands/bto.md

@@ -0,0 +1,171 @@
+# /bto — Full BTO Pipeline (Build · Test · Optimize)
+
+## Usage
+```
+/bto [path to existing skill OR description of new skill]
+```
+
+## Parameters
+- $ARGUMENTS — Path to an existing skill/command directory or file, OR a natural language description of a new skill to create
+
+## Protocol
+
+### Step 1: Setup — Load Skill
+
+Read `.claude/skills/bto/SKILL.md`
+
+### Step 2: Route by Input Type
+
+Inspect $ARGUMENTS to determine mode:
+
+**If $ARGUMENTS is a path that exists on disk:**
+- Mode: TEST → OPTIMIZE
+- Skip BUILD
+- Proceed to Step 4 (TEST)
+
+**If $ARGUMENTS is a natural language description (not a path):**
+- Mode: BUILD → TEST → OPTIMIZE
+- Proceed to Step 3 (BUILD)
+
+**If $ARGUMENTS is empty:**
+- Ask the user: "Provide a path to an existing skill, or describe a new skill to build."
+- Stop and wait.
+
+---
+
+### Step 3: BUILD (only if description provided)
+
+Read `.claude/skills/bto/modules/build.md`
+
+Execute the BUILD module:
+1. Auto-detect artifact type from description
+2. QUICK mode by default — parse requirements directly from description
+3. If user said "deep" anywhere in $ARGUMENTS — activate DEEP mode (load `explore` skill first)
+4. Generate complete artifact following build templates
+5. Run self-review (Layer 0 structural check)
+6. Create all files in the target directory
+7. Record `BUILD_OUTPUT_PATH` for use in next steps
+
+**Checkpoint BUILD:**
+```
+═══════════════════════════════════════════════════════
+CHECKPOINT 1: BUILD Complete
+Artifact generated and self-reviewed.
+Files created: [list generated files]
+Path: [BUILD_OUTPUT_PATH]
+• "ок" — run TEST on the new artifact
+• "переделай [aspect]" — rebuild with changes
+• "углуби [section]" — expand a section
+═══════════════════════════════════════════════════════
+```
+Wait for user confirmation before proceeding.
+
+---
+
+### Step 4: TEST
+
+Read `.claude/skills/bto/modules/test.md`
+Read `.claude/skills/bto/references/judge-rubrics.md`
+
+**Resolve artifact path:**
+- If BUILD was run → use `BUILD_OUTPUT_PATH`
+- If path was provided in $ARGUMENTS → use that path
+
+Execute TEST module in layers:
+
+**Layer 0 — Deterministic pre-checks (always run first):**
+- Run all structural checks for detected artifact type
+- Display Layer 0 output with per-check PASS/FAIL
+- If score < 80% → stop, report failures, do not proceed to LLM layers
+
+**Layer 1 — Single LLM judge (haiku):**
+- Run if Layer 0 passes
+- Quick spot-check on all 5 dimensions
+- Display scores and top 3 improvement suggestions
+
+**Layer 2 — Full judge panel (user-triggered or if Layer 1 score < 7.0):**
+- Ask: "Run full 3-judge panel for comprehensive evaluation? (yes/no)"
+- If yes → spawn 3 parallel agents using Agent tool:
+  - Agent 1: "BTO Judge — Domain Expert" (model: sonnet)
+  - Agent 2: "BTO Judge — Critic" (model: sonnet)
+  - Agent 3: "BTO Judge — Completeness Auditor" (model: sonnet)
+- Aggregate scores with weights: Expert 0.40, Critic 0.30, Auditor 0.30
+- Flag any dimension where max - min > 3 (trigger meta-judge if needed)
+- Display full evaluation report
+
+Record `TEST_SCORE` (overall weighted average) for use in OPTIMIZE step.
+
+**Checkpoint TEST:**
+```
+═══════════════════════════════════════════════════════
+CHECKPOINT 2: TEST Complete
+Artifact: [path]
+Layer 0: X/Y checks passed
+Layer 1: X.X/10 — [PASS / NEEDS WORK / FAIL]
+Layer 2: X.X/10 (weighted) — [if run]
+
+Overall: X.X/10
+• "ок" — run OPTIMIZE
+• "пропусти" — skip optimize (artifact is good)
+• "покажи детали [judge]" — expand judge feedback
+═══════════════════════════════════════════════════════
+```
+Wait for user confirmation before proceeding.
+
+---
+
+### Step 5: OPTIMIZE
+
+Read `.claude/skills/bto/modules/optimize.md`
+
+Execute OPTIMIZE module:
+1. If `TEST_SCORE` ≥ 8.0 → report "Artifact already high quality (X.X/10). Minor tweaks only." Show specific suggestions. Stop.
+2. If `TEST_SCORE` < 8.0 → run full evolutionary optimization:
+   - Round 1: Generate 5 variants (one per mutation strategy) → evaluate with Layer 1 (haiku) → select top 2
+   - Round 2: Crossover top 2 → generate 3 variants → evaluate with Layer 1 → select top 2
+   - Round 3: Crossover → generate 3 variants → evaluate with Layer 2 (3 parallel sonnet judges) → select winner
+3. Apply the winning variant to the artifact file
+4. Display before/after delta report
+
+**Checkpoint OPTIMIZE:**
+```
+═══════════════════════════════════════════════════════
+CHECKPOINT 3: OPTIMIZE Complete
+Artifact: [path]
+Rounds run: 3
+Total evaluations: 15
+
+BEFORE → AFTER:
+  METHODOLOGY:  X.X → X.X  (+X.X)
+  DEPTH:        X.X → X.X  (+X.X)
+  CORRECTNESS:  X.X → X.X  (+X.X)
+  USABILITY:    X.X → X.X  (+X.X)
+  ROBUSTNESS:   X.X → X.X  (+X.X)
+
+  OVERALL:      X.X → X.X  (+X.X)
+
+Winning Strategy: [strategy name]
+Recommendation: [Apply / Review / Original preferred]
+• "ок" — done
+• "ещё раунд" — run another optimization round
+• "откат" — restore original artifact
+═══════════════════════════════════════════════════════
+```
+
+---
+
+## Modular Usage
+
+Each module can be run independently:
+- `/bto-build [description]` — BUILD only
+- `/bto-test [path]` — TEST only
+- `/bto-optimize [path]` — OPTIMIZE only
+
+## Critical Rules
+
+- Always run Layer 0 before any LLM evaluation — it is free and fast
+- Never skip checkpoints — wait for user "ок" between modules
+- Only run OPTIMIZE if TEST score < 8.0
+- Agent tool is REQUIRED for Layer 2 parallel judge panel
+- BUILD mode: QUICK by default, DEEP only if user explicitly requests it
+- Record artifact path from BUILD and pass it through TEST → OPTIMIZE

package/templates/.claude/rules/bto-quality-gates.md

@@ -0,0 +1,91 @@
+# BTO Quality Gate Rules
+
+## What is BTO
+BTO (Build-Test-Optimize) is a pipeline for generating, evaluating, and iteratively
+improving skills, prompts, or any structured artifact via agent-driven evaluation loops.
+These rules apply to ANY evaluation system, not just Keysarium.
+
+## Layer Architecture and Model Budget
+
+| Layer | Role | Model | Trigger |
+|-------|------|-------|---------|
+| Layer 0 | Structural pre-check (format, completeness) | haiku | Always |
+| Layer 1 | Shallow semantic check (relevance, coherence) | haiku | After Layer 0 passes |
+| Layer 2 | Deep evaluation (quality, domain fit) | sonnet (judge panel) | After Layer 1 passes |
+| Layer 3 | Creative synthesis / optimization crossover | opus | On top-N candidates only |
+
+Never promote an artifact to a higher layer if the lower layer gate fails.
+
+## Cost Optimization Table
+
+| Task | Model | Rationale |
+|------|-------|-----------|
+| Layer 0 structural checks | haiku | High-frequency, pattern-matching only |
+| Layer 1 semantic baseline | haiku | Fast coherence scan, no deep reasoning needed |
+| Judge 1 — Domain Expert | sonnet | Domain knowledge + nuanced scoring |
+| Judge 2 — Critic | sonnet | Adversarial analysis, pattern detection |
+| Judge 3 — Completeness Auditor | sonnet | Structured coverage check |
+| Meta-judge (escalation) | sonnet | Disagreement resolution |
+| Crossover / creative synthesis | opus | Novel combination of best candidates |
+| Mutation workers (standard) | sonnet | Requires reasoning about improvement direction |
+| Variant fast-eval (ranking pass) | haiku | Volume scoring before full panel |
+
+Escalate to a higher-cost model only when the lower-cost model has failed or is insufficient.
+
+## Layer 0 Mandatory Checks
+Every generated skill or artifact MUST pass ALL of these before entering judge panel:
+
+- [ ] Required sections present (structure check)
+- [ ] No empty placeholders (`[TODO]`, `[TBD]`, `<INSERT>`)
+- [ ] Length within bounds (not below minimum, not above maximum)
+- [ ] Encoding valid (no broken unicode, no binary artifacts)
+- [ ] Self-reference loop absent (artifact does not cite itself as source)
+
+If any check fails → reject immediately, log reason, do NOT send to judges.
+Layer 0 may auto-retry up to 3 times before escalating to human review.
+
+## Judge Panel Rules
+
+- Panel MUST have an odd number of judges: 3 (standard) or 5 (high-stakes)
+- Each judge operates in strict isolation: reads the same artifact, writes to a separate evaluation file
+- Judges do NOT see each other's scores before submitting
+- Final score = weighted average (weights defined per panel configuration)
+- Standard weights: Domain Expert 0.4 / Critic 0.3 / Completeness Auditor 0.3
+- Disagreement threshold: if max_score - min_score > 3 points → escalate to meta-judge
+
+## Optimization Delta Gate
+
+- An optimization iteration is accepted ONLY if: `new_score - prev_score > 0.5`
+- If delta <= 0.5 for 3 consecutive iterations → declare convergence and stop
+- If score DECREASES by > 1.0 → rollback to previous best and log regression
+- Improvement must be measurable on the same rubric used in the previous iteration
+
+## Human Checkpoint Rules
+
+- NEVER auto-approve any artifact for delivery without a human checkpoint
+- Checkpoint is required after: Layer 2 evaluation, final optimization round, before packaging
+- Checkpoint format follows the standard checkpoint-protocol.md
+- Exception: Layer 0 rejections may be auto-retried up to 3 times before human escalation
+
+## BTO-Specific Anti-Patterns
+
+| Anti-Pattern | Detection Signal | Required Fix |
+|-------------|-----------------|--------------|
+| Score inflation | All judges score > 8.5 on first attempt | Add calibration prompt to critics |
+| Overfitting to rubric | Artifact optimizes wording to match rubric literally | Blind evaluation: hide rubric from generator |
+| Conformity collapse | Judges converge to identical scores after 1 round | Enforce isolation, re-randomize judge order |
+| Runaway optimization | > 10 iterations without convergence | Abort, log, human review |
+| Phantom improvement | Delta > 0.5 but no substantive content change | Diff-check content, not just score |
+| Judge-generator collusion | Same model used for both generation and evaluation | BLOCK — generator and judge models must differ |
+| Missing rejection log | Failed artifacts silently discarded | Every rejection MUST be logged with reason |
+
+## Auto-Detection
+Self-check generated artifacts and evaluation results against the anti-patterns above.
+If detected, flag with a WARNING label and halt the BTO loop pending human review.
+
+## Reusability Note
+These rules are artifact-type agnostic. Apply them to:
+- Skill generation pipelines
+- Prompt optimization loops
+- Presentation scoring systems
+- Any multi-judge evaluation workflow