Viraltest OpenEnv: deploy to HF Space

Single-commit history without PNG binaries (Hub pre-receive rejects them).

Made-with: Cursor

.agents/skills/openenv-cli/SKILL.md

@@ -0,0 +1,18 @@
+---
+name: openenv-cli
+description: "OpenEnv CLI (`openenv`) for scaffolding, validating, building, and pushing OpenEnv environments."
+---
+
+Install: `pip install openenv-core`
+
+The OpenEnv CLI command `openenv` is available.
+Use `openenv --help` to view available commands.
+
+Generated with `openenv-core v0.2.3`. Run `openenv skills add --force` to regenerate.
+
+## Tips
+
+- Start with `openenv init <env_name>` to scaffold a new environment
+- Validate projects with `openenv validate`
+- Build and deploy with `openenv build` and `openenv push`
+- Use `openenv <command> --help` for command-specific options

.codex/skills/openenv-cli

@@ -0,0 +1 @@
+../../.agents/skills/openenv-cli

.dockerignore

@@ -0,0 +1,15 @@
+.venv
+.git
+.gitignore
+.env
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+*.pyw
+*.pyz
+*.pywz
+*.pyzw
+*.pyzwz
+
+

.env.example

@@ -0,0 +1,6 @@
+# Copy to .env and set values ( .env is gitignored )
+HF_TOKEN=hf_your_token_here
+
+# Optional overrides for Step 5 / inference (defaults match inference.py):
+# MODEL_NAME=gemma-4-E4B-it-IQ4_XS
+# API_BASE_URL=https://router.huggingface.co/v1

.gitattributes

@@ -0,0 +1 @@
+*.png filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,13 @@
+# Local secrets (HF_TOKEN, etc.) — never commit
+.env
+.env.*
+!.env.example
+
+# Generated visualization outputs (regenerate: python visualize_optimal.py)
+# Hugging Face Spaces rejects plain-git binary files; keep charts local or use Git LFS elsewhere.
+*.png
+
+__pycache__/
+*.py[cod]
+*.egg-info/
+.mplconfig/

DESIGN.md

@@ -0,0 +1,792 @@
+# Viraltest — RL-Based Creator Optimization Agent
+
+## Problem
+
+Content creators on platforms like Meta (Instagram, Facebook) face:
+
+- Unpredictable engagement
+- No clear posting strategy
+- Pressure to post frequently
+- Burnout due to over-posting
+- Drop in content quality over time
+
+Existing tools show analytics (likes, reach) and past performance but don't **actively guide creators on optimal behavior over time**.
+
+**Core problem**: No intelligent system continuously learns and adapts a creator's posting strategy to balance growth and burnout.
+
+## Solution
+
+An RL agent that learns **when to post**, **what type to post**, **which tags to use**, and **how to differentiate from competitors** — maximizing engagement while minimizing burnout over a weekly cycle.
+
+---
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────────────────────────────┐
+│  INFERENCE SCRIPT (inference.py)                                    │
+│                                                                     │
+│  env = ViraltestEnv(base_url="https://...")                        │
+│  result = env.reset(task="weekly_strategic")  ← picks task         │
+│  result = env.step(action)                    ← type-safe!         │
+│                                                                     │
+│  ┌───────────────────────────────────────────────────────────┐     │
+│  │  LLM Agent (OpenAI Client)                                │     │
+│  │  Reads: observation → Decides: action                     │     │
+│  │  Model: Qwen/Qwen2.5-72B-Instruct                        │     │
+│  └───────────────────────────────────────────────────────────┘     │
+│                                                                     │
+│  Logs: [START] [STEP] [END] to stdout                              │
+└──────────────────────────┬──────────────────────────────────────────┘
+                           │
+                    WebSocket /ws
+                           │
+                           ▼
+┌─────────────────────────────────────────────────────────────────────┐
+│  DOCKER CONTAINER (HF Space)                                        │
+│                                                                     │
+│  ┌───────────────────────────────────────────────────────────┐     │
+│  │  FastAPI Server (server/app.py)  — port 8000              │     │
+│  │                                                           │     │
+│  │  ┌─────────────────────────────────────────────────────┐ │     │
+│  │  │  ViraltestEnvironment                               │ │     │
+│  │  │                                                     │ │     │
+│  │  │  ┌─────────────────┐   ┌──────────────────────┐   │ │     │
+│  │  │  │  reset(task)    │   │  step(action)         │   │ │     │
+│  │  │  │  • Set task     │   │  1. Validate action   │   │ │     │
+│  │  │  │  • Init state   │   │  2. Apply effects     │   │ │     │
+│  │  │  │  • energy=1.0   │   │  3. Calc engagement   │   │ │     │
+│  │  │  │  • followers=N  │   │  4. Tag analytics     │   │ │     │
+│  │  │  │  • Init tags    │   │  5. Competitor check   │   │ │     │
+│  │  │  │  • Init rivals  │   │  6. Update followers  │   │ │     │
+│  │  │  │  • Return obs   │   │  7. Calc reward       │   │ │     │
+│  │  │  └─────────────────┘   │  8. Check done        │   │ │     │
+│  │  │                        │  9. Return obs        │   │ │     │
+│  │  │  ┌─────────────────┐   └──────────────────────┘   │ │     │
+│  │  │  │  state()        │                               │ │     │
+│  │  │  │  • episode_id   │   ┌──────────────────────┐   │ │     │
+│  │  │  │  • step_count   │   │  Grader (per task)    │   │ │     │
+│  │  │  │  • task_name    │   │  • weekly_engage      │   │ │     │
+│  │  │  └─────────────────┘   │  • weekly_strategic   │   │ │     │
+│  │  │                        │  • weekly_competitive  │   │ │     │
+│  │  │                        └──────────────────────┘   │ │     │
+│  │  │                                                     │ │     │
+│  │  │  Simulation Engine (research-backed params)         │ │     │
+│  │  │  • Hour multipliers (Buffer 9.6M study)             │ │     │
+│  │  │  • Content rates (SocialInsider 2025)               │ │     │
+│  │  │  • Burnout curve (Sozee 2026 creator study)         │ │     │
+│  │  │  • Tag engagement model                             │ │     │
+│  │  │  • Competitor simulation                            │ │     │
+│  │  └─────────────────────────────────────────────────────┘ │     │
+│  └───────────────────────────────────────────────────────────┘     │
+│                                                                     │
+│  Isolated • Reproducible • Secure • Deterministic (seeded RNG)     │
+└─────────────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## Pydantic Models
+
+```
+models.py
+├── ViraltestAction(Action)
+│   ├── action_type: Literal["post", "rest", "create_content"]
+│   ├── content_type: Optional[Literal["reel", "story", "carousel", "text_post"]]
+│   ├── topic: Optional[str]
+│   └── tags: Optional[list[str]]         ← max 5 tags per post
+│
+└── ViraltestObservation(Observation)
+    ├── current_hour: int                  (0–23)
+    ├── day_of_week: int                   (0–6)
+    ├── days_elapsed: int
+    ├── creator_energy: float              (0.0–1.0, burnout meter)
+    ├── follower_count: int
+    ├── engagement_rate: float             (rolling avg last 10 posts)
+    ├── posts_today: int
+    ├── time_since_last_post: int          (hours)
+    ├── trending_topics: list[str]
+    ├── content_queue_size: int
+    ├── last_post_type: str
+    │
+    │   ── Tag Analytics ──
+    ├── tag_performance: dict[str, float]  (tag → avg engagement from your past posts)
+    ├── trending_tags: list[str]           (currently hot tags on the platform)
+    │
+    │   ── Competitor Intelligence ──
+    ├── competitor_recent_posts: list[dict] (last 3 posts from similar creators)
+    │   each: {content_type, topic, tags, engagement, hours_ago}
+    ├── competitor_avg_engagement: float    (avg engagement of similar creators)
+    ├── niche_saturation: float            (0.0–1.0, how crowded your topic space is)
+    │
+    ├── done: bool                         (inherited)
+    └── reward: float                      (inherited)
+```
+
+---
+
+## Data Flow — Single Step
+
+```
+AGENT                                   ENVIRONMENT
+  │                                          │
+  │  ── Action ───────────────────────────►  │
+  │  {                                       │
+  │    action_type: "post"                   │
+  │    content_type: "reel"                  │  1. Validate fields
+  │    topic: "AI trends"                    │  2. energy -= 0.25
+  │    tags: ["ai", "tech", "future"]        │  3. engagement = base_rate
+  │  }                                       │       × hour_mult
+  │                                          │       × energy_quality
+  │                                          │       × tag_boost
+  │                                          │       × trending_bonus
+  │                                          │       × competitor_diff_bonus
+  │                                          │       × audience_fatigue
+  │                                          │  4. Update tag_performance history
+  │                                          │  5. Update niche_saturation
+  │                                          │  6. followers += f(engagement)
+  │                                          │  7. advance hour
+  │                                          │  8. reward = composite score
+  │                                          │  9. done? (168 steps or energy=0)
+  │  ◄── Observation ─────────────────────  │
+  │  {                                       │
+  │    current_hour: 14                      │
+  │    creator_energy: 0.62                  │
+  │    follower_count: 10340                 │
+  │    engagement_rate: 0.048                │
+  │    tag_performance: {                    │
+  │      "ai": 0.72, "tech": 0.55,          │
+  │      "food": 0.31, "travel": 0.44       │
+  │    }                                     │
+  │    trending_tags: ["ai", "summer"]       │
+  │    competitor_recent_posts: [            │
+  │      {type:"carousel", topic:"AI",       │
+  │       tags:["ai","ml"], eng:0.61,        │
+  │       hours_ago: 3},                     │
+  │      ...                                 │
+  │    ]                                     │
+  │    niche_saturation: 0.7                 │
+  │    done: false, reward: 0.67             │
+  │  }                                       │
+```
+
+---
+
+## Step Processing (Server-Side)
+
+### 1. Validate Action
+
+- `action_type` must be one of `post`, `rest`, `create_content`
+- If `post`: `content_type` required, `topic` non-empty ≤200 chars, `tags` max 5 items from known pool
+- Invalid action → reward=0, error in observation
+
+### 2. Apply Energy Cost
+
+| Action | Energy Effect |
+|---|---|
+| Post (reel) | -0.25 |
+| Post (carousel) | -0.20 |
+| Post (story) | -0.08 |
+| Post (text_post) | -0.06 |
+| Rest | +0.12 (capped at 1.0) |
+| Create content | -0.05, queue += 1 |
+
+Repetition penalty: same content type as last 3 posts → extra -0.05.
+If energy ≤ 0 → `done = true` (burnout).
+
+### 3. Calculate Engagement (post only)
+
+```
+engagement = base_rate × hour_mult × quality × tag_boost × trending_bonus
+             × competitor_diff × fatigue_penalty
+```
+
+**Base engagement rates** (SocialInsider 2025):
+
+| Type | Rate | Reach Mult |
+|---|---|---|
+| Carousel | 0.55% | 1.0x |
+| Reel | 0.52% | 2.25x |
+| Story | 0.30% | 0.5x |
+| Text post | 0.37% | 0.44x |
+
+**Hour multipliers** (Buffer 9.6M posts):
+
+| Time Slot | Multiplier |
+|---|---|
+| 9AM–12PM weekdays | 1.3x |
+| 12PM–3PM Tue-Thu | 1.4x (peak) |
+| 6PM–8PM | 1.25x |
+| 8PM–11PM | 1.1x |
+| 11PM–6AM | 0.5x |
+| Fri/Sat | 0.7x base penalty |
+
+**Quality modifier** (Sozee burnout study: 30-52% productivity drop):
+
+```
+quality = 1.0 if energy > 0.5 else max(0.48, energy × 1.5)
+```
+
+**Tag boost** (see Tag Engagement section below):
+
+```
+tag_boost = 1.0 + 0.1 × count(tags that are in trending_tags)
+            + 0.05 × avg(tag_performance[tag] for tag in action.tags)
+```
+
+**Competitor differentiation bonus**:
+
+```
+if topic NOT in competitor_recent_topics (last 12hrs):
+    competitor_diff = 1.3   (unique angle, underserved)
+elif niche_saturation > 0.7:
+    competitor_diff = 0.6   (oversaturated, too many posting same thing)
+else:
+    competitor_diff = 1.0   (neutral)
+```
+
+**Audience fatigue**: posts_today > 3 → ×0.5, posts_today > 5 → ×0.1
+
+**Trending bonus**: topic matches trending → ×1.5
+
+### 4. Update Tag Performance
+
+After each post, the environment records engagement per tag:
+
+```python
+for tag in action.tags:
+    tag_history[tag].append(this_post_engagement)
+    tag_performance[tag] = rolling_avg(tag_history[tag], window=5)
+```
+
+This gives the agent a feedback loop — it can see which tags historically work and adapt.
+
+### 5. Update Competitor State
+
+Each step, the simulated competitors also "post" according to a deterministic schedule (seeded RNG):
+
+```python
+for competitor in competitors:
+    if should_post(competitor, current_hour):  # seeded probability
+        competitor.recent_posts.append({
+            content_type: random.choice(types),
+            topic: random.choice(competitor.niche_topics),
+            tags: random.sample(tag_pool, 3),
+            engagement: base + noise,
+            hours_ago: 0
+        })
+    # Age out old posts
+    competitor.recent_posts = [p for p in competitor.recent_posts if p.hours_ago < 48]
+
+niche_saturation = count(competitor posts with overlapping topic in last 12hrs) / max_posts
+```
+
+### 6. Update Followers
+
+- Posted: `followers += int(engagement × 100)`
+- No post for 48+ hrs: followers decay (algorithm deprioritization)
+
+### 7. Advance Time
+
+- hour += 1
+- If hour ≥ 24: day advances, posts_today resets, trending topics/tags rotate (seeded)
+
+### 8. Compute Reward
+
+```
+reward = clamp(0, 1,
+    engagement_gained × 0.3
+    + energy_delta × 0.15
+    + consistency_bonus × 0.15
+    + tag_optimization_score × 0.15
+    + competitor_diff_score × 0.15
+    - burnout_penalty × 0.1
+)
+```
+
+- `consistency_bonus`: 1.0 if 1-2 posts/day, 0.5 if 0 or 3, 0.0 if 4+
+- `tag_optimization_score`: how well agent's chosen tags match high-performing + trending tags
+- `competitor_diff_score`: 1.0 if posting unique angle, 0.0 if fully overlapping
+- `burnout_penalty`: 1.0 if energy < 0.2
+
+### 9. Check Done
+
+Episode ends when:
+- `step_count >= 168` (1 week = 7 days × 24 hours)
+- `energy <= 0` (burned out)
+
+---
+
+## Tag Engagement System
+
+### How Tags Work
+
+The environment maintains a **tag pool** of ~30 tags across categories:
+
+| Category | Example Tags |
+|---|---|
+| Tech | `ai`, `ml`, `coding`, `startup`, `saas` |
+| Lifestyle | `fitness`, `travel`, `food`, `wellness`, `fashion` |
+| Trending | `summer`, `worldcup`, `election` (rotate daily) |
+| Niche | `productivity`, `minimalism`, `stoic`, `web3` |
+| Broad | `motivation`, `tips`, `howto`, `viral` |
+
+### Tag Performance Tracking
+
+Each tag accumulates engagement history from the agent's own posts:
+
+```
+tag_performance = {
+    "ai": 0.72,          ← avg engagement when you used this tag
+    "fitness": 0.31,     ← this tag isn't working for your audience
+    "motivation": 0.55,
+    ...
+}
+```
+
+Initially all tags start at 0.0 (unknown). As the agent posts with different tags, it builds this signal.
+
+### Tag Dynamics
+
+- **Trending tags** change every 24 simulated hours (seeded, deterministic)
+- Using a trending tag gives +10% engagement per trending tag matched
+- Using a high-performing tag (from your history) gives +5% per tag
+- Using an **oversaturated tag** (competitors using it heavily) gives -10%
+- Max 5 tags per post — agent must choose wisely
+
+### What the Agent Must Learn
+
+1. **Discover** which tags work for its audience (explore early, exploit later)
+2. **Ride trends** — use trending tags when they align with its niche
+3. **Avoid saturation** — if competitors are all using `#ai`, pivot to `#ml` or `#coding`
+4. **Combine** high-performing niche tags with 1-2 trending tags for optimal reach+engagement
+
+---
+
+## Competitor Intelligence System
+
+### Simulated Competitors
+
+The environment simulates **3 competing creators** in the same niche. Each has:
+
+```python
+competitor = {
+    "name": "creator_A",
+    "niche_topics": ["AI", "tech", "startups"],      # their focus
+    "preferred_types": ["reel", "carousel"],           # what they mostly post
+    "posting_frequency": 2.5,                          # avg posts/day
+    "base_engagement": 0.45,                           # their avg engagement
+    "tag_preferences": ["ai", "startup", "coding"],
+}
+```
+
+### What the Agent Sees
+
+Each step, the observation includes:
+
+```python
+competitor_recent_posts: [
+    {"content_type": "reel", "topic": "AI tools", "tags": ["ai", "tools"],
+     "engagement": 0.61, "hours_ago": 3},
+    {"content_type": "carousel", "topic": "startup tips", "tags": ["startup"],
+     "engagement": 0.48, "hours_ago": 8},
+    {"content_type": "reel", "topic": "AI news", "tags": ["ai", "news"],
+     "engagement": 0.52, "hours_ago": 14},
+]
+competitor_avg_engagement: 0.54
+niche_saturation: 0.7   # 0.0=empty, 1.0=everyone posting same stuff
+```
+
+### How Competitors Affect Your Engagement
+
+```
+if your topic overlaps with ≥2 competitor posts in last 12hrs:
+    niche_saturation → high (0.7+)
+    your engagement × 0.6  (audience already saw similar content)
+
+if your topic is unique (no overlap in 12hrs):
+    competitor_diff_bonus = 1.3x  (fresh angle, algorithm favors)
+
+if competitor engagement is HIGH on a topic:
+    that topic has proven demand, but also competition
+    → agent must decide: follow the proven topic (safe) or differentiate (risky but higher upside)
+```
+
+### What the Agent Must Learn
+
+1. **Monitor** competitor posting patterns and timing
+2. **Differentiate** — find underserved time slots and topics
+3. **Counter-program** — post different content type when competitors flood reels
+4. **Learn from competitor success** — if competitor's carousel on "AI" got 0.8 engagement, the topic has demand, but post at a different time or with different tags
+
+---
+
+## Tasks & Graders (All Weekly — 168 steps)
+
+All three tasks run for exactly **1 week (168 hourly steps)**. The difficulty increases through what dimensions are graded and what constraints apply.
+
+### Task 1: weekly_engage (Easy)
+
+**Focus**: Pure engagement maximization.
+
+**What's active**: Basic mechanics only — time of day, content type, energy, audience fatigue.
+
+**What's NOT graded**: Tags, competitors (still simulated but don't affect score).
+
+**Grader formula**:
+
+```
+score = total_engagement / theoretical_max_engagement
+```
+
+**Theoretical max**: Calculated as if agent posted at every peak hour with best content type at full energy. Roughly ~14 optimal posts over 7 days.
+
+**How it's computed**:
+1. Sum all engagement values from every post the agent made
+2. Divide by the theoretical max (computed from: 2 posts/day × 7 days × peak_hour_mult × best_content_rate × quality=1.0)
+3. Clamp to [0.0, 1.0]
+
+**What a smart agent does**: Posts 1-2x/day at peak hours (12-3PM), uses high-engagement content types (carousel/reel), rests to keep energy above 0.5.
+
+**What a dumb agent scores**: Random ≈ 0.08–0.12. Spam-every-hour ≈ 0.15–0.25 (audience fatigue kills it).
+
+---
+
+### Task 2: weekly_strategic (Medium)
+
+**Focus**: Engagement + energy management + tag optimization.
+
+**What's active**: Everything from Task 1, PLUS tag engagement system.
+
+**Grader formula**:
+
+```
+tag_discovery = unique_tags_used_with_positive_engagement / total_tag_pool_size
+tag_exploitation = avg(top_3_tag_performances) / max_possible_tag_performance
+
+tag_score = 0.4 × tag_discovery + 0.6 × tag_exploitation
+
+score = (0.35 × normalized_engagement)
+      + (0.25 × tag_score)
+      + (0.25 × avg_energy)
+      + (0.15 × consistency_score)
+```
+
+**Constraints**:
+- If energy ever drops below 0.3 → score capped at 0.5
+- If fewer than 5 unique tags used across the week → score × 0.7
+
+**How each component works**:
+
+| Component | What it measures | How it's normalized |
+|---|---|---|
+| `normalized_engagement` | Total engagement across all posts | `sum(engagement) / theoretical_max` |
+| `tag_discovery` | Did the agent explore different tags? | `unique_positive_tags / 30 (pool size)` |
+| `tag_exploitation` | Did the agent learn which tags work and reuse them? | `avg(best 3 tags) / 1.0` |
+| `avg_energy` | Did the agent maintain sustainable energy? | `mean(energy at each step) / 1.0` |
+| `consistency_score` | Regular posting rhythm | `days_with_1_or_2_posts / 7` |
+
+**What a smart agent does**: Explores different tags in days 1-2, identifies top performers by day 3, then exploits them while riding trending tags. Balances rest to keep energy > 0.5.
+
+**What a dumb agent scores**: Random ≈ 0.10–0.15 (random tags, no learning). Always-same-tags ≈ 0.20 (no discovery).
+
+---
+
+### Task 3: weekly_competitive (Hard)
+
+**Focus**: Everything + competitor awareness + follower growth.
+
+**What's active**: Full simulation — engagement, tags, competitors, niche saturation.
+
+**Grader formula**:
+
+```
+follower_growth = (final_followers - initial_followers) / initial_followers
+normalized_growth = min(1.0, follower_growth / target_growth_rate)
+
+competitor_outperformance = your_avg_engagement / competitor_avg_engagement
+normalized_outperformance = min(1.0, competitor_outperformance / 1.5)
+
+differentiation = steps_where_topic_was_unique / total_posting_steps
+
+score = (0.25 × normalized_engagement)
+      + (0.20 × tag_score)           ← same formula as Task 2
+      + (0.20 × normalized_growth)
+      + (0.15 × normalized_outperformance)
+      + (0.10 × differentiation)
+      + (0.10 × min_energy_floor)
+```
+
+**Constraints**:
+- Energy hits 0 → score = 0.0 (total fail, burned out)
+- Fewer than 3 content types used → score × 0.5
+- Fewer than 8 unique tags used → score × 0.7
+- If agent never checks competitor patterns (always overlaps) → differentiation = 0
+
+**How each component works**:
+
+| Component | Weight | What it measures | Detail |
+|---|---|---|---|
+| `normalized_engagement` | 25% | Raw engagement quality | Same as Task 1 |
+| `tag_score` | 20% | Tag strategy quality | Discovery + exploitation (Task 2 formula) |
+| `normalized_growth` | 20% | Follower growth over the week | `target_growth_rate` = 5% (500 new followers on 10K base) |
+| `normalized_outperformance` | 15% | Beat your competitors | Your avg engagement / competitor avg. Capped at 1.0 when you're 1.5x better |
+| `differentiation` | 10% | Posting unique angles | % of your posts where topic wasn't posted by competitors in last 12hrs |
+| `min_energy_floor` | 10% | Never crashed | `min(energy_history)` — lowest energy point. Rewards agents that never dipped dangerously low |
+
+**What a smart agent does**:
+1. Days 1-2: Explore tags, observe competitor patterns
+2. Days 3-4: Exploit best tags, counter-program competitors (post when they rest, pick gaps)
+3. Days 5-7: Maximize engagement with learned strategy, maintain energy, diversify content types
+
+**What a dumb agent scores**: Random ≈ 0.08. Copy-competitor-strategy ≈ 0.20 (no differentiation). Smart ≈ 0.50–0.75.
+
+---
+
+## Grading Strategy — In Depth
+
+### Why Weekly for All Tasks
+
+- **Consistency**: Same horizon (168 steps) makes graders comparable
+- **Runtime**: 168 steps × 3 tasks = 504 total LLM calls. At ~2s per call = ~17 minutes. Under the 20-minute limit
+- **Meaningful cycle**: A week is the natural content planning cycle for creators. Days are too short to show learning. Months are too long for inference budget
+
+### Grading Philosophy
+
+The grading is designed so that **each task requires mastering the previous task's skills plus new ones**:
+
+```
+Task 1 (Easy)    → Can you post well?
+                    (timing + content type + energy)
+
+Task 2 (Medium)  → Can you post SMART?
+                    (Task 1 + tag discovery + tag exploitation)
+
+Task 3 (Hard)    → Can you OUTCOMPETE?
+                    (Task 2 + competitor awareness + differentiation + growth)
+```
+
+### Why These Weights
+
+**Task 1** — Engagement is everything (100% engagement-derived). Pure skill test.
+
+**Task 2** — Split focus:
+- 35% engagement (still important, but not enough alone)
+- 25% tags (new skill: must explore AND exploit)
+- 25% energy (sustainability matters now)
+- 15% consistency (rhythm matters)
+
+**Task 3** — Multi-dimensional:
+- No single component dominates (max 25%)
+- Agent must be good at everything, great at nothing is fine
+- `differentiation` (10%) is small but acts as tiebreaker between otherwise similar agents
+- `min_energy_floor` (10%) punishes agents that nearly crashed even if they recovered
+
+### Anti-Gaming Properties
+
+| Potential Exploit | Why it fails |
+|---|---|
+| Post every hour | Audience fatigue kills engagement → low `normalized_engagement` |
+| Always rest | Zero engagement, zero tag score, zero growth → score ≈ 0.05 |
+| Use same 2 tags always | `tag_discovery` tanks in Task 2/3. Score × 0.7 penalty if < 5/8 tags |
+| Copy competitor topics | `differentiation` = 0, `niche_saturation` high → engagement × 0.6 |
+| Post only reels | Score × 0.5 in Task 3 (need ≥ 3 types) |
+| Ignore competitors entirely | Random overlap → sometimes lucky, but `differentiation` averages low |
+| Post gibberish topics | Topic validation + no trending match → low engagement |
+
+### Score Distribution (Expected)
+
+| Agent Type | Task 1 | Task 2 | Task 3 |
+|---|---|---|---|
+| Random | 0.08–0.12 | 0.10–0.15 | 0.06–0.10 |
+| Always rest | 0.02 | 0.05 | 0.02 |
+| Spam (post every step) | 0.15–0.25 | 0.12–0.18 | 0.08–0.15 |
+| Fixed strategy (no learning) | 0.30–0.40 | 0.25–0.35 | 0.20–0.30 |
+| Smart LLM agent | 0.55–0.80 | 0.45–0.70 | 0.40–0.65 |
+
+Task 3 is intentionally hardest — even a good agent won't ace it because competitor dynamics add noise and require adaptation.
+
+---
+
+## Anti-Exploit Guards
+
+| Exploit | Guard |
+|---|---|
+| Reward hacking (long gibberish) | Cap reward per step at 1.0, validate topic, max 200 chars |
+| Grader gaming | Random agent must score < 0.15, spam agent < 0.30 |
+| State reset abuse | Reset only works between tasks, mid-episode reset ignored |
+| Invalid actions | Strict field validation, invalid → 0 reward + error |
+| Rest farming | Rest → reward ≈ 0, energy is a resource not a goal |
+| Repetitive posting | Same type 3x → engagement -20% + energy penalty |
+| Tag spamming | Max 5 tags per post, must be from known pool |
+| Competitor copying | Niche saturation penalty, differentiation score = 0 |
+
+### Sanity Test Agents
+
+Run before submitting:
+
+| Agent | Expected Score (Task 3) | Red Flag If |
+|---|---|---|
+| Random agent | < 0.10 | Reward too easy |
+| Always-rest | < 0.05 | Resting rewarded |
+| Spam (post every step, same type) | < 0.15 | No fatigue working |
+| Fixed (same action every time) | < 0.30 | Environment too simple |
+| Smart (LLM-driven) | 0.40–0.65 | This is the real range |
+
+---
+
+## Simulation Mechanics
+
+### Energy Dynamics (research-backed)
+
+```python
+energy -= content_cost[action.content_type]
+
+# Repetition fatigue (creative fatigue = 40% of burnout)
+if action.content_type == last_3_posts_type:
+    energy -= 0.05
+
+# Recovery: slow, not instant
+if action.action_type == "rest":
+    energy = min(1.0, energy + 0.12)
+
+# Quality modifier (30-52% productivity drop at burnout)
+quality = 1.0 if energy > 0.5 else max(0.48, energy * 1.5)
+```
+
+### Extended Features
+
+#### A. Content Repetition Fatigue
+Same content type 3x in a row → engagement drops 20%. Based on creative fatigue being #1 burnout cause (40%).
+
+#### B. Platform Activity / Competition Window
+`niche_saturation` (0.0–1.0) in observation. When many competitors post same topic → per-post engagement drops. From the broadcast scheduling paper (Preprints.org 2025).
+
+#### C. Follower Tier Response
+Small accounts (<10K) get more from reels (reach). Large accounts (>50K) benefit from carousels (depth). From CreatorsJet 10K post study.
+
+#### D. Trending Topic & Tag Bonus
+If topic or tags match trending → 1.5x and +10% respectively. Topics and tags rotate daily (seeded). Forces adaptive behavior.
+
+#### E. Algorithm Penalty for Inconsistency
+No post for 48+ hours → next 2 posts get 0.6x engagement. Based on algorithmic content selection research (arxiv:2410.13108).
+
+#### F. Tag Engagement Tracking
+Full per-tag engagement history. Agent sees which tags produce results and must balance exploration (try new tags) vs exploitation (reuse winners). See Tag Engagement System section.
+
+#### G. Competitor Awareness
+3 simulated rival creators with deterministic posting schedules. Agent sees their recent posts, topics, tags, and engagement. Must differentiate to avoid saturation. See Competitor Intelligence System section.
+
+---
+
+## Research Backing
+
+### Engagement Data
+
+- **Buffer 2026**: 9.6M posts analyzed — peak posting times, day-of-week effects
+- **SocialInsider 2025**: Engagement rates by content type (carousel 0.55%, reel 0.52%, image 0.37%)
+- **CreatorsJet 10K post study**: Reels give 2.25x reach vs images, carousels give depth
+
+### Burnout Data
+
+- **Sozee 2026**: 90% creators experience burnout, 30-52% productivity drop
+- **TastyEdits Creator Study**: 57% spend 4+ hrs/day, 79% have experienced burnout
+- **Creative fatigue**: #1 cause at 40%, algorithm pressure at 38%
+
+### Academic Papers
+
+| Paper | Relevance |
+|---|---|
+| "Review Old Strategies, New Environments: RL on Social Media" (ScienceDirect 2024) | RL framework for social media — validates env design |
+| arxiv:2410.13108 "Algorithmic Content Selection and User Disengagement" | Over-optimizing immediate engagement causes churn — justifies burnout mechanic |
+| arxiv:2211.13585 "Learning Optimal Break Policies" | Strategic breaks sustain engagement — supports "rest" action |
+| "Optimizing Broadcast Scheduling" (Preprints.org 2025) | Low-competition windows > frequency — competition variable |
+| RLNVR arxiv:2508.12165 | RL from noisy social media signals — proves this is active research |
+
+### Data Sources
+
+- **Meta Content Library**: Real engagement data for public Instagram/Facebook posts ([docs](https://developers.facebook.com/docs/content-library-and-api))
+- **Meta Graph API — Creator Marketplace Insights**: Real creator metrics ([docs](https://developers.facebook.com/docs/graph-api/reference/creator-marketplace-content/insights/))
+
+---
+
+## Inference Script Structure
+
+```python
+import os
+from openai import OpenAI
+from viraltest import ViraltestEnv, ViraltestAction
+
+API_KEY = os.getenv("HF_TOKEN") or os.getenv("API_KEY")
+API_BASE_URL = os.getenv("API_BASE_URL") or "https://router.huggingface.co/v1"
+MODEL_NAME = os.getenv("MODEL_NAME") or "Qwen/Qwen2.5-72B-Instruct"
+TASKS = ["weekly_engage", "weekly_strategic", "weekly_competitive"]
+MAX_STEPS = 168  # 7 days × 24 hours (same for all tasks)
+
+client = OpenAI(api_key=API_KEY, base_url=API_BASE_URL)
+
+for task in TASKS:
+    log_start(task, "viraltest", MODEL_NAME)
+    env = ViraltestEnv(base_url="http://localhost:8000")
+    result = env.reset(task=task)
+    rewards = []
+
+    for step in range(MAX_STEPS):
+        obs = result.observation
+        user_msg = format_observation(obs)
+        response = client.chat.completions.create(
+            model=MODEL_NAME,
+            messages=[
+                {"role": "system", "content": SYSTEM_PROMPT},
+                {"role": "user", "content": user_msg}
+            ],
+            temperature=0.7, max_tokens=150
+        )
+        action = parse_action(response.choices[0].message.content)
+        result = env.step(action)
+        rewards.append(result.reward)
+        log_step(step+1, str(action), result.reward, result.done, None)
+        if result.done:
+            break
+
+    score = grader_score(task, rewards, obs)
+    log_end(score > 0.1, len(rewards), score, rewards)
+    env.close()
+```
+
+Log format:
+
+```
+[START] task=weekly_competitive env=viraltest model=Qwen/Qwen2.5-72B-Instruct
+[STEP] step=1 action=post(reel,"AI trends",["ai","tech"]) reward=0.67 done=false error=null
+[STEP] step=2 action=rest() reward=0.05 done=false error=null
+...
+[END] success=true steps=168 score=0.624 rewards=0.67,0.05,...,0.55
+```
+
+---
+
+## Judging Alignment
+
+| Criteria | Weight | What backs us |
+|---|---|---|
+| Real-world utility | 30% | Meta Content Library, Buffer study, creator burnout stats, tag analytics, competitor analysis |
+| Task & grader quality | 25% | 3 weekly tasks with progressive difficulty, multi-component graders, deterministic |
+| Environment design | 20% | Energy from burnout studies, engagement from SocialInsider, tag + competitor systems |
+| Code quality & spec | 15% | OpenEnv compliant, typed models, Dockerfile works |
+| Creativity & novelty | 10% | Multi-objective (engagement vs burnout vs tags vs competition), backed by 5+ papers |
+
+---
+
+## File Map
+
+| File | Purpose |
+|---|---|
+| `models.py` | `ViraltestAction` and `ViraltestObservation` Pydantic models |
+| `server/viraltest_environment.py` | Simulation logic, task switching, graders, reward calc, tag + competitor systems |
+| `client.py` | `ViraltestEnv` client — `_step_payload`, `_parse_result`, `_parse_state` |
+| `inference.py` | LLM-driven agent with `[START]`/`[STEP]`/`[END]` logging |
+| `openenv.yaml` | Environment metadata |
+| `Dockerfile` | Container build |
+| `README.md` | User-facing docs |
+| `DESIGN.md` | This file |

Dockerfile

@@ -0,0 +1,82 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+# Multi-stage build using openenv-base
+# This Dockerfile is flexible and works for both:
+# - In-repo environments (with local OpenEnv sources)
+# - Standalone environments (with openenv from PyPI/Git)
+# The build script (openenv build) handles context detection and sets appropriate build args.
+
+ARG BASE_IMAGE=ghcr.io/meta-pytorch/openenv-base:latest
+FROM ${BASE_IMAGE} AS builder
+
+WORKDIR /app
+
+# Ensure git is available (required for installing dependencies from VCS)
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends git && \
+    rm -rf /var/lib/apt/lists/*
+
+# Build argument to control whether we're building standalone or in-repo
+ARG BUILD_MODE=in-repo
+ARG ENV_NAME=viraltest
+
+# Copy environment code (always at root of build context)
+COPY . /app/env
+
+# For in-repo builds, openenv is already vendored in the build context
+# For standalone builds, openenv will be installed via pyproject.toml
+WORKDIR /app/env
+
+# Ensure uv is available (for local builds where base image lacks it)
+RUN if ! command -v uv >/dev/null 2>&1; then \
+        curl -LsSf https://astral.sh/uv/install.sh | sh && \
+        mv /root/.local/bin/uv /usr/local/bin/uv && \
+        mv /root/.local/bin/uvx /usr/local/bin/uvx; \
+    fi
+    
+# Install dependencies using uv sync
+# If uv.lock exists, use it; otherwise resolve on the fly
+RUN --mount=type=cache,target=/root/.cache/uv \
+    if [ -f uv.lock ]; then \
+        uv sync --frozen --no-install-project --no-editable; \
+    else \
+        uv sync --no-install-project --no-editable; \
+    fi
+
+RUN --mount=type=cache,target=/root/.cache/uv \
+    if [ -f uv.lock ]; then \
+        uv sync --frozen --no-editable; \
+    else \
+        uv sync --no-editable; \
+    fi
+
+# Final runtime stage
+FROM ${BASE_IMAGE}
+
+WORKDIR /app
+
+# Copy the virtual environment from builder
+COPY --from=builder /app/env/.venv /app/.venv
+
+# Copy the environment code
+COPY --from=builder /app/env /app/env
+
+# Set PATH to use the virtual environment
+ENV PATH="/app/.venv/bin:$PATH"
+
+# Set PYTHONPATH so imports work correctly
+ENV PYTHONPATH="/app/env:$PYTHONPATH"
+
+ENV ENABLE_WEB_INTERFACE=true
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
+    CMD curl -f http://localhost:8000/health || exit 1
+
+# Run the FastAPI server
+# The module path is constructed to work with the /app/env structure
+CMD ["sh", "-c", "cd /app/env && uvicorn viraltest.server.app:app --host 0.0.0.0 --port 8000"]

README.md

@@ -0,0 +1,273 @@
+---
+title: Viraltest — Creator Optimization Agent
+emoji: 📊
+colorFrom: yellow
+colorTo: indigo
+sdk: docker
+pinned: false
+app_port: 8000
+base_path: /web
+tags:
+  - openenv
+---
+
+# Viraltest — RL-Based Creator Optimization Environment
+
+An [OpenEnv](https://github.com/meta-pytorch/OpenEnv) environment that simulates a social media creator’s weekly posting lifecycle. An AI agent learns **when to post**, **what format**, **which tags**, and **how to differentiate from competitors** — maximizing engagement while managing burnout and sleep.
+
+## Submission requirements — how this repo maps
+
+Use this table to confirm Phase 1 (automated) gates before you submit.
+
+| Requirement | Status in this repo | Where to verify |
+|---------------|---------------------|-----------------|
+| Real-world task (not a toy/game) | **Met** — creator scheduling, energy, trends, competitors | `server/viraltest_environment.py`, `DESIGN.md` |
+| Full OpenEnv spec: `openenv.yaml`, typed models, HTTP API | **Met** | `openenv.yaml`, `models.py`, `server/app.py` (`create_app`) |
+| `step()` / `reset()` / `state()` | **Met** — standard OpenEnv HTTP endpoints | Run `openenv validate` |
+| ≥3 tasks with graders (easy → hard), scores in **0.0–1.0** | **Met** — `weekly_engage`, `weekly_strategic`, `weekly_competitive` | `_run_grader()` in `server/viraltest_environment.py` |
+| Meaningful reward + partial progress | **Met** — per-step `_compute_reward()` | `_compute_reward()` |
+| Baseline inference script, reproducible | **Met** — root `inference.py` | See **Baseline inference** below |
+| `Dockerfile` builds | **Expected** — root `Dockerfile` | `docker build -t viraltest .` (run locally) |
+| HF Space deploys; `POST /reset` returns **200** | **You must configure** | See **Hugging Face Spaces** — ping **Space root**, not only `/web` |
+| `openenv validate` passes | **Met** in dev (`.venv/bin/openenv validate`) | CI / local |
+| Env vars: `API_BASE_URL`, `MODEL_NAME`, `HF_TOKEN` | **Documented** — `inference.py` reads them (see **Environment variables**) | HF Space **Settings → Secrets** |
+| `inference.py` at repo root; OpenAI client for LLM calls | **Met** | `inference.py` |
+| Structured stdout: `[START]`, `[STEP]`, `[END]` | **Met** — match field order in `log_*` helpers | `inference.py` |
+| Inference under 20 minutes; 2 vCPU / 8 GB | **Check** — 3 tasks × up to 168 steps each = many LLM calls; use a fast endpoint and sensible `MAX_TOKENS` | `inference.py` |
+
+### Minor items to double-check before judging
+
+1. **`[STEP]` `error=` field** — The spec asks for the raw `last_action_error` or `null`. This repo logs errors with spaces replaced by underscores so each line stays a single token after `error=`. If the organizer’s parser expects literal spaces inside unquoted messages, align with their sample; otherwise this is fine for one-line logs.
+2. **Default `API_BASE_URL` in `inference.py`** — Defaults are for local dev. On Hugging Face, set **`API_BASE_URL`** (e.g. `https://router.huggingface.co/v1`) and **`MODEL_NAME`** in Secrets so evaluation matches your setup.
+3. **Space URL for the validator** — The official script POSTs to `{your_space_url}/reset` with body `{}`. That must be the **root** of the Space (e.g. `https://YOURNAME-spacename.hf.space`), not the Gradio path under `base_path: /web`. Confirm with curl (see **Pre-submission validation**).
+
+---
+
+## Why this matters
+
+Many creators burn out while optimizing posting times and formats. This environment turns that tradeoff into a reproducible simulation so agents can be trained and compared on the same weekly horizon (**168** hourly steps).
+
+---
+
+## Quick Start (Python)
+
+The HTTP client is **async** (same pattern as root `inference.py`):
+
+```python
+import asyncio
+from viraltest import ViraltestAction, ViraltestEnv
+
+async def main():
+    env = ViraltestEnv(base_url="http://localhost:8000")
+    try:
+        result = await env.reset(task="weekly_engage")
+        action = ViraltestAction(
+            action_type="post",
+            content_type="reel",
+            topic="AI trends",
+            tags=["ai", "coding", "devtools"],
+        )
+        result = await env.step(action)
+        print(result.observation.engagement_rate, result.observation.creator_energy)
+    finally:
+        await env.close()
+
+asyncio.run(main())
+```
+
+---
+
+## Action space
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `action_type` | `"post" \| "rest" \| "create_content"` | What the agent does this hour |
+| `content_type` | `"reel" \| "story" \| "carousel" \| "text_post"` | Required when posting |
+| `topic` | `str` (≤200 chars) | Post topic |
+| `tags` | `list[str]` (≤5) | Tags from the environment tag pool |
+
+---
+
+## Observation space (high level)
+
+| Field | Description |
+|-------|-------------|
+| `current_hour`, `day_of_week`, `days_elapsed` | Simulated calendar |
+| `creator_energy`, `hours_since_sleep`, `sleep_debt` | Burnout and sleep |
+| `follower_count`, `engagement_rate` | Growth and rolling engagement |
+| `trending_topics`, `trending_tags`, `tag_performance` | Trends and learned tag quality |
+| `competitor_recent_posts`, `competitor_avg_engagement`, `niche_saturation` | Competition |
+| `error`, `reward`, `done`, `metadata` | Errors, shaping reward, termination, **`metadata["grader_score"]` at episode end** |
+
+Full schema: `GET /schema` when the server is running.
+
+---
+
+## Tasks and graders (168 steps each)
+
+| Task | Difficulty | Grader focus |
+|------|------------|--------------|
+| `weekly_engage` | Easier | Total engagement vs theoretical max; burnout penalty |
+| `weekly_strategic` | Medium | Engagement + tag discovery/exploitation + energy + consistency |
+| `weekly_competitive` | Hard | Adds growth vs competitors, differentiation, diversity constraints |
+
+Episode ends after **168** steps or if **energy ≤ 0**. Final normalized score is in **`observation.metadata["grader_score"]`** in **\[0, 1\]**.
+
+---
+
+## Reward shaping
+
+Per-step reward in **`[0, 1]`** combines engagement, energy change, posting consistency, tags, and competitor differentiation (`_compute_reward` in `server/viraltest_environment.py`). It is dense enough for learning signals before the terminal grader runs.
+
+---
+
+## Local development
+
+```bash
+git clone <your-repo-url>
+cd viral-posts-env   # or your fork name
+
+# Install (uv recommended; pip works too)
+uv sync
+# source .venv/bin/activate   # optional
+
+# Terminal 1 — API server
+uvicorn viraltest.server.app:app --host 0.0.0.0 --port 8000
+
+# Terminal 2 — optional UI
+# Open http://localhost:8000/dashboard  (see server routes in server/app.py)
+```
+
+Validate the OpenEnv layout:
+
+```bash
+.venv/bin/openenv validate
+# Expect: [OK] ... Ready for multi-mode deployment
+```
+
+---
+
+## Docker
+
+From the repository root (same directory as `Dockerfile`):
+
+```bash
+docker build -t viraltest-env:latest .
+docker run --rm -p 8000:8000 viraltest-env:latest
+```
+
+Smoke test:
+
+```bash
+curl -s -o /dev/null -w "%{http_code}" -X POST -H "Content-Type: application/json" -d '{}' http://localhost:8000/reset
+# Expect: 200
+```
+
+---
+
+## Hugging Face Spaces — deploy
+
+1. **Create a Space** with **Docker** SDK (this repo’s README frontmatter uses `sdk: docker`).
+2. **Push this repository** (or connect GitHub) so the Space builds from the root `Dockerfile`.
+3. **Settings → Variables and secrets** — add at least:
+   - **`HF_TOKEN`** — Hugging Face API token for inference (and Space pull if private).
+   - **`API_BASE_URL`** — OpenAI-compatible base URL (e.g. `https://router.huggingface.co/v1`).
+   - **`MODEL_NAME`** — Model id for that router (e.g. `Qwen/Qwen2.5-72B-Instruct`).
+4. **App port** — `8000` (see frontmatter `app_port: 8000`).
+5. **`base_path: /web`** — Used for the bundled web UI; the **REST** endpoints (`/reset`, `/step`, `/state`) remain on the **Space root host** as required by the submission validator. **Always test** `https://<your-space>.hf.space/reset` (not only `/web/...`).
+
+Optional CLI (if you use OpenEnv’s tooling):
+
+```bash
+pip install openenv-core
+openenv push   # follow OpenEnv docs for auth and target Space
+```
+
+---
+
+## Baseline inference (`inference.py`)
+
+**Location:** repository root — **`inference.py`** (required by the hackathon).
+
+**LLM client:** OpenAI-compatible client (`from openai import OpenAI`) using:
+
+| Variable | Role |
+|----------|------|
+| `API_BASE_URL` | OpenAI-compatible API base |
+| `MODEL_NAME` | Model name for `chat.completions` |
+| `HF_TOKEN` | Preferred API key (fallbacks: `OPENAI_API_KEY`, `API_KEY`) |
+| `IMAGE_NAME` / `LOCAL_IMAGE_NAME` | If using `ViraltestEnv.from_docker_image(...)` instead of HTTP |
+| `ENV_BASE_URL` | HTTP server URL (default `http://localhost:8000`) |
+
+**Stdout format (must not change field names or order):**
+
+```text
+[START] task=<name> env=<benchmark> model=<model>
+[STEP]  step=<n> action=<str> reward=<0.00> done=<true|false> error=<msg|null>
+[END]   success=<true|false> steps=<n> score=<0.00> rewards=<r1,r2,...>
+```
+
+Run locally (server on port 8000):
+
+```bash
+export HF_TOKEN=hf_...
+export API_BASE_URL=https://router.huggingface.co/v1
+export MODEL_NAME=Qwen/Qwen2.5-72B-Instruct
+uv sync && .venv/bin/python inference.py
+```
+
+**Short episodes for debugging** — `ALLOW_SHORT_EPISODE=1` and `MAX_STEPS` can shorten runs; full weekly tasks still use **168** steps unless you override (see comments in `inference.py`).
+
+---
+
+## Pre-submission validation
+
+Use the provided script (same checks as the official template: ping Space, Docker build, `openenv validate`):
+
+```bash
+chmod +x validate-submission.sh
+./validate-submission.sh https://YOUR-SPACE.hf.space /path/to/viral-posts-env
+```
+
+Or download the organizer’s script from their repo and pass your Space URL.
+
+**Manual ping (required to pass automated gate):**
+
+```bash
+curl -s -o /dev/null -w "%{http_code}\n" -X POST \
+  -H "Content-Type: application/json" -d '{}' \
+  https://YOUR-SPACE.hf.space/reset
+# Must print: 200
+```
+
+---
+
+## Baseline scores (reference)
+
+Deterministic dashboard agents (not the LLM) — see `README` tables in-repo history / `DESIGN.md` for methodology. Your **`inference.py`** scores will vary by model and endpoint; keep runs under the **20-minute** inference budget.
+
+---
+
+## Project structure
+
+```
+.
+├── inference.py              # Hackathon-required baseline (LLM + [START]/[STEP]/[END])
+├── openenv.yaml              # OpenEnv manifest
+├── models.py                 # ViraltestAction, ViraltestObservation
+├── client.py                 # ViraltestEnv client
+├── Dockerfile
+├── validate-submission.sh    # Local preflight
+├── test_scenarios.py         # Offline env tests
+├── DESIGN.md                 # Deep design / research notes
+└── server/
+    ├── app.py                # FastAPI + create_app
+    ├── viraltest_environment.py
+    └── dashboard.html
+```
+
+---
+
+## License
+
+See `LICENSE` in the repository root (BSD-style per upstream OpenEnv examples).

SIMULATION_REPORT.md

@@ -0,0 +1,276 @@
+# Viraltest Simulation Report
+
+**Task:** Hard — Competitive (weekly_competitive)
+**Episode Length:** 168 steps (7 days x 24 hours)
+**Starting Followers:** 10,000 | **Starting Energy:** 1.00
+
+---
+
+## Executive Summary
+
+11 agent strategies were evaluated on the Hard — Competitive task. The **Balanced Creator** (0.8775) and **Smart Agent** (0.8745) achieved the highest scores by combining strategic posting, energy management, and tag diversity. Two agents (**Spam Post**, **No Rest**) burned out within 8 steps, scoring 0.0000. The **Always Rest** agent lost 45% of its followers from inactivity.
+
+---
+
+## Leaderboard
+
+| Rank | Scenario | Score | Followers | Delta | Energy | Burned Out |
+|------|----------|-------|-----------|-------|--------|------------|
+| 1 | Balanced Creator | **0.8775** | 12,534 | +2,534 (+25.3%) | 1.00 | No |
+| 2 | Smart Agent | **0.8745** | 12,200 | +2,200 (+22.0%) | 1.00 | No |
+| 3 | Tag Explorer | **0.8323** | 11,351 | +1,351 (+13.5%) | 0.94 | No |
+| 4 | Copycat | **0.6136** | 11,589 | +1,589 (+15.9%) | 1.00 | No |
+| 5 | Burst Poster | **0.6111** | 11,701 | +1,701 (+17.0%) | 0.44 | No |
+| 6 | Queue Optimizer | **0.3520** | 11,215 | +1,215 (+12.2%) | 1.00 | No |
+| 7 | Weekend Warrior | **0.1257** | 7,659 | -2,341 (-23.4%) | 1.00 | No |
+| 8 | Night Poster | **0.0937** | 10,237 | +237 (+2.4%) | 0.59 | No |
+| 9 | Always Rest | **0.0350** | 5,497 | -4,503 (-45.0%) | 1.00 | No |
+| 10 | Spam Post | **0.0000** | 10,625 | +625 (+6.3%) | 0.00 | **YES** |
+| 11 | No Rest | **0.0000** | 10,213 | +213 (+2.1%) | 0.00 | **YES** |
+
+---
+
+## Detailed Agent Analysis
+
+### 1. Balanced Creator — Score: 0.8775 (BEST)
+
+| Metric | Value |
+|--------|-------|
+| Steps Completed | 168 / 168 |
+| Final Energy | 1.00 |
+| Final Followers | 12,534 (+25.3%) |
+| Engagement Rate | 0.827 |
+| Total Posts | 28 |
+| Total Rests | 84 |
+| Content Created | 56 |
+| Unique Tags | 19 |
+| Min Energy | 0.795 (never dipped below safe zone) |
+| Avg Reward | 0.219 |
+| Max Reward | 0.738 |
+
+**Strategy:** Create → Post → Rest cycle. Uses the content queue (56 items created, 28 posted from queue at 50% energy cost). Posts during peak hours with trending topics. Never risks burnout.
+
+**Top Tags:** #food (1.32), #election (1.31), #coding (1.16), #saas (1.03), #crypto (1.02)
+
+**Why it won:** Highest follower growth (+2,534), perfect energy management (never below 0.795), excellent tag diversity (19 unique), and consistent daily posting.
+
+---
+
+### 2. Smart Agent — Score: 0.8745
+
+| Metric | Value |
+|--------|-------|
+| Steps Completed | 168 / 168 |
+| Final Energy | 1.00 |
+| Final Followers | 12,200 (+22.0%) |
+| Engagement Rate | 1.556 |
+| Total Posts | 14 |
+| Total Rests | 154 |
+| Unique Tags | 19 |
+| Min Energy | 0.55 |
+| Avg Reward | 0.230 |
+| Max Reward | 0.760 |
+
+**Strategy:** Posts only during peak hours (9-20) when energy > 0.4 and posts < 2/day. Uses trending topics and tags. Rests aggressively.
+
+**Top Tags:** #ai (3.56), #wellness (2.55), #summer (2.36), #crypto (2.18), #newyear (2.01)
+
+**Why it's strong:** Highest individual tag performance (#ai at 3.56), highest engagement rate (1.556), but fewer posts (14 vs 28) cost it the top spot.
+
+---
+
+### 3. Tag Explorer — Score: 0.8323
+
+| Metric | Value |
+|--------|-------|
+| Steps Completed | 168 / 168 |
+| Final Energy | 0.94 |
+| Final Followers | 11,351 (+13.5%) |
+| Engagement Rate | 0.774 |
+| Total Posts | 15 |
+| Unique Tags | **30** (highest) |
+| Min Energy | 0.69 |
+
+**Strategy:** New tag combination every post. Maximizes tag discovery — 30 unique tags used (the highest of all agents).
+
+**Why it scored high:** The grading formula rewards tag diversity heavily. 30 unique tags gave a massive tag_discovery bonus.
+
+---
+
+### 4. Copycat — Score: 0.6136
+
+| Metric | Value |
+|--------|-------|
+| Steps Completed | 168 / 168 |
+| Final Energy | 1.00 |
+| Final Followers | 11,589 (+15.9%) |
+| Total Posts | 21 |
+| Unique Tags | 8 |
+| Min Energy | 0.10 (dangerous dip!) |
+
+**Strategy:** Copies competitor topics and content types. Posts when competitors are active.
+
+**Weakness:** High niche saturation from copying rivals. Only 8 unique tags (penalized). Min energy hit 0.10 — nearly burned out.
+
+---
+
+### 5. Burst Poster — Score: 0.6111
+
+| Metric | Value |
+|--------|-------|
+| Steps Completed | 168 / 168 |
+| Final Energy | 0.44 |
+| Final Followers | 11,701 (+17.0%) |
+| Total Posts | **57** (highest) |
+| Unique Tags | 13 |
+| Min Energy | 0.25 |
+
+**Strategy:** 3 posts in rapid succession, then rests until recovered. Repeat.
+
+**Weakness:** Ended with only 0.44 energy. 57 posts caused audience fatigue (posts > 3/day get heavy penalty). Low per-post engagement (0.208) despite high volume.
+
+---
+
+### 6. Queue Optimizer — Score: 0.3520
+
+| Metric | Value |
+|--------|-------|
+| Steps Completed | 168 / 168 |
+| Final Energy | 1.00 |
+| Final Followers | 11,215 (+12.2%) |
+| Total Posts | 14 |
+| Content Created | 17 |
+| Unique Tags | 12 |
+
+**Strategy:** Creates content first (builds queue), then posts from queue at half energy cost.
+
+**Weakness:** Spent too long in "prep" phase creating content. Only 14 actual posts despite 17 items queued. Score penalized for under-utilizing the queue.
+
+---
+
+### 7. Weekend Warrior — Score: 0.1257
+
+| Metric | Value |
+|--------|-------|
+| Steps Completed | 168 / 168 |
+| Final Followers | 7,659 **(-23.4%)** |
+| Total Posts | 6 |
+| Unique Tags | 6 |
+
+**Strategy:** Only posts on Saturday and Sunday. Rests Mon-Fri.
+
+**Weakness:** 5 days of inactivity triggered follower decay (-2,341) and algorithm penalty. Only 6 posts total. Weekend posting also gets a 0.7x penalty multiplier.
+
+---
+
+### 8. Night Poster — Score: 0.0937
+
+| Metric | Value |
+|--------|-------|
+| Steps Completed | 168 / 168 |
+| Final Followers | 10,237 (+2.4%) |
+| Total Posts | 49 |
+| Unique Tags | 2 |
+| Engagement Rate | 0.036 |
+
+**Strategy:** Posts exclusively at night (23:00-06:00) with boring topics.
+
+**Weakness:** Night hours get 0.5x multiplier. Only 2 unique tags (#stoic, #minimalism) — severe tag penalty. Despite 49 posts, engagement was near-zero (0.036).
+
+---
+
+### 9. Always Rest — Score: 0.0350
+
+| Metric | Value |
+|--------|-------|
+| Steps Completed | 168 / 168 |
+| Final Followers | 5,497 **(-45.0%)** |
+| Total Posts | 0 |
+| Engagement Rate | 0.000 |
+
+**Strategy:** Never posts. Rests every step.
+
+**Result:** Zero engagement. Lost 4,503 followers (45%) to decay. Algorithm penalty stacked from inactivity. Energy stayed at 1.00 — completely wasted.
+
+---
+
+### 10. Spam Post — Score: 0.0000
+
+| Metric | Value |
+|--------|-------|
+| Steps Completed | **4** / 168 |
+| Final Energy | **0.00 (BURNED OUT)** |
+| Final Followers | 10,625 (+6.3%) |
+
+**Strategy:** Posts the same reel with "AI tools" topic every step. No rest.
+
+**Result:** Burned out at step 4. Each reel costs 0.25 energy. 4 reels = 1.00 energy drained. Episode ended at step 4 with score 0.0000 (burnout = automatic fail on competitive task).
+
+---
+
+### 11. No Rest — Score: 0.0000
+
+| Metric | Value |
+|--------|-------|
+| Steps Completed | **8** / 168 |
+| Final Energy | **0.00 (BURNED OUT)** |
+| Final Followers | 10,213 (+2.1%) |
+
+**Strategy:** Posts varied content types but never rests.
+
+**Result:** Burned out at step 8. Mixed content types (reel, carousel, story, text_post) averaged ~0.125 energy cost. 8 posts without rest = burnout. Score: 0.0000.
+
+---
+
+## Key Metrics Comparison
+
+### Energy Management
+| Agent | Min Energy | Final Energy | Energy Safety |
+|-------|-----------|--------------|---------------|
+| Always Rest | 1.000 | 1.00 | Wasted |
+| Balanced | 0.795 | 1.00 | Excellent |
+| Tag Explorer | 0.690 | 0.94 | Good |
+| Queue Optimizer | 0.610 | 1.00 | Good |
+| Smart Agent | 0.550 | 1.00 | Good |
+| Burst Poster | 0.250 | 0.44 | Risky |
+| Night Poster | 0.230 | 0.59 | Dangerous |
+| Copycat | 0.100 | 1.00 | Near-fatal dip |
+| Weekend | 0.100 | 1.00 | Near-fatal dip |
+| No Rest | 0.000 | 0.00 | BURNED OUT |
+| Spam Post | 0.000 | 0.00 | BURNED OUT |
+
+### Posting Volume vs Quality
+| Agent | Posts | Engagement Rate | Engagement per Post |
+|-------|-------|----------------|---------------------|
+| Burst | 57 | 0.208 | Low (fatigue) |
+| Night Poster | 49 | 0.036 | Very low (timing) |
+| Balanced | 28 | 0.827 | High |
+| Copycat | 21 | 0.497 | Medium |
+| Tag Explorer | 15 | 0.774 | High |
+| Smart Agent | 14 | 1.556 | Very high |
+| Queue Opt | 14 | 0.870 | High |
+| Weekend | 6 | 0.635 | Medium |
+| Spam | 4 | 1.567 | High (but burned out) |
+
+---
+
+## Lessons Learned
+
+1. **Burnout is fatal** — On the competitive task, burnout = score 0.0000. Energy management is the #1 priority.
+
+2. **Quality > Quantity** — Smart Agent posted only 14 times but had the highest engagement rate (1.556). Burst posted 57 times but scored lower.
+
+3. **Tag diversity matters** — Tag Explorer's 30 unique tags boosted its score to 0.8323 despite moderate engagement. Night Poster's 2 tags destroyed its score.
+
+4. **Content queue is powerful** — Balanced Creator used create_content (56 times) to build a queue, then posted at half energy cost. This enabled 28 posts while maintaining 0.795+ energy.
+
+5. **Timing is critical** — Night Poster proved that posting at wrong hours (0.5x multiplier) wastes energy for near-zero engagement.
+
+6. **Copying competitors backfires** — Copycat achieved decent followers but niche saturation penalty and low tag diversity (8) capped its score at 0.6136.
+
+7. **Consistency beats bursts** — Posting 1-2/day consistently (Balanced, Smart) scored higher than bursting 3+ posts then resting (Burst).
+
+---
+
+*Report generated from Viraltest Creator Intelligence Center*
+*Task: weekly_competitive | 168 hourly steps | 3 competitor profiles*

__init__.py

@@ -0,0 +1,17 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""Viraltest Environment."""
+
+from .client import ViraltestEnv
+from .models import ScheduledAction, ViraltestAction, ViraltestObservation
+
+__all__ = [
+    "ScheduledAction",
+    "ViraltestAction",
+    "ViraltestObservation",
+    "ViraltestEnv",
+]

client.py

@@ -0,0 +1,91 @@
+"""Viraltest Environment Client."""
+
+from typing import Any, Dict
+
+from openenv.core import EnvClient
+from openenv.core.client_types import StepResult
+from openenv.core.env_server.types import State
+
+from .models import ViraltestAction, ViraltestObservation
+
+
+class ViraltestEnv(
+    EnvClient[ViraltestAction, ViraltestObservation, State]
+):
+    """
+    Client for the Viraltest Creator Optimization Environment.
+
+    Maintains a persistent WebSocket connection to the environment server.
+
+    Example:
+        >>> with ViraltestEnv(base_url="http://localhost:8000") as client:
+        ...     result = client.reset(task="weekly_engage")
+        ...     result = client.step(ViraltestAction(
+        ...         scheduled_actions=[
+        ...             {"hour": 12, "action_type": "post", "content_type": "reel",
+        ...              "topic": "AI trends", "tags": ["ai", "tech"]},
+        ...         ]
+        ...     ))
+    """
+
+    def _step_payload(self, action: ViraltestAction) -> Dict[str, Any]:
+        actions_list = []
+        for sa in action.scheduled_actions:
+            item: Dict[str, Any] = {
+                "hour": sa.hour,
+                "action_type": sa.action_type,
+            }
+            if sa.content_type is not None:
+                item["content_type"] = sa.content_type
+            if sa.topic is not None:
+                item["topic"] = sa.topic
+            if sa.tags is not None:
+                item["tags"] = sa.tags
+            actions_list.append(item)
+        return {"scheduled_actions": actions_list}
+
+    def _parse_result(self, payload: Dict[str, Any]) -> StepResult[ViraltestObservation]:
+        obs_data = payload.get("observation", {})
+        grader_score = obs_data.get("grader_score")
+        meta = obs_data.get("metadata", {})
+        if grader_score is not None:
+            meta["grader_score"] = grader_score
+        observation = ViraltestObservation(
+            current_hour=obs_data.get("current_hour", 0),
+            day_of_week=obs_data.get("day_of_week", 0),
+            days_elapsed=obs_data.get("days_elapsed", 0),
+            creator_energy=obs_data.get("creator_energy", 1.0),
+            follower_count=obs_data.get("follower_count", 0),
+            engagement_rate=obs_data.get("engagement_rate", 0.0),
+            hours_since_sleep=obs_data.get("hours_since_sleep", 0),
+            posts_today=obs_data.get("posts_today", 0),
+            sleep_debt=obs_data.get("sleep_debt", 0.0),
+            time_since_last_post=obs_data.get("time_since_last_post", 0),
+            trending_topics=obs_data.get("trending_topics", []),
+            content_queue_size=obs_data.get("content_queue_size", 0),
+            last_post_type=obs_data.get("last_post_type", "none"),
+            tag_performance=obs_data.get("tag_performance", {}),
+            trending_tags=obs_data.get("trending_tags", []),
+            competitor_recent_posts=obs_data.get("competitor_recent_posts", []),
+            competitor_avg_engagement=obs_data.get("competitor_avg_engagement", 0.0),
+            niche_saturation=obs_data.get("niche_saturation", 0.0),
+            daily_total_engagement=obs_data.get("daily_total_engagement", 0.0),
+            daily_posts_made=obs_data.get("daily_posts_made", 0),
+            daily_energy_min=obs_data.get("daily_energy_min", 1.0),
+            grader_score=grader_score,
+            error=obs_data.get("error"),
+            done=payload.get("done", False),
+            reward=payload.get("reward"),
+            metadata=meta,
+        )
+        return StepResult(
+            observation=observation,
+            reward=payload.get("reward"),
+            done=payload.get("done", False),
+        )
+
+    def _parse_state(self, payload: Dict[str, Any]) -> State:
+        return State(
+            episode_id=payload.get("episode_id"),
+            step_count=payload.get("step_count", 0),
+        )

inference.py

@@ -0,0 +1,304 @@
+"""
+Viraltest Inference Script — RL-Based Creator Optimization Agent
+===================================
+MANDATORY
+- Before submitting, ensure the following variables are defined in your environment configuration:
+    API_BASE_URL   The API endpoint for the LLM.
+    MODEL_NAME     The model identifier to use for inference.
+    HF_TOKEN or OPENAI_API_KEY or API_KEY   API key for the LLM client.
+    IMAGE_NAME or LOCAL_IMAGE_NAME   Docker image when using ViraltestEnv.from_docker_image()
+
+Optional:
+    ALLOW_SHORT_EPISODE=1   Allow MAX_STEPS below 7 (final grader score stays 0 if episode never ends).
+    MAX_STEPS   Step cap (default 7). Without ALLOW_SHORT_EPISODE, cap is at least 7 so graders run.
+
+Each step = one full day. The agent submits a sparse daily plan (only posts and create_content
+actions at specific hours). Unlisted hours automatically become rest.
+
+STDOUT FORMAT (single space after tag; score two decimals) — match hackathon sample exactly.
+"""
+
+import asyncio
+import json
+import os
+import textwrap
+from typing import Any, Dict, List, Optional
+
+from openai import OpenAI
+
+from viraltest import ViraltestAction, ViraltestEnv
+from viraltest.server.viraltest_environment import TAG_POOL, TASK_HORIZON
+
+DOCKER_IMAGE = os.getenv("IMAGE_NAME") or os.getenv("LOCAL_IMAGE_NAME")
+API_KEY = os.getenv("HF_TOKEN") or os.getenv("OPENAI_API_KEY") or os.getenv("API_KEY")
+API_BASE_URL = os.getenv("API_BASE_URL") or "http://127.0.0.1:1337/v1"
+MODEL_NAME = os.getenv("MODEL_NAME") or "gemma-4-E4B-it-IQ4_XS"
+BENCHMARK = os.getenv("VIRALTEST_BENCHMARK", "viraltest")
+
+TASKS = ["weekly_engage", "weekly_strategic", "weekly_competitive"]
+_ALLOW_SHORT = os.getenv("ALLOW_SHORT_EPISODE", "").lower() in ("1", "true", "yes")
+_REQUESTED_MAX = int(os.getenv("MAX_STEPS", str(TASK_HORIZON)))
+MAX_STEPS = _REQUESTED_MAX if _ALLOW_SHORT else max(_REQUESTED_MAX, TASK_HORIZON)
+TEMPERATURE = 0.7
+MAX_TOKENS = 512
+SUCCESS_SCORE_THRESHOLD = 0.1
+
+VALID_TAGS_TEXT = ", ".join(TAG_POOL)
+
+SYSTEM_PROMPT = textwrap.dedent(f"""\
+You are a social media content strategy agent. Each step is one full day (24 hours).
+You receive the current day's state and must plan your actions for the entire day.
+
+Reply with a JSON object containing "scheduled_actions" — a list of actions at specific hours.
+Hours you don't list will automatically be rest. Only include posts and create_content actions.
+
+FORMAT (JSON only, no markdown, no prose):
+{{
+  "scheduled_actions": [
+    {{"hour": 10, "action_type": "create_content"}},
+    {{"hour": 12, "action_type": "post", "content_type": "reel", "topic": "AI trends", "tags": ["ai", "coding"]}},
+    {{"hour": 18, "action_type": "post", "content_type": "carousel", "topic": "startup tips", "tags": ["startup", "growth"]}}
+  ]
+}}
+
+RULES:
+- hour: 0-23 (which hour of the day to perform the action)
+- action_type: "post" or "create_content" (rest is automatic for unlisted hours)
+- For posts: content_type (reel|story|carousel|text_post), topic, and tags are required
+- Tags must be from this pool: {VALID_TAGS_TEXT}
+- Max 5 tags per post
+- Empty scheduled_actions means rest all day
+- Peak posting hours: 9-12 (1.3x), 12-15 Tue-Thu (1.4x), 18-20 (1.25x)
+- Posting 3+ times/day causes audience fatigue; 1-2 posts/day is optimal
+- If energy hits 0, episode ends (burnout = game over)
+
+Plan strategically: schedule posts at peak hours, rest during off-hours to recover energy,
+and use create_content to build a content queue for cheaper posts later.""")
+
+
+def should_force_rest_day(obs: Any) -> bool:
+    """If energy is critically low, submit an empty schedule (all rest)."""
+    energy = float(getattr(obs, "creator_energy", 1.0))
+    return energy <= 0.15
+
+
+def log_start(task: str, env: str, model: str) -> None:
+    print(f"[START] task={task} env={env} model={model}", flush=True)
+
+
+def log_step(step: int, action: str, reward: float, done: bool, error: Optional[str]) -> None:
+    error_val = error.replace(" ", "_") if error else "null"
+    done_val = str(done).lower()
+    print(
+        f"[STEP] step={step} action={action} reward={reward:.2f} "
+        f"done={done_val} error={error_val}",
+        flush=True,
+    )
+
+
+def log_end(success: bool, steps: int, score: float, rewards: List[float]) -> None:
+    rewards_str = ",".join(f"{r:.2f}" for r in rewards)
+    print(
+        f"[END] success={str(success).lower()} steps={steps} "
+        f"score={score:.2f} rewards={rewards_str}",
+        flush=True,
+    )
+
+
+def format_observation(obs: Any) -> str:
+    """Serialize observation into a readable prompt for the LLM."""
+    tag_perf = obs.tag_performance or {}
+    top_tags = sorted(tag_perf.items(), key=lambda x: x[1], reverse=True)[:5]
+    top_tags_str = ", ".join(f"{t}={v:.2f}" for t, v in top_tags) if top_tags else "none yet"
+
+    comp_posts = obs.competitor_recent_posts or []
+    comp_str = ""
+    for p in comp_posts[:3]:
+        comp_str += (
+            f"  - {p.get('content_type','?')} on '{p.get('topic','?')}' "
+            f"tags={p.get('tags',[])} eng={p.get('engagement',0):.2f} "
+            f"({p.get('hours_ago',0)}h ago)\n"
+        )
+    if not comp_str:
+        comp_str = "  none\n"
+
+    days = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]
+    day_name = days[obs.day_of_week] if 0 <= obs.day_of_week < 7 else "?"
+
+    daily_eng = getattr(obs, "daily_total_engagement", 0.0)
+    daily_posts = getattr(obs, "daily_posts_made", 0)
+    daily_emin = getattr(obs, "daily_energy_min", 1.0)
+
+    return textwrap.dedent(f"""\
+Day: {day_name} (day_of_week={obs.day_of_week}, 0=Mon) | days_elapsed={obs.days_elapsed}
+Hours since sleep: {obs.hours_since_sleep} | Sleep debt: {obs.sleep_debt:.3f}
+Energy: {obs.creator_energy:.2f} | Followers: {obs.follower_count} | Engagement rate: {obs.engagement_rate:.3f}
+Hours since last post: {obs.time_since_last_post}
+Content queue: {obs.content_queue_size} | Last post type: {obs.last_post_type}
+Yesterday's engagement: {daily_eng:.3f} | Yesterday's posts: {daily_posts} | Yesterday's min energy: {daily_emin:.2f}
+Trending topics: {', '.join(obs.trending_topics)}
+Trending tags: {', '.join(obs.trending_tags)}
+Your top tags: {top_tags_str}
+Niche saturation: {obs.niche_saturation:.2f} | Competitor avg engagement: {obs.competitor_avg_engagement:.3f}
+Competitor recent posts:
+{comp_str}Plan your actions for today (list only posts and create_content at specific hours):""")
+
+
+def parse_daily_plan(response_text: str) -> ViraltestAction:
+    """Parse LLM JSON into ViraltestAction with scheduled_actions; fallback to empty (all rest)."""
+    text = response_text.strip()
+    if text.startswith("```"):
+        lines = text.split("\n")
+        lines = [l for l in lines if not l.strip().startswith("```")]
+        text = "\n".join(lines).strip()
+
+    try:
+        data: Dict[str, Any] = json.loads(text)
+        actions_raw = data.get("scheduled_actions", [])
+        if not isinstance(actions_raw, list):
+            return ViraltestAction(scheduled_actions=[])
+        return ViraltestAction(scheduled_actions=actions_raw)
+    except (json.JSONDecodeError, Exception):
+        return ViraltestAction(scheduled_actions=[])
+
+
+def format_action_str(action: ViraltestAction) -> str:
+    """Format daily plan for [STEP] log line."""
+    if not action.scheduled_actions:
+        return "daily_plan(rest_all)"
+    parts = []
+    for sa in action.scheduled_actions:
+        if sa.action_type == "post":
+            tags_str = ",".join(sa.tags) if sa.tags else ""
+            parts.append(f"h{sa.hour}:post({sa.content_type},\"{sa.topic}\",[{tags_str}])")
+        else:
+            parts.append(f"h{sa.hour}:{sa.action_type}()")
+    return "daily_plan(" + ";".join(parts) + ")"
+
+
+_model_exhausted = False
+
+
+def get_model_daily_plan(
+    client: OpenAI, obs: Any, history: List[Dict[str, str]]
+) -> ViraltestAction:
+    """Call the LLM to get a daily plan. Falls back to rest permanently after an unrecoverable error."""
+    global _model_exhausted
+    if _model_exhausted:
+        return ViraltestAction(scheduled_actions=[])
+
+    user_prompt = format_observation(obs)
+    messages = [{"role": "system", "content": SYSTEM_PROMPT}]
+    messages.extend(history[-12:])
+    messages.append({"role": "user", "content": user_prompt})
+
+    try:
+        completion = client.chat.completions.create(
+            model=MODEL_NAME,
+            messages=messages,
+            temperature=TEMPERATURE,
+            max_tokens=MAX_TOKENS,
+            stream=False,
+        )
+        text = (completion.choices[0].message.content or "").strip()
+        return parse_daily_plan(text) if text else ViraltestAction(scheduled_actions=[])
+    except Exception as exc:
+        err_str = str(exc)
+        print(f"[DEBUG] Model request failed: {exc}", flush=True)
+        if "402" in err_str or "429" in err_str or "credit" in err_str.lower() or "quota" in err_str.lower():
+            _model_exhausted = True
+            print("[DEBUG] Token/credit limit reached — falling back to rest for remaining steps", flush=True)
+        return ViraltestAction(scheduled_actions=[])
+
+
+async def run_task(client: OpenAI, task: str) -> None:
+    """Run a single task episode (7 daily steps)."""
+    global _model_exhausted
+    _model_exhausted = False
+
+    rewards: List[float] = []
+    steps_taken = 0
+    score = 0.0
+    success = False
+    env: Optional[ViraltestEnv] = None
+
+    log_start(task=task, env=BENCHMARK, model=MODEL_NAME)
+
+    try:
+        if DOCKER_IMAGE:
+            env = await ViraltestEnv.from_docker_image(DOCKER_IMAGE)
+        else:
+            env = ViraltestEnv(base_url=os.getenv("ENV_BASE_URL", "http://localhost:8000"))
+
+        result = await env.reset(task=task)
+        history: List[Dict[str, str]] = []
+
+        for step in range(1, MAX_STEPS + 1):
+            if result.done:
+                break
+
+            obs = result.observation
+            if should_force_rest_day(obs):
+                action = ViraltestAction(scheduled_actions=[])
+            else:
+                action = get_model_daily_plan(client, obs, history)
+
+            result = await env.step(action)
+
+            reward = result.reward or 0.0
+            done = result.done
+            error = getattr(result.observation, "error", None)
+
+            rewards.append(reward)
+            steps_taken = step
+
+            log_step(
+                step=step,
+                action=format_action_str(action),
+                reward=reward,
+                done=done,
+                error=error,
+            )
+
+            history.append({
+                "role": "assistant",
+                "content": json.dumps({
+                    "scheduled_actions": [
+                        {
+                            "hour": sa.hour,
+                            "action_type": sa.action_type,
+                            "content_type": sa.content_type,
+                            "topic": sa.topic,
+                            "tags": sa.tags,
+                        }
+                        for sa in action.scheduled_actions
+                    ]
+                }),
+            })
+
+            if done:
+                score = float(getattr(result.observation, "grader_score", 0) or 0)
+                if score == 0:
+                    meta = getattr(result.observation, "metadata", {}) or {}
+                    score = float(meta.get("grader_score", 0.0))
+                break
+
+        success = score >= SUCCESS_SCORE_THRESHOLD
+
+    finally:
+        if env is not None:
+            try:
+                await env.close()
+            except Exception as e:
+                print(f"[DEBUG] env.close() error: {e}", flush=True)
+        log_end(success=success, steps=steps_taken, score=score, rewards=rewards)
+
+
+async def main() -> None:
+    client = OpenAI(base_url=API_BASE_URL, api_key=API_KEY or "not-needed")
+    for task in TASKS:
+        await run_task(client, task)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

models.py

@@ -0,0 +1,87 @@
+"""Data models for the Viraltest Creator Optimization Environment."""
+
+from typing import Any, Dict, List, Literal, Optional
+
+from openenv.core.env_server.types import Action, Observation
+from pydantic import BaseModel, Field, field_validator
+
+VALID_CONTENT_TYPES = ("reel", "story", "carousel", "text_post")
+VALID_ACTION_TYPES = ("post", "create_content")
+
+
+class ScheduledAction(BaseModel):
+    """A single non-rest action scheduled at a specific hour of the day."""
+
+    hour: int = Field(..., ge=0, le=23, description="Hour of the day (0-23)")
+    action_type: Literal["post", "create_content"] = Field(
+        ..., description="What to do at this hour (unlisted hours default to rest)"
+    )
+    content_type: Optional[Literal["reel", "story", "carousel", "text_post"]] = Field(
+        default=None, description="Format of the post (required if posting)"
+    )
+    topic: Optional[str] = Field(
+        default=None, max_length=200, description="Topic of the post"
+    )
+    tags: Optional[List[str]] = Field(
+        default=None, description="Hashtags for the post (max 5)"
+    )
+
+    @field_validator("tags")
+    @classmethod
+    def validate_tags(cls, v: Optional[List[str]]) -> Optional[List[str]]:
+        if v is not None and len(v) > 5:
+            return v[:5]
+        return v
+
+
+class ViraltestAction(Action):
+    """Sparse daily plan: only non-rest actions. Unlisted hours default to rest."""
+
+    scheduled_actions: List[ScheduledAction] = Field(
+        default_factory=list,
+        description="Actions scheduled at specific hours; unlisted hours are rest",
+    )
+
+    @field_validator("scheduled_actions")
+    @classmethod
+    def validate_no_duplicate_hours(cls, v: List[ScheduledAction]) -> List[ScheduledAction]:
+        seen: set = set()
+        deduped: List[ScheduledAction] = []
+        for a in v:
+            if a.hour not in seen:
+                seen.add(a.hour)
+                deduped.append(a)
+        return deduped
+
+
+class ViraltestObservation(Observation):
+    """Observation the agent receives after each daily step."""
+
+    current_hour: int = Field(default=0, ge=0, le=23)
+    day_of_week: int = Field(default=0, ge=0, le=6)
+    days_elapsed: int = Field(default=0, ge=0)
+    creator_energy: float = Field(default=1.0, ge=0.0, le=1.0)
+    hours_since_sleep: int = Field(default=0, ge=0, description="Hours since last sleep period")
+    sleep_debt: float = Field(default=0.0, ge=0.0, le=1.0, description="Accumulated sleep debt (0=rested, 1=severe)")
+    follower_count: int = Field(default=0, ge=0)
+    engagement_rate: float = Field(default=0.0, ge=0.0)
+    posts_today: int = Field(default=0, ge=0)
+    time_since_last_post: int = Field(default=0, ge=0)
+    trending_topics: List[str] = Field(default_factory=list)
+    content_queue_size: int = Field(default=0, ge=0)
+    last_post_type: str = Field(default="none")
+
+    tag_performance: Dict[str, float] = Field(default_factory=dict)
+    trending_tags: List[str] = Field(default_factory=list)
+
+    competitor_recent_posts: List[Dict[str, Any]] = Field(default_factory=list)
+    competitor_avg_engagement: float = Field(default=0.0, ge=0.0)
+    niche_saturation: float = Field(default=0.0, ge=0.0, le=1.0)
+
+    daily_total_engagement: float = Field(default=0.0, ge=0.0, description="Total engagement earned this day")
+    daily_posts_made: int = Field(default=0, ge=0, description="Number of posts made this day")
+    daily_energy_min: float = Field(default=1.0, ge=0.0, le=1.0, description="Lowest energy during this day")
+
+    grader_score: Optional[float] = Field(default=None, description="Final grader score (set on last step when done=True)")
+
+    error: Optional[str] = Field(default=None)

openenv.yaml

@@ -0,0 +1,7 @@
+spec_version: 1
+name: viraltest
+type: space
+runtime: fastapi
+app: server.app:app
+port: 8000
+

pyproject.toml

@@ -0,0 +1,48 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+[build-system]
+requires = ["setuptools>=45", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "openenv-viraltest"
+version = "0.1.0"
+description = "Viraltest environment for OpenEnv"
+requires-python = ">=3.10"
+dependencies = [
+    # Core OpenEnv runtime (provides FastAPI server + HTTP client types)
+    # install from github
+    # "openenv-core[core] @ git+https://github.com/meta-pytorch/OpenEnv.git",
+    "openenv-core[core]>=0.2.2",
+    # Environment-specific dependencies
+    # Add all dependencies needed for your environment here
+    # Examples:
+    # "numpy>=1.19.0",
+    # "torch>=2.0.0",
+    # "gymnasium>=0.29.0",
+    # "openspiel>=1.0.0",
+    # "smolagents>=1.22.0,<2",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-cov>=4.0.0",
+]
+
+[project.scripts]
+# Server entry point - enables running via: uv run --project . server
+# or: python -m viraltest.server.app
+server = "viraltest.server.app:main"
+
+[tool.setuptools]
+include-package-data = true
+packages = ["viraltest", "viraltest.server"]
+package-dir = { "viraltest" = ".", "viraltest.server" = "server" }
+
+[tool.setuptools.package-data]
+"viraltest.server" = ["*.html"]

server/__init__.py

@@ -0,0 +1,11 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""Viraltest environment server components."""
+
+from .viraltest_environment import ViraltestEnvironment
+
+__all__ = ["ViraltestEnvironment"]

server/app.py

@@ -0,0 +1,510 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""
+FastAPI application for the Viraltest Environment.
+
+This module creates an HTTP server that exposes the ViraltestEnvironment
+over HTTP and WebSocket endpoints, compatible with EnvClient.
+
+Endpoints:
+    - POST /reset: Reset the environment
+    - POST /step: Execute an action
+    - GET /state: Get current environment state
+    - GET /schema: Get action/observation schemas
+    - WS /ws: WebSocket endpoint for persistent sessions
+
+Usage:
+    # Development (with auto-reload):
+    uvicorn server.app:app --reload --host 0.0.0.0 --port 8000
+
+    # Production:
+    uvicorn server.app:app --host 0.0.0.0 --port 8000 --workers 4
+
+    # Or run directly:
+    python -m server.app
+"""
+
+import json
+import os
+import random as stdlib_random
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from fastapi import Body
+from fastapi.responses import HTMLResponse, JSONResponse, RedirectResponse
+
+try:
+    from openenv.core.env_server.http_server import create_app
+except Exception as e:  # pragma: no cover
+    raise ImportError(
+        "openenv is required for the web interface. Install dependencies with '\n    uv sync\n'"
+    ) from e
+
+# OpenEnv Gradio UI lives at /web; Dockerfile sets this — default on for local parity with HF Spaces.
+if "ENABLE_WEB_INTERFACE" not in os.environ:
+    os.environ["ENABLE_WEB_INTERFACE"] = "true"
+
+try:
+    from ..models import ScheduledAction, ViraltestAction, ViraltestObservation
+    from .viraltest_environment import ViraltestEnvironment
+except ImportError:
+    from models import ScheduledAction, ViraltestAction, ViraltestObservation
+    from server.viraltest_environment import ViraltestEnvironment
+
+_DASHBOARD_HTML = (Path(__file__).parent / "dashboard.html").read_text()
+
+app = create_app(
+    ViraltestEnvironment,
+    ViraltestAction,
+    ViraltestObservation,
+    env_name="viraltest",
+    max_concurrent_envs=1,
+)
+
+_gradio_web = os.getenv("ENABLE_WEB_INTERFACE", "false").lower() in ("true", "1", "yes")
+if not _gradio_web:
+
+    @app.get("/", include_in_schema=False)
+    async def _root_redirect():
+        return RedirectResponse("/dashboard", status_code=302)
+
+    @app.get("/web", include_in_schema=False)
+    @app.get("/web/", include_in_schema=False)
+    async def _web_disabled_redirect():
+        return RedirectResponse("/dashboard", status_code=302)
+
+_dash_env: Optional[ViraltestEnvironment] = None
+_HISTORY_FILE = Path(__file__).parent / "simulation_history.json"
+
+
+def _obs_to_dict(obs: ViraltestObservation) -> Dict[str, Any]:
+    return {
+        "observation": obs.model_dump(),
+        "reward": obs.reward,
+        "done": obs.done,
+    }
+
+
+def _load_history() -> List[Dict[str, Any]]:
+    if _HISTORY_FILE.exists():
+        try:
+            return json.loads(_HISTORY_FILE.read_text())
+        except (json.JSONDecodeError, OSError):
+            return []
+    return []
+
+
+def _save_history_entry(entry: Dict[str, Any]) -> None:
+    history = _load_history()
+    history.append(entry)
+    if len(history) > 100:
+        history = history[-100:]
+    _HISTORY_FILE.write_text(json.dumps(history, indent=2))
+
+
+@app.get("/dashboard", response_class=HTMLResponse)
+async def dashboard():
+    return _DASHBOARD_HTML
+
+
+@app.get("/dashboard/history")
+async def dashboard_history():
+    history = _load_history()
+    out: List[Dict[str, Any]] = []
+    for row in history:
+        entry = dict(row)
+        if not entry.get("description"):
+            sid = entry.get("scenario_id")
+            if sid and sid in SCENARIOS:
+                entry["description"] = SCENARIOS[sid][1]
+        out.append(entry)
+    return out
+
+
+@app.delete("/dashboard/history")
+async def dashboard_history_clear():
+    if _HISTORY_FILE.exists():
+        _HISTORY_FILE.unlink()
+    return {"status": "cleared"}
+
+
+@app.post("/dashboard/reset")
+async def dashboard_reset(body: Dict[str, Any] = Body(default={})):
+    global _dash_env
+    _dash_env = ViraltestEnvironment()
+    task = body.get("task", "weekly_engage")
+    obs = _dash_env.reset(task=task)
+    return _obs_to_dict(obs)
+
+
+@app.post("/dashboard/step")
+async def dashboard_step(body: Dict[str, Any] = Body(...)):
+    global _dash_env
+    if _dash_env is None:
+        _dash_env = ViraltestEnvironment()
+        _dash_env.reset()
+    action_data = body.get("action", body)
+    action = ViraltestAction(**action_data)
+    obs = _dash_env.step(action)
+    return _obs_to_dict(obs)
+
+
+try:
+    from .viraltest_environment import TAG_POOL
+except ImportError:
+    from server.viraltest_environment import TAG_POOL
+
+_SIM_RNG = stdlib_random.Random(99)
+_CONTENT_TYPES = ["reel", "carousel", "story", "text_post"]
+_TOPICS = ["AI tools", "fitness routine", "growth hacks", "travel guide", "food recipe", "wellness tips"]
+
+
+def _make_daily_plan(actions: list) -> ViraltestAction:
+    """Helper: build a ViraltestAction from a list of ScheduledAction-like dicts."""
+    return ViraltestAction(scheduled_actions=[ScheduledAction(**a) for a in actions])
+
+
+def _plan_always_rest(obs: dict, day: int) -> ViraltestAction:
+    return _make_daily_plan([])
+
+
+def _plan_spam(obs: dict, day: int) -> ViraltestAction:
+    actions = [{"hour": h, "action_type": "post", "content_type": "reel",
+                "topic": "AI tools", "tags": ["ai"]} for h in range(24)]
+    return _make_daily_plan(actions)
+
+
+def _plan_smart(obs: dict, day: int) -> ViraltestAction:
+    trending = (obs.get("trending_topics") or ["AI tools"])[0]
+    t_tags = list((obs.get("trending_tags") or [])[:2])
+    pool_tag = TAG_POOL[(day * 2) % len(TAG_POOL)]
+    pool_tag2 = TAG_POOL[(day * 2 + 1) % len(TAG_POOL)]
+    ct1 = _CONTENT_TYPES[(day * 2) % 4]
+    ct2 = _CONTENT_TYPES[(day * 2 + 1) % 4]
+    actions = [
+        {"hour": 8, "action_type": "create_content"},
+        {"hour": 12, "action_type": "post", "content_type": ct1, "topic": trending, "tags": t_tags + [pool_tag]},
+        {"hour": 19, "action_type": "post", "content_type": ct2, "topic": trending, "tags": t_tags + [pool_tag2]},
+    ]
+    return _make_daily_plan(actions)
+
+
+def _plan_no_rest(obs: dict, day: int) -> ViraltestAction:
+    actions = []
+    for h in range(24):
+        ct = _CONTENT_TYPES[h % 4]
+        topic = _SIM_RNG.choice(_TOPICS)
+        tags = _SIM_RNG.sample(TAG_POOL, 3)
+        actions.append({"hour": h, "action_type": "post", "content_type": ct, "topic": topic, "tags": tags})
+    return _make_daily_plan(actions)
+
+
+def _plan_minimal(obs: dict, day: int) -> ViraltestAction:
+    trending = (obs.get("trending_topics") or ["minimalism"])[0]
+    tags = list((obs.get("trending_tags") or [])[:3])
+    return _make_daily_plan([
+        {"hour": 12, "action_type": "post", "content_type": "carousel", "topic": trending, "tags": tags},
+    ])
+
+
+def _plan_reel_max(obs: dict, day: int) -> ViraltestAction:
+    trending = (obs.get("trending_topics") or ["viral content"])[0]
+    tags = list((obs.get("trending_tags") or [])[:3])
+    return _make_daily_plan([
+        {"hour": 12, "action_type": "post", "content_type": "reel", "topic": trending, "tags": tags},
+        {"hour": 14, "action_type": "post", "content_type": "reel", "topic": trending, "tags": tags},
+    ])
+
+
+def _plan_split_schedule(obs: dict, day: int) -> ViraltestAction:
+    trending = (obs.get("trending_topics") or ["daily content"])[0]
+    tags = list((obs.get("trending_tags") or [])[:2]) + ["tips"]
+    return _make_daily_plan([
+        {"hour": 9, "action_type": "post", "content_type": "carousel", "topic": trending, "tags": tags},
+        {"hour": 19, "action_type": "post", "content_type": "reel", "topic": trending, "tags": tags},
+    ])
+
+
+def _plan_double_peak(obs: dict, day: int) -> ViraltestAction:
+    trending = (obs.get("trending_topics") or ["peak time content"])[0]
+    tags = list((obs.get("trending_tags") or [])[:3])
+    return _make_daily_plan([
+        {"hour": 9, "action_type": "post", "content_type": "reel", "topic": trending, "tags": tags},
+        {"hour": 15, "action_type": "post", "content_type": "carousel", "topic": trending, "tags": tags},
+    ])
+
+
+def _plan_tag_explorer(obs: dict, day: int) -> ViraltestAction:
+    trending = (obs.get("trending_topics") or ["devtools"])[0]
+    start = (day * 6) % len(TAG_POOL)
+    tags1 = [TAG_POOL[(start + i) % len(TAG_POOL)] for i in range(3)]
+    tags2 = [TAG_POOL[(start + 3 + i) % len(TAG_POOL)] for i in range(3)]
+    ct1 = _CONTENT_TYPES[(day * 2) % 4]
+    ct2 = _CONTENT_TYPES[(day * 2 + 1) % 4]
+    return _make_daily_plan([
+        {"hour": 10, "action_type": "post", "content_type": ct1, "topic": trending, "tags": tags1},
+        {"hour": 18, "action_type": "post", "content_type": ct2, "topic": trending, "tags": tags2},
+    ])
+
+
+def _plan_queue_optimizer(obs: dict, day: int) -> ViraltestAction:
+    trending = (obs.get("trending_topics") or ["productivity"])[0]
+    tags = list((obs.get("trending_tags") or [])[:2]) + ["growth"]
+    queue = obs.get("content_queue_size", 0)
+    if day < 2 or queue < 2:
+        return _make_daily_plan([
+            {"hour": 8, "action_type": "create_content"},
+            {"hour": 10, "action_type": "create_content"},
+            {"hour": 14, "action_type": "create_content"},
+        ])
+    ct = _CONTENT_TYPES[day % 4]
+    return _make_daily_plan([
+        {"hour": 12, "action_type": "post", "content_type": ct, "topic": trending, "tags": tags},
+        {"hour": 19, "action_type": "post", "content_type": _CONTENT_TYPES[(day + 1) % 4], "topic": trending, "tags": tags},
+    ])
+
+
+def _plan_weekend(obs: dict, day: int) -> ViraltestAction:
+    dow = obs.get("day_of_week", 0)
+    if dow not in (5, 6):
+        return _make_daily_plan([])
+    trending = (obs.get("trending_topics") or ["travel"])[0]
+    tags = list((obs.get("trending_tags") or [])[:3])
+    return _make_daily_plan([
+        {"hour": 11, "action_type": "post", "content_type": "reel", "topic": trending, "tags": tags},
+        {"hour": 17, "action_type": "post", "content_type": "reel", "topic": trending, "tags": tags},
+    ])
+
+
+def _plan_weekday_only(obs: dict, day: int) -> ViraltestAction:
+    dow = obs.get("day_of_week", 0)
+    if dow >= 5:
+        return _make_daily_plan([])
+    trending = (obs.get("trending_topics") or ["weekday content"])[0]
+    tags = list((obs.get("trending_tags") or [])[:2]) + ["productivity"]
+    ct = _CONTENT_TYPES[day % 4]
+    return _make_daily_plan([
+        {"hour": 12, "action_type": "post", "content_type": ct, "topic": trending, "tags": tags},
+    ])
+
+
+def _plan_random(obs: dict, day: int) -> ViraltestAction:
+    actions = []
+    for h in range(24):
+        r = _SIM_RNG.random()
+        if r < 0.1:
+            ct = _SIM_RNG.choice(_CONTENT_TYPES)
+            topic = _SIM_RNG.choice(["random topic", "AI tools", "fitness", "travel"])
+            tags = _SIM_RNG.sample(TAG_POOL, 2)
+            actions.append({"hour": h, "action_type": "post", "content_type": ct, "topic": topic, "tags": tags})
+        elif r < 0.15:
+            actions.append({"hour": h, "action_type": "create_content"})
+    return _make_daily_plan(actions)
+
+
+def _plan_sleep_conscious(obs: dict, day: int) -> ViraltestAction:
+    trending = (obs.get("trending_topics") or ["wellness"])[0]
+    tags = list((obs.get("trending_tags") or [])[:2]) + ["productivity"]
+    ct = _CONTENT_TYPES[day % 4]
+    return _make_daily_plan([
+        {"hour": 10, "action_type": "post", "content_type": ct, "topic": trending, "tags": tags},
+        {"hour": 16, "action_type": "create_content"},
+    ])
+
+
+def _plan_sleep_deprived(obs: dict, day: int) -> ViraltestAction:
+    trending = (obs.get("trending_topics") or ["coding"])[0]
+    tags = list((obs.get("trending_tags") or [])[:2])
+    actions = []
+    for h in range(24):
+        if 9 <= h <= 20 and len([a for a in actions if a["action_type"] == "post"]) < 2:
+            ct = _CONTENT_TYPES[h % 4]
+            actions.append({"hour": h, "action_type": "post", "content_type": ct, "topic": trending, "tags": tags})
+        else:
+            actions.append({"hour": h, "action_type": "create_content"})
+    return _make_daily_plan(actions)
+
+
+def _plan_growth_focus(obs: dict, day: int) -> ViraltestAction:
+    trending = (obs.get("trending_topics") or ["growth hacks"])[0]
+    return _make_daily_plan([
+        {"hour": 13, "action_type": "post", "content_type": "reel", "topic": trending, "tags": ["viral", "growth", "trending"]},
+    ])
+
+
+def _plan_tech_niche(obs: dict, day: int) -> ViraltestAction:
+    ct = _CONTENT_TYPES[day % 4]
+    return _make_daily_plan([
+        {"hour": 12, "action_type": "post", "content_type": ct, "topic": "AI tools and coding tips", "tags": ["ai", "coding", "devtools"]},
+        {"hour": 18, "action_type": "post", "content_type": _CONTENT_TYPES[(day + 1) % 4], "topic": "AI tools and coding tips", "tags": ["ai", "ml", "startup"]},
+    ])
+
+
+def _plan_conservative(obs: dict, day: int) -> ViraltestAction:
+    trending = (obs.get("trending_topics") or ["quick tip"])[0]
+    tags = list((obs.get("trending_tags") or [])[:2])
+    return _make_daily_plan([
+        {"hour": 13, "action_type": "post", "content_type": "text_post", "topic": trending, "tags": tags},
+    ])
+
+
+SCENARIOS = {
+    "always_rest": ("Always Rest", "Never posts. Tests follower decay + zero engagement.", _plan_always_rest),
+    "spam": ("Spam Post", "Same reel every hour. Burns out fast.", _plan_spam),
+    "no_rest": ("No Rest", "Posts every hour, never rests. Burns out fast.", _plan_no_rest),
+    "smart": ("Smart Agent", "Optimal: peak hours, trending, varied types, rests.", _plan_smart),
+    "queue_optimizer": ("Queue Optimizer", "Creates content first, posts from queue.", _plan_queue_optimizer),
+    "weekend": ("Weekend Warrior", "Only posts on Sat/Sun.", _plan_weekend),
+    "tag_explorer": ("Tag Explorer", "New tag combo every post. Max discovery.", _plan_tag_explorer),
+    "sleep_deprived": ("Sleep Deprived", "Never rests. Tests sleep deprivation.", _plan_sleep_deprived),
+    "sleep_conscious": ("Sleep Conscious", "Proper sleep schedule.", _plan_sleep_conscious),
+    "minimal": ("Minimal Poster", "1 post per day at noon.", _plan_minimal),
+    "reel_max": ("Reel Maximizer", "Reels at peak hours for max reach.", _plan_reel_max),
+    "split_schedule": ("Split Schedule", "Morning and evening posts.", _plan_split_schedule),
+    "double_peak": ("Double Peak", "Posts at 9am and 3pm.", _plan_double_peak),
+    "growth_focus": ("Growth Focus", "Maximizes follower growth.", _plan_growth_focus),
+    "weekday_only": ("Weekday Only", "No weekend posting.", _plan_weekday_only),
+    "tech_niche": ("Tech Niche", "AI/coding content focus.", _plan_tech_niche),
+    "conservative": ("Conservative", "One text post at 1pm.", _plan_conservative),
+    "random": ("Random Actor", "Random actions. Baseline test.", _plan_random),
+}
+
+
+@app.get("/dashboard/scenarios")
+async def dashboard_scenarios():
+    """List all simulation strategies for the dashboard UI."""
+    items = [{"id": k, "label": v[0], "description": v[1]} for k, v in SCENARIOS.items()]
+    items.sort(key=lambda x: (x["label"].lower()))
+    return JSONResponse(
+        content={"count": len(items), "scenarios": items},
+        headers={"Cache-Control": "no-store, max-age=0, must-revalidate"},
+    )
+
+
+@app.post("/dashboard/simulate")
+async def dashboard_simulate(body: Dict[str, Any] = Body(...)):
+    global _SIM_RNG
+    _SIM_RNG = stdlib_random.Random(99)
+
+    scenario_id = body.get("scenario", "smart")
+    task = body.get("task", "weekly_competitive")
+    if scenario_id not in SCENARIOS:
+        return {"error": f"Unknown scenario: {scenario_id}"}
+
+    label, desc, plan_fn = SCENARIOS[scenario_id]
+    env = ViraltestEnvironment()
+    obs = env.reset(task=task, seed=42)
+    obs_dict = obs.model_dump()
+
+    steps: List[Dict[str, Any]] = []
+    for day in range(1, 8):
+        action = plan_fn(obs_dict, day)
+        obs = env.step(action)
+        obs_dict = obs.model_dump()
+        r = obs.reward if obs.reward is not None else 0.0
+
+        n_posts = len([sa for sa in action.scheduled_actions if sa.action_type == "post"])
+        n_create = len([sa for sa in action.scheduled_actions if sa.action_type == "create_content"])
+        action_str = f"day{day}(posts={n_posts},creates={n_create})"
+
+        steps.append({
+            "step": day,
+            "action": action_str,
+            "reward": round(r, 4),
+            "done": obs.done,
+            "error": obs.error,
+            "energy": round(obs.creator_energy, 3),
+            "hours_since_sleep": obs.hours_since_sleep,
+            "sleep_debt": round(obs.sleep_debt, 3),
+            "followers": obs.follower_count,
+            "engagement_rate": round(obs.engagement_rate, 4),
+            "niche_saturation": round(obs.niche_saturation, 3),
+            "posts_today": obs.posts_today,
+            "hour": obs.current_hour,
+            "day": obs.day_of_week,
+            "days_elapsed": obs.days_elapsed,
+            "queue": obs.content_queue_size,
+            "tag_performance": obs.tag_performance,
+            "trending_topics": obs.trending_topics,
+            "trending_tags": obs.trending_tags,
+            "competitor_avg_engagement": round(obs.competitor_avg_engagement, 4),
+            "daily_total_engagement": round(obs.daily_total_engagement, 4),
+            "daily_posts_made": obs.daily_posts_made,
+            "daily_energy_min": round(obs.daily_energy_min, 3),
+        })
+        if obs.done:
+            break
+
+    score = (obs.metadata or {}).get("grader_score", 0.0)
+    result = {
+        "scenario": label,
+        "description": desc,
+        "task": task,
+        "steps": steps,
+        "total_steps": len(steps),
+        "score": round(score, 4),
+        "final": {
+            "energy": round(obs.creator_energy, 3),
+            "hours_since_sleep": obs.hours_since_sleep,
+            "sleep_debt": round(obs.sleep_debt, 3),
+            "followers": obs.follower_count,
+            "engagement_rate": round(obs.engagement_rate, 4),
+            "burned_out": obs.creator_energy <= 0,
+        },
+    }
+
+    rewards = [s["reward"] for s in steps]
+    total_posts = sum(s.get("daily_posts_made", 0) for s in steps)
+    _save_history_entry({
+        "id": datetime.now(timezone.utc).isoformat(),
+        "scenario": label,
+        "scenario_id": scenario_id,
+        "description": desc,
+        "task": task,
+        "score": round(score, 4),
+        "total_steps": len(steps),
+        "total_posts": total_posts,
+        "avg_reward": round(sum(rewards) / len(rewards), 4) if rewards else 0,
+        "final": result["final"],
+    })
+
+    return result
+
+
+def main(host: str = "0.0.0.0", port: int = 8000):
+    """
+    Entry point for direct execution via uv run or python -m.
+
+    This function enables running the server without Docker:
+        uv run --project . server
+        uv run --project . server --port 8001
+        python -m viraltest.server.app
+
+    Args:
+        host: Host address to bind to (default: "0.0.0.0")
+        port: Port number to listen on (default: 8000)
+
+    For production deployments, consider using uvicorn directly with
+    multiple workers:
+        uvicorn viraltest.server.app:app --workers 4
+    """
+    import uvicorn
+
+    uvicorn.run(app, host=host, port=port)
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--port", type=int, default=None)
+    args = parser.parse_args()
+    if args.port is not None:
+        main(port=args.port)
+    else:
+        main()

server/dashboard.html

@@ -0,0 +1,1306 @@
+<!DOCTYPE html>
+<html class="dark" lang="en">
+<head>
+<meta charset="utf-8"/>
+<meta content="width=device-width,initial-scale=1.0" name="viewport"/>
+<title>Growth Copilot — Simulation</title>
+<script src="https://cdn.tailwindcss.com?plugins=forms,container-queries"></script>
+<link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;600;700;800;900&family=Space+Grotesk:wght@400;500;700&display=swap" rel="stylesheet"/>
+<link href="https://fonts.googleapis.com/css2?family=Material+Symbols+Outlined:wght,FILL@100..700,0..1&display=swap" rel="stylesheet"/>
+<script>
+tailwind.config={darkMode:"class",theme:{extend:{colors:{"surface":"#0b1326","surface-low":"#131b2e","surface-high":"#222a3d","surface-top":"#2d3449","surface-lowest":"#060e20","on-surface":"#dae2fd","on-surface-dim":"#cbc3d7","primary":"#d0bcff","primary-ctr":"#a078ff","secondary":"#7bd0ff","secondary-ctr":"#00a6e0","tertiary":"#ffb2b9","tertiary-ctr":"#ea6479","outline":"#494454","error":"#ffb4ab"},fontFamily:{headline:["Inter"],body:["Inter"],label:["Space Grotesk"]}}}}
+</script>
+<style>
+body{background:#0b1326;color:#dae2fd;font-family:'Inter',sans-serif}
+.material-symbols-outlined{font-variation-settings:'FILL' 0,'wght' 400,'GRAD' 0,'opsz' 24}
+.glass{background:rgba(34,42,61,.6);backdrop-filter:blur(24px);border:1px solid rgba(73,68,84,.2)}
+.glass-solid{background:#131b2e;border:1px solid rgba(73,68,84,.15)}
+.energy-bar{transition:width .6s ease}
+.fade-in{animation:fadeIn .3s ease}
+@keyframes fadeIn{from{opacity:0;transform:translateY(4px)}to{opacity:1;transform:translateY(0)}}
+@keyframes pulse-glow{0%,100%{box-shadow:0 0 8px rgba(208,188,255,.2)}50%{box-shadow:0 0 20px rgba(208,188,255,.4)}}
+.pulse-glow{animation:pulse-glow 2s ease-in-out infinite}
+::-webkit-scrollbar{width:6px}
+::-webkit-scrollbar-track{background:transparent}
+::-webkit-scrollbar-thumb{background:rgba(73,68,84,.4);border-radius:3px}
+.sim-btn{transition:all .2s ease}
+.sim-btn:hover{transform:translateY(-1px)}
+.action-btn{transition:all .15s ease}
+.action-btn:active{transform:scale(.97)}
+</style>
+</head>
+<body class="min-h-screen flex">
+
+<!-- Sidebar -->
+<aside class="flex flex-col sticky top-0 h-screen w-64 border-r border-white/5 bg-surface-lowest shadow-2xl shadow-slate-950/50 shrink-0 z-50">
+  <div class="p-6 pb-4">
+    <div class="text-xl font-black tracking-tighter text-transparent bg-clip-text bg-gradient-to-br from-primary to-primary-ctr mb-1">Growth Copilot</div>
+    <div class="text-[9px] font-label uppercase tracking-[.2em] text-on-surface-dim/50">Weekly growth simulation</div>
+  </div>
+  <nav class="flex-1 px-3 space-y-1">
+    <a href="/dashboard" class="flex items-center gap-3 px-4 py-2.5 rounded-lg text-primary font-bold border-r-2 border-primary bg-gradient-to-r from-primary/10 to-transparent transition-all">
+      <span class="material-symbols-outlined text-[20px]">dashboard</span><span class="font-label text-sm">Dashboard</span>
+    </a>
+    <a href="/web/" class="flex items-center gap-3 px-4 py-2.5 rounded-lg text-slate-400 font-medium hover:text-slate-200 hover:bg-white/5 transition-all">
+      <span class="material-symbols-outlined text-[20px]">web</span><span class="font-label text-sm">OpenEnv UI</span>
+    </a>
+  </nav>
+  <!-- Task Selector in Sidebar -->
+  <div class="p-4 border-t border-white/5 space-y-3">
+    <div class="text-[9px] font-label uppercase tracking-widest text-on-surface-dim/60 mb-1">Task</div>
+    <select id="taskSelect" onchange="refreshTaskScoreBlurb()" class="w-full bg-surface border border-outline/30 rounded-lg px-3 py-2 text-sm font-label focus:ring-1 focus:ring-primary focus:outline-none">
+      <option value="weekly_engage">Easy — Engage</option>
+      <option value="weekly_strategic">Medium — Strategic</option>
+      <option value="weekly_competitive" selected>Hard — Competitive</option>
+    </select>
+    <button onclick="doReset()" class="w-full py-3 rounded-lg bg-gradient-to-br from-primary to-primary-ctr text-[#23005c] font-bold text-sm hover:opacity-90 transition active:scale-[.97]">
+      <span class="material-symbols-outlined text-[16px] align-middle mr-1">restart_alt</span>Reset
+    </button>
+  </div>
+</aside>
+
+<!-- Main -->
+<div class="flex-1 flex flex-col min-w-0">
+
+  <!-- Top Bar -->
+  <header class="flex justify-between items-center px-6 h-14 border-b border-white/5 bg-surface/60 backdrop-blur-xl sticky top-0 z-40">
+    <div class="flex items-center gap-5">
+      <span id="statusDot" class="flex items-center gap-2 text-xs font-label text-secondary"><span class="w-2 h-2 rounded-full bg-secondary"></span>Ready</span>
+      <span class="text-xs font-label text-on-surface-dim">Step <span id="stepNum" class="text-on-surface font-bold">0</span> / 168</span>
+    </div>
+    <div class="flex items-center gap-3">
+      <span id="rewardBadge" class="text-xs font-label text-on-surface-dim">Last reward: —</span>
+      <span class="text-xs font-label text-on-surface-dim/40">|</span>
+      <span id="timeBadge" class="text-xs font-label text-on-surface-dim"><span class="material-symbols-outlined text-[14px] align-middle">schedule</span> <span id="timeVal">9:00</span> <span id="dayVal" class="text-on-surface-dim/60">Mon</span></span>
+    </div>
+  </header>
+
+  <main class="flex-1 p-6 space-y-5 overflow-y-auto">
+
+    <!-- Hero Stat Cards -->
+    <div class="grid grid-cols-2 md:grid-cols-3 lg:grid-cols-6 gap-4">
+
+      <!-- Energy -->
+      <div class="glass-solid relative p-4 rounded-xl overflow-hidden">
+        <div class="absolute top-3 right-3 opacity-10"><span class="material-symbols-outlined text-4xl">bolt</span></div>
+        <div class="text-[9px] font-label text-on-surface-dim uppercase tracking-widest mb-1">Energy</div>
+        <div id="energyVal" class="text-3xl font-black tracking-tight">1.00</div>
+        <div class="mt-3 h-2 bg-surface-top rounded-full overflow-hidden">
+          <div id="energyBar" class="h-full bg-gradient-to-r from-tertiary-ctr to-tertiary energy-bar rounded-full" style="width:100%"></div>
+        </div>
+        <div id="energyHint" class="mt-1.5 text-[9px] font-label text-tertiary">FULL</div>
+      </div>
+
+      <!-- Followers -->
+      <div class="glass-solid relative p-4 rounded-xl overflow-hidden">
+        <div class="absolute top-3 right-3 opacity-10"><span class="material-symbols-outlined text-4xl">group</span></div>
+        <div class="text-[9px] font-label text-on-surface-dim uppercase tracking-widest mb-1">Followers</div>
+        <div id="followersVal" class="text-3xl font-black tracking-tight">10,000</div>
+        <div id="followersDelta" class="mt-1.5 text-[9px] font-label text-on-surface-dim">+0 since start</div>
+      </div>
+
+      <!-- Engagement -->
+      <div class="glass-solid relative p-4 rounded-xl overflow-hidden">
+        <div class="absolute top-3 right-3 opacity-10"><span class="material-symbols-outlined text-4xl">trending_up</span></div>
+        <div class="text-[9px] font-label text-on-surface-dim uppercase tracking-widest mb-1">Engagement</div>
+        <div id="engVal" class="text-3xl font-black tracking-tight text-secondary">0.000</div>
+        <div id="engVsComp" class="mt-1.5 text-[9px] font-label text-on-surface-dim">vs competitors: —</div>
+      </div>
+
+      <!-- Posts Today -->
+      <div class="glass-solid relative p-4 rounded-xl overflow-hidden">
+        <div class="absolute top-3 right-3 opacity-10"><span class="material-symbols-outlined text-4xl">send</span></div>
+        <div class="text-[9px] font-label text-on-surface-dim uppercase tracking-widest mb-1">Posts Today</div>
+        <div id="postsVal" class="text-3xl font-black tracking-tight">0</div>
+        <div class="mt-1.5 text-[9px] font-label text-on-surface-dim">max 2-3 optimal</div>
+      </div>
+
+      <!-- Queue -->
+      <div class="glass-solid relative p-4 rounded-xl overflow-hidden">
+        <div class="absolute top-3 right-3 opacity-10"><span class="material-symbols-outlined text-4xl">inventory_2</span></div>
+        <div class="text-[9px] font-label text-on-surface-dim uppercase tracking-widest mb-1">Content Queue</div>
+        <div id="queueVal" class="text-3xl font-black tracking-tight text-secondary">0</div>
+        <div class="mt-1.5 text-[9px] font-label text-on-surface-dim">posts cost 50% less</div>
+      </div>
+
+      <!-- Saturation -->
+      <div class="glass-solid relative p-4 rounded-xl overflow-hidden">
+        <div class="absolute top-3 right-3 opacity-10"><span class="material-symbols-outlined text-4xl">layers</span></div>
+        <div class="text-[9px] font-label text-on-surface-dim uppercase tracking-widest mb-1">Niche Saturation</div>
+        <div id="satVal" class="text-3xl font-black tracking-tight text-primary">0.00</div>
+        <div id="satHint" class="mt-1.5 text-[9px] font-label text-primary">LOW — post unique topics</div>
+      </div>
+    </div>
+
+    <div class="glass-solid border border-outline/20 rounded-xl px-4 py-3 space-y-3">
+      <div class="flex gap-3 items-start">
+        <span class="material-symbols-outlined text-secondary text-lg shrink-0">info</span>
+        <p class="text-[11px] font-label text-on-surface-dim leading-relaxed flex-1 min-w-0">
+          <span class="text-on-surface font-semibold">Simulation only</span> — not live social data. Each <span class="text-on-surface">step</span> is ~1 hour; <span class="text-on-surface">Post</span> drives engagement and tags; <span class="text-on-surface">Rest</span> restores energy while rivals keep posting.
+        </p>
+      </div>
+      <div class="border-t border-white/5 pt-3 space-y-2">
+        <div class="text-[10px] font-bold text-on-surface uppercase tracking-widest">Niche saturation</div>
+        <p class="text-[10px] font-label text-on-surface-dim leading-relaxed">
+          Shown after each step for your <span class="text-on-surface">last post topic</span>. The sim collects competitor posts from the last <span class="text-on-surface">12 simulated hours</span>, counts how many topics overlap yours (≥50% shared words), and divides by the number of those recent competitor posts. Result is capped at 1.0. High saturation usually means more crowd overlap; the environment can lower engagement when you post into a crowded topic.
+        </p>
+      </div>
+      <div class="border-t border-white/5 pt-3 space-y-2">
+        <div class="text-[10px] font-bold text-on-surface uppercase tracking-widest">Final score &amp; viral meter</div>
+        <p id="taskScoreBlurb" class="text-[10px] font-label text-on-surface-dim leading-relaxed"></p>
+        <p class="text-[10px] font-label text-on-surface-dim leading-relaxed">
+          <span class="text-on-surface font-semibold">Viral probability</span> (dashboard only): <code class="text-on-surface/90">min(100, round(engagement_rate × 1000))</code> with LOW / MEDIUM / HIGH labels at 40% and 70%. It is not the grader and not a forecast of real-world reach.
+        </p>
+      </div>
+    </div>
+
+    <!-- Charts Row -->
+    <div class="grid grid-cols-1 lg:grid-cols-3 gap-4">
+      <!-- Reward history chart -->
+      <div class="lg:col-span-2 glass-solid p-5 rounded-xl overflow-hidden">
+        <div class="flex justify-between items-center mb-2">
+          <div>
+            <h3 class="text-sm font-bold">Reward history</h3>
+            <p class="text-[10px] text-on-surface-dim mt-0.5">Per-step RL reward after each action (axes: step index × reward)</p>
+          </div>
+          <span class="flex items-center gap-1.5 text-[10px] font-label text-on-surface-dim"><span class="w-2 h-2 rounded-full bg-secondary"></span>Reward</span>
+        </div>
+        <div class="h-52 relative">
+          <svg id="engagementChart" class="w-full h-full" viewBox="0 0 760 208" preserveAspectRatio="xMidYMid meet"></svg>
+        </div>
+      </div>
+
+      <!-- Burnout Meter -->
+      <div class="glass-solid p-5 rounded-xl flex flex-col items-center overflow-hidden">
+        <div class="flex justify-between items-center w-full mb-3">
+          <h3 class="text-sm font-bold">Burnout Meter</h3>
+          <span class="material-symbols-outlined text-tertiary text-lg">monitor_heart</span>
+        </div>
+        <div class="relative w-40 h-40 mb-3">
+          <svg viewBox="0 0 120 120" class="w-full h-full -rotate-90">
+            <circle cx="60" cy="60" r="50" fill="none" stroke="#222a3d" stroke-width="10"/>
+            <circle id="burnoutArc" cx="60" cy="60" r="50" fill="none" stroke="url(#burnoutGrad)" stroke-width="10" stroke-linecap="round" stroke-dasharray="0 314" style="transition:stroke-dasharray .6s ease"/>
+            <defs><linearGradient id="burnoutGrad" x1="0%" y1="0%" x2="100%" y2="0%"><stop offset="0%" style="stop-color:#ffb2b9"/><stop offset="100%" style="stop-color:#ea6479"/></linearGradient></defs>
+          </svg>
+          <div class="absolute inset-0 flex flex-col items-center justify-center">
+            <span id="burnoutPct" class="text-4xl font-black tracking-tight">0%</span>
+            <span class="text-[8px] font-label text-tertiary uppercase tracking-widest mt-0.5">Cortisol Level</span>
+          </div>
+        </div>
+        <div id="burnoutRec" class="p-3 rounded-lg bg-surface border border-outline/15 text-[10px] font-label text-on-surface-dim text-center leading-relaxed w-full">
+          Recommendation: Start with a balanced create-rest cycle.
+        </div>
+      </div>
+    </div>
+
+    <!-- Second Charts Row -->
+    <div class="grid grid-cols-1 lg:grid-cols-3 gap-4">
+      <!-- Follower Growth -->
+      <div class="glass-solid p-5 rounded-xl overflow-hidden">
+        <h3 class="text-sm font-bold mb-3">Follower Growth</h3>
+        <div class="h-32 relative">
+          <svg id="followerChart" class="w-full h-full" viewBox="0 0 300 120" preserveAspectRatio="xMidYMid meet"></svg>
+        </div>
+        <div class="flex items-baseline gap-3 mt-2">
+          <span id="followerTotal" class="text-2xl font-black tracking-tight text-secondary">+0</span>
+          <span id="followerDeltaPct" class="text-xs font-label text-secondary/60">+0% vs start</span>
+        </div>
+      </div>
+
+      <!-- Top Performing Tags -->
+      <div class="glass-solid p-5 rounded-xl overflow-hidden">
+        <h3 class="text-sm font-bold mb-3">Top Performing Tags</h3>
+        <div id="topTagsList" class="space-y-3">
+          <div class="text-on-surface-dim italic text-[10px]">No tag data yet</div>
+        </div>
+      </div>
+
+      <!-- Recent RL Actions -->
+      <div class="glass-solid p-5 rounded-xl overflow-hidden">
+        <h3 class="text-sm font-bold mb-3">Recent RL Actions</h3>
+        <div id="recentActions" class="space-y-3 max-h-44 overflow-y-auto">
+          <div class="text-on-surface-dim italic text-[10px]">No actions yet</div>
+        </div>
+      </div>
+    </div>
+
+    <!-- Step & hour analytics -->
+    <div class="space-y-3">
+      <div class="flex items-center gap-2 px-1">
+        <span class="material-symbols-outlined text-secondary text-lg">show_chart</span>
+        <h2 class="text-sm font-bold">Step &amp; hour analytics</h2>
+        <span class="text-[9px] font-label text-on-surface-dim uppercase tracking-widest">X = simulation step (~1h); posts histogram = clock hour (0–23)</span>
+      </div>
+      <div class="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-3 xl:grid-cols-3 gap-3">
+        <div class="glass-solid p-4 rounded-xl overflow-hidden">
+          <div class="text-[10px] font-bold text-on-surface-dim uppercase tracking-widest mb-1">Energy / step</div>
+          <svg id="tsEnergy" class="w-full h-24" viewBox="0 0 360 112" preserveAspectRatio="xMidYMid meet"></svg>
+        </div>
+        <div class="glass-solid p-4 rounded-xl overflow-hidden">
+          <div class="text-[10px] font-bold text-on-surface-dim uppercase tracking-widest mb-1">Followers / step</div>
+          <svg id="tsFollowers" class="w-full h-24" viewBox="0 0 360 112" preserveAspectRatio="xMidYMid meet"></svg>
+        </div>
+        <div class="glass-solid p-4 rounded-xl overflow-hidden">
+          <div class="text-[10px] font-bold text-on-surface-dim uppercase tracking-widest mb-1">Follower Δ / step</div>
+          <svg id="tsFollowDelta" class="w-full h-24" viewBox="0 0 360 112" preserveAspectRatio="xMidYMid meet"></svg>
+        </div>
+        <div class="glass-solid p-4 rounded-xl overflow-hidden">
+          <div class="text-[10px] font-bold text-on-surface-dim uppercase tracking-widest mb-1">Engagement rate / step</div>
+          <svg id="tsEngagement" class="w-full h-24" viewBox="0 0 360 112" preserveAspectRatio="xMidYMid meet"></svg>
+        </div>
+        <div class="glass-solid p-4 rounded-xl overflow-hidden">
+          <div class="text-[10px] font-bold text-on-surface-dim uppercase tracking-widest mb-1">Reward / step</div>
+          <svg id="tsReward" class="w-full h-24" viewBox="0 0 360 112" preserveAspectRatio="xMidYMid meet"></svg>
+        </div>
+        <div class="glass-solid p-4 rounded-xl overflow-hidden">
+          <div class="text-[10px] font-bold text-on-surface-dim uppercase tracking-widest mb-1">Niche saturation / step</div>
+          <svg id="tsSat" class="w-full h-24" viewBox="0 0 360 112" preserveAspectRatio="xMidYMid meet"></svg>
+        </div>
+        <div class="glass-solid p-4 rounded-xl overflow-hidden">
+          <div class="text-[10px] font-bold text-on-surface-dim uppercase tracking-widest mb-1">Content queue / step</div>
+          <svg id="tsQueue" class="w-full h-24" viewBox="0 0 360 112" preserveAspectRatio="xMidYMid meet"></svg>
+        </div>
+        <div class="glass-solid p-4 rounded-xl overflow-hidden">
+          <div class="text-[10px] font-bold text-on-surface-dim uppercase tracking-widest mb-1">Competitor avg engagement / step</div>
+          <svg id="tsComp" class="w-full h-24" viewBox="0 0 360 112" preserveAspectRatio="xMidYMid meet"></svg>
+        </div>
+        <div class="glass-solid p-4 rounded-xl overflow-hidden">
+          <div class="text-[10px] font-bold text-on-surface-dim uppercase tracking-widest mb-1">Sleep debt / step</div>
+          <svg id="tsSleep" class="w-full h-24" viewBox="0 0 360 112" preserveAspectRatio="xMidYMid meet"></svg>
+        </div>
+        <div class="glass-solid p-4 rounded-xl overflow-hidden">
+          <div class="text-[10px] font-bold text-on-surface-dim uppercase tracking-widest mb-1">Hours since sleep / step</div>
+          <svg id="tsAwake" class="w-full h-24" viewBox="0 0 360 112" preserveAspectRatio="xMidYMid meet"></svg>
+        </div>
+        <div class="glass-solid p-4 rounded-xl overflow-hidden">
+          <div class="text-[10px] font-bold text-on-surface-dim uppercase tracking-widest mb-1">Posts by clock hour (0–23)</div>
+          <svg id="tsPostsHour" class="w-full h-20" viewBox="0 0 320 72" preserveAspectRatio="xMidYMid meet"></svg>
+          <div class="text-[10px] font-bold text-on-surface-dim uppercase tracking-widest mt-2 mb-0.5">Action counts (run)</div>
+          <svg id="tsActionMix" class="w-full h-14" viewBox="0 0 320 52" preserveAspectRatio="xMidYMid meet"></svg>
+        </div>
+      </div>
+    </div>
+
+    <!-- Bottom Stats -->
+    <div class="grid grid-cols-1 md:grid-cols-3 gap-4">
+      <div class="glass-solid p-4 rounded-xl overflow-hidden">
+        <div class="text-[9px] font-label text-on-surface-dim uppercase tracking-widest mb-1">Avg Reward</div>
+        <div id="bottomAvgReward" class="text-3xl font-black tracking-tight">0.00</div>
+        <div id="bottomAvgDelta" class="text-[10px] font-label text-on-surface-dim mt-1">—</div>
+      </div>
+      <div class="glass-solid p-4 rounded-xl overflow-hidden">
+        <div class="text-[9px] font-label text-on-surface-dim uppercase tracking-widest mb-1">Total Posts</div>
+        <div id="bottomTotalPosts" class="text-3xl font-black tracking-tight">0</div>
+        <div class="text-[10px] font-label text-on-surface-dim mt-1">across episode</div>
+      </div>
+      <div class="glass-solid relative p-4 rounded-xl overflow-hidden">
+        <div class="text-[9px] font-label text-on-surface-dim uppercase tracking-widest mb-1">Viral Probability</div>
+        <div id="bottomViralProb" class="text-3xl font-black tracking-tight">LOW (0%)</div>
+        <p id="viralFormulaNote" class="text-[9px] font-label text-on-surface-dim/90 leading-snug mt-2">From current engagement rate only (UI heuristic).</p>
+        <div class="absolute bottom-0 right-0 w-2/3 h-10 opacity-30 pointer-events-none">
+          <svg viewBox="0 0 200 30" class="w-full h-full" preserveAspectRatio="none">
+            <defs><linearGradient id="viralGrad" x1="0%" y1="0%" x2="100%" y2="0%"><stop offset="0%" style="stop-color:#d0bcff;stop-opacity:.5"/><stop offset="50%" style="stop-color:#ea6479;stop-opacity:.5"/><stop offset="100%" style="stop-color:#7bd0ff;stop-opacity:.5"/></linearGradient></defs>
+            <path d="M0,25 Q30,5 60,20 Q90,30 120,10 Q150,0 180,15 Q200,25 200,30 L0,30Z" fill="url(#viralGrad)"/>
+          </svg>
+        </div>
+      </div>
+    </div>
+
+    <!-- Main Grid: Actions / History / Intelligence -->
+    <div class="grid grid-cols-1 lg:grid-cols-12 gap-5">
+
+      <!-- Left: Actions + History -->
+      <div class="lg:col-span-8 space-y-5">
+
+        <!-- Action Panel -->
+        <div class="glass-solid p-5 rounded-xl overflow-hidden">
+          <h3 class="text-sm font-bold mb-4 flex items-center gap-2"><span class="material-symbols-outlined text-primary text-lg">gamepad</span>Send Action</h3>
+          <div class="grid grid-cols-3 gap-3 mb-3">
+            <button type="button" title="Advance one hour, recover energy, reduce burnout. Competitors still simulate." onclick="doAction('rest')" class="action-btn group p-4 rounded-xl bg-gradient-to-br from-tertiary/5 to-tertiary/10 border border-tertiary/15 hover:border-tertiary/40 hover:from-tertiary/10 hover:to-tertiary/20 text-center">
+              <span class="material-symbols-outlined text-tertiary text-3xl group-hover:scale-110 transition-transform">hotel</span>
+              <div class="text-sm font-bold text-tertiary mt-1">Rest</div>
+              <div class="text-[9px] text-on-surface-dim mt-0.5">+0.12 energy recovery</div>
+            </button>
+            <button type="button" title="Add one item to the queue. Costs a little energy; use before Post for cheaper publishes." onclick="doAction('create_content')" class="action-btn group p-4 rounded-xl bg-gradient-to-br from-secondary/5 to-secondary/10 border border-secondary/15 hover:border-secondary/40 hover:from-secondary/10 hover:to-secondary/20 text-center">
+              <span class="material-symbols-outlined text-secondary text-3xl group-hover:scale-110 transition-transform">edit_note</span>
+              <div class="text-sm font-bold text-secondary mt-1">Create</div>
+              <div class="text-[9px] text-on-surface-dim mt-0.5">-0.05 energy, +1 queue</div>
+            </button>
+            <button type="button" title="Publish to the feed: choose format, topic, and tags. Drives engagement and tag stats." onclick="showPostForm()" id="postBtn" class="action-btn group p-4 rounded-xl bg-gradient-to-br from-primary/5 to-primary/10 border border-primary/15 hover:border-primary/40 hover:from-primary/10 hover:to-primary/20 text-center">
+              <span class="material-symbols-outlined text-primary text-3xl group-hover:scale-110 transition-transform">send</span>
+              <div class="text-sm font-bold text-primary mt-1">Post</div>
+              <div class="text-[9px] text-on-surface-dim mt-0.5">type + topic + tags</div>
+            </button>
+          </div>
+          <!-- Post Form -->
+          <div id="postForm" class="hidden fade-in space-y-2.5 p-4 rounded-xl bg-surface border border-outline/30">
+            <div class="grid grid-cols-2 gap-2.5">
+              <select id="contentType" class="bg-surface-low border border-outline/30 rounded-lg px-3 py-2 text-sm font-label focus:ring-1 focus:ring-primary focus:outline-none">
+                <option value="reel">Reel (-0.25 energy)</option>
+                <option value="carousel">Carousel (-0.20)</option>
+                <option value="story">Story (-0.08)</option>
+                <option value="text_post">Text Post (-0.06)</option>
+              </select>
+              <input id="topicInput" class="bg-surface-low border border-outline/30 rounded-lg px-3 py-2 text-sm focus:ring-1 focus:ring-primary focus:outline-none" placeholder="Topic (e.g. AI trends)"/>
+            </div>
+            <input id="tagsInput" class="w-full bg-surface-low border border-outline/30 rounded-lg px-3 py-2 text-sm focus:ring-1 focus:ring-primary focus:outline-none" placeholder="Tags comma-separated (ai, ml, coding)"/>
+            <div class="flex gap-2">
+              <button type="button" onclick="doPost()" class="px-5 py-2 rounded-lg bg-primary text-[#23005c] font-bold text-sm hover:opacity-90 transition">Send Post</button>
+              <button type="button" onclick="hidePostForm()" class="px-5 py-2 rounded-lg border border-outline/30 text-sm text-on-surface-dim hover:bg-white/5 transition">Cancel</button>
+            </div>
+          </div>
+        </div>
+
+        <!-- Simulate Scenarios (loaded from /dashboard/scenarios) -->
+        <div class="glass-solid p-5 rounded-xl overflow-hidden">
+          <div class="flex flex-wrap justify-between items-center gap-2 mb-3">
+            <h3 class="text-sm font-bold flex items-center gap-2"><span class="material-symbols-outlined text-secondary text-lg">science</span>Simulate Scenarios</h3>
+            <div class="flex flex-col items-end gap-0.5">
+              <div class="flex items-center gap-2">
+                <span id="scenarioCount" class="text-[9px] font-label text-primary font-bold">…</span>
+                <span class="text-[9px] font-label text-on-surface-dim">168-step episode</span>
+              </div>
+              <span class="text-[8px] font-label text-on-surface-dim/70 max-w-[16rem] text-right leading-tight">All strategies below — scroll the grid or search. Count updates after load.</span>
+            </div>
+          </div>
+          <div class="mb-3 space-y-2">
+            <div class="text-[9px] font-label text-on-surface-dim uppercase tracking-widest">Suggested — Easy</div>
+            <div class="flex flex-wrap gap-2">
+              <button type="button" class="sim-btn px-2.5 py-1.5 rounded-lg bg-tertiary/10 border border-tertiary/25 text-[10px] font-label text-tertiary hover:bg-tertiary/20" onclick="runSim('easy_morning_story')">Morning story</button>
+              <button type="button" class="sim-btn px-2.5 py-1.5 rounded-lg bg-tertiary/10 border border-tertiary/25 text-[10px] font-label text-tertiary hover:bg-tertiary/20" onclick="runSim('easy_one_a_day')">One text @ 1pm</button>
+              <button type="button" class="sim-btn px-2.5 py-1.5 rounded-lg bg-tertiary/10 border border-tertiary/25 text-[10px] font-label text-tertiary hover:bg-tertiary/20" onclick="runSim('easy_relaxed')">Afternoon story</button>
+            </div>
+            <div class="text-[9px] font-label text-on-surface-dim uppercase tracking-widest">Suggested — Medium</div>
+            <div class="flex flex-wrap gap-2">
+              <button type="button" class="sim-btn px-2.5 py-1.5 rounded-lg bg-secondary/10 border border-secondary/25 text-[10px] font-label text-secondary hover:bg-secondary/20" onclick="runSim('medium_queue_cycle')">Create → post</button>
+              <button type="button" class="sim-btn px-2.5 py-1.5 rounded-lg bg-secondary/10 border border-secondary/25 text-[10px] font-label text-secondary hover:bg-secondary/20" onclick="runSim('medium_trend_rotate')">Trend + formats</button>
+              <button type="button" class="sim-btn px-2.5 py-1.5 rounded-lg bg-secondary/10 border border-secondary/25 text-[10px] font-label text-secondary hover:bg-secondary/20" onclick="runSim('medium_two_format')">Reel + carousel</button>
+            </div>
+          </div>
+          <input type="search" id="scenarioFilter" autocomplete="off" placeholder="Search strategies by name or description…" class="w-full mb-2 bg-surface-low border border-outline/30 rounded-lg px-3 py-2 text-sm focus:ring-1 focus:ring-primary focus:outline-none"/>
+          <div id="scenarioGrid" tabindex="0" role="region" aria-label="Strategy list, scroll for all scenarios" class="grid grid-cols-2 sm:grid-cols-3 lg:grid-cols-4 gap-2 mb-3 max-h-[min(52vh,36rem)] min-h-[14rem] overflow-y-auto overscroll-y-contain pr-1 py-1 rounded-lg border border-outline/15 bg-surface-low/40 scrollbar-thin shadow-inner">
+            <div class="col-span-full text-on-surface-dim text-[10px] italic py-4 text-center">Loading strategies…</div>
+          </div>
+          <!-- Sim Progress -->
+          <div id="simProgress" class="hidden">
+            <div class="flex items-center gap-3 mb-2">
+              <div class="h-2 flex-1 bg-surface-top rounded-full overflow-hidden"><div id="simBar" class="h-full bg-gradient-to-r from-primary to-secondary transition-all duration-100 rounded-full" style="width:0%"></div></div>
+              <span id="simPct" class="text-[10px] font-label text-on-surface-dim w-8 text-right">0%</span>
+            </div>
+            <div id="simResult" class="hidden"></div>
+          </div>
+        </div>
+
+        <!-- Step History -->
+        <div class="glass-solid rounded-xl overflow-hidden">
+          <div class="p-4 border-b border-white/5 flex justify-between items-center">
+            <h3 class="text-sm font-bold flex items-center gap-2"><span class="material-symbols-outlined text-on-surface-dim text-lg">history</span>Step History</h3>
+          </div>
+          <div id="historyLog" class="p-4 space-y-1.5 max-h-72 overflow-y-auto text-[11px] font-mono leading-relaxed">
+            <div class="text-on-surface-dim italic">Reset the environment to begin...</div>
+          </div>
+        </div>
+      </div>
+
+      <!-- Right: Intelligence Panels -->
+      <div class="lg:col-span-4 space-y-5">
+
+        <!-- Grader Score (shown when done) -->
+        <div id="graderCard" class="hidden glass-solid p-5 rounded-xl border-2 border-primary pulse-glow overflow-hidden">
+          <div class="flex justify-between items-start">
+            <div>
+              <div class="text-[9px] font-label text-primary uppercase tracking-widest">Final Score</div>
+              <div id="graderScore" class="text-5xl font-black text-primary tracking-tighter mt-1">—</div>
+            </div>
+            <span class="material-symbols-outlined text-primary/20 text-5xl">emoji_events</span>
+          </div>
+          <div id="graderLabel" class="mt-2 text-xs font-label text-on-surface-dim">Episode complete</div>
+        </div>
+
+        <!-- Trending -->
+        <div class="glass-solid p-5 rounded-xl overflow-hidden">
+          <h3 class="text-sm font-bold mb-3 flex items-center gap-2"><span class="material-symbols-outlined text-secondary text-lg">trending_up</span>Trending Now</h3>
+          <div class="mb-3">
+            <div class="text-[9px] font-label text-on-surface-dim uppercase tracking-widest mb-1.5">Topics</div>
+            <div id="trendTopics" class="flex flex-wrap gap-1.5"></div>
+          </div>
+          <div>
+            <div class="text-[9px] font-label text-on-surface-dim uppercase tracking-widest mb-1.5">Tags</div>
+            <div id="trendTags" class="flex flex-wrap gap-1.5"></div>
+          </div>
+        </div>
+
+        <!-- Tag Performance -->
+        <div class="glass-solid p-5 rounded-xl overflow-hidden">
+          <h3 class="text-sm font-bold mb-3 flex items-center gap-2"><span class="material-symbols-outlined text-primary text-lg">science</span>Tag Performance</h3>
+          <div id="tagPerf" class="space-y-2.5 text-xs">
+            <div class="text-on-surface-dim italic">No data yet</div>
+          </div>
+        </div>
+
+        <!-- Competitors -->
+        <div class="glass-solid p-5 rounded-xl overflow-hidden">
+          <h3 class="text-sm font-bold mb-3 flex items-center gap-2"><span class="material-symbols-outlined text-tertiary text-lg">groups</span>Competitors</h3>
+          <div class="mb-3 flex justify-between items-center">
+            <span class="text-[9px] font-label text-on-surface-dim uppercase tracking-widest">Avg Engagement</span>
+            <span id="compEng" class="text-sm font-bold text-tertiary">0.000</span>
+          </div>
+          <div id="compPosts" class="space-y-2 text-xs">
+            <div class="text-on-surface-dim italic">No competitor posts yet</div>
+          </div>
+        </div>
+      </div>
+    </div>
+
+    <!-- Simulation History -->
+    <div class="glass-solid rounded-xl overflow-hidden">
+      <div class="p-4 border-b border-white/5 flex justify-between items-center">
+        <h3 class="text-sm font-bold flex items-center gap-2"><span class="material-symbols-outlined text-primary text-lg">history</span>Simulation History</h3>
+        <div class="flex items-center gap-2">
+          <button onclick="loadHistory()" class="text-[9px] font-label text-secondary hover:text-secondary/80 transition">Refresh</button>
+          <button onclick="clearHistory()" class="text-[9px] font-label text-on-surface-dim/50 hover:text-tertiary transition">Clear</button>
+        </div>
+      </div>
+      <div class="overflow-x-auto">
+        <table class="w-full text-[11px] font-label">
+          <thead>
+            <tr class="text-on-surface-dim/60 uppercase tracking-wider border-b border-white/5">
+              <th class="text-left px-4 py-2.5">Time</th>
+              <th class="text-left px-4 py-2.5">Scenario</th>
+              <th class="text-left px-4 py-2.5">Task</th>
+              <th class="text-right px-4 py-2.5">Score</th>
+              <th class="text-right px-4 py-2.5">Steps</th>
+              <th class="text-right px-4 py-2.5">Posts</th>
+              <th class="text-right px-4 py-2.5">Followers</th>
+              <th class="text-right px-4 py-2.5">Delta</th>
+              <th class="text-right px-4 py-2.5">Energy</th>
+              <th class="text-center px-4 py-2.5">Status</th>
+            </tr>
+          </thead>
+          <tbody id="historyTable">
+            <tr><td colspan="10" class="px-4 py-6 text-center text-on-surface-dim italic">No history yet — run a simulation</td></tr>
+          </tbody>
+        </table>
+      </div>
+    </div>
+
+  </main>
+</div>
+
+<script>
+const API=window.location.origin;
+const DAYS=["Mon","Tue","Wed","Thu","Fri","Sat","Sun"];
+function fmtAxisNum(v){
+  const a=Math.abs(v);
+  if(a>=1e6)return (v/1e6).toFixed(1)+"M";
+  if(a>=1e3)return (v/1e3).toFixed(1)+"k";
+  if(a>=100)return v.toFixed(0);
+  if(a>=10)return v.toFixed(1);
+  return v.toFixed(2);
+}
+function refreshTaskScoreBlurb(){
+  const el=document.getElementById("taskScoreBlurb");
+  if(!el)return;
+  const t=document.getElementById("taskSelect").value;
+  if(t==="weekly_engage"){
+    el.innerHTML="<span class=\"text-on-surface font-semibold\">Easy (Engage):</span> final score = min(1, total episode engagement ÷ theoretical maximum). If energy hits 0 at the end, the score is multiplied by 0.3.";
+  }else if(t==="weekly_strategic"){
+    el.innerHTML="<span class=\"text-on-surface font-semibold\">Medium (Strategic):</span> 35% normalized engagement + 25% tag mix (discovery + top-tag performance) + 25% average energy + 15% days with solid posts. Penalties if energy ever crashes low or you use fewer than 5 unique tags.";
+  }else{
+    el.innerHTML="<span class=\"text-on-surface font-semibold\">Hard (Competitive):</span> 25% engagement + 20% tags + 20% follower growth + 15% beating rival avg engagement + 10% differentiated topics + 10% minimum energy floor. Score is 0 if burned out; ×0.5 if fewer than 3 content types; ×0.7 if fewer than 8 unique tags.";
+  }
+}
+let currentObs=null;
+const energyHistory=[];
+const rewardHistory=[];
+const followerHistory=[];
+const actionLog=[];
+const timelineHistory=[];
+let totalPostsCount=0;
+
+function recordTimelineFromObs(d, actionType){
+  const o=d.observation||d;
+  const step=o.metadata?.step??timelineHistory.length;
+  timelineHistory.push({
+    step,
+    simHour:(o.days_elapsed??0)*24+(o.current_hour??0),
+    hour:o.current_hour??0,
+    day:o.day_of_week??0,
+    energy:o.creator_energy??0,
+    followers:o.follower_count??0,
+    engagement:o.engagement_rate??0,
+    reward:d.reward??0,
+    sat:o.niche_saturation??0,
+    queue:o.content_queue_size??0,
+    postsToday:o.posts_today??0,
+    compAvg:o.competitor_avg_engagement??0,
+    sleepDebt:o.sleep_debt??0,
+    hoursSinceSleep:o.hours_since_sleep??0,
+    action:actionType||null,
+  });
+}
+
+function simActionType(actionStr){
+  const a=actionStr||"";
+  if(a.startsWith("post"))return "post";
+  if(a.startsWith("rest"))return "rest";
+  if(a.startsWith("create"))return "create_content";
+  return null;
+}
+
+function redrawTimelineCharts(){
+  drawStepLineChart("tsEnergy","energy","#ffb2b9");
+  drawStepLineChart("tsFollowers","followers","#7bd0ff");
+  drawFollowerDeltaChart("tsFollowDelta");
+  drawStepLineChart("tsEngagement","engagement","#a078ff");
+  drawStepLineChart("tsReward","reward","#d0bcff");
+  drawStepLineChart("tsSat","sat","#ea6479");
+  drawStepLineChart("tsQueue","queue","#00a6e0");
+  drawStepLineChart("tsComp","compAvg","#7bd0ff");
+  drawStepLineChart("tsSleep","sleepDebt","#958ea0");
+  drawStepLineChart("tsAwake","hoursSinceSleep","#cbc3d7");
+  drawPostsByHour("tsPostsHour");
+  drawActionMix("tsActionMix");
+}
+
+function drawStepLineChart(svgId,key,color){
+  const svg=document.getElementById(svgId);
+  const data=timelineHistory;
+  if(!svg)return;
+  const W=360,H=112,pL=48,pR=10,pT=10,pB=28;
+  const plotW=W-pL-pR,plotH=H-pT-pB;
+  if(!data.length){
+    svg.innerHTML=`<text x="${W/2}" y="${H/2}" text-anchor="middle" fill="#958ea0" font-size="10" font-family="Space Grotesk,sans-serif">No steps yet</text>`;
+    return;
+  }
+  const vals=data.map(d=>Number(d[key]??0));
+  let minV=Math.min(...vals),maxV=Math.max(...vals);
+  if(maxV-minV<1e-9){minV-=0.5;maxV+=0.5;}
+  const n=data.length;
+  const pts=data.map((d,i)=>{
+    const x=pL+(n<=1?plotW/2:i/(n-1)*plotW);
+    const v=Number(d[key]??0);
+    const y=pT+(1-(v-minV)/(maxV-minV))*plotH;
+    return {x,y};
+  });
+  let lineD;
+  if(pts.length===1)lineD=`M${pts[0].x},${pts[0].y} L${(pts[0].x+1)},${pts[0].y}`;
+  else lineD=smoothPath(pts);
+  const last=pts[pts.length-1],first=pts[0];
+  const areaD=lineD+` L${last.x},${H-pB} L${first.x},${H-pB} Z`;
+  const gid="g_"+svgId.replace(/[^a-zA-Z0-9_]/g,"_");
+  let h="";
+  for(let g=0;g<=4;g++){
+    const y=pT+(g/4)*plotH;
+    const val=maxV-(g/4)*(maxV-minV);
+    h+=`<line x1="${pL}" y1="${y}" x2="${W-pR}" y2="${y}" stroke="#494454" stroke-width="0.5" opacity="0.35"/>`;
+    h+=`<text x="${pL-5}" y="${y+3}" text-anchor="end" fill="#958ea0" font-size="8" font-family="Space Grotesk,sans-serif">${fmtAxisNum(val)}</text>`;
+  }
+  h+=`<line x1="${pL}" y1="${pT}" x2="${pL}" y2="${H-pB}" stroke="#cbc3d7" stroke-width="0.9"/>`;
+  h+=`<line x1="${pL}" y1="${H-pB}" x2="${W-pR}" y2="${H-pB}" stroke="#cbc3d7" stroke-width="0.9"/>`;
+  h+=`<defs><linearGradient id="${gid}" x1="0" y1="0" x2="0" y2="1"><stop offset="0" stop-color="${color}" stop-opacity="0.22"/><stop offset="1" stop-color="${color}" stop-opacity="0"/></linearGradient></defs>`;
+  h+=`<path d="${areaD}" fill="url(#${gid})"/><path d="${lineD}" fill="none" stroke="${color}" stroke-width="2"/>`;
+  const lastI=n-1;
+  h+=`<text x="${pL}" y="${H-8}" fill="#958ea0" font-size="8" font-family="Space Grotesk,sans-serif">0</text>`;
+  h+=`<text x="${pL+plotW/2}" y="${H-8}" text-anchor="middle" fill="#958ea0" font-size="8" font-family="Space Grotesk,sans-serif">${Math.floor(lastI/2)}</text>`;
+  h+=`<text x="${W-pR}" y="${H-8}" text-anchor="end" fill="#958ea0" font-size="8" font-family="Space Grotesk,sans-serif">${lastI}</text>`;
+  h+=`<text x="${pL+plotW/2}" y="${H-1}" text-anchor="middle" fill="#958ea0" font-size="7" font-family="Space Grotesk,sans-serif" opacity="0.75">step</text>`;
+  svg.innerHTML=h;
+}
+
+function drawFollowerDeltaChart(svgId){
+  const svg=document.getElementById(svgId);
+  const data=timelineHistory;
+  if(!svg)return;
+  const W=360,H=112,pL=48,pR=10,pT=10,pB=28;
+  const plotW=W-pL-pR,plotH=H-pT-pB;
+  if(data.length<2){
+    svg.innerHTML=`<text x="${W/2}" y="${H/2}" text-anchor="middle" fill="#958ea0" font-size="10" font-family="Space Grotesk,sans-serif">Need 2+ steps</text>`;
+    return;
+  }
+  const dlt=data.map((d,i)=>i===0?0:d.followers-data[i-1].followers);
+  const maxA=Math.max(...dlt.map(a=>Math.abs(a)),1);
+  const midY=pT+plotH/2;
+  const amp=(plotH/2-4);
+  const n=data.length;
+  const pts=dlt.map((dv,i)=>{
+    const x=pL+(n<=1?plotW/2:i/(n-1)*plotW);
+    const y=midY-(dv/maxA)*amp;
+    return {x,y};
+  });
+  const lineD=smoothPath(pts);
+  let h="";
+  h+=`<line x1="${pL}" y1="${midY}" x2="${W-pR}" y2="${midY}" stroke="#494454" stroke-width="0.6" opacity="0.45"/>`;
+  h+=`<text x="${pL-5}" y="${pT+8}" text-anchor="end" fill="#958ea0" font-size="8" font-family="Space Grotesk,sans-serif">+${fmtAxisNum(maxA)}</text>`;
+  h+=`<text x="${pL-5}" y="${H-pB}" text-anchor="end" fill="#958ea0" font-size="8" font-family="Space Grotesk,sans-serif">${fmtAxisNum(-maxA)}</text>`;
+  h+=`<line x1="${pL}" y1="${pT}" x2="${pL}" y2="${H-pB}" stroke="#cbc3d7" stroke-width="0.9"/>`;
+  h+=`<line x1="${pL}" y1="${H-pB}" x2="${W-pR}" y2="${H-pB}" stroke="#cbc3d7" stroke-width="0.9"/>`;
+  h+=`<path d="${lineD}" fill="none" stroke="#7bd0ff" stroke-width="2"/>`;
+  const lastI=n-1;
+  h+=`<text x="${pL}" y="${H-8}" fill="#958ea0" font-size="8" font-family="Space Grotesk,sans-serif">0</text>`;
+  h+=`<text x="${pL+plotW/2}" y="${H-8}" text-anchor="middle" fill="#958ea0" font-size="8" font-family="Space Grotesk,sans-serif">${Math.floor(lastI/2)}</text>`;
+  h+=`<text x="${W-pR}" y="${H-8}" text-anchor="end" fill="#958ea0" font-size="8" font-family="Space Grotesk,sans-serif">${lastI}</text>`;
+  h+=`<text x="${pL+plotW/2}" y="${H-1}" text-anchor="middle" fill="#958ea0" font-size="7" font-family="Space Grotesk,sans-serif" opacity="0.75">step · Δ followers</text>`;
+  svg.innerHTML=h;
+}
+
+function drawPostsByHour(svgId){
+  const svg=document.getElementById(svgId);
+  if(!svg)return;
+  const buckets=new Array(24).fill(0);
+  for(const p of timelineHistory){
+    if(p.action==="post")buckets[p.hour]++;
+  }
+  const postN=buckets.reduce((a,b)=>a+b,0);
+  if(!postN){
+    svg.innerHTML='<text x="160" y="40" text-anchor="middle" fill="#958ea0" font-size="10" font-family="Space Grotesk,sans-serif">No posts yet — histogram fills when you post</text>';
+    return;
+  }
+  const max=Math.max(...buckets,1);
+  const W=320,H=64,pL=16,pR=4,pT=4,pB=16;
+  const slot=(W-pL-pR)/24;
+  const bw=slot*0.72;
+  let rects="";
+  for(let h=0;h<24;h++){
+    const bh=(buckets[h]/max)*(H-pT-pB);
+    const x=pL+h*slot+(slot-bw)/2;
+    const y=H-pB-Math.max(bh,0.5);
+    rects+=`<rect x="${x.toFixed(2)}" y="${y.toFixed(2)}" width="${bw.toFixed(2)}" height="${Math.max(bh,0.5).toFixed(2)}" fill="#d0bcff" rx="1"/>`;
+  }
+  let labels="";
+  for(let h=0;h<24;h+=6){
+    labels+=`<text x="${(pL+h*slot+bw/2).toFixed(1)}" y="${H-3}" text-anchor="middle" fill="#958ea0" font-size="8" font-family="Space Grotesk,sans-serif">${h}h</text>`;
+  }
+  svg.innerHTML=rects+labels;
+}
+
+function drawActionMix(svgId){
+  const svg=document.getElementById(svgId);
+  if(!svg)return;
+  if(!timelineHistory.length){
+    svg.innerHTML='<text x="160" y="28" text-anchor="middle" fill="#958ea0" font-size="10" font-family="Space Grotesk,sans-serif">No steps yet</text>';
+    return;
+  }
+  let r=0,c=0,p=0;
+  for(const x of timelineHistory){
+    if(x.action==="rest")r++;
+    else if(x.action==="create_content")c++;
+    else if(x.action==="post")p++;
+  }
+  const W=320,H=44,pT=6,pB=4;
+  const labels=[["Rest",r,"#ffb2b9"],["Create",c,"#7bd0ff"],["Post",p,"#d0bcff"]];
+  const max=Math.max(r,c,p,1);
+  const bw=90;
+  let out="";
+  labels.forEach(([lab,n,col],i)=>{
+    const x=20+i*100;
+    const bh=(n/max)*(H-pT-pB);
+    const y=H-pB-bh;
+    out+=`<rect x="${x}" y="${y}" width="${bw}" height="${Math.max(bh,2)}" fill="${col}" rx="2"/>`;
+    out+=`<text x="${x+bw/2}" y="${H+2}" text-anchor="middle" fill="#958ea0" font-size="8" font-family="Space Grotesk,sans-serif">${lab} ${n}</text>`;
+  });
+  svg.innerHTML=out;
+}
+
+async function doReset(){
+  setStatus("Resetting...");
+  const task=document.getElementById("taskSelect").value;
+  energyHistory.length=0;rewardHistory.length=0;followerHistory.length=0;actionLog.length=0;timelineHistory.length=0;totalPostsCount=0;
+  try{
+    const r=await fetch(API+"/dashboard/reset",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({task})});
+    const d=await r.json();
+    updateUI(d);
+    document.getElementById("historyLog").innerHTML='<div class="text-secondary font-bold">Environment reset — task: '+task+'</div>';
+    document.getElementById("graderCard").classList.add("hidden");
+    document.getElementById("engagementChart").innerHTML="";
+    document.getElementById("followerChart").innerHTML="";
+    document.getElementById("recentActions").innerHTML='<div class="text-on-surface-dim italic text-[10px]">No actions yet</div>';
+    drawBurnoutMeter(1);
+    setStatus("Running");
+  }catch(e){setStatus("Error: "+e.message)}
+}
+
+async function doAction(type){
+  setStatus("Stepping...");
+  try{
+    const r=await fetch(API+"/dashboard/step",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({action:{action_type:type}})});
+    const d=await r.json();
+    updateUI(d,{actionType:type});
+    addLog(type+"()",d.reward,d.done,d.observation?.error);
+  }catch(e){setStatus("Error: "+e.message)}
+}
+
+async function doPost(){
+  const ct=document.getElementById("contentType").value;
+  const topic=document.getElementById("topicInput").value.trim();
+  const tagsRaw=document.getElementById("tagsInput").value.trim();
+  const tags=tagsRaw?tagsRaw.split(",").map(t=>t.trim()).filter(Boolean):[];
+  if(!topic){alert("Enter a topic");return}
+  setStatus("Stepping...");
+  try{
+    const body={action:{action_type:"post",content_type:ct,topic,tags:tags.length?tags:undefined}};
+    const r=await fetch(API+"/dashboard/step",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify(body)});
+    const d=await r.json();
+    updateUI(d,{actionType:"post"});
+    addLog(`post(${ct},"${topic}",[${tags.join(",")}])`,d.reward,d.done,d.observation?.error);
+    hidePostForm();
+  }catch(e){setStatus("Error: "+e.message)}
+}
+
+function updateUI(d, opts={}){
+  const o=d.observation||d;
+  currentObs=o;
+  recordTimelineFromObs(d, opts.actionType);
+  const energy=o.creator_energy??1;
+  const followers=o.follower_count??0;
+  const eng=o.engagement_rate??0;
+  const sat=o.niche_saturation??0;
+  const compAvg=o.competitor_avg_engagement??0;
+  const reward=d.reward??0;
+
+  document.getElementById("energyVal").textContent=energy.toFixed(2);
+  document.getElementById("energyBar").style.width=(energy*100)+"%";
+  const eHint=document.getElementById("energyHint");
+  if(energy<=0){eHint.textContent="BURNED OUT";eHint.className="mt-1.5 text-[9px] font-label text-error"}
+  else if(energy<0.3){eHint.textContent="CRITICAL";eHint.className="mt-1.5 text-[9px] font-label text-tertiary-ctr"}
+  else if(energy<0.5){eHint.textContent="LOW — REST NOW";eHint.className="mt-1.5 text-[9px] font-label text-tertiary"}
+  else if(energy<0.8){eHint.textContent="MODERATE";eHint.className="mt-1.5 text-[9px] font-label text-on-surface-dim"}
+  else{eHint.textContent="FULL";eHint.className="mt-1.5 text-[9px] font-label text-secondary"}
+
+  document.getElementById("followersVal").textContent=followers.toLocaleString();
+  const delta=followers-10000;
+  const dEl=document.getElementById("followersDelta");
+  dEl.textContent=(delta>=0?"+":"")+delta+" since start";
+  dEl.className="mt-1.5 text-[9px] font-label "+(delta>0?"text-secondary":delta<0?"text-tertiary":"text-on-surface-dim");
+
+  document.getElementById("engVal").textContent=eng.toFixed(3);
+  const diff=eng-compAvg;
+  const evc=document.getElementById("engVsComp");
+  evc.textContent="vs competitors: "+(diff>=0?"+":"")+diff.toFixed(3);
+  evc.className="mt-1.5 text-[9px] font-label "+(diff>0?"text-secondary":"text-tertiary");
+
+  document.getElementById("timeVal").textContent=(o.current_hour??0)+":00";
+  document.getElementById("dayVal").textContent=DAYS[o.day_of_week??0];
+  document.getElementById("postsVal").textContent=o.posts_today??0;
+  document.getElementById("queueVal").textContent=o.content_queue_size??0;
+  document.getElementById("satVal").textContent=sat.toFixed(2);
+  const sH=document.getElementById("satHint");
+  if(sat>0.7){sH.textContent="HIGH — diversify topics";sH.className="mt-1.5 text-[9px] font-label text-tertiary"}
+  else if(sat>0.4){sH.textContent="MEDIUM — some room";sH.className="mt-1.5 text-[9px] font-label text-on-surface-dim"}
+  else{sH.textContent="LOW — post unique topics";sH.className="mt-1.5 text-[9px] font-label text-primary"}
+  document.getElementById("stepNum").textContent=o.metadata?.step??0;
+
+  // Charts
+  energyHistory.push(energy);
+  rewardHistory.push(reward);
+  followerHistory.push(followers);
+  drawEngagementChart();
+  drawBurnoutMeter(energy);
+  drawFollowerBars();
+  updateBottomStats();
+  if(d.action_type||d.observation?.metadata)addRecentAction(d);
+
+  // Trending
+  const tt=document.getElementById("trendTopics");
+  tt.innerHTML=(o.trending_topics||[]).map(t=>`<span class="px-2 py-1 rounded-lg bg-secondary/10 border border-secondary/15 text-secondary text-[10px] font-label">${t}</span>`).join("");
+  const tg=document.getElementById("trendTags");
+  tg.innerHTML=(o.trending_tags||[]).map(t=>`<span class="px-2 py-1 rounded-lg bg-primary/10 border border-primary/15 text-primary text-[10px] font-label">#${t}</span>`).join("");
+
+  // Tag perf — sidebar panel
+  const tp=document.getElementById("tagPerf");
+  const perf=o.tag_performance||{};
+  const entries=Object.entries(perf).sort((a,b)=>b[1]-a[1]);
+  if(entries.length){
+    const maxV=Math.max(...entries.map(e=>e[1]),0.01);
+    tp.innerHTML=entries.slice(0,6).map(([tag,val],i)=>{
+      const w=Math.min(100,(val/maxV)*100);
+      const c=i%2===0?"primary":"secondary";
+      return `<div><div class="flex justify-between font-label text-[10px]"><span class="text-on-surface">#${tag}</span><span class="text-${c}">${val.toFixed(3)}</span></div><div class="h-1.5 bg-surface-top rounded-full mt-1 overflow-hidden"><div class="h-full bg-gradient-to-r from-${c} to-${c}-ctr rounded-full" style="width:${w}%"></div></div></div>`;
+    }).join("");
+  }else{tp.innerHTML='<div class="text-on-surface-dim italic text-[10px]">No tag data yet</div>'}
+
+  // Top tags styled list
+  const ttl=document.getElementById("topTagsList");
+  const colors=["secondary","primary","tertiary","on-surface-dim"];
+  if(entries.length){
+    ttl.innerHTML=entries.slice(0,4).map(([tag,val],i)=>{
+      const c=colors[i%colors.length];
+      const fmtVal=val>=1000?(val/1000).toFixed(1)+"k":val.toFixed(1);
+      return `<div class="flex items-center justify-between"><div class="flex items-center gap-2.5"><span class="w-2 h-2 rounded-full bg-${c}"></span><span class="text-sm font-label text-on-surface">#${tag}</span></div><span class="text-sm font-bold font-label text-${c}">${fmtVal}</span></div>`;
+    }).join("");
+  }else{ttl.innerHTML='<div class="text-on-surface-dim italic text-[10px]">No tag data yet</div>'}
+
+  // Competitors
+  document.getElementById("compEng").textContent=compAvg.toFixed(3);
+  const cp=document.getElementById("compPosts");
+  const posts=o.competitor_recent_posts||[];
+  if(posts.length){
+    const icons={reel:"movie",carousel:"view_carousel",story:"auto_stories",text_post:"article"};
+    cp.innerHTML=posts.slice(0,4).map(p=>`<div class="p-2.5 rounded-lg bg-surface border border-outline/15 flex items-start gap-2.5"><span class="material-symbols-outlined text-tertiary/40 text-lg mt-0.5">${icons[p.content_type]||"article"}</span><div class="flex-1 min-w-0"><div class="flex justify-between text-[10px]"><span class="font-bold text-on-surface truncate">${p.topic||"—"}</span><span class="text-on-surface-dim shrink-0 ml-2">${p.hours_ago}h</span></div><div class="text-[9px] text-on-surface-dim mt-0.5">${p.content_type} · eng: <span class="text-tertiary">${(p.engagement??0).toFixed(3)}</span></div></div></div>`).join("");
+  }else{cp.innerHTML='<div class="text-on-surface-dim italic text-[10px]">No competitor posts yet</div>'}
+
+  // Done state
+  if(d.done){
+    setStatus("Episode Done");
+    document.querySelectorAll("#postBtn,.action-btn").forEach(b=>{b.disabled=true;b.classList.add("opacity-30","pointer-events-none")});
+    const score=o.metadata?.grader_score;
+    if(score!=null){
+      const gc=document.getElementById("graderCard");
+      gc.classList.remove("hidden");
+      document.getElementById("graderScore").textContent=score.toFixed(4);
+      const lbl=document.getElementById("graderLabel");
+      if(score>=0.7)lbl.textContent="Excellent performance!";
+      else if(score>=0.4)lbl.textContent="Decent strategy, room for improvement";
+      else lbl.textContent="Poor performance — agent needs better strategy";
+    }
+  }else{
+    document.querySelectorAll("#postBtn,.action-btn").forEach(b=>{b.disabled=false;b.classList.remove("opacity-30","pointer-events-none")});
+    setStatus("Running");
+  }
+  redrawTimelineCharts();
+}
+
+function smoothPath(pts){
+  if(pts.length<2)return pts.map((p,i)=>(i===0?"M":"L")+p.x.toFixed(1)+","+p.y.toFixed(1)).join(" ");
+  let d="M"+pts[0].x.toFixed(1)+","+pts[0].y.toFixed(1);
+  for(let i=1;i<pts.length;i++){
+    const cp=(pts[i].x-pts[i-1].x)/3;
+    d+=` C${(pts[i-1].x+cp).toFixed(1)},${pts[i-1].y.toFixed(1)} ${(pts[i].x-cp).toFixed(1)},${pts[i].y.toFixed(1)} ${pts[i].x.toFixed(1)},${pts[i].y.toFixed(1)}`;
+  }
+  return d;
+}
+
+function drawEngagementChart(){
+  const svg=document.getElementById("engagementChart");
+  const data=rewardHistory;
+  if(!svg||!data.length)return;
+  const W=760,H=200,pL=56,pR=14,pT=12,pB=40;
+  const plotW=W-pL-pR,plotH=H-pT-pB;
+  const minR=Math.min(0,Math.min(...data));
+  const maxR=Math.max(...data,0.01);
+  const span=Math.max(maxR-minR,1e-6)*1.08;
+  const y0=minR;
+  const pts=data.map((v,i)=>({
+    x:pL+(i/Math.max(data.length-1,1))*plotW,
+    y:pT+(1-(v-y0)/span)*plotH,
+  }));
+  const lineD=smoothPath(pts);
+  const areaD=lineD+` L${pts[pts.length-1].x.toFixed(1)},${(H-pB).toFixed(1)} L${pts[0].x.toFixed(1)},${(H-pB).toFixed(1)} Z`;
+  const gid="eng_reward_grad";
+  let h="";
+  for(let g=0;g<=4;g++){
+    const y=pT+(g/4)*plotH;
+    const val=y0+(1-g/4)*span;
+    h+=`<line x1="${pL}" y1="${y}" x2="${W-pR}" y2="${y}" stroke="#494454" stroke-width="0.5" opacity="0.35"/>`;
+    h+=`<text x="${pL-6}" y="${y+3}" text-anchor="end" fill="#958ea0" font-size="9" font-family="Space Grotesk,sans-serif">${val.toFixed(2)}</text>`;
+  }
+  h+=`<line x1="${pL}" y1="${pT}" x2="${pL}" y2="${H-pB}" stroke="#cbc3d7" stroke-width="1"/>`;
+  h+=`<line x1="${pL}" y1="${H-pB}" x2="${W-pR}" y2="${H-pB}" stroke="#cbc3d7" stroke-width="1"/>`;
+  h+=`<defs><linearGradient id="${gid}" x1="0" y1="0" x2="0" y2="1"><stop offset="0" stop-color="#7bd0ff" stop-opacity="0.28"/><stop offset="1" stop-color="#7bd0ff" stop-opacity="0"/></linearGradient></defs>`;
+  h+=`<path d="${areaD}" fill="url(#${gid})"/><path d="${lineD}" fill="none" stroke="#7bd0ff" stroke-width="2.5"/>`;
+  const lastI=data.length-1;
+  h+=`<text x="${pL}" y="${H-18}" fill="#958ea0" font-size="9" font-family="Space Grotesk,sans-serif">step 0</text>`;
+  h+=`<text x="${pL+plotW/2}" y="${H-18}" text-anchor="middle" fill="#958ea0" font-size="9" font-family="Space Grotesk,sans-serif">step ${Math.floor(lastI/2)}</text>`;
+  h+=`<text x="${W-pR}" y="${H-18}" text-anchor="end" fill="#958ea0" font-size="9" font-family="Space Grotesk,sans-serif">step ${lastI}</text>`;
+  h+=`<text x="${pL+plotW/2}" y="${H-4}" text-anchor="middle" fill="#958ea0" font-size="9" font-family="Space Grotesk,sans-serif" opacity="0.85">simulation step index</text>`;
+  h+=`<text x="12" y="${pT+plotH/2}" transform="rotate(-90 12 ${pT+plotH/2})" text-anchor="middle" fill="#958ea0" font-size="9" font-family="Space Grotesk,sans-serif" opacity="0.85">reward</text>`;
+  svg.innerHTML=h;
+}
+
+function drawBurnoutMeter(energy){
+  const burnout=Math.round((1-energy)*100);
+  const circ=2*Math.PI*50;
+  const fill=(burnout/100)*circ;
+  document.getElementById("burnoutArc").setAttribute("stroke-dasharray",fill.toFixed(1)+" "+circ.toFixed(1));
+  document.getElementById("burnoutPct").textContent=burnout+"%";
+  const rec=document.getElementById("burnoutRec");
+  if(burnout>=70)rec.textContent="Recommendation: Limit posting for 45 mins to prevent creative fatigue.";
+  else if(burnout>=40)rec.textContent="Recommendation: Alternate between creating and resting to maintain output quality.";
+  else rec.textContent="Recommendation: Energy levels healthy. Good window for high-effort content.";
+}
+
+function drawFollowerBars(){
+  const svg=document.getElementById("followerChart");
+  const data=followerHistory;
+  if(data.length<2){svg.innerHTML="";return}
+  const W=300,H=120,pL=40,pR=8,pT=6,pB=22,plotW=W-pL-pR,plotH=H-pT-pB;
+  const chunks=Math.min(data.length,7);
+  const chunkSize=Math.max(1,Math.floor(data.length/chunks));
+  const bars=[];
+  for(let i=0;i<chunks;i++){
+    const start=i*chunkSize;
+    const end=Math.min(start+chunkSize,data.length);
+    const avg=data.slice(start,end).reduce((a,b)=>a+b,0)/(end-start);
+    bars.push(avg);
+  }
+  const fMin=Math.min(...bars),fMax=Math.max(...bars);
+  const base=fMin*0.998;
+  const maxDelta=Math.max(...bars.map(b=>b-base),1);
+  const barW=plotW/bars.length*0.58;
+  const gap=plotW/bars.length*0.42;
+  let html="";
+  html+=`<text x="4" y="${pT+10}" fill="#958ea0" font-size="7" font-family="Space Grotesk,sans-serif">${Math.round(fMax)}</text>`;
+  html+=`<text x="4" y="${pT+plotH}" fill="#958ea0" font-size="7" font-family="Space Grotesk,sans-serif">${Math.round(fMin)}</text>`;
+  html+=`<text transform="rotate(-90 14 ${pT+plotH/2})" x="14" y="${pT+plotH/2}" text-anchor="middle" fill="#958ea0" font-size="7" font-family="Space Grotesk,sans-serif">followers</text>`;
+  bars.forEach((v,i)=>{
+    const h=Math.max(4,((v-base)/maxDelta)*plotH);
+    const x=pL+i*(plotW/bars.length)+(gap/2);
+    const y=pT+plotH-h;
+    const opacity=0.5+0.5*(i/bars.length);
+    html+=`<rect x="${x.toFixed(1)}" y="${y.toFixed(1)}" width="${barW.toFixed(1)}" height="${h.toFixed(1)}" rx="3" fill="#7bd0ff" opacity="${opacity.toFixed(2)}"/>`;
+    html+=`<text x="${(x+barW/2).toFixed(1)}" y="${H-4}" text-anchor="middle" fill="#958ea0" font-size="7" font-family="Space Grotesk,sans-serif">${DAYS[i%7]}</text>`;
+  });
+  svg.innerHTML=html;
+  const delta=data[data.length-1]-data[0];
+  const pct=((delta/data[0])*100);
+  document.getElementById("followerTotal").textContent=(delta>=0?"+":"")+Math.round(delta).toLocaleString();
+  document.getElementById("followerDeltaPct").textContent=(pct>=0?"+":"")+pct.toFixed(0)+"% vs start";
+}
+
+function updateBottomStats(){
+  if(rewardHistory.length){
+    const avg=rewardHistory.reduce((a,b)=>a+b,0)/rewardHistory.length;
+    document.getElementById("bottomAvgReward").textContent=avg.toFixed(2);
+    if(rewardHistory.length>10){
+      const recent=rewardHistory.slice(-10).reduce((a,b)=>a+b,0)/10;
+      const old=rewardHistory.slice(0,10).reduce((a,b)=>a+b,0)/Math.min(10,rewardHistory.length);
+      const d=((recent-old)/Math.max(Math.abs(old),0.001)*100);
+      document.getElementById("bottomAvgDelta").textContent=(d>=0?"+":"")+d.toFixed(0)+"%";
+      document.getElementById("bottomAvgDelta").className="text-[10px] font-label mt-1 "+(d>=0?"text-secondary":"text-tertiary");
+    }
+  }
+  document.getElementById("bottomTotalPosts").textContent=totalPostsCount;
+  const eng=currentObs?.engagement_rate??0;
+  const viral=Math.min(100,Math.round(eng*1000));
+  const label=viral>=70?"HIGH":viral>=40?"MEDIUM":"LOW";
+  document.getElementById("bottomViralProb").textContent=label+" ("+viral+"%)";
+  const vn=document.getElementById("viralFormulaNote");
+  if(vn)vn.textContent="min(100, round("+eng.toFixed(3)+" × 1000)) = "+viral+" — labels LOW/MED/HIGH at 40 and 70 (display only).";
+}
+
+function addRecentAction(d){
+  const el=document.getElementById("recentActions");
+  const step=currentObs?.metadata?.step??0;
+  const reward=d.reward??0;
+  const icons={rest:"hotel",create_content:"edit_note",post:"send"};
+  const colors={rest:"tertiary",create_content:"secondary",post:"primary"};
+  const action=d.action_type||d.observation?.last_action||"step";
+  const icon=icons[action]||"play_arrow";
+  const c=colors[action]||"on-surface-dim";
+  const entry=`<div class="flex items-start gap-2.5 fade-in"><span class="material-symbols-outlined text-${c} text-lg mt-0.5 shrink-0">${icon}</span><div class="flex-1 min-w-0"><div class="text-xs font-bold text-on-surface truncate">${action.replace("_"," ")}</div><div class="text-[9px] text-on-surface-dim">${step} steps ago · r=${reward.toFixed(2)}</div></div></div>`;
+  if(el.querySelector(".italic"))el.innerHTML="";
+  el.innerHTML=entry+el.innerHTML;
+  if(el.children.length>8)el.removeChild(el.lastChild);
+}
+
+function addLog(action,reward,done,error){
+  if(action.startsWith("post"))totalPostsCount++;
+  const step=currentObs?.metadata?.step??0;
+  const log=document.getElementById("historyLog");
+  const errStr=error?` <span class="text-error">err=${error}</span>`:"";
+  const color=reward>0.5?"text-secondary":reward>0.2?"text-primary":"text-on-surface-dim";
+  const doneStr=done?'<span class="text-tertiary font-bold"> DONE</span>':"";
+  log.innerHTML+=`<div class="fade-in py-0.5"><span class="text-on-surface-dim/50">[${step}]</span> <span class="text-on-surface">${action}</span> <span class="${color}">r=${(reward??0).toFixed(2)}</span>${doneStr}${errStr}</div>`;
+  log.scrollTop=log.scrollHeight;
+  document.getElementById("rewardBadge").textContent="Last reward: "+(reward??0).toFixed(2);
+}
+
+let simRunning=false;
+async function runSim(scenario){
+  if(simRunning)return;
+  simRunning=true;
+  const task=document.getElementById("taskSelect").value;
+  document.querySelectorAll(".sim-btn").forEach(b=>b.classList.add("opacity-30","pointer-events-none"));
+  document.getElementById("simProgress").classList.remove("hidden");
+  document.getElementById("simResult").classList.add("hidden");
+  document.getElementById("simBar").style.width="0%";
+  document.getElementById("simPct").textContent="0%";
+  document.getElementById("graderCard").classList.add("hidden");
+  energyHistory.length=0;rewardHistory.length=0;followerHistory.length=0;timelineHistory.length=0;totalPostsCount=0;
+  setStatus("Simulating...");
+
+  try{
+    const r=await fetch(API+"/dashboard/simulate",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({scenario,task})});
+    const d=await r.json();
+    if(d.error){setStatus("Error: "+d.error);simRunning=false;return}
+
+    const log=document.getElementById("historyLog");
+    log.innerHTML=`<div class="text-secondary font-bold mb-1">Sim: ${d.scenario} — ${task}</div><div class="text-on-surface-dim text-[9px] mb-2">${d.description}</div>`;
+
+    const total=d.steps.length;
+    for(let i=0;i<total;i++){
+      const s=d.steps[i];
+      rewardHistory.push(s.reward);
+      energyHistory.push(s.energy);
+      followerHistory.push(s.followers);
+      timelineHistory.push({
+        step:s.step,
+        simHour:(s.days_elapsed??0)*24+(s.hour??0),
+        hour:s.hour??0,
+        day:s.day??0,
+        energy:s.energy,
+        followers:s.followers,
+        engagement:s.engagement_rate,
+        reward:s.reward,
+        sat:s.niche_saturation,
+        queue:s.queue,
+        postsToday:s.posts_today,
+        compAvg:s.competitor_avg_engagement,
+        sleepDebt:s.sleep_debt??0,
+        hoursSinceSleep:s.hours_since_sleep??0,
+        action:simActionType(s.action),
+      });
+      if(s.action.startsWith("post"))totalPostsCount++;
+
+      const pct=Math.round((i+1)/total*100);
+      document.getElementById("simBar").style.width=pct+"%";
+      document.getElementById("simPct").textContent=pct+"%";
+
+      // Live stat card updates every 5 steps
+      if(i%5===0||i===total-1){
+        document.getElementById("energyVal").textContent=s.energy.toFixed(2);
+        document.getElementById("energyBar").style.width=(s.energy*100)+"%";
+        document.getElementById("followersVal").textContent=s.followers.toLocaleString();
+        document.getElementById("engVal").textContent=s.engagement_rate.toFixed(3);
+        document.getElementById("stepNum").textContent=s.step;
+        document.getElementById("timeVal").textContent=s.hour+":00";
+        document.getElementById("dayVal").textContent=DAYS[s.day];
+        document.getElementById("postsVal").textContent=s.posts_today;
+        document.getElementById("queueVal").textContent=s.queue;
+        document.getElementById("satVal").textContent=s.niche_saturation.toFixed(2);
+        document.getElementById("compEng").textContent=s.competitor_avg_engagement.toFixed(3);
+        const diff=s.engagement_rate-s.competitor_avg_engagement;
+        const evc=document.getElementById("engVsComp");
+        evc.textContent="vs competitors: "+(diff>=0?"+":"")+diff.toFixed(3);
+        evc.className="mt-1.5 text-[9px] font-label "+(diff>0?"text-secondary":"text-tertiary");
+        const fdelta=s.followers-10000;
+        const fdEl=document.getElementById("followersDelta");
+        fdEl.textContent=(fdelta>=0?"+":"")+fdelta+" since start";
+        fdEl.className="mt-1.5 text-[9px] font-label "+(fdelta>0?"text-secondary":fdelta<0?"text-tertiary":"text-on-surface-dim");
+
+        drawEngagementChart();
+        drawBurnoutMeter(s.energy);
+        drawFollowerBars();
+        updateBottomStats();
+        redrawTimelineCharts();
+
+        // Update trending
+        const tt=document.getElementById("trendTopics");
+        tt.innerHTML=(s.trending_topics||[]).map(t=>`<span class="px-2 py-1 rounded-lg bg-secondary/10 border border-secondary/15 text-secondary text-[10px] font-label">${t}</span>`).join("");
+        const tg=document.getElementById("trendTags");
+        tg.innerHTML=(s.trending_tags||[]).map(t=>`<span class="px-2 py-1 rounded-lg bg-primary/10 border border-primary/15 text-primary text-[10px] font-label">#${t}</span>`).join("");
+
+        // Update tag perf
+        const perf=s.tag_performance||{};
+        const entries=Object.entries(perf).sort((a,b)=>b[1]-a[1]);
+        const tp=document.getElementById("tagPerf");
+        if(entries.length){
+          const maxV=Math.max(...entries.map(e=>e[1]),0.01);
+          tp.innerHTML=entries.slice(0,6).map(([tag,val],j)=>{
+            const c=j%2===0?"primary":"secondary";
+            const w=Math.min(100,(val/maxV)*100);
+            return `<div><div class="flex justify-between font-label text-[10px]"><span class="text-on-surface">#${tag}</span><span class="text-${c}">${val.toFixed(3)}</span></div><div class="h-1.5 bg-surface-top rounded-full mt-1 overflow-hidden"><div class="h-full bg-gradient-to-r from-${c} to-${c}-ctr rounded-full" style="width:${w}%"></div></div></div>`;
+          }).join("");
+        }
+        const ttl=document.getElementById("topTagsList");
+        const colors=["secondary","primary","tertiary","on-surface-dim"];
+        if(entries.length){
+          ttl.innerHTML=entries.slice(0,4).map(([tag,val],j)=>{
+            const c=colors[j%colors.length];
+            const fmtVal=val>=1000?(val/1000).toFixed(1)+"k":val.toFixed(1);
+            return `<div class="flex items-center justify-between"><div class="flex items-center gap-2.5"><span class="w-2 h-2 rounded-full bg-${c}"></span><span class="text-sm font-label text-on-surface">#${tag}</span></div><span class="text-sm font-bold font-label text-${c}">${fmtVal}</span></div>`;
+          }).join("");
+        }
+
+        await new Promise(r=>setTimeout(r,12));
+      }
+
+      const color=s.reward>0.5?"text-secondary":s.reward>0.2?"text-primary":"text-on-surface-dim";
+      const err=s.error?` <span class="text-error">err=${s.error}</span>`:"";
+      const dn=s.done?'<span class="text-tertiary font-bold"> DONE</span>':"";
+      log.innerHTML+=`<div class="fade-in py-0.5"><span class="text-on-surface-dim/50">[${s.step}]</span> <span class="text-on-surface">${s.action}</span> <span class="${color}">r=${s.reward.toFixed(2)}</span>${dn}${err}</div>`;
+      log.scrollTop=log.scrollHeight;
+    }
+
+    const f=d.final;
+    const sc=d.score;
+    redrawTimelineCharts();
+
+    // Final update of all panels using last step data
+    const lastStep=d.steps[d.steps.length-1];
+    if(lastStep){
+      const tt=document.getElementById("trendTopics");
+      tt.innerHTML=(lastStep.trending_topics||[]).map(t=>`<span class="px-2 py-1 rounded-lg bg-secondary/10 border border-secondary/15 text-secondary text-[10px] font-label">${t}</span>`).join("");
+      const tg=document.getElementById("trendTags");
+      tg.innerHTML=(lastStep.trending_tags||[]).map(t=>`<span class="px-2 py-1 rounded-lg bg-primary/10 border border-primary/15 text-primary text-[10px] font-label">#${t}</span>`).join("");
+
+      const perf=lastStep.tag_performance||{};
+      const entries=Object.entries(perf).sort((a,b)=>b[1]-a[1]);
+      const tp=document.getElementById("tagPerf");
+      if(entries.length){
+        const maxV=Math.max(...entries.map(e=>e[1]),0.01);
+        tp.innerHTML=entries.slice(0,6).map(([tag,val],j)=>{
+          const c=j%2===0?"primary":"secondary";
+          const w=Math.min(100,(val/maxV)*100);
+          return `<div><div class="flex justify-between font-label text-[10px]"><span class="text-on-surface">#${tag}</span><span class="text-${c}">${val.toFixed(3)}</span></div><div class="h-1.5 bg-surface-top rounded-full mt-1 overflow-hidden"><div class="h-full bg-gradient-to-r from-${c} to-${c}-ctr rounded-full" style="width:${w}%"></div></div></div>`;
+        }).join("");
+      }
+      const ttl=document.getElementById("topTagsList");
+      const colors=["secondary","primary","tertiary","on-surface-dim"];
+      if(entries.length){
+        ttl.innerHTML=entries.slice(0,4).map(([tag,val],j)=>{
+          const c=colors[j%colors.length];
+          const fmtVal=val>=1000?(val/1000).toFixed(1)+"k":val.toFixed(1);
+          return `<div class="flex items-center justify-between"><div class="flex items-center gap-2.5"><span class="w-2 h-2 rounded-full bg-${c}"></span><span class="text-sm font-label text-on-surface">#${tag}</span></div><span class="text-sm font-bold font-label text-${c}">${fmtVal}</span></div>`;
+        }).join("");
+      }
+
+      document.getElementById("compEng").textContent=lastStep.competitor_avg_engagement.toFixed(3);
+      currentObs={engagement_rate:lastStep.engagement_rate,metadata:{}};
+    }
+
+    // Show grader card
+    const gc=document.getElementById("graderCard");
+    gc.classList.remove("hidden");
+    document.getElementById("graderScore").textContent=sc.toFixed(4);
+    const lbl=document.getElementById("graderLabel");
+    if(sc>=0.7)lbl.textContent="Excellent performance!";
+    else if(sc>=0.4)lbl.textContent="Decent strategy, room for improvement";
+    else lbl.textContent="Poor performance — agent needs better strategy";
+
+    const res=document.getElementById("simResult");
+    res.classList.remove("hidden");
+    const scoreColor=sc>=0.7?"text-primary":sc>=0.3?"text-secondary":"text-tertiary";
+    const scoreBg=sc>=0.7?"border-primary/30 bg-primary/5":sc>=0.3?"border-secondary/30 bg-secondary/5":"border-tertiary/30 bg-tertiary/5";
+    res.innerHTML=`
+      <div class="p-4 rounded-xl border ${scoreBg} space-y-2">
+        <div class="flex justify-between items-center"><span class="text-[10px] font-label text-on-surface-dim uppercase tracking-widest">Grader Score</span><span class="text-3xl font-black ${scoreColor}">${sc.toFixed(4)}</span></div>
+        <div class="grid grid-cols-2 gap-x-6 gap-y-1 text-[10px] font-label">
+          <div class="flex justify-between"><span class="text-on-surface-dim">Steps</span><span>${d.total_steps}</span></div>
+          <div class="flex justify-between"><span class="text-on-surface-dim">Burned Out</span><span class="${f.burned_out?"text-tertiary":"text-secondary"}">${f.burned_out?"YES":"NO"}</span></div>
+          <div class="flex justify-between"><span class="text-on-surface-dim">Final Energy</span><span>${f.energy.toFixed(2)}</span></div>
+          <div class="flex justify-between"><span class="text-on-surface-dim">Followers</span><span>${f.followers.toLocaleString()}</span></div>
+          <div class="flex justify-between"><span class="text-on-surface-dim">Engagement</span><span>${f.engagement_rate.toFixed(4)}</span></div>
+          <div class="flex justify-between"><span class="text-on-surface-dim">Total Posts</span><span>${totalPostsCount}</span></div>
+        </div>
+      </div>`;
+    updateBottomStats();
+    setStatus("Simulation Done");
+    loadHistory();
+  }catch(e){setStatus("Error: "+e.message)}
+  document.querySelectorAll(".sim-btn").forEach(b=>b.classList.remove("opacity-30","pointer-events-none"));
+  simRunning=false;
+}
+
+function showPostForm(){document.getElementById("postForm").classList.remove("hidden")}
+function hidePostForm(){document.getElementById("postForm").classList.add("hidden")}
+function setStatus(s){
+  const el=document.getElementById("statusDot");
+  const color=s.includes("Error")?"text-error":s==="Running"?"text-secondary":s.includes("Done")?"text-primary":"text-on-surface-dim";
+  el.className="flex items-center gap-2 text-xs font-label "+color;
+  el.innerHTML=`<span class="w-2 h-2 rounded-full ${color.replace("text-","bg-")}"></span>${s}`;
+}
+
+async function loadHistory(){
+  try{
+    const r=await fetch(API+"/dashboard/history");
+    const data=await r.json();
+    const tb=document.getElementById("historyTable");
+    if(!data.length){tb.innerHTML='<tr><td colspan="10" class="px-4 py-6 text-center text-on-surface-dim italic">No history yet — run a simulation</td></tr>';return}
+    const taskLabels={weekly_engage:"Easy",weekly_strategic:"Medium",weekly_competitive:"Hard"};
+    tb.innerHTML=data.slice().reverse().map(h=>{
+      const dt=new Date(h.id);
+      const time=dt.toLocaleDateString("en-US",{month:"short",day:"numeric"})+' '+dt.toLocaleTimeString("en-US",{hour:"2-digit",minute:"2-digit"});
+      const f=h.final||{};
+      const delta=f.followers-10000;
+      const deltaStr=(delta>=0?"+":"")+delta.toLocaleString();
+      const deltaClass=delta>0?"text-secondary":delta<0?"text-tertiary":"text-on-surface-dim";
+      const scoreColor=h.score>=0.7?"text-primary":h.score>=0.3?"text-secondary":"text-tertiary";
+      const status=f.burned_out?'<span class="text-tertiary font-bold">BURNED</span>':h.total_steps>=168?'<span class="text-secondary">DONE</span>':'<span class="text-on-surface-dim">PARTIAL</span>';
+      const energyColor=f.energy>=0.5?"text-secondary":f.energy>0?"text-tertiary":"text-error";
+      const desc=(h.description||"").trim();
+      return `<tr class="border-b border-white/5 hover:bg-white/[.02] transition">
+        <td class="px-4 py-2.5 text-on-surface-dim whitespace-nowrap">${time}</td>
+        <td class="px-4 py-2.5 min-w-[14rem] max-w-lg align-top">
+          <div class="text-on-surface font-bold">${_escapeHtml(h.scenario)}</div>
+          ${desc?`<div class="text-[10px] text-on-surface/75 mt-1 leading-relaxed whitespace-normal">${_escapeHtml(desc)}</div>`:""}
+        </td>
+        <td class="px-4 py-2.5 text-on-surface-dim">${taskLabels[h.task]||h.task}</td>
+        <td class="px-4 py-2.5 text-right ${scoreColor} font-bold">${h.score.toFixed(4)}</td>
+        <td class="px-4 py-2.5 text-right text-on-surface-dim">${h.total_steps}</td>
+        <td class="px-4 py-2.5 text-right text-on-surface-dim">${h.total_posts}</td>
+        <td class="px-4 py-2.5 text-right text-on-surface">${(f.followers||0).toLocaleString()}</td>
+        <td class="px-4 py-2.5 text-right ${deltaClass}">${deltaStr}</td>
+        <td class="px-4 py-2.5 text-right ${energyColor}">${(f.energy||0).toFixed(2)}</td>
+        <td class="px-4 py-2.5 text-center">${status}</td>
+      </tr>`;
+    }).join("");
+  }catch(e){console.error("History load failed",e)}
+}
+
+async function clearHistory(){
+  if(!confirm("Clear all simulation history?"))return;
+  await fetch(API+"/dashboard/history",{method:"DELETE"});
+  loadHistory();
+}
+
+function _escapeHtml(t){
+  const d=document.createElement("div");
+  d.textContent=t??"";
+  return d.innerHTML;
+}
+
+let _scenarioItems=[];
+
+async function loadScenarioButtons(){
+  const grid=document.getElementById("scenarioGrid");
+  const countEl=document.getElementById("scenarioCount");
+  const filterEl=document.getElementById("scenarioFilter");
+  if(!grid)return;
+  try{
+    const r=await fetch(API+"/dashboard/scenarios",{cache:"no-store",headers:{"Cache-Control":"no-cache"}});
+    const data=await r.json();
+    _scenarioItems=data.scenarios||[];
+    if(countEl)countEl.textContent=_scenarioItems.length+" strategies";
+    const pin=new Set(["easy_morning_story","easy_one_a_day","easy_relaxed","medium_queue_cycle","medium_trend_rotate","medium_two_format","smart","balanced","high_freq","optimal_sleep","sleep_conscious","sleep_debt_aware"]);
+    _scenarioItems.sort((a,b)=>{
+      const pa=pin.has(a.id)?0:1,pb=pin.has(b.id)?0:1;
+      if(pa!==pb)return pa-pb;
+      return (a.label||"").localeCompare(b.label||"","en",{sensitivity:"base"});
+    });
+    function render(){
+      const q=(filterEl&&filterEl.value||"").trim().toLowerCase();
+      grid.innerHTML="";
+      let n=0;
+      for(const s of _scenarioItems){
+        const lab=(s.label||"").toLowerCase();
+        const id=(s.id||"").toLowerCase();
+        const desc=(s.description||"").toLowerCase();
+        if(q&&!(lab.includes(q)||id.includes(q)||desc.includes(q)))continue;
+        n++;
+        const btn=document.createElement("button");
+        btn.type="button";
+        btn.className="sim-btn p-2.5 rounded-lg bg-surface border border-outline/20 hover:border-secondary/40 text-left transition";
+        if(pin.has(s.id))btn.classList.add("border-primary/25","hover:border-primary/55");
+        btn.onclick=()=>runSim(s.id);
+        btn.innerHTML=`<div class="text-xs font-bold text-on-surface leading-tight">${_escapeHtml(s.label)}</div><div class="text-[8px] text-on-surface-dim mt-0.5 line-clamp-2">${_escapeHtml(s.description)}</div>`;
+        grid.appendChild(btn);
+      }
+      if(!n)grid.innerHTML='<div class="col-span-full text-on-surface-dim text-[10px] italic py-4 text-center">No strategies match your search.</div>';
+    }
+    if(filterEl)filterEl.oninput=render;
+    render();
+  }catch(e){
+    console.error(e);
+    grid.innerHTML='<div class="col-span-full text-error text-[10px] py-3">Could not load strategies. Refresh the page.</div>';
+    if(countEl)countEl.textContent="";
+  }
+}
+
+loadScenarioButtons();
+loadHistory();
+doReset();
+refreshTaskScoreBlurb();
+</script>
+</body>
+</html>

server/requirements.txt

@@ -0,0 +1,6 @@
+openenv[core]>=0.2.0
+fastapi>=0.115.0
+uvicorn>=0.24.0
+
+
+

server/simulation_history.json

@@ -0,0 +1,1802 @@
+[
+  {
+    "id": "2026-04-05T10:50:54.850500+00:00",
+    "scenario": "Always Rest",
+    "scenario_id": "always_rest",
+    "task": "weekly_competitive",
+    "score": 0.035,
+    "total_steps": 168,
+    "total_posts": 0,
+    "avg_reward": 0.15,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 5497,
+      "engagement_rate": 0.0,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-05T10:50:54.859097+00:00",
+    "scenario": "Anti-Trend",
+    "scenario_id": "anti_trend",
+    "task": "weekly_competitive",
+    "score": 0.2316,
+    "total_steps": 168,
+    "total_posts": 14,
+    "avg_reward": 0.2201,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 11125,
+      "engagement_rate": 0.747,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-05T10:50:54.868624+00:00",
+    "scenario": "Bad Timing",
+    "scenario_id": "bad_timing",
+    "task": "weekly_competitive",
+    "score": 0.0937,
+    "total_steps": 168,
+    "total_posts": 49,
+    "avg_reward": 0.1611,
+    "final": {
+      "energy": 0.59,
+      "hours_since_sleep": 5,
+      "sleep_debt": 0.0,
+      "followers": 10237,
+      "engagement_rate": 0.0358,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-05T10:50:54.878099+00:00",
+    "scenario": "Balanced Creator",
+    "scenario_id": "balanced",
+    "task": "weekly_competitive",
+    "score": 0.8775,
+    "total_steps": 168,
+    "total_posts": 28,
+    "avg_reward": 0.2187,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 2,
+      "sleep_debt": 0.0,
+      "followers": 12534,
+      "engagement_rate": 0.8273,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-05T10:50:54.891038+00:00",
+    "scenario": "Burst Poster",
+    "scenario_id": "burst",
+    "task": "weekly_competitive",
+    "score": 0.6111,
+    "total_steps": 168,
+    "total_posts": 57,
+    "avg_reward": 0.2318,
+    "final": {
+      "energy": 0.44,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 11701,
+      "engagement_rate": 0.2076,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-05T10:50:54.901147+00:00",
+    "scenario": "Carousel Only",
+    "scenario_id": "carousel_only",
+    "task": "weekly_competitive",
+    "score": 0.417,
+    "total_steps": 168,
+    "total_posts": 14,
+    "avg_reward": 0.2353,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 12074,
+      "engagement_rate": 1.3175,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-05T10:50:54.911264+00:00",
+    "scenario": "Competitor Avoider",
+    "scenario_id": "comp_avoider",
+    "task": "weekly_competitive",
+    "score": 0.446,
+    "total_steps": 168,
+    "total_posts": 14,
+    "avg_reward": 0.2365,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 12678,
+      "engagement_rate": 1.8163,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-05T10:50:54.921231+00:00",
+    "scenario": "Conservative Energy",
+    "scenario_id": "conservative",
+    "task": "weekly_competitive",
+    "score": 0.2181,
+    "total_steps": 168,
+    "total_posts": 7,
+    "avg_reward": 0.1967,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 10239,
+      "engagement_rate": 0.3439,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-05T10:50:54.931980+00:00",
+    "scenario": "Content Creator",
+    "scenario_id": "content_creator",
+    "task": "weekly_competitive",
+    "score": 0.6434,
+    "total_steps": 168,
+    "total_posts": 12,
+    "avg_reward": 0.2065,
+    "final": {
+      "energy": 0.309,
+      "hours_since_sleep": 28,
+      "sleep_debt": 0.017,
+      "followers": 10931,
+      "engagement_rate": 0.525,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-05T10:50:54.942037+00:00",
+    "scenario": "Copycat",
+    "scenario_id": "copycat",
+    "task": "weekly_competitive",
+    "score": 0.6136,
+    "total_steps": 168,
+    "total_posts": 21,
+    "avg_reward": 0.1887,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 11589,
+      "engagement_rate": 0.497,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-05T10:50:54.951850+00:00",
+    "scenario": "Creator Economy",
+    "scenario_id": "creator_economy",
+    "task": "weekly_competitive",
+    "score": 0.2515,
+    "total_steps": 168,
+    "total_posts": 14,
+    "avg_reward": 0.2226,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 11994,
+      "engagement_rate": 1.3918,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-05T10:50:54.961166+00:00",
+    "scenario": "Crypto/Web3",
+    "scenario_id": "crypto_niche",
+    "task": "weekly_competitive",
+    "score": 0.2879,
+    "total_steps": 168,
+    "total_posts": 14,
+    "avg_reward": 0.2324,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 12444,
+      "engagement_rate": 1.6187,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-05T10:50:54.970461+00:00",
+    "scenario": "Double Peak",
+    "scenario_id": "double_peak",
+    "task": "weekly_competitive",
+    "score": 0.4519,
+    "total_steps": 168,
+    "total_posts": 14,
+    "avg_reward": 0.2352,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 13138,
+      "engagement_rate": 2.0814,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-05T10:50:54.980718+00:00",
+    "scenario": "Early Bird",
+    "scenario_id": "early_bird",
+    "task": "weekly_competitive",
+    "score": 0.2075,
+    "total_steps": 168,
+    "total_posts": 16,
+    "avg_reward": 0.2284,
+    "final": {
+      "energy": 0.62,
+      "hours_since_sleep": 2,
+      "sleep_debt": 0.0,
+      "followers": 10818,
+      "engagement_rate": 0.4138,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-05T10:50:54.989979+00:00",
+    "scenario": "Energy Saver",
+    "scenario_id": "energy_saver",
+    "task": "weekly_competitive",
+    "score": 0.3744,
+    "total_steps": 168,
+    "total_posts": 7,
+    "avg_reward": 0.2111,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 11080,
+      "engagement_rate": 1.5483,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-05T10:50:55.000118+00:00",
+    "scenario": "Engagement Chaser",
+    "scenario_id": "engagement_chaser",
+    "task": "weekly_competitive",
+    "score": 0.4194,
+    "total_steps": 168,
+    "total_posts": 21,
+    "avg_reward": 0.2224,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 15287,
+      "engagement_rate": 2.2466,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-05T10:50:55.009873+00:00",
+    "scenario": "Events/News",
+    "scenario_id": "events",
+    "task": "weekly_competitive",
+    "score": 0.158,
+    "total_steps": 168,
+    "total_posts": 4,
+    "avg_reward": 0.1732,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 7491,
+      "engagement_rate": 1.4388,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-05T10:50:55.018674+00:00",
+    "scenario": "Fashion Content",
+    "scenario_id": "fashion",
+    "task": "weekly_competitive",
+    "score": 0.2181,
+    "total_steps": 168,
+    "total_posts": 14,
+    "avg_reward": 0.2147,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 11135,
+      "engagement_rate": 0.7898,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-05T10:50:55.027894+00:00",
+    "scenario": "Food Creator",
+    "scenario_id": "food_creator",
+    "task": "weekly_competitive",
+    "score": 0.2612,
+    "total_steps": 168,
+    "total_posts": 15,
+    "avg_reward": 0.2293,
+    "final": {
+      "energy": 0.7,
+      "hours_since_sleep": 2,
+      "sleep_debt": 0.0,
+      "followers": 12091,
+      "engagement_rate": 1.1978,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-05T10:50:55.037230+00:00",
+    "scenario": "Gaming Niche",
+    "scenario_id": "gaming_niche",
+    "task": "weekly_competitive",
+    "score": 0.2188,
+    "total_steps": 168,
+    "total_posts": 14,
+    "avg_reward": 0.2062,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 11364,
+      "engagement_rate": 0.9138,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-05T10:50:55.047589+00:00",
+    "scenario": "Growth Focus",
+    "scenario_id": "growth_focus",
+    "task": "weekly_competitive",
+    "score": 0.2764,
+    "total_steps": 168,
+    "total_posts": 14,
+    "avg_reward": 0.2205,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 12621,
+      "engagement_rate": 1.7101,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-05T10:50:55.059854+00:00",
+    "scenario": "High Frequency",
+    "scenario_id": "high_freq",
+    "task": "weekly_competitive",
+    "score": 0.8611,
+    "total_steps": 168,
+    "total_posts": 22,
+    "avg_reward": 0.2058,
+    "final": {
+      "energy": 0.92,
+      "hours_since_sleep": 2,
+      "sleep_debt": 0.0,
+      "followers": 12654,
+      "engagement_rate": 1.079,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-05T10:50:55.072522+00:00",
+    "scenario": "Lifestyle Niche",
+    "scenario_id": "lifestyle_niche",
+    "task": "weekly_competitive",
+    "score": 0.2612,
+    "total_steps": 168,
+    "total_posts": 14,
+    "avg_reward": 0.2288,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 12251,
+      "engagement_rate": 1.6295,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-05T10:50:55.081957+00:00",
+    "scenario": "Low Frequency",
+    "scenario_id": "low_freq",
+    "task": "weekly_competitive",
+    "score": 0.3241,
+    "total_steps": 168,
+    "total_posts": 4,
+    "avg_reward": 0.1768,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 10461,
+      "engagement_rate": 1.1563,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-05T10:50:55.089553+00:00",
+    "scenario": "Marathon Runner",
+    "scenario_id": "marathon",
+    "task": "weekly_competitive",
+    "score": 0.0,
+    "total_steps": 50,
+    "total_posts": 9,
+    "avg_reward": 0.1323,
+    "final": {
+      "energy": 0.0,
+      "hours_since_sleep": 22,
+      "sleep_debt": 0.028,
+      "followers": 10137,
+      "engagement_rate": 0.157,
+      "burned_out": true
+    }
+  },
+  {
+    "id": "2026-04-05T10:50:55.095782+00:00",
+    "scenario": "Midday Focus",
+    "scenario_id": "midday",
+    "task": "weekly_competitive",
+    "score": 0.4317,
+    "total_steps": 168,
+    "total_posts": 14,
+    "avg_reward": 0.2306,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 13537,
+      "engagement_rate": 2.3076,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-05T10:50:55.106103+00:00",
+    "scenario": "Minimal Poster",
+    "scenario_id": "minimal",
+    "task": "weekly_competitive",
+    "score": 0.3658,
+    "total_steps": 168,
+    "total_posts": 7,
+    "avg_reward": 0.2039,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 10907,
+      "engagement_rate": 1.3002,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-05T10:50:55.116369+00:00",
+    "scenario": "ML/AI Deep Dive",
+    "scenario_id": "ml_deep",
+    "task": "weekly_competitive",
+    "score": 0.2266,
+    "total_steps": 168,
+    "total_posts": 14,
+    "avg_reward": 0.2197,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 11180,
+      "engagement_rate": 0.7014,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-05T10:50:55.125451+00:00",
+    "scenario": "Monday Motivation",
+    "scenario_id": "monday",
+    "task": "weekly_competitive",
+    "score": 0.2606,
+    "total_steps": 168,
+    "total_posts": 4,
+    "avg_reward": 0.159,
+    "final": {
+      "energy": 0.75,
+      "hours_since_sleep": 2,
+      "sleep_debt": 0.0,
+      "followers": 5827,
+      "engagement_rate": 0.911,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-05T10:50:55.134737+00:00",
+    "scenario": "Napper",
+    "scenario_id": "napper",
+    "task": "weekly_competitive",
+    "score": 0.3623,
+    "total_steps": 168,
+    "total_posts": 14,
+    "avg_reward": 0.2264,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 11322,
+      "engagement_rate": 0.8914,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-05T10:50:55.144641+00:00",
+    "scenario": "Night Owl",
+    "scenario_id": "night_owl",
+    "task": "weekly_competitive",
+    "score": 0.266,
+    "total_steps": 168,
+    "total_posts": 14,
+    "avg_reward": 0.194,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 11927,
+      "engagement_rate": 1.328,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-05T10:50:55.153554+00:00",
+    "scenario": "Night Shift",
+    "scenario_id": "night_shift",
+    "task": "weekly_competitive",
+    "score": 0.2105,
+    "total_steps": 168,
+    "total_posts": 16,
+    "avg_reward": 0.2453,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 11069,
+      "engagement_rate": 0.5602,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-05T10:50:55.159353+00:00",
+    "scenario": "No Rest",
+    "scenario_id": "no_rest",
+    "task": "weekly_competitive",
+    "score": 0.0,
+    "total_steps": 8,
+    "total_posts": 8,
+    "avg_reward": 0.2686,
+    "final": {
+      "energy": 0.0,
+      "hours_since_sleep": 10,
+      "sleep_debt": 0.0,
+      "followers": 10213,
+      "engagement_rate": 0.2732,
+      "burned_out": true
+    }
+  },
+  {
+    "id": "2026-04-05T10:50:55.164846+00:00",
+    "scenario": "Optimal Sleep",
+    "scenario_id": "optimal_sleep",
+    "task": "weekly_competitive",
+    "score": 0.3635,
+    "total_steps": 168,
+    "total_posts": 14,
+    "avg_reward": 0.2257,
+    "final": {
+      "energy": 0.9,
+      "hours_since_sleep": 3,
+      "sleep_debt": 0.0,
+      "followers": 11305,
+      "engagement_rate": 0.8729,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-05T10:50:55.174882+00:00",
+    "scenario": "Photography Focus",
+    "scenario_id": "photography",
+    "task": "weekly_competitive",
+    "score": 0.1838,
+    "total_steps": 168,
+    "total_posts": 16,
+    "avg_reward": 0.22,
+    "final": {
+      "energy": 0.5,
+      "hours_since_sleep": 3,
+      "sleep_debt": 0.0,
+      "followers": 10736,
+      "engagement_rate": 0.4388,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-05T10:50:55.184216+00:00",
+    "scenario": "Productivity Guru",
+    "scenario_id": "productivity",
+    "task": "weekly_competitive",
+    "score": 0.184,
+    "total_steps": 168,
+    "total_posts": 16,
+    "avg_reward": 0.227,
+    "final": {
+      "energy": 0.62,
+      "hours_since_sleep": 2,
+      "sleep_debt": 0.0,
+      "followers": 10741,
+      "engagement_rate": 0.3797,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-05T10:50:55.192896+00:00",
+    "scenario": "Queue Heavy",
+    "scenario_id": "queue_heavy",
+    "task": "weekly_competitive",
+    "score": 0.1933,
+    "total_steps": 168,
+    "total_posts": 8,
+    "avg_reward": 0.1923,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 9453,
+      "engagement_rate": 0.781,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-05T10:50:55.202107+00:00",
+    "scenario": "Queue Optimizer",
+    "scenario_id": "queue_optimizer",
+    "task": "weekly_competitive",
+    "score": 0.352,
+    "total_steps": 168,
+    "total_posts": 14,
+    "avg_reward": 0.2233,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 11215,
+      "engagement_rate": 0.8701,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-05T10:50:55.209453+00:00",
+    "scenario": "Random Actor",
+    "scenario_id": "random",
+    "task": "weekly_competitive",
+    "score": 0.0,
+    "total_steps": 22,
+    "total_posts": 11,
+    "avg_reward": 0.2318,
+    "final": {
+      "energy": 0.0,
+      "hours_since_sleep": 17,
+      "sleep_debt": 0.033,
+      "followers": 10159,
+      "engagement_rate": 0.087,
+      "burned_out": true
+    }
+  },
+  {
+    "id": "2026-04-05T10:50:55.215343+00:00",
+    "scenario": "Reel Maximizer",
+    "scenario_id": "reel_max",
+    "task": "weekly_competitive",
+    "score": 0.4344,
+    "total_steps": 168,
+    "total_posts": 14,
+    "avg_reward": 0.2295,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 13314,
+      "engagement_rate": 2.1201,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-05T10:50:55.225542+00:00",
+    "scenario": "SaaS/Business",
+    "scenario_id": "saas",
+    "task": "weekly_competitive",
+    "score": 0.2015,
+    "total_steps": 168,
+    "total_posts": 14,
+    "avg_reward": 0.2182,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 10958,
+      "engagement_rate": 0.6072,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-05T10:50:55.234793+00:00",
+    "scenario": "Sleep Conscious",
+    "scenario_id": "sleep_conscious",
+    "task": "weekly_competitive",
+    "score": 0.3635,
+    "total_steps": 168,
+    "total_posts": 14,
+    "avg_reward": 0.2257,
+    "final": {
+      "energy": 0.9,
+      "hours_since_sleep": 3,
+      "sleep_debt": 0.0,
+      "followers": 11305,
+      "engagement_rate": 0.8729,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-05T10:50:55.245249+00:00",
+    "scenario": "Sleep Debt Aware",
+    "scenario_id": "sleep_debt_aware",
+    "task": "weekly_competitive",
+    "score": 0.3745,
+    "total_steps": 168,
+    "total_posts": 14,
+    "avg_reward": 0.2293,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 11412,
+      "engagement_rate": 0.9425,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-05T10:50:55.252673+00:00",
+    "scenario": "Sleep Deprived",
+    "scenario_id": "sleep_deprived",
+    "task": "weekly_competitive",
+    "score": 0.0,
+    "total_steps": 16,
+    "total_posts": 2,
+    "avg_reward": 0.2248,
+    "final": {
+      "energy": 0.0,
+      "hours_since_sleep": 18,
+      "sleep_debt": 0.045,
+      "followers": 10215,
+      "engagement_rate": 1.0806,
+      "burned_out": true
+    }
+  },
+  {
+    "id": "2026-04-05T10:50:55.258355+00:00",
+    "scenario": "Sleep Respecting",
+    "scenario_id": "sleep_respecting",
+    "task": "weekly_competitive",
+    "score": 0.3623,
+    "total_steps": 168,
+    "total_posts": 14,
+    "avg_reward": 0.2264,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 11322,
+      "engagement_rate": 0.8914,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-05T10:50:55.268389+00:00",
+    "scenario": "Smart Agent",
+    "scenario_id": "smart",
+    "task": "weekly_competitive",
+    "score": 0.8745,
+    "total_steps": 168,
+    "total_posts": 14,
+    "avg_reward": 0.2301,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 12200,
+      "engagement_rate": 1.5557,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-05T10:50:55.276258+00:00",
+    "scenario": "Spam Post",
+    "scenario_id": "spam",
+    "task": "weekly_competitive",
+    "score": 0.0,
+    "total_steps": 4,
+    "total_posts": 4,
+    "avg_reward": 0.387,
+    "final": {
+      "energy": 0.0,
+      "hours_since_sleep": 6,
+      "sleep_debt": 0.0,
+      "followers": 10625,
+      "engagement_rate": 1.567,
+      "burned_out": true
+    }
+  },
+  {
+    "id": "2026-04-05T10:50:55.281752+00:00",
+    "scenario": "Split Schedule",
+    "scenario_id": "split_schedule",
+    "task": "weekly_competitive",
+    "score": 0.385,
+    "total_steps": 168,
+    "total_posts": 15,
+    "avg_reward": 0.2347,
+    "final": {
+      "energy": 0.75,
+      "hours_since_sleep": 2,
+      "sleep_debt": 0.0,
+      "followers": 11689,
+      "engagement_rate": 0.9724,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-05T10:50:55.291899+00:00",
+    "scenario": "Stoic Philosophy",
+    "scenario_id": "stoic",
+    "task": "weekly_competitive",
+    "score": 0.1071,
+    "total_steps": 168,
+    "total_posts": 7,
+    "avg_reward": 0.2069,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 10108,
+      "engagement_rate": 0.1578,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-05T10:50:55.301186+00:00",
+    "scenario": "Story Spammer",
+    "scenario_id": "story_spammer",
+    "task": "weekly_competitive",
+    "score": 0.1632,
+    "total_steps": 168,
+    "total_posts": 29,
+    "avg_reward": 0.1592,
+    "final": {
+      "energy": 0.87,
+      "hours_since_sleep": 2,
+      "sleep_debt": 0.0,
+      "followers": 10504,
+      "engagement_rate": 0.1285,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-05T10:50:55.310194+00:00",
+    "scenario": "Tag Exploiter",
+    "scenario_id": "tag_exploiter",
+    "task": "weekly_competitive",
+    "score": 0.2922,
+    "total_steps": 168,
+    "total_posts": 14,
+    "avg_reward": 0.2358,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 13696,
+      "engagement_rate": 2.2487,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-05T10:50:55.320255+00:00",
+    "scenario": "Tag Explorer",
+    "scenario_id": "tag_explorer",
+    "task": "weekly_competitive",
+    "score": 0.8323,
+    "total_steps": 168,
+    "total_posts": 15,
+    "avg_reward": 0.2253,
+    "final": {
+      "energy": 0.94,
+      "hours_since_sleep": 2,
+      "sleep_debt": 0.0,
+      "followers": 11351,
+      "engagement_rate": 0.7735,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-05T10:50:55.333620+00:00",
+    "scenario": "Tech Niche",
+    "scenario_id": "tech_niche",
+    "task": "weekly_competitive",
+    "score": 0.2001,
+    "total_steps": 168,
+    "total_posts": 14,
+    "avg_reward": 0.215,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 10770,
+      "engagement_rate": 0.533,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-05T10:50:55.343185+00:00",
+    "scenario": "Text Only",
+    "scenario_id": "text_only",
+    "task": "weekly_competitive",
+    "score": 0.1583,
+    "total_steps": 168,
+    "total_posts": 21,
+    "avg_reward": 0.1857,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 10485,
+      "engagement_rate": 0.234,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-05T10:50:55.352680+00:00",
+    "scenario": "Travel Blogger",
+    "scenario_id": "travel",
+    "task": "weekly_competitive",
+    "score": 0.2975,
+    "total_steps": 168,
+    "total_posts": 14,
+    "avg_reward": 0.2307,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 12749,
+      "engagement_rate": 1.9614,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-05T10:50:55.362329+00:00",
+    "scenario": "Trend Chaser",
+    "scenario_id": "trend_chaser",
+    "task": "weekly_competitive",
+    "score": 0.4344,
+    "total_steps": 168,
+    "total_posts": 14,
+    "avg_reward": 0.2413,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 14148,
+      "engagement_rate": 2.6985,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-05T10:50:55.373024+00:00",
+    "scenario": "Tuesday Thursday",
+    "scenario_id": "tue_thu",
+    "task": "weekly_competitive",
+    "score": 0.1826,
+    "total_steps": 168,
+    "total_posts": 4,
+    "avg_reward": 0.1731,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 9154,
+      "engagement_rate": 3.4748,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-05T10:50:55.382708+00:00",
+    "scenario": "Weekday Only",
+    "scenario_id": "weekday_only",
+    "task": "weekly_competitive",
+    "score": 0.2366,
+    "total_steps": 168,
+    "total_posts": 10,
+    "avg_reward": 0.2046,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 9810,
+      "engagement_rate": 1.0028,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-05T10:50:55.392284+00:00",
+    "scenario": "Weekend Warrior",
+    "scenario_id": "weekend",
+    "task": "weekly_competitive",
+    "score": 0.1257,
+    "total_steps": 168,
+    "total_posts": 6,
+    "avg_reward": 0.1648,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 7659,
+      "engagement_rate": 0.635,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-05T10:51:44.770556+00:00",
+    "scenario": "Aggressive Energy",
+    "scenario_id": "aggressive",
+    "task": "weekly_competitive",
+    "score": 0.8255,
+    "total_steps": 168,
+    "total_posts": 29,
+    "avg_reward": 0.1875,
+    "final": {
+      "energy": 0.75,
+      "hours_since_sleep": 2,
+      "sleep_debt": 0.0,
+      "followers": 13021,
+      "engagement_rate": 0.8084,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-06T14:25:47.636598+00:00",
+    "scenario": "Sleep Respecting",
+    "scenario_id": "sleep_respecting",
+    "task": "weekly_competitive",
+    "score": 0.3623,
+    "total_steps": 168,
+    "total_posts": 14,
+    "avg_reward": 0.2264,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 11322,
+      "engagement_rate": 0.8914,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-06T14:26:41.631567+00:00",
+    "scenario": "Creator Economy",
+    "scenario_id": "creator_economy",
+    "task": "weekly_competitive",
+    "score": 0.2515,
+    "total_steps": 168,
+    "total_posts": 14,
+    "avg_reward": 0.2226,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 11994,
+      "engagement_rate": 1.3918,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-06T14:27:32.195059+00:00",
+    "scenario": "Weekday Only",
+    "scenario_id": "weekday_only",
+    "task": "weekly_competitive",
+    "score": 0.2366,
+    "total_steps": 168,
+    "total_posts": 10,
+    "avg_reward": 0.2046,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 9810,
+      "engagement_rate": 1.0028,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-06T14:28:12.547146+00:00",
+    "scenario": "Weekday Only",
+    "scenario_id": "weekday_only",
+    "task": "weekly_competitive",
+    "score": 0.2366,
+    "total_steps": 168,
+    "total_posts": 10,
+    "avg_reward": 0.2046,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 9810,
+      "engagement_rate": 1.0028,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-06T14:29:19.356814+00:00",
+    "scenario": "No Rest",
+    "scenario_id": "no_rest",
+    "task": "weekly_engage",
+    "score": 0.027,
+    "total_steps": 8,
+    "total_posts": 8,
+    "avg_reward": 0.2686,
+    "final": {
+      "energy": 0.0,
+      "hours_since_sleep": 10,
+      "sleep_debt": 0.0,
+      "followers": 10213,
+      "engagement_rate": 0.2732,
+      "burned_out": true
+    }
+  },
+  {
+    "id": "2026-04-06T14:29:21.996045+00:00",
+    "scenario": "No Rest",
+    "scenario_id": "no_rest",
+    "task": "weekly_engage",
+    "score": 0.027,
+    "total_steps": 8,
+    "total_posts": 8,
+    "avg_reward": 0.2686,
+    "final": {
+      "energy": 0.0,
+      "hours_since_sleep": 10,
+      "sleep_debt": 0.0,
+      "followers": 10213,
+      "engagement_rate": 0.2732,
+      "burned_out": true
+    }
+  },
+  {
+    "id": "2026-04-06T14:29:33.742894+00:00",
+    "scenario": "Text Only",
+    "scenario_id": "text_only",
+    "task": "weekly_engage",
+    "score": 0.2049,
+    "total_steps": 168,
+    "total_posts": 21,
+    "avg_reward": 0.1857,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 10485,
+      "engagement_rate": 0.234,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-06T14:29:39.176314+00:00",
+    "scenario": "Gaming Niche",
+    "scenario_id": "gaming_niche",
+    "task": "weekly_engage",
+    "score": 0.5658,
+    "total_steps": 168,
+    "total_posts": 14,
+    "avg_reward": 0.2062,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 11364,
+      "engagement_rate": 0.9138,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-06T14:29:50.321368+00:00",
+    "scenario": "Midday Focus",
+    "scenario_id": "midday",
+    "task": "weekly_engage",
+    "score": 1.0,
+    "total_steps": 168,
+    "total_posts": 14,
+    "avg_reward": 0.2306,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 13537,
+      "engagement_rate": 2.3076,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-06T17:52:48.224991+00:00",
+    "scenario": "Double Peak",
+    "scenario_id": "double_peak",
+    "task": "weekly_competitive",
+    "score": 0.4519,
+    "total_steps": 168,
+    "total_posts": 14,
+    "avg_reward": 0.2352,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 13138,
+      "engagement_rate": 2.0814,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-06T17:53:45.401024+00:00",
+    "scenario": "Photography Focus",
+    "scenario_id": "photography",
+    "task": "weekly_competitive",
+    "score": 0.1838,
+    "total_steps": 168,
+    "total_posts": 16,
+    "avg_reward": 0.22,
+    "final": {
+      "energy": 0.5,
+      "hours_since_sleep": 3,
+      "sleep_debt": 0.0,
+      "followers": 10736,
+      "engagement_rate": 0.4388,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-06T17:54:16.540951+00:00",
+    "scenario": "Burst Poster",
+    "scenario_id": "burst",
+    "task": "weekly_competitive",
+    "score": 0.6111,
+    "total_steps": 168,
+    "total_posts": 57,
+    "avg_reward": 0.2318,
+    "final": {
+      "energy": 0.44,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 11701,
+      "engagement_rate": 0.2076,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-06T17:54:39.699482+00:00",
+    "scenario": "Engagement Chaser",
+    "scenario_id": "engagement_chaser",
+    "task": "weekly_competitive",
+    "score": 0.4194,
+    "total_steps": 168,
+    "total_posts": 21,
+    "avg_reward": 0.2224,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 15287,
+      "engagement_rate": 2.2466,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-06T18:09:31.470202+00:00",
+    "scenario": "Lifestyle Niche",
+    "scenario_id": "lifestyle_niche",
+    "task": "weekly_competitive",
+    "score": 0.2612,
+    "total_steps": 168,
+    "total_posts": 14,
+    "avg_reward": 0.2288,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 12251,
+      "engagement_rate": 1.6295,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-06T18:09:42.791462+00:00",
+    "scenario": "Content Creator",
+    "scenario_id": "content_creator",
+    "task": "weekly_competitive",
+    "score": 0.6434,
+    "total_steps": 168,
+    "total_posts": 12,
+    "avg_reward": 0.2065,
+    "final": {
+      "energy": 0.309,
+      "hours_since_sleep": 28,
+      "sleep_debt": 0.017,
+      "followers": 10931,
+      "engagement_rate": 0.525,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-06T18:25:35.360345+00:00",
+    "scenario": "Anti-Trend",
+    "scenario_id": "anti_trend",
+    "task": "weekly_competitive",
+    "score": 0.2316,
+    "total_steps": 168,
+    "total_posts": 14,
+    "avg_reward": 0.2201,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 11125,
+      "engagement_rate": 0.747,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-06T18:28:21.455943+00:00",
+    "scenario": "Fashion Content",
+    "scenario_id": "fashion",
+    "task": "weekly_competitive",
+    "score": 0.2181,
+    "total_steps": 168,
+    "total_posts": 14,
+    "avg_reward": 0.2147,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 11135,
+      "engagement_rate": 0.7898,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-06T18:28:26.860641+00:00",
+    "scenario": "Low Frequency",
+    "scenario_id": "low_freq",
+    "task": "weekly_competitive",
+    "score": 0.3241,
+    "total_steps": 168,
+    "total_posts": 4,
+    "avg_reward": 0.1768,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 10461,
+      "engagement_rate": 1.1563,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-06T18:28:36.279972+00:00",
+    "scenario": "Balanced Creator",
+    "scenario_id": "balanced",
+    "task": "weekly_competitive",
+    "score": 0.8775,
+    "total_steps": 168,
+    "total_posts": 28,
+    "avg_reward": 0.2187,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 2,
+      "sleep_debt": 0.0,
+      "followers": 12534,
+      "engagement_rate": 0.8273,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-06T18:29:19.542258+00:00",
+    "scenario": "Napper",
+    "scenario_id": "napper",
+    "task": "weekly_competitive",
+    "score": 0.3623,
+    "total_steps": 168,
+    "total_posts": 14,
+    "avg_reward": 0.2264,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 11322,
+      "engagement_rate": 0.8914,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-06T19:48:37.931282+00:00",
+    "scenario": "Optimal Sleep",
+    "scenario_id": "optimal_sleep",
+    "task": "weekly_competitive",
+    "score": 0.3635,
+    "total_steps": 168,
+    "total_posts": 14,
+    "avg_reward": 0.2257,
+    "final": {
+      "energy": 0.9,
+      "hours_since_sleep": 3,
+      "sleep_debt": 0.0,
+      "followers": 11305,
+      "engagement_rate": 0.8729,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-06T19:49:01.327141+00:00",
+    "scenario": "Marathon Runner",
+    "scenario_id": "marathon",
+    "task": "weekly_competitive",
+    "score": 0.0,
+    "total_steps": 50,
+    "total_posts": 9,
+    "avg_reward": 0.1323,
+    "final": {
+      "energy": 0.0,
+      "hours_since_sleep": 22,
+      "sleep_debt": 0.028,
+      "followers": 10137,
+      "engagement_rate": 0.157,
+      "burned_out": true
+    }
+  },
+  {
+    "id": "2026-04-06T19:49:13.972097+00:00",
+    "scenario": "Balanced Creator",
+    "scenario_id": "balanced",
+    "task": "weekly_competitive",
+    "score": 0.8775,
+    "total_steps": 168,
+    "total_posts": 28,
+    "avg_reward": 0.2187,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 2,
+      "sleep_debt": 0.0,
+      "followers": 12534,
+      "engagement_rate": 0.8273,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-06T19:49:37.864235+00:00",
+    "scenario": "Engagement Chaser",
+    "scenario_id": "engagement_chaser",
+    "task": "weekly_competitive",
+    "score": 0.4194,
+    "total_steps": 168,
+    "total_posts": 21,
+    "avg_reward": 0.2224,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 15287,
+      "engagement_rate": 2.2466,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-06T19:50:08.348742+00:00",
+    "scenario": "Early Bird",
+    "scenario_id": "early_bird",
+    "task": "weekly_competitive",
+    "score": 0.2075,
+    "total_steps": 168,
+    "total_posts": 16,
+    "avg_reward": 0.2284,
+    "final": {
+      "energy": 0.62,
+      "hours_since_sleep": 2,
+      "sleep_debt": 0.0,
+      "followers": 10818,
+      "engagement_rate": 0.4138,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-06T19:50:15.765261+00:00",
+    "scenario": "Queue Heavy",
+    "scenario_id": "queue_heavy",
+    "task": "weekly_competitive",
+    "score": 0.1933,
+    "total_steps": 168,
+    "total_posts": 8,
+    "avg_reward": 0.1923,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 9453,
+      "engagement_rate": 0.781,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-06T19:50:26.015235+00:00",
+    "scenario": "Balanced Creator",
+    "scenario_id": "balanced",
+    "task": "weekly_competitive",
+    "score": 0.8775,
+    "total_steps": 168,
+    "total_posts": 28,
+    "avg_reward": 0.2187,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 2,
+      "sleep_debt": 0.0,
+      "followers": 12534,
+      "engagement_rate": 0.8273,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-06T19:50:30.364460+00:00",
+    "scenario": "High Frequency",
+    "scenario_id": "high_freq",
+    "task": "weekly_competitive",
+    "score": 0.8611,
+    "total_steps": 168,
+    "total_posts": 22,
+    "avg_reward": 0.2058,
+    "final": {
+      "energy": 0.92,
+      "hours_since_sleep": 2,
+      "sleep_debt": 0.0,
+      "followers": 12654,
+      "engagement_rate": 1.079,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-06T19:50:38.185556+00:00",
+    "scenario": "Sleep Conscious",
+    "scenario_id": "sleep_conscious",
+    "task": "weekly_competitive",
+    "score": 0.3635,
+    "total_steps": 168,
+    "total_posts": 14,
+    "avg_reward": 0.2257,
+    "final": {
+      "energy": 0.9,
+      "hours_since_sleep": 3,
+      "sleep_debt": 0.0,
+      "followers": 11305,
+      "engagement_rate": 0.8729,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-06T19:50:44.256241+00:00",
+    "scenario": "Burst Poster",
+    "scenario_id": "burst",
+    "task": "weekly_competitive",
+    "score": 0.6111,
+    "total_steps": 168,
+    "total_posts": 57,
+    "avg_reward": 0.2318,
+    "final": {
+      "energy": 0.44,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 11701,
+      "engagement_rate": 0.2076,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-06T19:51:00.755964+00:00",
+    "scenario": "Queue Optimizer",
+    "scenario_id": "queue_optimizer",
+    "task": "weekly_competitive",
+    "score": 0.352,
+    "total_steps": 168,
+    "total_posts": 14,
+    "avg_reward": 0.2233,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 11215,
+      "engagement_rate": 0.8701,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-07T19:19:06.982475+00:00",
+    "scenario": "Easy: Afternoon story",
+    "scenario_id": "easy_relaxed",
+    "task": "weekly_engage",
+    "score": 0.0776,
+    "total_steps": 168,
+    "total_posts": 7,
+    "avg_reward": 0.1885,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 10185,
+      "engagement_rate": 0.2689,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-07T19:25:22.760913+00:00",
+    "scenario": "Medium: Reel + carousel day",
+    "scenario_id": "medium_two_format",
+    "task": "weekly_engage",
+    "score": 1.0,
+    "total_steps": 168,
+    "total_posts": 14,
+    "avg_reward": 0.2305,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 13498,
+      "engagement_rate": 2.3223,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-07T19:37:07.163654+00:00",
+    "scenario": "Easy: Morning story",
+    "scenario_id": "easy_morning_story",
+    "task": "weekly_engage",
+    "score": 0.1126,
+    "total_steps": 168,
+    "total_posts": 7,
+    "avg_reward": 0.2064,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 10269,
+      "engagement_rate": 0.3903,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-07T19:37:08.936466+00:00",
+    "scenario": "Easy: One text at 1pm",
+    "scenario_id": "easy_one_a_day",
+    "task": "weekly_engage",
+    "score": 0.0992,
+    "total_steps": 168,
+    "total_posts": 7,
+    "avg_reward": 0.1933,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 10239,
+      "engagement_rate": 0.3439,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-07T19:37:10.555676+00:00",
+    "scenario": "Easy: Afternoon story",
+    "scenario_id": "easy_relaxed",
+    "task": "weekly_engage",
+    "score": 0.0776,
+    "total_steps": 168,
+    "total_posts": 7,
+    "avg_reward": 0.1885,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 10185,
+      "engagement_rate": 0.2689,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-07T19:37:12.240540+00:00",
+    "scenario": "Medium: Create then post",
+    "scenario_id": "medium_queue_cycle",
+    "task": "weekly_engage",
+    "score": 0.8459,
+    "total_steps": 168,
+    "total_posts": 14,
+    "avg_reward": 0.2318,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 12045,
+      "engagement_rate": 1.3511,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-07T19:37:14.032300+00:00",
+    "scenario": "Medium: Trend + format rotation",
+    "scenario_id": "medium_trend_rotate",
+    "task": "weekly_engage",
+    "score": 0.5524,
+    "total_steps": 168,
+    "total_posts": 14,
+    "avg_reward": 0.2265,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 11332,
+      "engagement_rate": 0.9003,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-07T19:37:15.697454+00:00",
+    "scenario": "Medium: Reel + carousel day",
+    "scenario_id": "medium_two_format",
+    "task": "weekly_engage",
+    "score": 1.0,
+    "total_steps": 168,
+    "total_posts": 14,
+    "avg_reward": 0.2305,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 13498,
+      "engagement_rate": 2.3223,
+      "burned_out": false
+    }
+  },
+  {
+    "id": "2026-04-07T19:38:24.165792+00:00",
+    "scenario": "Easy: One text at 1pm",
+    "scenario_id": "easy_one_a_day",
+    "task": "weekly_engage",
+    "score": 0.0992,
+    "total_steps": 168,
+    "total_posts": 7,
+    "avg_reward": 0.1933,
+    "final": {
+      "energy": 1.0,
+      "hours_since_sleep": 1,
+      "sleep_debt": 0.0,
+      "followers": 10239,
+      "engagement_rate": 0.3439,
+      "burned_out": false
+    }
+  }
+]

server/viraltest_environment.py

@@ -0,0 +1,844 @@
+"""
+Viraltest Environment — RL-Based Creator Optimization Simulation.
+
+Simulates a social media creator's weekly posting lifecycle.
+The agent decides when to post, what format, which tags, and how
+to differentiate from competitors, while managing burnout.
+"""
+
+import random
+from collections import defaultdict
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional
+from uuid import uuid4
+
+from openenv.core.env_server.interfaces import Environment
+from openenv.core.env_server.types import State
+
+try:
+    from ..models import ScheduledAction, ViraltestAction, ViraltestObservation
+except ImportError:
+    from models import ScheduledAction, ViraltestAction, ViraltestObservation
+
+# ---------------------------------------------------------------------------
+# Constants (research-backed)
+# ---------------------------------------------------------------------------
+
+TASK_HORIZON = 7  # 7 daily steps (each step simulates 24 hours internally)
+
+CONTENT_ENERGY_COST = {
+    "reel": 0.25,
+    "carousel": 0.20,
+    "story": 0.08,
+    "text_post": 0.06,
+}
+
+BASE_ENGAGEMENT = {
+    "reel": 0.52,
+    "carousel": 0.55,
+    "story": 0.30,
+    "text_post": 0.37,
+}
+
+REACH_MULT = {
+    "reel": 2.25,
+    "carousel": 1.0,
+    "story": 0.5,
+    "text_post": 0.44,
+}
+
+TAG_POOL = [
+    # Tech
+    "ai", "ml", "coding", "startup", "saas", "devtools",
+    # Lifestyle
+    "fitness", "travel", "food", "wellness", "fashion", "photography",
+    # Trending (base set — rotated daily)
+    "summer", "worldcup", "election", "newyear", "oscars", "climate",
+    # Niche
+    "productivity", "minimalism", "stoic", "web3", "gaming", "crypto",
+    # Broad
+    "motivation", "tips", "howto", "viral", "trending", "growth",
+]
+
+TOPIC_CATEGORIES = {
+    "tech": ["AI tools", "coding tips", "startup life", "tech news", "SaaS growth", "dev workflow"],
+    "lifestyle": ["fitness routine", "travel guide", "food recipe", "wellness tips", "fashion haul", "photo editing"],
+    "business": ["growth hacks", "marketing strategy", "creator economy", "monetization", "brand deals", "analytics"],
+}
+
+VALID_TASKS = ("weekly_engage", "weekly_strategic", "weekly_competitive")
+
+# Hour multipliers (Buffer 9.6M post study)
+PEAK_HOURS = {
+    "weekday_morning": (9, 12, 1.3),
+    "weekday_peak": (12, 15, 1.4),
+    "evening": (18, 20, 1.25),
+    "late_evening": (20, 23, 1.1),
+    "night": (23, 6, 0.5),
+    "off_hours": (6, 9, 0.8),
+}
+
+WEEKEND_PENALTY = 0.7
+PEAK_DAYS = (1, 2, 3)  # Tue, Wed, Thu (0=Mon)
+
+
+@dataclass
+class CompetitorState:
+    name: str
+    niche_topics: List[str]
+    preferred_types: List[str]
+    posting_frequency: float
+    base_engagement: float
+    tag_preferences: List[str]
+    recent_posts: List[Dict[str, Any]] = field(default_factory=list)
+
+
+COMPETITOR_PROFILES = [
+    {
+        "name": "creator_alpha",
+        "niche_topics": ["AI tools", "coding tips", "tech news"],
+        "preferred_types": ["reel", "carousel"],
+        "posting_frequency": 2.5,
+        "base_engagement": 0.45,
+        "tag_preferences": ["ai", "coding", "tech news"],
+    },
+    {
+        "name": "creator_beta",
+        "niche_topics": ["growth hacks", "marketing strategy", "creator economy"],
+        "preferred_types": ["carousel", "text_post"],
+        "posting_frequency": 1.8,
+        "base_engagement": 0.40,
+        "tag_preferences": ["growth", "tips", "viral"],
+    },
+    {
+        "name": "creator_gamma",
+        "niche_topics": ["fitness routine", "wellness tips", "motivation"],
+        "preferred_types": ["reel", "story"],
+        "posting_frequency": 3.0,
+        "base_engagement": 0.38,
+        "tag_preferences": ["fitness", "wellness", "motivation"],
+    },
+]
+
+INITIAL_FOLLOWERS = 10000
+REST_RECOVERY = 0.12
+CREATE_CONTENT_COST = 0.05
+REPETITION_ENERGY_PENALTY = 0.05
+AUDIENCE_FATIGUE_THRESHOLD_1 = 3
+AUDIENCE_FATIGUE_THRESHOLD_2 = 5
+FOLLOWER_DECAY_HOURS = 48
+ALGORITHM_PENALTY_MULT = 0.6
+ALGORITHM_PENALTY_DURATION = 2
+
+# Sleep mechanics (research-backed: Frontiers Neuroscience 2025, Frontiers Human Neuroscience 2014)
+# - Cognitive performance follows a continuous decay curve, not step functions
+# - Full night deprivation (~24hrs) impairs performance by ~50%
+# - Uses exponential decay: quality = 1.0 * (0.5 ^ ((hours - optimal) / halflife))
+SLEEP_OPTIMAL_AWAKE = 14  # Hours awake with no performance impact
+SLEEP_HALFLIFE_HOURS = 10  # Hours beyond optimal for quality to halve
+SLEEP_MIN_QUALITY = 0.30  # Floor for sleep-based quality (can't go below 30%)
+SLEEP_ENERGY_DRAIN_START = 16  # Hours awake before extra energy drain kicks in
+SLEEP_ENERGY_DRAIN_RATE = 0.015  # Energy drain per hour when sleep deprived
+SLEEP_RECOVERY_PER_REST = 2  # Hours of "sleep credit" per rest action (rest = nap)
+
+
+# ---------------------------------------------------------------------------
+# Environment
+# ---------------------------------------------------------------------------
+
+class ViraltestEnvironment(Environment):
+    """
+    Weekly creator optimization simulation.
+
+    The agent manages a social media creator's posting strategy over 7 days
+    (168 hourly steps), balancing engagement, energy, tags, and competition.
+    """
+
+    SUPPORTS_CONCURRENT_SESSIONS: bool = True
+
+    def __init__(self) -> None:
+        self._state = State(episode_id=str(uuid4()), step_count=0)
+        self._task = "weekly_engage"
+        self._rng = random.Random(42)
+        self._init_state()
+
+    def _init_state(self) -> None:
+        self._energy = 1.0
+        self._followers = INITIAL_FOLLOWERS
+        self._initial_followers = INITIAL_FOLLOWERS
+        self._hour = 9
+        self._day = 0  # 0=Mon
+        self._posts_today = 0
+        self._last_post_types: List[str] = []
+        self._time_since_last_post = 0
+        self._engagement_history: List[float] = []
+        self._tag_history: Dict[str, List[float]] = defaultdict(list)
+        self._content_queue = 0
+        self._unique_tags_used: set = set()
+        self._unique_content_types: set = set()
+        self._energy_history: List[float] = [1.0]
+        self._posting_steps = 0
+        self._episode_done = False
+        self._last_topic: Optional[str] = None
+        self._final_observation: Optional[ViraltestObservation] = None
+        self._unique_topic_steps = 0
+        self._days_with_good_posts: set = set()
+        self._total_engagement = 0.0
+        self._posts_per_day: Dict[int, int] = defaultdict(int)
+        self._algorithm_penalty_remaining = 0
+
+        self._trending_topics = self._pick_trending_topics()
+        self._trending_tags = self._pick_trending_tags()
+        self._competitors = [CompetitorState(**p) for p in COMPETITOR_PROFILES]
+
+        # Sleep state: creator starts well-rested at 9am (awake since ~7am)
+        self._hours_since_sleep = 2  # Woke up 2 hours ago at start (9am)
+        self._sleep_debt = 0.0  # 0 = fully rested, 1 = severe deprivation
+
+    # ----- trend rotation -----
+
+    def _pick_trending_topics(self) -> List[str]:
+        all_topics = []
+        for cat_topics in TOPIC_CATEGORIES.values():
+            all_topics.extend(cat_topics)
+        return self._rng.sample(all_topics, min(3, len(all_topics)))
+
+    def _pick_trending_tags(self) -> List[str]:
+        return self._rng.sample(TAG_POOL, min(5, len(TAG_POOL)))
+
+    def _rotate_trends(self) -> None:
+        self._trending_topics = self._pick_trending_topics()
+        self._trending_tags = self._pick_trending_tags()
+
+    # ----- hour multiplier -----
+
+    def _get_hour_multiplier(self) -> float:
+        h = self._hour
+        d = self._day
+
+        is_weekend = d >= 5
+        base = WEEKEND_PENALTY if is_weekend else 1.0
+
+        if 12 <= h < 15 and d in PEAK_DAYS:
+            return base * 1.4
+        if 9 <= h < 12:
+            return base * 1.3
+        if 18 <= h < 20:
+            return base * 1.25
+        if 20 <= h < 23:
+            return base * 1.1
+        if h >= 23 or h < 6:
+            return base * 0.5
+        return base * 0.8
+
+    # ----- quality -----
+
+    def _get_quality_modifier(self) -> float:
+        """
+        Quality affected by both energy and sleep debt.
+        
+        Sleep uses exponential decay curve (not step function):
+        - No impact until SLEEP_OPTIMAL_AWAKE hours (14hrs)
+        - Then: quality = 0.5 ^ ((hours - optimal) / halflife)
+        - At 24hrs awake: ~50% quality (matches research)
+        - Floor at SLEEP_MIN_QUALITY (30%)
+        """
+        # Energy component (existing logic)
+        if self._energy > 0.5:
+            energy_factor = 1.0
+        else:
+            energy_factor = max(0.48, self._energy * 1.5)
+
+        # Sleep component - exponential decay curve
+        if self._hours_since_sleep <= SLEEP_OPTIMAL_AWAKE:
+            sleep_factor = 1.0
+        else:
+            hours_over = self._hours_since_sleep - SLEEP_OPTIMAL_AWAKE
+            # Exponential decay: halves every SLEEP_HALFLIFE_HOURS
+            sleep_factor = 0.5 ** (hours_over / SLEEP_HALFLIFE_HOURS)
+            sleep_factor = max(SLEEP_MIN_QUALITY, sleep_factor)
+
+        return energy_factor * sleep_factor
+
+    # ----- tags -----
+
+    def _calc_tag_boost(self, tags: Optional[List[str]]) -> float:
+        if not tags:
+            return 1.0
+        trending_count = sum(1 for t in tags if t in self._trending_tags)
+        perf_values = [
+            self._tag_performance_avg(t) for t in tags if self._tag_performance_avg(t) > 0
+        ]
+        perf_avg = sum(perf_values) / len(perf_values) if perf_values else 0.0
+        return 1.0 + 0.1 * trending_count + 0.05 * perf_avg
+
+    def _tag_performance_avg(self, tag: str) -> float:
+        history = self._tag_history.get(tag, [])
+        if not history:
+            return 0.0
+        window = history[-5:]
+        return sum(window) / len(window)
+
+    def _get_tag_performance_dict(self) -> Dict[str, float]:
+        return {tag: self._tag_performance_avg(tag) for tag in self._unique_tags_used}
+
+    # ----- competitors -----
+
+    def _advance_competitors(self) -> None:
+        for comp in self._competitors:
+            for p in comp.recent_posts:
+                p["hours_ago"] += 1
+            comp.recent_posts = [p for p in comp.recent_posts if p["hours_ago"] < 48]
+
+            post_prob = comp.posting_frequency / 24.0
+            if self._rng.random() < post_prob:
+                ct = self._rng.choice(comp.preferred_types)
+                topic = self._rng.choice(comp.niche_topics)
+                tags = self._rng.sample(
+                    comp.tag_preferences, min(3, len(comp.tag_preferences))
+                )
+                eng = comp.base_engagement + self._rng.uniform(-0.1, 0.1)
+                eng = max(0.0, min(1.0, eng))
+                comp.recent_posts.append({
+                    "content_type": ct,
+                    "topic": topic,
+                    "tags": tags,
+                    "engagement": round(eng, 3),
+                    "hours_ago": 0,
+                })
+
+    def _get_competitor_recent_posts(self, limit: int = 5) -> List[Dict[str, Any]]:
+        all_posts: List[Dict[str, Any]] = []
+        for comp in self._competitors:
+            for p in comp.recent_posts:
+                all_posts.append(p)
+        all_posts.sort(key=lambda x: x["hours_ago"])
+        return all_posts[:limit]
+
+    def _get_competitor_avg_engagement(self) -> float:
+        engagements = []
+        for comp in self._competitors:
+            for p in comp.recent_posts:
+                engagements.append(p["engagement"])
+        return sum(engagements) / len(engagements) if engagements else 0.0
+
+    def _calc_niche_saturation(self, topic: Optional[str]) -> float:
+        if not topic:
+            return 0.0
+        recent_topics = []
+        for comp in self._competitors:
+            for p in comp.recent_posts:
+                if p["hours_ago"] < 12:
+                    recent_topics.append(p["topic"].lower())
+        if not recent_topics:
+            return 0.0
+        topic_lower = topic.lower()
+        overlap = sum(1 for t in recent_topics if _topic_overlap(topic_lower, t))
+        return min(1.0, overlap / max(1, len(recent_topics)))
+
+    def _calc_competitor_diff(self, topic: Optional[str]) -> float:
+        if not topic:
+            return 1.0
+        saturation = self._calc_niche_saturation(topic)
+        recent_topics = []
+        for comp in self._competitors:
+            for p in comp.recent_posts:
+                if p["hours_ago"] < 12:
+                    recent_topics.append(p["topic"].lower())
+        topic_lower = topic.lower()
+        has_overlap = any(_topic_overlap(topic_lower, t) for t in recent_topics)
+        if not has_overlap:
+            return 1.3
+        if saturation > 0.7:
+            return 0.6
+        return 1.0
+
+    # ----- core API -----
+
+    def reset(
+        self,
+        seed: Optional[int] = None,
+        episode_id: Optional[str] = None,
+        **kwargs: Any,
+    ) -> ViraltestObservation:
+        self._task = kwargs.get("task", "weekly_engage")
+        if self._task not in VALID_TASKS:
+            self._task = "weekly_engage"
+
+        self._rng = random.Random(seed if seed is not None else 42)
+        self._state = State(
+            episode_id=episode_id or str(uuid4()), step_count=0
+        )
+        self._init_state()
+
+        return self._build_observation(reward=0.0, error=None)
+
+    def step(self, action: ViraltestAction, **kwargs: Any) -> ViraltestObservation:  # type: ignore[override]
+        """Process a daily step: run 24 hourly sub-steps using the sparse schedule."""
+        if self._episode_done and self._final_observation is not None:
+            return self._final_observation
+
+        self._state.step_count += 1
+
+        schedule: Dict[int, ScheduledAction] = {}
+        errors: List[str] = []
+        for sa in action.scheduled_actions:
+            if sa.hour < 0 or sa.hour > 23:
+                errors.append(f"Invalid hour: {sa.hour}")
+                continue
+            err = self._validate_scheduled_action(sa)
+            if err:
+                errors.append(f"hour {sa.hour}: {err}")
+                continue
+            schedule[sa.hour] = sa
+
+        daily_engagement = 0.0
+        daily_reward = 0.0
+        daily_posts = 0
+        energy_min = self._energy
+        burned_out = False
+
+        for hour in range(24):
+            if burned_out:
+                break
+
+            if hour in schedule:
+                sa = schedule[hour]
+                hourly_eng, hourly_reward = self._process_hour_action(sa)
+            else:
+                hourly_eng, hourly_reward = self._process_hour_rest()
+
+            daily_engagement += hourly_eng
+            daily_reward += hourly_reward
+            if hourly_eng > 0:
+                daily_posts += 1
+            energy_min = min(energy_min, self._energy)
+
+            self._advance_competitors()
+            self._advance_time()
+            self._energy_history.append(self._energy)
+
+            if self._energy <= 0.0:
+                burned_out = True
+
+        day_posts = self._posts_per_day.get(self._day - 1, 0) if self._day > 0 else self._posts_per_day.get(0, 0)
+        prev_day = max(0, self._day - 1)
+        if 1 <= self._posts_per_day.get(prev_day, 0) <= 2:
+            self._days_with_good_posts.add(prev_day)
+
+        avg_reward = daily_reward / 24.0
+
+        error_str = "; ".join(errors) if errors else None
+
+        done = self._state.step_count >= TASK_HORIZON or self._energy <= 0.0
+        if done:
+            self._episode_done = True
+            grader_score = self._run_grader()
+            self._final_observation = self._build_observation(
+                reward=round(avg_reward, 4),
+                error=error_str,
+                done=True,
+                grader_score=grader_score,
+                daily_total_engagement=daily_engagement,
+                daily_posts_made=daily_posts,
+                daily_energy_min=energy_min,
+            )
+            return self._final_observation
+
+        return self._build_observation(
+            reward=round(avg_reward, 4),
+            error=error_str,
+            daily_total_engagement=daily_engagement,
+            daily_posts_made=daily_posts,
+            daily_energy_min=energy_min,
+        )
+
+    def _process_hour_action(self, sa: ScheduledAction) -> tuple:
+        """Process a single scheduled (non-rest) hourly action. Returns (engagement, reward)."""
+        engagement = 0.0
+
+        if sa.action_type == "post":
+            cost = CONTENT_ENERGY_COST.get(sa.content_type, 0.1)  # type: ignore[arg-type]
+            if self._content_queue > 0:
+                cost *= 0.5
+                self._content_queue -= 1
+            if len(self._last_post_types) >= 3 and all(
+                t == sa.content_type for t in self._last_post_types[-3:]
+            ):
+                cost += REPETITION_ENERGY_PENALTY
+            self._energy = max(0.0, self._energy - cost)
+            self._unique_content_types.add(sa.content_type)  # type: ignore[arg-type]
+
+            if self._energy <= 0.0:
+                engagement = 0.0
+            else:
+                base = BASE_ENGAGEMENT.get(sa.content_type, 0.3)  # type: ignore[arg-type]
+                reach = REACH_MULT.get(sa.content_type, 1.0)  # type: ignore[arg-type]
+                hour_mult = self._get_hour_multiplier()
+                quality = self._get_quality_modifier()
+                tag_boost = self._calc_tag_boost(sa.tags)
+                trending_bonus = 1.5 if self._is_topic_trending(sa.topic) else 1.0
+                comp_diff = self._calc_competitor_diff(sa.topic)
+
+                fatigue = 1.0
+                if self._posts_today >= AUDIENCE_FATIGUE_THRESHOLD_2:
+                    fatigue = 0.1
+                elif self._posts_today >= AUDIENCE_FATIGUE_THRESHOLD_1:
+                    fatigue = 0.5
+
+                algo_mult = 1.0
+                if self._algorithm_penalty_remaining > 0:
+                    algo_mult = ALGORITHM_PENALTY_MULT
+                    self._algorithm_penalty_remaining -= 1
+
+                engagement = (
+                    base * reach * hour_mult * quality * tag_boost
+                    * trending_bonus * comp_diff * fatigue * algo_mult
+                )
+                engagement = min(engagement, 5.0)
+
+            self._last_topic = sa.topic
+
+            if sa.tags and engagement > 0:
+                for tag in sa.tags:
+                    tag_lower = tag.lower()
+                    self._tag_history[tag_lower].append(engagement)
+                    self._unique_tags_used.add(tag_lower)
+
+            self._engagement_history.append(engagement)
+            self._total_engagement += engagement
+            self._posting_steps += 1
+
+            if self._calc_competitor_diff(sa.topic) >= 1.3:
+                self._unique_topic_steps += 1
+
+            self._last_post_types.append(sa.content_type)  # type: ignore[arg-type]
+            if len(self._last_post_types) > 3:
+                self._last_post_types = self._last_post_types[-3:]
+            self._posts_today += 1
+            self._posts_per_day[self._day] += 1
+            self._time_since_last_post = 0
+
+            if engagement > 0:
+                self._followers += int(engagement * 100)
+
+        elif sa.action_type == "create_content":
+            self._energy = max(0.0, self._energy - CREATE_CONTENT_COST)
+            self._content_queue += 1
+            self._time_since_last_post += 1
+
+        if self._time_since_last_post >= FOLLOWER_DECAY_HOURS:
+            self._followers = max(0, self._followers - int(self._followers * 0.005))
+            if self._algorithm_penalty_remaining == 0:
+                self._algorithm_penalty_remaining = ALGORITHM_PENALTY_DURATION
+
+        reward = 0.0 if self._energy <= 0.0 else self._compute_hourly_reward(sa, engagement)
+        return engagement, reward
+
+    def _process_hour_rest(self) -> tuple:
+        """Process a rest hour. Returns (0.0, reward)."""
+        self._energy = min(1.0, self._energy + REST_RECOVERY)
+        self._hours_since_sleep = max(0, self._hours_since_sleep - SLEEP_RECOVERY_PER_REST)
+        self._sleep_debt = max(0.0, self._sleep_debt - 0.1)
+        self._time_since_last_post += 1
+
+        if self._time_since_last_post >= FOLLOWER_DECAY_HOURS:
+            self._followers = max(0, self._followers - int(self._followers * 0.005))
+            if self._algorithm_penalty_remaining == 0:
+                self._algorithm_penalty_remaining = ALGORITHM_PENALTY_DURATION
+
+        reward = 0.0 if self._energy <= 0.0 else self._compute_rest_reward()
+        return 0.0, reward
+
+    @property
+    def state(self) -> State:
+        return self._state
+
+    # ----- validation -----
+
+    def _validate_scheduled_action(self, sa: ScheduledAction) -> Optional[str]:
+        if sa.action_type not in ("post", "create_content"):
+            return f"Invalid action_type: {sa.action_type}"
+        if sa.action_type == "post":
+            if not sa.content_type:
+                return "content_type is required when posting"
+            if sa.content_type not in CONTENT_ENERGY_COST:
+                return f"Invalid content_type: {sa.content_type}"
+            if not sa.topic or not sa.topic.strip():
+                return "topic is required when posting"
+            if len(sa.topic) > 200:
+                return "topic must be ≤200 characters"
+            if sa.tags:
+                valid = [t for t in sa.tags if t.lower() in TAG_POOL]
+                sa.tags = valid if valid else None
+        return None
+
+    # ----- trending -----
+
+    def _is_topic_trending(self, topic: Optional[str]) -> bool:
+        if not topic:
+            return False
+        topic_lower = topic.lower()
+        return any(t.lower() in topic_lower for t in self._trending_topics)
+
+    # ----- reward -----
+
+    def _compute_hourly_reward(self, sa: ScheduledAction, engagement: float) -> float:
+        eng_component = min(1.0, engagement / 2.0) * 0.3
+
+        prev_energy = self._energy_history[-2] if len(self._energy_history) >= 2 else 1.0
+        energy_delta = self._energy - prev_energy
+        energy_component = max(0.0, min(1.0, (energy_delta + 0.3) / 0.6)) * 0.15
+
+        day_posts = self._posts_per_day.get(self._day, 0)
+        if 1 <= day_posts <= 2:
+            consistency = 1.0
+        elif day_posts == 0 or day_posts == 3:
+            consistency = 0.5
+        else:
+            consistency = 0.0
+        consistency_component = consistency * 0.15
+
+        tag_component = 0.0
+        if sa.action_type == "post" and sa.tags:
+            trending_match = sum(1 for t in sa.tags if t.lower() in self._trending_tags) / 5.0
+            tag_component = min(1.0, trending_match + 0.3) * 0.15
+
+        comp_component = 0.0
+        if sa.action_type == "post":
+            diff = self._calc_competitor_diff(sa.topic)
+            comp_component = min(1.0, diff / 1.3) * 0.15
+
+        burnout_penalty = 0.1 if self._energy < 0.2 else 0.0
+
+        raw = eng_component + energy_component + consistency_component + tag_component + comp_component - burnout_penalty
+        return max(0.0, min(1.0, raw))
+
+    def _compute_rest_reward(self) -> float:
+        prev_energy = self._energy_history[-2] if len(self._energy_history) >= 2 else 1.0
+        energy_delta = self._energy - prev_energy
+        energy_component = max(0.0, min(1.0, (energy_delta + 0.3) / 0.6)) * 0.15
+
+        day_posts = self._posts_per_day.get(self._day, 0)
+        if 1 <= day_posts <= 2:
+            consistency = 1.0
+        elif day_posts == 0 or day_posts == 3:
+            consistency = 0.5
+        else:
+            consistency = 0.0
+        consistency_component = consistency * 0.15
+
+        burnout_penalty = 0.1 if self._energy < 0.2 else 0.0
+        raw = energy_component + consistency_component - burnout_penalty
+        return max(0.0, min(1.0, raw))
+
+    # ----- time -----
+
+    def _advance_time(self) -> None:
+        self._hour += 1
+
+        # Track hours since sleep (always increases unless resting)
+        self._hours_since_sleep += 1
+
+        # Sleep deprivation drains extra energy (smooth ramp after threshold)
+        if self._hours_since_sleep > SLEEP_ENERGY_DRAIN_START:
+            hours_over = self._hours_since_sleep - SLEEP_ENERGY_DRAIN_START
+            # Drain increases smoothly the longer you're awake
+            drain = SLEEP_ENERGY_DRAIN_RATE * (1 + hours_over * 0.1)
+            self._energy = max(0.0, self._energy - drain)
+
+        # Update sleep debt (smooth accumulation based on hours awake)
+        if self._hours_since_sleep > SLEEP_OPTIMAL_AWAKE:
+            hours_over = self._hours_since_sleep - SLEEP_OPTIMAL_AWAKE
+            # Debt accumulates faster the longer awake (quadratic-ish curve)
+            debt_rate = 0.01 * (1 + hours_over * 0.05)
+            self._sleep_debt = min(1.0, self._sleep_debt + debt_rate)
+
+        if self._hour >= 24:
+            self._hour = 0
+            self._day += 1
+            self._posts_today = 0
+            self._rotate_trends()
+
+    # ----- observation builder -----
+
+    def _build_observation(
+        self,
+        reward: float,
+        error: Optional[str],
+        done: bool = False,
+        grader_score: Optional[float] = None,
+        daily_total_engagement: float = 0.0,
+        daily_posts_made: int = 0,
+        daily_energy_min: float = 1.0,
+    ) -> ViraltestObservation:
+        recent_eng = self._engagement_history[-10:] if self._engagement_history else []
+        eng_rate = sum(recent_eng) / len(recent_eng) if recent_eng else 0.0
+
+        meta: Dict[str, Any] = {"step": self._state.step_count, "task": self._task}
+        if grader_score is not None:
+            meta["grader_score"] = round(grader_score, 4)
+
+        return ViraltestObservation(
+            current_hour=self._hour,
+            day_of_week=self._day % 7,
+            days_elapsed=self._day,
+            creator_energy=round(self._energy, 3),
+            hours_since_sleep=self._hours_since_sleep,
+            sleep_debt=round(self._sleep_debt, 3),
+            follower_count=self._followers,
+            engagement_rate=round(eng_rate, 4),
+            posts_today=self._posts_today,
+            time_since_last_post=self._time_since_last_post,
+            trending_topics=list(self._trending_topics),
+            content_queue_size=self._content_queue,
+            last_post_type=self._last_post_types[-1] if self._last_post_types else "none",
+            tag_performance=self._get_tag_performance_dict(),
+            trending_tags=list(self._trending_tags),
+            competitor_recent_posts=self._get_competitor_recent_posts(),
+            competitor_avg_engagement=round(self._get_competitor_avg_engagement(), 4),
+            niche_saturation=round(self._calc_niche_saturation(self._last_topic), 3),
+            daily_total_engagement=round(daily_total_engagement, 4),
+            daily_posts_made=daily_posts_made,
+            daily_energy_min=round(daily_energy_min, 3),
+            grader_score=round(grader_score, 4) if grader_score is not None else None,
+            error=error,
+            done=done,
+            reward=round(reward, 4),
+            metadata=meta,
+        )
+
+    # ----- graders -----
+
+    def _run_grader(self) -> float:
+        if self._task == "weekly_engage":
+            return self._grade_weekly_engage()
+        elif self._task == "weekly_strategic":
+            return self._grade_weekly_strategic()
+        elif self._task == "weekly_competitive":
+            return self._grade_weekly_competitive()
+        return 0.0
+
+    def _theoretical_max_engagement(self) -> float:
+        best_base = max(BASE_ENGAGEMENT.values())
+        best_reach = max(REACH_MULT.values())
+        peak_mult = 1.4
+        quality = 1.0
+        posts_per_day = 2
+        days = 7
+        return best_base * best_reach * peak_mult * quality * posts_per_day * days
+
+    def _grade_weekly_engage(self) -> float:
+        theoretical_max = self._theoretical_max_engagement()
+        if theoretical_max <= 0:
+            return 0.0
+        raw = min(1.0, self._total_engagement / theoretical_max)
+        if self._energy <= 0.0:
+            raw *= 0.3  # burnout penalty even on easy task
+        return raw
+
+    def _grade_weekly_strategic(self) -> float:
+        # Burnout = severe penalty (not total fail like competitive, but close)
+        if self._energy <= 0.0:
+            return max(0.0, min(0.15, self._total_engagement * 0.01))
+
+        # Engagement: 35%
+        theoretical_max = self._theoretical_max_engagement()
+        norm_eng = min(1.0, self._total_engagement / theoretical_max) if theoretical_max > 0 else 0.0
+
+        # Tag score: 25%  (40% discovery + 60% exploitation)
+        positive_tags = sum(1 for t in self._unique_tags_used if self._tag_performance_avg(t) > 0)
+        tag_discovery = min(1.0, positive_tags / 30.0)
+        top_perfs = sorted(
+            [self._tag_performance_avg(t) for t in self._unique_tags_used], reverse=True
+        )[:3]
+        tag_exploitation = (sum(top_perfs) / len(top_perfs)) if top_perfs else 0.0
+        tag_exploitation = min(1.0, tag_exploitation / 2.0)
+        tag_score = 0.4 * tag_discovery + 0.6 * tag_exploitation
+
+        # Avg energy: 25%
+        avg_energy = sum(self._energy_history) / len(self._energy_history) if self._energy_history else 0.0
+
+        # Consistency: 15%
+        consistency = len(self._days_with_good_posts) / 7.0
+
+        raw = 0.35 * norm_eng + 0.25 * tag_score + 0.25 * avg_energy + 0.15 * consistency
+
+        # Constraints
+        min_energy = min(self._energy_history) if self._energy_history else 0.0
+        if min_energy < 0.2:
+            raw *= 0.4  # crashed hard
+        elif min_energy < 0.3:
+            raw = min(raw, 0.45)
+        if len(self._unique_tags_used) < 5:
+            raw *= 0.7
+
+        return max(0.0, min(1.0, raw))
+
+    def _grade_weekly_competitive(self) -> float:
+        # Burnout = total fail
+        if self._energy <= 0.0:
+            return 0.0
+
+        # Engagement: 25%
+        theoretical_max = self._theoretical_max_engagement()
+        norm_eng = min(1.0, self._total_engagement / theoretical_max) if theoretical_max > 0 else 0.0
+
+        # Tag score: 20%
+        positive_tags = sum(1 for t in self._unique_tags_used if self._tag_performance_avg(t) > 0)
+        tag_discovery = min(1.0, positive_tags / 30.0)
+        top_perfs = sorted(
+            [self._tag_performance_avg(t) for t in self._unique_tags_used], reverse=True
+        )[:3]
+        tag_exploitation = (sum(top_perfs) / len(top_perfs)) if top_perfs else 0.0
+        tag_exploitation = min(1.0, tag_exploitation / 2.0)
+        tag_score = 0.4 * tag_discovery + 0.6 * tag_exploitation
+
+        # Follower growth: 20%
+        growth = (self._followers - self._initial_followers) / self._initial_followers if self._initial_followers > 0 else 0.0
+        target_growth = 0.05
+        norm_growth = min(1.0, max(0.0, growth / target_growth))
+
+        # Competitor outperformance: 15%
+        comp_avg = self._get_competitor_avg_engagement()
+        my_avg = self._total_engagement / self._posting_steps if self._posting_steps > 0 else 0.0
+        outperformance = my_avg / comp_avg if comp_avg > 0 else 1.0
+        norm_outperformance = min(1.0, outperformance / 1.5)
+
+        # Differentiation: 10%
+        differentiation = self._unique_topic_steps / self._posting_steps if self._posting_steps > 0 else 0.0
+
+        # Energy floor: 10%
+        min_energy = min(self._energy_history) if self._energy_history else 0.0
+        energy_floor = min(1.0, max(0.0, min_energy))
+
+        raw = (
+            0.25 * norm_eng
+            + 0.20 * tag_score
+            + 0.20 * norm_growth
+            + 0.15 * norm_outperformance
+            + 0.10 * differentiation
+            + 0.10 * energy_floor
+        )
+
+        # Constraints
+        if len(self._unique_content_types) < 3:
+            raw *= 0.5
+        if len(self._unique_tags_used) < 8:
+            raw *= 0.7
+
+        return max(0.0, min(1.0, raw))
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _topic_overlap(topic_a: str, topic_b: str) -> bool:
+    """Check if two topics have significant word overlap."""
+    words_a = set(topic_a.split())
+    words_b = set(topic_b.split())
+    if not words_a or not words_b:
+        return False
+    common = words_a & words_b
+    return len(common) / min(len(words_a), len(words_b)) >= 0.5

test_scenarios.py

@@ -0,0 +1,219 @@
+"""
+Viraltest — Edge Case & Scenario Tests (Daily Plan Format)
+Runs scenarios for all 3 tasks using the new daily step format.
+Each step = one full day. Agent submits a sparse daily plan.
+"""
+
+import random as stdlib_random
+from typing import Callable, Dict, List, Tuple
+
+from models import ScheduledAction, ViraltestAction
+from server.viraltest_environment import (
+    TAG_POOL,
+    ViraltestEnvironment,
+    ViraltestObservation,
+)
+
+TASKS = ["weekly_engage", "weekly_strategic", "weekly_competitive"]
+SEED = 42
+
+_CONTENT_TYPES = ["reel", "carousel", "story", "text_post"]
+_TOPICS = ["AI tools", "fitness routine", "growth hacks", "travel guide", "food recipe", "wellness tips"]
+_rng = stdlib_random.Random(99)
+
+
+def _plan(actions: list) -> ViraltestAction:
+    return ViraltestAction(scheduled_actions=[ScheduledAction(**a) for a in actions])
+
+
+def run_episode(
+    task: str,
+    plan_fn: Callable[[Dict, int], ViraltestAction],
+    label: str,
+) -> float:
+    env = ViraltestEnvironment()
+    obs = env.reset(task=task, seed=SEED)
+    obs_dict = obs.model_dump()
+    rewards: List[float] = []
+    min_energy = 1.0
+    burned_out = False
+
+    for day in range(1, 8):
+        action = plan_fn(obs_dict, day)
+        obs = env.step(action)
+        obs_dict = obs.model_dump()
+        r = obs.reward if obs.reward is not None else 0.0
+        rewards.append(r)
+        min_energy = min(min_energy, obs.creator_energy)
+        if obs.done and obs.creator_energy <= 0:
+            burned_out = True
+        if obs.done:
+            break
+
+    score = (obs.metadata or {}).get("grader_score", 0.0)
+    total_steps = len(rewards)
+
+    print(f"  Task: {task}")
+    print(f"  Days: {total_steps} | Done: {obs.done} | Burned out: {burned_out}")
+    print(f"  Score: {score:.4f} | Total reward: {sum(rewards):.2f} | Avg reward: {sum(rewards)/len(rewards):.3f}")
+    print(f"  Energy: {obs.creator_energy:.2f} | Min energy: {min_energy:.2f}")
+    print(f"  Followers: {obs.follower_count} (started 10000, delta {obs.follower_count - 10000:+d})")
+    print(f"  Engagement rate: {obs.engagement_rate:.4f}")
+    print(f"  Unique tags: {len(obs.tag_performance)}")
+    print(f"  Niche saturation: {obs.niche_saturation:.3f}")
+    print()
+    return score
+
+
+def plan_always_rest(obs: dict, day: int) -> ViraltestAction:
+    return _plan([])
+
+
+def plan_spam(obs: dict, day: int) -> ViraltestAction:
+    return _plan([{"hour": h, "action_type": "post", "content_type": "reel",
+                   "topic": "AI tools", "tags": ["ai"]} for h in range(24)])
+
+
+def plan_smart(obs: dict, day: int) -> ViraltestAction:
+    trending = (obs.get("trending_topics") or ["AI tools"])[0]
+    t_tags = list((obs.get("trending_tags") or [])[:2])
+    pool_tag = TAG_POOL[(day * 2) % len(TAG_POOL)]
+    pool_tag2 = TAG_POOL[(day * 2 + 1) % len(TAG_POOL)]
+    ct1 = _CONTENT_TYPES[(day * 2) % 4]
+    ct2 = _CONTENT_TYPES[(day * 2 + 1) % 4]
+    return _plan([
+        {"hour": 8, "action_type": "create_content"},
+        {"hour": 12, "action_type": "post", "content_type": ct1, "topic": trending, "tags": t_tags + [pool_tag]},
+        {"hour": 19, "action_type": "post", "content_type": ct2, "topic": trending, "tags": t_tags + [pool_tag2]},
+    ])
+
+
+def plan_no_rest(obs: dict, day: int) -> ViraltestAction:
+    actions = []
+    for h in range(24):
+        ct = _CONTENT_TYPES[h % 4]
+        topic = _rng.choice(_TOPICS)
+        tags = _rng.sample(TAG_POOL, 3)
+        actions.append({"hour": h, "action_type": "post", "content_type": ct, "topic": topic, "tags": tags})
+    return _plan(actions)
+
+
+def plan_minimal(obs: dict, day: int) -> ViraltestAction:
+    trending = (obs.get("trending_topics") or ["minimalism"])[0]
+    tags = list((obs.get("trending_tags") or [])[:3])
+    return _plan([
+        {"hour": 12, "action_type": "post", "content_type": "carousel", "topic": trending, "tags": tags},
+    ])
+
+
+def plan_tag_explorer(obs: dict, day: int) -> ViraltestAction:
+    trending = (obs.get("trending_topics") or ["devtools"])[0]
+    start = (day * 6) % len(TAG_POOL)
+    tags1 = [TAG_POOL[(start + i) % len(TAG_POOL)] for i in range(3)]
+    tags2 = [TAG_POOL[(start + 3 + i) % len(TAG_POOL)] for i in range(3)]
+    ct1 = _CONTENT_TYPES[(day * 2) % 4]
+    ct2 = _CONTENT_TYPES[(day * 2 + 1) % 4]
+    return _plan([
+        {"hour": 10, "action_type": "post", "content_type": ct1, "topic": trending, "tags": tags1},
+        {"hour": 18, "action_type": "post", "content_type": ct2, "topic": trending, "tags": tags2},
+    ])
+
+
+def plan_queue_optimizer(obs: dict, day: int) -> ViraltestAction:
+    trending = (obs.get("trending_topics") or ["productivity"])[0]
+    tags = list((obs.get("trending_tags") or [])[:2]) + ["growth"]
+    queue = obs.get("content_queue_size", 0)
+    if day < 3 or queue < 2:
+        return _plan([
+            {"hour": 8, "action_type": "create_content"},
+            {"hour": 10, "action_type": "create_content"},
+            {"hour": 14, "action_type": "create_content"},
+        ])
+    ct = _CONTENT_TYPES[day % 4]
+    return _plan([
+        {"hour": 12, "action_type": "post", "content_type": ct, "topic": trending, "tags": tags},
+        {"hour": 19, "action_type": "post", "content_type": _CONTENT_TYPES[(day + 1) % 4], "topic": trending, "tags": tags},
+    ])
+
+
+def plan_double_peak(obs: dict, day: int) -> ViraltestAction:
+    trending = (obs.get("trending_topics") or ["peak time content"])[0]
+    tags = list((obs.get("trending_tags") or [])[:3])
+    return _plan([
+        {"hour": 9, "action_type": "post", "content_type": "reel", "topic": trending, "tags": tags},
+        {"hour": 15, "action_type": "post", "content_type": "carousel", "topic": trending, "tags": tags},
+    ])
+
+
+def plan_random(obs: dict, day: int) -> ViraltestAction:
+    actions = []
+    for h in range(24):
+        r = _rng.random()
+        if r < 0.1:
+            ct = _rng.choice(_CONTENT_TYPES)
+            topic = _rng.choice(["random topic", "AI tools", "fitness", "travel"])
+            tags = _rng.sample(TAG_POOL, 2)
+            actions.append({"hour": h, "action_type": "post", "content_type": ct, "topic": topic, "tags": tags})
+        elif r < 0.15:
+            actions.append({"hour": h, "action_type": "create_content"})
+    return _plan(actions)
+
+
+SCENARIOS: List[Tuple[str, Callable, str]] = [
+    ("Always Rest", plan_always_rest, "Zero engagement, no growth, energy stays max"),
+    ("Spam Post", plan_spam, "Post every hour, burns out instantly"),
+    ("Smart Agent", plan_smart, "Peak hours, trending, varied types, energy management"),
+    ("No Rest", plan_no_rest, "Post every hour, never rests, burns out"),
+    ("Minimal Poster", plan_minimal, "1 carousel at noon per day"),
+    ("Tag Explorer", plan_tag_explorer, "Rotates through tag pool for max discovery"),
+    ("Queue Optimizer", plan_queue_optimizer, "Creates content first, posts from queue"),
+    ("Double Peak", plan_double_peak, "Posts at 9am and 3pm"),
+    ("Random Actor", plan_random, "Random sparse actions each day"),
+]
+
+
+if __name__ == "__main__":
+    print("=" * 70)
+    print("VIRALTEST — DAILY PLAN SCENARIO TESTS")
+    print("=" * 70)
+    print()
+
+    for scenario_name, plan_fn, description in SCENARIOS:
+        print("=" * 70)
+        print(f"{scenario_name}")
+        print(f"  {description}")
+        print("=" * 70)
+        print()
+
+        for task in TASKS:
+            _rng = stdlib_random.Random(99)
+            run_episode(task, plan_fn, scenario_name)
+
+        print()
+
+    print("=" * 70)
+    print("SUMMARY TABLE")
+    print("=" * 70)
+    print()
+    print(f"{'Scenario':<30} {'Engage':>8} {'Strategic':>10} {'Competitive':>12}")
+    print("-" * 62)
+
+    for scenario_name, plan_fn, _ in SCENARIOS:
+        scores = []
+        for task in TASKS:
+            _rng = stdlib_random.Random(99)
+            env = ViraltestEnvironment()
+            obs = env.reset(task=task, seed=SEED)
+            obs_dict = obs.model_dump()
+            for day in range(1, 8):
+                action = plan_fn(obs_dict, day)
+                obs = env.step(action)
+                obs_dict = obs.model_dump()
+                if obs.done:
+                    break
+            scores.append((obs.metadata or {}).get("grader_score", 0.0))
+        print(f"{scenario_name:<30} {scores[0]:>8.4f} {scores[1]:>10.4f} {scores[2]:>12.4f}")
+
+    print()
+    print("EXPECTED: Smart/Queue/Tag Explorer should score highest.")
+    print("Burnout agents (spam, no_rest) should score near 0 on strategic/competitive.")

validate-submission.sh

@@ -0,0 +1,355 @@
+#!/usr/bin/env bash
+#
+# validate-submission.sh — OpenEnv Submission Validator for Viraltest
+#
+# Checks that your HF Space is live, Docker image builds, and openenv validate passes.
+#
+# Prerequisites:
+#   - Docker:       https://docs.docker.com/get-docker/
+#   - openenv validate: uv sync (uses .venv/bin/openenv), or pip install openenv-core, or uv on PATH
+#   - curl (usually pre-installed)
+#
+# Run:
+#     chmod +x validate-submission.sh
+#     ./validate-submission.sh <ping_url> [repo_dir]
+#
+# Optional: create repo-local .env (gitignored) with HF_TOKEN=... — sourced automatically.
+#     cp .env.example .env   # then edit .env
+#
+# Skip Docker build (Step 2) — faster local checks; run full build before submit:
+#     SKIP_DOCKER=1 ./validate-submission.sh https://your-space.hf.space
+#
+# Step 5 — Hugging Face Inference Router LLM smoke test (runs by default if HF_TOKEN is set):
+#     export HF_TOKEN=hf_...   # required for Step 5; never commit; use Space Secrets for deploys
+#     # Optional overrides (defaults match inference.py / HF router):
+#     export MODEL_NAME=gemma-4-E4B-it-IQ4_XS
+#     export API_BASE_URL=https://router.huggingface.co/v1
+#     SKIP_LLM_SMOKE=1         # only if you must skip Step 5 (e.g. CI without secrets)
+#
+# HF token permissions (403 = insufficient permissions):
+#   - Create or edit at https://huggingface.co/settings/tokens
+#   - For https://router.huggingface.co/v1 the token must be allowed to call
+#     Inference Providers / serverless inference for your account (UI labels vary).
+#   - If 403 persists, confirm billing/access for Inference Providers in HF account settings.
+#   - LLM_SMOKE_OPTIONAL=1 — still pass Steps 1,3–5 when Step 5 auth fails (not for production).
+#
+# Arguments:
+#   ping_url   Your HuggingFace Space URL (e.g. https://your-space.hf.space)
+#   repo_dir   Path to your repo (default: current directory)
+#
+# Examples:
+#   ./validate-submission.sh https://my-team.hf.space
+#   ./validate-submission.sh https://my-team.hf.space ./viraltest
+
+set -uo pipefail
+
+DOCKER_BUILD_TIMEOUT=600
+if [ -t 1 ]; then
+  RED='\033[0;31m'
+  GREEN='\033[0;32m'
+  YELLOW='\033[1;33m'
+  BOLD='\033[1m'
+  NC='\033[0m'
+else
+  RED='' GREEN='' YELLOW='' BOLD='' NC=''
+fi
+
+run_with_timeout() {
+  local secs="$1"; shift
+  if command -v timeout &>/dev/null; then
+    timeout "$secs" "$@"
+  elif command -v gtimeout &>/dev/null; then
+    gtimeout "$secs" "$@"
+  else
+    "$@" &
+    local pid=$!
+    ( sleep "$secs" && kill "$pid" 2>/dev/null ) &
+    local watcher=$!
+    wait "$pid" 2>/dev/null
+    local rc=$?
+    kill "$watcher" 2>/dev/null
+    wait "$watcher" 2>/dev/null
+    return $rc
+  fi
+}
+
+portable_mktemp() {
+  local prefix="${1:-validate}"
+  mktemp "${TMPDIR:-/tmp}/${prefix}-XXXXXX" 2>/dev/null || mktemp
+}
+
+CLEANUP_FILES=()
+cleanup() { rm -f "${CLEANUP_FILES[@]+"${CLEANUP_FILES[@]}"}"; }
+trap cleanup EXIT
+
+PING_URL="${1:-}"
+REPO_DIR="${2:-.}"
+
+if [ -z "$PING_URL" ]; then
+  printf "Usage: %s <ping_url> [repo_dir]\n" "$0"
+  printf "\n"
+  printf "  ping_url   Your HuggingFace Space URL (e.g. https://your-space.hf.space)\n"
+  printf "  repo_dir   Path to your repo (default: current directory)\n"
+  exit 1
+fi
+
+if ! REPO_DIR="$(cd "$REPO_DIR" 2>/dev/null && pwd)"; then
+  printf "Error: directory '%s' not found\n" "${2:-.}"
+  exit 1
+fi
+PING_URL="${PING_URL%/}"
+export PING_URL
+PASS=0
+
+log()  { printf "[%s] %b\n" "$(date -u +%H:%M:%S)" "$*"; }
+pass() { log "${GREEN}PASSED${NC} -- $1"; PASS=$((PASS + 1)); }
+fail() { log "${RED}FAILED${NC} -- $1"; }
+hint() { printf "  ${YELLOW}Hint:${NC} %b\n" "$1"; }
+stop_at() {
+  printf "\n"
+  printf "${RED}${BOLD}Validation stopped at %s.${NC} Fix the above before continuing.\n" "$1"
+  exit 1
+}
+
+if [ -f "$REPO_DIR/.env" ]; then
+  set -a
+  # shellcheck disable=SC1091
+  . "$REPO_DIR/.env"
+  set +a
+fi
+
+printf "\n"
+printf "${BOLD}========================================${NC}\n"
+printf "${BOLD}  Viraltest Submission Validator${NC}\n"
+printf "${BOLD}========================================${NC}\n"
+log "Repo:     $REPO_DIR"
+log "Ping URL: $PING_URL"
+if [ "${SKIP_DOCKER:-}" = "1" ]; then
+  log "${YELLOW}SKIP_DOCKER=1 — Docker build will be skipped${NC}"
+fi
+printf "\n"
+
+# ──────────────────────────────────────
+# Step 1: Ping HF Space
+# ──────────────────────────────────────
+log "${BOLD}Step 1/5: Pinging HF Space${NC} ($PING_URL/reset) ..."
+
+CURL_OUTPUT=$(portable_mktemp "validate-curl")
+CLEANUP_FILES+=("$CURL_OUTPUT")
+HTTP_CODE=$(curl -s -o "$CURL_OUTPUT" -w "%{http_code}" -X POST \
+  -H "Content-Type: application/json" -d '{}' \
+  "$PING_URL/reset" --max-time 30 2>"$CURL_OUTPUT" || printf "000")
+
+if [ "$HTTP_CODE" = "200" ]; then
+  pass "HF Space is live and responds to /reset"
+elif [ "$HTTP_CODE" = "000" ]; then
+  fail "HF Space not reachable (connection failed or timed out)"
+  hint "Check your network and that the Space is running."
+  stop_at "Step 1"
+else
+  fail "HF Space /reset returned HTTP $HTTP_CODE (expected 200)"
+  hint "Make sure your Space is running. Try: curl -X POST $PING_URL/reset"
+  stop_at "Step 1"
+fi
+
+# ──────────────────────────────────────
+# Step 2: Docker build
+# ──────────────────────────────────────
+if [ "${SKIP_DOCKER:-}" = "1" ]; then
+  log "${BOLD}Step 2/5: Docker build${NC} ${YELLOW}SKIPPED${NC} (SKIP_DOCKER=1)"
+  hint "Run without SKIP_DOCKER=1 before submission to confirm docker build still succeeds."
+else
+  log "${BOLD}Step 2/5: Running docker build${NC} ..."
+
+  if ! command -v docker &>/dev/null; then
+    fail "docker command not found"
+    hint "Install Docker: https://docs.docker.com/get-docker/"
+    stop_at "Step 2"
+  fi
+
+  if [ -f "$REPO_DIR/Dockerfile" ]; then
+    DOCKER_CONTEXT="$REPO_DIR"
+  elif [ -f "$REPO_DIR/server/Dockerfile" ]; then
+    DOCKER_CONTEXT="$REPO_DIR/server"
+  else
+    fail "No Dockerfile found in repo root or server/ directory"
+    stop_at "Step 2"
+  fi
+
+  log "  Found Dockerfile in $DOCKER_CONTEXT"
+
+  BUILD_OK=false
+  BUILD_OUTPUT=$(run_with_timeout "$DOCKER_BUILD_TIMEOUT" docker build "$DOCKER_CONTEXT" 2>&1) && BUILD_OK=true
+
+  if [ "$BUILD_OK" = true ]; then
+    pass "Docker build succeeded"
+  else
+    fail "Docker build failed (timeout=${DOCKER_BUILD_TIMEOUT}s)"
+    printf "%s\n" "$BUILD_OUTPUT" | tail -20
+    stop_at "Step 2"
+  fi
+fi
+
+# ──────────────────────────────────────
+# Step 3: openenv validate
+# ──────────────────────────────────────
+log "${BOLD}Step 3/5: Running openenv validate${NC} ..."
+
+VALIDATE_OK=false
+VALIDATE_OUTPUT=""
+VENV_OPENENV="$REPO_DIR/.venv/bin/openenv"
+if command -v uv &>/dev/null && [ -f "$REPO_DIR/pyproject.toml" ]; then
+  log "  Using: uv run openenv validate (avoids global CLI / Python mismatch)"
+  VALIDATE_OUTPUT=$(cd "$REPO_DIR" && uv run openenv validate 2>&1) && VALIDATE_OK=true
+elif command -v openenv &>/dev/null; then
+  VALIDATE_OUTPUT=$(cd "$REPO_DIR" && openenv validate 2>&1) && VALIDATE_OK=true
+elif [ -x "$VENV_OPENENV" ]; then
+  log "  Using: .venv/bin/openenv (repo virtualenv; run: uv sync)"
+  VALIDATE_OUTPUT=$(cd "$REPO_DIR" && "$VENV_OPENENV" validate 2>&1) && VALIDATE_OK=true
+else
+  fail "openenv not found (no uv, no openenv on PATH, no .venv/bin/openenv)"
+  hint "From the repo: uv sync  # then re-run; or: pip install openenv-core"
+  stop_at "Step 3"
+fi
+
+if [ "$VALIDATE_OK" = true ]; then
+  pass "openenv validate passed"
+  [ -n "$VALIDATE_OUTPUT" ] && log "  $VALIDATE_OUTPUT"
+else
+  fail "openenv validate failed"
+  printf "%s\n" "$VALIDATE_OUTPUT"
+  stop_at "Step 3"
+fi
+
+# ──────────────────────────────────────
+# Step 4: Viraltest-specific checks
+# ──────────────────────────────────────
+log "${BOLD}Step 4/5: Viraltest environment checks${NC} ..."
+
+STEP_OUTPUT=$(portable_mktemp "validate-step")
+CLEANUP_FILES+=("$STEP_OUTPUT")
+
+# Test all 3 tasks respond to reset
+for TASK in weekly_engage weekly_strategic weekly_competitive; do
+  TASK_CODE=$(curl -s -o "$STEP_OUTPUT" -w "%{http_code}" -X POST \
+    -H "Content-Type: application/json" \
+    -d "{\"task\": \"$TASK\"}" \
+    "$PING_URL/reset" --max-time 15 2>/dev/null || printf "000")
+
+  if [ "$TASK_CODE" = "200" ]; then
+    log "  ${GREEN}OK${NC} task=$TASK reset responds"
+  else
+    fail "Task $TASK reset returned HTTP $TASK_CODE"
+    stop_at "Step 4"
+  fi
+done
+
+# Test step endpoint with a daily plan action (sparse: one post at hour 12)
+STEP_CODE=$(curl -s -o "$STEP_OUTPUT" -w "%{http_code}" -X POST \
+  -H "Content-Type: application/json" \
+  -d '{"action":{"scheduled_actions":[{"hour":12,"action_type":"post","content_type":"reel","topic":"AI trends","tags":["ai","ml"]}]}}' \
+  "$PING_URL/step" --max-time 15 2>/dev/null || printf "000")
+
+if [ "$STEP_CODE" = "200" ]; then
+  pass "Step endpoint responds correctly"
+else
+  fail "Step endpoint returned HTTP $STEP_CODE"
+  stop_at "Step 4"
+fi
+
+# Check inference.py exists
+if [ -f "$REPO_DIR/inference.py" ]; then
+  pass "inference.py found in project root"
+else
+  fail "inference.py not found in $REPO_DIR"
+  stop_at "Step 4"
+fi
+
+# ──────────────────────────────────────
+# Step 5: HF Inference Router — one chat completion
+# ──────────────────────────────────────
+DEFAULT_SMOKE_MODEL="gemma-4-E4B-it-IQ4_XS"
+DEFAULT_SMOKE_API="https://router.huggingface.co/v1"
+SMOKE_MODEL="${MODEL_NAME:-$DEFAULT_SMOKE_MODEL}"
+SMOKE_API="${API_BASE_URL:-$DEFAULT_SMOKE_API}"
+
+if [ "${SKIP_LLM_SMOKE:-}" = "1" ]; then
+  log "${BOLD}Step 5/5: LLM router smoke test${NC} ${YELLOW}SKIPPED${NC} (SKIP_LLM_SMOKE=1)"
+elif [ -z "${HF_TOKEN:-}" ]; then
+  fail "Step 5 requires HF_TOKEN (Inference router). Export it from https://huggingface.co/settings/tokens"
+  hint "Override model/URL: MODEL_NAME and API_BASE_URL (defaults: $DEFAULT_SMOKE_MODEL, $DEFAULT_SMOKE_API). To skip Step 5: SKIP_LLM_SMOKE=1"
+  stop_at "Step 5"
+else
+  log "${BOLD}Step 5/5: LLM router smoke test${NC} (model=$SMOKE_MODEL) ..."
+  LLM_OK=false
+  LLM_OUT=""
+  if [ ! -f "$REPO_DIR/pyproject.toml" ]; then
+    fail "No pyproject.toml in repo — cannot run LLM smoke test"
+    stop_at "Step 5"
+  fi
+  RUN_PYTHON=()
+  if command -v uv &>/dev/null; then
+    RUN_PYTHON=(uv run python)
+  elif [ -x "$REPO_DIR/.venv/bin/python" ]; then
+    RUN_PYTHON=("$REPO_DIR/.venv/bin/python")
+  else
+    fail "Need uv on PATH or .venv/bin/python (run: uv sync)"
+    stop_at "Step 5"
+  fi
+  if [ "${#RUN_PYTHON[@]}" -gt 0 ]; then
+    LLM_OUT=$(cd "$REPO_DIR" && \
+      MODEL_NAME="$SMOKE_MODEL" API_BASE_URL="$SMOKE_API" HF_TOKEN="$HF_TOKEN" \
+      "${RUN_PYTHON[@]}" - <<'PY' 2>&1
+import os, sys
+from openai import OpenAI
+
+def main() -> None:
+    client = OpenAI(
+        base_url=os.environ["API_BASE_URL"].rstrip("/"),
+        api_key=os.environ["HF_TOKEN"],
+    )
+    r = client.chat.completions.create(
+        model=os.environ["MODEL_NAME"],
+        messages=[{"role": "user", "content": "Reply with exactly: OK"}],
+        max_tokens=32,
+        temperature=0.0,
+    )
+    text = (r.choices[0].message.content or "").strip()
+    if not text:
+        print("empty completion", file=sys.stderr)
+        sys.exit(1)
+    print(text[:500])
+
+if __name__ == "__main__":
+    main()
+PY
+    ) && LLM_OK=true
+  fi
+
+  if [ "$LLM_OK" = true ]; then
+    pass "LLM router responded"
+    if [ -n "$LLM_OUT" ]; then
+      preview="${LLM_OUT:0:120}"
+      [ "${#LLM_OUT}" -gt 120 ] && preview="${preview}..."
+      log "  completion: $preview"
+    fi
+  else
+    fail "LLM router smoke test failed"
+    printf "%s\n" "$LLM_OUT"
+    if [ "${LLM_SMOKE_OPTIONAL:-}" = "1" ]; then
+      hint "LLM_SMOKE_OPTIONAL=1 set — continuing (fix HF token / Inference Providers access for real inference runs)."
+    else
+      hint "403 often means the token cannot use Inference Providers for this account. See HF token settings or set LLM_SMOKE_OPTIONAL=1 to still pass Steps 1–4."
+      stop_at "Step 5"
+    fi
+  fi
+fi
+
+printf "\n"
+printf "${BOLD}========================================${NC}\n"
+printf "${GREEN}${BOLD}  All checks passed!${NC}\n"
+printf "${GREEN}${BOLD}  Your submission is ready to submit.${NC}\n"
+printf "${BOLD}========================================${NC}\n"
+printf "\n"
+
+exit 0

visualize_optimal.py

@@ -0,0 +1,732 @@
+"""
+Visualization of optimal posting strategies for the Viraltest environment.
+Shows engagement multipliers, sleep effects, recommended posting windows,
+and simulation results for all 61 test scenarios.
+"""
+
+import matplotlib.pyplot as plt
+import numpy as np
+from matplotlib.patches import Rectangle
+from matplotlib.colors import LinearSegmentedColormap
+from collections import Counter
+from typing import Callable, List, Tuple, Dict, Any
+
+# Environment constants (matching viraltest_environment.py)
+CONTENT_ENERGY_COST = {"reel": 0.25, "carousel": 0.20, "story": 0.08, "text_post": 0.06}
+BASE_ENGAGEMENT = {"reel": 0.52, "carousel": 0.55, "story": 0.30, "text_post": 0.37}
+REACH_MULT = {"reel": 2.25, "carousel": 1.0, "story": 0.5, "text_post": 0.44}
+WEEKEND_PENALTY = 0.7
+PEAK_DAYS = (1, 2, 3)  # Tue, Wed, Thu
+
+# Sleep constants
+SLEEP_OPTIMAL_AWAKE = 14
+SLEEP_HALFLIFE_HOURS = 10
+SLEEP_MIN_QUALITY = 0.30
+
+
+def get_hour_multiplier(hour: int, day: int) -> float:
+    """Calculate engagement multiplier for given hour and day."""
+    is_weekend = day >= 5
+    base = WEEKEND_PENALTY if is_weekend else 1.0
+
+    if 12 <= hour < 15 and day in PEAK_DAYS:
+        return base * 1.4
+    if 9 <= hour < 12:
+        return base * 1.3
+    if 18 <= hour < 20:
+        return base * 1.25
+    if 20 <= hour < 23:
+        return base * 1.1
+    if hour >= 23 or hour < 6:
+        return base * 0.5
+    return base * 0.8
+
+
+def get_sleep_factor(hours_since_sleep: int) -> float:
+    """Calculate sleep quality factor (exponential decay)."""
+    if hours_since_sleep <= SLEEP_OPTIMAL_AWAKE:
+        return 1.0
+    hours_over = hours_since_sleep - SLEEP_OPTIMAL_AWAKE
+    factor = 0.5 ** (hours_over / SLEEP_HALFLIFE_HOURS)
+    return max(SLEEP_MIN_QUALITY, factor)
+
+
+def create_visualizations():
+    """Generate all visualization plots."""
+    fig = plt.figure(figsize=(16, 14))
+    fig.suptitle('Viraltest Environment - Optimal Posting Strategy Guide', 
+                 fontsize=16, fontweight='bold', y=0.98)
+
+    # 1. Hour x Day Engagement Heatmap
+    ax1 = fig.add_subplot(2, 2, 1)
+    days = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
+    hours = list(range(24))
+    
+    heatmap_data = np.zeros((24, 7))
+    for d in range(7):
+        for h in range(24):
+            heatmap_data[h, d] = get_hour_multiplier(h, d)
+    
+    im = ax1.imshow(heatmap_data, aspect='auto', cmap='RdYlGn', vmin=0.3, vmax=1.5)
+    ax1.set_xticks(range(7))
+    ax1.set_xticklabels(days)
+    ax1.set_yticks(range(0, 24, 2))
+    ax1.set_yticklabels([f'{h:02d}:00' for h in range(0, 24, 2)])
+    ax1.set_xlabel('Day of Week')
+    ax1.set_ylabel('Hour of Day')
+    ax1.set_title('Engagement Multiplier by Hour & Day', fontweight='bold')
+    
+    # Add colorbar
+    cbar = plt.colorbar(im, ax=ax1, shrink=0.8)
+    cbar.set_label('Multiplier')
+    
+    # Highlight peak zones
+    for d in PEAK_DAYS:
+        rect = Rectangle((d-0.5, 11.5), 1, 3, linewidth=2, 
+                         edgecolor='blue', facecolor='none', linestyle='--')
+        ax1.add_patch(rect)
+    ax1.text(2, 10.5, 'PEAK\nZONE', fontsize=8, color='blue', ha='center', fontweight='bold')
+
+    # 2. Content Type Comparison
+    ax2 = fig.add_subplot(2, 2, 2)
+    content_types = list(BASE_ENGAGEMENT.keys())
+    x = np.arange(len(content_types))
+    width = 0.25
+    
+    base_vals = [BASE_ENGAGEMENT[ct] for ct in content_types]
+    reach_vals = [REACH_MULT[ct] for ct in content_types]
+    energy_vals = [CONTENT_ENERGY_COST[ct] for ct in content_types]
+    
+    # Calculate effective engagement (base * reach)
+    effective = [BASE_ENGAGEMENT[ct] * REACH_MULT[ct] for ct in content_types]
+    
+    bars1 = ax2.bar(x - width, base_vals, width, label='Base Engagement', color='steelblue')
+    bars2 = ax2.bar(x, reach_vals, width, label='Reach Multiplier', color='seagreen')
+    bars3 = ax2.bar(x + width, energy_vals, width, label='Energy Cost', color='coral')
+    
+    ax2.set_xlabel('Content Type')
+    ax2.set_ylabel('Value')
+    ax2.set_title('Content Type Comparison', fontweight='bold')
+    ax2.set_xticks(x)
+    ax2.set_xticklabels(['Reel', 'Carousel', 'Story', 'Text Post'])
+    ax2.legend(loc='upper right')
+    ax2.grid(axis='y', alpha=0.3)
+    
+    # Add efficiency annotation
+    efficiency = [(BASE_ENGAGEMENT[ct] * REACH_MULT[ct]) / CONTENT_ENERGY_COST[ct] 
+                  for ct in content_types]
+    for i, (ct, eff) in enumerate(zip(content_types, efficiency)):
+        ax2.annotate(f'Eff: {eff:.1f}', (i, max(base_vals[i], reach_vals[i], energy_vals[i]) + 0.1),
+                    ha='center', fontsize=8, color='purple')
+
+    # 3. Sleep Quality Decay Curve
+    ax3 = fig.add_subplot(2, 2, 3)
+    hours_awake = np.linspace(0, 40, 200)
+    sleep_quality = [get_sleep_factor(int(h)) for h in hours_awake]
+    
+    ax3.plot(hours_awake, sleep_quality, 'b-', linewidth=2, label='Quality Factor')
+    ax3.axvline(x=SLEEP_OPTIMAL_AWAKE, color='green', linestyle='--', 
+                label=f'Optimal threshold ({SLEEP_OPTIMAL_AWAKE}h)')
+    ax3.axhline(y=0.5, color='orange', linestyle=':', alpha=0.7,
+                label='50% quality (24h awake)')
+    ax3.axhline(y=SLEEP_MIN_QUALITY, color='red', linestyle=':', alpha=0.7,
+                label=f'Floor ({SLEEP_MIN_QUALITY*100:.0f}%)')
+    
+    # Fill regions
+    ax3.fill_between(hours_awake, sleep_quality, alpha=0.3)
+    ax3.axvspan(0, SLEEP_OPTIMAL_AWAKE, alpha=0.1, color='green', label='_No fatigue')
+    ax3.axvspan(SLEEP_OPTIMAL_AWAKE, 24, alpha=0.1, color='yellow')
+    ax3.axvspan(24, 40, alpha=0.1, color='red')
+    
+    ax3.set_xlabel('Hours Since Sleep')
+    ax3.set_ylabel('Quality Multiplier')
+    ax3.set_title('Sleep Deprivation Effect (Exponential Decay)', fontweight='bold')
+    ax3.set_xlim(0, 40)
+    ax3.set_ylim(0, 1.1)
+    ax3.legend(loc='upper right', fontsize=8)
+    ax3.grid(alpha=0.3)
+    
+    # Add annotations
+    ax3.annotate('No impact', xy=(7, 1.02), fontsize=9, color='green')
+    ax3.annotate('Mild fatigue', xy=(18, 0.85), fontsize=9, color='orange')
+    ax3.annotate('Severe', xy=(30, 0.4), fontsize=9, color='red')
+
+    # 4. Optimal Daily Schedule
+    ax4 = fig.add_subplot(2, 2, 4)
+    
+    # Create a 24-hour timeline
+    hours_day = np.arange(24)
+    
+    # Define activity zones
+    sleep_zone = [(0, 7)]  # Sleep 0-7
+    low_zone = [(7, 9), (21, 24)]  # Low engagement
+    medium_zone = [(9, 12), (15, 18), (20, 21)]  # Medium
+    peak_zone = [(12, 15), (18, 20)]  # Peak
+    
+    # Plot colored bands
+    for start, end in sleep_zone:
+        ax4.axvspan(start, end, alpha=0.3, color='navy', label='Sleep (rest)' if start == 0 else '')
+    for start, end in low_zone:
+        ax4.axvspan(start, end, alpha=0.3, color='gray', label='Low engagement' if start == 7 else '')
+    for start, end in medium_zone:
+        ax4.axvspan(start, end, alpha=0.3, color='yellow', label='Medium' if start == 9 else '')
+    for start, end in peak_zone:
+        ax4.axvspan(start, end, alpha=0.4, color='green', label='Peak hours' if start == 12 else '')
+    
+    # Plot engagement curve for peak weekday
+    engagement_curve = [get_hour_multiplier(h, 2) for h in hours_day]  # Wednesday
+    ax4.plot(hours_day, engagement_curve, 'k-', linewidth=2, marker='o', markersize=4)
+    
+    # Add recommended actions
+    actions = [
+        (3, 0.3, 'SLEEP', 'white'),
+        (10, 1.35, 'POST #1', 'darkgreen'),
+        (13, 1.45, 'PEAK POST', 'darkgreen'),
+        (19, 1.3, 'POST #2', 'darkgreen'),
+        (16, 0.85, 'Rest/Create', 'gray'),
+    ]
+    for x, y, text, color in actions:
+        ax4.annotate(text, (x, y), fontsize=9, fontweight='bold', 
+                    color=color, ha='center',
+                    bbox=dict(boxstyle='round,pad=0.3', facecolor='white', alpha=0.8))
+    
+    ax4.set_xlabel('Hour of Day')
+    ax4.set_ylabel('Engagement Multiplier')
+    ax4.set_title('Optimal Daily Schedule (Peak Weekday: Tue-Thu)', fontweight='bold')
+    ax4.set_xlim(0, 24)
+    ax4.set_ylim(0, 1.6)
+    ax4.set_xticks(range(0, 25, 3))
+    ax4.set_xticklabels([f'{h:02d}:00' for h in range(0, 25, 3)])
+    ax4.legend(loc='lower right', fontsize=8)
+    ax4.grid(alpha=0.3)
+
+    plt.tight_layout(rect=[0, 0, 1, 0.96])
+    
+    # Save figure
+    plt.savefig('optimal_posting_guide.png', dpi=150, bbox_inches='tight',
+                facecolor='white', edgecolor='none')
+    print("Saved: optimal_posting_guide.png")
+    
+    # Create second figure with strategy summary
+    fig2, axes = plt.subplots(1, 2, figsize=(14, 6))
+    fig2.suptitle('Strategy Recommendations', fontsize=14, fontweight='bold')
+    
+    # Left: Energy vs Posts tradeoff
+    ax5 = axes[0]
+    posts_per_day = np.arange(0, 6)
+    
+    # Calculate energy remaining after N posts of each type
+    for ct in content_types:
+        cost = CONTENT_ENERGY_COST[ct]
+        energy_remaining = [max(0, 1.0 - n * cost) for n in posts_per_day]
+        ax5.plot(posts_per_day, energy_remaining, '-o', label=ct.replace('_', ' ').title(), linewidth=2)
+    
+    ax5.axhline(y=0.4, color='orange', linestyle='--', label='Safe threshold')
+    ax5.axhline(y=0.2, color='red', linestyle='--', label='Burnout risk')
+    
+    ax5.set_xlabel('Posts Per Day')
+    ax5.set_ylabel('Energy Remaining')
+    ax5.set_title('Energy Drain by Content Type', fontweight='bold')
+    ax5.legend(loc='upper right')
+    ax5.grid(alpha=0.3)
+    ax5.set_xlim(0, 5)
+    ax5.set_ylim(0, 1.1)
+    
+    # Right: Effective Engagement Score
+    ax6 = axes[1]
+    
+    # Calculate total effective engagement for different strategies
+    strategies = [
+        ('2 Reels/day', 2 * BASE_ENGAGEMENT['reel'] * REACH_MULT['reel'], 2 * CONTENT_ENERGY_COST['reel']),
+        ('2 Carousels/day', 2 * BASE_ENGAGEMENT['carousel'] * REACH_MULT['carousel'], 2 * CONTENT_ENERGY_COST['carousel']),
+        ('1 Reel + 1 Carousel', BASE_ENGAGEMENT['reel'] * REACH_MULT['reel'] + BASE_ENGAGEMENT['carousel'] * REACH_MULT['carousel'], 
+         CONTENT_ENERGY_COST['reel'] + CONTENT_ENERGY_COST['carousel']),
+        ('3 Stories/day', 3 * BASE_ENGAGEMENT['story'] * REACH_MULT['story'], 3 * CONTENT_ENERGY_COST['story']),
+        ('4 Text Posts/day', 4 * BASE_ENGAGEMENT['text_post'] * REACH_MULT['text_post'], 4 * CONTENT_ENERGY_COST['text_post']),
+    ]
+    
+    names = [s[0] for s in strategies]
+    engagement = [s[1] for s in strategies]
+    energy_cost = [s[2] for s in strategies]
+    efficiency = [e/c for e, c in zip(engagement, energy_cost)]
+    
+    x = np.arange(len(names))
+    width = 0.35
+    
+    bars1 = ax6.bar(x - width/2, engagement, width, label='Total Engagement', color='steelblue')
+    bars2 = ax6.bar(x + width/2, energy_cost, width, label='Energy Cost', color='coral')
+    
+    ax6.set_ylabel('Value')
+    ax6.set_title('Daily Strategy Comparison', fontweight='bold')
+    ax6.set_xticks(x)
+    ax6.set_xticklabels(names, rotation=15, ha='right')
+    ax6.legend()
+    ax6.grid(axis='y', alpha=0.3)
+    
+    # Add efficiency labels
+    for i, eff in enumerate(efficiency):
+        ax6.annotate(f'Eff: {eff:.1f}', (i, max(engagement[i], energy_cost[i]) + 0.1),
+                    ha='center', fontsize=9, color='green', fontweight='bold')
+    
+    plt.tight_layout(rect=[0, 0, 1, 0.95])
+    plt.savefig('strategy_comparison.png', dpi=150, bbox_inches='tight',
+                facecolor='white', edgecolor='none')
+    print("Saved: strategy_comparison.png")
+    
+    plt.show()
+
+
+def print_summary():
+    """Print text summary of optimal strategies."""
+    print("\n" + "="*70)
+    print("OPTIMAL POSTING STRATEGY SUMMARY")
+    print("="*70)
+    
+    print("\n📅 BEST DAYS:")
+    print("   • Tuesday, Wednesday, Thursday (peak engagement)")
+    print("   • Weekend has 30% penalty")
+    
+    print("\n⏰ BEST HOURS:")
+    print("   • 12:00-15:00 on Tue/Wed/Thu (+40% engagement)")
+    print("   • 09:00-12:00 any weekday (+30%)")
+    print("   • 18:00-20:00 evening (+25%)")
+    print("   • AVOID: 23:00-06:00 (-50%)")
+    
+    print("\n📱 CONTENT TYPES (by reach efficiency):")
+    for ct in ['reel', 'carousel', 'text_post', 'story']:
+        eff = (BASE_ENGAGEMENT[ct] * REACH_MULT[ct]) / CONTENT_ENERGY_COST[ct]
+        print(f"   • {ct.replace('_', ' ').title():12} - "
+              f"Reach: {REACH_MULT[ct]:.2f}x, Energy: {CONTENT_ENERGY_COST[ct]:.0%}, "
+              f"Efficiency: {eff:.1f}")
+    
+    print("\n😴 SLEEP SCHEDULE:")
+    print(f"   • No quality impact for first {SLEEP_OPTIMAL_AWAKE} hours awake")
+    print("   • Quality halves every 10 hours beyond that")
+    print("   • At 24h awake: 50% quality")
+    print("   • Rest during 23:00-07:00 to maintain quality")
+    
+    print("\n🎯 RECOMMENDED DAILY ROUTINE:")
+    print("   07:00 - Wake up (2h buffer before posting)")
+    print("   09:00-12:00 - Post #1 (morning peak)")
+    print("   12:00-15:00 - Post #2 (midday peak on Tue-Thu)")
+    print("   15:00-18:00 - Rest or create content")
+    print("   18:00-20:00 - Optional Post #3 (evening)")
+    print("   23:00 - Sleep (rest actions)")
+    
+    print("\n⚡ ENERGY MANAGEMENT:")
+    print("   • Stay above 0.4 energy (quality drops below 0.5)")
+    print("   • 2 reels/day = 50% energy (sustainable)")
+    print("   • Use content queue for 50% energy discount")
+    print("   • Rest recovers 12% energy + 2h sleep credit")
+    
+    print("\n" + "="*70)
+
+
+def run_all_scenarios() -> List[Dict[str, Any]]:
+    """Run all 61 scenarios and collect results."""
+    from server.viraltest_environment import ViraltestEnvironment
+    from models import ViraltestAction
+    from test_scenarios import SCENARIOS, TASKS
+    
+    # Import reset functions
+    from test_scenarios import (
+        _reset_smart_state, _reset_queue_state, _reset_burst_state,
+        _reset_tag_explorer_state, _reset_balanced_state, _reset_queue_heavy_state,
+        _reset_alternating_state, _reset_content_creator_state, _reset_nap_state
+    )
+    
+    def _reset_all():
+        _reset_smart_state()
+        _reset_queue_state()
+        _reset_burst_state()
+        _reset_tag_explorer_state()
+        _reset_balanced_state()
+        _reset_queue_heavy_state()
+        _reset_alternating_state()
+        _reset_content_creator_state()
+        _reset_nap_state()
+    
+    SEED = 42
+    results = []
+    
+    for scenario_name, agent_fn, description in SCENARIOS:
+        scenario_results = {
+            'name': scenario_name,
+            'description': description,
+            'scores': {},
+            'details': {}
+        }
+        
+        for task in TASKS:
+            _reset_all()
+            env = ViraltestEnvironment()
+            obs = env.reset(task=task, seed=SEED)
+            
+            rewards = []
+            actions = []
+            min_energy = 1.0
+            max_sleep_debt = 0.0
+            burned_out = False
+            
+            for step in range(1, 169):
+                action = agent_fn(obs, step)
+                obs = env.step(action)
+                r = obs.reward if obs.reward is not None else 0.0
+                rewards.append(r)
+                actions.append(action.action_type)
+                min_energy = min(min_energy, obs.creator_energy)
+                max_sleep_debt = max(max_sleep_debt, obs.sleep_debt)
+                if obs.done and obs.creator_energy <= 0:
+                    burned_out = True
+                if obs.done:
+                    break
+            
+            score = (obs.metadata or {}).get("grader_score", 0.0)
+            action_counts = Counter(actions)
+            
+            scenario_results['scores'][task] = score
+            scenario_results['details'][task] = {
+                'steps': len(rewards),
+                'burned_out': burned_out,
+                'min_energy': min_energy,
+                'max_sleep_debt': max_sleep_debt,
+                'final_energy': obs.creator_energy,
+                'followers': obs.follower_count,
+                'follower_delta': obs.follower_count - 10000,
+                'engagement_rate': obs.engagement_rate,
+                'posts': action_counts.get('post', 0),
+                'rests': action_counts.get('rest', 0),
+                'creates': action_counts.get('create_content', 0),
+                'total_reward': sum(rewards),
+            }
+        
+        results.append(scenario_results)
+    
+    return results
+
+
+def create_scenario_visualizations(results: List[Dict[str, Any]]):
+    """Create visualizations for all scenario results."""
+    
+    # Extract data
+    names = [r['name'].replace('SCENARIO ', 'S') for r in results]
+    short_names = [n.split(':')[0] for n in names]  # Just "S1", "S2", etc.
+    
+    engage_scores = [r['scores']['weekly_engage'] for r in results]
+    strategic_scores = [r['scores']['weekly_strategic'] for r in results]
+    competitive_scores = [r['scores']['weekly_competitive'] for r in results]
+    
+    # Figure 1: Score comparison bar chart
+    fig1, axes = plt.subplots(3, 1, figsize=(18, 12))
+    fig1.suptitle('All 61 Scenarios - Performance Scores by Task', fontsize=14, fontweight='bold')
+    
+    x = np.arange(len(results))
+    
+    # Color based on score
+    def get_colors(scores):
+        colors = []
+        for s in scores:
+            if s >= 0.7:
+                colors.append('green')
+            elif s >= 0.4:
+                colors.append('orange')
+            elif s > 0:
+                colors.append('coral')
+            else:
+                colors.append('red')
+        return colors
+    
+    # Weekly Engage
+    ax1 = axes[0]
+    ax1.bar(x, engage_scores, color=get_colors(engage_scores), edgecolor='black', linewidth=0.5)
+    ax1.set_ylabel('Score')
+    ax1.set_title('Weekly Engage Task', fontweight='bold')
+    ax1.set_xticks(x)
+    ax1.set_xticklabels(short_names, rotation=90, fontsize=7)
+    ax1.axhline(y=0.7, color='green', linestyle='--', alpha=0.5, label='Good (0.7+)')
+    ax1.axhline(y=0.4, color='orange', linestyle='--', alpha=0.5, label='Medium (0.4+)')
+    ax1.set_ylim(0, 1.1)
+    ax1.legend(loc='upper right')
+    ax1.grid(axis='y', alpha=0.3)
+    
+    # Weekly Strategic
+    ax2 = axes[1]
+    ax2.bar(x, strategic_scores, color=get_colors(strategic_scores), edgecolor='black', linewidth=0.5)
+    ax2.set_ylabel('Score')
+    ax2.set_title('Weekly Strategic Task', fontweight='bold')
+    ax2.set_xticks(x)
+    ax2.set_xticklabels(short_names, rotation=90, fontsize=7)
+    ax2.axhline(y=0.7, color='green', linestyle='--', alpha=0.5)
+    ax2.axhline(y=0.4, color='orange', linestyle='--', alpha=0.5)
+    ax2.set_ylim(0, 1.1)
+    ax2.grid(axis='y', alpha=0.3)
+    
+    # Weekly Competitive
+    ax3 = axes[2]
+    ax3.bar(x, competitive_scores, color=get_colors(competitive_scores), edgecolor='black', linewidth=0.5)
+    ax3.set_ylabel('Score')
+    ax3.set_title('Weekly Competitive Task', fontweight='bold')
+    ax3.set_xticks(x)
+    ax3.set_xticklabels(short_names, rotation=90, fontsize=7)
+    ax3.axhline(y=0.7, color='green', linestyle='--', alpha=0.5)
+    ax3.axhline(y=0.4, color='orange', linestyle='--', alpha=0.5)
+    ax3.set_ylim(0, 1.1)
+    ax3.grid(axis='y', alpha=0.3)
+    
+    plt.tight_layout(rect=[0, 0, 1, 0.97])
+    plt.savefig('scenario_scores.png', dpi=150, bbox_inches='tight', facecolor='white')
+    print("Saved: scenario_scores.png")
+    
+    # Figure 2: Top 15 scenarios
+    fig2, ax = plt.subplots(figsize=(14, 8))
+    fig2.suptitle('Top 15 Scenarios by Average Score', fontsize=14, fontweight='bold')
+    
+    # Calculate average scores
+    avg_scores = [(r['name'], 
+                   (r['scores']['weekly_engage'] + r['scores']['weekly_strategic'] + r['scores']['weekly_competitive']) / 3,
+                   r['scores']['weekly_engage'],
+                   r['scores']['weekly_strategic'],
+                   r['scores']['weekly_competitive'])
+                  for r in results]
+    avg_scores.sort(key=lambda x: x[1], reverse=True)
+    top15 = avg_scores[:15]
+    
+    y = np.arange(len(top15))
+    width = 0.25
+    
+    names_top = [t[0].replace('SCENARIO ', '').split(':')[1].strip()[:25] for t in top15]
+    engage_top = [t[2] for t in top15]
+    strategic_top = [t[3] for t in top15]
+    competitive_top = [t[4] for t in top15]
+    
+    bars1 = ax.barh(y + width, engage_top, width, label='Engage', color='steelblue')
+    bars2 = ax.barh(y, strategic_top, width, label='Strategic', color='seagreen')
+    bars3 = ax.barh(y - width, competitive_top, width, label='Competitive', color='coral')
+    
+    ax.set_xlabel('Score')
+    ax.set_ylabel('Scenario')
+    ax.set_yticks(y)
+    ax.set_yticklabels(names_top)
+    ax.legend(loc='lower right')
+    ax.set_xlim(0, 1.1)
+    ax.grid(axis='x', alpha=0.3)
+    ax.invert_yaxis()
+    
+    # Add average score labels
+    for i, (name, avg, e, s, c) in enumerate(top15):
+        ax.text(1.02, i, f'Avg: {avg:.2f}', va='center', fontsize=9, fontweight='bold')
+    
+    plt.tight_layout(rect=[0, 0, 0.95, 0.97])
+    plt.savefig('top_scenarios.png', dpi=150, bbox_inches='tight', facecolor='white')
+    print("Saved: top_scenarios.png")
+    
+    # Figure 3: Sleep-related scenarios comparison
+    fig3, axes = plt.subplots(1, 2, figsize=(14, 6))
+    fig3.suptitle('Sleep-Related Scenarios Analysis', fontsize=14, fontweight='bold')
+    
+    sleep_scenarios = [r for r in results if any(kw in r['name'].lower() or kw in r['description'].lower() 
+                                                  for kw in ['sleep', 'night', 'rest', 'marathon', 'nap'])]
+    
+    # Left: Scores comparison
+    ax_left = axes[0]
+    sleep_names = [r['name'].replace('SCENARIO ', '').split(':')[1].strip()[:20] for r in sleep_scenarios]
+    sleep_engage = [r['scores']['weekly_engage'] for r in sleep_scenarios]
+    sleep_strategic = [r['scores']['weekly_strategic'] for r in sleep_scenarios]
+    sleep_competitive = [r['scores']['weekly_competitive'] for r in sleep_scenarios]
+    
+    y = np.arange(len(sleep_scenarios))
+    width = 0.25
+    
+    ax_left.barh(y + width, sleep_engage, width, label='Engage', color='steelblue')
+    ax_left.barh(y, sleep_strategic, width, label='Strategic', color='seagreen')
+    ax_left.barh(y - width, sleep_competitive, width, label='Competitive', color='coral')
+    
+    ax_left.set_xlabel('Score')
+    ax_left.set_ylabel('Scenario')
+    ax_left.set_yticks(y)
+    ax_left.set_yticklabels(sleep_names)
+    ax_left.legend(loc='lower right')
+    ax_left.set_xlim(0, 1.1)
+    ax_left.grid(axis='x', alpha=0.3)
+    ax_left.set_title('Sleep Scenario Scores')
+    ax_left.invert_yaxis()
+    
+    # Right: Sleep debt and energy analysis
+    ax_right = axes[1]
+    
+    # Get sleep debt and min energy for strategic task
+    sleep_debt_vals = [r['details']['weekly_strategic']['max_sleep_debt'] for r in sleep_scenarios]
+    min_energy_vals = [r['details']['weekly_strategic']['min_energy'] for r in sleep_scenarios]
+    burned_out = [r['details']['weekly_strategic']['burned_out'] for r in sleep_scenarios]
+    
+    x = np.arange(len(sleep_scenarios))
+    width = 0.35
+    
+    bars1 = ax_right.bar(x - width/2, sleep_debt_vals, width, label='Max Sleep Debt', color='purple', alpha=0.7)
+    bars2 = ax_right.bar(x + width/2, min_energy_vals, width, label='Min Energy', color='orange', alpha=0.7)
+    
+    # Mark burned out scenarios
+    for i, bo in enumerate(burned_out):
+        if bo:
+            ax_right.annotate('💀', (i, max(sleep_debt_vals[i], min_energy_vals[i]) + 0.05),
+                            ha='center', fontsize=12)
+    
+    ax_right.set_xlabel('Scenario')
+    ax_right.set_ylabel('Value')
+    ax_right.set_xticks(x)
+    ax_right.set_xticklabels(sleep_names, rotation=45, ha='right', fontsize=8)
+    ax_right.legend(loc='upper right')
+    ax_right.set_ylim(0, 1.2)
+    ax_right.grid(axis='y', alpha=0.3)
+    ax_right.set_title('Sleep Debt vs Min Energy (💀 = burned out)')
+    
+    plt.tight_layout(rect=[0, 0, 1, 0.95])
+    plt.savefig('sleep_scenarios.png', dpi=150, bbox_inches='tight', facecolor='white')
+    print("Saved: sleep_scenarios.png")
+    
+    # Figure 4: Scenario categories heatmap
+    fig4, ax = plt.subplots(figsize=(16, 10))
+    fig4.suptitle('All Scenarios - Score Heatmap', fontsize=14, fontweight='bold')
+    
+    # Create matrix for heatmap
+    all_scores = np.array([[r['scores']['weekly_engage'], 
+                            r['scores']['weekly_strategic'], 
+                            r['scores']['weekly_competitive']] for r in results])
+    
+    im = ax.imshow(all_scores, aspect='auto', cmap='RdYlGn', vmin=0, vmax=1)
+    
+    ax.set_yticks(range(len(results)))
+    ax.set_yticklabels([r['name'].replace('SCENARIO ', '') for r in results], fontsize=7)
+    ax.set_xticks([0, 1, 2])
+    ax.set_xticklabels(['Engage', 'Strategic', 'Competitive'])
+    
+    # Add score text
+    for i in range(len(results)):
+        for j in range(3):
+            score = all_scores[i, j]
+            color = 'white' if score < 0.5 else 'black'
+            ax.text(j, i, f'{score:.2f}', ha='center', va='center', fontsize=6, color=color)
+    
+    cbar = plt.colorbar(im, ax=ax, shrink=0.8)
+    cbar.set_label('Score')
+    
+    plt.tight_layout(rect=[0, 0, 1, 0.97])
+    plt.savefig('scenario_heatmap.png', dpi=150, bbox_inches='tight', facecolor='white')
+    print("Saved: scenario_heatmap.png")
+    
+    # Figure 5: Action distribution for top performers
+    fig5, axes = plt.subplots(2, 3, figsize=(15, 10))
+    fig5.suptitle('Action Distribution - Top 6 Strategies', fontsize=14, fontweight='bold')
+    
+    top6 = avg_scores[:6]
+    top6_results = [r for r in results if r['name'] in [t[0] for t in top6]]
+    top6_results.sort(key=lambda r: next(t[1] for t in top6 if t[0] == r['name']), reverse=True)
+    
+    for idx, r in enumerate(top6_results):
+        ax = axes[idx // 3, idx % 3]
+        details = r['details']['weekly_strategic']
+        
+        actions = ['Posts', 'Rests', 'Creates']
+        counts = [details['posts'], details['rests'], details['creates']]
+        colors = ['steelblue', 'seagreen', 'coral']
+        
+        wedges, texts, autotexts = ax.pie(counts, labels=actions, autopct='%1.0f%%',
+                                          colors=colors, startangle=90)
+        ax.set_title(r['name'].replace('SCENARIO ', '').split(':')[1].strip()[:25], fontsize=10)
+        
+        # Add stats
+        avg = (r['scores']['weekly_engage'] + r['scores']['weekly_strategic'] + r['scores']['weekly_competitive']) / 3
+        ax.text(0, -1.3, f"Avg Score: {avg:.2f} | Energy: {details['final_energy']:.2f}", 
+               ha='center', fontsize=8)
+    
+    plt.tight_layout(rect=[0, 0.02, 1, 0.95])
+    plt.savefig('top_actions.png', dpi=150, bbox_inches='tight', facecolor='white')
+    print("Saved: top_actions.png")
+    
+    return results
+
+
+def print_scenario_summary(results: List[Dict[str, Any]]):
+    """Print summary table of all scenarios."""
+    print("\n" + "="*100)
+    print("ALL 61 SCENARIOS - SIMULATION RESULTS")
+    print("="*100)
+    
+    # Calculate averages and sort
+    scored_results = []
+    for r in results:
+        avg = (r['scores']['weekly_engage'] + r['scores']['weekly_strategic'] + r['scores']['weekly_competitive']) / 3
+        scored_results.append((r, avg))
+    scored_results.sort(key=lambda x: x[1], reverse=True)
+    
+    print(f"\n{'Rank':<5} {'Scenario':<45} {'Engage':>8} {'Strategic':>10} {'Competitive':>12} {'Avg':>8}")
+    print("-" * 100)
+    
+    for rank, (r, avg) in enumerate(scored_results, 1):
+        name = r['name'].replace('SCENARIO ', '')[:43]
+        e = r['scores']['weekly_engage']
+        s = r['scores']['weekly_strategic']
+        c = r['scores']['weekly_competitive']
+        
+        # Add indicator for top performers
+        indicator = "🏆" if rank <= 3 else "⭐" if rank <= 10 else "  "
+        print(f"{indicator}{rank:<3} {name:<45} {e:>8.4f} {s:>10.4f} {c:>12.4f} {avg:>8.4f}")
+    
+    print("\n" + "="*100)
+    print("TOP 10 DETAILED ANALYSIS")
+    print("="*100)
+    
+    for rank, (r, avg) in enumerate(scored_results[:10], 1):
+        print(f"\n#{rank} {r['name']}")
+        print(f"   Description: {r['description']}")
+        
+        for task in ['weekly_engage', 'weekly_strategic', 'weekly_competitive']:
+            d = r['details'][task]
+            print(f"   {task}: Score={r['scores'][task]:.4f} | "
+                  f"Posts={d['posts']} Rests={d['rests']} Creates={d['creates']} | "
+                  f"Energy={d['final_energy']:.2f} | Followers={d['follower_delta']:+d}")
+    
+    # Sleep scenario analysis
+    print("\n" + "="*100)
+    print("SLEEP MECHANICS ANALYSIS")
+    print("="*100)
+    
+    sleep_keywords = ['sleep', 'night', 'rest', 'marathon', 'nap', 'awake']
+    sleep_results = [(r, (r['scores']['weekly_engage'] + r['scores']['weekly_strategic'] + r['scores']['weekly_competitive']) / 3) 
+                     for r in results 
+                     if any(kw in r['name'].lower() or kw in r['description'].lower() for kw in sleep_keywords)]
+    sleep_results.sort(key=lambda x: x[1], reverse=True)
+    
+    print(f"\n{'Scenario':<40} {'Avg Score':>10} {'Max Sleep Debt':>15} {'Burned Out':>12}")
+    print("-" * 80)
+    
+    for r, avg in sleep_results:
+        name = r['name'].replace('SCENARIO ', '').split(':')[1].strip()[:38]
+        debt = r['details']['weekly_strategic']['max_sleep_debt']
+        bo = "YES 💀" if r['details']['weekly_strategic']['burned_out'] else "No"
+        print(f"{name:<40} {avg:>10.4f} {debt:>15.3f} {bo:>12}")
+    
+    print("\n" + "="*100)
+
+
+if __name__ == "__main__":
+    print("Generating optimal posting visualizations...")
+    print_summary()
+    create_visualizations()
+    
+    print("\n" + "="*70)
+    print("Running all 61 scenarios...")
+    print("="*70)
+    
+    results = run_all_scenarios()
+    print_scenario_summary(results)
+    create_scenario_visualizations(results)
+    
+    print("\n✅ All visualizations generated!")
+    print("   - optimal_posting_guide.png")
+    print("   - strategy_comparison.png")
+    print("   - scenario_scores.png")
+    print("   - top_scenarios.png")
+    print("   - sleep_scenarios.png")
+    print("   - scenario_heatmap.png")
+    print("   - top_actions.png")