brainiac 0.0.9 → 0.0.10

data/bin/brainiac-completion.bash

@@ -8,8 +8,18 @@ _brainiac() {
 
   local brainiac_dir="${BRAINIAC_DIR:-$HOME/.brainiac}"
 
-  # Top-level commands
-  local commands="server stop restart logs status register unregister list show brain discord cron provider role agent config path version help setup projects card-map handler"
+  # 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"
+
+  # Add installed plugin names as top-level commands
+  if [[ -f "$brainiac_dir/plugins.json" ]]; then
+    local plugin_names
+    plugin_names=$(ruby -rjson -e '
+      config = JSON.parse(File.read(ARGV[0]))
+      (config["plugins"] || []).each { |p| puts p.is_a?(Hash) ? p["name"] : p.to_s }
+    ' "$brainiac_dir/plugins.json" 2>/dev/null)
+    commands="$commands $plugin_names"
+  fi
 
   # Helper: list agent keys from registry
   _brainiac_agents() {
@@ -32,6 +42,13 @@ _brainiac() {
     fi
   }
 
+  # Helper: list project keys
+  _brainiac_projects() {
+    if [[ -f "$brainiac_dir/projects.json" ]]; then
+      ruby -rjson -e 'JSON.parse(File.read(ARGV[0])).each_key { |k| puts k }' "$brainiac_dir/projects.json" 2>/dev/null
+    fi
+  }
+
   # Determine position in command
   case $cword in
     1)
@@ -43,6 +60,14 @@ _brainiac() {
   local cmd="${words[1]}"
 
   case "$cmd" in
+    plugin)
+      case $cword in
+        2)
+          COMPREPLY=($(compgen -W "new" -- "$cur"))
+          ;;
+      esac
+      ;;
+
     role)
       case $cword in
         2)
@@ -90,7 +115,6 @@ _brainiac() {
         4)
           local subcmd="${words[3]}"
           if [[ "$subcmd" == "env" ]]; then
-            # Suggest --delete or existing env var names for this agent
             local agent_key="${words[2]}"
             local env_keys=""
             if [[ -f "$brainiac_dir/agents.json" ]]; then
@@ -104,7 +128,6 @@ _brainiac() {
           fi
           ;;
         5)
-          # After --delete, suggest env var names
           if [[ "${words[3]}" == "env" && "${words[4]}" == "--delete" ]]; then
             local agent_key="${words[2]}"
             local env_keys=""
@@ -149,20 +172,6 @@ _brainiac() {
       esac
       ;;
 
-    discord)
-      case $cword in
-        2)
-          COMPREPLY=($(compgen -W "config default map owner token agents status" -- "$cur"))
-          ;;
-        3)
-          local subcmd="${words[2]}"
-          if [[ "$subcmd" == "token" ]]; then
-            COMPREPLY=($(compgen -W "$(_brainiac_agents)" -- "$cur"))
-          fi
-          ;;
-      esac
-      ;;
-
     cron)
       case $cword in
         2)
@@ -176,8 +185,74 @@ _brainiac() {
         2)
           COMPREPLY=($(compgen -W "list default" -- "$cur"))
           ;;
+        3)
+          if [[ "${words[2]}" == "default" ]]; then
+            COMPREPLY=($(compgen -W "$(_brainiac_projects)" -- "$cur"))
+          fi
+          ;;
       esac
       ;;
+
+    install)
+      # Suggest known plugin names that aren't installed
+      if [[ $cword -eq 2 ]]; then
+        COMPREPLY=($(compgen -W "--path --version" -- "$cur"))
+      fi
+      ;;
+
+    uninstall)
+      if [[ $cword -eq 2 && -f "$brainiac_dir/plugins.json" ]]; then
+        local installed
+        installed=$(ruby -rjson -e '
+          config = JSON.parse(File.read(ARGV[0]))
+          (config["plugins"] || []).each { |p| puts p.is_a?(Hash) ? p["name"] : p.to_s }
+        ' "$brainiac_dir/plugins.json" 2>/dev/null)
+        COMPREPLY=($(compgen -W "$installed" -- "$cur"))
+      fi
+      ;;
+
+    *)
+      # Check if cmd is an installed plugin — delegate completion to it
+      if [[ -f "$brainiac_dir/plugins.json" ]]; then
+        local is_plugin
+        is_plugin=$(ruby -rjson -e '
+          config = JSON.parse(File.read(ARGV[0]))
+          names = (config["plugins"] || []).map { |p| p.is_a?(Hash) ? p["name"] : p.to_s }
+          puts "yes" if names.include?(ARGV[1])
+        ' "$brainiac_dir/plugins.json" "$cmd" 2>/dev/null)
+
+        if [[ "$is_plugin" == "yes" && $cword -eq 2 ]]; then
+          # Get plugin subcommands via its CLI module
+          local subcmds
+          subcmds=$(ruby -rjson -e '
+            brainiac_dir = ENV["BRAINIAC_DIR"] || File.join(Dir.home, ".brainiac")
+            config = JSON.parse(File.read(File.join(brainiac_dir, "plugins.json")))
+            entry = (config["plugins"] || []).find { |p| (p.is_a?(Hash) ? p["name"] : p.to_s) == ARGV[0] }
+            exit unless entry
+
+            module Brainiac; module Plugins; end; end
+
+            if entry.is_a?(Hash) && entry["path"]
+              $LOAD_PATH.unshift(File.join(entry["path"], "lib"))
+            end
+
+            cli_file = if entry.is_a?(Hash) && entry["path"]
+                         File.join(entry["path"], "lib", "brainiac", "plugins", ARGV[0], "cli.rb")
+                       end
+
+            if cli_file && File.exist?(cli_file)
+              load cli_file
+              pascal = ARGV[0].split(/[-_]/).map(&:capitalize).join
+              mod = Brainiac::Plugins.const_get(pascal) if Brainiac::Plugins.const_defined?(pascal)
+              if mod&.respond_to?(:completions)
+                puts mod.completions.join("\n")
+              end
+            end
+          ' "$cmd" 2>/dev/null)
+          COMPREPLY=($(compgen -W "$subcmds" -- "$cur"))
+        fi
+      fi
+      ;;
   esac
 }
 

data/brainiac.gemspec

@@ -4,7 +4,8 @@ Gem::Specification.new do |s|
   s.name        = "brainiac"
   s.version     = Brainiac::VERSION
   s.summary     = "AI agent webhook receiver and dispatcher"
-  s.description = "Webhook receiver that listens for Fizzy, GitHub, Discord, and Zoho Mail events, then dispatches work to AI agent CLIs."
+  s.description = "Webhook receiver that listens for GitHub and Zoho Mail events, then dispatches work to AI agent CLIs. " \
+                  "Additional channels (Discord, Fizzy) available via plugins."
   s.authors     = ["Andy Davis"]
   s.homepage    = "https://github.com/stowzilla/brainiac"
   s.license     = "MIT"
@@ -16,7 +17,6 @@ Gem::Specification.new do |s|
   s.add_dependency "puma", "~> 7.2"
   s.add_dependency "rackup", "~> 2.3"
   s.add_dependency "sinatra", "~> 4.1"
-  s.add_dependency "websocket-client-simple", "~> 0.8.0"
 
   s.add_development_dependency "minitest", "~> 5.25"
   s.add_development_dependency "rake", "~> 13.0"

data/lib/brainiac/config.rb

@@ -172,19 +172,6 @@ DEFAULT_PROJECT = {
   "allowed_efforts" => %w[low medium high xhigh max]
 }.freeze
 
-# --- Discord (optional) ---
-# Discord is enabled when any agent in the registry has a discord_bot_token
-# Requires the websocket-client-simple gem.
-
-DISCORD_ENABLED = begin
-  require "websocket-client-simple"
-  true
-rescue LoadError
-  warn "WARNING: websocket-client-simple gem not found. Discord bot disabled."
-  warn "Install with: gem install websocket-client-simple"
-  false
-end
-
 # --- Version check ---
 
 # Check if local brainiac is behind origin/master.
@@ -210,13 +197,13 @@ def check_brainiac_version
   { behind: true, local_sha: local_sha[0..6], remote_sha: remote_sha[0..6], commits_behind: count.strip.to_i }
 end
 
-# Discord user ID of the machine owner (for version-outdated notifications).
-# Reads from discord.json (Discord-scoped config).
-def owner_discord_id
-  discord_file = File.join(BRAINIAC_DIR, "discord.json")
-  return nil unless File.exist?(discord_file)
+# Owner identifier (for version-outdated notifications).
+# Reads from brainiac.json.
+def owner_id
+  brainiac_config_file = File.join(BRAINIAC_DIR, "brainiac.json")
+  return nil unless File.exist?(brainiac_config_file)
 
-  JSON.parse(File.read(discord_file))["owner_discord_id"]
+  JSON.parse(File.read(brainiac_config_file))["owner_id"]
 rescue JSON::ParserError
   nil
 end
@@ -224,8 +211,9 @@ end
 # --- Dashboard auth ---
 
 DASHBOARD_TOKEN = begin
-  discord_file = File.join(BRAINIAC_DIR, "discord.json")
-  JSON.parse(File.read(discord_file))["dashboard_token"] if File.exist?(discord_file)
+  brainiac_config_file = File.join(BRAINIAC_DIR, "brainiac.json")
+  config = File.exist?(brainiac_config_file) ? JSON.parse(File.read(brainiac_config_file)) : {}
+  config["dashboard_token"]
 rescue JSON::ParserError
   nil
 end

data/lib/brainiac/cron.rb

@@ -200,12 +200,17 @@ end
 
 # Add a new cron job
 def add_cron_job(id:, schedule:, agent:, project:, prompt: nil, script: nil, enabled: true, model: nil, effort: nil, discord_channel_id: nil,
+                 notify_channel: nil, notify_target: nil,
                  forum_title: nil, forum_reply_to_latest: false, repeat_count: nil)
   parsed = parse_cron_expression(schedule)
   return { error: "Invalid cron expression" } unless parsed
   return { error: "Must provide either prompt or script, not both" } if prompt && script
   return { error: "Must provide either prompt or script" } unless prompt || script
 
+  # Normalize: discord_channel_id is legacy shorthand for notify_channel: discord, notify_target: <id>
+  notify_channel ||= :discord if discord_channel_id
+  notify_target ||= discord_channel_id
+
   job = {
     id: id,
     schedule: schedule,
@@ -217,6 +222,8 @@ def add_cron_job(id:, schedule:, agent:, project:, prompt: nil, script: nil, ena
     prompt: prompt,
     script: script,
     enabled: enabled,
+    notify_channel: notify_channel&.to_s,
+    notify_target: notify_target,
     discord_channel_id: discord_channel_id,
     forum_title: forum_title,
     forum_reply_to_latest: forum_reply_to_latest,
@@ -308,7 +315,7 @@ def execute_script_job(job, project)
   log_file = File.join(project["repo_path"], "tmp/cron-script-#{job[:id]}-#{timestamp}.log")
   FileUtils.mkdir_p(File.dirname(log_file))
 
-  draft_file = prepare_script_discord_draft(job, timestamp) if job[:discord_channel_id]
+  draft_file = prepare_script_notification_draft(job, timestamp) if job[:notify_target] || job[:discord_channel_id]
 
   LOG.info "[Cron] Running script #{script_path} for job #{job[:id]}, tail -f #{log_file}"
 
@@ -327,16 +334,17 @@ def execute_script_job(job, project)
   end
 end
 
-# Prepare a Discord draft file and meta for a script job. Returns the draft file path.
-def prepare_script_discord_draft(job, timestamp)
-  draft_file = File.join(DISCORD_DRAFT_DIR, "cron-script-#{timestamp}-#{job[:id]}.md")
+# Prepare a notification draft file for a script job. Returns the draft file path.
+def prepare_script_notification_draft(job, timestamp)
+  notify_dir = File.join(BRAINIAC_DIR, "tmp", "notify", "draft")
+  FileUtils.mkdir_p(notify_dir)
+  draft_file = File.join(notify_dir, "cron-script-#{timestamp}-#{job[:id]}.md")
   meta_file = "#{draft_file}.meta.json"
 
-  FileUtils.mkdir_p(File.dirname(draft_file))
-
   script_agent_key = job[:agent]&.downcase&.gsub(/[^a-z0-9-]/, "-")
   meta = {
-    channel_id: job[:discord_channel_id],
+    notify_channel: (job[:notify_channel] || "discord").to_s,
+    notify_target: job[:notify_target] || job[:discord_channel_id],
     agent_key: script_agent_key,
     agent_name: job[:agent] || "Script",
     cron_job_id: job[:id],
@@ -353,10 +361,13 @@ def deliver_script_output(job, log_file, draft_file)
   return unless File.exist?(log_file)
 
   output = File.read(log_file).strip
+  has_notify = job[:notify_target] || job[:discord_channel_id]
 
-  if job[:discord_channel_id] && draft_file && !output.empty?
+  if has_notify && draft_file && !output.empty?
     File.write(draft_file, output)
-    LOG.info "[Cron] Script output written to #{draft_file} (#{output.length} chars)"
+    # Deliver via notification system
+    notify_cron_output(job, output, agent_name: job[:agent])
+    LOG.info "[Cron] Script output delivered via notification (#{output.length} chars)"
   elsif !output.empty?
     LOG.info "[Cron] Script output: #{output[0..200]}..."
   else
@@ -369,15 +380,22 @@ def build_cron_prompt(job, project)
   prompt = job[:prompt]
   agent_name = job[:agent]
   timestamp = Time.now.strftime("%Y%m%d-%H%M%S")
+  has_notify = job[:notify_target] || job[:discord_channel_id]
 
-  if job[:discord_channel_id]
-    draft_file = File.join(DISCORD_DRAFT_DIR, "cron-#{timestamp}-#{agent_name}-#{job[:id]}.md")
+  if has_notify
+    notify_dir = File.join(BRAINIAC_DIR, "tmp", "notify", "draft")
+    FileUtils.mkdir_p(notify_dir)
+    draft_file = File.join(notify_dir, "cron-#{timestamp}-#{agent_name}-#{job[:id]}.md")
     meta_file = "#{draft_file}.meta.json"
-    FileUtils.mkdir_p(File.dirname(draft_file))
 
     agent_key = agent_name.downcase.gsub(/[^a-z0-9-]/, "-")
+    notify_channel = (job[:notify_channel] || "discord").to_s
+    notify_target = job[:notify_target] || job[:discord_channel_id]
+
     meta = {
-      channel_id: job[:discord_channel_id],
+      notify_channel: notify_channel,
+      notify_target: notify_target,
+      channel_id: notify_target,
       agent_key: agent_key,
       agent_name: agent_name,
       cron_job_id: job[:id],
@@ -388,8 +406,8 @@ def build_cron_prompt(job, project)
     File.write(meta_file, JSON.pretty_generate(meta))
 
     full_prompt = <<~PROMPT
-      ## Scheduled Task (Discord Posting)
-      This is a scheduled cron job that will post to Discord channel #{job[:discord_channel_id]}.
+      ## Scheduled Task (Notification Posting)
+      This is a scheduled cron job. Output will be posted to #{notify_channel} (#{notify_target}).
 
       You were asked to: "#{prompt}"
 
@@ -397,7 +415,7 @@ def build_cron_prompt(job, project)
       Source directory: #{project["repo_path"]}
 
       **IMPORTANT: Write your response to #{draft_file}. Do NOT reply via stdout.**
-      Your response will be automatically posted to Discord.
+      Your response will be automatically posted.
 
       #{prompt}
     PROMPT
@@ -428,16 +446,13 @@ def handle_cron_completion(job, project, agent_name, agent_config_name, log_file
   cron_exit_status = $CHILD_STATUS.exitstatus
   LOG.info "[Cron] Job #{job[:id]} finished (exit: #{cron_exit_status})"
 
-  if cron_exit_status && cron_exit_status != 0 && job[:discord_channel_id]
-    bot_token = discord_bot_tokens[agent_config_name] || discord_bot_tokens.values.first
-    if bot_token
-      notify_agent_crash(
-        exit_status: cron_exit_status, log_file: log_file,
-        agent_name: agent_name, source: :discord,
-        source_context: { channel_id: job[:discord_channel_id], bot_token: bot_token },
-        project_config: project
-      )
-    end
+  if cron_exit_status && cron_exit_status != 0 && job[:notify_target]
+    notify_agent_crash(
+      exit_status: cron_exit_status, log_file: log_file,
+      agent_name: agent_name, source: :cron,
+      source_context: { job: job },
+      project_config: project
+    )
   end
 
   extract_cron_response_from_log(job, agent_config_name, log_file, response_file, meta_file)

data/lib/brainiac/handlers/github.rb

@@ -249,44 +249,19 @@ def close_uat_cards_after_deploy(project_key, project_config)
 end
 
 def send_deploy_notification(project_key, closed_cards)
-  channel_id = DISCORD_CONFIG["deploy_notification_channel_id"]
-  return unless channel_id
-
-  token = discord_bot_tokens.values.first
-  return unless token
-
   card_lines = closed_cards.map { |c| "• [##{c[:number]} — #{c[:title]}](#{c[:url]})" }.join("\n")
   message = "🚀 **#{project_key.capitalize}** deployed to production\nClosed UAT cards:\n#{card_lines}"
-
-  send_discord_message(channel_id, message, token: token)
-rescue StandardError => e
-  LOG.warn "Failed to send deploy notification: #{e.message}"
+  send_notification(:deploy, message, metadata_project: project_key)
 end
 
 def send_uat_deploy_notification(project_key)
-  channel_id = DISCORD_CONFIG["deploy_notification_channel_id"]
-  return unless channel_id
-
-  token = discord_bot_tokens.values.first
-  return unless token
-
   message = "✅ **#{project_key.capitalize}** deployed to UAT successfully"
-  send_discord_message(channel_id, message, token: token)
-rescue StandardError => e
-  LOG.warn "Failed to send UAT deploy notification: #{e.message}"
+  send_notification(:deploy, message, metadata_project: project_key)
 end
 
 def send_workflow_failure_notification(project_key, workflow_name, run_url)
-  channel_id = DISCORD_CONFIG["deploy_notification_channel_id"]
-  return unless channel_id
-
-  token = discord_bot_tokens.values.first
-  return unless token
-
   message = "❌ **#{project_key.capitalize}** — #{workflow_name} failed\n[View run](#{run_url})"
-  send_discord_message(channel_id, message, token: token)
-rescue StandardError => e
-  LOG.warn "Failed to send workflow failure notification: #{e.message}"
+  send_notification(:ci_failure, message, metadata_project: project_key)
 end
 
 def handle_github_issue_opened(payload)

data/lib/brainiac/handlers/zoho.rb

@@ -164,27 +164,21 @@ def format_zoho_notification(email, rule)
   parts.join("\n")
 end
 
-# Send the notification to the configured Discord channel.
+# Send the notification to the configured channel.
 def notify_zoho_match(email, rule)
-  channel_id = rule["discord_channel_id"] || ZOHO_CONFIG["default_discord_channel_id"]
-  unless channel_id
-    LOG.warn "[Zoho] No discord_channel_id configured for rule '#{rule["label"]}' and no default set"
+  target = rule["notify_target"] || rule["discord_channel_id"] || ZOHO_CONFIG["default_notify_target"] || ZOHO_CONFIG["default_discord_channel_id"]
+  channel = rule["notify_channel"] || ZOHO_CONFIG["notify_channel"] || "discord"
+
+  unless target
+    LOG.warn "[Zoho] No notify_target configured for rule '#{rule["label"]}' and no default set"
     return
   end
 
   message = format_zoho_notification(email, rule)
+  agent = rule["notify_as"] || ZOHO_CONFIG["notify_as"]
 
-  tokens = discord_bot_tokens
-  bot_name = rule["notify_as"] || ZOHO_CONFIG["notify_as"] || tokens.keys.first
-  token = tokens[bot_name&.downcase] || tokens.values.first
-
-  unless token
-    LOG.warn "[Zoho] No Discord bot token available to send notification"
-    return
-  end
-
-  LOG.info "[Zoho] Sending notification to channel #{channel_id} (bot: #{bot_name})"
-  send_discord_message(channel_id, message, token: token)
+  LOG.info "[Zoho] Sending notification via #{channel} to #{target}"
+  send_notification(:zoho_email, message, channel: channel, target: target, agent: agent)
 end
 
 # ---------------------------------------------------------------------------
@@ -360,20 +354,20 @@ end
 
 # Act on the triage decision
 def execute_zoho_triage_decision(decision, email, rule)
-  channel_id = rule["discord_channel_id"] || ZOHO_CONFIG["default_discord_channel_id"]
-  tokens = discord_bot_tokens
-  bot_name = rule["notify_as"] || ZOHO_CONFIG["notify_as"] || tokens.keys.first
-  token = tokens[bot_name&.downcase] || tokens.values.first
+  channel_id = rule["notify_target"] || rule["discord_channel_id"] ||
+               ZOHO_CONFIG["default_notify_target"] || ZOHO_CONFIG["default_discord_channel_id"]
+  notify_channel = rule["notify_channel"] || ZOHO_CONFIG["notify_channel"] || "discord"
+  bot_name = rule["notify_as"] || ZOHO_CONFIG["notify_as"]
 
   case decision["decision"]
   when "create_card"
-    create_zoho_triage_card(decision, email, channel_id, token)
+    create_zoho_triage_card(decision, email, channel_id, notify_channel, bot_name)
   when "skip"
     msg = "📧 **Support Email — No Card Needed**\n"
     msg += "**Subject:** #{email["subject"]}\n"
     msg += "**From:** #{email["fromAddress"]}\n"
     msg += "**Reason:** #{decision["reason"]}"
-    send_discord_message(channel_id, msg, token: token) if channel_id && token
+    send_notification(:zoho_triage, msg, channel: notify_channel, target: channel_id, agent: bot_name)
     LOG.info "[Zoho:Triage] Skipped card: #{decision["reason"]}"
   when "borderline"
     msg = "⚠️ **Support Email — Needs Human Decision**\n"
@@ -382,8 +376,8 @@ def execute_zoho_triage_decision(decision, email, rule)
     msg += "**Why borderline:** #{decision["reason"]}\n"
     summary = (email["summary"] || "").to_s[0..300]
     msg += "```\n#{summary}\n```" unless summary.empty?
-    send_discord_message(channel_id, msg, token: token) if channel_id && token
-    LOG.info "[Zoho:Triage] Borderline — posted to Discord for human decision"
+    send_notification(:zoho_triage, msg, channel: notify_channel, target: channel_id, agent: bot_name)
+    LOG.info "[Zoho:Triage] Borderline — posted for human decision"
   else
     LOG.warn "[Zoho:Triage] Unknown decision: #{decision["decision"]}"
     notify_zoho_match(email, rule)
@@ -391,7 +385,7 @@ def execute_zoho_triage_decision(decision, email, rule)
 end
 
 # Create a card from the triage decision
-def create_zoho_triage_card(decision, email, channel_id, token)
+def create_zoho_triage_card(decision, email, channel_id, notify_channel, bot_name)
   board_id = ZOHO_CONFIG["triage_board_id"]
   unless board_id
     LOG.error "[Zoho:Triage] No triage_board_id configured in zoho.json"
@@ -418,15 +412,13 @@ def create_zoho_triage_card(decision, email, channel_id, token)
     card_url = card_info[:url]
     LOG.info "[Zoho:Triage] Created card ##{card_number}: #{title}"
 
-    # Notify Discord
-    if channel_id && token
-      msg = "🎫 **Support Card Created: [##{card_number}](#{card_url})**\n"
-      msg += "**Title:** #{title}\n"
-      msg += "**Assigned to:** #{decision["assign_to"] || "unassigned"}\n"
-      msg += "**Tags:** #{tags.join(", ")}\n"
-      msg += "**From:** #{email["fromAddress"]}"
-      send_discord_message(channel_id, msg, token: token)
-    end
+    # Notify configured channel
+    msg = "🎫 **Support Card Created: [##{card_number}](#{card_url})**\n"
+    msg += "**Title:** #{title}\n"
+    msg += "**Assigned to:** #{decision["assign_to"] || "unassigned"}\n"
+    msg += "**Tags:** #{tags.join(", ")}\n"
+    msg += "**From:** #{email["fromAddress"]}"
+    send_notification(:zoho_triage, msg, channel: notify_channel, target: channel_id, agent: bot_name)
   else
     LOG.warn "[Zoho:Triage] No work item plugin handled card creation"
     notify_zoho_match(email, { "label" => "Support Email (no card plugin)", "emoji" => "⚠️" }.merge(rule_defaults(nil)))

data/lib/brainiac/helpers.rb

@@ -186,17 +186,17 @@ def notify_agent_crash(exit_status:, log_file:, agent_name:, source:, source_con
   snippet = extract_crash_snippet(log_file)
   snippet_block = snippet ? "\n```\n#{snippet[-1500..]}\n```" : ""
 
-  # Try plugin-registered crash handlers first
+  # Emit to plugins — they handle their own channel-specific delivery
   handled = Brainiac.emit(:agent_crashed,
                           exit_status: exit_status, log_file: log_file, agent_name: agent_display,
                           source: source, source_context: source_context, project_config: project_config,
                           snippet: snippet)
 
-  # If a plugin handled it for this source, we're done
-  return if handled.any?(source)
+  # If a plugin handled it, we're done
+  return if handled.any?
 
-  case source
-  when :github
+  # Built-in: GitHub crash comment (doesn't need a plugin)
+  if source == :github
     pr_number = source_context[:pr_number]
     repo_name = source_context[:repo_name]
     return unless pr_number && repo_name
@@ -209,16 +209,6 @@ def notify_agent_crash(exit_status:, log_file:, agent_name:, source:, source_con
     rescue StandardError => e
       LOG.error "[CrashNotify] Failed to post GitHub crash comment: #{e.message}"
     end
-
-  when :discord
-    channel_id = source_context[:channel_id]
-    message_id = source_context[:message_id]
-    bot_token = source_context[:bot_token]
-    return unless channel_id && bot_token
-
-    message = "💥 **#{agent_display} crashed** (exit code #{exit_status})\nLog: `#{log_file}`#{snippet_block}"
-    send_discord_message(channel_id, message, token: bot_token, reply_to: message_id)
-    LOG.info "[CrashNotify] Posted crash message to Discord channel #{channel_id}"
   end
 rescue StandardError => e
   LOG.error "[CrashNotify] Unexpected error: #{e.message}"
@@ -358,7 +348,7 @@ def handle_agent_completion(**ctx)
   end
 
   brain_push(message: "#{ctx[:agent_config_name] || "agent"}: #{ctx[:log_name]}")
-  check_brainiac_restart(ctx[:head_before], ctx[:status_before], ctx[:chdir], ctx[:project_key_for_restart], ctx[:agent_config_name])
+  # check_brainiac_restart(ctx[:head_before], ctx[:status_before], ctx[:chdir], ctx[:project_key_for_restart], ctx[:agent_config_name])
 end
 
 def check_brainiac_restart(head_before, status_before, chdir, project_key_for_restart, agent_config_name)