brainiac-discord 0.0.16 → 0.0.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: afab8518a3314e7873e2bec99ba79f7efeedf1b45b80be5ccc9d0654d0b64b77
-  data.tar.gz: a39348b184343d375313e1ca30e746165690562a729bac532e9880af4a9b540c
+  metadata.gz: 81f74969c95690e118d85fe590b2e2d35b39609937e807afaa2865ac58c8846d
+  data.tar.gz: cde31da7b3a0b2a4b84bff28b4b1e2fa99fe6ba7e7e8e372b572b1d0ea085c5c
 SHA512:
-  metadata.gz: aecb0bff2e82096ba8ec67c7a862a9316025030fa999d87c323f023a95ab463807c0dcf1eac5b7055b1d6307f346acf80fd08ae0805bf21c7e248fc29e3f35b5
-  data.tar.gz: aeb1f966c703cbf553d50535dcf6768ef1af4fc38443c47b0e0d4544dd11c42d5cf31049ccc86a7a8d6efdfd7e256e9f02c898cac9792ebc82732c243ba4692b
+  metadata.gz: 397af906d3f427dab7723fe20d3cc25840a35e109e4e054f9cf9689337cbcc8ccc376e0b14403d5dd38ede9fc25b3b2e2efa368371dae012b14c6dd5e9f0aa03
+  data.tar.gz: 8201ec6515468a4ed1a1f4e63ecc8bdf66c57e333a096c00c216559bb4a1466443928ea6c35542efdd77f80bea0c80a2555916cf053ffff41e6e721f329029ba

data/lib/brainiac/plugins/discord/api.rb

@@ -16,7 +16,10 @@ module Brainiac
         DISCORD_API_BASE = "https://discord.com/api/v10"
 
         # Emojis reserved for brainiac functionality — not treated as feedback
-        RESERVED_EMOJIS = %w[👀 ❌ 🛑 🚫 ⚠️ ⏳ 😶 ❔ ❓ 🧠].freeze
+        RESERVED_EMOJIS = %w[👀 ❌ 🛑 🚫 ⚠️ ⏳ 😶 ❔ ❓ 🧠 🌿 🪾 🍴 🍽️].freeze
+
+        # All emojis that trigger conversation forking
+        FORK_EMOJIS = %w[🌿 🪾 🍴 🍽️].freeze
 
         class << self
           def request(method, path, token:, body: nil, log_errors: true)

data/lib/brainiac/plugins/discord/branching.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+module Brainiac
+  module Plugins
+    module Discord
+      # Conversation branching — fork a conversation into a new thread.
+      #
+      # Supports two triggers:
+      # - Fork emoji reactions (🌿, 🪾, 🍴, 🍽️) on any message → creates thread from that message
+      # - [fork] or [fork:topic] inline tag → creates thread from the tagged message
+      #
+      # Branched threads start "unbound" — no worktree, no project lock-in.
+      # The agent can discuss, search brain, and read files across any registered project.
+      # When implementation work is requested, the worktree is created at that point.
+      #
+      # Threading limitations:
+      # - You can create a thread from a message in a regular text channel
+      # - You CANNOT create a thread from a message inside an existing thread
+      # - When the source message is in a thread, we create a standalone thread in the parent channel
+      module Branching
+        class << self
+          # Fork a conversation from a message into a new thread.
+          #
+          # @param source_channel_id [String] The channel where the source message lives
+          # @param source_message_id [String] The message to branch from
+          # @param source_message [Hash, nil] The source message object (avoids re-fetch if already have it)
+          # @param source_is_thread [Boolean] Whether the source channel is a thread
+          # @param parent_channel_id [String] The parent text channel (same as source if not in a thread)
+          # @param topic [String, nil] Optional thread title (defaults to message content snippet)
+          # @param agent_key [String] The agent handling this branch
+          # @param agent_name [String] Display name of the agent
+          # @param bot_token [String] Discord bot token
+          # @param project_key [String, nil] Optional project to inherit (not locked until implementation)
+          # @param fork_emoji [String] The emoji that triggered the fork (default: 🌿)
+          # @return [Hash, nil] The created thread object, or nil on failure
+          def fork_conversation(source_channel_id:, source_message_id:, agent_key:, agent_name:, bot_token:,
+                                source_message: nil, source_is_thread: false, parent_channel_id: nil,
+                                topic: nil, project_key: nil, fork_emoji: "🌿")
+            # Fetch the source message if not provided
+            source_message ||= Api.fetch_message(source_channel_id, source_message_id, token: bot_token)
+            unless source_message
+              LOG.warn "[Discord:#{agent_name}] Cannot fork — failed to fetch message #{source_message_id}" if defined?(LOG)
+              return nil
+            end
+
+            # Build thread title
+            content = source_message["content"]&.strip || ""
+            content = strip_inline_tags(content)
+            thread_title = build_thread_title(topic, content, agent_name)
+
+            # Create the thread
+            # If the source message is inside a thread, we can't create a sub-thread from it.
+            # Instead, create a standalone thread in the parent channel.
+            thread = if source_is_thread && parent_channel_id
+                       create_standalone_thread(parent_channel_id, thread_title, agent_name, bot_token)
+                     else
+                       Api.create_thread(source_channel_id, source_message_id, name: thread_title, token: bot_token)
+                     end
+
+            unless thread && thread["id"]
+              LOG.error "[Discord:#{agent_name}] Failed to create branch thread from message #{source_message_id}" if defined?(LOG)
+              return nil
+            end
+
+            thread_id = thread["id"]
+            LOG.info "[Discord:#{agent_name}] Created branch thread #{thread_id}: \"#{thread_title}\"" if defined?(LOG)
+
+            # Register as an unbound branch (no worktree yet)
+            register_unbound_branch(
+              agent_key: agent_key, agent_name: agent_name,
+              thread_id: thread_id, project_key: project_key,
+              source_channel_id: source_channel_id, source_message_id: source_message_id
+            )
+
+            # React on the source message to indicate branching
+            Thread.new { Api.add_reaction(source_channel_id, source_message_id, fork_emoji, token: bot_token) }
+
+            # Post an intro message in the new thread
+            # Include a reference to the original message when created as a standalone thread
+            if source_is_thread
+              post_branch_intro_with_reference(thread_id, agent_name, source_channel_id, source_message_id, bot_token)
+            else
+              post_branch_intro(thread_id, agent_name, bot_token)
+            end
+
+            thread
+          end
+
+          # Legacy method signature for backward compatibility with [fork] tag handling.
+          # The message.rb handler uses the old parameter names.
+          def fork_conversation_legacy(channel_id:, message_id:, agent_key:, agent_name:, bot_token:, topic: nil, project_key: nil)
+            fork_conversation(
+              source_channel_id: channel_id,
+              source_message_id: message_id,
+              source_message: nil,
+              source_is_thread: false,
+              parent_channel_id: channel_id,
+              topic: topic,
+              agent_key: agent_key,
+              agent_name: agent_name,
+              bot_token: bot_token,
+              project_key: project_key
+            )
+          end
+
+          private
+
+          # Create a standalone thread (not connected to a message).
+          # Used when forking from inside an existing thread.
+          # Discord API: POST /channels/<channel_id>/threads
+          def create_standalone_thread(channel_id, name, agent_name, bot_token)
+            thread_name = name.length > 100 ? "#{name[0..96]}..." : name
+            result = Api.request(:post, "/channels/#{channel_id}/threads", token: bot_token, body: {
+                                   name: thread_name,
+                                   type: 11, # PUBLIC_THREAD
+                                   auto_archive_duration: 1440
+                                 })
+
+            if result && result["id"]
+              LOG.info "[Discord:#{agent_name}] Created standalone thread #{result["id"]} in channel #{channel_id}" if defined?(LOG)
+            elsif defined?(LOG)
+              LOG.error "[Discord:#{agent_name}] Failed to create standalone thread: #{result.inspect}"
+            end
+
+            result
+          end
+
+          # Strip inline tags from content for cleaner thread titles.
+          #
+          # The bracket-tag regex uses an atomic group ((?>...)) around the tag
+          # name so the engine can't backtrack into overlapping alternatives on
+          # malformed input like "[p:[?:[?:...". Without it, the "p"/"?"
+          # alternatives combined with the unbounded [^\]]+ argument create
+          # polynomial-time backtracking (ReDoS) on adversarial strings.
+          def strip_inline_tags(content)
+            content
+              .gsub(/\[(?>fork|branch|project|effort|cli|profile|p|deploy|chat|question|\?|fresh|plan|worktree|workitem)(?::[^\]]*)?\]/i, "")
+              .gsub(/\[\w+\]/i, "") # Model tags and others
+              .gsub(/<@!?\d+>/, "") # Discord mentions
+              .strip
+          end
+
+          def build_thread_title(topic, content, agent_name)
+            if topic && topic != true
+              "#{agent_name}: #{topic}"
+            elsif !content.empty?
+              snippet = content[0..60]
+              snippet = "#{snippet}..." if content.length > 60
+              "#{agent_name}: #{snippet}"
+            else
+              "#{agent_name}: Branch"
+            end
+          end
+
+          def register_unbound_branch(agent_key:, agent_name:, thread_id:, project_key:, source_channel_id:, source_message_id:)
+            thread_map_key = "#{agent_key}:#{thread_id}"
+
+            Config.thread_map_mutex.synchronize do
+              map = Config.load_thread_map
+              map[thread_map_key] = {
+                "channel_id" => thread_id,
+                "project" => project_key,
+                "unbound" => true, # No worktree yet — created on demand
+                "source_channel_id" => source_channel_id,
+                "source_message_id" => source_message_id,
+                "created_at" => Time.now.iso8601
+              }
+              Config.save_thread_map(map)
+            end
+
+            LOG.info "[Discord:#{agent_name}] Registered unbound branch #{thread_map_key} (project: #{project_key || "none"})" if defined?(LOG)
+          end
+
+          def post_branch_intro(thread_id, agent_name, bot_token)
+            intro = "_Branched conversation. I'll work in this thread — the original stays undisturbed._"
+            Api.send_message(thread_id, intro, token: bot_token)
+          rescue StandardError => e
+            LOG.warn "[Discord:#{agent_name}] Failed to post branch intro: #{e.message}" if defined?(LOG)
+          end
+
+          # Post intro with a reference to the original message (for standalone threads).
+          def post_branch_intro_with_reference(thread_id, agent_name, source_channel_id, source_message_id, bot_token)
+            # Discord message link format: https://discord.com/channels/guild_id/channel_id/message_id
+            # For within the same server, we can use a relative link
+            message_link = "https://discord.com/channels/@me/#{source_channel_id}/#{source_message_id}"
+            intro = "_Branched from [this message](#{message_link}). I'll work in this thread — the original stays undisturbed._"
+            Api.send_message(thread_id, intro, token: bot_token)
+          rescue StandardError => e
+            LOG.warn "[Discord:#{agent_name}] Failed to post branch intro with reference: #{e.message}" if defined?(LOG)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/brainiac/plugins/discord/gateway.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "websocket-client-simple"
+require "websocket"
 
 module Brainiac
   module Plugins
@@ -12,6 +13,15 @@ module Brainiac
       # and MESSAGE_REACTION_ADD events to handler functions.
       module Gateway
         GATEWAY_URL = "wss://gateway.discord.gg/?v=10&encoding=json"
+        GATEWAY_QUERY = "?v=10&encoding=json"
+
+        # Reconnect backoff (seconds). A normal disconnect starts at BASE and
+        # doubles up to CAP; a handshake rejection (HTTP non-101, e.g. Discord
+        # returning 429 to the WebSocket upgrade) starts higher to avoid a
+        # reconnect storm across many bots hammering the gateway in lockstep.
+        BACKOFF_BASE = 5
+        BACKOFF_HANDSHAKE_BASE = 30
+        BACKOFF_CAP = 300
 
         # Per-bot state: { agent_key => { token:, user_id:, status:, thread: } }
         @bots = {}
@@ -142,19 +152,80 @@ module Brainiac
 
           private
 
+          # Resolve the gateway URL to connect to, and honor Discord's session
+          # start limits. Queries GET /gateway/bot (authenticated) which returns
+          # the recommended WebSocket URL plus session_start_limit. If the bot
+          # has exhausted its identify allowance, sleep until the window resets
+          # before returning so we don't burn reconnects against a hard limit.
+          # Falls back to the hardcoded GATEWAY_URL if the call fails.
+          def resolve_gateway_url(bot_token, agent_display)
+            info = Api.request(:get, "/gateway/bot", token: bot_token, log_errors: false)
+            unless info.is_a?(Hash) && info["url"]
+              LOG.warn "[Discord:#{agent_display}] Could not fetch /gateway/bot, using default URL" if defined?(LOG)
+              return GATEWAY_URL
+            end
+
+            honor_session_limit(info["session_start_limit"], agent_display)
+
+            "#{info["url"]}/#{GATEWAY_QUERY}"
+          rescue StandardError => e
+            LOG.warn "[Discord:#{agent_display}] /gateway/bot lookup failed: #{e.message}, using default URL" if defined?(LOG)
+            GATEWAY_URL
+          end
+
+          # If Discord reports no remaining identifies, wait out the reset window.
+          def honor_session_limit(limit, agent_display)
+            return unless limit.is_a?(Hash)
+
+            remaining = limit["remaining"].to_i
+            return if remaining.positive?
+
+            reset_after_s = (limit["reset_after"].to_i / 1000.0).ceil
+            reset_after_s = 1 if reset_after_s <= 0
+            LOG.warn "[Discord:#{agent_display}] Session start limit exhausted, waiting #{reset_after_s}s" if defined?(LOG)
+            sleep reset_after_s
+          end
+
+          # Exponential backoff with full jitter, capped. `attempt` is 0-based.
+          def backoff_delay(attempt, base)
+            capped = [base * (2**attempt), BACKOFF_CAP].min
+            # Full jitter: random between base and the capped ceiling.
+            rand(base.to_f..capped.to_f).round(1)
+          end
+
           def start_gateway_for(agent_key, bot_token)
             thread = Thread.new do
               agent_display = agent_display_name(agent_key) || agent_key.capitalize
               bot_user_id = nil
+              attempt = 0
 
               loop do
                 bot_user_id = run_gateway_connection(agent_key, agent_display, bot_token, bot_user_id)
+                # A clean return means the connection was established at least
+                # once; reset backoff so a later transient drop recovers fast.
+                attempt = 0
+                delay = backoff_delay(attempt, BACKOFF_BASE)
+                LOG.info "[Discord:#{agent_display}] Reconnecting in #{delay}s..." if defined?(LOG)
+                sleep delay
+              rescue WebSocket::Error::Handshake::InvalidStatusCode => e
+                @bots_mutex.synchronize do
+                  @bots[agent_key][:status] = "error" if @bots[agent_key]
+                end
+                delay = backoff_delay(attempt, BACKOFF_HANDSHAKE_BASE)
+                attempt += 1
+                if defined?(LOG)
+                  LOG.error "[Discord:#{agent_display}] Gateway handshake rejected (#{e.message}) — " \
+                            "likely rate limited; backing off #{delay}s"
+                end
+                sleep delay
               rescue StandardError => e
                 @bots_mutex.synchronize do
                   @bots[agent_key][:status] = "error" if @bots[agent_key]
                 end
-                LOG.error "[Discord:#{agent_display}] Gateway error: #{e.message}, reconnecting in 5s..." if defined?(LOG)
-                sleep 5
+                delay = backoff_delay(attempt, BACKOFF_BASE)
+                attempt += 1
+                LOG.error "[Discord:#{agent_display}] Gateway error: #{e.message}, reconnecting in #{delay}s..." if defined?(LOG)
+                sleep delay
               end
             end
             @bots_mutex.synchronize { @bots[agent_key][:thread] = thread if @bots[agent_key] }
@@ -172,10 +243,17 @@ module Brainiac
               bots[agent_key][:token] = bot_token
             end
 
-            LOG.debug "[Discord:#{agent_display}] Connecting to Gateway..." if defined?(LOG) && LOG.respond_to?(:debug)
+            # The WebSocket handshake runs in websocket-client-simple's own reader
+            # thread, so a non-101 response surfaces via the :error callback rather
+            # than raising here. Capture it and re-raise after the connection wait
+            # so the reconnect loop can apply handshake-specific backoff.
+            handshake_error = nil
+
+            gateway_url = resolve_gateway_url(bot_token, agent_display)
+            LOG.debug "[Discord:#{agent_display}] Connecting to #{gateway_url}" if defined?(LOG) && LOG.respond_to?(:debug)
             heartbeat_thread = nil
             last_sequence = nil
-            ws = WebSocket::Client::Simple.connect(GATEWAY_URL)
+            ws = WebSocket::Client::Simple.connect(gateway_url)
 
             ws.on :message do |msg|
               next if msg.data.nil? || msg.data.empty?
@@ -203,22 +281,40 @@ module Brainiac
             end
 
             ws.on :error do |e|
+              handshake_error = e if e.is_a?(WebSocket::Error::Handshake::InvalidStatusCode)
               LOG.error "[Discord:#{agent_display}] WebSocket error: #{e.message}" if defined?(LOG)
             end
 
-            wait_for_disconnect(ws, agent_display)
+            wait_for_disconnect(ws, agent_display) { handshake_error }
+
+            # If the connection never opened because Discord rejected the upgrade,
+            # propagate so the caller backs off harder instead of tight-looping.
+            raise handshake_error if handshake_error && !ws.open?
+
             bot_user_id
           end
 
+          # Block until the socket closes. Returns promptly if a handshake error
+          # is reported (the socket never opens in that case). Backoff between
+          # reconnects is owned by the caller (start_gateway_for).
           def wait_for_disconnect(websocket, agent_display)
+            # Give the handshake a brief window to complete before deciding the
+            # socket is dead, so we don't treat a still-connecting socket as lost.
+            grace = 10
+            grace.times do
+              sleep 0.5
+              break if websocket.open? || (block_given? && yield)
+            end
+
             loop do
-              sleep 1
-              next if websocket.open?
+              return if block_given? && yield && !websocket.open?
 
-              LOG.info "[Discord:#{agent_display}] Connection lost, reconnecting in 5s..." if defined?(LOG)
-              sleep 5
-              break
+              break unless websocket.open?
+
+              sleep 1
             end
+
+            LOG.info "[Discord:#{agent_display}] Connection lost" if defined?(LOG)
           end
 
           def handle_gateway_op(websocket, payload, agent_key, agent_display, bot_token, bot_user_id, heartbeat_thread, last_sequence)

data/lib/brainiac/plugins/discord/message.rb

@@ -66,6 +66,18 @@ module Brainiac
             return unless authorize_user(discord_user, discord_user_id, message, channel_id, message_id, agent_name, bot_token)
 
             tags = parse_inline_tags(clean_content)
+
+            # [fork] or [fork:topic] — branch the conversation before dispatching
+            if tags[:fork_branch]
+              return handle_fork_branch(
+                tags: tags, agent_key: agent_key, agent_name: agent_name, bot_token: bot_token,
+                channel_id: channel_id, message_id: message_id, message: message,
+                clean_content: clean_content, parent_channel_id: parent_channel_id,
+                discord_user: discord_user, attachment_paths: attachment_paths,
+                is_thread: is_thread
+              )
+            end
+
             project_key, project_config = resolve_project(tags[:project], parent_channel_id, agent_name, channel_id, message_id, bot_token)
 
             # Thread owners bypass intent checking ONLY when they're the sole agent in
@@ -91,6 +103,67 @@ module Brainiac
 
           private
 
+          # Handle [fork] or [fork:topic] tag — create a branch thread and dispatch to it.
+          # The branched thread starts unbound (no worktree) and inherits the parent's project.
+          def handle_fork_branch(tags:, agent_key:, agent_name:, bot_token:, channel_id:, message_id:,
+                                 message:, clean_content:, parent_channel_id:, discord_user:, attachment_paths:, is_thread:)
+            topic = tags[:fork_branch] == true ? nil : tags[:fork_branch]
+
+            # Resolve project from channel mapping (inherited, but not locked until implementation)
+            project_key, _project_config, _mapping = Config.find_project_for_channel(parent_channel_id)
+
+            # Create the branch thread
+            thread = Branching.fork_conversation(
+              source_channel_id: channel_id,
+              source_message_id: message_id,
+              source_message: nil, # Will be fetched by Branching
+              source_is_thread: is_thread,
+              parent_channel_id: parent_channel_id,
+              topic: topic,
+              agent_key: agent_key,
+              agent_name: agent_name,
+              bot_token: bot_token,
+              project_key: project_key
+            )
+
+            unless thread
+              LOG.error "[Discord:#{agent_name}] Failed to create fork branch" if defined?(LOG)
+              Thread.new { Api.add_reaction(channel_id, message_id, "⚠️", token: bot_token) }
+              return
+            end
+
+            branch_thread_id = thread["id"]
+            LOG.info "[Discord:#{agent_name}] Forked to thread #{branch_thread_id}, dispatching there" if defined?(LOG)
+
+            # Now dispatch to the new thread
+            # Re-synthesize a message event as if it came from the new thread
+            branch_message = message.dup
+            branch_message["channel_id"] = branch_thread_id
+
+            # Fetch fresh channel info for the new thread
+            branch_channel_info = Api.fetch_channel_info(branch_thread_id, token: bot_token)
+
+            # Build context for the branched thread (no prior history since it's new)
+            branch_channel_history = ""
+
+            # Resolve project again (same result, but for clarity)
+            branch_project_key, branch_project_config = resolve_project(tags[:project], parent_channel_id, agent_name,
+                                                                        branch_thread_id, message_id, bot_token)
+
+            # Dispatch to the branch
+            route_dispatch(
+              agent_key: agent_key, agent_name: agent_name, bot_token: bot_token, is_bot: false,
+              channel_id: branch_thread_id, message_id: message_id, message: branch_message,
+              clean_content: clean_content, clean_content_for_prompt: tags[:clean_text],
+              chat_mode: tags[:chat_mode], fresh: tags[:fresh], is_thread: true, is_dm: false,
+              channel_info: branch_channel_info, parent_channel_id: parent_channel_id,
+              discord_user: discord_user, reply_context: "",
+              channel_history: branch_channel_history, project_key: branch_project_key,
+              project_config: branch_project_config, attachment_paths: attachment_paths,
+              directly_addressed: true # User explicitly forked to us
+            )
+          end
+
           # Check if the agent's Discord role was @mentioned in this message.
           # Discord role mentions use <@&ROLE_ID> syntax and populate mention_roles array.
           def role_mentioned?(message, content, agent_key)
@@ -607,7 +680,8 @@ module Brainiac
               resolved: resolved, project_config: project_config,
               session_key: session_key, supersede_key: supersede_key,
               attachment_paths: attachment_paths, timestamp: timestamp, response_dir: response_dir,
-              profile: parse_inline_tags(clean_content)[:profile]
+              profile: resolve_thread_profile(thread_map_key, clean_content),
+              explicit_model: explicit_model_tag?(clean_content, project_config, cli_provider_override: cli_provider_override)
             )
           end
 
@@ -712,6 +786,55 @@ module Brainiac
                      "cli=#{cli_provider}, model=#{model}, effort=#{effort}"
           end
 
+          # Resolve the profile ([profile:X]/[p:X]) for this dispatch and make it sticky.
+          #
+          # An inline tag wins and is saved on the thread map entry (and the core work item),
+          # so later untagged replies in the same thread keep running on that profile until a
+          # different [p:X] replaces it. Without a tag, the stored thread profile is used, then
+          # the work item's (e.g. set from a Fizzy card). nil means the default profile.
+          # Unknown profile names are passed through (core ignores them with a warning) but
+          # never saved, so a typo can't pin the thread to a nonexistent profile.
+          def resolve_thread_profile(thread_map_key, clean_content)
+            inline = parse_inline_tags(clean_content)[:profile]
+            return inline unless thread_map_key
+
+            if inline
+              persist_thread_profile(thread_map_key, inline) if !defined?(profile_entry) || profile_entry(inline)
+              return inline
+            end
+
+            entry = Config.thread_map_mutex.synchronize { Config.load_thread_map[thread_map_key] }
+            return nil unless entry
+
+            entry["profile"] || work_item_profile_for(entry["branch"])
+          end
+
+          def persist_thread_profile(thread_map_key, profile)
+            branch = Config.thread_map_mutex.synchronize do
+              map = Config.load_thread_map
+              entry = map[thread_map_key]
+              next nil unless entry
+
+              if entry["profile"] != profile
+                entry["profile"] = profile
+                Config.save_thread_map(map)
+                LOG.info "[Discord] Persisted profile for #{thread_map_key}: #{profile}" if defined?(LOG)
+              end
+              entry["branch"]
+            end
+
+            return unless branch && defined?(update_work_item_overrides) &&
+                          method(:update_work_item_overrides).parameters.any? { |t, n| t == :key && n == :profile }
+
+            update_work_item_overrides(branch: branch, profile: profile)
+          end
+
+          def work_item_profile_for(branch)
+            return nil unless branch && defined?(work_item_overrides_for)
+
+            work_item_overrides_for(branch: branch)["profile"]
+          end
+
           def explicit_model_tag?(clean_content, project_config, cli_provider_override: nil)
             return false unless project_config
 
@@ -871,6 +994,8 @@ module Brainiac
                         "model" => model, "effort" => effort, "created_at" => Time.now.iso8601 }
               entry["branch"] = branch if branch
               entry["chat_mode"] = true if chat_mode
+              # Keep a sticky profile when an entry is rebuilt (e.g. its worktree was recreated).
+              entry["profile"] = map.dig(thread_map_key, "profile") if map.dig(thread_map_key, "profile")
               map[thread_map_key] = entry
               Config.save_thread_map(map)
             end
@@ -906,7 +1031,8 @@ module Brainiac
           def spawn_agent(agent_key:, agent_name:, bot_token:, channel_id:, message_id:, discord_user:,
                           work_dir:, prompt_file:, response_file:, meta_file:, model:, effort:,
                           actual_resume:, resolved:, project_config:,
-                          session_key:, supersede_key:, attachment_paths:, timestamp:, response_dir:, profile: nil)
+                          session_key:, supersede_key:, attachment_paths:, timestamp:, response_dir:, profile: nil,
+                          explicit_model: nil)
             agent_config_name = agent_key.downcase.gsub(/[^a-z0-9-]/, "-")
             log_file = File.join(response_dir, "discord-agent-#{timestamp}-#{agent_key}-#{message_id}.log")
 
@@ -926,6 +1052,10 @@ module Brainiac
             # XDG_DATA_HOME). An explicitly-requested [profile:X] wins over agent
             # env; the default profile is only a fallback. See core profiles.rb.
             agent_env = profile_spawn_env(agent_env, profile) if defined?(profile_spawn_env)
+            # The *effective* profile name that actually ran (explicit if valid,
+            # else the default profile) — recorded in durable history so the
+            # monitor can show which account/profile the session used.
+            effective_profile = defined?(effective_profile_name) ? effective_profile_name(profile) : profile
             unless agent_env.empty?
               spawn_env.merge!(agent_env)
               LOG.info "[Discord:#{agent_name}] Injecting #{agent_env.size} env var(s): #{agent_env.keys.join(", ")}" if defined?(LOG)
@@ -942,6 +1072,22 @@ module Brainiac
               LOG.info "[Discord:#{agent_name}] Injecting GitHub App token (GH_TOKEN) for bot identity" if defined?(LOG)
             end
 
+            # For providers with no runtime --model flag (e.g. kiro-cli, model_flag: ""),
+            # persist the model to the provider's settings store before spawning. Discord
+            # dispatches its own agents and never calls core's run_agent, so we invoke the
+            # same helper here — running it under the fully-assembled spawn_env so the write
+            # targets the correct account's KIRO_HOME. No-op when a model_flag is configured.
+            # explicit_model tells the helper whether this came from an inline tag: an explicit
+            # [auto] writes (a deliberate reset), a defaulted "auto" does not. Guard the kwarg
+            # against older core builds whose apply_settings_model has no `explicit:` param.
+            if defined?(apply_settings_model)
+              if method(:apply_settings_model).parameters.any? { |t, n| t == :key && n == :explicit }
+                apply_settings_model(model, resolved, spawn_env, explicit: explicit_model)
+              else
+                apply_settings_model(model, resolved, spawn_env)
+              end
+            end
+
             head_before, status_before = capture_brainiac_state(project_config, work_dir)
             prompt_mode = resolved["prompt_mode"] || "stdin"
 
@@ -966,7 +1112,8 @@ module Brainiac
               attachment_paths: attachment_paths, project_config: project_config,
               head_before: head_before, status_before: status_before,
               supersede_key: supersede_key,
-              resolved: resolved, model: model, work_dir: work_dir, started_at: started_at
+              resolved: resolved, model: model, work_dir: work_dir, started_at: started_at,
+              profile: effective_profile
             )
           end
 
@@ -1145,7 +1292,7 @@ module Brainiac
           def monitor_agent(pid:, session_key:, agent_name:, agent_config_name:, channel_id:, message_id:,
                             bot_token:, response_file:, meta_file:, prompt_file:, log_file:,
                             attachment_paths:, project_config:, head_before:, status_before:, supersede_key: nil,
-                            resolved: nil, model: nil, work_dir: nil, started_at: nil)
+                            resolved: nil, model: nil, work_dir: nil, started_at: nil, profile: nil)
             Thread.new do
               Process.wait(pid)
               exit_status = $CHILD_STATUS
@@ -1162,7 +1309,7 @@ module Brainiac
                 agent_name: agent_name, agent_config_name: agent_config_name,
                 channel_id: channel_id, message_id: message_id, log_file: log_file,
                 resolved: resolved, model: model, work_dir: work_dir, started_at: started_at,
-                exit_status: exit_status
+                exit_status: exit_status, profile: profile
               )
 
               if exit_status.signaled? || session_cancelled
@@ -1205,7 +1352,8 @@ module Brainiac
           # Fully best-effort: archive_session_history already rescues internally, but we
           # guard here too so a history failure can never break Discord's completion path.
           def archive_discord_session_history(agent_name:, agent_config_name:, channel_id:, message_id:,
-                                              log_file:, resolved:, model:, work_dir:, started_at:, exit_status:)
+                                              log_file:, resolved:, model:, work_dir:, started_at:, exit_status:,
+                                              profile: nil)
             return unless defined?(archive_session_history)
 
             ctx = {
@@ -1219,6 +1367,7 @@ module Brainiac
               chdir: work_dir,
               agent_cli: resolved && resolved["agent_cli"],
               model: model,
+              profile: profile,
               started_at: started_at
             }
 

data/lib/brainiac/plugins/discord/reactions.rb

@@ -11,6 +11,16 @@ module Brainiac
       # - 🧠 to stream the full thinking log to a thread
       # - Non-reserved emojis logged as feedback to the agent's persona
       module Reactions
+        # Global deduplication for fork reactions. Tracks which messages have
+        # already been forked to prevent duplicates from multiple agents or
+        # repeated Discord events.
+        #
+        # Key: "channel_id:message_id" -> Time the fork was handled
+        # Entries expire after 60 seconds (well beyond Discord's duplicate window).
+        FORK_DEDUP = {}
+        FORK_DEDUP_MUTEX = Mutex.new
+        FORK_DEDUP_TTL = 60 # seconds
+
         class << self
           def handle(reaction_data, agent_key, bot_token, bot_user_id)
             channel_id = reaction_data["channel_id"]
@@ -31,6 +41,8 @@ module Brainiac
               handle_thinking_stream(agent_key, agent_name, channel_id, message_id, bot_token)
             when "❌"
               handle_cancel(agent_key, agent_name, channel_id, message_id, bot_token)
+            when "🌿", "🪾", "🍴", "🍽️"
+              handle_branch(agent_key, agent_name, channel_id, message_id, bot_token, emoji: emoji_name)
             else
               unless Api::RESERVED_EMOJIS.include?(emoji_name)
                 Thread.new do
@@ -171,6 +183,116 @@ module Brainiac
             end
           end
 
+          # Handle fork reactions (🌿, 🪾, 🍴, 🍽️) — fork the conversation into a new thread.
+          # The reacted message becomes the root of the new branch.
+          #
+          # Multi-agent coordination uses a two-phase approach:
+          # 1. Global deduplication — atomic check-and-claim ensures only one agent proceeds
+          # 2. Ownership check — determines which specific agent should handle it
+          #
+          # This prevents both the race condition (multiple agents passing ownership check
+          # simultaneously) and duplicate events (Discord sending the same reaction multiple times).
+          def handle_branch(agent_key, agent_name, channel_id, message_id, bot_token, emoji: "🌿")
+            LOG.info "[Discord:#{agent_name}] #{emoji} fork reaction on message #{message_id} in channel #{channel_id}" if defined?(LOG)
+
+            dedup_key = "#{channel_id}:#{message_id}"
+
+            # Fetch source message to determine ownership
+            source_message = Api.fetch_message(channel_id, message_id, token: bot_token)
+            unless source_message
+              LOG.warn "[Discord:#{agent_name}] #{emoji} skipping — couldn't fetch message #{message_id}" if defined?(LOG)
+              return
+            end
+
+            # Check if this agent should handle the fork (based on mentions/authorship/fallback)
+            unless should_handle_fork?(agent_key, source_message)
+              LOG.info "[Discord:#{agent_name}] #{emoji} skipping — another agent should handle this fork" if defined?(LOG)
+              return
+            end
+
+            # Atomic claim — only one agent gets past this point
+            unless claim_fork!(dedup_key, agent_key)
+              LOG.info "[Discord:#{agent_name}] #{emoji} skipping — fork already claimed by another process" if defined?(LOG)
+              return
+            end
+
+            LOG.info "[Discord:#{agent_name}] #{emoji} handling fork for message #{message_id}" if defined?(LOG)
+
+            # Check if we're in a thread — get parent channel for project resolution
+            channel_info = Api.fetch_channel_info(channel_id, token: bot_token)
+            is_thread = channel_info && [11, 12].include?(channel_info["type"])
+            parent_channel_id = is_thread ? channel_info["parent_id"] : channel_id
+
+            # Resolve project from channel mapping (inherited, but not locked)
+            project_key, _project_config, _mapping = Config.find_project_for_channel(parent_channel_id)
+
+            thread = Branching.fork_conversation(
+              source_channel_id: channel_id,
+              source_message_id: message_id,
+              source_message: source_message,
+              source_is_thread: is_thread,
+              parent_channel_id: parent_channel_id,
+              topic: nil, # Auto-generate from message content
+              agent_key: agent_key,
+              agent_name: agent_name,
+              bot_token: bot_token,
+              project_key: project_key,
+              fork_emoji: emoji
+            )
+
+            Api.add_reaction(channel_id, message_id, "⚠️", token: bot_token) unless thread
+          end
+
+          # Atomically claim a fork operation. Returns true if this caller wins,
+          # false if already claimed. Cleans up expired entries while holding the lock.
+          def claim_fork!(dedup_key, agent_key)
+            FORK_DEDUP_MUTEX.synchronize do
+              now = Time.now
+
+              # Clean up expired entries
+              FORK_DEDUP.delete_if { |_, claimed_at| now - claimed_at > FORK_DEDUP_TTL }
+
+              # Check if already claimed
+              return false if FORK_DEDUP.key?(dedup_key)
+
+              # Claim it
+              FORK_DEDUP[dedup_key] = now
+              LOG.debug "[Discord] Fork claimed: #{dedup_key} by #{agent_key}" if defined?(LOG) && LOG.respond_to?(:debug)
+              true
+            end
+          end
+
+          # Determine if this agent should handle a fork reaction.
+          # Only one agent should handle each fork to avoid duplicates.
+          def should_handle_fork?(agent_key, source_message)
+            bot_user_id = Gateway.bot_user_id(agent_key)&.to_s
+            return false unless bot_user_id
+
+            # 1. If this bot authored the message → handle it
+            return true if source_message.dig("author", "id").to_s == bot_user_id
+
+            # 2. If this bot was @mentioned in the message → handle it
+            mentions = source_message["mentions"] || []
+            content = source_message["content"] || ""
+            if mentions.any? { |m| m["id"].to_s == bot_user_id } ||
+               content.match?(/<@!?#{Regexp.escape(bot_user_id)}>/)
+              return true
+            end
+
+            # 3. Fallback: deterministic selection among all active bots
+            # Pick the bot with the lexicographically smallest agent_key
+            active_bot_keys = []
+            Gateway.each_bot do |key, info|
+              active_bot_keys << key if info[:user_id]
+            end
+
+            return false if active_bot_keys.empty?
+
+            # Pick the smallest key to ensure deterministic selection
+            designated_handler = active_bot_keys.min
+            agent_key == designated_handler
+          end
+
           def log_emoji_feedback(channel_id, message_id, user_id, emoji_name, agent_key, agent_name, bot_token)
             msg = Api.fetch_message(channel_id, message_id, token: bot_token, log_errors: false)
             return unless msg&.dig("author", "bot")

data/lib/brainiac/plugins/discord/version.rb

@@ -3,7 +3,7 @@
 module Brainiac
   module Plugins
     module Discord
-      VERSION = "0.0.16"
+      VERSION = "0.0.18"
     end
   end
 end

data/lib/brainiac/plugins/discord.rb

@@ -8,6 +8,7 @@ require_relative "discord/prompts"
 require_relative "discord/api"
 require_relative "discord/delivery"
 require_relative "discord/reactions"
+require_relative "discord/branching"
 require_relative "discord/message"
 require_relative "discord/thread_cleanup"
 require_relative "discord/gateway"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: brainiac-discord
 version: !ruby/object:Gem::Version
-  version: 0.0.16
+  version: 0.0.18
 platform: ruby
 authors:
 - Andy Davis
@@ -104,6 +104,7 @@ files:
 - README.md
 - lib/brainiac/plugins/discord.rb
 - lib/brainiac/plugins/discord/api.rb
+- lib/brainiac/plugins/discord/branching.rb
 - lib/brainiac/plugins/discord/cli.rb
 - lib/brainiac/plugins/discord/config.rb
 - lib/brainiac/plugins/discord/delivery.rb