brainiac 0.0.17 → 0.0.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: faf9d51fb98a0185bdf17224d0adc4539ec4b0584194ad4c67248f6092fd97a4
-  data.tar.gz: 15ad522a423295771f9f55847b2a07ea207f28709dab653896dd233f5888b8fd
+  metadata.gz: 3a5e88ff667021341d3ff4bd4da63212b3918b8c210d276c3c9d0f00ff97e121
+  data.tar.gz: ba02b2ab6f6e0e519ef00887da6f53fb6be2dd234fb8db30bc5bc7c9896433b5
 SHA512:
-  metadata.gz: 0c02497473d20acb2e64150a502cae30bad9e031da305be68655ee1b3f9854a99d734c93e887c2474927e7a63f85836c254cd1b14d5208778635c6940171be99
-  data.tar.gz: 118a28a54a16e21cf20f0199ed36dace15e82dbae60d9cab2c090a22241fa6eb7a7a5d2dee53763b37a13d43e9e9a3855d60cc8868ecd30fa95a6fe045fdad0c
+  metadata.gz: 013f765fe110ad69fa3522ba45d46f3200f8f34bad4da62cc3df78b751246d52056b226005ecfce2cda99fbfb77e82230c1e6b679a5525d49b471770776c3249
+  data.tar.gz: b206d36e38e5fd284a8e276109e1a5656986f954f87e393cefa7ef77a0b1f0226b96fc50c80027e00ac66e60dc64107560fbe64d77d3a84198adb673cd1ca50c

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    brainiac (0.0.17)
+    brainiac (0.0.18)
       puma (~> 7.2)
       rackup (~> 2.3)
       sinatra (~> 4.1)
@@ -84,7 +84,7 @@ DEPENDENCIES
 CHECKSUMS
   ast (2.4.3) sha256=954615157c1d6a382bc27d690d973195e79db7f55e9765ac7c481c60bdb4d383
   base64 (0.3.0) sha256=27337aeabad6ffae05c265c450490628ef3ebd4b67be58257393227588f5a97b
-  brainiac (0.0.17)
+  brainiac (0.0.18)
   json (2.19.9) sha256=9b9025b7cdddafa38d316eca0b2358488e42d417045c1b90d216a9fefe46b79a
   language_server-protocol (3.17.0.5) sha256=fd1e39a51a28bf3eec959379985a72e296e9f9acfce46f6a79d31ca8760803cc
   lint_roller (1.1.0) sha256=2c0c845b632a7d172cb849cc90c1bce937a28c5c8ccccb50dfd46a485003cc87

data/bin/brainiac

@@ -1162,7 +1162,7 @@ when "config"
 
   configure_server(options)
 
-when "server", "s"
+when "server", "s", "start"
   OptionParser.new do |opts|
     opts.banner = "Usage: brainiac server [options]"
     opts.on("-d", "--daemon", "Run server in background (detached)")
@@ -3138,6 +3138,7 @@ when "help", "--help", "-h", nil
       Usage:
         brainiac setup                  Bootstrap a new machine (deps, dirs, configs)
         brainiac server [options]       Start the Brainiac webhook server (foreground)
+        brainiac start [options]        Alias for 'brainiac server'
         brainiac stop                   Stop the running server
         brainiac restart                Restart the server
         brainiac logs                   Tail the server log
@@ -3217,6 +3218,7 @@ when "help", "--help", "-h", nil
       Examples:
         # Start the server in the foreground (like rails server)
         brainiac server
+        brainiac start
         brainiac s
       #{"  "}
         # Register current directory

data/bin/brainiac-completion.bash

@@ -9,7 +9,7 @@ _brainiac() {
   local brainiac_dir="${BRAINIAC_DIR:-$HOME/.brainiac}"
 
   # Top-level commands (built-in + installed plugins)
-  local commands="server stop restart logs status register unregister list show brain cron provider role agent config path version help setup projects card-map handler plugin install uninstall plugins"
+  local commands="server start stop restart logs status register unregister list show brain cron provider role agent config path version help setup projects card-map handler plugin install uninstall plugins"
 
   # Add installed plugin names as top-level commands
   if [[ -f "$brainiac_dir/plugins.json" ]]; then

data/lib/brainiac/helpers.rb

@@ -254,6 +254,93 @@ def register_work_item(branch:, worktree: nil, project: nil, agent: nil, source:
   work_item_id
 end
 
+# Update dispatch overrides on a work item (cli_provider, model, effort).
+# Only non-nil values are stored; nil values are removed from existing overrides.
+# Returns true if the work item was found and updated, false otherwise.
+def update_work_item_overrides(cli_provider: nil, model: nil, effort: nil, work_item_id: nil, branch: nil) # rubocop:disable Naming/PredicateMethod
+  map = load_work_item_map
+
+  target_id = work_item_id
+  unless target_id
+    map.each do |wid, info|
+      if info.is_a?(Hash) && info["branch"] == branch
+        target_id = wid
+        break
+      end
+    end
+  end
+
+  return false unless target_id && map[target_id]
+
+  overrides = map[target_id]["overrides"] || {}
+  overrides["cli_provider"] = cli_provider if cli_provider
+  overrides["model"] = model if model
+  overrides["effort"] = effort if effort
+  overrides.compact!
+
+  if overrides.empty?
+    map[target_id].delete("overrides")
+  else
+    map[target_id]["overrides"] = overrides
+  end
+
+  save_work_item_map(map)
+  LOG.info "[WorkItem] Updated overrides for #{target_id}: #{overrides}" unless overrides.empty?
+  true
+end
+
+# Retrieve dispatch overrides for a work item.
+# Returns a hash (may be empty) with keys like "cli_provider", "model", "effort".
+def work_item_overrides_for(work_item_id: nil, branch: nil)
+  map = load_work_item_map
+
+  target_id = work_item_id
+  unless target_id
+    map.each do |wid, info|
+      if info.is_a?(Hash) && info["branch"] == branch
+        target_id = wid
+        break
+      end
+    end
+  end
+
+  return {} unless target_id && map[target_id]
+
+  map[target_id]["overrides"] || {}
+end
+
+# Resolve dispatch overrides for a work item, merging stored overrides with
+# inline tags from the current message. Inline tags take priority and are
+# persisted for future dispatches.
+#
+# Parameters:
+#   work_item_id: or branch: — identifies the work item
+#   inline_cli_provider: — [cli:X] from current message (nil if not specified)
+#   inline_model: — resolved model from current message (nil if not specified)
+#   inline_effort: — [effort:X] from current message (nil if not specified)
+#
+# Returns: { cli_provider: String|nil, model: String|nil, effort: String|nil }
+def resolve_work_item_overrides(work_item_id: nil, branch: nil, inline_cli_provider: nil, inline_model: nil, inline_effort: nil)
+  stored = work_item_overrides_for(work_item_id: work_item_id, branch: branch)
+
+  # Inline tags override stored values
+  resolved = {
+    cli_provider: inline_cli_provider || stored["cli_provider"],
+    model: inline_model || stored["model"],
+    effort: inline_effort || stored["effort"]
+  }
+
+  # Persist any new inline overrides to the work item for future dispatches
+  new_overrides = {}
+  new_overrides[:cli_provider] = inline_cli_provider if inline_cli_provider
+  new_overrides[:model] = inline_model if inline_model
+  new_overrides[:effort] = inline_effort if inline_effort
+
+  update_work_item_overrides(work_item_id: work_item_id, branch: branch, **new_overrides) if new_overrides.any? && (work_item_id || branch)
+
+  resolved
+end
+
 # Add or update a source on an existing work item.
 # Returns true if the work item was found and updated, false otherwise.
 def register_work_item_source(source:, source_data:, work_item_id: nil, branch: nil) # rubocop:disable Naming/PredicateMethod

data/lib/brainiac/prompts.rb

@@ -227,7 +227,8 @@ end
 # Lean prompt for resumed sessions. The previous session already has the full context
 # (role, persona, knowledge, core instructions, channel prompts). We only send the new
 # comment and any fresh card context so the agent knows what changed.
-def render_resume_prompt(comment_body:, comment_creator:, comment_id:, card_number: nil, agent_name: AI_AGENT_NAME)
+def render_resume_prompt(comment_body:, comment_creator:, comment_id:, card_number: nil, agent_name: AI_AGENT_NAME,
+                         response_destination: nil)
   # Touch memory file (same as render_prompt does)
   memory_dir = memory_dir_for(agent_name)
   card_id = card_number || "unknown"
@@ -247,6 +248,10 @@ def render_resume_prompt(comment_body:, comment_creator:, comment_id:, card_numb
   lines << ""
   lines << "---"
   lines << "Respond to this comment. All your previous instructions still apply."
+  if response_destination
+    lines << ""
+    lines << "**Response destination: #{response_destination}**"
+  end
 
   lines.join("\n")
 end

data/lib/brainiac/routes/api.rb

@@ -25,6 +25,7 @@ def format_active_sessions
       started_at: info[:started_at].iso8601,
       elapsed_seconds: (Time.now - info[:started_at]).to_i,
       log_file: info[:log_file], alive: true,
+      channel_id: info[:channel_id],
       children: child_processes_for(info[:pid])
     }
   end

data/lib/brainiac/version.rb

@@ -2,5 +2,5 @@
 
 module Brainiac
   # @return [String] the current gem version
-  VERSION = "0.0.17"
+  VERSION = "0.0.18"
 end

data/monitor/waybar/session_slot.rb

@@ -0,0 +1,242 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Brainiac Waybar Per-Session Module
+# Each instance represents one session slot.
+#
+# Usage: session_slot.rb <index>              → JSON output for waybar
+#        session_slot.rb <index> --tail       → Left-click: tail the log
+#        session_slot.rb <index> --manage     → Right-click: kill menu
+#        session_slot.rb <index> --thread     → Middle-click: open Discord thread
+
+require "shellwords"
+require "time"
+require_relative "../shared"
+
+AGENTS = load_agent_config.freeze
+INFRA_CMDS = %w[kiro-cli-chat ruby-lsp clangd gopls].freeze
+DISCORD_CONFIG_FILE = File.join(BRAINIAC_DIR, "discord.json")
+
+index = ARGV.find { |a| !a.start_with?("--") }&.to_i
+unless index
+  puts({ text: "", tooltip: "", class: "" }.to_json)
+  exit
+end
+
+def load_discord_guild_id
+  return nil unless File.exist?(DISCORD_CONFIG_FILE)
+
+  config = JSON.parse(File.read(DISCORD_CONFIG_FILE))
+  config["guild_id"]
+rescue JSON::ParserError
+  nil
+end
+
+def escape_pango(str)
+  str.gsub("&", "&amp;").gsub("<", "&lt;").gsub(">", "&gt;")
+end
+
+def find_terminal
+  %w[alacritty kitty gnome-terminal xterm].find { |t| system("which #{t} > /dev/null 2>&1") }
+end
+
+def open_log(log_file)
+  return unless log_file && File.exist?(log_file)
+
+  terminal = find_terminal
+  case terminal
+  when "alacritty"
+    spawn("alacritty", "-e", "tail", "-f", log_file, %i[out err] => "/dev/null")
+  when "kitty"
+    spawn("kitty", "tail", "-f", log_file, %i[out err] => "/dev/null")
+  when "gnome-terminal"
+    spawn("gnome-terminal", "--", "tail", "-f", log_file, %i[out err] => "/dev/null")
+  else
+    spawn("xterm", "-e", "tail", "-f", log_file, %i[out err] => "/dev/null")
+  end
+end
+
+def handle_tail(session)
+  return unless session
+
+  open_log(session["log_file"])
+end
+
+def handle_manage(session)
+  return unless session
+
+  entries = []
+  agent = session["agent"]
+  elapsed = format_elapsed(session["elapsed_seconds"] || 0)
+  context = format_context(session["card_key"])
+  emoji = AGENTS.dig(agent&.downcase, :emoji) || DEFAULT_EMOJI
+
+  entries << { display: "#{emoji} #{agent}: #{context} (#{elapsed})", type: :log, log: session["log_file"] }
+  entries << { display: "   ⛔ Kill session", type: :kill_session, card_key: session["card_key"], agent: agent }
+
+  (session["children"] || []).each do |c|
+    cmd_short = c["cmd"].to_s.split("/").last.to_s.split.first.to_s
+    cmd_short = c["cmd"].to_s[0..40] if cmd_short.empty?
+    next if INFRA_CMDS.any? { |ic| cmd_short.start_with?(ic) }
+
+    entries << {
+      display: "   └ 🔪 Kill: #{cmd_short} (#{format_elapsed(c["elapsed_seconds"])}) [PID #{c["pid"]}]",
+      type: :kill_child, pid: c["pid"], cmd: cmd_short
+    }
+  end
+
+  launcher = %w[rofi fuzzel wofi zenity fzf].find { |cmd| system("which #{cmd} > /dev/null 2>&1") }
+  unless launcher
+    system("notify-send", "Brainiac", "No menu launcher found")
+    return
+  end
+
+  menu_text = entries.map { |e| e[:display] }.join("\n")
+  selected_line = case launcher
+                  when "rofi"
+                    IO.popen(%w[rofi -dmenu -i -p] + ["Manage"], "r+") do |io|
+                      io.puts menu_text
+                      io.close_write
+                      io.read.strip
+                    end
+                  when "fuzzel"
+                    IO.popen(%w[fuzzel --dmenu --prompt] + ["Manage: "], "r+") do |io|
+                      io.puts menu_text
+                      io.close_write
+                      io.read.strip
+                    end
+                  when "wofi"
+                    IO.popen(%w[wofi --dmenu --prompt] + ["Manage"], "r+") do |io|
+                      io.puts menu_text
+                      io.close_write
+                      io.read.strip
+                    end
+                  when "zenity"
+                    IO.popen(["zenity", "--list", "--title", "Manage", "--column", "Action", "--width", "500", "--height", "300"], "r+",
+                             err: "/dev/null") do |io|
+                      entries.each { |e| io.puts e[:display] }
+                      io.close_write
+                      io.read.strip
+                    end
+                  when "fzf"
+                    `echo "#{menu_text}" | fzf --prompt="Manage: "`.strip
+                  end
+
+  return if selected_line.to_s.empty?
+
+  selected = entries.find { |e| e[:display].strip == selected_line.strip }
+  return unless selected
+
+  case selected[:type]
+  when :log
+    open_log(selected[:log])
+  when :kill_session
+    uri = URI("#{SERVER_URL}/api/sessions/kill/#{selected[:card_key]}")
+    Net::HTTP.post(uri, "", { "Content-Type" => "application/json" })
+    system("notify-send", "Brainiac", "Killed session: #{selected[:agent]}")
+  when :kill_child
+    begin
+      Process.kill("TERM", selected[:pid])
+    rescue StandardError
+      nil
+    end
+    Thread.new do
+      sleep 3
+      begin
+        Process.kill("KILL", selected[:pid])
+      rescue StandardError
+        nil
+      end
+    end
+    system("notify-send", "Brainiac", "Killed #{selected[:cmd]} (PID #{selected[:pid]})")
+  end
+end
+
+def handle_thread(session)
+  return unless session
+
+  guild_id = load_discord_guild_id
+  unless guild_id
+    system("notify-send", "Brainiac", "No guild_id in discord.json")
+    return
+  end
+
+  unless session["card_key"].to_s.start_with?("discord-")
+    system("notify-send", "Brainiac", "Not a Discord session (#{session["agent"]})")
+    return
+  end
+
+  thread_id = session["channel_id"]
+  unless thread_id
+    # Fallback: parse from card_key
+    parts = session["card_key"].to_s.split("-")
+    numeric_parts = parts.grep(/\A\d{15,}\z/)
+    thread_id = numeric_parts.first
+  end
+
+  unless thread_id
+    system("notify-send", "Brainiac", "Cannot determine thread ID")
+    return
+  end
+
+  url = "https://discord.com/channels/#{guild_id}/#{thread_id}"
+  spawn("xdg-open", url, %i[out err] => "/dev/null")
+end
+
+def generate_output(index)
+  state = fetch_state
+
+  if state["error"]
+    puts({ text: "", tooltip: "", class: "" }.to_json) if index.positive?
+    puts({ text: "⚠️", tooltip: "Brainiac Error: #{escape_pango(state["error"])}", class: "error" }.to_json) if index.zero?
+    return
+  end
+
+  sessions = state["sessions"] || []
+
+  if index.zero? && sessions.empty?
+    puts({ text: "💤", tooltip: "No active agent sessions", class: "idle" }.to_json)
+    return
+  end
+
+  session = sessions[index]
+  unless session
+    puts({ text: "", tooltip: "", class: "" }.to_json)
+    return
+  end
+
+  agent = session["agent"]
+  emoji = AGENTS.dig(agent&.downcase, :emoji) || DEFAULT_EMOJI
+  elapsed = format_elapsed(session["elapsed_seconds"] || 0)
+  context = format_context(session["card_key"])
+
+  tooltip_lines = ["#{emoji} #{agent}: #{context} (#{elapsed})"]
+
+  (session["children"] || []).each do |c|
+    cmd_short = c["cmd"].to_s.split("/").last.to_s.split.first.to_s
+    cmd_short = c["cmd"].to_s[0..40] if cmd_short.empty?
+    next if INFRA_CMDS.any? { |ic| cmd_short.start_with?(ic) }
+
+    tooltip_lines << "   └ #{escape_pango(cmd_short)} (#{format_elapsed(c["elapsed_seconds"])}) [PID #{c["pid"]}]"
+  end
+
+  tooltip_lines << "\nL-click: tail log | R-click: manage | M-click: open thread"
+
+  puts({ text: emoji, tooltip: tooltip_lines.join("\n"), class: "working" }.to_json)
+end
+
+# --- Main ---
+
+state = fetch_state
+sessions = state["sessions"] || []
+session = sessions[index]
+
+if ARGV.include?("--tail")
+  handle_tail(session)
+elsif ARGV.include?("--manage")
+  handle_manage(session)
+elsif ARGV.include?("--thread")
+  handle_thread(session)
+else
+  generate_output(index)
+end

data/monitor/waybar/setup.rb

@@ -4,7 +4,7 @@
 # One-time setup: installs Brainiac modules into waybar config.
 #
 # Adds:
-#   - Agent session status module (custom/brainiac)
+#   - Per-session slot modules (custom/brainiac-session-0 through N)
 #   - Per-environment deploy dots (custom/brainiac-deploy-<env>)
 #
 # Usage: ruby monitor/waybar/setup.rb
@@ -16,12 +16,20 @@ 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")
+WAYBAR_JSON = File.join(BRAINIAC_DIR, "waybar.json")
+
+# Max concurrent agent sessions to show (each gets its own clickable module)
+MAX_SESSION_SLOTS = 8
 
 # 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
+# Falls back to the repo path where setup.rb was run from (handles gem version mismatch)
 WRAPPER_DIR = File.join(BRAINIAC_DIR, "bin")
 FileUtils.mkdir_p(WRAPPER_DIR)
 
+# The directory where this setup script lives — used as fallback when the server_root
+# (gem install) doesn't have newer files yet
+SETUP_SOURCE_ROOT = File.expand_path("../..", __dir__)
+
 def load_waybar_config
   content = File.read(WAYBAR_CONFIG)
   json_content = content.lines.reject { |line| line.strip.start_with?("//") }.join
@@ -32,18 +40,15 @@ 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
+# Shared resolver code used by all wrapper scripts
+RESOLVER_CODE = <<~RUBY
   require "json"
   require "net/http"
   require "uri"
 
+  SETUP_SOURCE_ROOT = "#{SETUP_SOURCE_ROOT}"
+
   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)
@@ -51,56 +56,48 @@ File.write(status_wrapper, <<~SCRIPT)
       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
+  def find_script(relative_path)
+    # Try server_root first (gem install or running server's source)
+    root = resolve_server_root
+    if root
+      script = File.join(root, relative_path)
+      return script if File.exist?(script)
     end
+    # Fallback: the repo where setup.rb was run from
+    fallback = File.join(SETUP_SOURCE_ROOT, relative_path)
+    return fallback if File.exist?(fallback)
+    nil
   end
-  puts({ text: "⚠️", tooltip: "Brainiac server root not found", class: "error" }.to_json)
+RUBY
+
+# --- Create wrapper scripts ---
+
+# Session slot wrapper (handles all session interactions)
+session_slot_wrapper = File.join(WRAPPER_DIR, "waybar-session-slot")
+File.write(session_slot_wrapper, <<~SCRIPT)
+  #!/usr/bin/env ruby
+  #{RESOLVER_CODE}
+  script = find_script("monitor/waybar/session_slot.rb")
+  exec("ruby", script, *ARGV) if script
+  puts({ text: "", tooltip: "", class: "" }.to_json) unless ARGV.any? { |a| a.start_with?("--") }
 SCRIPT
-File.chmod(0o755, status_wrapper)
+File.chmod(0o755, session_slot_wrapper)
 
-# Log viewer wrapper
+# Log viewer wrapper (legacy — still available for global manage-all)
 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"
+  #{RESOLVER_CODE}
+  script = find_script("monitor/waybar/view_logs.rb")
+  exec("ruby", script) if script
+  warn "Brainiac: view_logs.rb not found"
 SCRIPT
 File.chmod(0o755, logs_wrapper)
 
@@ -108,39 +105,30 @@ File.chmod(0o755, logs_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
+  #{RESOLVER_CODE}
+  script = find_script("monitor/waybar/deploy_env.rb")
+  if script
+    load script
+    exit
   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)
+  puts({ text: "", tooltip: "Brainiac: deploy_env.rb not found", class: "error" }.to_json)
 SCRIPT
 File.chmod(0o755, deploy_wrapper)
 
 puts "✓ Created wrapper scripts in #{WRAPPER_DIR}"
 
+# --- Determine session slot count ---
+
+session_slots = MAX_SESSION_SLOTS
+if File.exist?(WAYBAR_JSON)
+  waybar_cfg = begin
+    JSON.parse(File.read(WAYBAR_JSON))
+  rescue StandardError
+    {}
+  end
+  session_slots = waybar_cfg["max_session_slots"] if waybar_cfg["max_session_slots"]
+end
+
 # --- Update waybar config ---
 
 config = load_waybar_config
@@ -153,18 +141,26 @@ config = load_waybar_config
 end
 config.each_key { |key| config.delete(key) if key.to_s.include?("brainiac") }
 
-# Add agent session module to modules-center
+# Add per-session slot modules 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
-}
+session_slots.times do |i|
+  mod_name = "custom/brainiac-session-#{i}"
+  config["modules-center"] << mod_name
+
+  config[mod_name] = {
+    "exec" => "#{session_slot_wrapper} #{i}",
+    "return-type" => "json",
+    "interval" => 3,
+    "format" => "{}",
+    "tooltip" => true,
+    "on-click" => "#{session_slot_wrapper} #{i} --tail",
+    "on-click-right" => "#{session_slot_wrapper} #{i} --manage",
+    "on-click-middle" => "#{session_slot_wrapper} #{i} --thread"
+  }
+end
+
+puts "✓ Added #{session_slots} session slot module(s)"
 
 # Add per-environment deploy modules (if deployments.json exists)
 if File.exist?(DEPLOYMENTS_CONFIG)
@@ -172,11 +168,12 @@ if File.exist?(DEPLOYMENTS_CONFIG)
   envs = (deployments["environments"] || {}).keys
 
   center = config["modules-center"]
-  brainiac_idx = center.index("custom/brainiac") || center.length
+  # Insert deploys after the session slots
+  insert_idx = center.rindex { |m| m.to_s.include?("brainiac-session") }&.+(1) || center.length
 
   envs.each_with_index do |env, i|
     mod_name = "custom/brainiac-deploy-#{env}"
-    center.insert(brainiac_idx + i, mod_name)
+    center.insert(insert_idx + i, mod_name)
 
     config[mod_name] = {
       "exec" => "#{deploy_wrapper} #{env}",
@@ -200,12 +197,15 @@ puts "✓ Updated waybar config at #{WAYBAR_CONFIG}"
 
 style = File.exist?(WAYBAR_STYLE) ? File.read(WAYBAR_STYLE) : ""
 
-unless style.include?("#custom-brainiac")
+unless style.include?("brainiac-session")
+  # Remove old single-module style if present
+  style = style.gsub(/\/\* Brainiac agent session module \*\/\n#custom-brainiac \{[^}]*\}\n?/, "")
+
   css = <<~CSS
 
-    /* Brainiac agent session module */
-    #custom-brainiac {
-      padding-right: 100px;
+    /* Brainiac per-session slot modules */
+    [id^="custom-brainiac-session-"] {
+      padding: 0 2px;
     }
 
     /* Brainiac per-environment deploy dots */

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: brainiac
 version: !ruby/object:Gem::Version
-  version: 0.0.17
+  version: 0.0.18
 platform: ruby
 authors:
 - Andy Davis
@@ -146,6 +146,7 @@ files:
 - monitor/daemon.rb
 - monitor/shared.rb
 - monitor/waybar/deploy_env.rb
+- monitor/waybar/session_slot.rb
 - monitor/waybar/setup.rb
 - monitor/waybar/status.rb
 - monitor/waybar/view_logs.rb