stream_weaver 0.3.0

data/examples/dashboard_components.rb

@@ -0,0 +1,108 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Example: Dashboard Components
+# Showcases all dashboard-style components with dark theme
+# Run with: ./exe/streamweaver examples/dashboard_components.rb
+
+app "Dashboard Components Demo", theme: :dark, layout: :wide do
+  # Header with pulse indicator
+  app_header "Dashboard Components", variant: :primary do
+    pulse_indicator color: :green, label: "System Active"
+  end
+
+  header2 "Status Dots"
+  text "Colored indicator dots with optional glow effect:"
+  hstack spacing: :lg, align: :center do
+    vstack spacing: :xs, align: :center do
+      status_dot status: :red
+      text "Red"
+    end
+    vstack spacing: :xs, align: :center do
+      status_dot status: :yellow
+      text "Yellow"
+    end
+    vstack spacing: :xs, align: :center do
+      status_dot status: :green
+      text "Green"
+    end
+    vstack spacing: :xs, align: :center do
+      status_dot status: :green, pulse: true
+      text "Pulsing"
+    end
+    vstack spacing: :xs, align: :center do
+      status_dot status: :gray
+      text "Gray"
+    end
+  end
+
+  header2 "Badges"
+  text "Count/label badges in various variants:"
+  hstack spacing: :md do
+    badge "5", variant: :default
+    badge "3", variant: :danger
+    badge "12", variant: :warning
+    badge "OK", variant: :success
+    badge "new", variant: :info
+  end
+
+  header2 "Stat Displays"
+  text "Large metric numbers with labels:"
+  hstack spacing: :xl do
+    stat_display value: 24, label: "TOTAL", color: :default
+    stat_display value: 7, label: "PENDING", color: :blue
+    stat_display value: 12, label: "IN PROGRESS", color: :purple
+    stat_display value: 5, label: "BLOCKED", color: :red
+  end
+
+  header2 "Type Tags"
+  text "Activity type badges:"
+  hstack spacing: :md do
+    type_tag :research
+    type_tag :task
+    type_tag :escalation
+    type_tag :communication
+    type_tag :warning
+    type_tag :info
+  end
+
+  header2 "Priority Items"
+  text "Items with priority-colored left borders (hover to see slide effect):"
+  vstack spacing: :md do
+    priority_item priority: :critical, title: "Database migration blocked",
+                  description: "Production schema changes require downtime window approval.",
+                  meta_left: "ops", meta_right: "Schedule window"
+
+    priority_item priority: :urgent, title: "API rate limits exceeded",
+                  description: "Third-party integration hitting 429 errors. Need backoff strategy.",
+                  meta_left: "backend", meta_right: "Implement retry"
+
+    priority_item priority: :high, title: "Security audit findings",
+                  description: "3 medium-severity items need remediation before release.",
+                  meta_left: "security", meta_right: "Review findings"
+
+    priority_item priority: :normal, title: "Documentation update",
+                  description: "API docs need refresh for v2 endpoints.",
+                  meta_left: "docs", meta_right: "Update guides"
+  end
+
+  header2 "Activity Items"
+  text "Activity feed with time, title, summary, and type (hover to see highlight):"
+  vstack spacing: :none do
+    activity_item time: "15:00", title: "Performance analysis complete",
+                  summary: "Identified 3 slow queries, recommended indexes",
+                  type: :research
+
+    activity_item time: "15:05", title: "Deployment approval needed",
+                  summary: "Staging verified, awaiting prod sign-off",
+                  type: :escalation
+
+    activity_item time: "14:00", title: "Feature branch merged",
+                  summary: "User preferences module integrated",
+                  type: :task
+
+    activity_item time: "13:30", title: "Standup notes shared",
+                  summary: "Team aligned on sprint priorities",
+                  type: :communication
+  end
+end

data/examples/deferred_fragments_demo.rb

@@ -0,0 +1,62 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Manual-verification harness for deferred fragments (`fragment ..., defer: true`)
+# -- the Turbo `turbo_frame_tag ..., src:` equivalent. Every deferred block below
+# sleeps, so the point is visible: the shell paints immediately and each region
+# fills in on its own afterwards, with zero JavaScript in this file.
+#
+#   SW_NO_OPEN=1 STREAMWEAVER_PORT=4599 ruby examples/deferred_fragments_demo.rb
+#
+# SW_DEFER_DELAY overrides the per-fragment sleep (default 1.5s, matching the
+# learnhotwire course's `sleep 1.5` hover-card demo).
+
+$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
+require "stream_weaver"
+
+DELAY = (ENV["SW_DEFER_DELAY"] || "1.5").to_f
+
+def slow_work(label)
+  sleep DELAY
+  "#{label} finished at #{Time.now.strftime('%H:%M:%S.%L')}"
+end
+
+app "Deferred Fragments" do
+  header1 "Deferred fragments"
+  md "This line and everything above it render **immediately**. Each panel below " \
+     "sleeps #{DELAY}s inside its `defer: true` block, so the block cannot run " \
+     "during the page render -- the shell would take #{(DELAY * 3).round(1)}s if it did."
+  text "Shell rendered at #{Time.now.strftime('%H:%M:%S.%L')}"
+
+  header3 "1. Default placeholder (spinner)"
+  fragment :default_placeholder, defer: true do
+    text slow_work("Panel 1")
+  end
+
+  header3 "2. String placeholder"
+  fragment :string_placeholder, defer: true, placeholder: "Crunching numbers…" do
+    text slow_work("Panel 2")
+  end
+
+  header3 "3. Custom DSL placeholder, reading state from the field above it"
+  text_field :who, placeholder: "type a name, then reload", label: "Who"
+  fragment :reads_state, defer: true, placeholder: -> { alert(variant: :info) { text "Waiting for the server…" } } do
+    text slow_work("Panel 3 for #{state[:who].to_s.empty? ? '(nobody)' : state[:who]}")
+  end
+
+  header3 "4. Deferred nested inside deferred (loads as a chain)"
+  fragment :outer_panel, defer: true, placeholder: "Outer loading…" do
+    text slow_work("Outer")
+    fragment :inner_panel, defer: true, placeholder: "Inner loading…" do
+      text slow_work("Inner")
+    end
+  end
+
+  header3 "5. Full-container swap"
+  md "This button swaps the whole app container. The panels above should return " \
+     "to their placeholders and fetch again rather than sticking on a placeholder."
+  button "Re-render the page" do |s|
+    s[:renders] = s[:renders].to_i + 1
+  end
+  text "Full re-renders so far: #{state[:renders].to_i}"
+end.run!

data/examples/generate_more_spike/README.md

@@ -0,0 +1,63 @@
+# Generate-More Spike (T1)
+
+Standalone spike demonstrating the generate-more loop using **push-to-state** architecture.
+
+## How to Run
+
+```bash
+cd examples/generate_more_spike
+ruby app.rb
+```
+
+The app opens at `http://127.0.0.1:4567` (or next available port).
+
+## What It Demonstrates
+
+1. **Generate More button** -- Enter an optional prompt and select how many options to generate (1-5).
+2. **Skeleton placeholders** -- While generating, skeleton shimmer cards appear for pending options.
+3. **Simulated agent** -- A background thread simulates an agent (polls for requests, sleeps 1-3s per option, pushes results to state).
+4. **Push-to-state** -- New options are written to server-side shared state. SSE sends the re-rendered HTML to the browser. The browser never receives raw data -- it gets a fully rendered content div.
+5. **Timeout** -- If generation takes longer than 15s, a timeout warning appears.
+6. **Cancel** -- A cancel button aborts in-progress generation.
+7. **Session isolation** -- Each browser session gets its own state keyed by session ID.
+
+## Architecture Validated
+
+### Push-to-State Pattern
+
+The agent pushes options into a shared server-side state store, NOT directly into the DOM via SSE. StreamWeaver's existing `Streamer.replace()` sends the complete re-rendered HTML for the content div. This:
+
+- Eliminates the phantom option race condition (user on different slide when options arrive)
+- Keeps everything in sync automatically (no stale partial state)
+- Aligns with StreamWeaver's reactive model (re-render from state)
+- Is simpler than SSE-to-DOM with targeted element updates
+
+### Key Finding: Session Cookie Limitation
+
+The agent thread has NO access to Sinatra's cookie-based session. Push-to-state requires a server-side state store (in-memory hash, file-backed JSON, or similar) keyed by session ID. T10 must implement `DeckState` as a file-backed store, not rely on `session[:streamlit_state]`.
+
+## State Machine
+
+```
+                        IDLE
+                          |
+                [user clicks Generate]
+                          |
+                          v
+                    GENERATING
+                   /     |      \
+        [all received]   |   [user cancels]
+               |    [timeout 15s]    |
+               v         |          v
+             IDLE    TIMED_OUT   CANCELLED
+                         |          |
+                    [retry/dismiss] [cleanup]
+                         |          |
+                         v          v
+                        IDLE      IDLE
+```
+
+## Files
+
+- `app.rb` -- The spike app (standalone, does not modify the gem)
+- `README.md` -- This file

data/examples/generate_more_spike/app.rb

@@ -0,0 +1,441 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# ============================================================================
+# Generate-More Spike (T1)
+# ============================================================================
+#
+# Standalone spike demonstrating the generate-more loop using push-to-state.
+# This is throwaway code -- T10 will do the real implementation.
+#
+# Key architectural decision being validated:
+#   Push-to-state, NOT push-to-DOM.
+#   The "agent" pushes new options into server-side state, and StreamWeaver's
+#   reactive re-render handles display. No direct DOM manipulation via SSE.
+#
+# Run with:
+#   cd examples/generate_more_spike && ruby app.rb
+#
+# What it demonstrates:
+#   1. "Generate More" button with prompt input
+#   2. Skeleton placeholders appear while generating
+#   3. Simulated agent (Thread.new) detects request, sleeps, pushes state
+#   4. Page re-renders reactively with new options replacing skeletons
+#   5. Timeout after 15s shows error message
+#   6. Cancel button aborts pending generation
+#   7. Session-scoped request queue
+# ============================================================================
+
+require_relative '../../lib/stream_weaver'
+require 'json'
+require 'securerandom'
+
+# ============================================================================
+# Generate-More State Machine (Discovered through implementation)
+# ============================================================================
+# States:
+#   :idle       - No generation in progress. Generate button enabled.
+#   :generating - Request queued, skeletons visible, cancel button shown.
+#   :timed_out  - 15s elapsed without all options arriving.
+#   :cancelled  - User cancelled, agent acknowledged. Transient -> idle.
+#
+# Transitions:
+#   idle -> generating       (user clicks Generate)
+#   generating -> idle       (all options received)
+#   generating -> timed_out  (15s timeout, checked in timer)
+#   generating -> cancelled  (user clicks Cancel)
+#   cancelled -> idle        (immediate, after cleanup)
+#   timed_out -> idle        (user clicks Generate again)
+# ============================================================================
+
+# ============================================================================
+# Shared state store (simulates file-backed DeckState for the spike)
+# ============================================================================
+# In T10 this becomes DeckState with file-backed JSON per session.
+# Key finding: session cookies can't hold this state (agent thread has no
+# access to Sinatra sessions). A shared server-side store keyed by session
+# ID is required.
+
+module SpikeState
+  @mutex = Mutex.new
+  @sessions = {}
+  @pending_requests = []
+  @cancelled_sessions = {}
+
+  class << self
+    attr_reader :mutex
+
+    def get(session_id)
+      @mutex.synchronize do
+        @sessions[session_id] ||= default_state
+        @sessions[session_id].dup
+      end
+    end
+
+    def update(session_id)
+      @mutex.synchronize do
+        @sessions[session_id] ||= default_state
+        yield @sessions[session_id]
+      end
+    end
+
+    def queue_request(request)
+      @mutex.synchronize { @pending_requests << request }
+    end
+
+    def take_requests
+      @mutex.synchronize do
+        taken = @pending_requests.dup
+        @pending_requests.clear
+        taken
+      end
+    end
+
+    def cancel(session_id)
+      @mutex.synchronize { @cancelled_sessions[session_id] = true }
+    end
+
+    def cancelled?(session_id)
+      @mutex.synchronize { @cancelled_sessions.delete(session_id) || false }
+    end
+
+    private
+
+    def default_state
+      {
+        options: [
+          { id: "opt_1", label: "Monolith", description: "Single deployable unit, simpler operations", generated: false },
+          { id: "opt_2", label: "Microservices", description: "Independent services, complex but scalable", generated: false },
+        ],
+        generate_status: :idle,
+        requested_count: 0,
+        received_count: 0,
+        prompt: nil,
+        started_at: nil,
+      }
+    end
+  end
+end
+
+# ============================================================================
+# Simulated agent options
+# ============================================================================
+
+SIMULATED_OPTIONS = [
+  { label: "Event-Driven", description: "Loosely coupled via message bus, great for async workflows" },
+  { label: "Serverless", description: "Functions-as-a-service, pay per invocation, auto-scaling" },
+  { label: "Modular Monolith", description: "Best of both: monolith deployment, modular internals" },
+  { label: "Hexagonal", description: "Ports and adapters pattern, testable and flexible" },
+  { label: "CQRS", description: "Separate read/write models for optimized query performance" },
+  { label: "Service Mesh", description: "Sidecar proxies handle networking, observability built-in" },
+]
+
+# ============================================================================
+# Simulated Agent Thread
+# ============================================================================
+# In the real system, an external agent polls GET /deck/pending.
+# Here we simulate with a thread watching the shared state.
+
+$streamer_ref = nil
+$sim_option_index = 0
+
+def start_agent_simulator
+  Thread.new do
+    loop do
+      requests = SpikeState.take_requests
+
+      requests.each do |request|
+        session_id = request[:session_id]
+        count = request[:count]
+        prompt = request[:prompt]
+
+        $stderr.puts "[Agent] Processing generate request: count=#{count}, prompt=#{prompt.inspect}"
+
+        count.times do |i|
+          # Check cancellation
+          if SpikeState.cancelled?(session_id)
+            $stderr.puts "[Agent] Generation cancelled for session #{session_id}"
+            SpikeState.update(session_id) { |s| s[:generate_status] = :idle }
+            push_rerender(session_id)
+            break
+          end
+
+          # Simulate LLM generation delay (1-3 seconds per option)
+          sleep(1.0 + rand * 2.0)
+
+          # Check cancellation again after sleep
+          if SpikeState.cancelled?(session_id)
+            $stderr.puts "[Agent] Generation cancelled (post-sleep) for session #{session_id}"
+            SpikeState.update(session_id) { |s| s[:generate_status] = :idle }
+            push_rerender(session_id)
+            break
+          end
+
+          # Check if already timed out
+          state = SpikeState.get(session_id)
+          if state[:generate_status] != :generating
+            $stderr.puts "[Agent] State is #{state[:generate_status]}, stopping generation"
+            break
+          end
+
+          # Pick a simulated option
+          opt = SIMULATED_OPTIONS[$sim_option_index % SIMULATED_OPTIONS.length]
+          $sim_option_index += 1
+
+          desc = prompt && !prompt.strip.empty? ?
+            "#{opt[:description]} (prompted: #{prompt})" :
+            opt[:description]
+
+          opt_id = "gen_#{SecureRandom.hex(4)}"
+
+          # PUSH TO STATE -- the key architectural decision
+          SpikeState.update(session_id) do |s|
+            s[:options] << {
+              id: opt_id,
+              label: opt[:label],
+              description: desc,
+              generated: true,
+            }
+            s[:received_count] += 1
+            $stderr.puts "[Agent] Pushed option #{i + 1}/#{count}: #{opt[:label]} (#{s[:received_count]}/#{s[:requested_count]})"
+
+            # If all received, transition to idle
+            if s[:received_count] >= s[:requested_count]
+              s[:generate_status] = :idle
+              $stderr.puts "[Agent] All options received -> idle"
+            end
+          end
+
+          # Notify browser to re-render via SSE
+          push_rerender(session_id)
+        end
+      end
+
+      sleep 0.5 unless requests.any?
+    end
+  end
+end
+
+def push_rerender(session_id)
+  return unless $streamer_ref
+  html = build_options_html(session_id)
+  $streamer_ref.replace("#spike-content", html)
+end
+
+# ============================================================================
+# HTML builder for option cards + skeletons + status
+# ============================================================================
+# This is what StreamWeaver's reactive re-render would produce.
+# The component tree reads state and renders the current view.
+
+def build_options_html(session_id)
+  state = SpikeState.get(session_id)
+  status = state[:generate_status]
+  options = state[:options]
+  requested = state[:requested_count]
+  received = state[:received_count]
+  remaining = status == :generating ? [requested - received, 0].max : 0
+
+  html = +""
+
+  # Status banner
+  case status
+  when :generating
+    elapsed = state[:started_at] ? (Time.now.to_f - state[:started_at]).round(1) : 0
+    html << %(<div style="background:#1e3a5f;border:1px solid #3b82f6;border-radius:8px;padding:12px 16px;margin-bottom:16px;display:flex;align-items:center;justify-content:space-between">)
+    html << %(<div style="display:flex;align-items:center;gap:8px">)
+    html << %(<div style="width:12px;height:12px;border-radius:50%;background:#3b82f6;animation:pulse 1s ease-in-out infinite"></div>)
+    html << %(<span style="color:#93c5fd">Generating #{requested} option(s)... #{received}/#{requested} received (#{elapsed}s)</span>)
+    html << %(</div>)
+    html << %(<form method="post" action="/spike/cancel" style="margin:0">)
+    html << %(<input type="hidden" name="session_id" value="#{session_id}">)
+    html << %(<button type="submit" style="background:#dc2626;color:white;border:none;border-radius:6px;padding:6px 16px;cursor:pointer;font-size:0.875rem">Cancel</button>)
+    html << %(</form></div>)
+  when :timed_out
+    html << %(<div style="background:#451a03;border:1px solid #f59e0b;border-radius:8px;padding:12px 16px;margin-bottom:16px">)
+    html << %(<span style="color:#fbbf24">Generation timed out after 15s. #{received}/#{requested} options received. Click Generate to try again.</span>)
+    html << %(</div>)
+  end
+
+  # Options grid
+  html << %(<div style="display:grid;grid-template-columns:repeat(auto-fill,minmax(280px,1fr));gap:16px">)
+
+  options.each do |opt|
+    border = opt[:generated] ? "#22c55e" : "#374151"
+    badge = opt[:generated] ?
+      %(<span style="background:#166534;color:#86efac;font-size:0.7rem;padding:2px 8px;border-radius:9999px;margin-left:8px">generated</span>) : ""
+
+    html << %(<div style="background:#1f2937;border:1px solid #{border};border-radius:12px;padding:16px">)
+    html << %(<h3 style="margin:0 0 8px;color:#f3f4f6;font-size:1rem">#{opt[:label]}#{badge}</h3>)
+    html << %(<p style="margin:0;color:#9ca3af;font-size:0.875rem">#{opt[:description]}</p>)
+    html << %(</div>)
+  end
+
+  # Skeleton placeholders
+  remaining.times do
+    html << %(<div style="background:#1f2937;border:1px solid #374151;border-radius:12px;padding:16px">)
+    html << %(<div style="background:#374151;height:20px;width:60%;border-radius:4px;margin-bottom:12px;animation:shimmer 1.5s ease-in-out infinite alternate"></div>)
+    html << %(<div style="background:#374151;height:14px;width:90%;border-radius:4px;margin-bottom:8px;animation:shimmer 1.5s ease-in-out infinite alternate 0.2s"></div>)
+    html << %(<div style="background:#374151;height:14px;width:75%;border-radius:4px;animation:shimmer 1.5s ease-in-out infinite alternate 0.4s"></div>)
+    html << %(</div>)
+  end
+
+  html << %(</div>)
+
+  # CSS for animations (included each push since SSE replaces content)
+  html << %(<style>)
+  html << %(@keyframes shimmer{from{opacity:0.5}to{opacity:1}})
+  html << %(@keyframes pulse{0%,100%{opacity:1}50%{opacity:0.4}})
+  html << %(</style>)
+
+  html
+end
+
+# ============================================================================
+# StreamWeaver App
+# ============================================================================
+
+SpikeApp = app "Generate-More Spike", theme: :dark, stylesheets: [
+  "data:text/css,@keyframes shimmer{from{opacity:0.5}to{opacity:1}}@keyframes pulse{0%,100%{opacity:1}50%{opacity:0.4}}"
+] do
+  # Assign a session ID on first visit
+  state[:spike_session] ||= SecureRandom.hex(8)
+  session_id = state[:spike_session]
+
+  # Initialize session state if needed
+  SpikeState.get(session_id)
+  spike_state = SpikeState.get(session_id)
+
+  header1 "Generate-More Spike"
+  text "Demonstrates the push-to-state architecture for the generate-more loop."
+  text "Options below are pre-seeded. Click 'Generate More' to simulate an agent generating additional options."
+
+  div style: "border-top:1px solid #374151;margin:16px 0"
+
+  # Generate controls
+  card do
+    header3 "Generate More Options"
+
+    text_field :gen_prompt, placeholder: "e.g., Focus on event-driven patterns", label: "Prompt (optional)"
+
+    select :gen_count, ["1", "2", "3", "4", "5"], default: "2", label: "Number of options"
+
+    is_generating = spike_state[:generate_status] == :generating
+
+    unless is_generating
+      button "Generate More", variant: :primary do |s|
+        sid = s[:spike_session]
+        count = (s[:gen_count] || "2").to_i
+        prompt = s[:gen_prompt]
+
+        # Transition to :generating
+        SpikeState.update(sid) do |ss|
+          ss[:generate_status] = :generating
+          ss[:requested_count] = count
+          ss[:received_count] = 0
+          ss[:prompt] = prompt
+          ss[:started_at] = Time.now.to_f
+        end
+
+        # Queue request for the agent simulator
+        SpikeState.queue_request(
+          session_id: sid,
+          count: count,
+          prompt: prompt,
+          timestamp: Time.now,
+        )
+
+        $stderr.puts "[Server] Generate request queued: session=#{sid} count=#{count} prompt=#{prompt.inspect}"
+      end
+    end
+  end
+
+  # Content area -- this div is replaced by SSE pushes
+  div id: "spike-content" do
+    # Initial render: show current options from spike state
+    spike_state[:options].each do |opt|
+      card do
+        badge_label = opt[:generated] ? " [generated]" : ""
+        header3 "#{opt[:label]}#{badge_label}"
+        text opt[:description]
+      end
+    end
+
+    # Show skeletons if currently generating
+    if spike_state[:generate_status] == :generating
+      remaining = [spike_state[:requested_count] - spike_state[:received_count], 0].max
+      remaining.times do
+        div style: "background:#1f2937;border:1px solid #374151;border-radius:12px;padding:16px;margin-top:8px" do
+          div style: "background:#374151;height:20px;width:60%;border-radius:4px;margin-bottom:12px;animation:shimmer 1.5s ease-in-out infinite alternate"
+          div style: "background:#374151;height:14px;width:90%;border-radius:4px;margin-bottom:8px;animation:shimmer 1.5s ease-in-out infinite alternate 0.2s"
+          div style: "background:#374151;height:14px;width:75%;border-radius:4px;animation:shimmer 1.5s ease-in-out infinite alternate 0.4s"
+        end
+      end
+    end
+
+    if spike_state[:generate_status] == :timed_out
+      alert variant: :warning, title: "Timeout" do
+        text "Generation timed out after 15s. #{spike_state[:received_count]}/#{spike_state[:requested_count]} options received."
+      end
+    end
+  end
+
+  # State debug panel
+  div style: "margin-top:24px;padding:16px;background:#111827;border:1px solid #1f2937;border-radius:8px" do
+    header4 "State Debug"
+    text "Session: #{session_id}"
+    text "Status: #{spike_state[:generate_status]}"
+    text "Options: #{spike_state[:options].length} (#{spike_state[:options].count { |o| o[:generated] }} generated)"
+    text "Requested: #{spike_state[:requested_count]}, Received: #{spike_state[:received_count]}"
+    if spike_state[:started_at] && spike_state[:generate_status] == :generating
+      text "Elapsed: #{(Time.now.to_f - spike_state[:started_at]).round(1)}s"
+    end
+  end
+
+  # SSE stream: agent pushes re-rendered content here
+  stream do |streamer|
+    $streamer_ref = streamer
+    # Timeout checker loop
+    loop do
+      sleep 1
+      SpikeState.mutex.synchronize do
+        SpikeState.instance_variable_get(:@sessions).each do |sid, s|
+          next unless s[:generate_status] == :generating && s[:started_at]
+          elapsed = Time.now.to_f - s[:started_at]
+          if elapsed > 15
+            s[:generate_status] = :timed_out
+            $stderr.puts "[Server] Session #{sid} timed out (#{elapsed.round(1)}s)"
+            Thread.new { push_rerender(sid) }
+          end
+        end
+      end
+    end
+  end
+end
+
+# ============================================================================
+# Custom routes (cancel endpoint)
+# ============================================================================
+
+SpikeApp.post '/spike/cancel' do
+  state = session[:streamlit_state] ||= {}
+  session_id = state[:spike_session]
+
+  if session_id
+    SpikeState.cancel(session_id)
+    SpikeState.update(session_id) { |s| s[:generate_status] = :idle }
+    $stderr.puts "[Server] Cancel for session #{session_id}"
+    Thread.new { push_rerender(session_id) }
+  end
+
+  redirect '/'
+end
+
+# ============================================================================
+# Start
+# ============================================================================
+
+agent_thread = start_agent_simulator
+$stderr.puts "[Spike] Agent simulator started"
+
+SpikeApp.run!