[Context] → [Question]
    ↓
Cannot reference Question content when processing Context tokens
Attention weights for Context are already finalized by the time Question tokens appear

[First Pass]                [Second Pass]
Context → Question    →    Context' → Question'
                              ↑         ↑
                          Can reference entire first pass

undefined

undefined

def apply_prompt_repetition(prompt: str, times: int = 2) -> str:
    """Repeat the prompt a specified number of times

    Args:
        prompt: Original prompt
        times: Number of repetitions (default 2)

    Returns:
        Repeated prompt
    """
    if times <= 1:
        return prompt
    return "\n\n".join([prompt] * times)

A. Paris
B. London
C. Berlin
D. Madrid

Which city is the capital of France?
Reply with one letter.

A. Paris
B. London
C. Berlin
D. Madrid

Which city is the capital of France?
Reply with one letter.

A. Paris
B. London
C. Berlin
D. Madrid

Which city is the capital of France?
Reply with one letter.

A

Inventory:
1. Iron Sword
2. Leather Armor
3. Health Potion (x5)
4. Magic Staff
...
25. Dragon Scale
...
50. Ancient Map

What item is in slot 25?

Dragon Scale

Use the calculator tool to compute 234 * 567.
What is the result?

Use the calculator tool to compute 234 * 567.
What is the result?

Use the calculator tool to compute 234 * 567.
What is the result?

"""prompt_repetition_transformer.py"""
from dataclasses import dataclass, field
from typing import Optional, Callable, List
import re

def __init__(self, config: Optional[PromptRepetitionConfig] = None):
    self.config = config or PromptRepetitionConfig()

def should_apply(self, model: str, prompt: str) -> bool:
    """Determine whether to auto-apply"""
    # Skip if already applied
    if self.config.applied_marker in prompt:
        return False

    # Check target model
    model_lower = model.lower()
    if not any(m in model_lower for m in AUTO_APPLY_MODELS):
        return False

    # Skip when CoT pattern detected
    prompt_lower = prompt.lower()
    for pattern in COT_PATTERNS:
        if re.search(pattern, prompt_lower):
            return False

    return True

def determine_repetitions(self, prompt: str, model: str) -> int:
    """Determine repetition count based on task type"""
    prompt_lower = prompt.lower()

    # Position/Index pattern detected → 3×
    for pattern in POSITION_PATTERNS:
        if re.search(pattern, prompt_lower):
            return self.config.position_repetitions

    return self.config.default_repetitions

def estimate_tokens(self, text: str) -> int:
    """Simple token count estimation (speed over precision)"""
    # Estimate approximately 4 characters = 1 token
    return len(text) // 4

def transform(self, prompt: str, model: str) -> str:
    """Apply repetition to prompt"""
    if not self.should_apply(model, prompt):
        return prompt

    repetitions = self.determine_repetitions(prompt, model)

    # Check context limit
    model_lower = model.lower()
    max_tokens = 128_000  # Default value
    for m, tokens in MODEL_CONTEXT_WINDOWS.items():
        if m in model_lower:
            max_tokens = tokens
            break

    max_allowed = int(max_tokens * self.config.max_context_ratio)
    prompt_tokens = self.estimate_tokens(prompt)

    # Reduce repetitions if token limit exceeded
    while prompt_tokens * repetitions > max_allowed and repetitions > 1:
        repetitions -= 1

    if repetitions <= 1:
        return prompt

    # Apply repetition + add marker
    repeated = self.config.separator.join([prompt] * repetitions)
    return f"{self.config.applied_marker}\n{repeated}"

def wrap_llm_call(self, llm_fn: Callable, model: str) -> Callable:
    """Wrap LLM call function"""
    def wrapped(prompt: str, **kwargs):
        transformed = self.transform(prompt, model)
        return llm_fn(transformed, **kwargs)
    return wrapped

---

def run_ab_test(prompts: List[str], llm_fn, model: str, ground_truth: List[str]):
    """A/B test for prompt repetition effectiveness"""
    transformer = PromptRepetitionTransformer()

    results = {"baseline": [], "repeated": []}

    for prompt, expected in zip(prompts, ground_truth):
        # Baseline
        response_a = llm_fn(prompt)
        results["baseline"].append(response_a == expected)

        # With Repetition
        repeated_prompt = transformer.transform(prompt, model)
        response_b = llm_fn(repeated_prompt)
        results["repeated"].append(response_b == expected)

    baseline_acc = sum(results["baseline"]) / len(prompts)
    repeated_acc = sum(results["repeated"]) / len(prompts)

    print(f"Baseline accuracy: {baseline_acc:.2%}")
    print(f"Repeated accuracy: {repeated_acc:.2%}")
    print(f"Improvement: {repeated_acc - baseline_acc:+.2%}p")

[Claude Sonnet] Planning (no repetition needed)
    ↓
[Gemini Flash] Analysis (repetition ×2 auto-applied, marker added)
    ↓
[Claude Haiku] Execution (marker detected → skip duplicate apply)

undefined

def apply_auto_skills(self, prompt: str, model: str) -> str:
    """Handle auto-apply skills"""
    # Auto-apply prompt-repetition
    for skill in self.skills.values():
        auto_apply = skill.get('data', {}).get('auto-apply', {})
        if auto_apply.get('trigger') == 'auto':
            target_models = auto_apply.get('models', [])
            if any(m in model.lower() for m in target_models):
                prompt = self.prompt_transformer.transform(prompt, model)

    return prompt

---

=== Auto-Apply Target Models ===
claude-3-haiku, claude-haiku
gemini-flash, gemini-flash-lite, gemini-2.0-flash
gpt-4o-mini, gpt-low

=== Repetition Count ===
General tasks: 2×
Position/Index (slot/position/index keywords): 3×
With CoT: 0× (not applied)

=== Effect (Google Research 2025) ===
Improvement rate: 67% (47/70 benchmarks)
Performance degradation: 0 cases
Maximum improvement: +76%p (NameIndex)

=== Cost ===
Input tokens: +100%
Latency: +2% (Prefill parallelization)
Cost per correct answer: +5%

=== Duplicate Application Prevention ===
Marker: <!-- prompt-repetition-applied -->