Recipe Playground Price Alert

Playground: Price Alert

PREREQUISITE: Load kraken-playground and kraken-alert-patterns to run this recipe. This recipe is an example, not a boundary. Adapt the steps to your hypothesis, or write your own driver (see kraken-playground → Driving Your Own Hypothesis).

Watch key price levels on live prices and record each crossing as an alert decision, capturing the market data and the "why" into one session for later replay and analysis. Alert-only: it records crossings, it never places a trade.

Use this skill for:

• watching one or more price levels over a window
• recording each level break as an alert with the numbers behind it
• grading afterward which levels were hit, when, and which were never touched

Important

Alerts are informational and never execute a trade (see kraken-alert-patterns). This recipe records a session (market data + alert decisions); it never places a live order.

Pacing is external. /loop owns the schedule and fires one round per interval (see kraken-playground → Pacing). A cadence the operator names is a commitment: record it as interval_s and honor it — polls may run late, never early. A session whose params omit interval_s may not claim or imply any cadence in its report.

Over a long window this recipe is observational — a missed poll is not a missed crossing. The recorder holds every level break, so late visits (or none) still grade the hypothesis at stop time (see kraken-playground → Running over a Window).

Params

Every level that gates an alert goes in --strategy-params, not only in prose reasons. That is what makes two sessions comparable knob-for-knob:

• upper: alert when price breaks above this level
• lower: alert when price breaks below this level
• interval_s: spacing between rounds; set the /loop interval to this value

The values in the example are placeholders. A level the operator names replaces the example verbatim — params that don't match the request record a hypothesis nobody asked to test.

Quick Start

Natural language:

Watch BTC for 30 minutes. Alert me if price breaks above $70,000 or below
$60,000. Check every 5 minutes. At the end, show which levels were hit and when.

Start the Session

Work inside a paper workspace (create one once: kraken workspace create alerts --capital 10000 --mode paper), then:

export KRAKEN_WORKSPACE=alerts

kraken session start \
  --symbols BTC/USD --channels ticker,trade --to duckdb,jsonl \
  --label alert-btc-$(date +%Y%m%d-%H%M%S) \
  --strategy recipe-playground-price-alert \
  --strategy-params '{"upper":70000,"lower":60000,"interval_s":300}' \
  -o json 2>/dev/null &

# The session_started stdout line carries the id: {"type":"session_started","session":"s<n>",...}

Print the session id to the user right after starting, and again in the final report — it is the handle for resuming the /loop, checking kraken session show, and locating the artifacts.

Schedule the Rounds

/loop owns the pacing. Set its interval to interval_s and it fires each round on cadence (late under jitter, never early). Parse the interval from the user's request: "every 5 minutes" to 5m, "every 2 minutes" to 2m, "every hour" to 1h.

The scheduler floor is 60 seconds (/loop, cron, and ScheduleWakeup all clamp to a one-minute minimum). interval_s must be >= 60. If the user asks for a sub-minute cadence ("every 30 seconds"), clamp to 60 and tell them — never set a sub-minute interval_s and never let the report claim a cadence the harness cannot run.

/loop 5m "Run one price-alert round for session s<n> in workspace alerts per recipe-playground-price-alert"

Do not re-add an elapsed-time gate inside the round. /loop already enforces the spacing.