brainiac-discord 0.0.17 → 0.0.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3b1fa3c52f3226376895626cbf3ba0d97963dcd8ea9f5ae227f4615797e48a6c
-  data.tar.gz: 99b890d0c8ccb29079b2617e0cd661aef8c703040b90db58a148938a73fc2990
+  metadata.gz: 81f74969c95690e118d85fe590b2e2d35b39609937e807afaa2865ac58c8846d
+  data.tar.gz: cde31da7b3a0b2a4b84bff28b4b1e2fa99fe6ba7e7e8e372b572b1d0ea085c5c
 SHA512:
-  metadata.gz: 5754062ffb91909ec05451e84b3b03fca71754cbe9cb4434e154eb9e70df34654ffcd7c37c28be4adea593628944bc2d9b19a46d7d60fc08c15b7ebb40848520
-  data.tar.gz: ac00ebaa2b82042fb2fc7abbf3dcf94d1f674b0b9ded9a1e3fd7cd3974f0256ff0162440935acaa9b334e3eb2f081ed1393aaf2de87b99e61aa53fed8a0c4bcf
+  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/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)

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.17"
+      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.17
+  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