brainiac 0.0.5 → 0.0.7

data/monitor/daemon.rb

@@ -2,32 +2,13 @@
 # frozen_string_literal: true
 
 # Brainiac Monitor Daemon
-# Polls /api/status and exposes agent state via Unix socket for waybar
-# No longer triggers config updates - waybar module polls this socket directly
+# Polls /api/status and exposes agent state via Unix socket for waybar/xbar.
+# Modules (waybar/status.rb, xbar/plugin.rb) read from this socket.
 
-require "json"
-require "net/http"
-require "socket"
+require "fileutils"
+require_relative "shared"
 
-SOCKET_PATH = "/tmp/brainiac-monitor.sock"
-API_URL = "http://localhost:4567/api/status"
 POLL_INTERVAL = 2 # seconds
-CONFIG_PATH = File.expand_path("~/.brainiac/waybar.json")
-
-# Load agent configuration from JSON
-def load_agent_config
-  config = JSON.parse(File.read(CONFIG_PATH))
-  agents = {}
-  config["agents"].each do |agent|
-    agents[agent["name"]] = { color: agent["color"], emoji: agent["emoji"] }
-  end
-  agents
-rescue StandardError => e
-  warn "Failed to load waybar.json: #{e.message}"
-  {}
-end
-
-AGENTS = load_agent_config.freeze
 
 @state = { sessions: [], count: 0, recent: [], last_update: nil }
 
@@ -67,12 +48,10 @@ def start_server
   server = UNIXServer.new(SOCKET_PATH)
   File.chmod(0o666, SOCKET_PATH)
 
-  # Write PID file
   File.write("/tmp/brainiac-daemon.pid", Process.pid)
 
   puts "Monitor daemon started, socket: #{SOCKET_PATH}"
 
-  # Start polling thread
   poller = Thread.new do
     loop do
       update_state
@@ -80,10 +59,8 @@ def start_server
     end
   end
 
-  # Initial state fetch
   update_state
 
-  # Accept client connections
   loop do
     client = server.accept
     Thread.new { handle_client(client) }

data/monitor/shared.rb

@@ -0,0 +1,247 @@
+# frozen_string_literal: true
+
+# Shared helpers for all monitor scripts (waybar, xbar, daemon).
+#
+# Provides: constants, config loading, state fetching, formatting utilities.
+# Require this at the top of any monitor script.
+
+require "json"
+require "net/http"
+require "socket"
+require "uri"
+
+# --- Constants ---
+
+SOCKET_PATH = "/tmp/brainiac-monitor.sock"
+API_URL = "http://localhost:4567/api/status"
+SERVER_URL = "http://localhost:4567"
+CONFIG_PATH = File.expand_path("~/.brainiac/waybar.json")
+BRAINIAC_DIR = File.expand_path("~/.brainiac")
+
+# --- Agent Config ---
+
+# Load agent configuration from ~/.brainiac/waybar.json.
+# Returns { "galen" => { emoji: "🤖", color: "blue" }, ... }
+def load_agent_config
+  config = JSON.parse(File.read(CONFIG_PATH, encoding: "utf-8"))
+  agents = {}
+  (config["agents"] || []).each do |agent|
+    agents[agent["name"].downcase] = { emoji: agent["emoji"], color: agent["color"] }
+  end
+  agents
+rescue StandardError => e
+  warn "Failed to load waybar.json: #{e.message}"
+  {}
+end
+
+def load_monitor_config
+  return {} unless File.exist?(CONFIG_PATH)
+
+  JSON.parse(File.read(CONFIG_PATH, encoding: "utf-8"))
+rescue StandardError
+  {}
+end
+
+DEFAULT_EMOJI = "❓"
+
+# --- State Fetching ---
+
+# Fetch state from daemon socket (fast, no HTTP overhead).
+def fetch_state_from_socket
+  socket = UNIXSocket.new(SOCKET_PATH)
+  data = socket.read
+  socket.close
+  JSON.parse(data)
+end
+
+# Fetch state from brainiac HTTP API (fallback when daemon not running).
+def fetch_state_from_api
+  uri = URI(API_URL)
+  response = Net::HTTP.get_response(uri)
+  return nil unless response.is_a?(Net::HTTPSuccess)
+
+  JSON.parse(response.body)
+rescue StandardError
+  nil
+end
+
+# Fetch agent state — tries socket first, falls back to API.
+def fetch_state
+  fetch_state_from_socket
+rescue Errno::ENOENT, Errno::ECONNREFUSED
+  fetch_state_from_api || { "sessions" => [], "count" => 0, "error" => "server not reachable" }
+rescue StandardError => e
+  { "sessions" => [], "count" => 0, "error" => e.message }
+end
+
+# Fetch deployment state from API.
+def fetch_deployments
+  uri = URI("#{SERVER_URL}/api/deployments")
+  response = Net::HTTP.get_response(uri)
+  JSON.parse(response.body)["deployments"] || []
+rescue StandardError
+  nil
+end
+
+# --- Formatting ---
+
+def format_elapsed(seconds)
+  return "#{seconds}s" if seconds < 60
+
+  minutes = seconds / 60
+  return "#{minutes}m" if minutes < 60
+
+  hours = minutes / 60
+  return "#{hours}h" if hours < 24
+
+  "#{hours / 24}d"
+end
+
+def format_context(card_key)
+  return "" unless card_key
+
+  if card_key.start_with?("discord-")
+    "Discord"
+  elsif card_key.start_with?("card-")
+    "##{card_key.split("-")[1]}"
+  else
+    card_key
+  end
+end
+
+def time_ago(iso_string)
+  return nil unless iso_string
+
+  seconds = (Time.now - Time.parse(iso_string)).to_i
+  "#{format_elapsed(seconds)} ago"
+rescue StandardError
+  nil
+end
+
+# --- Log Preview ---
+
+ANSI_REGEX = /\e\[[0-9;]*[a-zA-Z]|\e\[\?[0-9;]*[a-zA-Z]/
+LOG_PREVIEW_LINES = 15
+LOG_LINE_MAX = 80
+LOG_FONT = "SFMono-Regular"
+LOG_SIZE = 12
+
+def tail_log(log_file, lines: LOG_PREVIEW_LINES)
+  return [] unless log_file && File.exist?(log_file)
+
+  raw = `tail -n 50 #{log_file.shellescape} 2>/dev/null`
+  raw.encode("UTF-8", invalid: :replace, undef: :replace, replace: "")
+     .lines
+     .map { |l| l.gsub(ANSI_REGEX, "").gsub(/[^[:print:]\t]/, "").strip }
+     .reject(&:empty?)
+     .last(lines)
+rescue StandardError
+  []
+end
+
+def format_log_line(text)
+  text.length > LOG_LINE_MAX ? "#{text[0, LOG_LINE_MAX]}…" : text
+end
+
+# --- Deploy Helpers ---
+
+DEPLOY_RECENT_WINDOW = 30 * 60 # 30 minutes
+
+def deploy_dot_emoji(dep)
+  status = dep["last_deploy_status"]
+  if status == "deploying"
+    "🟠"
+  elsif status == "failed"
+    "💥"
+  elsif dep["status"] == "occupied"
+    deploy_time = dep["last_deploy_at"] || dep["deployed_at"]
+    recent = deploy_time && (Time.now - Time.parse(deploy_time)) < DEPLOY_RECENT_WINDOW
+    recent ? "🚀" : "🔴"
+  else
+    "🟢"
+  end
+end
+
+# Resolve worktree path for a card number from card_map.json or filesystem glob.
+def resolve_worktree(card_number, glob_base: "~/Code")
+  # Try card_map.json first
+  card_map_path = File.join(BRAINIAC_DIR, "card_map.json")
+  if File.exist?(card_map_path)
+    card_map = begin
+      JSON.parse(File.read(card_map_path))
+    rescue StandardError
+      {}
+    end
+    entry = card_map.values.find { |e| e["number"].to_s == card_number.to_s }
+    return entry["worktree"] if entry && entry["worktree"] && File.directory?(entry["worktree"].to_s)
+  end
+
+  # Fallback: glob
+  matches = Dir.glob(File.expand_path("#{glob_base}/*fizzy-#{card_number}-*/"))
+  matches.find { |d| File.directory?(d) }
+end
+
+# Generate the bash deploy script with terraform lock retry logic.
+def deploy_bash_script(env_key, worktree:, aws_profile: nil)
+  <<~BASH
+    cd #{worktree.shellescape}
+    #{"export AWS_PROFILE=#{aws_profile.shellescape}" if aws_profile}
+    echo "🚀 Deploying to #{env_key}..."
+    echo
+    logfile=$(mktemp)
+    ./scripts/deploy.sh #{env_key.shellescape} 2>&1 | tee "$logfile"
+    status=${PIPESTATUS[0]}
+    if [ $status -ne 0 ] && grep -q "checksums previously recorded in the dependency lock file" "$logfile"; then
+      echo
+      echo "⚠️  Terraform lock file mismatch — removing lock and running init -upgrade..."
+      echo
+      rm -f infrastructure/#{env_key.shellescape}/.terraform.lock.hcl
+      (cd infrastructure/#{env_key.shellescape} && terraform init -upgrade)
+      echo
+      echo "🔄 Retrying deploy..."
+      echo
+      ./scripts/deploy.sh #{env_key.shellescape} 2>&1
+      status=$?
+    fi
+    rm -f "$logfile"
+    echo
+    if [ $status -eq 0 ]; then echo "✅ Deploy complete"; else echo "❌ Deploy failed (exit $status)"; fi
+    echo "Press Enter to close..."
+    read
+  BASH
+end
+
+# Mark an environment as deploying via the brainiac API.
+def mark_deploying_via_api(env_key, worktree:)
+  uri = URI("#{SERVER_URL}/api/deployments/#{env_key}/deploying")
+  req = Net::HTTP::Post.new(uri, "Content-Type" => "application/json")
+  req.body = { worktree: worktree }.to_json
+  Net::HTTP.start(uri.hostname, uri.port) { |http| http.request(req) }
+rescue StandardError
+  # Non-fatal — deploy proceeds even if server is unreachable
+end
+
+# Resolve AWS_PROFILE from deployments.json for an environment.
+def resolve_aws_profile(env_key)
+  config_file = File.join(BRAINIAC_DIR, "deployments.json")
+  return nil unless File.exist?(config_file)
+
+  cfg = begin
+    JSON.parse(File.read(config_file))
+  rescue StandardError
+    {}
+  end
+  cfg.dig("environments", env_key, "aws_profile")
+end
+
+# --- Color ---
+
+COLOR_MAP = {
+  "red" => "#ff5555", "green" => "#50fa7b", "blue" => "#8be9fd",
+  "yellow" => "#f1fa8c", "cyan" => "#8be9fd", "magenta" => "#ff79c6",
+  "purple" => "#bd93f9", "pink" => "#ff79c6", "white" => "#f8f8f2"
+}.freeze
+
+def hex_color(name)
+  COLOR_MAP[name] || name
+end

data/monitor/{waybar-deploy-env.rb → waybar/deploy_env.rb}

@@ -2,18 +2,13 @@
 # frozen_string_literal: true
 
 # Brainiac Waybar Per-Environment Deploy Module
-# Usage: waybar-deploy-env.rb <env_key>
-#        waybar-deploy-env.rb <env_key> --click
-#        waybar-deploy-env.rb <env_key> --deploy
+# Usage: deploy_env.rb <env_key>
+#        deploy_env.rb <env_key> --click
+#        deploy_env.rb <env_key> --deploy
 
-require "json"
-require "net/http"
 require "shellwords"
-require "uri"
 require "time"
-
-SERVER_URL = "http://localhost:4567"
-RECENT_WINDOW = 30 * 60
+require_relative "../shared"
 
 env_key = ARGV.find { |a| !a.start_with?("--") }
 unless env_key
@@ -21,30 +16,7 @@ unless env_key
   exit
 end
 
-def fetch_deployments
-  uri = URI("#{SERVER_URL}/api/deployments")
-  response = Net::HTTP.get_response(uri)
-  JSON.parse(response.body)["deployments"] || []
-rescue StandardError
-  nil
-end
-
-def time_ago(iso_time)
-  return nil unless iso_time
-
-  seconds = (Time.now - Time.parse(iso_time)).to_i
-  return "#{seconds}s ago" if seconds < 60
-
-  minutes = seconds / 60
-  return "#{minutes}m ago" if minutes < 60
-
-  hours = minutes / 60
-  "#{hours}h ago"
-end
-
 def resize_deploy_terminal
-  # Shrink the deploy terminal to ~15% width after it tiles in at 50%
-  # Calculates resize delta from monitor width dynamically
   script = "sleep 0.5 && " \
            'width=$(hyprctl monitors -j | ruby -rjson -e "puts JSON.parse(STDIN.read)[0][%q(width)]") && ' \
            "delta=$(( (width / 2) - (width * 15 / 100) )) && " \
@@ -58,8 +30,10 @@ def handle_click(env_key, deployment)
   if deployment["last_deploy_status"] == "failed" && deployment["last_deploy_log"]
     log = deployment["last_deploy_log"]
     if File.exist?(log.to_s)
-      spawn("alacritty", "--class", "brainiac-deploy", "-e", "bash", "-c",
-            "echo '=== Deploy failure: #{deployment["label"] || env_key} ===' && echo && cat #{Shellwords.escape(log)} && echo && echo 'Press Enter to close...' && read",
+      label = deployment["label"] || env_key
+      cmd = "echo '=== Deploy failure: #{label} ===' && echo && " \
+            "cat #{Shellwords.escape(log)} && echo && echo 'Press Enter to close...' && read"
+      spawn("alacritty", "--class", "brainiac-deploy", "-e", "bash", "-c", cmd,
             %i[out err] => "/dev/null")
       resize_deploy_terminal
       return
@@ -79,63 +53,17 @@ def handle_deploy(env_key, deployment)
                                                                                                        end} 2>/dev/null`.strip
   return if card_number.empty?
 
-  matches = Dir.glob(File.expand_path("~/Code/*fizzy-#{card_number}-*/"))
-  worktree = matches.find { |d| File.directory?(d) }
+  worktree = resolve_worktree(card_number)
   unless worktree
     `timeout 10 zenity --error --text="No worktree found for card ##{card_number}" 2>/dev/null`
     return
   end
 
-  # Resolve AWS_PROFILE from deployments config
-  aws_profile = nil
-  config_file = File.expand_path("~/.brainiac/deployments.json")
-  if File.exist?(config_file)
-    cfg = begin
-      JSON.parse(File.read(config_file))
-    rescue StandardError
-      {}
-    end
-    aws_profile = cfg.dig("environments", env_key, "aws_profile")
-  end
-
-  deploy_script = <<~BASH
-    cd #{Shellwords.escape(worktree)}
-    #{"export AWS_PROFILE=#{Shellwords.escape(aws_profile)}" if aws_profile}
-    echo "🚀 #{env_key} deploy in progress..."
-    echo
-    logfile=$(mktemp)
-    ./scripts/deploy.sh #{Shellwords.escape(env_key)} 2>&1 | tee "$logfile"
-    status=${PIPESTATUS[0]}
-    if [ $status -ne 0 ] && grep -q "checksums previously recorded in the dependency lock file" "$logfile"; then
-      echo
-      echo "⚠️  Terraform lock file mismatch — removing lock and running init -upgrade..."
-      echo
-      rm -f infrastructure/#{Shellwords.escape(env_key)}/.terraform.lock.hcl
-      (cd infrastructure/#{Shellwords.escape(env_key)} && terraform init -upgrade)
-      echo
-      echo "🔄 Retrying deploy..."
-      echo
-      ./scripts/deploy.sh #{Shellwords.escape(env_key)} 2>&1
-      status=$?
-    fi
-    rm -f "$logfile"
-    echo
-    if [ $status -eq 0 ]; then echo "✅ Deploy complete"; else echo "❌ Deploy failed (exit $status)"; fi
-    echo "Press Enter to close..."
-    read
-  BASH
-
-  # Mark deploying via API so waybar turns orange immediately
-  begin
-    uri = URI("#{SERVER_URL}/api/deployments/#{env_key}/deploying")
-    req = Net::HTTP::Post.new(uri, "Content-Type" => "application/json")
-    req.body = { worktree: worktree }.to_json
-    Net::HTTP.start(uri.hostname, uri.port) { |http| http.request(req) }
-  rescue StandardError
-    # Non-fatal — deploy proceeds even if server is unreachable
-  end
+  aws_profile = resolve_aws_profile(env_key)
+  mark_deploying_via_api(env_key, worktree: worktree)
 
-  spawn("alacritty", "--class", "brainiac-deploy", "-e", "bash", "-c", deploy_script, %i[out err] => "/dev/null")
+  script = deploy_bash_script(env_key, worktree: worktree, aws_profile: aws_profile)
+  spawn("alacritty", "--class", "brainiac-deploy", "-e", "bash", "-c", script, %i[out err] => "/dev/null")
   resize_deploy_terminal
 end
 
@@ -156,7 +84,7 @@ def generate_output(env_key)
 
   if d["status"] == "occupied"
     deploy_time = d["last_deploy_at"] || d["deployed_at"]
-    recent = deploy_time && (Time.now - Time.parse(deploy_time)) < RECENT_WINDOW
+    recent = deploy_time && (Time.now - Time.parse(deploy_time)) < DEPLOY_RECENT_WINDOW
     status = d["last_deploy_status"]
 
     if status == "deploying"

data/monitor/waybar/setup.rb

@@ -0,0 +1,232 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# One-time setup: installs Brainiac modules into waybar config.
+#
+# Adds:
+#   - Agent session status module (custom/brainiac)
+#   - Per-environment deploy dots (custom/brainiac-deploy-<env>)
+#
+# Usage: ruby monitor/waybar/setup.rb
+
+require "json"
+require "fileutils"
+
+WAYBAR_CONFIG = File.expand_path("~/.config/waybar/config.jsonc")
+WAYBAR_STYLE  = File.expand_path("~/.config/waybar/style.css")
+BRAINIAC_DIR  = File.expand_path("~/.brainiac")
+DEPLOYMENTS_CONFIG = File.join(BRAINIAC_DIR, "deployments.json")
+
+# Wrapper scripts go to ~/.brainiac/bin/ and resolve from /api/status (server_root field)
+# Falls back to ~/.brainiac/server.root file for cold-start scenarios
+WRAPPER_DIR = File.join(BRAINIAC_DIR, "bin")
+FileUtils.mkdir_p(WRAPPER_DIR)
+
+def load_waybar_config
+  content = File.read(WAYBAR_CONFIG)
+  json_content = content.lines.reject { |line| line.strip.start_with?("//") }.join
+  JSON.parse(json_content)
+end
+
+def save_waybar_config(config)
+  File.write(WAYBAR_CONFIG, JSON.pretty_generate(config))
+end
+
+# --- Create wrapper scripts ---
+
+# Status wrapper
+status_wrapper = File.join(WRAPPER_DIR, "waybar-status")
+File.write(status_wrapper, <<~SCRIPT)
+  #!/usr/bin/env ruby
+  require "json"
+  require "net/http"
+  require "uri"
+
+  def resolve_server_root
+    # Primary: query the running server's /api/status endpoint
+    uri = URI("http://localhost:4567/api/status")
+    response = Net::HTTP.start(uri.hostname, uri.port, open_timeout: 1, read_timeout: 2) { |http| http.get(uri.path) }
+    if response.is_a?(Net::HTTPSuccess)
+      data = JSON.parse(response.body)
+      root = data["server_root"]
+      return root if root && File.directory?(root)
+    end
+    # Fallback: read the file (cold-start or server returned no root)
+    root_file = File.expand_path("~/.brainiac/server.root")
+    File.read(root_file).strip if File.exist?(root_file)
+  rescue StandardError
+    # Fallback: read the file (server unreachable)
+    root_file = File.expand_path("~/.brainiac/server.root")
+    File.exist?(root_file) ? File.read(root_file).strip : nil
+  end
+
+  server_root = resolve_server_root
+  if server_root
+    script = File.join(server_root, "monitor", "waybar", "status.rb")
+    if File.exist?(script)
+      load script
+      exit
+    end
+  end
+  puts({ text: "⚠️", tooltip: "Brainiac server root not found", class: "error" }.to_json)
+SCRIPT
+File.chmod(0o755, status_wrapper)
+
+# Log viewer wrapper
+logs_wrapper = File.join(WRAPPER_DIR, "waybar-logs")
+File.write(logs_wrapper, <<~SCRIPT)
+  #!/usr/bin/env ruby
+  require "json"
+  require "net/http"
+  require "uri"
+
+  def resolve_server_root
+    uri = URI("http://localhost:4567/api/status")
+    response = Net::HTTP.start(uri.hostname, uri.port, open_timeout: 1, read_timeout: 2) { |http| http.get(uri.path) }
+    if response.is_a?(Net::HTTPSuccess)
+      data = JSON.parse(response.body)
+      root = data["server_root"]
+      return root if root && File.directory?(root)
+    end
+    root_file = File.expand_path("~/.brainiac/server.root")
+    File.read(root_file).strip if File.exist?(root_file)
+  rescue StandardError
+    root_file = File.expand_path("~/.brainiac/server.root")
+    File.exist?(root_file) ? File.read(root_file).strip : nil
+  end
+
+  server_root = resolve_server_root
+  if server_root
+    script = File.join(server_root, "monitor", "waybar", "view_logs.rb")
+    exec("ruby", script) if File.exist?(script)
+  end
+  warn "Brainiac server root not found"
+SCRIPT
+File.chmod(0o755, logs_wrapper)
+
+# Deploy env wrapper
+deploy_wrapper = File.join(WRAPPER_DIR, "waybar-deploy-env")
+File.write(deploy_wrapper, <<~SCRIPT)
+  #!/usr/bin/env ruby
+  require "json"
+  require "net/http"
+  require "uri"
+
+  def resolve_server_root
+    uri = URI("http://localhost:4567/api/status")
+    response = Net::HTTP.start(uri.hostname, uri.port, open_timeout: 1, read_timeout: 2) { |http| http.get(uri.path) }
+    if response.is_a?(Net::HTTPSuccess)
+      data = JSON.parse(response.body)
+      root = data["server_root"]
+      return root if root && File.directory?(root)
+    end
+    root_file = File.expand_path("~/.brainiac/server.root")
+    File.read(root_file).strip if File.exist?(root_file)
+  rescue StandardError
+    root_file = File.expand_path("~/.brainiac/server.root")
+    File.exist?(root_file) ? File.read(root_file).strip : nil
+  end
+
+  server_root = resolve_server_root
+  if server_root
+    script = File.join(server_root, "monitor", "waybar", "deploy_env.rb")
+    if File.exist?(script)
+      load script
+      exit
+    end
+  end
+  puts({ text: "", tooltip: "Brainiac server root not found", class: "error" }.to_json)
+SCRIPT
+File.chmod(0o755, deploy_wrapper)
+
+puts "✓ Created wrapper scripts in #{WRAPPER_DIR}"
+
+# --- Update waybar config ---
+
+config = load_waybar_config
+
+# Clean up old brainiac modules from all positions
+%w[modules-left modules-center modules-right].each do |pos|
+  next unless config[pos]
+
+  config[pos].reject! { |m| m.to_s.include?("brainiac") }
+end
+config.each_key { |key| config.delete(key) if key.to_s.include?("brainiac") }
+
+# Add agent session module to modules-center
+config["modules-center"] ||= []
+config["modules-center"] << "custom/brainiac"
+
+config["custom/brainiac"] = {
+  "exec" => status_wrapper,
+  "return-type" => "json",
+  "interval" => 3,
+  "format" => "{}",
+  "tooltip" => true,
+  "on-click" => logs_wrapper
+}
+
+# Add per-environment deploy modules (if deployments.json exists)
+if File.exist?(DEPLOYMENTS_CONFIG)
+  deployments = JSON.parse(File.read(DEPLOYMENTS_CONFIG))
+  envs = (deployments["environments"] || {}).keys
+
+  center = config["modules-center"]
+  brainiac_idx = center.index("custom/brainiac") || center.length
+
+  envs.each_with_index do |env, i|
+    mod_name = "custom/brainiac-deploy-#{env}"
+    center.insert(brainiac_idx + i, mod_name)
+
+    config[mod_name] = {
+      "exec" => "#{deploy_wrapper} #{env}",
+      "return-type" => "json",
+      "interval" => 30,
+      "format" => "{}",
+      "tooltip" => true,
+      "escape" => false,
+      "on-click" => "#{deploy_wrapper} #{env} --click",
+      "on-click-right" => "#{deploy_wrapper} #{env} --deploy"
+    }
+  end
+
+  puts "✓ Added #{envs.size} deploy environment module(s): #{envs.join(", ")}"
+end
+
+save_waybar_config(config)
+puts "✓ Updated waybar config at #{WAYBAR_CONFIG}"
+
+# --- Update CSS ---
+
+style = File.exist?(WAYBAR_STYLE) ? File.read(WAYBAR_STYLE) : ""
+
+unless style.include?("#custom-brainiac")
+  css = <<~CSS
+
+    /* Brainiac agent session module */
+    #custom-brainiac {
+      padding-right: 100px;
+    }
+
+    /* Brainiac per-environment deploy dots */
+    [id^="custom-brainiac-deploy-"] {
+      font-size: 28px;
+      padding: 0 6px;
+      border-radius: 8px;
+      border: 2px solid transparent;
+    }
+
+    [id^="custom-brainiac-deploy-"].deploy-recent {
+      border: 2px solid #4488ff;
+    }
+
+    [id^="custom-brainiac-deploy-"].deploy-failed {
+      border: 2px solid #ff4444;
+    }
+  CSS
+  File.write(WAYBAR_STYLE, "#{style.strip}\n#{css}")
+  puts "✓ Added brainiac styles to #{WAYBAR_STYLE}"
+end
+
+puts ""
+puts "Restart waybar to apply: omarchy restart waybar"