brainiac 0.0.11 → 0.0.13

data/bin/brainiac

@@ -912,46 +912,85 @@ when "setup"
     end
   end
 
-  # Handler configuration
-  brainiac_config_path = File.join(BRAINIAC_DIR, "brainiac.json")
+  # Agent setup — agents.json is the authority
+  agents_file = File.join(BRAINIAC_DIR, "agents.json")
+  existing_agents = if File.exist?(agents_file)
+                      registry = JSON.parse(File.read(agents_file))
+                      registry.keys
+                    else
+                      []
+                    end
+
   puts ""
-  if File.exist?(brainiac_config_path)
-    puts "✓ Handler config already exists at ~/.brainiac/brainiac.json"
+  if existing_agents.empty?
+    puts "No agents found in ~/.brainiac/agents.json"
+    print "Create your first agent? Name: "
+    agent_name = $stdin.gets&.strip
+    if agent_name && !agent_name.empty?
+      agent_key = agent_name.downcase.gsub(/[^a-z0-9-]/, "-")
+      registry = { agent_key => { "display_name" => agent_name, "local" => true, "env" => {} } }
+      File.write(agents_file, JSON.pretty_generate(registry))
+      puts "✓ Created #{agents_file} with agent '#{agent_name}'"
+      existing_agents = [agent_key]
+    else
+      agent_name = nil
+      puts "  Skipped — add agents to ~/.brainiac/agents.json later"
+    end
   else
-    puts "Which integrations do you want to enable?"
-    puts "(You can change this later in ~/.brainiac/brainiac.json)"
-    puts ""
-
-    available_handlers = {
-      "github" => "GitHub (PR reviews, CI failure handling, deploy tracking)",
-      "zoho" => "Zoho Mail (email notifications and triage)"
-    }
+    puts "Found #{existing_agents.size} agent(s): #{existing_agents.join(", ")}"
+  end
 
-    enabled_handlers = {}
-    available_handlers.each do |key, description|
-      print "  Enable #{description}? [Y/n] "
-      answer = $stdin.gets&.strip&.downcase
-      enabled_handlers[key] = answer != "n"
+  # Default agent selection
+  brainiac_config_path = File.join(BRAINIAC_DIR, "brainiac.json")
+  puts ""
+  if File.exist?(brainiac_config_path)
+    current = begin
+      JSON.parse(File.read(brainiac_config_path)).fetch("default_agent", nil)
+    rescue StandardError
+      nil
     end
-
-    config = { "handlers" => enabled_handlers }
+    puts "✓ Config already exists at ~/.brainiac/brainiac.json (default_agent: #{current})"
+  else
+    default_agent = if existing_agents.size == 1
+                      name = existing_agents.first
+                      # Look up display name if available
+                      display = begin
+                        JSON.parse(File.read(agents_file)).dig(name, "display_name") || name.capitalize
+                      rescue StandardError
+                        name.capitalize
+                      end
+                      print "Set #{display} as default agent? [Y/n] "
+                      answer = $stdin.gets&.strip&.downcase
+                      answer == "n" ? nil : display
+                    elsif existing_agents.size > 1
+                      puts "Choose default agent:"
+                      display_names = existing_agents.map do |key|
+                        JSON.parse(File.read(agents_file)).dig(key, "display_name") || key.capitalize
+                      rescue StandardError
+                        key.capitalize
+                      end
+                      display_names.each_with_index { |a, i| puts "  #{i + 1}) #{a}" }
+                      print "Enter number [1]: "
+                      choice = $stdin.gets&.strip
+                      idx = choice.to_i - 1
+                      idx = 0 if idx.negative? || idx >= display_names.size
+                      display_names[idx]
+                    else
+                      agent_name
+                    end
+
+    default_agent ||= existing_agents.first&.capitalize
+    config = { "default_agent" => default_agent }
     File.write(brainiac_config_path, JSON.pretty_generate(config))
-    puts ""
-    puts "✓ Wrote handler config to ~/.brainiac/brainiac.json"
-
-    enabled_list = enabled_handlers.select { |_, v| v }.keys
-    disabled_list = enabled_handlers.reject { |_, v| v }.keys
-    puts "  Enabled: #{enabled_list.join(", ")}" if enabled_list.any?
-    puts "  Disabled: #{disabled_list.join(", ")}" if disabled_list.any?
+    puts "✓ Wrote config to ~/.brainiac/brainiac.json (default_agent: #{default_agent})"
   end
 
   puts ""
   puts "Next steps:"
-  puts "  1. Edit config files in ~/.brainiac/ with your secrets and IDs"
-  puts "  2. Create agent configs in ~/.kiro/agents/"
-  puts "  3. Register projects: cd ~/Code/myproject && brainiac register"
-  puts "  4. Initialize brain: brainiac brain init"
-  puts "  5. Start server: brainiac server"
+  puts "  1. Register projects: cd ~/Code/myproject && brainiac register"
+  puts "  2. Initialize brain: brainiac brain init"
+  puts "  3. Install plugins: brainiac install discord / fizzy / github / zoho"
+  puts "  4. Start server: brainiac server"
 
   # Shell completion setup
   puts ""
@@ -1054,64 +1093,6 @@ when "show"
   end
   show_project(ARGV[0])
 
-when "handler", "handlers"
-  handler_cmd = ARGV.shift
-  case handler_cmd
-  when "list", "ls", nil
-    brainiac_config_path = File.join(BRAINIAC_DIR, "brainiac.json")
-    config = if File.exist?(brainiac_config_path)
-               JSON.parse(File.read(brainiac_config_path))
-             else
-               {}
-             end
-    handlers = config["handlers"] || {}
-
-    # Built-in handlers
-    builtins = %w[github zoho]
-    puts "Built-in handlers:"
-    builtins.each do |name|
-      enabled = handlers.fetch(name, true)
-      status = enabled ? "✓ enabled" : "✗ disabled"
-      puts "  #{name.ljust(10)} #{status}"
-    end
-
-    # Custom handlers
-    custom_dir = File.join(BRAINIAC_DIR, "handlers")
-    if Dir.exist?(custom_dir)
-      custom_files = Dir.glob(File.join(custom_dir, "*.rb"))
-      if custom_files.any?
-        puts ""
-        puts "Custom handlers (#{custom_dir}):"
-        custom_files.each do |f|
-          name = File.basename(f, ".rb")
-          enabled = handlers.fetch(name, true)
-          status = enabled ? "✓ enabled" : "✗ disabled"
-          puts "  #{name.ljust(10)} #{status}"
-        end
-      end
-    end
-
-  when "enable"
-    name = ARGV.shift
-    unless name
-      puts "Usage: brainiac handler enable <name>"
-      exit 1
-    end
-    update_handler_config(name, true)
-
-  when "disable"
-    name = ARGV.shift
-    unless name
-      puts "Usage: brainiac handler disable <name>"
-      exit 1
-    end
-    update_handler_config(name, false)
-
-  else
-    puts "Usage: brainiac handler <list|enable|disable> [name]"
-    exit 1
-  end
-
 when "config"
   OptionParser.new do |opts|
     opts.banner = "Usage: brainiac config [options]"
@@ -1322,8 +1303,8 @@ when "cron"
       opts.on("-p", "--project KEY", "Project key") { |v| project = v }
       opts.on("-m", "--model MODEL", "Model to use (opus, sonnet, haiku, auto)") { |v| model = v }
       opts.on("-e", "--effort LEVEL", "Effort level (low, medium, high, xhigh, max)") { |v| effort = v }
-      opts.on("-d", "--notify TARGET", "Notification target (channel ID, card number, etc.)") { |v| notify_target = v }
-      opts.on("-c", "--channel CHANNEL", "Notification channel (discord, fizzy — default: discord)") { |v| notify_channel = v }
+      opts.on("-d", "--notify TARGET", "Notification target (channel ID, webhook URL, etc.)") { |v| notify_target = v }
+      opts.on("-c", "--channel CHANNEL", "Notification channel name (provided by plugins)") { |v| notify_channel = v }
       opts.on("-t", "--title TITLE", "Forum post title (for forum channels)") { |v| forum_title = v }
       opts.on("-r", "--repeat COUNT", Integer, "Number of times to repeat (for recurring schedules)") { |v| repeat_count = v }
       opts.on("--script PATH", "Run script directly (no agent, output posted via notify)") { |v| script = v }
@@ -1366,7 +1347,6 @@ when "cron"
     payload[:script] = script if script
     payload[:model] = model if model
     payload[:effort] = effort if effort
-    payload[:discord_channel_id] = notify_target if notify_target && (!notify_channel || notify_channel == "discord")
     payload[:notify_channel] = notify_channel if notify_channel
     payload[:notify_target] = notify_target if notify_target
     payload[:forum_title] = forum_title if forum_title
@@ -1383,7 +1363,7 @@ when "cron"
         puts "  Project: #{project}"
         puts "  Model: #{model || "default"}" unless script
         puts "  Effort: #{effort || "default"}" unless script
-        puts "  Notify: #{notify_target ? "#{notify_channel || "discord"} → #{notify_target}" : "none"}"
+        puts "  Notify: #{notify_target ? "#{notify_channel || "default"} → #{notify_target}" : "none"}"
         puts "  Forum title: #{forum_title || "auto"}" if notify_target && forum_title
         puts "  Repeat: #{repeat_count ? "#{repeat_count} times" : "unlimited"}"
         puts script ? "  Script: #{script}" : "  Prompt: #{prompt}"
@@ -1428,9 +1408,9 @@ when "cron"
           puts "  #{status} #{id}"
           puts "    Schedule: #{schedule_display}"
           puts "    Agent: #{job["script"] ? "none (script mode)" : job["agent"]} | Project: #{job["project"]}"
-          notify_ch = job["notify_channel"] || (job["discord_channel_id"] ? "discord" : nil)
-          notify_tgt = job["notify_target"] || job["discord_channel_id"]
-          puts "    Notify: #{notify_ch} → #{notify_tgt}" if notify_tgt
+          notify_ch = job["notify_channel"]
+          notify_tgt = job["notify_target"]
+          puts "    Notify: #{notify_ch || "default"} → #{notify_tgt}" if notify_tgt
           puts job["script"] ? "    Script: #{job["script"]}" : "    Prompt: #{job["prompt"]}"
           puts "    Last run: #{last_run}"
           puts
@@ -1527,14 +1507,14 @@ when "cron"
       opts.banner = "Usage: brainiac cron update <job-id> [options]"
       opts.on("-s", "--schedule EXPR", "New cron expression") { |v| schedule = v }
       opts.on("-d", "--notify TARGET", "New notification target") { |v| notify_target = v }
-      opts.on("-c", "--channel CHANNEL", "New notification channel (discord, fizzy)") { |v| notify_channel = v }
+      opts.on("-c", "--channel CHANNEL", "New notification channel") { |v| notify_channel = v }
       opts.on("-t", "--title TITLE", "New forum post title") { |v| forum_title = v }
     end.parse!
 
     unless id && (schedule || notify_target || notify_channel || forum_title)
       puts "Error: Missing required arguments"
       puts "Usage: brainiac cron update <job-id> -s \"42 13 * * 1-5\""
-      puts "   or: brainiac cron update <job-id> -d \"channel-id\" -c discord"
+      puts "   or: brainiac cron update <job-id> -d \"channel-id\" -c channel-name"
       puts "   or: brainiac cron update <job-id> -t \"Daily Update\""
       exit 1
     end
@@ -1543,7 +1523,6 @@ when "cron"
     req = Net::HTTP::Post.new(uri, "Content-Type" => "application/json")
     payload = { id: id }
     payload[:schedule] = schedule if schedule
-    payload[:discord_channel_id] = notify_target if notify_target
     payload[:notify_channel] = notify_channel if notify_channel
     payload[:notify_target] = notify_target if notify_target
     payload[:forum_title] = forum_title if forum_title
@@ -1555,7 +1534,7 @@ when "cron"
       if data["success"]
         puts "✓ Updated cron job: #{id}"
         puts "  New schedule: #{schedule}" if schedule
-        puts "  New notify: #{notify_channel || "discord"} → #{notify_target}" if notify_target
+        puts "  New notify: #{notify_channel || "default"} → #{notify_target}" if notify_target
         puts "  New forum title: #{forum_title}" if forum_title
       else
         puts "Error: #{data["error"]}"
@@ -1604,7 +1583,7 @@ when "cron"
       Examples:
         # Recurring
         brainiac cron add -s "0 9 * * *" -p marketplace "Summarize yesterday's work"
-        brainiac cron add -s "@daily" -p brainiac -a GLaDOS "Run security audit"
+        brainiac cron add -s "@daily" -p brainiac -a Robin "Run security audit"
       #{"  "}
         # One-time
         brainiac cron add -s "tomorrow at 9am" -p marketplace "Reminder about priorities"
@@ -1787,10 +1766,10 @@ when "agent"
       puts "If no options are given and stdin is a terminal, interactive mode is used."
       puts ""
       puts "Examples:"
+      puts "  brainiac agent create MyAgent   # interactive"
       puts "  brainiac agent create SecurityBot --local --role code-reviewer"
       puts "  brainiac agent create Jane --role general-engineer --cli grok"
-      puts "  brainiac agent create Avon --persona \"Dry wit, sardonic, brilliant\""
-      puts "  brainiac agent create MyAgent   # interactive"
+      puts "  brainiac agent create Merlin --persona \"Wise, enigmatic, helpful\""
       exit 1
     end
 
@@ -1941,16 +1920,16 @@ when "agent"
 
       Examples:
         brainiac agent list
-        brainiac agent default Galen
+        brainiac agent default Sherlock
         brainiac agent create SecurityBot --local --role code-reviewer
         brainiac agent create Jane --cli grok
         brainiac agent create MyAgent             # interactive mode
         brainiac agent remove SecurityBot
-        brainiac agent galen set local true
-        brainiac agent galen set persona "Dry, sardonic"
-        brainiac agent galen set role code-reviewer,general-engineer
-        brainiac agent galen env MY_TOKEN abc123
-        brainiac agent galen show
+        brainiac agent sherlock set local true
+        brainiac agent sherlock set persona "Dry, sardonic"
+        brainiac agent sherlock set role code-reviewer,general-engineer
+        brainiac agent sherlock env MY_TOKEN abc123
+        brainiac agent sherlock show
     HELP
 
   else
@@ -2295,7 +2274,7 @@ when "update", "upgrade"
 
     plugin_entry = (plugins_config["plugins"] || []).find { |p| (p.is_a?(Hash) ? p["name"] : p.to_s) == name }
 
-    if plugin_entry && plugin_entry.is_a?(Hash) && plugin_entry["path"]
+    if plugin_entry.is_a?(Hash) && plugin_entry["path"]
       puts "Plugin '#{name}' is installed from a local path: #{plugin_entry["path"]}"
       puts "Local plugins are updated via git pull in their source directory."
       exit 0

data/brainiac.gemspec

@@ -3,9 +3,10 @@ require_relative "lib/brainiac/version"
 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 GitHub and Zoho Mail events, then dispatches work to AI agent CLIs. " \
-                  "Additional channels (Discord, Fizzy) available via plugins."
+  s.summary     = "Multi-agent orchestration layer for developer workflows"
+  s.description = "Core orchestration engine that manages AI agent identity, long-term memory (brain), " \
+                  "prompt construction, and dispatch. Communication channels are provided by plugins: " \
+                  "brainiac-discord, brainiac-fizzy, brainiac-github, and more."
   s.authors     = ["Andy Davis"]
   s.homepage    = "https://github.com/stowzilla/brainiac"
   s.license     = "MIT"

data/docs/waybar-config.md

@@ -10,39 +10,19 @@ This file configures how agents appear in the status bar — waybar on Linux, xb
 {
   "agents": [
     {
-      "name": "GLaDOS",
-      "emoji": "🤖",
-      "color": "blue"
-    },
-    {
-      "name": "Galen",
-      "emoji": "🛠️",
+      "name": "Sherlock",
+      "emoji": "🔍",
       "color": "green"
     },
     {
-      "name": "Threepio",
-      "emoji": "📝",
-      "color": "yellow"
+      "name": "Robin",
+      "emoji": "🏹",
+      "color": "blue"
     },
     {
-      "name": "Sheogorath",
-      "emoji": "🎭",
+      "name": "Merlin",
+      "emoji": "🧙",
       "color": "purple"
-    },
-    {
-      "name": "Kaylee",
-      "emoji": "🔧",
-      "color": "pink"
-    },
-    {
-      "name": "Avon",
-      "emoji": "🔐",
-      "color": "red"
-    },
-    {
-      "name": "Sleeper Service",
-      "emoji": "💤",
-      "color": "cyan"
     }
   ],
   "default_emoji": "❓",

data/lib/brainiac/agents.rb

@@ -6,12 +6,12 @@
 # environment variable can be set per-agent:
 #
 #   {
-#     "galen": {
-#       "display_name": "Galen",
+#     "sherlock": {
+#       "display_name": "Sherlock",
 #       "local": true,
 #       "env": {
 #         "SOME_TOKEN": "token_abc...",
-#         "DISCORD_BOT_TOKEN": "Bot_abc..."
+#         "OTHER_TOKEN": "Bot_abc..."
 #       }
 #     }
 #   }
@@ -71,7 +71,7 @@ def agent_env_var(agent_name, var_name)
 end
 
 # Get the display name for an agent (from agents.json registry).
-# This is the human-readable canonical name (e.g., "GLaDOS" not "glados").
+# This is the human-readable canonical name (e.g., "Robin" not "robin").
 # Core owns this — it's the identity used across all channels and plugins.
 def agent_display_name(agent_name)
   return agent_name unless agent_name
@@ -173,7 +173,7 @@ def detect_mentioned_agent(text)
   all_agent_names.each do |name|
     return name if downcased.include?("@#{name.downcase}")
 
-    # Some systems render mentions using first name only (e.g. "@Sleeper" not "@Sleeper Service").
+    # Some systems render mentions using first name only (e.g. "@Robin" not "@Robin Hood").
     # Fall back to matching the first word of multi-word agent names.
     first_word = name.split.first.downcase
     next if first_word == name.downcase # already checked above

data/lib/brainiac/config.rb

@@ -5,6 +5,7 @@ require "openssl"
 require "open3"
 require "fileutils"
 require "logger"
+require "securerandom"
 require "net/http"
 require "uri"
 
@@ -46,15 +47,6 @@ AI_AGENT_NAME = ENV.fetch("AI_AGENT_NAME", nil) || BRAINIAC_CONFIG["default_agen
   MSG
 end
 
-# Check whether a handler is enabled. Defaults to true when brainiac.json
-# doesn't exist or doesn't list the handler (backwards compatible — all on).
-def handler_enabled?(name)
-  handlers = BRAINIAC_CONFIG["handlers"]
-  return true unless handlers # No config = everything enabled
-
-  handlers.fetch(name.to_s, true)
-end
-
 LOG_LEVEL = ENV.fetch("LOG_LEVEL", "info").downcase
 LOG = Logger.new($stdout)
 LOG.level = case LOG_LEVEL
@@ -78,26 +70,6 @@ KNOWLEDGE_COLLECTION = "brainiac-knowledge"
 
 ROLES_DIR = File.join(BRAINIAC_DIR, "roles")
 
-# --- GitHub auth ---
-
-GITHUB_CONFIG_FILE = File.join(BRAINIAC_DIR, "github.json")
-
-def load_github_config
-  return {} unless File.exist?(GITHUB_CONFIG_FILE)
-
-  JSON.parse(File.read(GITHUB_CONFIG_FILE))
-rescue JSON::ParserError => e
-  LOG.error "Failed to parse GitHub config: #{e.message}"
-  {}
-end
-
-GITHUB_CONFIG = load_github_config
-
-def github_webhook_secret
-  # Fallback to env var
-  GITHUB_CONFIG["webhook_secret"] || ENV.fetch("GITHUB_WEBHOOK_SECRET", nil)
-end
-
 NOTIFICATION_COMMAND = ENV.fetch("NOTIFICATION_COMMAND", nil)
 
 # --- Projects ---
@@ -137,13 +109,6 @@ def reload_projects!(force: false)
   LOG.info "Reloaded projects configuration: #{PROJECTS.keys.join(", ")}"
 end
 
-def reload_github_config!(force: false)
-  return unless file_changed?(GITHUB_CONFIG_FILE, force: force)
-
-  GITHUB_CONFIG.replace(load_github_config)
-  LOG.info "Reloaded GitHub configuration"
-end
-
 PROJECTS = load_projects_config
 
 DEFAULT_PROJECT = {

data/lib/brainiac/cron.rb

@@ -199,17 +199,14 @@ def reload_cron_jobs!(force: false)
 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,
+def add_cron_job(id:, schedule:, agent:, project:, prompt: nil, script: nil, enabled: true, model: nil, effort: 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
+  return { error: "notify_target requires notify_channel (e.g. -c discord)" } if notify_target && !notify_channel
 
   job = {
     id: id,
@@ -224,7 +221,6 @@ def add_cron_job(id:, schedule:, agent:, project:, prompt: nil, script: nil, ena
     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,
     repeat_count: repeat_count,
@@ -269,9 +265,9 @@ def toggle_cron_job(id, enabled)
   end
 end
 
-# Update a cron job's schedule, discord channel, and/or forum title
-def update_cron_job(id, schedule: nil, discord_channel_id: nil, forum_title: nil, forum_reply_to_latest: nil)
-  return { error: "No updates provided" } if schedule.nil? && discord_channel_id.nil? && forum_title.nil? && forum_reply_to_latest.nil?
+# Update a cron job's schedule, notification target, and/or forum title
+def update_cron_job(id, schedule: nil, notify_target: nil, notify_channel: nil, forum_title: nil, forum_reply_to_latest: nil)
+  return { error: "No updates provided" } if schedule.nil? && notify_target.nil? && forum_title.nil? && forum_reply_to_latest.nil?
 
   if schedule
     parsed = parse_cron_expression(schedule)
@@ -287,7 +283,8 @@ def update_cron_job(id, schedule: nil, discord_channel_id: nil, forum_title: nil
       job[:schedule] = schedule
       job[:parsed] = parsed
     end
-    job[:discord_channel_id] = discord_channel_id if discord_channel_id
+    job[:notify_target] = notify_target if notify_target
+    job[:notify_channel] = notify_channel if notify_channel
     job[:forum_title] = forum_title if forum_title
     job[:forum_reply_to_latest] = forum_reply_to_latest unless forum_reply_to_latest.nil?
     jobs[id.to_sym] = job
@@ -315,7 +312,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_notification_draft(job, timestamp) if job[:notify_target] || job[:discord_channel_id]
+  draft_file = prepare_script_notification_draft(job, timestamp) if job[:notify_target]
 
   LOG.info "[Cron] Running script #{script_path} for job #{job[:id]}, tail -f #{log_file}"
 
@@ -343,8 +340,8 @@ def prepare_script_notification_draft(job, timestamp)
 
   script_agent_key = job[:agent]&.downcase&.gsub(/[^a-z0-9-]/, "-")
   meta = {
-    notify_channel: (job[:notify_channel] || "discord").to_s,
-    notify_target: job[:notify_target] || job[:discord_channel_id],
+    notify_channel: job[:notify_channel]&.to_s,
+    notify_target: job[:notify_target],
     agent_key: script_agent_key,
     agent_name: job[:agent] || "Script",
     cron_job_id: job[:id],
@@ -361,9 +358,10 @@ 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]
+  has_notify = job[:notify_target]
 
   if has_notify && draft_file && !output.empty?
+    LOG.warn "[Cron] Job #{job[:id]} has notify_target but no notify_channel — notification may not be delivered" unless job[:notify_channel]
     File.write(draft_file, output)
     # Deliver via notification system
     notify_cron_output(job, output, agent_name: job[:agent])
@@ -380,7 +378,7 @@ 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]
+  has_notify = job[:notify_target]
 
   if has_notify
     notify_dir = File.join(BRAINIAC_DIR, "tmp", "notify", "draft")
@@ -389,8 +387,8 @@ def build_cron_prompt(job, project)
     meta_file = "#{draft_file}.meta.json"
 
     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]
+    notify_channel = job[:notify_channel]&.to_s
+    notify_target = job[:notify_target]
 
     meta = {
       notify_channel: notify_channel,

data/lib/brainiac/handlers/shared/inline_tags.rb

@@ -3,7 +3,8 @@
 # Shared inline tag parsing for handler messages.
 #
 # Messages from any channel can contain inline tags like:
-#   [project:my-project], [opus], [effort:high], [cli:grok], [chat], [plan]
+#   [project:my-project], [opus], [effort:high], [cli:grok], [chat], [plan],
+#   [branch:feature-xyz], [workitem:wi-abc123]
 #
 # This module provides a single parser that extracts all tags and returns
 # a structured result with the cleaned text.
@@ -31,9 +32,21 @@ def parse_inline_tags(text)
     planning: false,
     deploy_intent: nil,
     worktree_override: nil,
+    work_item: nil,
+    branch_override: nil,
     clean_text: text.dup
   }
 
+  parse_value_tags(result)
+  parse_flag_tags(result)
+  parse_work_item_tags(result)
+  parse_model_tag(result)
+
+  result[:clean_text].strip!
+  result
+end
+
+def parse_value_tags(result)
   # [project:my-project]
   if (match = result[:clean_text].match(/\[project:(\S+)\]/i))
     result[:project] = match[1]
@@ -52,6 +65,14 @@ def parse_inline_tags(text)
     result[:clean_text].sub!(match[0], "")
   end
 
+  # [deploy] or [deploy:dev01]
+  if (match = result[:clean_text].match(/\[deploy(?::([^\]]+))?\]/i))
+    result[:deploy_intent] = match[1]&.strip&.downcase || :auto
+    result[:clean_text].sub!(match[0], "")
+  end
+end
+
+def parse_flag_tags(result)
   # [chat], [question], [?]
   if result[:clean_text].match?(/\[(chat|question|\?)\]/i)
     result[:chat_mode] = true
@@ -59,23 +80,35 @@ def parse_inline_tags(text)
   end
 
   # [plan]
-  if result[:clean_text].match?(/\[plan\]/i)
-    result[:planning] = true
-    result[:clean_text].sub!(/\[plan\]/i, "")
+  return unless result[:clean_text].match?(/\[plan\]/i)
+
+  result[:planning] = true
+  result[:clean_text].sub!(/\[plan\]/i, "")
+end
+
+def parse_work_item_tags(result)
+  # [worktree:branch-name] — legacy syntax, still supported
+  if (match = result[:clean_text].match(/\[worktree:([^\]]+)\]/))
+    result[:worktree_override] = match[1].strip
+    result[:clean_text].sub!(match[0], "")
   end
 
-  # [deploy] or [deploy:dev01]
-  if (match = result[:clean_text].match(/\[deploy(?::([^\]]+))?\]/i))
-    result[:deploy_intent] = match[1]&.strip&.downcase || :auto
+  # [branch:branch-name] — preferred syntax for targeting a branch/worktree
+  if (match = result[:clean_text].match(/\[branch:([^\]]+)\]/i))
+    result[:branch_override] = match[1].strip
+    # Also set worktree_override for backward compat with plugins that read it
+    result[:worktree_override] ||= result[:branch_override]
     result[:clean_text].sub!(match[0], "")
   end
 
-  # [worktree:branch-name]
-  if (match = result[:clean_text].match(/\[worktree:([^\]]+)\]/))
-    result[:worktree_override] = match[1].strip
+  # [workitem:wi-abc123] — target a specific work item by ID
+  if (match = result[:clean_text].match(/\[workitem:([^\]]+)\]/i))
+    result[:work_item] = match[1].strip
     result[:clean_text].sub!(match[0], "")
   end
+end
 
+def parse_model_tag(result)
   # Model tag: any remaining [word] that isn't a known tag — detected separately
   # because it depends on the project's allowed_models config. We just capture
   # the raw match here for the caller to resolve.
@@ -83,7 +116,4 @@ def parse_inline_tags(text)
     result[:model_tag] = match[1].downcase
     result[:clean_text].sub!(match[0], "")
   end
-
-  result[:clean_text].strip!
-  result
 end