[Context] → [Question]
    ↓
处理Context token时无法参考Question内容
Question token出现时，对Context的注意力权重已确定

[第一次处理]                [第二次处理]
Context → Question    →    Context' → Question'
                              ↑         ↑
                          可参考第一次处理的全部内容

# 自动应用前的上下文检查
max_context = model_context_window * 0.8  # 80%安全余量
if len(prompt_tokens) * repetitions > max_context:
    repetitions = max(1, int(max_context / len(prompt_tokens)))

def apply_prompt_repetition(prompt: str, times: int = 2) -> str:
    """将提示词重复指定次数

    Args:
        prompt: 原始提示词
        times: 重复次数（默认2次）

    Returns:
        重复后的提示词
    """
    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

# 各模型的上下文窗口（token数量）
MODEL_CONTEXT_WINDOWS = {
    "claude-3-haiku": 200_000,
    "claude-haiku": 200_000,
    "gemini-flash": 1_000_000,
    "gemini-flash-lite": 1_000_000,
    "gemini-2.0-flash": 1_000_000,
    "gpt-4o-mini": 128_000,
    "gpt-low": 128_000,
}

# 自动应用的目标模型
AUTO_APPLY_MODELS = list(MODEL_CONTEXT_WINDOWS.keys())

# CoT模式（不适用提示词重复）
COT_PATTERNS = [
    r"step by step",
    r"think through",
    r"let's think",
    r"reasoning:",
    r"chain of thought",
]

# 位置/索引模式（重复3次）
POSITION_PATTERNS = [
    r"slot \d+",
    r"position \d+",
    r"index \d+",
    r"\d+번째",
    r"item \d+",
    r"row \d+",
    r"column \d+",
]

@dataclass
class PromptRepetitionConfig:
    """提示词重复配置"""
    default_repetitions: int = 2
    position_repetitions: int = 3
    separator: str = "\n\n"
    max_context_ratio: float = 0.8
    applied_marker: str = "<!-- prompt-repetition-applied -->"

class PromptRepetitionTransformer:
    """轻量模型专用提示词重复自动应用转换器"""

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

    def should_apply(self, model: str, prompt: str) -> bool:
        """判断是否应自动应用"""
        # 已应用过则跳过
        if self.config.applied_marker in prompt:
            return False

        # 检查是否为目标模型
        model_lower = model.lower()
        if not any(m in model_lower for m in AUTO_APPLY_MODELS):
            return False

        # 检测到CoT模式则跳过
        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:
        """根据任务类型确定重复次数"""
        prompt_lower = prompt.lower()

        # 检测到位置/索引模式 → 重复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:
        """简易token数量估算（优先速度而非精度）"""
        # 平均每4个字符=1个token
        return len(text) // 4

    def transform(self, prompt: str, model: str) -> str:
        """对提示词应用重复处理"""
        if not self.should_apply(model, prompt):
            return prompt

        repetitions = self.determine_repetitions(prompt, model)

        # 检查上下文限制
        model_lower = model.lower()
        max_tokens = 128_000  # 默认值
        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)

        # 超出token限制时调整重复次数
        while prompt_tokens * repetitions > max_allowed and repetitions > 1:
            repetitions -= 1

        if repetitions <= 1:
            return prompt

        # 应用重复处理并添加标记
        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:
        """包装LLM调用函数"""
        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测试"""
    transformer = PromptRepetitionTransformer()

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

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

        # 重复应用组
        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_acc:.2%}")
    print(f"重复应用后准确率: {repeated_acc:.2%}")
    print(f"提升幅度: {repeated_acc - baseline_acc:+.2%}p")

[Claude Sonnet] 制定计划（无需重复）
    ↓
[Gemini Flash] 分析（自动重复2次，添加标记）
    ↓
[Claude Haiku] 执行（检测到标记 → 跳过重复应用）

# 需添加到skill_loader.py的代码
from prompt_repetition_transformer import PromptRepetitionTransformer

class SkillLoader:
    def __init__(self, ...):
        # ... 原有代码 ...
        self.prompt_transformer = PromptRepetitionTransformer()

    def apply_auto_skills(self, prompt: str, model: str) -> str:
        """处理自动应用的技巧"""
        # 自动应用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

=== 自动应用目标模型 ===
claude-3-haiku, claude-haiku
gemini-flash, gemini-flash-lite, gemini-2.0-flash
gpt-4o-mini, gpt-low

=== 重复次数 ===
普通任务：2次
位置/索引类（含slot/position/index关键词）：3次
搭配CoT：0次（不适用）

=== 效果（Google Research 2025） ===
提升占比：67%（47/70基准任务）
性能下降：0例
最大提升幅度：+76个百分点（NameIndex任务）

=== 成本 ===
输入Token：+100%
延迟：+2%（Prefill并行化）
单正确答案成本：+5%

=== 避免重复应用 ===
标记：<!-- prompt-repetition-applied -->