ROLE: You are a senior Python developer building production alerting infrastructure. CONTEXT: - We need to send messages from a trading firm to a private Telegram chat - Credentials are stored in config/notifications.json with keys: telegram_token, telegram_chat_id - The function will be called from many other scripts — must be robust TASK: Write a Python module scripts/telegram.py that exposes: send_telegram(message: str, parse_mode: str = "HTML") -> bool Requirements: 1. Load config from BASE/config/notifications.json (BASE = parent dir) 2. POST to api.telegram.org with 10s timeout 3. Retry once on network error 4. Return True on HTTP 200, False otherwise 5. Log failures (not successes) to logs/telegram.log 6. Support HTML formatting tags OUTPUT FORMAT: A single complete Python file, no commentary, no markdown fences. Include all imports. Include a __main__ block that sends "test alert". CONSTRAINTS: - No external dependencies beyond requests + pathlib + json + logging - No hardcoded credentials

ROLE: You are a senior Python developer. CONTEXT: - We need a Telegram bot that listens for commands and dispatches them - It runs as a launchd job with KeepAlive=true (must crash-resist) - Commands must come ONLY from telegram_chat_id in config TASK: Write scripts/telegram_listener.py that: 1. Long-polls api.telegram.org/getUpdates with 30s timeout 2. On each message, validates sender_id == telegram_chat_id 3. Routes commands: /status -> reads dashboard/trades.json and replies with NAV + positions /halt -> touches memory/HALT (executors check this flag) /resume -> removes memory/HALT /pnl -> computes daily P&L from trades.json 4. Logs every command + response to logs/telegram.log 5. Sleeps 1s and loops forever OUTPUT FORMAT: Single Python file. No commentary. No markdown fences. CONSTRAINTS: - Use only stdlib + requests - Must survive network errors without crashing

ROLE: You are a senior Python developer building communication infrastructure. CONTEXT: - We need to send HTML emails as a backup to Telegram alerts - Both Gmail and Yahoo are supported via SMTP with App Passwords - Credentials are in config/notifications.json: { "email_provider": "gmail" | "yahoo", "email_from": "you@gmail.com", "email_app_password": "...", "email_to": "alerts@you.com" } TASK: Write scripts/email.py that exposes: send_email(subject: str, body_html: str) -> bool Requirements: 1. Look up SMTP server + port from provider: gmail -> smtp.gmail.com:587 yahoo -> smtp.mail.yahoo.com:587 2. Use STARTTLS on port 587 3. Send MIME multipart with HTML body 4. Timeout 15s; one retry on failure 5. Log failures to logs/email.log 6. Return True on success OUTPUT FORMAT: Single Python file. No commentary. No markdown fences. CONSTRAINTS: - stdlib only (smtplib, email.mime, ssl, json, pathlib, logging) - Never log the app password

ROLE: You are a quantitative developer building market data infrastructure. CONTEXT: - We use yfinance as the primary data source (free, no API key) - All strategies read from this module — must be reliable - Anti-lookahead bias is non-negotiable: signal generation uses .shift(1) - Data must be cached locally so we don't re-download on every script TASK: Write scripts/market_data.py that exposes: get_history(symbol: str, period: str = "1y", interval: str = "1d") -> DataFrame Returns OHLCV DataFrame, cached for 1 hour in memory/cache/. get_universe(symbols: list[str], period: str = "1y") -> DataFrame Batch download. Returns multi-column DataFrame keyed by symbol. get_vix() -> float Returns the latest VIX close. get_spy_regime() -> str Returns "bullish" if SPY > SPY.SMA(50), else "bearish". compute_signal(data: DataFrame, lookback: int = 30) -> DataFrame Returns lookback-day % change SHIFTED by 1 (anti-lookahead). OUTPUT FORMAT: Single Python file. No commentary. No markdown fences. Include type hints. Include docstrings on each public function. CONSTRAINTS: - Use yfinance, pandas, numpy only - Cache to memory/cache/ as parquet files - Stale cache after 3600s (1 hour)

ROLE: You are a senior Python developer building Claude agents with tool use. CONTEXT: - We use anthropic Python SDK with Claude Sonnet 4.6 - Agents need to be able to call functions — read files, query data, place orders - The tool-use loop must handle multi-turn responses TASK: Write scripts/agent.py that: 1. Defines two tools using Claude's tool schema: - get_positions() -> reads dashboard/trades.json - get_quote(symbol: str) -> reads dashboard/quotes.json 2. Implements run_agent(system_prompt, user_message) that: a. Sends initial message with both tools defined b. If response has tool_use blocks, executes the local functions c. Sends tool_result back in next turn d. Loops until response is text-only e. Returns the final text answer 3. Handles errors gracefully (tool errors do NOT crash the loop) OUTPUT FORMAT: Single Python file with both tool definitions and the loop. Include a __main__ block: ask "What positions are open?" and print the answer. CONSTRAINTS: - Use anthropic SDK - Max 6 tool-use turns before forcing text reply - Log every tool call to logs/agent.log

ROLE: You are a senior systems engineer building production schedulers on macOS. CONTEXT: - The firm has 6 recurring jobs that need to run automatically: marketopen (8:55am ET Mon-Fri) quotes (every 15 min) sync (every 5 min) execution (9:35am ET Mon-Fri) heartbeat (every 5 min) daily (4:30pm ET Mon-Fri) - All scripts live under /Users/<you>/my-firm/scripts/ - Python runtime is /usr/local/bin/python3.14 TASK: Generate 6 launchd plist files I can drop into ~/Library/LaunchAgents/. Each plist must: 1. Label as com.firm.<jobname> 2. Use StartCalendarInterval for time-of-day jobs, StartInterval for intervals 3. Set KeepAlive=false (we don't want infinite restart on time-bounded jobs) 4. Redirect stdout to /tmp/<jobname>.out and stderr to /tmp/<jobname>.err 5. Pass the full python3.14 path + script path in ProgramArguments OUTPUT FORMAT: 6 plist files concatenated, each prefixed with a comment line: <!-- FILE: com.firm.marketopen.plist --> No commentary outside the files themselves. CONSTRAINTS: - Use proper XML escaping - Use absolute paths only - Weekday entries: 1=Mon, 2=Tue, 3=Wed, 4=Thu, 5=Fri

ROLE: You are a senior systems engineer building production schedulers on Linux. CONTEXT: - Same 6 firm jobs as the macOS prompt - Target system: Ubuntu 24.04 LTS - Python at /usr/bin/python3.14 - User running them: 'firmuser' TASK: Generate BOTH cron and systemd versions: VERSION 1 — crontab entries (single block): Format: minute hour dom month dow command Use absolute paths. Redirect output to /var/log/firm/<jobname>.log. VERSION 2 — systemd timer + service pair for each job: <jobname>.service — defines what to run, User=firmuser <jobname>.timer — defines when, OnCalendar= or OnUnitActiveSec= OUTPUT FORMAT: Header "=== CRON ===" followed by the crontab block. Header "=== SYSTEMD ===" followed by each .service / .timer file with FILE: comments. CONSTRAINTS: - No commentary outside the files - Use absolute paths everywhere

ROLE: You are a senior agent designer. You write AGENTS.md identity files for production AI agents in autonomous trading firms. CONTEXT: The firm runs on Paperclip with hub-and-spoke topology: CEO -> routes work to: Research, Risk, Execution, Comms, Compliance Each agent has an AGENTS.md file that defines its role completely. TASK: Given an agent role provided by the user, generate a complete AGENTS.md with EXACTLY these sections in this order: # <Role Name> Agent ## Role <1-2 sentences describing the agent's job> ## Authority <bullet list of what this agent CAN do> ## Hard Rules <numbered list of non-negotiable rules — at least 4> ## Tools Available <bullet list of functions/modules this agent can call> ## Escalation <when and to whom this agent escalates> ## Tone <one sentence on communication style> OUTPUT FORMAT: A single Markdown file. No commentary outside the file. CONSTRAINTS: - The "Hard Rules" section must include at least one rule about paper mode - The "Tone" must be terse and factual - Never include marketing language

ROLE: You are a principal engineer integrating six existing modules into one clean notification system. CONTEXT: We have these working modules in scripts/: telegram.py -> send_telegram(msg, parse_mode) email.py -> send_email(subject, body_html) market_data.py -> get_vix(), get_spy_regime(), get_history() agent.py -> run_agent(system_prompt, user_msg) We need a single entry point: notifier.py that decides where alerts go. TASK: Write scripts/notifier.py that exposes: notify(message: str, level: str = "info") -> dict Routing rules: level "debug" -> log only (no send) level "info" -> Telegram only level "warning" -> Telegram + log level "critical" -> Telegram + email + log level "error" -> Telegram + email + log + halt-check Behavior: - Returns dict: {"telegram": bool, "email": bool, "logged": bool} - On critical/error, also writes to memory/HALT-PENDING (requires human resume) - On Telegram failure for warning+, fall back to email automatically - Every call writes one line to logs/notifier.log OUTPUT FORMAT: Single Python file. No commentary. No markdown fences. CONSTRAINTS: - Re-use existing modules, do not reimplement - No new external dependencies - Each notification level must be testable independently