strategy-translate

strategy-translate (placeholder)

Fourth stage of the paper-to-production pipeline. Converts a validated vectorized backtest into an event-driven strategy file.

⚠️ This skill is currently a placeholder

The vectorized → event-driven translation depends on your team's specific event-driven framework (event types, function signatures, order and position API, clock handling). Rather than guess, this skill refuses to emit strategy code until references/framework_spec.md is filled in with real contracts.

Run:

python scripts/check_spec.py

It will exit non-zero and tell you exactly what the spec must include. Once framework_spec.md is filled in, re-run.

Runtime

Requires Python ≥ 3.9 and pytest (for the bundled sizing tests); install via the plugin's root requirements.txt.

When (eventually) to use

• A validated papers/<arxiv-id>/code/backtest.py exists and benchmark.md says at least "partially replicated" with medium+ confidence.
• The team's event-driven framework spec is complete.

What the skill will translate

Once the spec is real, the translator maps vectorized operations into the event loop:

Vectorized idiom	Event-driven equivalent
prices.pct_change()	track last close per symbol, compute on new bar
weights.shift(1) * returns	apply prior-bar weight to realized P&L on on_bar
signal.rolling(L).mean()	maintain an online rolling buffer of length L
rebalance daily	schedule on every on_bar end-of-day event

Generated files land in papers/<arxiv-id>/strategy/:

• strategy.py — the event-driven implementation.
• sizing.py — imports size_contracts from this skill's bundled script.
• tests/test_strategy.py — minimum: sizing unit tests + one bar-replay sanity test.

Contract sizing — the money-losing bug class

Even though translation is a placeholder, the sizing math is NOT — it ships fully implemented at scripts/size_contracts.py with unit tests at scripts/tests/test_size_contracts.py. Run:

python -m pytest scripts/tests/test_size_contracts.py -v

The tests MUST pass before any strategy goes live. Sizing errors cost real money.

The function

def size_contracts(target_notional, price, multiplier,
                   margin_rate, available_capital):
    contracts = round(target_notional / (price * multiplier))
    margin_required = abs(contracts) * price * multiplier * margin_rate
    if margin_required > available_capital:
        scale = available_capital / margin_required
        contracts = int(contracts * scale)
    return contracts

Handles:

• Fractional → integer contract rounding.
• Margin check against available capital.
• Automatic scale-down when margin would be breached (never silently over-leverages).
• Short positions (negative target notional).

Rules

• Do NOT translate without a populated framework_spec.md.
• Do NOT ship a strategy without passing test_size_contracts.py.
• Generated strategy.py must include its own smoke test that replays at least one historical day of bars and asserts P&L within a tolerance of the vectorized backtest — otherwise translation errors slip into production.