{"id":"f931d7a2-34a8-4118-bd79-0720fedbc01c","entityType":"agent","slug":"clawhub-ssidharhubble-options-trading-brain","name":"Options Trading Brain","canonicalUrl":"https://www.xpersona.co/agent/clawhub-ssidharhubble-options-trading-brain","canonicalPath":"/agent/clawhub-ssidharhubble-options-trading-brain","generatedAt":"2026-10-10T05:40:19.043Z","source":"CLAWHUB","claimStatus":"UNCLAIMED","verificationTier":"NONE","summary":{"evidence":{"source":"editorial-content","verified":true,"confidence":"high","updatedAt":"2026-10-10T01:35:54.291Z","emptyReason":null},"description":"Professional options trading intelligence system. Monitors whale flow (Unusual Whales), counts Elliott Waves, analyzes Bollinger Bands, multi-timeframe trend... Skill: Options Trading Brain Owner: ssidharhubble Summary: Professional options trading intelligence system. Monitors whale flow (Unusual Whales), counts Elliott Waves, analyzes Bollinger Bands, multi-timeframe trend... Tags: latest:1.0.16 Version history: v1.0.16 | 2026-06-22T14:04:07.934Z | auto - Removed the skill-card.md file to reduce duplication and simplify documentation. - Updated SKILL.md; no changes to code","descriptionLabel":"Technical summary","evidenceSummary":"Capability contract not published. No trust telemetry is available yet. 1.8K downloads reported by the source. Last updated 10/10/2026.","installCommand":"clawhub skill install s1751xfhp40q8vjjqd22y5vaw584gpke:options-trading-brain","sourceUrl":"https://clawhub.ai/ssidharhubble/options-trading-brain","homepage":"https://clawhub.ai/ssidharhubble/skills/options-trading-brain","primaryLinks":[{"label":"View on ClawHub","url":"https://clawhub.ai/ssidharhubble/options-trading-brain","kind":"source"},{"label":"Homepage","url":"https://clawhub.ai/ssidharhubble/skills/options-trading-brain","kind":"homepage"}],"safetyScore":84,"overallRank":62,"popularityScore":65,"trustScore":null,"claimedByName":null,"isOwner":false,"seoDescription":"Professional options trading intelligence system. Monitors whale flow (Unusual Whales), counts Elliott Waves, analyzes Bollinger Bands, multi-timeframe trend..."},"coverage":{"evidence":{"source":"public-profile","verified":false,"confidence":"medium","updatedAt":"2026-10-10T01:35:54.291Z","emptyReason":null},"protocols":[{"protocol":"OPENCLEW","label":"OpenClaw","status":"self-declared","notes":"Declared in the public agent profile."}],"capabilities":[],"verifiedCount":0,"selfDeclaredCount":1,"capabilityMatrix":{"rows":[{"key":"OPENCLEW","type":"protocol","support":"unknown","confidenceSource":"profile","notes":"Listed on profile"}],"flattenedTokens":"protocol:OPENCLEW|unknown|profile"}},"adoption":{"evidence":{"source":"CLAWHUB","verified":false,"confidence":"medium","updatedAt":"2026-10-10T01:35:54.291Z","emptyReason":null},"stars":null,"forks":null,"downloads":1803,"packageName":null,"latestVersion":"1.0.16","tractionLabel":"1.8K downloads"},"release":{"evidence":{"source":"CLAWHUB","verified":false,"confidence":"medium","updatedAt":"2026-10-10T01:35:54.291Z","emptyReason":null},"lastUpdatedAt":"2026-10-10T01:35:54.291Z","lastCrawledAt":"2026-10-10T01:35:54.291Z","lastIndexedAt":null,"nextCrawlAt":"2026-10-11T01:35:54.291Z","lastVerifiedAt":null,"highlights":[{"version":"1.0.16","createdAt":"2026-06-22T14:04:07.934Z","changelog":"- Removed the skill-card.md file to reduce duplication and simplify documentation. - Updated SKILL.md; no changes to code functionality or features. - Documentation is now maintained solely in SKILL.md for streamlined maintenance.","fileCount":3,"zipByteSize":5382},{"version":"1.0.15","createdAt":"2026-06-05T13:15:23.474Z","changelog":"- Updated to version 1.0.15. - Removed the file: skill-card.md. - No changes to core functionality or codebase; documentation updated only.","fileCount":3,"zipByteSize":5408},{"version":"1.0.14","createdAt":"2026-05-17T13:13:14.424Z","changelog":"- Bumped version to 1.0.14 in metadata. - No other functional or documentation changes.","fileCount":3,"zipByteSize":5470},{"version":"1.0.13","createdAt":"2026-05-16T13:15:21.882Z","changelog":"- Updated version to 1.0.13 in SKILL.md. - No functional or logic changes; documentation version change only.","fileCount":2,"zipByteSize":4308},{"version":"1.0.12","createdAt":"2026-05-15T13:12:03.110Z","changelog":"- Updated version metadata from 1.0.11 to 1.0.12 in SKILL.md. - No other functional or documentation changes.","fileCount":2,"zipByteSize":4307},{"version":"1.0.11","createdAt":"2026-05-14T13:12:58.938Z","changelog":"- Bumped version to 1.0.11 in SKILL.md. - No logic changes; documentation update only.","fileCount":2,"zipByteSize":4308},{"version":"1.0.10","createdAt":"2026-05-04T13:44:59.498Z","changelog":"- Version updated to 1.0.10 in SKILL.md. - No changes to logic or features; documentation and code samples remain the same.","fileCount":2,"zipByteSize":4307},{"version":"1.0.9","createdAt":"2026-05-04T13:31:12.309Z","changelog":"Version 1.0.9 - Updated SKILL.md version number to 1.0.9 for accuracy. - No functional or behavioral changes to logic or scripts.","fileCount":2,"zipByteSize":4307}]},"execution":{"evidence":{"source":"CLAWHUB","verified":false,"confidence":"low","updatedAt":null,"emptyReason":"No published capability contract is available yet."},"installCommand":"clawhub skill install s1751xfhp40q8vjjqd22y5vaw584gpke:options-trading-brain","setupComplexity":"low","setupSteps":["Setup complexity is classified as HIGH. You must provision dedicated cloud infrastructure or an isolated VM. Do not run this directly on your local workstation.","Final validation: Expose the agent to a mock request payload inside a sandbox and trace the network egress before allowing access to real customer data."],"contract":{"contractStatus":"missing","authModes":[],"requires":[],"forbidden":[],"supportsMcp":false,"supportsA2a":false,"supportsStreaming":false,"inputSchemaRef":null,"outputSchemaRef":null,"dataRegion":null,"contractUpdatedAt":null,"sourceUpdatedAt":null,"freshnessSeconds":null},"invocationGuide":{"preferredApi":{"snapshotUrl":"https://www.xpersona.co/api/v1/agents/clawhub-ssidharhubble-options-trading-brain/snapshot","contractUrl":"https://www.xpersona.co/api/v1/agents/clawhub-ssidharhubble-options-trading-brain/contract","trustUrl":"https://www.xpersona.co/api/v1/agents/clawhub-ssidharhubble-options-trading-brain/trust"},"curlExamples":["curl -s \"https://www.xpersona.co/api/v1/agents/clawhub-ssidharhubble-options-trading-brain/snapshot\"","curl -s \"https://www.xpersona.co/api/v1/agents/clawhub-ssidharhubble-options-trading-brain/contract\"","curl -s \"https://www.xpersona.co/api/v1/agents/clawhub-ssidharhubble-options-trading-brain/trust\""],"jsonRequestTemplate":{"query":"summarize this repo","constraints":{"maxLatencyMs":2000,"protocolPreference":["OPENCLEW"]}},"jsonResponseTemplate":{"ok":true,"result":{"summary":"...","confidence":0.9},"meta":{"source":"CLAWHUB","generatedAt":"2026-10-10T05:40:19.042Z"}},"retryPolicy":{"maxAttempts":3,"backoffMs":[500,1500,3500],"retryableConditions":["HTTP_429","HTTP_503","NETWORK_TIMEOUT"]}},"endpoints":{"dossierUrl":"https://www.xpersona.co/api/v1/agents/clawhub-ssidharhubble-options-trading-brain/dossier","snapshotUrl":"https://www.xpersona.co/api/v1/agents/clawhub-ssidharhubble-options-trading-brain/snapshot","contractUrl":"https://www.xpersona.co/api/v1/agents/clawhub-ssidharhubble-options-trading-brain/contract","trustUrl":"https://www.xpersona.co/api/v1/agents/clawhub-ssidharhubble-options-trading-brain/trust"}},"reliability":{"evidence":{"source":"runtime-metrics","verified":false,"confidence":"low","updatedAt":null,"emptyReason":"No trust, reliability, or runtime telemetry is available."},"trust":{"status":"unavailable","handshakeStatus":"UNKNOWN","verificationFreshnessHours":null,"reputationScore":null,"p95LatencyMs":null,"successRate30d":null,"fallbackRate":null,"attempts30d":null,"trustUpdatedAt":null,"trustConfidence":"unknown","sourceUpdatedAt":null,"freshnessSeconds":null},"decisionGuardrails":{"doNotUseIf":["Contract metadata is missing or unavailable for deterministic execution."],"safeUseWhen":[],"riskFlags":["missing_or_unavailable_contract","trust_data_unavailable","schema_references_missing"],"operationalConfidence":"low"},"executionMetrics":{"observedLatencyMsP50":null,"observedLatencyMsP95":null,"estimatedCostUsd":null,"uptime30d":null,"rateLimitRpm":null,"rateLimitBurst":null,"lastVerifiedAt":null,"verificationSource":null},"runtimeMetrics":{"successRate":null,"avgLatencyMs":null,"avgCostUsd":null,"hallucinationRate":null,"retryRate":null,"disputeRate":null,"p50Latency":null,"p95Latency":null,"lastUpdated":null}},"benchmarks":{"evidence":{"source":"no-benchmark-data","verified":false,"confidence":"low","updatedAt":null,"emptyReason":"No benchmark suites or observed failure patterns are available."},"suites":[],"failurePatterns":[]},"artifacts":{"evidence":{"source":"CLAWHUB","verified":false,"confidence":"high","updatedAt":"2026-10-10T01:35:54.291Z","emptyReason":null},"readme":"Skill: Options Trading Brain\n\nOwner: ssidharhubble\n\nSummary: Professional options trading intelligence system. Monitors whale flow (Unusual Whales), counts Elliott Waves, analyzes Bollinger Bands, multi-timeframe trend...\n\nTags: latest:1.0.16\n\nVersion history:\n\nv1.0.16 | 2026-06-22T14:04:07.934Z | auto\n\n- Removed the skill-card.md file to reduce duplication and simplify documentation.\n- Updated SKILL.md; no changes to code functionality or features.\n- Documentation is now maintained solely in SKILL.md for streamlined maintenance.\n\nv1.0.15 | 2026-06-05T13:15:23.474Z | auto\n\n- Updated to version 1.0.15.\n- Removed the file: skill-card.md.\n- No changes to core functionality or codebase; documentation updated only.\n\nv1.0.14 | 2026-05-17T13:13:14.424Z | auto\n\n- Bumped version to 1.0.14 in metadata.\n- No other functional or documentation changes.\n\nv1.0.13 | 2026-05-16T13:15:21.882Z | auto\n\n- Updated version to 1.0.13 in SKILL.md.\n- No functional or logic changes; documentation version change only.\n\nv1.0.12 | 2026-05-15T13:12:03.110Z | auto\n\n- Updated version metadata from 1.0.11 to 1.0.12 in SKILL.md.\n- No other functional or documentation changes.\n\nv1.0.11 | 2026-05-14T13:12:58.938Z | auto\n\n- Bumped version to 1.0.11 in SKILL.md.\n- No logic changes; documentation update only.\n\nv1.0.10 | 2026-05-04T13:44:59.498Z | auto\n\n- Version updated to 1.0.10 in SKILL.md.\n- No changes to logic or features; documentation and code samples remain the same.\n\nv1.0.9 | 2026-05-04T13:31:12.309Z | auto\n\nVersion 1.0.9\n\n- Updated SKILL.md version number to 1.0.9 for accuracy.\n- No functional or behavioral changes to logic or scripts.\n\nv1.0.8 | 2026-05-03T13:42:33.736Z | auto\n\n- Updated version to 1.0.8 in SKILL.md.\n- No functional or description changes; documentation updated to reflect version increment only.\n\nv1.0.7 | 2026-05-03T13:31:44.269Z | auto\n\n- Updated version to 1.0.7 in SKILL.md.\n- No functionality or description changes; documentation version bump only.\n\nv1.0.6 | 2026-05-02T13:42:33.603Z | auto\n\n- Updated version to 1.0.6 in metadata.\n- No functional or documentation changes; version bump only.\n\nv1.0.5 | 2026-05-02T13:28:21.870Z | auto\n\n- Documentation updated in SKILL.md—version bumped to 1.0.5.\n- No changes to code or features; SKILL.md remained consistent in content aside from version.\n\nv1.0.4 | 2026-05-01T13:22:13.060Z | auto\n\n- Documentation updated in SKILL.md to reflect the new version (1.0.4).\n- No changes made to code or functionality; this version consists solely of documentation changes.\n\nv1.0.3 | 2026-04-30T13:20:03.800Z | auto\n\n- Updated version to 1.0.3.\n- No functional or content changes—documentation and scripts remain the same.\n\nv1.0.2 | 2026-04-30T01:50:01.584Z | auto\n\n- Major update: All core analysis scripts are now embedded directly in documentation for transparency and offline reference.\n- Expanded descriptions and logic for each of the 5 input signals: whale flow, Elliott Wave, Bollinger Bands, trend alignment, and liquidity zones.\n- Usage instructions and requirements clarified; now emphasizes full autonomy (no API keys needed for main analysis).\n- Compatibility updated to Python 3.10+ and includes optional Unusual Whales subscription.\n- Metadata, tags, and author information revised for clarity and discoverability.\n\nv1.0.1 | 2026-04-30T01:14:38.606Z | auto\n\n- Enhanced trade signal logic: now requires 3+ indicator alignments, with whale flow as mandatory.\n- Added advanced liquidity mapping (strike walls, max pain, GEX, PCR) to signal calculation.\n- Modularized scripts for whale flow, Elliott Wave, Bollinger Bands, trend, and liquidity analysis.\n- CLI tools provided for single or multi-module scans.\n- Improved focus on high-conviction signals for both theta and directional options strategies.\n\nArchive index:\n\nArchive v1.0.16: 3 files, 5382 bytes\n\nFiles: skill-card.md (1924b), SKILL.md (10670b), _meta.json (141b)\n\nFile v1.0.16:SKILL.md\n\n---\nname: options-trading-brain\nversion: 1.0.16\ndescription: |\n  Professional-grade options trading signal generator. Monitors whale flow (Unusual \n  Whales), counts Elliott Waves, analyzes Bollinger Bands, multi-timeframe trend \n  alignment, and liquidity zones. Combines all 5 inputs into actionable trade signals.\n  Use when user asks for options signals, stock analysis, trading setups, or to check \n  a specific ticker. Fully autonomous — no API keys required for core analysis.\ncompatibility: Python 3.10+, yfinance, numpy, scipy. Optional: Unusual Whales subscription.\nmetadata:\n  author: ssyopro.zo.computer\n  category: finance\n  display-name: Options Trading Brain\n  tags: options, trading, signals, elliott-wave, whale-flow, bollinger, theta-gang\n---\n\n# Options Trading Brain\n\nProfessional options trading intelligence system combining 5 analysis dimensions into one unified signal.\n\n## The 5 Inputs (Signal Requires 3+ Aligned)\n\n### 1. Whale Flow (Unusual Whales)\n- Filter: $25K+ premium, sweep/block executions, ask-side fills\n- Hierarchy: sweeps > blocks > splits > single fills\n- Bullish: calls at ask + volume > OI; Bearish: puts at ask + volume > OI\n\n### 2. Elliott Wave\n- Wave 3 = strongest momentum entry\n- Wave 5 = exhaustion warning\n- Rules: Wave 2 can't retrace Wave 1; Wave 3 not shortest; Wave 4 can't overlap Wave 1\n\n### 3. Bollinger Bands\n- Squeeze (BB width < 2% of price) = volatile expansion imminent\n- Band thrust through upper/lower = strong momentum continuation\n- Position near bands = overbought/oversold reversal candidates\n\n### 4. Multi-Timeframe Trend\n- ADX > 25 = confirmed trend\n- MA alignment (price > MA20 > MA50) = uptrend confirmed\n- Weekly/Daily must align for high conviction\n\n### 5. Liquidity Zones\n- 4-layer strike walls: OI concentration + GEX + PCR + Max Pain proximity\n- Max Pain = where max options expire worthless (gravity level)\n- Support = cluster of put OI below price; Resistance = call OI above\n\n## Signal Hierarchy\n\n| Conviction | Requirement |\n|---|---|\n| **HIGH** | Whale + Wave 3 + (Trend OR Bollinger) aligned |\n| **MEDIUM** | Whale + 2 others aligned |\n| **NONE** | No whale signal = no trade |\n\n## Scripts (all embedded below)\n\n### whale_scanner.py\n```python\n#!/usr/bin/env python3\n\"\"\"Whale flow scanner — Unusual Whales inspired filters.\"\"\"\nimport yfinance as yf, numpy as np\n\nWHALE_THRESHOLD = 25_000  # $25K minimum\n\ndef get_price(ticker: str) -> float:\n    return yf.Ticker(ticker).info[\"regularMarketPrice\"]\n\ndef scan(ticker: str) -> dict:\n    price = get_price(ticker)\n    chains = yf.Ticker(ticker).option_chain()\n    \n    calls = chains.calls[chains.calls[\"volume\"] * chains.calls[\"lastPrice\"] * 100 >= WHALE_THRESHOLD]\n    puts  = chains.puts[chains.puts[\"volume\"] * chains.puts[\"lastPrice\"] * 100 >= WHALE_THRESHOLD]\n    \n    call_premium = (calls[\"volume\"] * calls[\"lastPrice\"] * 100).sum()\n    put_premium  = (puts[\"volume\"] * puts[\"lastPrice\"] * 100).sum()\n    \n    return {\n        \"ticker\": ticker, \"price\": price,\n        \"whale_calls\": len(calls), \"whale_puts\": len(puts),\n        \"call_premium\": call_premium, \"put_premium\": put_premium,\n        \"direction\": \"bullish\" if call_premium > put_premium * 1.2\n                    else \"bearish\" if put_premium > call_premium * 1.2 else \"neutral\"\n    }\n\nif __name__ == \"__main__\":\n    import sys\n    r = scan(sys.argv[1] if len(sys.argv) > 1 else \"SPY\")\n    print(f\"{r['ticker']}: {r['direction']} | Calls: {r['whale_calls']} | Puts: {r['whale_puts']} | \"\n          f\"Call$: ${r['call_premium']:,.0f} | Put$: ${r['put_premium']:,.0f}\")\n```\n\n### elliott_wave.py\n```python\n#!/usr/bin/env python3\n\"\"\"Elliott Wave counter — validates 3 rules, identifies impulse waves.\"\"\"\nimport yfinance as yf, numpy as np\n\ndef count_waves(prices: list) -> dict:\n    highs, lows = [], []\n    for i in range(1, len(prices)-1):\n        if prices[i] > prices[i-1] and prices[i] > prices[i+1]: highs.append(i)\n        if prices[i] < prices[i-1] and prices[i] < prices[i+1]: lows.append(i)\n    \n    if len(highs) < 2: return {\"wave_count\": 0, \"wave_number\": 0, \"wave_type\": \"unknown\"}\n    \n    wave3_strong = highs[1] - highs[0] > (highs[0] - lows[0]) if len(highs) > 1 else False\n    return {\n        \"wave_count\": len(highs),\n        \"wave_number\": min(5, len(highs)),\n        \"wave_type\": \"impulse_wave_3\" if wave3_strong else \"impulse_wave_1_or_5\"\n    }\n\ndef fib_levels(high: float, low: float) -> dict:\n    return {\n        \"fib_236\": low + (high - low) * 0.236,\n        \"fib_382\": low + (high - low) * 0.382,\n        \"fib_500\": low + (high - low) * 0.500,\n        \"fib_618\": low + (high - low) * 0.618,\n        \"fib_786\": low + (high - low) * 0.786,\n    }\n\ndef validate_impulse(p1, p2, p3, p4, p5) -> bool:\n    return (p2 < p1 and p3 > max(p1,p2) and p4 < p3 and p4 > p1 and p5 < p4)\n\nif __name__ == \"__main__\":\n    import sys\n    ticker = sys.argv[1] if len(sys.argv) > 1 else \"SPY\"\n    data = yf.download(ticker, period=\"3mo\", auto_redirect=True)[\"Close\"].dropna()\n    waves = count_waves(data.values.tolist())\n    print(f\"{ticker}: Wave {waves['wave_number']} ({waves['wave_type']})\")\n```\n\n### bollinger_analyzer.py\n```python\n#!/usr/bin/env python3\n\"\"\"Bollinger Bands analyzer — squeeze, thrust, regime detection.\"\"\"\nimport yfinance as yf, numpy as np\n\ndef get_bands(prices: np.ndarray, window=20):\n    sma = np.convolve(prices, np.ones(window)/window, mode='valid')\n    std = np.array([np.std(prices[i:i+window]) for i in range(len(prices)-window+1)])\n    upper = sma + 2*std; lower = sma - 2*std\n    return {\"sma\": sma, \"upper\": upper, \"lower\": lower, \"width\": upper-lower}\n\ndef detect_squeeze(bands: dict, threshold_pct=0.02) -> bool:\n    latest_width_pct = bands[\"width\"][-1] / bands[\"sma\"][-1]\n    return latest_width_pct < threshold_pct\n\ndef regime(bands: dict, price: float) -> str:\n    bbp = (price - bands[\"lower\"][-1]) / (bands[\"upper\"][-1] - bands[\"lower\"][-1])\n    if bbp > 0.90: return \"upper_thrust_bullish\"\n    if bbp < 0.10: return \"lower_thrust_bearish\"\n    if bbp > 0.60: return \"bullish\"\n    if bbp < 0.40: return \"bearish\"\n    return \"neutral\"\n\nif __name__ == \"__main__\":\n    import sys\n    ticker = sys.argv[1] if len(sys.argv) > 1 else \"SPY\"\n    data = yf.download(ticker, period=\"3mo\", auto_redirect=True)[\"Close\"].dropna().values\n    bands = get_bands(data)\n    sqz = detect_squeeze(bands)\n    reg = regime(bands, data[-1])\n    pos = (data[-1] - bands[\"lower\"][-1]) / (bands[\"upper\"][-1] - bands[\"lower\"][-1])\n    print(f\"{ticker}: {'SQUEEZE' if sqz else 'Normal'} | Regime: {reg} | BBPosition: {pos:.1%}\")\n```\n\n### trend_engine.py\n```python\n#!/usr/bin/env python3\n\"\"\"Multi-timeframe trend engine — ADX + MA alignment.\"\"\"\nimport yfinance as yf, numpy as np\n\ndef adx(high, low, close, period=14):\n    plus_dm = np.maximum(high[1:] - high[:-1], 0)\n    minus_dm = np.maximum(low[:-1] - low[1:], 0)\n    tr = high[1:] - low[1:]; tr = np.maximum(tr, np.abs(close[1:] - close[:-1]))\n    plus_di = 100 * np.mean(plus_dm[-period:]) / (np.mean(tr[-period:]) + 1e-9)\n    minus_di = 100 * np.mean(minus_dm[-period:]) / (np.mean(tr[-period:]) + 1e-9)\n    return plus_di / (plus_di + minus_di + 1e-9) * 100\n\ndef ma_alignment(prices, ma20, ma50):\n    return \"bullish\" if prices[-1] > ma20[-1] > ma50[-1] else \\\n           \"bearish\" if prices[-1] < ma20[-1] < ma50[-1] else \"mixed\"\n\nif __name__ == \"__main__\":\n    import sys\n    ticker = sys.argv[1] if len(sys.argv) > 1 else \"SPY\"\n    for tf in [\"1d\",\"1wk\",\"1mo\"]:\n        try:\n            d = yf.download(ticker, period=\"3mo\", interval=tf, auto_redirect=True)\n            h,l,c = d[\"High\"].values, d[\"Low\"].values, d[\"Close\"].values\n            a = adx(h,l,c)\n            ma20 = np.convolve(c, np.ones(20)/20, mode='valid')\n            ma50 = np.convolve(c, np.ones(50)/50, mode='valid')\n            al = ma_alignment(c, ma20, ma50)\n            print(f\"{tf.upper()}: ADX={a:.1f} | MA={al}\")\n        except: pass\n```\n\n### liquidity_map.py\n```python\n#!/usr/bin/env python3\n\"\"\"Liquidity zones — max pain, strike walls, support/resistance.\"\"\"\nimport yfinance as yf\n\ndef get_liquidity(ticker: str) -> dict:\n    t = yf.Ticker(ticker)\n    price = t.info[\"regularMarketPrice\"]\n    try:\n        chain = t.option_chain(tExpiry := t.options[0])\n        strikes = sorted(chain.calls[\"strike\"].values)\n        max_pain = strikes[np.argmin(np.abs(strikes - price))]\n        return {\"max_pain\": max_pain, \"price\": price, \"expiry\": tExpiry}\n    except: return {\"max_pain\": price, \"price\": price, \"expiry\": \"unknown\"}\n\nif __name__ == \"__main__\":\n    import sys\n    ticker = sys.argv[1] if len(sys.argv) > 1 else \"SPY\"\n    z = get_liquidity(ticker)\n    pct = (z[\"max_pain\"] - z[\"price\"]) / z[\"price\"] * 100\n    print(f\"{ticker}: Price={z['price']:.2f} | Max Pain={z['max_pain']:.2f} ({pct:+.2f}%) | Expires: {z['expiry']}\")\n```\n\n### signal_generator.py\n```python\n#!/usr/bin/env python3\n\"\"\"Combined signal generator — all 5 inputs, unified output.\"\"\"\nimport subprocess, sys\n\ndef run_script(name, ticker):\n    try:\n        r = subprocess.run([\"python\", f\"scripts/{name}\", ticker], capture_output=True, text=True, timeout=30)\n        return r.stdout.strip()\n    except: return \"\"\n\ndef generate(ticker: str) -> dict:\n    whale   = run_script(\"whale_scanner.py\", ticker)\n    wave    = run_script(\"elliott_wave.py\", ticker)\n    bands   = run_script(\"bollinger_analyzer.py\", ticker)\n    trend   = run_script(\"trend_engine.py\", ticker)\n    liq     = run_script(\"liquidity_map.py\", ticker)\n    signals = {\"whale\": \"🟢\" in whale, \"wave3\": \"3\" in wave, \"squeeze\": \"SQUEEZE\" in bands}\n    score   = sum(signals.values())\n    conviction = \"HIGH\" if score >= 3 and signals[\"whale\"] else \\\n                 \"MEDIUM\" if score >= 2 and signals[\"whale\"] else \"NONE\"\n    return {\"ticker\": ticker, \"score\": score, \"conviction\": conviction, \"details\": locals()}\n\nif __name__ == \"__main__\":\n    ticker = sys.argv[1] if len(sys.argv) > 1 else \"AAPL\"\n    result = generate(ticker)\n    print(f\"{ticker}: {result['conviction']} ({result['score']}/5 signals)\")\n    print(f\"  Whale: {result['details']['whale']} | Wave3: {result['details']['wave3']} | Squeeze: {result['details']['squeeze']}\")\n```\n\n## Usage\n\nRun any script directly:\n```bash\npython scripts/whale_scanner.py SPY\npython scripts/elliott_wave.py NVDA\npython scripts/bollinger_analyzer.py TSLA\npython scripts/signal_generator.py --ticker AAPL\n```\n\nOr run all 5 inputs together:\n```bash\npython scripts/signal_generator.py --ticker NVDA\n```\n\n## Research Sources\n\n- Whale flow: FlowProof.io — \"sweeps > blocks > splits > single fills\"\n- Elliott Wave: elliottwave-forecast.com — 3 inviolable rules\n- Liquidity: StrikeWatch EA — 4-layer strike wall conviction scoring\n\nFile v1.0.16:_meta.json\n\n{\n  \"ownerId\": \"kn723dy43mmbqpy0cp62hwptm984gga5\",\n  \"slug\": \"options-trading-brain\",\n  \"version\": \"1.0.16\",\n  \"publishedAt\": 1782137047934\n}\n\nFile v1.0.16:skill-card.md\n\n## Description:\n\nOptions Trading Brain is an options trading signal generator that combines whale flow, Elliott Wave, Bollinger Band, multi-timeframe trend, and liquidity-zone analysis into ticker-level trading signals.\n\nThis skill is ready for commercial/non-commercial use.\n\n## Publisher:\n\n[ssidharhubble](https://clawhub.ai/user/ssidharhubble)\n\n### License/Terms of Use:\n\nMIT-0\n\n## Use Case:\n\nExternal traders and agent users use this skill to request options signals, stock analysis, trading setups, or ticker checks. Outputs should be treated as informational analysis requiring independent human review before any financial decision.\n\n### Deployment Geography for Use:\n\nGlobal\n\n## Known Risks and Mitigations:\n\nRisk: The skill gives broad, actionable options-trading signals while overstating how its analysis works.\n\nMitigation: Treat outputs as informational analysis only, and require independent human review before any trade or portfolio decision.\n\nRisk: The skill's trading outputs are described by security evidence as overconfident and incompletely implemented.\n\nMitigation: Validate market data, assumptions, and risk controls with trusted tools before relying on any generated setup.\n\n## Reference(s):\n\n\n## Skill Output:\n\n**Output Type(s):** [text, markdown, code, shell commands, guidance]\n\n**Output Format:** [Markdown with embedded Python and shell command examples]\n\n**Output Parameters:** [1D]\n\n**Other Properties Related to Output:** [Trading outputs are generated from the skill's documented analysis dimensions and may depend on available market data.]\n\n## Skill Version(s):\n\n1.0.16 (source: frontmatter and server release evidence)\n\n## Ethical Considerations:\n\nUsers should evaluate whether this skill is appropriate for their environment, review any generated or modified files before relying on them, and apply their organization's safety, security, and compliance requirements before deployment.\n\nArchive v1.0.15: 3 files, 5408 bytes\n\nFiles: skill-card.md (2071b), SKILL.md (10670b), _meta.json (141b)\n\nFile v1.0.15:SKILL.md\n\n---\nname: options-trading-brain\nversion: 1.0.15\ndescription: |\n  Professional-grade options trading signal generator. Monitors whale flow (Unusual \n  Whales), counts Elliott Waves, analyzes Bollinger Bands, multi-timeframe trend \n  alignment, and liquidity zones. Combines all 5 inputs into actionable trade signals.\n  Use when user asks for options signals, stock analysis, trading setups, or to check \n  a specific ticker. Fully autonomous — no API keys required for core analysis.\ncompatibility: Python 3.10+, yfinance, numpy, scipy. Optional: Unusual Whales subscription.\nmetadata:\n  author: ssyopro.zo.computer\n  category: finance\n  display-name: Options Trading Brain\n  tags: options, trading, signals, elliott-wave, whale-flow, bollinger, theta-gang\n---\n\n# Options Trading Brain\n\nProfessional options trading intelligence system combining 5 analysis dimensions into one unified signal.\n\n## The 5 Inputs (Signal Requires 3+ Aligned)\n\n### 1. Whale Flow (Unusual Whales)\n- Filter: $25K+ premium, sweep/block executions, ask-side fills\n- Hierarchy: sweeps > blocks > splits > single fills\n- Bullish: calls at ask + volume > OI; Bearish: puts at ask + volume > OI\n\n### 2. Elliott Wave\n- Wave 3 = strongest momentum entry\n- Wave 5 = exhaustion warning\n- Rules: Wave 2 can't retrace Wave 1; Wave 3 not shortest; Wave 4 can't overlap Wave 1\n\n### 3. Bollinger Bands\n- Squeeze (BB width < 2% of price) = volatile expansion imminent\n- Band thrust through upper/lower = strong momentum continuation\n- Position near bands = overbought/oversold reversal candidates\n\n### 4. Multi-Timeframe Trend\n- ADX > 25 = confirmed trend\n- MA alignment (price > MA20 > MA50) = uptrend confirmed\n- Weekly/Daily must align for high conviction\n\n### 5. Liquidity Zones\n- 4-layer strike walls: OI concentration + GEX + PCR + Max Pain proximity\n- Max Pain = where max options expire worthless (gravity level)\n- Support = cluster of put OI below price; Resistance = call OI above\n\n## Signal Hierarchy\n\n| Conviction | Requirement |\n|---|---|\n| **HIGH** | Whale + Wave 3 + (Trend OR Bollinger) aligned |\n| **MEDIUM** | Whale + 2 others aligned |\n| **NONE** | No whale signal = no trade |\n\n## Scripts (all embedded below)\n\n### whale_scanner.py\n```python\n#!/usr/bin/env python3\n\"\"\"Whale flow scanner — Unusual Whales inspired filters.\"\"\"\nimport yfinance as yf, numpy as np\n\nWHALE_THRESHOLD = 25_000  # $25K minimum\n\ndef get_price(ticker: str) -> float:\n    return yf.Ticker(ticker).info[\"regularMarketPrice\"]\n\ndef scan(ticker: str) -> dict:\n    price = get_price(ticker)\n    chains = yf.Ticker(ticker).option_chain()\n    \n    calls = chains.calls[chains.calls[\"volume\"] * chains.calls[\"lastPrice\"] * 100 >= WHALE_THRESHOLD]\n    puts  = chains.puts[chains.puts[\"volume\"] * chains.puts[\"lastPrice\"] * 100 >= WHALE_THRESHOLD]\n    \n    call_premium = (calls[\"volume\"] * calls[\"lastPrice\"] * 100).sum()\n    put_premium  = (puts[\"volume\"] * puts[\"lastPrice\"] * 100).sum()\n    \n    return {\n        \"ticker\": ticker, \"price\": price,\n        \"whale_calls\": len(calls), \"whale_puts\": len(puts),\n        \"call_premium\": call_premium, \"put_premium\": put_premium,\n        \"direction\": \"bullish\" if call_premium > put_premium * 1.2\n                    else \"bearish\" if put_premium > call_premium * 1.2 else \"neutral\"\n    }\n\nif __name__ == \"__main__\":\n    import sys\n    r = scan(sys.argv[1] if len(sys.argv) > 1 else \"SPY\")\n    print(f\"{r['ticker']}: {r['direction']} | Calls: {r['whale_calls']} | Puts: {r['whale_puts']} | \"\n          f\"Call$: ${r['call_premium']:,.0f} | Put$: ${r['put_premium']:,.0f}\")\n```\n\n### elliott_wave.py\n```python\n#!/usr/bin/env python3\n\"\"\"Elliott Wave counter — validates 3 rules, identifies impulse waves.\"\"\"\nimport yfinance as yf, numpy as np\n\ndef count_waves(prices: list) -> dict:\n    highs, lows = [], []\n    for i in range(1, len(prices)-1):\n        if prices[i] > prices[i-1] and prices[i] > prices[i+1]: highs.append(i)\n        if prices[i] < prices[i-1] and prices[i] < prices[i+1]: lows.append(i)\n    \n    if len(highs) < 2: return {\"wave_count\": 0, \"wave_number\": 0, \"wave_type\": \"unknown\"}\n    \n    wave3_strong = highs[1] - highs[0] > (highs[0] - lows[0]) if len(highs) > 1 else False\n    return {\n        \"wave_count\": len(highs),\n        \"wave_number\": min(5, len(highs)),\n        \"wave_type\": \"impulse_wave_3\" if wave3_strong else \"impulse_wave_1_or_5\"\n    }\n\ndef fib_levels(high: float, low: float) -> dict:\n    return {\n        \"fib_236\": low + (high - low) * 0.236,\n        \"fib_382\": low + (high - low) * 0.382,\n        \"fib_500\": low + (high - low) * 0.500,\n        \"fib_618\": low + (high - low) * 0.618,\n        \"fib_786\": low + (high - low) * 0.786,\n    }\n\ndef validate_impulse(p1, p2, p3, p4, p5) -> bool:\n    return (p2 < p1 and p3 > max(p1,p2) and p4 < p3 and p4 > p1 and p5 < p4)\n\nif __name__ == \"__main__\":\n    import sys\n    ticker = sys.argv[1] if len(sys.argv) > 1 else \"SPY\"\n    data = yf.download(ticker, period=\"3mo\", auto_redirect=True)[\"Close\"].dropna()\n    waves = count_waves(data.values.tolist())\n    print(f\"{ticker}: Wave {waves['wave_number']} ({waves['wave_type']})\")\n```\n\n### bollinger_analyzer.py\n```python\n#!/usr/bin/env python3\n\"\"\"Bollinger Bands analyzer — squeeze, thrust, regime detection.\"\"\"\nimport yfinance as yf, numpy as np\n\ndef get_bands(prices: np.ndarray, window=20):\n    sma = np.convolve(prices, np.ones(window)/window, mode='valid')\n    std = np.array([np.std(prices[i:i+window]) for i in range(len(prices)-window+1)])\n    upper = sma + 2*std; lower = sma - 2*std\n    return {\"sma\": sma, \"upper\": upper, \"lower\": lower, \"width\": upper-lower}\n\ndef detect_squeeze(bands: dict, threshold_pct=0.02) -> bool:\n    latest_width_pct = bands[\"width\"][-1] / bands[\"sma\"][-1]\n    return latest_width_pct < threshold_pct\n\ndef regime(bands: dict, price: float) -> str:\n    bbp = (price - bands[\"lower\"][-1]) / (bands[\"upper\"][-1] - bands[\"lower\"][-1])\n    if bbp > 0.90: return \"upper_thrust_bullish\"\n    if bbp < 0.10: return \"lower_thrust_bearish\"\n    if bbp > 0.60: return \"bullish\"\n    if bbp < 0.40: return \"bearish\"\n    return \"neutral\"\n\nif __name__ == \"__main__\":\n    import sys\n    ticker = sys.argv[1] if len(sys.argv) > 1 else \"SPY\"\n    data = yf.download(ticker, period=\"3mo\", auto_redirect=True)[\"Close\"].dropna().values\n    bands = get_bands(data)\n    sqz = detect_squeeze(bands)\n    reg = regime(bands, data[-1])\n    pos = (data[-1] - bands[\"lower\"][-1]) / (bands[\"upper\"][-1] - bands[\"lower\"][-1])\n    print(f\"{ticker}: {'SQUEEZE' if sqz else 'Normal'} | Regime: {reg} | BBPosition: {pos:.1%}\")\n```\n\n### trend_engine.py\n```python\n#!/usr/bin/env python3\n\"\"\"Multi-timeframe trend engine — ADX + MA alignment.\"\"\"\nimport yfinance as yf, numpy as np\n\ndef adx(high, low, close, period=14):\n    plus_dm = np.maximum(high[1:] - high[:-1], 0)\n    minus_dm = np.maximum(low[:-1] - low[1:], 0)\n    tr = high[1:] - low[1:]; tr = np.maximum(tr, np.abs(close[1:] - close[:-1]))\n    plus_di = 100 * np.mean(plus_dm[-period:]) / (np.mean(tr[-period:]) + 1e-9)\n    minus_di = 100 * np.mean(minus_dm[-period:]) / (np.mean(tr[-period:]) + 1e-9)\n    return plus_di / (plus_di + minus_di + 1e-9) * 100\n\ndef ma_alignment(prices, ma20, ma50):\n    return \"bullish\" if prices[-1] > ma20[-1] > ma50[-1] else \\\n           \"bearish\" if prices[-1] < ma20[-1] < ma50[-1] else \"mixed\"\n\nif __name__ == \"__main__\":\n    import sys\n    ticker = sys.argv[1] if len(sys.argv) > 1 else \"SPY\"\n    for tf in [\"1d\",\"1wk\",\"1mo\"]:\n        try:\n            d = yf.download(ticker, period=\"3mo\", interval=tf, auto_redirect=True)\n            h,l,c = d[\"High\"].values, d[\"Low\"].values, d[\"Close\"].values\n            a = adx(h,l,c)\n            ma20 = np.convolve(c, np.ones(20)/20, mode='valid')\n            ma50 = np.convolve(c, np.ones(50)/50, mode='valid')\n            al = ma_alignment(c, ma20, ma50)\n            print(f\"{tf.upper()}: ADX={a:.1f} | MA={al}\")\n        except: pass\n```\n\n### liquidity_map.py\n```python\n#!/usr/bin/env python3\n\"\"\"Liquidity zones — max pain, strike walls, support/resistance.\"\"\"\nimport yfinance as yf\n\ndef get_liquidity(ticker: str) -> dict:\n    t = yf.Ticker(ticker)\n    price = t.info[\"regularMarketPrice\"]\n    try:\n        chain = t.option_chain(tExpiry := t.options[0])\n        strikes = sorted(chain.calls[\"strike\"].values)\n        max_pain = strikes[np.argmin(np.abs(strikes - price))]\n        return {\"max_pain\": max_pain, \"price\": price, \"expiry\": tExpiry}\n    except: return {\"max_pain\": price, \"price\": price, \"expiry\": \"unknown\"}\n\nif __name__ == \"__main__\":\n    import sys\n    ticker = sys.argv[1] if len(sys.argv) > 1 else \"SPY\"\n    z = get_liquidity(ticker)\n    pct = (z[\"max_pain\"] - z[\"price\"]) / z[\"price\"] * 100\n    print(f\"{ticker}: Price={z['price']:.2f} | Max Pain={z['max_pain']:.2f} ({pct:+.2f}%) | Expires: {z['expiry']}\")\n```\n\n### signal_generator.py\n```python\n#!/usr/bin/env python3\n\"\"\"Combined signal generator — all 5 inputs, unified output.\"\"\"\nimport subprocess, sys\n\ndef run_script(name, ticker):\n    try:\n        r = subprocess.run([\"python\", f\"scripts/{name}\", ticker], capture_output=True, text=True, timeout=30)\n        return r.stdout.strip()\n    except: return \"\"\n\ndef generate(ticker: str) -> dict:\n    whale   = run_script(\"whale_scanner.py\", ticker)\n    wave    = run_script(\"elliott_wave.py\", ticker)\n    bands   = run_script(\"bollinger_analyzer.py\", ticker)\n    trend   = run_script(\"trend_engine.py\", ticker)\n    liq     = run_script(\"liquidity_map.py\", ticker)\n    signals = {\"whale\": \"🟢\" in whale, \"wave3\": \"3\" in wave, \"squeeze\": \"SQUEEZE\" in bands}\n    score   = sum(signals.values())\n    conviction = \"HIGH\" if score >= 3 and signals[\"whale\"] else \\\n                 \"MEDIUM\" if score >= 2 and signals[\"whale\"] else \"NONE\"\n    return {\"ticker\": ticker, \"score\": score, \"conviction\": conviction, \"details\": locals()}\n\nif __name__ == \"__main__\":\n    ticker = sys.argv[1] if len(sys.argv) > 1 else \"AAPL\"\n    result = generate(ticker)\n    print(f\"{ticker}: {result['conviction']} ({result['score']}/5 signals)\")\n    print(f\"  Whale: {result['details']['whale']} | Wave3: {result['details']['wave3']} | Squeeze: {result['details']['squeeze']}\")\n```\n\n## Usage\n\nRun any script directly:\n```bash\npython scripts/whale_scanner.py SPY\npython scripts/elliott_wave.py NVDA\npython scripts/bollinger_analyzer.py TSLA\npython scripts/signal_generator.py --ticker AAPL\n```\n\nOr run all 5 inputs together:\n```bash\npython scripts/signal_generator.py --ticker NVDA\n```\n\n## Research Sources\n\n- Whale flow: FlowProof.io — \"sweeps > blocks > splits > single fills\"\n- Elliott Wave: elliottwave-forecast.com — 3 inviolable rules\n- Liquidity: StrikeWatch EA — 4-layer strike wall conviction scoring\n\nFile v1.0.15:_meta.json\n\n{\n  \"ownerId\": \"kn723dy43mmbqpy0cp62hwptm984gga5\",\n  \"slug\": \"options-trading-brain\",\n  \"version\": \"1.0.15\",\n  \"publishedAt\": 1780665323474\n}\n\nFile v1.0.15:skill-card.md\n\n## Description: <br>\nOptions Trading Brain provides an experimental options and stock analysis workflow that generates ticker-level signal summaries from market and options data. <br>\n\nThis skill is ready for commercial/non-commercial use. <br>\n\n## Publisher: <br>\n[ssidharhubble](https://clawhub.ai/user/ssidharhubble) <br>\n\n### License/Terms of Use: <br>\nMIT-0 <br>\n\n\n## Use Case: <br>\nExternal users and agents use this skill to review options-oriented ticker analysis, including market data checks and generated signal summaries. Treat the results as market-analysis assistance, not dependable trading advice. <br>\n\n### Deployment Geography for Use: <br>\nGlobal <br>\n\n## Known Risks and Mitigations: <br>\nRisk: The skill gives high-risk trading signals and may overstate the completeness of its analysis. <br>\nMitigation: Review outputs as experimental market analysis, validate findings with independent sources, and do not rely on the skill as a trading advisor. <br>\nRisk: The security review says the skill fetches market and options data but does not appear to place trades. <br>\nMitigation: Confirm execution behavior before use and keep trading decisions or order placement outside this skill. <br>\n\n\n## Reference(s): <br>\n- [ClawHub skill page](https://clawhub.ai/ssidharhubble/options-trading-brain) <br>\n\n\n## Skill Output: <br>\n**Output Type(s):** [text, code, shell commands, guidance] <br>\n**Output Format:** [Markdown with embedded Python and shell command examples] <br>\n**Output Parameters:** [1D] <br>\n**Other Properties Related to Output:** [Outputs may include ticker-level conviction labels, market-analysis summaries, and command examples for running embedded Python scripts.] <br>\n\n## Skill Version(s): <br>\n1.0.15 (source: frontmatter and server release evidence) <br>\n\n## Ethical Considerations: <br>\nUsers should evaluate whether this skill is appropriate for their environment, review any generated or modified files before relying on them, and apply their organization's safety, security, and compliance requirements before deployment. <br>\n\nArchive v1.0.14: 3 files, 5470 bytes\n\nFiles: skill-card.md (2146b), SKILL.md (10670b), _meta.json (141b)\n\nFile v1.0.14:SKILL.md\n\n---\nname: options-trading-brain\nversion: 1.0.14\ndescription: |\n  Professional-grade options trading signal generator. Monitors whale flow (Unusual \n  Whales), counts Elliott Waves, analyzes Bollinger Bands, multi-timeframe trend \n  alignment, and liquidity zones. Combines all 5 inputs into actionable trade signals.\n  Use when user asks for options signals, stock analysis, trading setups, or to check \n  a specific ticker. Fully autonomous — no API keys required for core analysis.\ncompatibility: Python 3.10+, yfinance, numpy, scipy. Optional: Unusual Whales subscription.\nmetadata:\n  author: ssyopro.zo.computer\n  category: finance\n  display-name: Options Trading Brain\n  tags: options, trading, signals, elliott-wave, whale-flow, bollinger, theta-gang\n---\n\n# Options Trading Brain\n\nProfessional options trading intelligence system combining 5 analysis dimensions into one unified signal.\n\n## The 5 Inputs (Signal Requires 3+ Aligned)\n\n### 1. Whale Flow (Unusual Whales)\n- Filter: $25K+ premium, sweep/block executions, ask-side fills\n- Hierarchy: sweeps > blocks > splits > single fills\n- Bullish: calls at ask + volume > OI; Bearish: puts at ask + volume > OI\n\n### 2. Elliott Wave\n- Wave 3 = strongest momentum entry\n- Wave 5 = exhaustion warning\n- Rules: Wave 2 can't retrace Wave 1; Wave 3 not shortest; Wave 4 can't overlap Wave 1\n\n### 3. Bollinger Bands\n- Squeeze (BB width < 2% of price) = volatile expansion imminent\n- Band thrust through upper/lower = strong momentum continuation\n- Position near bands = overbought/oversold reversal candidates\n\n### 4. Multi-Timeframe Trend\n- ADX > 25 = confirmed trend\n- MA alignment (price > MA20 > MA50) = uptrend confirmed\n- Weekly/Daily must align for high conviction\n\n### 5. Liquidity Zones\n- 4-layer strike walls: OI concentration + GEX + PCR + Max Pain proximity\n- Max Pain = where max options expire worthless (gravity level)\n- Support = cluster of put OI below price; Resistance = call OI above\n\n## Signal Hierarchy\n\n| Conviction | Requirement |\n|---|---|\n| **HIGH** | Whale + Wave 3 + (Trend OR Bollinger) aligned |\n| **MEDIUM** | Whale + 2 others aligned |\n| **NONE** | No whale signal = no trade |\n\n## Scripts (all embedded below)\n\n### whale_scanner.py\n```python\n#!/usr/bin/env python3\n\"\"\"Whale flow scanner — Unusual Whales inspired filters.\"\"\"\nimport yfinance as yf, numpy as np\n\nWHALE_THRESHOLD = 25_000  # $25K minimum\n\ndef get_price(ticker: str) -> float:\n    return yf.Ticker(ticker).info[\"regularMarketPrice\"]\n\ndef scan(ticker: str) -> dict:\n    price = get_price(ticker)\n    chains = yf.Ticker(ticker).option_chain()\n    \n    calls = chains.calls[chains.calls[\"volume\"] * chains.calls[\"lastPrice\"] * 100 >= WHALE_THRESHOLD]\n    puts  = chains.puts[chains.puts[\"volume\"] * chains.puts[\"lastPrice\"] * 100 >= WHALE_THRESHOLD]\n    \n    call_premium = (calls[\"volume\"] * calls[\"lastPrice\"] * 100).sum()\n    put_premium  = (puts[\"volume\"] * puts[\"lastPrice\"] * 100).sum()\n    \n    return {\n        \"ticker\": ticker, \"price\": price,\n        \"whale_calls\": len(calls), \"whale_puts\": len(puts),\n        \"call_premium\": call_premium, \"put_premium\": put_premium,\n        \"direction\": \"bullish\" if call_premium > put_premium * 1.2\n                    else \"bearish\" if put_premium > call_premium * 1.2 else \"neutral\"\n    }\n\nif __name__ == \"__main__\":\n    import sys\n    r = scan(sys.argv[1] if len(sys.argv) > 1 else \"SPY\")\n    print(f\"{r['ticker']}: {r['direction']} | Calls: {r['whale_calls']} | Puts: {r['whale_puts']} | \"\n          f\"Call$: ${r['call_premium']:,.0f} | Put$: ${r['put_premium']:,.0f}\")\n```\n\n### elliott_wave.py\n```python\n#!/usr/bin/env python3\n\"\"\"Elliott Wave counter — validates 3 rules, identifies impulse waves.\"\"\"\nimport yfinance as yf, numpy as np\n\ndef count_waves(prices: list) -> dict:\n    highs, lows = [], []\n    for i in range(1, len(prices)-1):\n        if prices[i] > prices[i-1] and prices[i] > prices[i+1]: highs.append(i)\n        if prices[i] < prices[i-1] and prices[i] < prices[i+1]: lows.append(i)\n    \n    if len(highs) < 2: return {\"wave_count\": 0, \"wave_number\": 0, \"wave_type\": \"unknown\"}\n    \n    wave3_strong = highs[1] - highs[0] > (highs[0] - lows[0]) if len(highs) > 1 else False\n    return {\n        \"wave_count\": len(highs),\n        \"wave_number\": min(5, len(highs)),\n        \"wave_type\": \"impulse_wave_3\" if wave3_strong else \"impulse_wave_1_or_5\"\n    }\n\ndef fib_levels(high: float, low: float) -> dict:\n    return {\n        \"fib_236\": low + (high - low) * 0.236,\n        \"fib_382\": low + (high - low) * 0.382,\n        \"fib_500\": low + (high - low) * 0.500,\n        \"fib_618\": low + (high - low) * 0.618,\n        \"fib_786\": low + (high - low) * 0.786,\n    }\n\ndef validate_impulse(p1, p2, p3, p4, p5) -> bool:\n    return (p2 < p1 and p3 > max(p1,p2) and p4 < p3 and p4 > p1 and p5 < p4)\n\nif __name__ == \"__main__\":\n    import sys\n    ticker = sys.argv[1] if len(sys.argv) > 1 else \"SPY\"\n    data = yf.download(ticker, period=\"3mo\", auto_redirect=True)[\"Close\"].dropna()\n    waves = count_waves(data.values.tolist())\n    print(f\"{ticker}: Wave {waves['wave_number']} ({waves['wave_type']})\")\n```\n\n### bollinger_analyzer.py\n```python\n#!/usr/bin/env python3\n\"\"\"Bollinger Bands analyzer — squeeze, thrust, regime detection.\"\"\"\nimport yfinance as yf, numpy as np\n\ndef get_bands(prices: np.ndarray, window=20):\n    sma = np.convolve(prices, np.ones(window)/window, mode='valid')\n    std = np.array([np.std(prices[i:i+window]) for i in range(len(prices)-window+1)])\n    upper = sma + 2*std; lower = sma - 2*std\n    return {\"sma\": sma, \"upper\": upper, \"lower\": lower, \"width\": upper-lower}\n\ndef detect_squeeze(bands: dict, threshold_pct=0.02) -> bool:\n    latest_width_pct = bands[\"width\"][-1] / bands[\"sma\"][-1]\n    return latest_width_pct < threshold_pct\n\ndef regime(bands: dict, price: float) -> str:\n    bbp = (price - bands[\"lower\"][-1]) / (bands[\"upper\"][-1] - bands[\"lower\"][-1])\n    if bbp > 0.90: return \"upper_thrust_bullish\"\n    if bbp < 0.10: return \"lower_thrust_bearish\"\n    if bbp > 0.60: return \"bullish\"\n    if bbp < 0.40: return \"bearish\"\n    return \"neutral\"\n\nif __name__ == \"__main__\":\n    import sys\n    ticker = sys.argv[1] if len(sys.argv) > 1 else \"SPY\"\n    data = yf.download(ticker, period=\"3mo\", auto_redirect=True)[\"Close\"].dropna().values\n    bands = get_bands(data)\n    sqz = detect_squeeze(bands)\n    reg = regime(bands, data[-1])\n    pos = (data[-1] - bands[\"lower\"][-1]) / (bands[\"upper\"][-1] - bands[\"lower\"][-1])\n    print(f\"{ticker}: {'SQUEEZE' if sqz else 'Normal'} | Regime: {reg} | BBPosition: {pos:.1%}\")\n```\n\n### trend_engine.py\n```python\n#!/usr/bin/env python3\n\"\"\"Multi-timeframe trend engine — ADX + MA alignment.\"\"\"\nimport yfinance as yf, numpy as np\n\ndef adx(high, low, close, period=14):\n    plus_dm = np.maximum(high[1:] - high[:-1], 0)\n    minus_dm = np.maximum(low[:-1] - low[1:], 0)\n    tr = high[1:] - low[1:]; tr = np.maximum(tr, np.abs(close[1:] - close[:-1]))\n    plus_di = 100 * np.mean(plus_dm[-period:]) / (np.mean(tr[-period:]) + 1e-9)\n    minus_di = 100 * np.mean(minus_dm[-period:]) / (np.mean(tr[-period:]) + 1e-9)\n    return plus_di / (plus_di + minus_di + 1e-9) * 100\n\ndef ma_alignment(prices, ma20, ma50):\n    return \"bullish\" if prices[-1] > ma20[-1] > ma50[-1] else \\\n           \"bearish\" if prices[-1] < ma20[-1] < ma50[-1] else \"mixed\"\n\nif __name__ == \"__main__\":\n    import sys\n    ticker = sys.argv[1] if len(sys.argv) > 1 else \"SPY\"\n    for tf in [\"1d\",\"1wk\",\"1mo\"]:\n        try:\n            d = yf.download(ticker, period=\"3mo\", interval=tf, auto_redirect=True)\n            h,l,c = d[\"High\"].values, d[\"Low\"].values, d[\"Close\"].values\n            a = adx(h,l,c)\n            ma20 = np.convolve(c, np.ones(20)/20, mode='valid')\n            ma50 = np.convolve(c, np.ones(50)/50, mode='valid')\n            al = ma_alignment(c, ma20, ma50)\n            print(f\"{tf.upper()}: ADX={a:.1f} | MA={al}\")\n        except: pass\n```\n\n### liquidity_map.py\n```python\n#!/usr/bin/env python3\n\"\"\"Liquidity zones — max pain, strike walls, support/resistance.\"\"\"\nimport yfinance as yf\n\ndef get_liquidity(ticker: str) -> dict:\n    t = yf.Ticker(ticker)\n    price = t.info[\"regularMarketPrice\"]\n    try:\n        chain = t.option_chain(tExpiry := t.options[0])\n        strikes = sorted(chain.calls[\"strike\"].values)\n        max_pain = strikes[np.argmin(np.abs(strikes - price))]\n        return {\"max_pain\": max_pain, \"price\": price, \"expiry\": tExpiry}\n    except: return {\"max_pain\": price, \"price\": price, \"expiry\": \"unknown\"}\n\nif __name__ == \"__main__\":\n    import sys\n    ticker = sys.argv[1] if len(sys.argv) > 1 else \"SPY\"\n    z = get_liquidity(ticker)\n    pct = (z[\"max_pain\"] - z[\"price\"]) / z[\"price\"] * 100\n    print(f\"{ticker}: Price={z['price']:.2f} | Max Pain={z['max_pain']:.2f} ({pct:+.2f}%) | Expires: {z['expiry']}\")\n```\n\n### signal_generator.py\n```python\n#!/usr/bin/env python3\n\"\"\"Combined signal generator — all 5 inputs, unified output.\"\"\"\nimport subprocess, sys\n\ndef run_script(name, ticker):\n    try:\n        r = subprocess.run([\"python\", f\"scripts/{name}\", ticker], capture_output=True, text=True, timeout=30)\n        return r.stdout.strip()\n    except: return \"\"\n\ndef generate(ticker: str) -> dict:\n    whale   = run_script(\"whale_scanner.py\", ticker)\n    wave    = run_script(\"elliott_wave.py\", ticker)\n    bands   = run_script(\"bollinger_analyzer.py\", ticker)\n    trend   = run_script(\"trend_engine.py\", ticker)\n    liq     = run_script(\"liquidity_map.py\", ticker)\n    signals = {\"whale\": \"🟢\" in whale, \"wave3\": \"3\" in wave, \"squeeze\": \"SQUEEZE\" in bands}\n    score   = sum(signals.values())\n    conviction = \"HIGH\" if score >= 3 and signals[\"whale\"] else \\\n                 \"MEDIUM\" if score >= 2 and signals[\"whale\"] else \"NONE\"\n    return {\"ticker\": ticker, \"score\": score, \"conviction\": conviction, \"details\": locals()}\n\nif __name__ == \"__main__\":\n    ticker = sys.argv[1] if len(sys.argv) > 1 else \"AAPL\"\n    result = generate(ticker)\n    print(f\"{ticker}: {result['conviction']} ({result['score']}/5 signals)\")\n    print(f\"  Whale: {result['details']['whale']} | Wave3: {result['details']['wave3']} | Squeeze: {result['details']['squeeze']}\")\n```\n\n## Usage\n\nRun any script directly:\n```bash\npython scripts/whale_scanner.py SPY\npython scripts/elliott_wave.py NVDA\npython scripts/bollinger_analyzer.py TSLA\npython scripts/signal_generator.py --ticker AAPL\n```\n\nOr run all 5 inputs together:\n```bash\npython scripts/signal_generator.py --ticker NVDA\n```\n\n## Research Sources\n\n- Whale flow: FlowProof.io — \"sweeps > blocks > splits > single fills\"\n- Elliott Wave: elliottwave-forecast.com — 3 inviolable rules\n- Liquidity: StrikeWatch EA — 4-layer strike wall conviction scoring\n\nFile v1.0.14:_meta.json\n\n{\n  \"ownerId\": \"kn723dy43mmbqpy0cp62hwptm984gga5\",\n  \"slug\": \"options-trading-brain\",\n  \"version\": \"1.0.14\",\n  \"publishedAt\": 1779023594424\n}\n\nFile v1.0.14:skill-card.md\n\n## Description: <br>\nProfessional-grade options trading signal generator that combines whale-flow filters, Elliott Wave counts, Bollinger Bands, multi-timeframe trend alignment, and liquidity zones into trade signals. <br>\n\nThis skill is ready for commercial/non-commercial use. <br>\n\n## Publisher: <br>\n[ssidharhubble](https://clawhub.ai/user/ssidharhubble) <br>\n\n### License/Terms of Use: <br>\nMIT-0 <br>\n\n\n## Use Case: <br>\nExternal users and agents use this skill to evaluate ticker requests and produce informational options-analysis signals and trading setup summaries. The outputs should support research and review, not replace independent financial judgment. <br>\n\n### Deployment Geography for Use: <br>\nGlobal <br>\n\n## Known Risks and Mitigations: <br>\nRisk: Options trading signals may be incorrect, incomplete, or misleading if treated as financial advice. <br>\nMitigation: Independently verify signals, review assumptions, and consult qualified financial professionals before risking money. <br>\nRisk: Embedded scripts may make public market-data network requests when executed. <br>\nMitigation: Run scripts in an isolated environment and review data dependencies before execution. <br>\n\n\n## Reference(s): <br>\n- [ClawHub release page](https://clawhub.ai/ssidharhubble/options-trading-brain) <br>\n- [Skill source artifact](artifact/SKILL.md) <br>\n\n\n## Skill Output: <br>\n**Output Type(s):** [text, markdown, code, shell commands, guidance] <br>\n**Output Format:** [Markdown analysis with optional Python and shell command snippets] <br>\n**Output Parameters:** [1D] <br>\n**Other Properties Related to Output:** [May depend on public market-data network requests and an optional Unusual Whales subscription; outputs are informational and are not financial advice.] <br>\n\n## Skill Version(s): <br>\n1.0.14 (source: frontmatter and server release evidence) <br>\n\n## Ethical Considerations: <br>\nUsers should evaluate whether this skill is appropriate for their environment, review any generated or modified files before relying on them, and apply their organization's safety, security, and compliance requirements before deployment. <br>\n\nArchive v1.0.13: 2 files, 4308 bytes\n\nFiles: SKILL.md (10670b), _meta.json (141b)\n\nFile v1.0.13:SKILL.md\n\n---\nname: options-trading-brain\nversion: 1.0.13\ndescription: |\n  Professional-grade options trading signal generator. Monitors whale flow (Unusual \n  Whales), counts Elliott Waves, analyzes Bollinger Bands, multi-timeframe trend \n  alignment, and liquidity zones. Combines all 5 inputs into actionable trade signals.\n  Use when user asks for options signals, stock analysis, trading setups, or to check \n  a specific ticker. Fully autonomous — no API keys required for core analysis.\ncompatibility: Python 3.10+, yfinance, numpy, scipy. Optional: Unusual Whales subscription.\nmetadata:\n  author: ssyopro.zo.computer\n  category: finance\n  display-name: Options Trading Brain\n  tags: options, trading, signals, elliott-wave, whale-flow, bollinger, theta-gang\n---\n\n# Options Trading Brain\n\nProfessional options trading intelligence system combining 5 analysis dimensions into one unified signal.\n\n## The 5 Inputs (Signal Requires 3+ Aligned)\n\n### 1. Whale Flow (Unusual Whales)\n- Filter: $25K+ premium, sweep/block executions, ask-side fills\n- Hierarchy: sweeps > blocks > splits > single fills\n- Bullish: calls at ask + volume > OI; Bearish: puts at ask + volume > OI\n\n### 2. Elliott Wave\n- Wave 3 = strongest momentum entry\n- Wave 5 = exhaustion warning\n- Rules: Wave 2 can't retrace Wave 1; Wave 3 not shortest; Wave 4 can't overlap Wave 1\n\n### 3. Bollinger Bands\n- Squeeze (BB width < 2% of price) = volatile expansion imminent\n- Band thrust through upper/lower = strong momentum continuation\n- Position near bands = overbought/oversold reversal candidates\n\n### 4. Multi-Timeframe Trend\n- ADX > 25 = confirmed trend\n- MA alignment (price > MA20 > MA50) = uptrend confirmed\n- Weekly/Daily must align for high conviction\n\n### 5. Liquidity Zones\n- 4-layer strike walls: OI concentration + GEX + PCR + Max Pain proximity\n- Max Pain = where max options expire worthless (gravity level)\n- Support = cluster of put OI below price; Resistance = call OI above\n\n## Signal Hierarchy\n\n| Conviction | Requirement |\n|---|---|\n| **HIGH** | Whale + Wave 3 + (Trend OR Bollinger) aligned |\n| **MEDIUM** | Whale + 2 others aligned |\n| **NONE** | No whale signal = no trade |\n\n## Scripts (all embedded below)\n\n### whale_scanner.py\n```python\n#!/usr/bin/env python3\n\"\"\"Whale flow scanner — Unusual Whales inspired filters.\"\"\"\nimport yfinance as yf, numpy as np\n\nWHALE_THRESHOLD = 25_000  # $25K minimum\n\ndef get_price(ticker: str) -> float:\n    return yf.Ticker(ticker).info[\"regularMarketPrice\"]\n\ndef scan(ticker: str) -> dict:\n    price = get_price(ticker)\n    chains = yf.Ticker(ticker).option_chain()\n    \n    calls = chains.calls[chains.calls[\"volume\"] * chains.calls[\"lastPrice\"] * 100 >= WHALE_THRESHOLD]\n    puts  = chains.puts[chains.puts[\"volume\"] * chains.puts[\"lastPrice\"] * 100 >= WHALE_THRESHOLD]\n    \n    call_premium = (calls[\"volume\"] * calls[\"lastPrice\"] * 100).sum()\n    put_premium  = (puts[\"volume\"] * puts[\"lastPrice\"] * 100).sum()\n    \n    return {\n        \"ticker\": ticker, \"price\": price,\n        \"whale_calls\": len(calls), \"whale_puts\": len(puts),\n        \"call_premium\": call_premium, \"put_premium\": put_premium,\n        \"direction\": \"bullish\" if call_premium > put_premium * 1.2\n                    else \"bearish\" if put_premium > call_premium * 1.2 else \"neutral\"\n    }\n\nif __name__ == \"__main__\":\n    import sys\n    r = scan(sys.argv[1] if len(sys.argv) > 1 else \"SPY\")\n    print(f\"{r['ticker']}: {r['direction']} | Calls: {r['whale_calls']} | Puts: {r['whale_puts']} | \"\n          f\"Call$: ${r['call_premium']:,.0f} | Put$: ${r['put_premium']:,.0f}\")\n```\n\n### elliott_wave.py\n```python\n#!/usr/bin/env python3\n\"\"\"Elliott Wave counter — validates 3 rules, identifies impulse waves.\"\"\"\nimport yfinance as yf, numpy as np\n\ndef count_waves(prices: list) -> dict:\n    highs, lows = [], []\n    for i in range(1, len(prices)-1):\n        if prices[i] > prices[i-1] and prices[i] > prices[i+1]: highs.append(i)\n        if prices[i] < prices[i-1] and prices[i] < prices[i+1]: lows.append(i)\n    \n    if len(highs) < 2: return {\"wave_count\": 0, \"wave_number\": 0, \"wave_type\": \"unknown\"}\n    \n    wave3_strong = highs[1] - highs[0] > (highs[0] - lows[0]) if len(highs) > 1 else False\n    return {\n        \"wave_count\": len(highs),\n        \"wave_number\": min(5, len(highs)),\n        \"wave_type\": \"impulse_wave_3\" if wave3_strong else \"impulse_wave_1_or_5\"\n    }\n\ndef fib_levels(high: float, low: float) -> dict:\n    return {\n        \"fib_236\": low + (high - low) * 0.236,\n        \"fib_382\": low + (high - low) * 0.382,\n        \"fib_500\": low + (high - low) * 0.500,\n        \"fib_618\": low + (high - low) * 0.618,\n        \"fib_786\": low + (high - low) * 0.786,\n    }\n\ndef validate_impulse(p1, p2, p3, p4, p5) -> bool:\n    return (p2 < p1 and p3 > max(p1,p2) and p4 < p3 and p4 > p1 and p5 < p4)\n\nif __name__ == \"__main__\":\n    import sys\n    ticker = sys.argv[1] if len(sys.argv) > 1 else \"SPY\"\n    data = yf.download(ticker, period=\"3mo\", auto_redirect=True)[\"Close\"].dropna()\n    waves = count_waves(data.values.tolist())\n    print(f\"{ticker}: Wave {waves['wave_number']} ({waves['wave_type']})\")\n```\n\n### bollinger_analyzer.py\n```python\n#!/usr/bin/env python3\n\"\"\"Bollinger Bands analyzer — squeeze, thrust, regime detection.\"\"\"\nimport yfinance as yf, numpy as np\n\ndef get_bands(prices: np.ndarray, window=20):\n    sma = np.convolve(prices, np.ones(window)/window, mode='valid')\n    std = np.array([np.std(prices[i:i+window]) for i in range(len(prices)-window+1)])\n    upper = sma + 2*std; lower = sma - 2*std\n    return {\"sma\": sma, \"upper\": upper, \"lower\": lower, \"width\": upper-lower}\n\ndef detect_squeeze(bands: dict, threshold_pct=0.02) -> bool:\n    latest_width_pct = bands[\"width\"][-1] / bands[\"sma\"][-1]\n    return latest_width_pct < threshold_pct\n\ndef regime(bands: dict, price: float) -> str:\n    bbp = (price - bands[\"lower\"][-1]) / (bands[\"upper\"][-1] - bands[\"lower\"][-1])\n    if bbp > 0.90: return \"upper_thrust_bullish\"\n    if bbp < 0.10: return \"lower_thrust_bearish\"\n    if bbp > 0.60: return \"bullish\"\n    if bbp < 0.40: return \"bearish\"\n    return \"neutral\"\n\nif __name__ == \"__main__\":\n    import sys\n    ticker = sys.argv[1] if len(sys.argv) > 1 else \"SPY\"\n    data = yf.download(ticker, period=\"3mo\", auto_redirect=True)[\"Close\"].dropna().values\n    bands = get_bands(data)\n    sqz = detect_squeeze(bands)\n    reg = regime(bands, data[-1])\n    pos = (data[-1] - bands[\"lower\"][-1]) / (bands[\"upper\"][-1] - bands[\"lower\"][-1])\n    print(f\"{ticker}: {'SQUEEZE' if sqz else 'Normal'} | Regime: {reg} | BBPosition: {pos:.1%}\")\n```\n\n### trend_engine.py\n```python\n#!/usr/bin/env python3\n\"\"\"Multi-timeframe trend engine — ADX + MA alignment.\"\"\"\nimport yfinance as yf, numpy as np\n\ndef adx(high, low, close, period=14):\n    plus_dm = np.maximum(high[1:] - high[:-1], 0)\n    minus_dm = np.maximum(low[:-1] - low[1:], 0)\n    tr = high[1:] - low[1:]; tr = np.maximum(tr, np.abs(close[1:] - close[:-1]))\n    plus_di = 100 * np.mean(plus_dm[-period:]) / (np.mean(tr[-period:]) + 1e-9)\n    minus_di = 100 * np.mean(minus_dm[-period:]) / (np.mean(tr[-period:]) + 1e-9)\n    return plus_di / (plus_di + minus_di + 1e-9) * 100\n\ndef ma_alignment(prices, ma20, ma50):\n    return \"bullish\" if prices[-1] > ma20[-1] > ma50[-1] else \\\n           \"bearish\" if prices[-1] < ma20[-1] < ma50[-1] else \"mixed\"\n\nif __name__ == \"__main__\":\n    import sys\n    ticker = sys.argv[1] if len(sys.argv) > 1 else \"SPY\"\n    for tf in [\"1d\",\"1wk\",\"1mo\"]:\n        try:\n            d = yf.download(ticker, period=\"3mo\", interval=tf, auto_redirect=True)\n            h,l,c = d[\"High\"].values, d[\"Low\"].values, d[\"Close\"].values\n            a = adx(h,l,c)\n            ma20 = np.convolve(c, np.ones(20)/20, mode='valid')\n            ma50 = np.convolve(c, np.ones(50)/50, mode='valid')\n            al = ma_alignment(c, ma20, ma50)\n            print(f\"{tf.upper()}: ADX={a:.1f} | MA={al}\")\n        except: pass\n```\n\n### liquidity_map.py\n```python\n#!/usr/bin/env python3\n\"\"\"Liquidity zones — max pain, strike walls, support/resistance.\"\"\"\nimport yfinance as yf\n\ndef get_liquidity(ticker: str) -> dict:\n    t = yf.Ticker(ticker)\n    price = t.info[\"regularMarketPrice\"]\n    try:\n        chain = t.option_chain(tExpiry := t.options[0])\n        strikes = sorted(chain.calls[\"strike\"].values)\n        max_pain = strikes[np.argmin(np.abs(strikes - price))]\n        return {\"max_pain\": max_pain, \"price\": price, \"expiry\": tExpiry}\n    except: return {\"max_pain\": price, \"price\": price, \"expiry\": \"unknown\"}\n\nif __name__ == \"__main__\":\n    import sys\n    ticker = sys.argv[1] if len(sys.argv) > 1 else \"SPY\"\n    z = get_liquidity(ticker)\n    pct = (z[\"max_pain\"] - z[\"price\"]) / z[\"price\"] * 100\n    print(f\"{ticker}: Price={z['price']:.2f} | Max Pain={z['max_pain']:.2f} ({pct:+.2f}%) | Expires: {z['expiry']}\")\n```\n\n### signal_generator.py\n```python\n#!/usr/bin/env python3\n\"\"\"Combined signal generator — all 5 inputs, unified output.\"\"\"\nimport subprocess, sys\n\ndef run_script(name, ticker):\n    try:\n        r = subprocess.run([\"python\", f\"scripts/{name}\", ticker], capture_output=True, text=True, timeout=30)\n        return r.stdout.strip()\n    except: return \"\"\n\ndef generate(ticker: str) -> dict:\n    whale   = run_script(\"whale_scanner.py\", ticker)\n    wave    = run_script(\"elliott_wave.py\", ticker)\n    bands   = run_script(\"bollinger_analyzer.py\", ticker)\n    trend   = run_script(\"trend_engine.py\", ticker)\n    liq     = run_script(\"liquidity_map.py\", ticker)\n    signals = {\"whale\": \"🟢\" in whale, \"wave3\": \"3\" in wave, \"squeeze\": \"SQUEEZE\" in bands}\n    score   = sum(signals.values())\n    conviction = \"HIGH\" if score >= 3 and signals[\"whale\"] else \\\n                 \"MEDIUM\" if score >= 2 and signals[\"whale\"] else \"NONE\"\n    return {\"ticker\": ticker, \"score\": score, \"conviction\": conviction, \"details\": locals()}\n\nif __name__ == \"__main__\":\n    ticker = sys.argv[1] if len(sys.argv) > 1 else \"AAPL\"\n    result = generate(ticker)\n    print(f\"{ticker}: {result['conviction']} ({result['score']}/5 signals)\")\n    print(f\"  Whale: {result['details']['whale']} | Wave3: {result['details']['wave3']} | Squeeze: {result['details']['squeeze']}\")\n```\n\n## Usage\n\nRun any script directly:\n```bash\npython scripts/whale_scanner.py SPY\npython scripts/elliott_wave.py NVDA\npython scripts/bollinger_analyzer.py TSLA\npython scripts/signal_generator.py --ticker AAPL\n```\n\nOr run all 5 inputs together:\n```bash\npython scripts/signal_generator.py --ticker NVDA\n```\n\n## Research Sources\n\n- Whale flow: FlowProof.io — \"sweeps > blocks > splits > single fills\"\n- Elliott Wave: elliottwave-forecast.com — 3 inviolable rules\n- Liquidity: StrikeWatch EA — 4-layer strike wall conviction scoring\n\nFile v1.0.13:_meta.json\n\n{\n  \"ownerId\": \"kn723dy43mmbqpy0cp62hwptm984gga5\",\n  \"slug\": \"options-trading-brain\",\n  \"version\": \"1.0.13\",\n  \"publishedAt\": 1778937321882\n}\n\nArchive v1.0.12: 2 files, 4307 bytes\n\nFiles: SKILL.md (10670b), _meta.json (141b)\n\nFile v1.0.12:SKILL.md\n\n---\nname: options-trading-brain\nversion: 1.0.12\ndescription: |\n  Professional-grade options trading signal generator. Monitors whale flow (Unusual \n  Whales), counts Elliott Waves, analyzes Bollinger Bands, multi-timeframe trend \n  alignment, and liquidity zones. Combines all 5 inputs into actionable trade signals.\n  Use when user asks for options signals, stock analysis, trading setups, or to check \n  a specific ticker. Fully autonomous — no API keys required for core analysis.\ncompatibility: Python 3.10+, yfinance, numpy, scipy. Optional: Unusual Whales subscription.\nmetadata:\n  author: ssyopro.zo.computer\n  category: finance\n  display-name: Options Trading Brain\n  tags: options, trading, signals, elliott-wave, whale-flow, bollinger, theta-gang\n---\n\n# Options Trading Brain\n\nProfessional options trading intelligence system combining 5 analysis dimensions into one unified signal.\n\n## The 5 Inputs (Signal Requires 3+ Aligned)\n\n### 1. Whale Flow (Unusual Whales)\n- Filter: $25K+ premium, sweep/block executions, ask-side fills\n- Hierarchy: sweeps > blocks > splits > single fills\n- Bullish: calls at ask + volume > OI; Bearish: puts at ask + volume > OI\n\n### 2. Elliott Wave\n- Wave 3 = strongest momentum entry\n- Wave 5 = exhaustion warning\n- Rules: Wave 2 can't retrace Wave 1; Wave 3 not shortest; Wave 4 can't overlap Wave 1\n\n### 3. Bollinger Bands\n- Squeeze (BB width < 2% of price) = volatile expansion imminent\n- Band thrust through upper/lower = strong momentum continuation\n- Position near bands = overbought/oversold reversal candidates\n\n### 4. Multi-Timeframe Trend\n- ADX > 25 = confirmed trend\n- MA alignment (price > MA20 > MA50) = uptrend confirmed\n- Weekly/Daily must align for high conviction\n\n### 5. Liquidity Zones\n- 4-layer strike walls: OI concentration + GEX + PCR + Max Pain proximity\n- Max Pain = where max options expire worthless (gravity level)\n- Support = cluster of put OI below price; Resistance = call OI above\n\n## Signal Hierarchy\n\n| Conviction | Requirement |\n|---|---|\n| **HIGH** | Whale + Wave 3 + (Trend OR Bollinger) aligned |\n| **MEDIUM** | Whale + 2 others aligned |\n| **NONE** | No whale signal = no trade |\n\n## Scripts (all embedded below)\n\n### whale_scanner.py\n```python\n#!/usr/bin/env python3\n\"\"\"Whale flow scanner — Unusual Whales inspired filters.\"\"\"\nimport yfinance as yf, numpy as np\n\nWHALE_THRESHOLD = 25_000  # $25K minimum\n\ndef get_price(ticker: str) -> float:\n    return yf.Ticker(ticker).info[\"regularMarketPrice\"]\n\ndef scan(ticker: str) -> dict:\n    price = get_price(ticker)\n    chains = yf.Ticker(ticker).option_chain()\n    \n    calls = chains.calls[chains.calls[\"volume\"] * chains.calls[\"lastPrice\"] * 100 >= WHALE_THRESHOLD]\n    puts  = chains.puts[chains.puts[\"volume\"] * chains.puts[\"lastPrice\"] * 100 >= WHALE_THRESHOLD]\n    \n    call_premium = (calls[\"volume\"] * calls[\"lastPrice\"] * 100).sum()\n    put_premium  = (puts[\"volume\"] * puts[\"lastPrice\"] * 100).sum()\n    \n    return {\n        \"ticker\": ticker, \"price\": price,\n        \"whale_calls\": len(calls), \"whale_puts\": len(puts),\n        \"call_premium\": call_premium, \"put_premium\": put_premium,\n        \"direction\": \"bullish\" if call_premium > put_premium * 1.2\n                    else \"bearish\" if put_premium > call_premium * 1.2 else \"neutral\"\n    }\n\nif __name__ == \"__main__\":\n    import sys\n    r = scan(sys.argv[1] if len(sys.argv) > 1 else \"SPY\")\n    print(f\"{r['ticker']}: {r['direction']} | Calls: {r['whale_calls']} | Puts: {r['whale_puts']} | \"\n          f\"Call$: ${r['call_premium']:,.0f} | Put$: ${r['put_premium']:,.0f}\")\n```\n\n### elliott_wave.py\n```python\n#!/usr/bin/env python3\n\"\"\"Elliott Wave counter — validates 3 rules, identifies impulse waves.\"\"\"\nimport yfinance as yf, numpy as np\n\ndef count_waves(prices: list) -> dict:\n    highs, lows = [], []\n    for i in range(1, len(prices)-1):\n        if prices[i] > prices[i-1] and prices[i] > prices[i+1]: highs.append(i)\n        if prices[i] < prices[i-1] and prices[i] < prices[i+1]: lows.append(i)\n    \n    if len(highs) < 2: return {\"wave_count\": 0, \"wave_number\": 0, \"wave_type\": \"unknown\"}\n    \n    wave3_strong = highs[1] - highs[0] > (highs[0] - lows[0]) if len(highs) > 1 else False\n    return {\n        \"wave_count\": len(highs),\n        \"wave_number\": min(5, len(highs)),\n        \"wave_type\": \"impulse_wave_3\" if wave3_strong else \"impulse_wave_1_or_5\"\n    }\n\ndef fib_levels(high: float, low: float) -> dict:\n    return {\n        \"fib_236\": low + (high - low) * 0.236,\n        \"fib_382\": low + (high - low) * 0.382,\n        \"fib_500\": low + (high - low) * 0.500,\n        \"fib_618\": low + (high - low) * 0.618,\n        \"fib_786\": low + (high - low) * 0.786,\n    }\n\ndef validate_impulse(p1, p2, p3, p4, p5) -> bool:\n    return (p2 < p1 and p3 > max(p1,p2) and p4 < p3 and p4 > p1 and p5 < p4)\n\nif __name__ == \"__main__\":\n    import sys\n    ticker = sys.argv[1] if len(sys.argv) > 1 else \"SPY\"\n    data = yf.download(ticker, period=\"3mo\", auto_redirect=True)[\"Close\"].dropna()\n    waves = count_waves(data.values.tolist())\n    print(f\"{ticker}: Wave {waves['wave_number']} ({waves['wave_type']})\")\n```\n\n### bollinger_analyzer.py\n```python\n#!/usr/bin/env python3\n\"\"\"Bollinger Bands analyzer — squeeze, thrust, regime detection.\"\"\"\nimport yfinance as yf, numpy as np\n\ndef get_bands(prices: np.ndarray, window=20):\n    sma = np.convolve(prices, np.ones(window)/window, mode='valid')\n    std = np.array([np.std(prices[i:i+window]) for i in range(len(prices)-window+1)])\n    upper = sma + 2*std; lower = sma - 2*std\n    return {\"sma\": sma, \"upper\": upper, \"lower\": lower, \"width\": upper-lower}\n\ndef detect_squeeze(bands: dict, threshold_pct=0.02) -> bool:\n    latest_width_pct = bands[\"width\"][-1] / bands[\"sma\"][-1]\n    return latest_width_pct < threshold_pct\n\ndef regime(bands: dict, price: float) -> str:\n    bbp = (price - bands[\"lower\"][-1]) / (bands[\"upper\"][-1] - bands[\"lower\"][-1])\n    if bbp > 0.90: return \"upper_thrust_bullish\"\n    if bbp < 0.10: return \"lower_thrust_bearish\"\n    if bbp > 0.60: return \"bullish\"\n    if bbp < 0.40: return \"bearish\"\n    return \"neutral\"\n\nif __name__ == \"__main__\":\n    import sys\n    ticker = sys.argv[1] if len(sys.argv) > 1 else \"SPY\"\n    data = yf.download(ticker, period=\"3mo\", auto_redirect=True)[\"Close\"].dropna().values\n    bands = get_bands(data)\n    sqz = detect_squeeze(bands)\n    reg = regime(bands, data[-1])\n    pos = (data[-1] - bands[\"lower\"][-1]) / (bands[\"upper\"][-1] - bands[\"lower\"][-1])\n    print(f\"{ticker}: {'SQUEEZE' if sqz else 'Normal'} | Regime: {reg} | BBPosition: {pos:.1%}\")\n```\n\n### trend_engine.py\n```python\n#!/usr/bin/env python3\n\"\"\"Multi-timeframe trend engine — ADX + MA alignment.\"\"\"\nimport yfinance as yf, numpy as np\n\ndef adx(high, low, close, period=14):\n    plus_dm = np.maximum(high[1:] - high[:-1], 0)\n    minus_dm = np.maximum(low[:-1] - low[1:], 0)\n    tr = high[1:] - low[1:]; tr = np.maximum(tr, np.abs(close[1:] - close[:-1]))\n    plus_di = 100 * np.mean(plus_dm[-period:]) / (np.mean(tr[-period:]) + 1e-9)\n    minus_di = 100 * np.mean(minus_dm[-period:]) / (np.mean(tr[-period:]) + 1e-9)\n    return plus_di / (plus_di + minus_di + 1e-9) * 100\n\ndef ma_alignment(prices, ma20, ma50):\n    return \"bullish\" if prices[-1] > ma20[-1] > ma50[-1] else \\\n           \"bearish\" if prices[-1] < ma20[-1] < ma50[-1] else \"mixed\"\n\nif __name__ == \"__main__\":\n    import sys\n    ticker = sys.argv[1] if len(sys.argv) > 1 else \"SPY\"\n    for tf in [\"1d\",\"1wk\",\"1mo\"]:\n        try:\n            d = yf.download(ticker, period=\"3mo\", interval=tf, auto_redirect=True)\n            h,l,c = d[\"High\"].values, d[\"Low\"].values, d[\"Close\"].values\n            a = adx(h,l,c)\n            ma20 = np.convolve(c, np.ones(20)/20, mode='valid')\n            ma50 = np.convolve(c, np.ones(50)/50, mode='valid')\n            al = ma_alignment(c, ma20, ma50)\n            print(f\"{tf.upper()}: ADX={a:.1f} | MA={al}\")\n        except: pass\n```\n\n### liquidity_map.py\n```python\n#!/usr/bin/env python3\n\"\"\"Liquidity zones — max pain, strike walls, support/resistance.\"\"\"\nimport yfinance as yf\n\ndef get_liquidity(ticker: str) -> dict:\n    t = yf.Ticker(ticker)\n    price = t.info[\"regularMarketPrice\"]\n    try:\n        chain = t.option_chain(tExpiry := t.options[0])\n        strikes = sorted(chain.calls[\"strike\"].values)\n        max_pain = strikes[np.argmin(np.abs(strikes - price))]\n        return {\"max_pain\": max_pain, \"price\": price, \"expiry\": tExpiry}\n    except: return {\"max_pain\": price, \"price\": price, \"expiry\": \"unknown\"}\n\nif __name__ == \"__main__\":\n    import sys\n    ticker = sys.argv[1] if len(sys.argv) > 1 else \"SPY\"\n    z = get_liquidity(ticker)\n    pct = (z[\"max_pain\"] - z[\"price\"]) / z[\"price\"] * 100\n    print(f\"{ticker}: Price={z['price']:.2f} | Max Pain={z['max_pain']:.2f} ({pct:+.2f}%) | Expires: {z['expiry']}\")\n```\n\n### signal_generator.py\n```python\n#!/usr/bin/env python3\n\"\"\"Combined signal generator — all 5 inputs, unified output.\"\"\"\nimport subprocess, sys\n\ndef run_script(name, ticker):\n    try:\n        r = subprocess.run([\"python\", f\"scripts/{name}\", ticker], capture_output=True, text=True, timeout=30)\n        return r.stdout.strip()\n    except: return \"\"\n\ndef generate(ticker: str) -> dict:\n    whale   = run_script(\"whale_scanner.py\", ticker)\n    wave    = run_script(\"elliott_wave.py\", ticker)\n    bands   = run_script(\"bollinger_analyzer.py\", ticker)\n    trend   = run_script(\"trend_engine.py\", ticker)\n    liq     = run_script(\"liquidity_map.py\", ticker)\n    signals = {\"whale\": \"🟢\" in whale, \"wave3\": \"3\" in wave, \"squeeze\": \"SQUEEZE\" in bands}\n    score   = sum(signals.values())\n    conviction = \"HIGH\" if score >= 3 and signals[\"whale\"] else \\\n                 \"MEDIUM\" if score >= 2 and signals[\"whale\"] else \"NONE\"\n    return {\"ticker\": ticker, \"score\": score, \"conviction\": conviction, \"details\": locals()}\n\nif __name__ == \"__main__\":\n    ticker = sys.argv[1] if len(sys.argv) > 1 else \"AAPL\"\n    result = generate(ticker)\n    print(f\"{ticker}: {result['conviction']} ({result['score']}/5 signals)\")\n    print(f\"  Whale: {result['details']['whale']} | Wave3: {result['details']['wave3']} | Squeeze: {result['details']['squeeze']}\")\n```\n\n## Usage\n\nRun any script directly:\n```bash\npython scripts/whale_scanner.py SPY\npython scripts/elliott_wave.py NVDA\npython scripts/bollinger_analyzer.py TSLA\npython scripts/signal_generator.py --ticker AAPL\n```\n\nOr run all 5 inputs together:\n```bash\npython scripts/signal_generator.py --ticker NVDA\n```\n\n## Research Sources\n\n- Whale flow: FlowProof.io — \"sweeps > blocks > splits > single fills\"\n- Elliott Wave: elliottwave-forecast.com — 3 inviolable rules\n- Liquidity: StrikeWatch EA — 4-layer strike wall conviction scoring\n\nFile v1.0.12:_meta.json\n\n{\n  \"ownerId\": \"kn723dy43mmbqpy0cp62hwptm984gga5\",\n  \"slug\": \"options-trading-brain\",\n  \"version\": \"1.0.12\",\n  \"publishedAt\": 1778850723110\n}\n\nArchive v1.0.11: 2 files, 4308 bytes\n\nFiles: SKILL.md (10670b), _meta.json (141b)\n\nFile v1.0.11:SKILL.md\n\n---\nname: options-trading-brain\nversion: 1.0.11\ndescription: |\n  Professional-grade options trading signal generator. Monitors whale flow (Unusual \n  Whales), counts Elliott Waves, analyzes Bollinger Bands, multi-timeframe trend \n  alignment, and liquidity zones. Combines all 5 inputs into actionable trade signals.\n  Use when user asks for options signals, stock analysis, trading setups, or to check \n  a specific ticker. Fully autonomous — no API keys required for core analysis.\ncompatibility: Python 3.10+, yfinance, numpy, scipy. Optional: Unusual Whales subscription.\nmetadata:\n  author: ssyopro.zo.computer\n  category: finance\n  display-name: Options Trading Brain\n  tags: options, trading, signals, elliott-wave, whale-flow, bollinger, theta-gang\n---\n\n# Options Trading Brain\n\nProfessional options trading intelligence system combining 5 analysis dimensions into one unified signal.\n\n## The 5 Inputs (Signal Requires 3+ Aligned)\n\n### 1. Whale Flow (Unusual Whales)\n- Filter: $25K+ premium, sweep/block executions, ask-side fills\n- Hierarchy: sweeps > blocks > splits > single fills\n- Bullish: calls at ask + volume > OI; Bearish: puts at ask + volume > OI\n\n### 2. Elliott Wave\n- Wave 3 = strongest momentum entry\n- Wave 5 = exhaustion warning\n- Rules: Wave 2 can't retrace Wave 1; Wave 3 not shortest; Wave 4 can't overlap Wave 1\n\n### 3. Bollinger Bands\n- Squeeze (BB width < 2% of price) = volatile expansion imminent\n- Band thrust through upper/lower = strong momentum continuation\n- Position near bands = overbought/oversold reversal candidates\n\n### 4. Multi-Timeframe Trend\n- ADX > 25 = confirmed trend\n- MA alignment (price > MA20 > MA50) = uptrend confirmed\n- Weekly/Daily must align for high conviction\n\n### 5. Liquidity Zones\n- 4-layer strike walls: OI concentration + GEX + PCR + Max Pain proximity\n- Max Pain = where max options expire worthless (gravity level)\n- Support = cluster of put OI below price; Resistance = call OI above\n\n## Signal Hierarchy\n\n| Conviction | Requirement |\n|---|---|\n| **HIGH** | Whale + Wave 3 + (Trend OR Bollinger) aligned |\n| **MEDIUM** | Whale + 2 others aligned |\n| **NONE** | No whale signal = no trade |\n\n## Scripts (all embedded below)\n\n### whale_scanner.py\n```python\n#!/usr/bin/env python3\n\"\"\"Whale flow scanner — Unusual Whales inspired filters.\"\"\"\nimport yfinance as yf, numpy as np\n\nWHALE_THRESHOLD = 25_000  # $25K minimum\n\ndef get_price(ticker: str) -> float:\n    return yf.Ticker(ticker).info[\"regularMarketPrice\"]\n\ndef scan(ticker: str) -> dict:\n    price = get_price(ticker)\n    chains = yf.Ticker(ticker).option_chain()\n    \n    calls = chains.calls[chains.calls[\"volume\"] * chains.calls[\"lastPrice\"] * 100 >= WHALE_THRESHOLD]\n    puts  = chains.puts[chains.puts[\"volume\"] * chains.puts[\"lastPrice\"] * 100 >= WHALE_THRESHOLD]\n    \n    call_premium = (calls[\"volume\"] * calls[\"lastPrice\"] * 100).sum()\n    put_premium  = (puts[\"volume\"] * puts[\"lastPrice\"] * 100).sum()\n    \n    return {\n        \"ticker\": ticker, \"price\": price,\n        \"whale_calls\": len(calls), \"whale_puts\": len(puts),\n        \"call_premium\": call_premium, \"put_premium\": put_premium,\n        \"direction\": \"bullish\" if call_premium > put_premium * 1.2\n                    else \"bearish\" if put_premium > call_premium * 1.2 else \"neutral\"\n    }\n\nif __name__ == \"__main__\":\n    import sys\n    r = scan(sys.argv[1] if len(sys.argv) > 1 else \"SPY\")\n    print(f\"{r['ticker']}: {r['direction']} | Calls: {r['whale_calls']} | Puts: {r['whale_puts']} | \"\n          f\"Call$: ${r['call_premium']:,.0f} | Put$: ${r['put_premium']:,.0f}\")\n```\n\n### elliott_wave.py\n```python\n#!/usr/bin/env python3\n\"\"\"Elliott Wave counter — validates 3 rules, identifies impulse waves.\"\"\"\nimport yfinance as yf, numpy as np\n\ndef count_waves(prices: list) -> dict:\n    highs, lows = [], []\n    for i in range(1, len(prices)-1):\n        if prices[i] > prices[i-1] and prices[i] > prices[i+1]: highs.append(i)\n        if prices[i] < prices[i-1] and prices[i] < prices[i+1]: lows.append(i)\n    \n    if len(highs) < 2: return {\"wave_count\": 0, \"wave_number\": 0, \"wave_type\": \"unknown\"}\n    \n    wave3_strong = highs[1] - highs[0] > (highs[0] - lows[0]) if len(highs) > 1 else False\n    return {\n        \"wave_count\": len(highs),\n        \"wave_number\": min(5, len(highs)),\n        \"wave_type\": \"impulse_wave_3\" if wave3_strong else \"impulse_wave_1_or_5\"\n    }\n\ndef fib_levels(high: float, low: float) -> dict:\n    return {\n        \"fib_236\": low + (high - low) * 0.236,\n        \"fib_382\": low + (high - low) * 0.382,\n        \"fib_500\": low + (high - low) * 0.500,\n        \"fib_618\": low + (high - low) * 0.618,\n        \"fib_786\": low + (high - low) * 0.786,\n    }\n\ndef validate_impulse(p1, p2, p3, p4, p5) -> bool:\n    return (p2 < p1 and p3 > max(p1,p2) and p4 < p3 and p4 > p1 and p5 < p4)\n\nif __name__ == \"__main__\":\n    import sys\n    ticker = sys.argv[1] if len(sys.argv) > 1 else \"SPY\"\n    data = yf.download(ticker, period=\"3mo\", auto_redirect=True)[\"Close\"].dropna()\n    waves = count_waves(data.values.tolist())\n    print(f\"{ticker}: Wave {waves['wave_number']} ({waves['wave_type']})\")\n```\n\n### bollinger_analyzer.py\n```python\n#!/usr/bin/env python3\n\"\"\"Bollinger Bands analyzer — squeeze, thrust, regime detection.\"\"\"\nimport yfinance as yf, numpy as np\n\ndef get_bands(prices: np.ndarray, window=20):\n    sma = np.convolve(prices, np.ones(window)/window, mode='valid')\n    std = np.array([np.std(prices[i:i+window]) for i in range(len(prices)-window+1)])\n    upper = sma + 2*std; lower = sma - 2*std\n    return {\"sma\": sma, \"upper\": upper, \"lower\": lower, \"width\": upper-lower}\n\ndef detect_squeeze(bands: dict, threshold_pct=0.02) -> bool:\n    latest_width_pct = bands[\"width\"][-1] / bands[\"sma\"][-1]\n    return latest_width_pct < threshold_pct\n\ndef regime(bands: dict, price: float) -> str:\n    bbp = (price - bands[\"lower\"][-1]) / (bands[\"upper\"][-1] - bands[\"lower\"][-1])\n    if bbp > 0.90: return \"upper_thrust_bullish\"\n    if bbp < 0.10: return \"lower_thrust_bearish\"\n    if bbp > 0.60: return \"bullish\"\n    if bbp < 0.40: return \"bearish\"\n    return \"neutral\"\n\nif __name__ == \"__main__\":\n    import sys\n    ticker = sys.argv[1] if len(sys.argv) > 1 else \"SPY\"\n    data = yf.download(ticker, period=\"3mo\", auto_redirect=True)[\"Close\"].dropna().values\n    bands = get_bands(data)\n    sqz = detect_squeeze(bands)\n    reg = regime(bands, data[-1])\n    pos = (data[-1] - bands[\"lower\"][-1]) / (bands[\"upper\"][-1] - bands[\"lower\"][-1])\n    print(f\"{ticker}: {'SQUEEZE' if sqz else 'Normal'} | Regime: {reg} | BBPosition: {pos:.1%}\")\n```\n\n### trend_engine.py\n```python\n#!/usr/bin/env python3\n\"\"\"Multi-timeframe trend engine — ADX + MA alignment.\"\"\"\nimport yfinance as yf, numpy as np\n\ndef adx(high, low, close, period=14):\n    plus_dm = np.maximum(high[1:] - high[:-1], 0)\n    minus_dm = np.maximum(low[:-1] - low[1:], 0)\n    tr = high[1:] - low[1:]; tr = np.maximum(tr, np.abs(close[1:] - close[:-1]))\n    plus_di = 100 * np.mean(plus_dm[-period:]) / (np.mean(tr[-period:]) + 1e-9)\n    minus_di = 100 * np.mean(minus_dm[-period:]) / (np.mean(tr[-period:]) + 1e-9)\n    return plus_di / (plus_di + minus_di + 1e-9) * 100\n\ndef ma_alignment(prices, ma20, ma50):\n    return \"bullish\" if prices[-1] > ma20[-1] > ma50[-1] else \\\n           \"bearish\" if prices[-1] < ma20[-1] < ma50[-1] else \"mixed\"\n\nif __name__ == \"__main__\":\n    import sys\n    ticker = sys.argv[1] if len(sys.argv) > 1 else \"SPY\"\n    for tf in [\"1d\",\"1wk\",\"1mo\"]:\n        try:\n            d = yf.download(ticker, period=\"3mo\", interval=tf, auto_redirect=True)\n            h,l,c = d[\"High\"].values, d[\"Low\"].values, d[\"Close\"].values\n            a = adx(h,l,c)\n            ma20 = np.convolve(c, np.ones(20)/20, mode='valid')\n            ma50 = np.convolve(c, np.ones(50)/50, mode='valid')\n            al = ma_alignment(c, ma20, ma50)\n            print(f\"{tf.upper()}: ADX={a:.1f} | MA={al}\")\n        except: pass\n```\n\n### liquidity_map.py\n```python\n#!/usr/bin/env python3\n\"\"\"Liquidity zones — max pain, strike walls, support/resistance.\"\"\"\nimport yfinance as yf\n\ndef get_liquidity(ticker: str) -> dict:\n    t = yf.Ticker(ticker)\n    price = t.info[\"regularMarketPrice\"]\n    try:\n        chain = t.option_chain(tExpiry := t.options[0])\n        strikes = sorted(chain.calls[\"strike\"].values)\n        max_pain = strikes[np.argmin(np.abs(strikes - price))]\n        return {\"max_pain\": max_pain, \"price\": price, \"expiry\": tExpiry}\n    except: return {\"max_pain\": price, \"price\": price, \"expiry\": \"unknown\"}\n\nif __name__ == \"__main__\":\n    import sys\n    ticker = sys.argv[1] if len(sys.argv) > 1 else \"SPY\"\n    z = get_liquidity(ticker)\n    pct = (z[\"max_pain\"] - z[\"price\"]) / z[\"price\"] * 100\n    print(f\"{ticker}: Price={z['price']:.2f} | Max Pain={z['max_pain']:.2f} ({pct:+.2f}%) | Expires: {z['expiry']}\")\n```\n\n### signal_generator.py\n```python\n#!/usr/bin/env python3\n\"\"\"Combined signal generator — all 5 inputs, unified output.\"\"\"\nimport subprocess, sys\n\ndef run_script(name, ticker):\n    try:\n        r = subprocess.run([\"python\", f\"scripts/{name}\", ticker], capture_output=True, text=True, timeout=30)\n        return r.stdout.strip()\n    except: return \"\"\n\ndef generate(ticker: str) -> dict:\n    whale   = run_script(\"whale_scanner.py\", ticker)\n    wave    = run_script(\"elliott_wave.py\", ticker)\n    bands   = run_script(\"bollinger_analyzer.py\", ticker)\n    trend   = run_script(\"trend_engine.py\", ticker)\n    liq     = run_script(\"liquidity_map.py\", ticker)\n    signals = {\"whale\": \"🟢\" in whale, \"wave3\": \"3\" in wave, \"squeeze\": \"SQUEEZE\" in bands}\n    score   = sum(signals.values())\n    conviction = \"HIGH\" if score >= 3 and signals[\"whale\"] else \\\n                 \"MEDIUM\" if score >= 2 and signals[\"whale\"] else \"NONE\"\n    return {\"ticker\": ticker, \"score\": score, \"conviction\": conviction, \"details\": locals()}\n\nif __name__ == \"__main__\":\n    ticker = sys.argv[1] if len(sys.argv) > 1 else \"AAPL\"\n    result = generate(ticker)\n    print(f\"{ticker}: {result['conviction']} ({result['score']}/5 signals)\")\n    print(f\"  Whale: {result['details']['whale']} | Wave3: {result['details']['wave3']} | Squeeze: {result['details']['squeeze']}\")\n```\n\n## Usage\n\nRun any script directly:\n```bash\npython scripts/whale_scanner.py SPY\npython scripts/elliott_wave.py NVDA\npython scripts/bollinger_analyzer.py TSLA\npython scripts/signal_generator.py --ticker AAPL\n```\n\nOr run all 5 inputs together:\n```bash\npython scripts/signal_generator.py --ticker NVDA\n```\n\n## Research Sources\n\n- Whale flow: FlowProof.io — \"sweeps > blocks > splits > single fills\"\n- Elliott Wave: elliottwave-forecast.com — 3 inviolable rules\n- Liquidity: StrikeWatch EA — 4-layer strike wall conviction scoring\n\nFile v1.0.11:_meta.json\n\n{\n  \"ownerId\": \"kn723dy43mmbqpy0cp62hwptm984gga5\",\n  \"slug\": \"options-trading-brain\",\n  \"version\": \"1.0.11\",\n  \"publishedAt\": 1778764378938\n}\n\nArchive v1.0.10: 2 files, 4307 bytes\n\nFiles: SKILL.md (10670b), _meta.json (141b)\n\nFile v1.0.10:SKILL.md\n\n---\nname: options-trading-brain\nversion: 1.0.10\ndescription: |\n  Professional-grade options trading signal generator. Monitors whale flow (Unusual \n  Whales), counts Elliott Waves, analyzes Bollinger Bands, multi-timeframe trend \n  alignment, and liquidity zones. Combines all 5 inputs into actionable trade signals.\n  Use when user asks for options signals, stock analysis, trading setups, or to check \n  a specific ticker. Fully autonomous — no API keys required for core analysis.\ncompatibility: Python 3.10+, yfinance, numpy, scipy. Optional: Unusual Whales subscription.\nmetadata:\n  author: ssyopro.zo.computer\n  category: finance\n  display-name: Options Trading Brain\n  tags: options, trading, signals, elliott-wave, whale-flow, bollinger, theta-gang\n---\n\n# Options Trading Brain\n\nProfessional options trading intelligence system combining 5 analysis dimensions into one unified signal.\n\n## The 5 Inputs (Signal Requires 3+ Aligned)\n\n### 1. Whale Flow (Unusual Whales)\n- Filter: $25K+ premium, sweep/block executions, ask-side fills\n- Hierarchy: sweeps > blocks > splits > single fills\n- Bullish: calls at ask + volume > OI; Bearish: puts at ask + volume > OI\n\n### 2. Elliott Wave\n- Wave 3 = strongest momentum entry\n- Wave 5 = exhaustion warning\n- Rules: Wave 2 can't retrace Wave 1; Wave 3 not shortest; Wave 4 can't overlap Wave 1\n\n### 3. Bollinger Bands\n- Squeeze (BB width < 2% of price) = volatile expansion imminent\n- Band thrust through upper/lower = strong momentum continuation\n- Position near bands = overbought/oversold reversal candidates\n\n### 4. Multi-Timeframe Trend\n- ADX > 25 = confirmed trend\n- MA alignment (price > MA20 > MA50) = uptrend confirmed\n- Weekly/Daily must align for high conviction\n\n### 5. Liquidity Zones\n- 4-layer strike walls: OI concentration + GEX + PCR + Max Pain proximity\n- Max Pain = where max options expire worthless (gravity level)\n- Support = cluster of put OI below price; Resistance = call OI above\n\n## Signal Hierarchy\n\n| Conviction | Requirement |\n|---|---|\n| **HIGH** | Whale + Wave 3 + (Trend OR Bollinger) aligned |\n| **MEDIUM** | Whale + 2 others aligned |\n| **NONE** | No whale signal = no trade |\n\n## Scripts (all embedded below)\n\n### whale_scanner.py\n```python\n#!/usr/bin/env python3\n\"\"\"Whale flow scanner — Unusual Whales inspired filters.\"\"\"\nimport yfinance as yf, numpy as np\n\nWHALE_THRESHOLD = 25_000  # $25K minimum\n\ndef get_price(ticker: str) -> float:\n    return yf.Ticker(ticker).info[\"regularMarketPrice\"]\n\ndef scan(ticker: str) -> dict:\n    price = get_price(ticker)\n    chains = yf.Ticker(ticker).option_chain()\n    \n    calls = chains.calls[chains.calls[\"volume\"] * chains.calls[\"lastPrice\"] * 100 >= WHALE_THRESHOLD]\n    puts  = chains.puts[chains.puts[\"volume\"] * chains.puts[\"lastPrice\"] * 100 >= WHALE_THRESHOLD]\n    \n    call_premium = (calls[\"volume\"] * calls[\"lastPrice\"] * 100).sum()\n    put_premium  = (puts[\"volume\"] * puts[\"lastPrice\"] * 100).sum()\n    \n    return {\n        \"ticker\": ticker, \"price\": price,\n        \"whale_calls\": len(calls), \"whale_puts\": len(puts),\n        \"call_premium\": call_premium, \"put_premium\": put_premium,\n        \"direction\": \"bullish\" if call_premium > put_premium * 1.2\n                    else \"bearish\" if put_premium > call_premium * 1.2 else \"neutral\"\n    }\n\nif __name__ == \"__main__\":\n    import sys\n    r = scan(sys.argv[1] if len(sys.argv) > 1 else \"SPY\")\n    print(f\"{r['ticker']}: {r['direction']} | Calls: {r['whale_calls']} | Puts: {r['whale_puts']} | \"\n          f\"Call$: ${r['call_premium']:,.0f} | Put$: ${r['put_premium']:,.0f}\")\n```\n\n### elliott_wave.py\n```python\n#!/usr/bin/env python3\n\"\"\"Elliott Wave counter — validates 3 rules, identifies impulse waves.\"\"\"\nimport yfinance as yf, numpy as np\n\ndef count_waves(prices: list) -> dict:\n    highs, lows = [], []\n    for i in range(1, len(prices)-1):\n        if prices[i] > prices[i-1] and prices[i] > prices[i+1]: highs.append(i)\n        if prices[i] < prices[i-1] and prices[i] < prices[i+1]: lows.append(i)\n    \n    if len(highs) < 2: return {\"wave_count\": 0, \"wave_number\": 0, \"wave_type\": \"unknown\"}\n    \n    wave3_strong = highs[1] - highs[0] > (highs[0] - lows[0]) if len(highs) > 1 else False\n    return {\n        \"wave_count\": len(highs),\n        \"wave_number\": min(5, len(highs)),\n        \"wave_type\": \"impulse_wave_3\" if wave3_strong else \"impulse_wave_1_or_5\"\n    }\n\ndef fib_levels(high: float, low: float) -> dict:\n    return {\n        \"fib_236\": low + (high - low) * 0.236,\n        \"fib_382\": low + (high - low) * 0.382,\n        \"fib_500\": low + (high - low) * 0.500,\n        \"fib_618\": low + (high - low) * 0.618,\n        \"fib_786\": low + (high - low) * 0.786,\n    }\n\ndef validate_impulse(p1, p2, p3, p4, p5) -> bool:\n    return (p2 < p1 and p3 > max(p1,p2) and p4 < p3 and p4 > p1 and p5 < p4)\n\nif __name__ == \"__main__\":\n    import sys\n    ticker = sys.argv[1] if len(sys.argv) > 1 else \"SPY\"\n    data = yf.download(ticker, period=\"3mo\", auto_redirect=True)[\"Close\"].dropna()\n    waves = count_waves(data.values.tolist())\n    print(f\"{ticker}: Wave {waves['wave_number']} ({waves['wave_type']})\")\n```\n\n### bollinger_analyzer.py\n```python\n#!/usr/bin/env python3\n\"\"\"Bollinger Bands analyzer — squeeze, thrust, regime detection.\"\"\"\nimport yfinance as yf, numpy as np\n\ndef get_bands(prices: np.ndarray, window=20):\n    sma = np.convolve(prices, np.ones(window)/window, mode='valid')\n    std = np.array([np.std(prices[i:i+window]) for i in range(len(prices)-window+1)])\n    upper = sma + 2*std; lower = sma - 2*std\n    return {\"sma\": sma, \"upper\": upper, \"lower\": lower, \"width\": upper-lower}\n\ndef detect_squeeze(bands: dict, threshold_pct=0.02) -> bool:\n    latest_width_pct = bands[\"width\"][-1] / bands[\"sma\"][-1]\n    return latest_width_pct < threshold_pct\n\ndef regime(bands: dict, price: float) -> str:\n    bbp = (price - bands[\"lower\"][-1]) / (bands[\"upper\"][-1] - bands[\"lower\"][-1])\n    if bbp > 0.90: return \"upper_thrust_bullish\"\n    if bbp < 0.10: return \"lower_thrust_bearish\"\n    if bbp > 0.60: return \"bullish\"\n    if bbp < 0.40: return \"bearish\"\n    return \"neutral\"\n\nif __name__ == \"__main__\":\n    import sys\n    ticker = sys.argv[1] if len(sys.argv) > 1 else \"SPY\"\n    data = yf.download(ticker, period=\"3mo\", auto_redirect=True)[\"Close\"].dropna().values\n    bands = get_bands(data)\n    sqz = detect_squeeze(bands)\n    reg = regime(bands, data[-1])\n    pos = (data[-1] - bands[\"lower\"][-1]) / (bands[\"upper\"][-1] - bands[\"lower\"][-1])\n    print(f\"{ticker}: {'SQUEEZE' if sqz else 'Normal'} | Regime: {reg} | BBPosition: {pos:.1%}\")\n```\n\n### trend_engine.py\n```python\n#!/usr/bin/env python3\n\"\"\"Multi-timeframe trend engine — ADX + MA alignment.\"\"\"\nimport yfinance as yf, numpy as np\n\ndef adx(high, low, close, period=14):\n    plus_dm = np.maximum(high[1:] - high[:-1], 0)\n    minus_dm = np.maximum(low[:-1] - low[1:], 0)\n    tr = high[1:] - low[1:]; tr = np.maximum(tr, np.abs(close[1:] - close[:-1]))\n    plus_di = 100 * np.mean(plus_dm[-period:]) / (np.mean(tr[-period:]) + 1e-9)\n    minus_di = 100 * np.mean(minus_dm[-period:]) / (np.mean(tr[-period:]) + 1e-9)\n    return plus_di / (plus_di + minus_di + 1e-9) * 100\n\ndef ma_alignment(prices, ma20, ma50):\n    return \"bullish\" if prices[-1] > ma20[-1] > ma50[-1] else \\\n           \"bearish\" if prices[-1] < ma20[-1] < ma50[-1] else \"mixed\"\n\nif __name__ == \"__main__\":\n    import sys\n    ticker = sys.argv[1] if len(sys.argv) > 1 else \"SPY\"\n    for tf in [\"1d\",\"1wk\",\"1mo\"]:\n        try:\n            d = yf.download(ticker, period=\"3mo\", interval=tf, auto_redirect=True)\n            h,l,c = d[\"High\"].values, d[\"Low\"].values, d[\"Close\"].values\n            a = adx(h,l,c)\n            ma20 = np.convolve(c, np.ones(20)/20, mode='valid')\n            ma50 = np.convolve(c, np.ones(50)/50, mode='valid')\n            al = ma_alignment(c, ma20, ma50)\n            print(f\"{tf.upper()}: ADX={a:.1f} | MA={al}\")\n        except: pass\n```\n\n### liquidity_map.py\n```python\n#!/usr/bin/env python3\n\"\"\"Liquidity zones — max pain, strike walls, support/resistance.\"\"\"\nimport yfinance as yf\n\ndef get_liquidity(ticker: str) -> dict:\n    t = yf.Ticker(ticker)\n    price = t.info[\"regularMarketPrice\"]\n    try:\n        chain = t.option_chain(tExpiry := t.options[0])\n        strikes = sorted(chain.calls[\"strike\"].values)\n        max_pain = strikes[np.argmin(np.abs(strikes - price))]\n        return {\"max_pain\": max_pain, \"price\": price, \"expiry\": tExpiry}\n    except: return {\"max_pain\": price, \"price\": price, \"expiry\": \"unknown\"}\n\nif __name__ == \"__main__\":\n    import sys\n    ticker = sys.argv[1] if len(sys.argv) > 1 else \"SPY\"\n    z = get_liquidity(ticker)\n    pct = (z[\"max_pain\"] - z[\"price\"]) / z[\"price\"] * 100\n    print(f\"{ticker}: Price={z['price']:.2f} | Max Pain={z['max_pain']:.2f} ({pct:+.2f}%) | Expires: {z['expiry']}\")\n```\n\n### signal_generator.py\n```python\n#!/usr/bin/env python3\n\"\"\"Combined signal generator — all 5 inputs, unified output.\"\"\"\nimport subprocess, sys\n\ndef run_script(name, ticker):\n    try:\n        r = subprocess.run([\"python\", f\"scripts/{name}\", ticker], capture_output=True, text=True, timeout=30)\n        return r.stdout.strip()\n    except: return \"\"\n\ndef generate(ticker: str) -> dict:\n    whale   = run_script(\"whale_scanner.py\", ticker)\n    wave    = run_script(\"elliott_wave.py\", ticker)\n    bands   = run_script(\"bollinger_analyzer.py\", ticker)\n    trend   = run_script(\"trend_engine.py\", ticker)\n    liq     = run_script(\"liquidity_map.py\", ticker)\n    signals = {\"whale\": \"🟢\" in whale, \"wave3\": \"3\" in wave, \"squeeze\": \"SQUEEZE\" in bands}\n    score   = sum(signals.values())\n    conviction = \"HIGH\" if score >= 3 and signals[\"whale\"] else \\\n                 \"MEDIUM\" if score >= 2 and signals[\"whale\"] else \"NONE\"\n    return {\"ticker\": ticker, \"score\": score, \"conviction\": conviction, \"details\": locals()}\n\nif __name__ == \"__main__\":\n    ticker = sys.argv[1] if len(sys.argv) > 1 else \"AAPL\"\n    result = generate(ticker)\n    print(f\"{ticker}: {result['conviction']} ({result['score']}/5 signals)\")\n    print(f\"  Whale: {result['details']['whale']} | Wave3: {result['details']['wave3']} | Squeeze: {result['details']['squeeze']}\")\n```\n\n## Usage\n\nRun any script directly:\n```bash\npython scripts/whale_scanner.py SPY\npython scripts/elliott_wave.py NVDA\npython scripts/bollinger_analyzer.py TSLA\npython scripts/signal_generator.py --ticker AAPL\n```\n\nOr run all 5 inputs together:\n```bash\npython scripts/signal_generator.py --ticker NVDA\n```\n\n## Research Sources\n\n- Whale flow: FlowProof.io — \"sweeps > blocks > splits > single fills\"\n- Elliott Wave: elliottwave-forecast.com — 3 inviolable rules\n- Liquidity: StrikeWatch EA — 4-layer strike wall conviction scoring\n\nFile v1.0.10:_meta.json\n\n{\n  \"ownerId\": \"kn723dy43mmbqpy0cp62hwptm984gga5\",\n  \"slug\": \"options-trading-brain\",\n  \"version\": \"1.0.10\",\n  \"publishedAt\": 1777902299498\n}\n\nArchive v1.0.9: 2 files, 4307 bytes\n\nFiles: SKILL.md (10669b), _meta.json (140b)\n\nFile v1.0.9:SKILL.md\n\n---\nname: options-trading-brain\nversion: 1.0.9\ndescription: |\n  Professional-grade options trading signal generator. Monitors whale flow (Unusual \n  Whales), counts Elliott Waves, analyzes Bollinger Bands, multi-timeframe trend \n  alignment, and liquidity zones. Combines all 5 inputs into actionable trade signals.\n  Use when user asks for options signals, stock analysis, trading setups, or to check \n  a specific ticker. Fully autonomous — no API keys required for core analysis.\ncompatibility: Python 3.10+, yfinance, numpy, scipy. Optional: Unusual Whales subscription.\nmetadata:\n  author: ssyopro.zo.computer\n  category: finance\n  display-name: Options Trading Brain\n  tags: options, trading, signals, elliott-wave, whale-flow, bollinger, theta-gang\n---\n\n# Options Trading Brain\n\nProfessional options trading intelligence system combining 5 analysis dimensions into one unified signal.\n\n## The 5 Inputs (Signal Requires 3+ Aligned)\n\n### 1. Whale Flow (Unusual Whales)\n- Filter: $25K+ premium, sweep/block executions, ask-side fills\n- Hierarchy: sweeps > blocks > splits > single fills\n- Bullish: calls at ask + volume > OI; Bearish: puts at ask + volume > OI\n\n### 2. Elliott Wave\n- Wave 3 = strongest momentum entry\n- Wave 5 = exhaustion warning\n- Rules: Wave 2 can't retrace Wave 1; Wave 3 not shortest; Wave 4 can't overlap Wave 1\n\n### 3. Bollinger Bands\n- Squeeze (BB width < 2% of price) = volatile expansion imminent\n- Band thrust through upper/lower = strong momentum continuation\n- Position near bands = overbought/oversold reversal candidates\n\n### 4. Multi-Timeframe Trend\n- ADX > 25 = confirmed trend\n- MA alignment (price > MA20 > MA50) = uptrend confirmed\n- Weekly/Daily must align for high conviction\n\n### 5. Liquidity Zones\n- 4-layer strike walls: OI concentration + GEX + PCR + Max Pain proximity\n- Max Pain = where max options expire worthless (gravity level)\n- Support = cluster of put OI below price; Resistance = call OI above\n\n## Signal Hierarchy\n\n| Conviction | Requirement |\n|---|---|\n| **HIGH** | Whale + Wave 3 + (Trend OR Bollinger) aligned |\n| **MEDIUM** | Whale + 2 others aligned |\n| **NONE** | No whale signal = no trade |\n\n## Scripts (all embedded below)\n\n### whale_scanner.py\n```python\n#!/usr/bin/env python3\n\"\"\"Whale flow scanner — Unusual Whales inspired filters.\"\"\"\nimport yfinance as yf, numpy as np\n\nWHALE_THRESHOLD = 25_000  # $25K minimum\n\ndef get_price(ticker: str) -> float:\n    return yf.Ticker(ticker).info[\"regularMarketPrice\"]\n\ndef scan(ticker: str) -> dict:\n    price = get_price(ticker)\n    chains = yf.Ticker(ticker).option_chain()\n    \n    calls = chains.calls[chains.calls[\"volume\"] * chains.calls[\"lastPrice\"] * 100 >= WHALE_THRESHOLD]\n    puts  = chains.puts[chains.puts[\"volume\"] * chains.puts[\"lastPrice\"] * 100 >= WHALE_THRESHOLD]\n    \n    call_premium = (calls[\"volume\"] * calls[\"lastPrice\"] * 100).sum()\n    put_premium  = (puts[\"volume\"] * puts[\"lastPrice\"] * 100).sum()\n    \n    return {\n        \"ticker\": ticker, \"price\": price,\n        \"whale_calls\": len(calls), \"whale_puts\": len(puts),\n        \"call_premium\": call_premium, \"put_premium\": put_premium,\n        \"direction\": \"bullish\" if call_premium > put_premium * 1.2\n                    else \"bearish\" if put_premium > call_premium * 1.2 else \"neutral\"\n    }\n\nif __name__ == \"__main__\":\n    import sys\n    r = scan(sys.argv[1] if len(sys.argv) > 1 else \"SPY\")\n    print(f\"{r['ticker']}: {r['direction']} | Calls: {r['whale_calls']} | Puts: {r['whale_puts']} | \"\n          f\"Call$: ${r['call_premium']:,.0f} | Put$: ${r['put_premium']:,.0f}\")\n```\n\n### elliott_wave.py\n```python\n#!/usr/bin/env python3\n\"\"\"Elliott Wave counter — validates 3 rules, identifies impulse waves.\"\"\"\nimport yfinance as yf, numpy as np\n\ndef count_waves(prices: list) -> dict:\n    highs, lows = [], []\n    for i in range(1, len(prices)-1):\n        if prices[i] > prices[i-1] and prices[i] > prices[i+1]: highs.append(i)\n        if prices[i] < prices[i-1] and prices[i] < prices[i+1]: lows.append(i)\n    \n    if len(highs) < 2: return {\"wave_count\": 0, \"wave_number\": 0, \"wave_type\": \"unknown\"}\n    \n    wave3_strong = highs[1] - highs[0] > (highs[0] - lows[0]) if len(highs) > 1 else False\n    return {\n        \"wave_count\": len(highs),\n        \"wave_number\": min(5, len(highs)),\n        \"wave_type\": \"impulse_wave_3\" if wave3_strong else \"impulse_wave_1_or_5\"\n    }\n\ndef fib_levels(high: float, low: float) -> dict:\n    return {\n        \"fib_236\": low + (high - low) * 0.236,\n        \"fib_382\": low + (high - low) * 0.382,\n        \"fib_500\": low + (high - low) * 0.500,\n        \"fib_618\": low + (high - low) * 0.618,\n        \"fib_786\": low + (high - low) * 0.786,\n    }\n\ndef validate_impulse(p1, p2, p3, p4, p5) -> bool:\n    return (p2 < p1 and p3 > max(p1,p2) and p4 < p3 and p4 > p1 and p5 < p4)\n\nif __name__ == \"__main__\":\n    import sys\n    ticker = sys.argv[1] if len(sys.argv) > 1 else \"SPY\"\n    data = yf.download(ticker, period=\"3mo\", auto_redirect=True)[\"Close\"].dropna()\n    waves = count_waves(data.values.tolist())\n    print(f\"{ticker}: Wave {waves['wave_number']} ({waves['wave_type']})\")\n```\n\n### bollinger_analyzer.py\n```python\n#!/usr/bin/env python3\n\"\"\"Bollinger Bands analyzer — squeeze, thrust, regime detection.\"\"\"\nimport yfinance as yf, numpy as np\n\ndef get_bands(prices: np.ndarray, window=20):\n    sma = np.convolve(prices, np.ones(window)/window, mode='valid')\n    std = np.array([np.std(prices[i:i+window]) for i in range(len(prices)-window+1)])\n    upper = sma + 2*std; lower = sma - 2*std\n    return {\"sma\": sma, \"upper\": upper, \"lower\": lower, \"width\": upper-lower}\n\ndef detect_squeeze(bands: dict, threshold_pct=0.02) -> bool:\n    latest_width_pct = bands[\"width\"][-1] / bands[\"sma\"][-1]\n    return latest_width_pct < threshold_pct\n\ndef regime(bands: dict, price: float) -> str:\n    bbp = (price - bands[\"lower\"][-1]) / (bands[\"upper\"][-1] - bands[\"lower\"][-1])\n    if bbp > 0.90: return \"upper_thrust_bullish\"\n    if bbp < 0.10: return \"lower_thrust_bearish\"\n    if bbp > 0.60: return \"bullish\"\n    if bbp < 0.40: return \"bearish\"\n    return \"neutral\"\n\nif __name__ == \"__main__\":\n    import sys\n    ticker = sys.argv[1] if len(sys.argv) > 1 else \"SPY\"\n    data = yf.download(ticker, period=\"3mo\", auto_redirect=True)[\"Close\"].dropna().values\n    bands = get_bands(data)\n    sqz = detect_squeeze(bands)\n    reg = regime(bands, data[-1])\n    pos = (data[-1] - bands[\"lower\"][-1]) / (bands[\"upper\"][-1] - bands[\"lower\"][-1])\n    print(f\"{ticker}: {'SQUEEZE' if sqz else 'Normal'} | Regime: {reg} | BBPosition: {pos:.1%}\")\n```\n\n### trend_engine.py\n```python\n#!/usr/bin/env python3\n\"\"\"Multi-timeframe trend engine — ADX + MA alignment.\"\"\"\nimport yfinance as yf, numpy as np\n\ndef adx(high, low, close, period=14):\n    plus_dm = np.maximum(high[1:] - high[:-1], 0)\n    minus_dm = np.maximum(low[:-1] - low[1:], 0)\n    tr = high[1:] - low[1:]; tr = np.maximum(tr, np.abs(close[1:] - close[:-1]))\n    plus_di = 100 * np.mean(plus_dm[-period:]) / (np.mean(tr[-period:]) + 1e-9)\n    minus_di = 100 * np.mean(minus_dm[-period:]) / (np.mean(tr[-period:]) + 1e-9)\n    return plus_di / (plus_di + minus_di + 1e-9) * 100\n\ndef ma_alignment(prices, ma20, ma50):\n    return \"bullish\" if prices[-1] > ma20[-1] > ma50[-1] else \\\n           \"bearish\" if prices[-1] < ma20[-1] < ma50[-1] else \"mixed\"\n\nif __name__ == \"__main__\":\n    import sys\n    ticker = sys.argv[1] if len(sys.argv) > 1 else \"SPY\"\n    for tf in [\"1d\",\"1wk\",\"1mo\"]:\n        try:\n            d = yf.download(ticker, period=\"3mo\", interval=tf, auto_redirect=True)\n            h,l,c = d[\"High\"].values, d[\"Low\"].values, d[\"Close\"].values\n            a = adx(h,l,c)\n            ma20 = np.convolve(c, np.ones(20)/20, mode='valid')\n            ma50 = np.convolve(c, np.ones(50)/50, mode='valid')\n            al = ma_alignment(c, ma20, ma50)\n            print(f\"{tf.upper()}: ADX={a:.1f} | MA={al}\")\n        except: pass\n```\n\n### liquidity_map.py\n```python\n#!/usr/bin/env python3\n\"\"\"Liquidity zones — max pain, strike walls, support/resistance.\"\"\"\nimport yfinance as yf\n\ndef get_liquidity(ticker: str) -> dict:\n    t = yf.Ticker(ticker)\n    price = t.info[\"regularMarketPrice\"]\n    try:\n        chain = t.option_chain(tExpiry := t.options[0])\n        strikes = sorted(chain.calls[\"strike\"].values)\n        max_pain = strikes[np.argmin(np.abs(strikes - price))]\n        return {\"max_pain\": max_pain, \"price\": price, \"expiry\": tExpiry}\n    except: return {\"max_pain\": price, \"price\": price, \"expiry\": \"unknown\"}\n\nif __name__ == \"__main__\":\n    import sys\n    ticker = sys.argv[1] if len(sys.argv) > 1 else \"SPY\"\n    z = get_liquidity(ticker)\n    pct = (z[\"max_pain\"] - z[\"price\"]) / z[\"price\"] * 100\n    print(f\"{ticker}: Price={z['price']:.2f} | Max Pain={z['max_pain']:.2f} ({pct:+.2f}%) | Expires: {z['expiry']}\")\n```\n\n### signal_generator.py\n```python\n#!/usr/bin/env python3\n\"\"\"Combined signal generator — all 5 inputs, unified output.\"\"\"\nimport subprocess, sys\n\ndef run_script(name, ticker):\n    try:\n        r = subprocess.run([\"python\", f\"scripts/{name}\", ticker], capture_output=True, text=True, timeout=30)\n        return r.stdout.strip()\n    except: return \"\"\n\ndef generate(ticker: str) -> dict:\n    whale   = run_script(\"whale_scanner.py\", ticker)\n    wave    = run_script(\"elliott_wave.py\", ticker)\n    bands   = run_script(\"bollinger_analyzer.py\", ticker)\n    trend   = run_script(\"trend_engine.py\", ticker)\n    liq     = run_script(\"liquidity_map.py\", ticker)\n    signals = {\"whale\": \"🟢\" in whale, \"wave3\": \"3\" in wave, \"squeeze\": \"SQUEEZE\" in bands}\n    score   = sum(signals.values())\n    conviction = \"HIGH\" if score >= 3 and signals[\"whale\"] else \\\n                 \"MEDIUM\" if score >= 2 and signals[\"whale\"] else \"NONE\"\n    return {\"ticker\": ticker, \"score\": score, \"conviction\": conviction, \"details\": locals()}\n\nif __name__ == \"__main__\":\n    ticker = sys.argv[1] if len(sys.argv) > 1 else \"AAPL\"\n    result = generate(ticker)\n    print(f\"{ticker}: {result['conviction']} ({result['score']}/5 signals)\")\n    print(f\"  Whale: {result['details']['whale']} | Wave3: {result['details']['wave3']} | Squeeze: {result['details']['squeeze']}\")\n```\n\n## Usage\n\nRun any script directly:\n```bash\npython scripts/whale_scanner.py SPY\npython scripts/elliott_wave.py NVDA\npython scripts/bollinger_analyzer.py TSLA\npython scripts/signal_generator.py --ticker AAPL\n```\n\nOr run all 5 inputs together:\n```bash\npython scripts/signal_generator.py --ticker NVDA\n```\n\n## Research Sources\n\n- Whale flow: FlowProof.io — \"sweeps > blocks > splits > single fills\"\n- Elliott Wave: elliottwave-forecast.com — 3 inviolable rules\n- Liquidity: StrikeWatch EA — 4-layer strike wall conviction scoring\n\nFile v1.0.9:_meta.json\n\n{\n  \"ownerId\": \"kn723dy43mmbqpy0cp62hwptm984gga5\",\n  \"slug\": \"options-trading-brain\",\n  \"version\": \"1.0.9\",\n  \"publishedAt\": 1777901472309\n}\n\nArchive v1.0.8: 2 files, 4308 bytes\n\nFiles: SKILL.md (10669b), _meta.json (140b)\n\nFile v1.0.8:SKILL.md\n\n---\nname: options-trading-brain\nversion: 1.0.8\ndescription: |\n  Professional-grade options trading signal generator. Monitors whale flow (Unusual \n  Whales), counts Elliott Waves, analyzes Bollinger Bands, multi-timeframe trend \n  alignment, and liquidity zones. Combines all 5 inputs into actionable trade signals.\n  Use when user asks for options signals, stock analysis, trading setups, or to check \n  a specific ticker. Fully autonomous — no API keys required for core analysis.\ncompatibility: Python 3.10+, yfinance, numpy, scipy. Optional: Unusual Whales subscription.\nmetadata:\n  author: ssyopro.zo.computer\n  category: finance\n  display-name: Options Trading Brain\n  tags: options, trading, signals, elliott-wave, whale-flow, bollinger, theta-gang\n---\n\n# Options Trading Brain\n\nProfessional options trading intelligence system combining 5 analysis dimensions into one unified signal.\n\n## The 5 Inputs (Signal Requires 3+ Aligned)\n\n### 1. Whale Flow (Unusual Whales)\n- Filter: $25K+ premium, sweep/block executions, ask-side fills\n- Hierarchy: sweeps > blocks > splits > single fills\n- Bullish: calls at ask + volume > OI; Bearish: puts at ask + volume > OI\n\n### 2. Elliott Wave\n- Wave 3 = strongest momentum entry\n- Wave 5 = exhaustion warning\n- Rules: Wave 2 can't retrace Wave 1; Wave 3 not shortest; Wave 4 can't overlap Wave 1\n\n### 3. Bollinger Bands\n- Squeeze (BB width < 2% of price) = volatile expansion imminent\n- Band thrust through upper/lower = strong momentum continuation\n- Position near bands = overbought/oversold reversal candidates\n\n### 4. Multi-Timeframe Trend\n- ADX > 25 = confirmed trend\n- MA alignment (price > MA20 > MA50) = uptrend confirmed\n- Weekly/Daily must align for high conviction\n\n### 5. Liquidity Zones\n- 4-layer strike walls: OI concentration + GEX + PCR + Max Pain proximity\n- Max Pain = where max options expire worthless (gravity level)\n- Support = cluster of put OI below price; Resistance = call OI above\n\n## Signal Hierarchy\n\n| Conviction | Requirement |\n|---|---|\n| **HIGH** | Whale + Wave 3 + (Trend OR Bollinger) aligned |\n| **MEDIUM** | Whale + 2 others aligned |\n| **NONE** | No whale signal = no trade |\n\n## Scripts (all embedded below)\n\n### whale_scanner.py\n```python\n#!/usr/bin/env python3\n\"\"\"Whale flow scanner — Unusual Whales inspired filters.\"\"\"\nimport yfinance as yf, numpy as np\n\nWHALE_THRESHOLD = 25_000  # $25K minimum\n\ndef get_price(ticker: str) -> float:\n    return yf.Ticker(ticker).info[\"regularMarketPrice\"]\n\ndef scan(ticker: str) -> dict:\n    price = get_price(ticker)\n    chains = yf.Ticker(ticker).option_chain()\n    \n    calls = chains.calls[chains.calls[\"volume\"] * chains.calls[\"lastPrice\"] * 100 >= WHALE_THRESHOLD]\n    puts  = chains.puts[chains.puts[\"volume\"] * chains.puts[\"lastPrice\"] * 100 >= WHALE_THRESHOLD]\n    \n    call_premium = (calls[\"volume\"] * calls[\"lastPrice\"] * 100).sum()\n    put_premium  = (puts[\"volume\"] * puts[\"lastPrice\"] * 100).sum()\n    \n    return {\n        \"ticker\": ticker, \"price\": price,\n        \"whale_calls\": len(calls), \"whale_puts\": len(puts),\n        \"call_premium\": call_premium, \"put_premium\": put_premium,\n        \"direction\": \"bullish\" if call_premium > put_premium * 1.2\n                    else \"bearish\" if put_premium > call_premium * 1.2 else \"neutral\"\n    }\n\nif __name__ == \"__main__\":\n    import sys\n    r = scan(sys.argv[1] if len(sys.argv) > 1 else \"SPY\")\n    print(f\"{r['ticker']}: {r['direction']} | Calls: {r['whale_calls']} | Puts: {r['whale_puts']} | \"\n          f\"Call$: ${r['call_premium']:,.0f} | Put$: ${r['put_premium']:,.0f}\")\n```\n\n### elliott_wave.py\n```python\n#!/usr/bin/env python3\n\"\"\"Elliott Wave counter — validates 3 rules, identifies impulse waves.\"\"\"\nimport yfinance as yf, numpy as np\n\ndef count_waves(prices: list) -> dict:\n    highs, lows = [], []\n    for i in range(1, len(prices)-1):\n        if prices[i] > prices[i-1] and prices[i] > prices[i+1]: highs.append(i)\n        if prices[i] < prices[i-1] and prices[i] < prices[i+1]: lows.append(i)\n    \n    if len(highs) < 2: return {\"wave_count\": 0, \"wave_number\": 0, \"wave_type\": \"unknown\"}\n    \n    wave3_strong = highs[1] - highs[0] > (highs[0] - lows[0]) if len(highs) > 1 else False\n    return {\n        \"wave_count\": len(highs),\n        \"wave_number\": min(5, len(highs)),\n        \"wave_type\": \"impulse_wave_3\" if wave3_strong else \"impulse_wave_1_or_5\"\n    }\n\ndef fib_levels(high: float, low: float) -> dict:\n    return {\n        \"fib_236\": low + (high - low) * 0.236,\n        \"fib_382\": low + (high - low) * 0.382,\n        \"fib_500\": low + (high - low) * 0.500,\n        \"fib_618\": low + (high - low) * 0.618,\n        \"fib_786\": low + (high - low) * 0.786,\n    }\n\ndef validate_impulse(p1, p2, p3, p4, p5) -> bool:\n    return (p2 < p1 and p3 > max(p1,p2) and p4 < p3 and p4 > p1 and p5 < p4)\n\nif __name__ == \"__main__\":\n    import sys\n    ticker = sys.argv[1] if len(sys.argv) > 1 else \"SPY\"\n    data = yf.download(ticker, period=\"3mo\", auto_redirect=True)[\"Close\"].dropna()\n    waves = count_waves(data.values.tolist())\n    print(f\"{ticker}: Wave {waves['wave_number']} ({waves['wave_type']})\")\n```\n\n### bollinger_analyzer.py\n```python\n#!/usr/bin/env python3\n\"\"\"Bollinger Bands analyzer — squeeze, thrust, regime detection.\"\"\"\nimport yfinance as yf, numpy as np\n\ndef get_bands(prices: np.ndarray, window=20):\n    sma = np.convolve(prices, np.ones(window)/window, mode='valid')\n    std = np.array([np.std(prices[i:i+window]) for i in range(len(prices)-window+1)])\n    upper = sma + 2*std; lower = sma - 2*std\n    return {\"sma\": sma, \"upper\": upper, \"lower\": lower, \"width\": upper-lower}\n\ndef detect_squeeze(bands: dict, threshold_pct=0.02) -> bool:\n    latest_width_pct = bands[\"width\"][-1] / bands[\"sma\"][-1]\n    return latest_width_pct < threshold_pct\n\ndef regime(bands: dict, price: float) -> str:\n    bbp = (price - bands[\"lower\"][-1]) / (bands[\"upper\"][-1] - bands[\"lower\"][-1])\n    if bbp > 0.90: return \"upper_thrust_bullish\"\n    if bbp < 0.10: return \"lower_thrust_bearish\"\n    if bbp > 0.60: return \"bullish\"\n    if bbp < 0.40: return \"bearish\"\n    return \"neutral\"\n\nif __name__ == \"__main__\":\n    import sys\n    ticker = sys.argv[1] if len(sys.argv) > 1 else \"SPY\"\n    data = yf.download(ticker, period=\"3mo\", auto_redirect=True)[\"Close\"].dropna().values\n    bands = get_bands(data)\n    sqz = detect_squeeze(bands)\n    reg = regime(bands, data[-1])\n    pos = (data[-1] - bands[\"lower\"][-1]) / (bands[\"upper\"][-1] - bands[\"lower\"][-1])\n    print(f\"{ticker}: {'SQUEEZE' if sqz else 'Normal'} | Regime: {reg} | BBPosition: {pos:.1%}\")\n```\n\n### trend_engine.py\n```python\n#!/usr/bin/env python3\n\"\"\"Multi-timeframe trend engine — ADX + MA alignment.\"\"\"\nimport yfinance as yf, numpy as np\n\ndef adx(high, low, close, period=14):\n    plus_dm = np.maximum(high[1:] - high[:-1], 0)\n    minus_dm = np.maximum(low[:-1] - low[1:], 0)\n    tr = high[1:] - low[1:]; tr = np.maximum(tr, np.abs(close[1:] - close[:-1]))\n    plus_di = 100 * np.mean(plus_dm[-period:]) / (np.mean(tr[-period:]) + 1e-9)\n    minus_di = 100 * np.mean(minus_dm[-period:]) / (np.mean(tr[-period:]) + 1e-9)\n    return plus_di / (plus_di + minus_di + 1e-9) * 100\n\ndef ma_alignment(prices, ma20, ma50):\n    return \"bullish\" if prices[-1] > ma20[-1] > ma50[-1] else \\\n           \"bearish\" if prices[-1] < ma20[-1] < ma50[-1] else \"mixed\"\n\nif __name__ == \"__main__\":\n    import sys\n    ticker = sys.argv[1] if len(sys.argv) > 1 else \"SPY\"\n    for tf in [\"1d\",\"1wk\",\"1mo\"]:\n        try:\n            d = yf.download(ticker, period=\"3mo\", interval=tf, auto_redirect=True)\n            h,l,c = d[\"High\"].values, d[\"Low\"].values, d[\"Close\"].values\n            a = adx(h,l,c)\n            ma20 = np.convolve(c, np.ones(20)/20, mode='valid')\n            ma50 = np.convolve(c, np.ones(50)/50, mode='valid')\n            al = ma_alignment(c, ma20, ma50)\n            print(f\"{tf.upper()}: ADX={a:.1f} | MA={al}\")\n        except: pass\n```\n\n### liquidity_map.py\n```python\n#!/usr/bin/env python3\n\"\"\"Liquidity zones — max pain, strike walls, support/resistance.\"\"\"\nimport yfinance as yf\n\ndef get_liquidity(ticker: str) -> dict:\n    t = yf.Ticker(ticker)\n    price = t.info[\"regularMarketPrice\"]\n    try:\n        chain = t.option_chain(tExpiry := t.options[0])\n        strikes = sorted(chain.calls[\"strike\"].values)\n        max_pain = strikes[np.argmin(np.abs(strikes - price))]\n        return {\"max_pain\": max_pain, \"price\": price, \"expiry\": tExpiry}\n    except: return {\"max_pain\": price, \"price\": price, \"expiry\": \"unknown\"}\n\nif __name__ == \"__main__\":\n    import sys\n    ticker = sys.argv[1] if len(sys.argv) > 1 else \"SPY\"\n    z = get_liquidity(ticker)\n    pct = (z[\"max_pain\"] - z[\"price\"]) / z[\"price\"] * 100\n    print(f\"{ticker}: Price={z['price']:.2f} | Max Pain={z['max_pain']:.2f} ({pct:+.2f}%) | Expires: {z['expiry']}\")\n```\n\n### signal_generator.py\n```python\n#!/usr/bin/env python3\n\"\"\"Combined signal generator — all 5 inputs, unified output.\"\"\"\nimport subprocess, sys\n\ndef run_script(name, ticker):\n    try:\n        r = subprocess.run([\"python\", f\"scripts/{name}\", ticker], capture_output=True, text=True, timeout=30)\n        return r.stdout.strip()\n    except: return \"\"\n\ndef generate(ticker: str) -> dict:\n    whale   = run_script(\"whale_scanner.py\", ticker)\n    wave    = run_script(\"elliott_wave.py\", ticker)\n    bands   = run_script(\"bollinger_analyzer.py\", ticker)\n    trend   = run_script(\"trend_engine.py\", ticker)\n    liq     = run_script(\"liquidity_map.py\", ticker)\n    signals = {\"whale\": \"🟢\" in whale, \"wave3\": \"3\" in wave, \"squeeze\": \"SQUEEZE\" in bands}\n    score   = sum(signals.values())\n    conviction = \"HIGH\" if score >= 3 and signals[\"whale\"] else \\\n                 \"MEDIUM\" if score >= 2 and signals[\"whale\"] else \"NONE\"\n    return {\"ticker\": ticker, \"score\": score, \"conviction\": conviction, \"details\": locals()}\n\nif __name__ == \"__main__\":\n    ticker = sys.argv[1] if len(sys.argv) > 1 else \"AAPL\"\n    result = generate(ticker)\n    print(f\"{ticker}: {result['conviction']} ({result['score']}/5 signals)\")\n    print(f\"  Whale: {result['details']['whale']} | Wave3: {result['details']['wave3']} | Squeeze: {result['details']['squeeze']}\")\n```\n\n## Usage\n\nRun any script directly:\n```bash\npython scripts/whale_scanner.py SPY\npython scripts/elliott_wave.py NVDA\npython scripts/bollinger_analyzer.py TSLA\npython scripts/signal_generator.py --ticker AAPL\n```\n\nOr run all 5 inputs together:\n```bash\npython scripts/signal_generator.py --ticker NVDA\n```\n\n## Research Sources\n\n- Whale flow: FlowProof.io — \"sweeps > blocks > splits > single fills\"\n- Elliott Wave: elliottwave-forecast.com — 3 inviolable rules\n- Liquidity: StrikeWatch EA — 4-layer strike wall conviction scoring\n\nFile v1.0.8:_meta.json\n\n{\n  \"ownerId\": \"kn723dy43mmbqpy0cp62hwptm984gga5\",\n  \"slug\": \"options-trading-brain\",\n  \"version\": \"1.0.8\",\n  \"publishedAt\": 1777815753736\n}\n\nArchive v1.0.7: 2 files, 4306 bytes\n\nFiles: SKILL.md (10669b), _meta.json (140b)\n\nFile v1.0.7:SKILL.md\n\n---\nname: options-trading-brain\nversion: 1.0.7\ndescription: |\n  Professional-grade options trading signal generator. Monitors whale flow (Unusual \n  Whales), counts Elliott Waves, analyzes Bollinger Bands, multi-timeframe trend \n  alignment, and liquidity zones. Combines all 5 inputs into actionable trade signals.\n  Use when user asks for options signals, stock analysis, trading setups, or to check \n  a specific ticker. Fully autonomous — no API keys required for core analysis.\ncompatibility: Python 3.10+, yfinance, numpy, scipy. Optional: Unusual Whales subscription.\nmetadata:\n  author: ssyopro.zo.computer\n  category: finance\n  display-name: Options Trading Brain\n  tags: options, trading, signals, elliott-wave, whale-flow, bollinger, theta-gang\n---\n\n# Options Trading Brain\n\nProfessional options trading intelligence system combining 5 analysis dimensions into one unified signal.\n\n## The 5 Inputs (Signal Requires 3+ Aligned)\n\n### 1. Whale Flow (Unusual Whales)\n- Filter: $25K+ premium, sweep/block executions, ask-side fills\n- Hierarchy: sweeps > blocks > splits > single fills\n- Bullish: calls at ask + volume > OI; Bearish: puts at ask + volume > OI\n\n### 2. Elliott Wave\n- Wave 3 = strongest momentum entry\n- Wave 5 = exhaustion warning\n- Rules: Wave 2 can't retrace Wave 1; Wave 3 not shortest; Wave 4 can't overlap Wave 1\n\n### 3. Bollinger Bands\n- Squeeze (BB width < 2% of price) = volatile expansion imminent\n- Band thrust through upper/lower = strong momentum continuation\n- Position near bands = overbought/oversold reversal candidates\n\n### 4. Multi-Timeframe Trend\n- ADX > 25 = confirmed trend\n- MA alignment (price > MA20 > MA50) = uptrend confirmed\n- Weekly/Daily must align for high conviction\n\n### 5. Liquidity Zones\n- 4-layer strike walls: OI concentration + GEX + PCR + Max Pain proximity\n- Max Pain = where max options expire worthless (gravity level)\n- Support = cluster of put OI below price; Resistance = call OI above\n\n## Signal Hierarchy\n\n| Conviction | Requirement |\n|---|---|\n| **HIGH** | Whale + Wave 3 + (Trend OR Bollinger) aligned |\n| **MEDIUM** | Whale + 2 others aligned |\n| **NONE** | No whale signal = no trade |\n\n## Scripts (all embedded below)\n\n### whale_scanner.py\n```python\n#!/usr/bin/env python3\n\"\"\"Whale flow scanner — Unusual Whales inspired filters.\"\"\"\nimport yfinance as yf, numpy as np\n\nWHALE_THRESHOLD = 25_000  # $25K minimum\n\ndef get_price(ticker: str) -> float:\n    return yf.Ticker(ticker).info[\"regularMarketPrice\"]\n\ndef scan(ticker: str) -> dict:\n    price = get_price(ticker)\n    chains = yf.Ticker(ticker).option_chain()\n    \n    calls = chains.calls[chains.calls[\"volume\"] * chains.calls[\"lastPrice\"] * 100 >= WHALE_THRESHOLD]\n    puts  = chains.puts[chains.puts[\"volume\"] * chains.puts[\"lastPrice\"] * 100 >= WHALE_THRESHOLD]\n    \n    call_premium = (calls[\"volume\"] * calls[\"lastPrice\"] * 100).sum()\n    put_premium  = (puts[\"volume\"] * puts[\"lastPrice\"] * 100).sum()\n    \n    return {\n        \"ticker\": ticker, \"price\": price,\n        \"whale_calls\": len(calls), \"whale_puts\": len(puts),\n        \"call_premium\": call_premium, \"put_premium\": put_premium,\n        \"direction\": \"bullish\" if call_premium > put_premium * 1.2\n                    else \"bearish\" if put_premium > call_premium * 1.2 else \"neutral\"\n    }\n\nif __name__ == \"__main__\":\n    import sys\n    r = scan(sys.argv[1] if len(sys.argv) > 1 else \"SPY\")\n    print(f\"{r['ticker']}: {r['direction']} | Calls: {r['whale_calls']} | Puts: {r['whale_puts']} | \"\n          f\"Call$: ${r['call_premium']:,.0f} | Put$: ${r['put_premium']:,.0f}\")\n```\n\n### elliott_wave.py\n```python\n#!/usr/bin/env python3\n\"\"\"Elliott Wave counter — validates 3 rules, identifies impulse waves.\"\"\"\nimport yfinance as yf, numpy as np\n\ndef count_waves(prices: list) -> dict:\n    highs, lows = [], []\n    for i in range(1, len(prices)-1):\n        if prices[i] > prices[i-1] and prices[i] > prices[i+1]: highs.append(i)\n        if prices[i] < prices[i-1] and prices[i] < prices[i+1]: lows.append(i)\n    \n    if len(highs) < 2: return {\"wave_count\": 0, \"wave_number\": 0, \"wave_type\": \"unknown\"}\n    \n    wave3_strong = highs[1] - highs[0] > (highs[0] - lows[0]) if len(highs) > 1 else False\n    return {\n        \"wave_count\": len(highs),\n        \"wave_number\": min(5, len(highs)),\n        \"wave_type\": \"impulse_wave_3\" if wave3_strong else \"impulse_wave_1_or_5\"\n    }\n\ndef fib_levels(high: float, low: float) -> dict:\n    return {\n        \"fib_236\": low + (high - low) * 0.236,\n        \"fib_382\": low + (high - low) * 0.382,\n        \"fib_500\": low + (high - low) * 0.500,\n        \"fib_618\": low + (high - low) * 0.618,\n        \"fib_786\": low + (high - low) * 0.786,\n    }\n\ndef validate_impulse(p1, p2, p3, p4, p5) -> bool:\n    return (p2 < p1 and p3 > max(p1,p2) and p4 < p3 and p4 > p1 and p5 < p4)\n\nif __name__ == \"__main__\":\n    import sys\n    ticker = sys.argv[1] if len(sys.argv) > 1 else \"SPY\"\n    data = yf.download(ticker, period=\"3mo\", auto_redirect=True)[\"Close\"].dropna()\n    waves = count_waves(data.values.tolist())\n    print(f\"{ticker}: Wave {waves['wave_number']} ({waves['wave_type']})\")\n```\n\n### bollinger_analyzer.py\n```python\n#!/usr/bin/env python3\n\"\"\"Bollinger Bands analyzer — squeeze, thrust, regime detection.\"\"\"\nimport yfinance as yf, numpy as np\n\ndef get_bands(prices: np.ndarray, window=20):\n    sma = np.convolve(prices, np.ones(window)/window, mode='valid')\n    std = np.array([np.std(prices[i:i+window]) for i in range(len(prices)-window+1)])\n    upper = sma + 2*std; lower = sma - 2*std\n    return {\"sma\": sma, \"upper\": upper, \"lower\": lower, \"width\": upper-lower}\n\ndef detect_squeeze(bands: dict, threshold_pct=0.02) -> bool:\n    latest_width_pct = bands[\"width\"][-1] / bands[\"sma\"][-1]\n    return latest_width_pct < threshold_pct\n\ndef regime(bands: dict, price: float) -> str:\n    bbp = (price - bands[\"lower\"][-1]) / (bands[\"upper\"][-1] - bands[\"lower\"][-1])\n    if bbp > 0.90: return \"upper_thrust_bullish\"\n    if bbp < 0.10: return \"lower_thrust_bearish\"\n    if bbp > 0.60: return \"bullish\"\n    if bbp < 0.40: return \"bearish\"\n    return \"neutral\"\n\nif __name__ == \"__main__\":\n    import sys\n    ticker = sys.argv[1] if len(sys.argv) > 1 else \"SPY\"\n    data = yf.download(ticker, period=\"3mo\", auto_redirect=True)[\"Close\"].dropna().values\n    bands = get_bands(data)\n    sqz = detect_squeeze(bands)\n    reg = regime(bands, data[-1])\n    pos = (data[-1] - bands[\"lower\"][-1]) / (bands[\"upper\"][-1] - bands[\"lower\"][-1])\n    print(f\"{ticker}: {'SQUEEZE' if sqz else 'Normal'} | Regime: {reg} | BBPosition: {pos:.1%}\")\n```\n\n### trend_engine.py\n```python\n#!/usr/bin/env python3\n\"\"\"Multi-timeframe trend engine — ADX + MA alignment.\"\"\"\nimport yfinance as yf, numpy as np\n\ndef adx(high, low, close, period=14):\n    plus_dm = np.maximum(high[1:] - high[:-1], 0)\n    minus_dm = np.maximum(low[:-1] - low[1:], 0)\n    tr = high[1:] - low[1:]; tr = np.maximum(tr, np.abs(close[1:] - close[:-1]))\n    plus_di = 100 * np.mean(plus_dm[-period:]) / (np.mean(tr[-period:]) + 1e-9)\n    minus_di = 100 * np.mean(minus_dm[-period:]) / (np.mean(tr[-period:]) + 1e-9)\n    return plus_di / (plus_di + minus_di + 1e-9) * 100\n\ndef ma_alignment(prices, ma20, ma50):\n    return \"bullish\" if prices[-1] > ma20[-1] > ma50[-1] else \\\n           \"bearish\" if prices[-1] < ma20[-1] < ma50[-1] else \"mixed\"\n\nif __name__ == \"__main__\":\n    import sys\n    ticker = sys.argv[1] if len(sys.argv) > 1 else \"SPY\"\n    for tf in [\"1d\",\"1wk\",\"1mo\"]:\n        try:\n            d = yf.download(ticker, period=\"3mo\", interval=tf, auto_redirect=True)\n            h,l,c = d[\"High\"].values, d[\"Low\"].values, d[\"Close\"].values\n            a = adx(h,l,c)\n            ma20 = np.convolve(c, np.ones(20)/20, mode='valid')\n            ma50 = np.convolve(c, np.ones(50)/50, mode='valid')\n            al = ma_alignment(c, ma20, ma50)\n            print(f\"{tf.upper()}: ADX={a:.1f} | MA={al}\")\n        except: pass\n```\n\n### liquidity_map.py\n```python\n#!/usr/bin/env python3\n\"\"\"Liquidity zones — max pain, strike walls, support/resistance.\"\"\"\nimport yfinance as yf\n\ndef get_liquidity(ticker: str) -> dict:\n    t = yf.Ticker(ticker)\n    price = t.info[\"regularMarketPrice\"]\n    try:\n        chain = t.option_chain(tExpiry := t.options[0])\n        strikes = sorted(chain.calls[\"strike\"].values)\n        max_pain = strikes[np.argmin(np.abs(strikes - price))]\n        return {\"max_pain\": max_pain, \"price\": price, \"expiry\": tExpiry}\n    except: return {\"max_pain\": price, \"price\": price, \"expiry\": \"unknown\"}\n\nif __name__ == \"__main__\":\n    import sys\n    ticker = sys.argv[1] if len(sys.argv) > 1 else \"SPY\"\n    z = get_liquidity(ticker)\n    pct = (z[\"max_pain\"] - z[\"price\"]) / z[\"price\"] * 100\n    print(f\"{ticker}: Price={z['price']:.2f} | Max Pain={z['max_pain']:.2f} ({pct:+.2f}%) | Expires: {z['expiry']}\")\n```\n\n### signal_generator.py\n```python\n#!/usr/bin/env python3\n\"\"\"Combined signal generator — all 5 inputs, unified output.\"\"\"\nimport subprocess, sys\n\ndef run_script(name, ticker):\n    try:\n        r = subprocess.run([\"python\", f\"scripts/{name}\", ticker], capture_output=True, text=True, timeout=30)\n        return r.stdout.strip()\n    except: return \"\"\n\ndef generate(ticker: str) -> dict:\n    whale   = run_script(\"whale_scanner.py\", ticker)\n    wave    = run_script(\"elliott_wave.py\", ticker)\n    bands   = run_script(\"bollinger_analyzer.py\", ticker)\n    trend   = run_script(\"trend_engine.py\", ticker)\n    liq     = run_script(\"liquidity_map.py\", ticker)\n    signals = {\"whale\": \"🟢\" in whale, \"wave3\": \"3\" in wave, \"squeeze\": \"SQUEEZE\" in bands}\n    score   = sum(signals.values())\n    conviction = \"HIGH\" if score >= 3 and signals[\"whale\"] else \\\n                 \"MEDIUM\" if score >= 2 and signals[\"whale\"] else \"NONE\"\n    return {\"ticker\": ticker, \"score\": score, \"conviction\": conviction, \"details\": locals()}\n\nif __name__ == \"__main__\":\n    ticker = sys.argv[1] if len(sys.argv) > 1 else \"AAPL\"\n    result = generate(ticker)\n    print(f\"{ticker}: {result['conviction']} ({result['score']}/5 signals)\")\n    print(f\"  Whale: {result['details']['whale']} | Wave3: {result['details']['wave3']} | Squeeze: {result['details']['squeeze']}\")\n```\n\n## Usage\n\nRun any script directly:\n```bash\npython scripts/whale_scanner.py SPY\npython scripts/elliott_wave.py NVDA\npython scripts/bollinger_analyzer.py TSLA\npython scripts/signal_generator.py --ticker AAPL\n```\n\nOr run all 5 inputs together:\n```bash\npython scripts/signal_generator.py --ticker NVDA\n```\n\n## Research Sources\n\n- Whale flow: FlowProof.io — \"sweeps > blocks > splits > single fills\"\n- Elliott Wave: elliottwave-forecast.com — 3 inviolable rules\n- Liquidity: StrikeWatch EA — 4-layer strike wall conviction scoring\n\nFile v1.0.7:_meta.json\n\n{\n  \"ownerId\": \"kn723dy43mmbqpy0cp62hwptm984gga5\",\n  \"slug\": \"options-trading-brain\",\n  \"version\": \"1.0.7\",\n  \"publishedAt\": 1777815104269\n}","readmeExcerpt":"Skill: Options Trading Brain Owner: ssidharhubble Summary: Professional options trading intelligence system. Monitors whale flow (Unusual Whales), counts Elliott Waves, analyzes Bollinger Bands, multi-timeframe trend... Tags: latest:1.0.16 Version history: v1.0.16 | 2026-06-22T14:04:07.934Z | auto - Removed the skill-card.md file to reduce duplication and simplify documentation. - Updated SKILL.md; no changes to code","codeSnippets":[],"executableExamples":[{"language":"python","snippet":"#!/usr/bin/env python3\n\"\"\"Whale flow scanner — Unusual Whales inspired filters.\"\"\"\nimport yfinance as yf, numpy as np\n\nWHALE_THRESHOLD = 25_000  # $25K minimum\n\ndef get_price(ticker: str) -> float:\n    return yf.Ticker(ticker).info[\"regularMarketPrice\"]\n\ndef scan(ticker: str) -> dict:\n    price = get_price(ticker)\n    chains = yf.Ticker(ticker).option_chain()\n    \n    calls = chains.calls[chains.calls[\"volume\"] * chains.calls[\"lastPrice\"] * 100 >= WHALE_THRESHOLD]\n    puts  = chains.puts[chains.puts[\"volume\"] * chains.puts[\"lastPrice\"] * 100 >= WHALE_THRESHOLD]\n    \n    call_premium = (calls[\"volume\"] * calls[\"lastPrice\"] * 100).sum()\n    put_premium  = (puts[\"volume\"] * puts[\"lastPrice\"] * 100).sum()\n    \n    return {\n        \"ticker\": ticker, \"price\": price,\n        \"whale_calls\": len(calls), \"whale_puts\": len(puts),\n        \"call_premium\": call_premium, \"put_premium\": put_premium,\n        \"direction\": \"bullish\" if call_premium > put_premium * 1.2\n                    else \"bearish\" if put_premium > call_premium * 1.2 else \"neutral\"\n    }\n\nif __name__ == \"__main__\":\n    import sys\n    r = scan(sys.argv[1] if len(sys.argv) > 1 else \"SPY\")\n    print(f\"{r['ticker']}: {r['direction']} | Calls: {r['whale_calls']} | Puts: {r['whale_puts']} | \"\n          f\"Call$: ${r['call_premium']:,.0f} | Put$: ${r['put_premium']:,.0f}\")"},{"language":"python","snippet":"#!/usr/bin/env python3\n\"\"\"Elliott Wave counter — validates 3 rules, identifies impulse waves.\"\"\"\nimport yfinance as yf, numpy as np\n\ndef count_waves(prices: list) -> dict:\n    highs, lows = [], []\n    for i in range(1, len(prices)-1):\n        if prices[i] > prices[i-1] and prices[i] > prices[i+1]: highs.append(i)\n        if prices[i] < prices[i-1] and prices[i] < prices[i+1]: lows.append(i)\n    \n    if len(highs) < 2: return {\"wave_count\": 0, \"wave_number\": 0, \"wave_type\": \"unknown\"}\n    \n    wave3_strong = highs[1] - highs[0] > (highs[0] - lows[0]) if len(highs) > 1 else False\n    return {\n        \"wave_count\": len(highs),\n        \"wave_number\": min(5, len(highs)),\n        \"wave_type\": \"impulse_wave_3\" if wave3_strong else \"impulse_wave_1_or_5\"\n    }\n\ndef fib_levels(high: float, low: float) -> dict:\n    return {\n        \"fib_236\": low + (high - low) * 0.236,\n        \"fib_382\": low + (high - low) * 0.382,\n        \"fib_500\": low + (high - low) * 0.500,\n        \"fib_618\": low + (high - low) * 0.618,\n        \"fib_786\": low + (high - low) * 0.786,\n    }\n\ndef validate_impulse(p1, p2, p3, p4, p5) -> bool:\n    return (p2 < p1 and p3 > max(p1,p2) and p4 < p3 and p4 > p1 and p5 < p4)\n\nif __name__ == \"__main__\":\n    import sys\n    ticker = sys.argv[1] if len(sys.argv) > 1 else \"SPY\"\n    data = yf.download(ticker, period=\"3mo\", auto_redirect=True)[\"Close\"].dropna()\n    waves = count_waves(data.values.tolist())\n    print(f\"{ticker}: Wave {waves['wave_number']} ({waves['wave_type']})\")"},{"language":"python","snippet":"#!/usr/bin/env python3\n\"\"\"Bollinger Bands analyzer — squeeze, thrust, regime detection.\"\"\"\nimport yfinance as yf, numpy as np\n\ndef get_bands(prices: np.ndarray, window=20):\n    sma = np.convolve(prices, np.ones(window)/window, mode='valid')\n    std = np.array([np.std(prices[i:i+window]) for i in range(len(prices)-window+1)])\n    upper = sma + 2*std; lower = sma - 2*std\n    return {\"sma\": sma, \"upper\": upper, \"lower\": lower, \"width\": upper-lower}\n\ndef detect_squeeze(bands: dict, threshold_pct=0.02) -> bool:\n    latest_width_pct = bands[\"width\"][-1] / bands[\"sma\"][-1]\n    return latest_width_pct < threshold_pct\n\ndef regime(bands: dict, price: float) -> str:\n    bbp = (price - bands[\"lower\"][-1]) / (bands[\"upper\"][-1] - bands[\"lower\"][-1])\n    if bbp > 0.90: return \"upper_thrust_bullish\"\n    if bbp < 0.10: return \"lower_thrust_bearish\"\n    if bbp > 0.60: return \"bullish\"\n    if bbp < 0.40: return \"bearish\"\n    return \"neutral\"\n\nif __name__ == \"__main__\":\n    import sys\n    ticker = sys.argv[1] if len(sys.argv) > 1 else \"SPY\"\n    data = yf.download(ticker, period=\"3mo\", auto_redirect=True)[\"Close\"].dropna().values\n    bands = get_bands(data)\n    sqz = detect_squeeze(bands)\n    reg = regime(bands, data[-1])\n    pos = (data[-1] - bands[\"lower\"][-1]) / (bands[\"upper\"][-1] - bands[\"lower\"][-1])\n    print(f\"{ticker}: {'SQUEEZE' if sqz else 'Normal'} | Regime: {reg} | BBPosition: {pos:.1%}\")"},{"language":"python","snippet":"#!/usr/bin/env python3\n\"\"\"Multi-timeframe trend engine — ADX + MA alignment.\"\"\"\nimport yfinance as yf, numpy as np\n\ndef adx(high, low, close, period=14):\n    plus_dm = np.maximum(high[1:] - high[:-1], 0)\n    minus_dm = np.maximum(low[:-1] - low[1:], 0)\n    tr = high[1:] - low[1:]; tr = np.maximum(tr, np.abs(close[1:] - close[:-1]))\n    plus_di = 100 * np.mean(plus_dm[-period:]) / (np.mean(tr[-period:]) + 1e-9)\n    minus_di = 100 * np.mean(minus_dm[-period:]) / (np.mean(tr[-period:]) + 1e-9)\n    return plus_di / (plus_di + minus_di + 1e-9) * 100\n\ndef ma_alignment(prices, ma20, ma50):\n    return \"bullish\" if prices[-1] > ma20[-1] > ma50[-1] else \\\n           \"bearish\" if prices[-1] < ma20[-1] < ma50[-1] else \"mixed\"\n\nif __name__ == \"__main__\":\n    import sys\n    ticker = sys.argv[1] if len(sys.argv) > 1 else \"SPY\"\n    for tf in [\"1d\",\"1wk\",\"1mo\"]:\n        try:\n            d = yf.download(ticker, period=\"3mo\", interval=tf, auto_redirect=True)\n            h,l,c = d[\"High\"].values, d[\"Low\"].values, d[\"Close\"].values\n            a = adx(h,l,c)\n            ma20 = np.convolve(c, np.ones(20)/20, mode='valid')\n            ma50 = np.convolve(c, np.ones(50)/50, mode='valid')\n            al = ma_alignment(c, ma20, ma50)\n            print(f\"{tf.upper()}: ADX={a:.1f} | MA={al}\")\n        except: pass"},{"language":"python","snippet":"#!/usr/bin/env python3\n\"\"\"Liquidity zones — max pain, strike walls, support/resistance.\"\"\"\nimport yfinance as yf\n\ndef get_liquidity(ticker: str) -> dict:\n    t = yf.Ticker(ticker)\n    price = t.info[\"regularMarketPrice\"]\n    try:\n        chain = t.option_chain(tExpiry := t.options[0])\n        strikes = sorted(chain.calls[\"strike\"].values)\n        max_pain = strikes[np.argmin(np.abs(strikes - price))]\n        return {\"max_pain\": max_pain, \"price\": price, \"expiry\": tExpiry}\n    except: return {\"max_pain\": price, \"price\": price, \"expiry\": \"unknown\"}\n\nif __name__ == \"__main__\":\n    import sys\n    ticker = sys.argv[1] if len(sys.argv) > 1 else \"SPY\"\n    z = get_liquidity(ticker)\n    pct = (z[\"max_pain\"] - z[\"price\"]) / z[\"price\"] * 100\n    print(f\"{ticker}: Price={z['price']:.2f} | Max Pain={z['max_pain']:.2f} ({pct:+.2f}%) | Expires: {z['expiry']}\")"},{"language":"python","snippet":"#!/usr/bin/env python3\n\"\"\"Combined signal generator — all 5 inputs, unified output.\"\"\"\nimport subprocess, sys\n\ndef run_script(name, ticker):\n    try:\n        r = subprocess.run([\"python\", f\"scripts/{name}\", ticker], capture_output=True, text=True, timeout=30)\n        return r.stdout.strip()\n    except: return \"\"\n\ndef generate(ticker: str) -> dict:\n    whale   = run_script(\"whale_scanner.py\", ticker)\n    wave    = run_script(\"elliott_wave.py\", ticker)\n    bands   = run_script(\"bollinger_analyzer.py\", ticker)\n    trend   = run_script(\"trend_engine.py\", ticker)\n    liq     = run_script(\"liquidity_map.py\", ticker)\n    signals = {\"whale\": \"🟢\" in whale, \"wave3\": \"3\" in wave, \"squeeze\": \"SQUEEZE\" in bands}\n    score   = sum(signals.values())\n    conviction = \"HIGH\" if score >= 3 and signals[\"whale\"] else \\\n                 \"MEDIUM\" if score >= 2 and signals[\"whale\"] else \"NONE\"\n    return {\"ticker\": ticker, \"score\": score, \"conviction\": conviction, \"details\": locals()}\n\nif __name__ == \"__main__\":\n    ticker = sys.argv[1] if len(sys.argv) > 1 else \"AAPL\"\n    result = generate(ticker)\n    print(f\"{ticker}: {result['conviction']} ({result['score']}/5 signals)\")\n    print(f\"  Whale: {result['details']['whale']} | Wave3: {result['details']['wave3']} | Squeeze: {result['details']['squeeze']}\")"}],"parameters":null,"dependencies":[],"permissions":[],"extractedFiles":[{"path":"SKILL.md","content":"---\nname: options-trading-brain\nversion: 1.0.16\ndescription: |\n  Professional-grade options trading signal generator. Monitors whale flow (Unusual \n  Whales), counts Elliott Waves, analyzes Bollinger Bands, multi-timeframe trend \n  alignment, and liquidity zones. Combines all 5 inputs into actionable trade signals.\n  Use when user asks for options signals, stock analysis, trading setups, or to check \n  a specific ticker. Fully autonomous — no API keys required for core analysis.\ncompatibility: Python 3.10+, yfinance, numpy, scipy. Optional: Unusual Whales subscription.\nmetadata:\n  author: ssyopro.zo.computer\n  category: finance\n  display-name: Options Trading Brain\n  tags: options, trading, signals, elliott-wave, whale-flow, bollinger, theta-gang\n---\n\n# Options Trading Brain\n\nProfessional options trading intelligence system combining 5 analysis dimensions into one unified signal.\n\n## The 5 Inputs (Signal Requires 3+ Aligned)\n\n### 1. Whale Flow (Unusual Whales)\n- Filter: $25K+ premium, sweep/block executions, ask-side fills\n- Hierarchy: sweeps > blocks > splits > single fills\n- Bullish: calls at ask + volume > OI; Bearish: puts at ask + volume > OI\n\n### 2. Elliott Wave\n- Wave 3 = strongest momentum entry\n- Wave 5 = exhaustion warning\n- Rules: Wave 2 can't retrace Wave 1; Wave 3 not shortest; Wave 4 can't overlap Wave 1\n\n### 3. Bollinger Bands\n- Squeeze (BB width < 2% of price) = volatile expansion imminent\n- Band thrust through upper/lower = strong momentum continuation\n- Position near bands = overbought/oversold reversal candidates\n\n### 4. Multi-Timeframe Trend\n- ADX > 25 = confirmed trend\n- MA alignment (price > MA20 > MA50) = uptrend confirmed\n- Weekly/Daily must align for high conviction\n\n### 5. Liquidity Zones\n- 4-layer strike walls: OI concentration + GEX + PCR + Max Pain proximity\n- Max Pain = where max options expire worthless (gravity level)\n- Support = cluster of put OI below price; Resistance = call OI above\n\n## Signal Hierarchy\n\n| Conviction | Requirement |\n|---|---|\n| **HIGH** | Whale + Wave 3 + (Trend OR Bollinger) aligned |\n| **MEDIUM** | Whale + 2 others aligned |\n| **NONE** | No whale signal = no trade |\n\n## Scripts (all embedded below)\n\n### whale_scanner.py\n```python\n#!/usr/bin/env python3\n\"\"\"Whale flow scanner — Unusual Whales inspired filters.\"\"\"\nimport yfinance as yf, numpy as np\n\nWHALE_THRESHOLD = 25_000  # $25K minimum\n\ndef get_price(ticker: str) -> float:\n    return yf.Ticker(ticker).info[\"regularMarketPrice\"]\n\ndef scan(ticker: str) -> dict:\n    price = get_price(ticker)\n    chains = yf.Ticker(ticker).option_chain()\n    \n    calls = chains.calls[chains.calls[\"volume\"] * chains.calls[\"lastPrice\"] * 100 >= WHALE_THRESHOLD]\n    puts  = chains.puts[chains.puts[\"volume\"] * chains.puts[\"lastPrice\"] * 100 >= WHALE_THRESHOLD]\n    \n    call_premium = (calls[\"volume\"] * calls[\"lastPrice\"] * 100).sum()\n    put_premium  = (puts[\"volume\"] * puts[\"lastPrice\"] * 100).sum()\n    \n    return {\n        \"ticker\": ticker, \"price\": price,\n      "},{"path":"_meta.json","content":"{\n  \"ownerId\": \"kn723dy43mmbqpy0cp62hwptm984gga5\",\n  \"slug\": \"options-trading-brain\",\n  \"version\": \"1.0.16\",\n  \"publishedAt\": 1782137047934\n}"},{"path":"skill-card.md","content":"## Description:\n\nOptions Trading Brain is an options trading signal generator that combines whale flow, Elliott Wave, Bollinger Band, multi-timeframe trend, and liquidity-zone analysis into ticker-level trading signals.\n\nThis skill is ready for commercial/non-commercial use.\n\n## Publisher:\n\n[ssidharhubble](https://clawhub.ai/user/ssidharhubble)\n\n### License/Terms of Use:\n\nMIT-0\n\n## Use Case:\n\nExternal traders and agent users use this skill to request options signals, stock analysis, trading setups, or ticker checks. Outputs should be treated as informational analysis requiring independent human review before any financial decision.\n\n### Deployment Geography for Use:\n\nGlobal\n\n## Known Risks and Mitigations:\n\nRisk: The skill gives broad, actionable options-trading signals while overstating how its analysis works.\n\nMitigation: Treat outputs as informational analysis only, and require independent human review before any trade or portfolio decision.\n\nRisk: The skill's trading outputs are described by security evidence as overconfident and incompletely implemented.\n\nMitigation: Validate market data, assumptions, and risk controls with trusted tools before relying on any generated setup.\n\n## Reference(s):\n\n\n## Skill Output:\n\n**Output Type(s):** [text, markdown, code, shell commands, guidance]\n\n**Output Format:** [Markdown with embedded Python and shell command examples]\n\n**Output Parameters:** [1D]\n\n**Other Properties Related to Output:** [Trading outputs are generated from the skill's documented analysis dimensions and may depend on available market data.]\n\n## Skill Version(s):\n\n1.0.16 (source: frontmatter and server release evidence)\n\n## Ethical Considerations:\n\nUsers should evaluate whether this skill is appropriate for their environment, review any generated or modified files before relying on them, and apply their organization's safety, security, and compliance requirements before deployment."}],"languages":[],"docsSourceLabel":"CLAWHUB","editorialOverview":"Professional options trading intelligence system. Monitors whale flow (Unusual Whales), counts Elliott Waves, analyzes Bollinger Bands, multi-timeframe trend... Skill: Options Trading Brain Owner: ssidharhubble Summary: Professional options trading intelligence system. Monitors whale flow (Unusual Whales), counts Elliott Waves, analyzes Bollinger Bands, multi-timeframe trend... Tags: latest:1.0.16 Version history: v1.0.16 | 2026-06-22T14:04:07.934Z | auto - Removed the skill-card.md file to reduce duplication and simplify documentation. - Updated SKILL.md; no changes to code","editorialQuality":{"score":100,"threshold":65,"status":"ready","wordCount":1182,"uniquenessScore":51,"reasons":[]}},"media":{"evidence":{"source":"no-media","verified":false,"confidence":"low","updatedAt":"2026-10-10T01:35:54.291Z","emptyReason":"No screenshots, media assets, or demo links are available."},"primaryImageUrl":null,"mediaAssetCount":0,"assets":[],"demoUrl":null},"ownerResources":{"evidence":{"source":"unclaimed","verified":false,"confidence":"low","updatedAt":"2026-10-10T01:35:54.291Z","emptyReason":"This page has not been claimed by the agent owner."},"hasCustomPage":false,"customPageUpdatedAt":null,"customLinks":[],"structuredLinks":{"docsUrl":null,"demoUrl":null,"supportUrl":null,"pricingUrl":null,"statusUrl":null},"customPage":null},"relatedAgents":{"evidence":{"source":"protocol-neighbors","verified":false,"confidence":"medium","updatedAt":"2026-10-10T05:40:19.043Z","emptyReason":null},"items":[{"id":"8ebccd8e-3863-4187-8355-c3f14e1f9edf","entityType":"agent","canonicalPath":"/agent/iofficeai-aionui","slug":"iofficeai-aionui","name":"AionUi","description":"Free, local, open-source 24/7 Cowork app and OpenClaw for Gemini CLI, Claude Code, Codex, OpenCode, Qwen Code, Goose CLI, Auggie, and more | 🌟 Star if you like it!","url":"https://github.com/iOfficeAI/AionUi","homepage":"https://www.aionui.com","source":"GITHUB_REPOS","protocols":["MCP","OPENCLAW"],"capabilities":[],"safetyScore":100,"overallRank":70,"updatedAt":"2026-10-09T19:11:12.944Z","createdAt":"2026-02-25T03:38:16.584Z","downloads":null},{"id":"b917f68a-ebff-438e-84f8-3f4b2494c0bc","entityType":"agent","canonicalPath":"/agent/activepieces-activepieces","slug":"activepieces-activepieces","name":"activepieces","description":"AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents","url":"https://github.com/activepieces/activepieces","homepage":"https://www.activepieces.com","source":"GITHUB_REPOS","protocols":["OPENCLAW"],"capabilities":[],"safetyScore":100,"overallRank":70,"updatedAt":"2026-04-15T02:22:12.426Z","createdAt":"2026-02-25T03:38:12.412Z","downloads":null},{"id":"5cb26759-3a39-483f-94cf-276a98c13bb8","entityType":"agent","canonicalPath":"/agent/cherryhq-cherry-studio","slug":"cherryhq-cherry-studio","name":"cherry-studio","description":"AI productivity studio with smart chat, autonomous agents, and 300+ assistants. Unified access to frontier LLMs","url":"https://github.com/CherryHQ/cherry-studio","homepage":"https://cherry-ai.com","source":"GITHUB_REPOS","protocols":["MCP","OPENCLAW"],"capabilities":[],"safetyScore":100,"overallRank":70,"updatedAt":"2026-04-11T14:38:40.986Z","createdAt":"2026-02-25T03:38:19.379Z","downloads":null},{"id":"6f6582d0-5d76-4f0f-b81d-86520247950b","entityType":"agent","canonicalPath":"/agent/copilotkit-copilotkit","slug":"copilotkit-copilotkit","name":"CopilotKit","description":"The Frontend for Agents & Generative UI. React + Angular","url":"https://github.com/CopilotKit/CopilotKit","homepage":"https://docs.copilotkit.ai","source":"GITHUB_REPOS","protocols":["OPENCLAW"],"capabilities":[],"safetyScore":100,"overallRank":70,"updatedAt":"2026-03-25T09:50:57.846Z","createdAt":"2026-02-25T03:39:14.617Z","downloads":null}],"links":{"hub":"/agent","source":"/agent/source/clawhub","protocols":[{"label":"OpenClaw","href":"/agent/protocol/openclew"}]}}}