brainiac 0.0.11 → 0.0.13

data/lib/brainiac/helpers.rb

@@ -112,7 +112,8 @@ end
 def load_work_item_map
   return {} unless File.exist?(WORK_ITEM_MAP_FILE)
 
-  JSON.parse(File.read(WORK_ITEM_MAP_FILE))
+  raw = JSON.parse(File.read(WORK_ITEM_MAP_FILE))
+  migrate_work_item_map(raw)
 rescue JSON::ParserError
   {}
 end
@@ -121,17 +122,164 @@ def save_work_item_map(map)
   File.write(WORK_ITEM_MAP_FILE, JSON.pretty_generate(map))
 end
 
-def slugify(title, max_length: 40)
-  title.downcase.gsub(/[^a-z0-9\s-]/, "").strip.gsub(/\s+/, "-").slice(0, max_length).chomp("-")
+# Migrate old-format work item maps (keyed by Fizzy card internal ID with flat structure)
+# to the new source-agnostic format (keyed by work item ID with sources hash).
+# Old format: { "fizzy-uuid" => { "number" => 42, "branch" => "...", "worktree" => "...", "project" => "...", "agent" => "..." } }
+# New format: { "wi-abc123" => { "id" => "wi-...", "branch" => "...", "worktree" => "...",
+#   "project" => "...", "agent" => "...", "sources" => { "fizzy" => { ... } } } }
+def migrate_work_item_map(raw)
+  return raw if raw.empty?
+
+  # Detect: if any entry has a "sources" key, it's already new format (or mixed)
+  # If none have "sources", it's entirely old format
+  needs_migration = raw.values.any? { |v| v.is_a?(Hash) && !v.key?("sources") }
+  return raw unless needs_migration
+
+  migrated = {}
+  raw.each do |key, entry|
+    next unless entry.is_a?(Hash)
+
+    if entry.key?("sources")
+      # Already new format
+      migrated[key] = entry
+    else
+      # Old format — migrate. Generate a work item ID from the branch or card number.
+      work_item_id = generate_work_item_id(branch: entry["branch"], card_number: entry["number"])
+      migrated[work_item_id] = {
+        "id" => work_item_id,
+        "branch" => entry["branch"],
+        "worktree" => entry["worktree"],
+        "project" => entry["project"],
+        "agent" => entry["agent"],
+        "sources" => {
+          "fizzy" => {
+            "card_internal_id" => key,
+            "card_number" => entry["number"]
+          }
+        }
+      }
+      # Preserve PR tracking if it exists
+      migrated[work_item_id]["sources"]["github"] = { "prs" => entry["prs"] } if entry["prs"]
+    end
+  end
+  migrated
+end
+
+# Generate a deterministic work item ID from available identifiers.
+# Priority: branch name (universal join key), then card number fallback.
+def generate_work_item_id(branch: nil, card_number: nil)
+  if branch
+    "wi-#{Digest::SHA256.hexdigest(branch)[0..7]}"
+  elsif card_number
+    "wi-card-#{card_number}"
+  else
+    "wi-#{SecureRandom.hex(4)}"
+  end
+end
+
+# Find a work item by its branch name. Returns [work_item_id, info] or nil.
+# This is the primary lookup method — branch is the universal join key.
+def find_work_item_by_branch(branch)
+  return nil unless branch
+
+  map = load_work_item_map
+  map.each do |work_item_id, info|
+    next unless info.is_a?(Hash) && info["branch"] == branch
+
+    return [work_item_id, info]
+  end
+  nil
+end
+
+# Find a work item by its ID. Returns the info hash or nil.
+def find_work_item_by_id(work_item_id)
+  return nil unless work_item_id
+
+  map = load_work_item_map
+  map[work_item_id]
+end
+
+# Find a work item by a Fizzy card internal ID (for backward compat with Fizzy plugin).
+# Returns [work_item_id, info] or nil.
+def find_work_item_by_card(card_internal_id)
+  return nil unless card_internal_id
+
+  map = load_work_item_map
+  map.each do |work_item_id, info|
+    next unless info.is_a?(Hash)
+
+    fizzy_source = info.dig("sources", "fizzy")
+    next unless fizzy_source && fizzy_source["card_internal_id"] == card_internal_id
+
+    return [work_item_id, info]
+  end
+  nil
+end
+
+# Register a new work item or update an existing one.
+# Returns the work item ID.
+def register_work_item(branch:, worktree: nil, project: nil, agent: nil, source: nil, source_data: {})
+  map = load_work_item_map
+
+  # Check if a work item already exists for this branch
+  existing_id = nil
+  map.each do |wid, info|
+    if info.is_a?(Hash) && info["branch"] == branch
+      existing_id = wid
+      break
+    end
+  end
+
+  work_item_id = existing_id || generate_work_item_id(branch: branch)
+
+  if existing_id
+    # Update existing entry — merge in new source, update worktree/agent if provided
+    map[work_item_id]["worktree"] = worktree if worktree
+    map[work_item_id]["agent"] = agent if agent
+    map[work_item_id]["sources"] ||= {}
+    map[work_item_id]["sources"][source] = source_data if source
+  else
+    # Create new entry
+    map[work_item_id] = {
+      "id" => work_item_id,
+      "branch" => branch,
+      "worktree" => worktree,
+      "project" => project,
+      "agent" => agent,
+      "sources" => source ? { source => source_data } : {}
+    }
+  end
+
+  save_work_item_map(map)
+  work_item_id
+end
+
+# Add or update a source on an existing work item.
+# Returns true if the work item was found and updated, false otherwise.
+def register_work_item_source(source:, source_data:, work_item_id: nil, branch: nil) # rubocop:disable Naming/PredicateMethod
+  map = load_work_item_map
+
+  # Find by ID or branch
+  target_id = work_item_id
+  unless target_id
+    map.each do |wid, info|
+      if info.is_a?(Hash) && info["branch"] == branch
+        target_id = wid
+        break
+      end
+    end
+  end
+
+  return false unless target_id && map[target_id]
+
+  map[target_id]["sources"] ||= {}
+  map[target_id]["sources"][source] = source_data
+  save_work_item_map(map)
+  true
 end
 
-def verify_github_signature!(request, payload_body)
-  signature = request.env["HTTP_X_HUB_SIGNATURE_256"]
-  halt 403, { error: "Missing GitHub signature" }.to_json unless signature
-  secret = github_webhook_secret
-  halt 500, { error: "GitHub webhook secret not configured" }.to_json unless secret
-  computed = "sha256=#{OpenSSL::HMAC.hexdigest("sha256", secret, payload_body)}"
-  halt 403, { error: "Invalid GitHub signature" }.to_json unless Rack::Utils.secure_compare(signature, computed)
+def slugify(title, max_length: 40)
+  title.downcase.gsub(/[^a-z0-9\s-]/, "").strip.gsub(/\s+/, "-").slice(0, max_length).chomp("-")
 end
 
 def run_cmd(*cmd, chdir:, env: {})
@@ -184,7 +332,6 @@ end
 def notify_agent_crash(exit_status:, log_file:, agent_name:, source:, source_context:, project_config:)
   agent_display = agent_name || "Agent"
   snippet = extract_crash_snippet(log_file)
-  snippet_block = snippet ? "\n```\n#{snippet[-1500..]}\n```" : ""
 
   # Emit to plugins — they handle their own channel-specific delivery
   handled = Brainiac.emit(:agent_crashed,
@@ -192,28 +339,66 @@ def notify_agent_crash(exit_status:, log_file:, agent_name:, source:, source_con
                           source: source, source_context: source_context, project_config: project_config,
                           snippet: snippet)
 
-  # If a plugin handled it, we're done
-  return if handled.any?
-
-  # 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
-
-    work_dir = source_context[:work_dir] || Dir.pwd
-    comment_body = "💥 **#{agent_display} crashed** (exit code #{exit_status})\n\nLog: `#{log_file}`#{snippet_block}"
-    begin
-      run_cmd("gh", "pr", "comment", pr_number.to_s, "--repo", repo_name, "--body", comment_body, chdir: work_dir)
-      LOG.info "[CrashNotify] Posted crash comment on GitHub PR ##{pr_number}"
-    rescue StandardError => e
-      LOG.error "[CrashNotify] Failed to post GitHub crash comment: #{e.message}"
-    end
-  end
+  # If no plugin handled it, log a warning
+  LOG.warn "[CrashNotify] Agent crashed but no plugin handled notification (source: #{source})" unless handled.any?
 rescue StandardError => e
   LOG.error "[CrashNotify] Unexpected error: #{e.message}"
 end
 
+# Check if a prior CLI session exists in the given directory for the specified CLI binary.
+# This prevents resume attempts when the CLI provider changed (e.g., [cli:grok] in a thread
+# started by kiro-cli) or when the session was started on a different machine.
+def prior_session_exists?(chdir, agent_cli)
+  return false unless chdir && agent_cli
+
+  cli_name = File.basename(agent_cli)
+
+  # Check for CLI-specific session markers:
+  # - grok uses .grok/ directory for session state
+  # - kiro-cli uses .kiro-cli/ or similar
+  # - Generic fallback: check tmp/ for agent logs from this CLI
+  session_dir = File.join(chdir, ".#{cli_name}")
+  return true if File.directory?(session_dir)
+
+  # Fallback: look for recent session logs in tmp/ that suggest this CLI ran here before.
+  # This covers CLIs that don't leave a dotdir but do leave logs via brainiac.
+  tmp_dir = File.join(chdir, "tmp")
+  return false unless File.directory?(tmp_dir)
+
+  Dir.glob(File.join(tmp_dir, "agent-*.log")).any? do |log|
+    # Only count logs from the last 24 hours as valid "resumable" sessions
+    File.mtime(log) > Time.now - 86_400
+  end
+rescue StandardError
+  false
+end
+
+# Public helper: check if resume is viable for a given project + CLI provider combo.
+# Plugins should call this BEFORE building the prompt to decide between
+# render_resume_prompt (lean) and render_prompt (full context).
+#
+# Returns true if the CLI supports resume AND a prior session exists in the working directory.
+# When this returns false, plugins should use render_prompt with thread history as card_context
+# so the agent gets full context even though this is a follow-up message.
+def resume_viable?(project_config:, cli_provider: nil, agent_name: nil, chdir: nil)
+  resolved = resolve_project_cli_config(project_config, cli_provider_override: cli_provider, agent_name: agent_name)
+  chdir ||= resolved["repo_path"]
+  return false unless resolved["resume_flag"]
+
+  prior_session_exists?(chdir, resolved["agent_cli"])
+end
+
+# Determine whether a session resume should actually happen.
+# Returns truthy (the resume flag string) if viable, false otherwise.
+# Logs a message when resume was requested but isn't possible.
+def resolve_resume(resume, resolved, chdir)
+  return false unless resume && resolved["resume_flag"]
+  return resolved["resume_flag"] if prior_session_exists?(chdir, resolved["agent_cli"])
+
+  LOG.info "[Dispatch] Resume requested but not viable for #{resolved["agent_cli"]} in #{chdir} — starting fresh session"
+  false
+end
+
 def run_agent(prompt, project_config:, chdir: nil, log_name: "agent", model: nil, effort: nil, agent_name: nil, card_number: nil, comment_id: nil,
               source: nil, source_context: {}, skip_column_move: false, cli_provider: nil, resume: false)
   resolved = resolve_project_cli_config(project_config, cli_provider_override: cli_provider, agent_name: agent_name)
@@ -222,9 +407,8 @@ def run_agent(prompt, project_config:, chdir: nil, log_name: "agent", model: nil
   effort ||= resolved["agent_effort"]
   agent_config_name = agent_name&.downcase&.gsub(/[^a-z0-9-]/, "-")
 
-  # Auto-resume: if the provider supports session resume and we're in a worktree
-  # that has had a previous session, resume it. Only applies to follow-ups (not first dispatch).
-  should_resume = resume && resolved["resume_flag"]
+  # Auto-resume: only if the provider supports it AND a prior session exists for this CLI here.
+  should_resume = resolve_resume(resume, resolved, chdir)
 
   # Pre-dispatch hook — plugins can prep the working directory (e.g., copy config files, clean up)
   Brainiac.emit(:pre_dispatch, chdir: chdir, project_config: project_config, agent_name: agent_name)

data/lib/brainiac/hooks.rb

@@ -22,7 +22,7 @@
 #   end
 #
 # Usage (in core):
-#   Brainiac.emit(:agent_completed, card_number: 42, agent_name: "Galen", ...)
+#   Brainiac.emit(:agent_completed, card_number: 42, agent_name: "Sherlock", ...)
 
 module Brainiac
   @hooks = Hash.new { |h, k| h[k] = [] }

data/lib/brainiac/notifications.rb

@@ -77,8 +77,8 @@ end
 # Convenience: send a notification for cron job output.
 def notify_cron_output(job, message, agent_name: nil)
   send_notification(:cron, message,
-                    target: job[:notify_target] || job[:discord_channel_id],
-                    channel: job[:notify_channel] || (job[:discord_channel_id] ? :discord : nil),
+                    target: job[:notify_target],
+                    channel: job[:notify_channel],
                     agent: agent_name || job[:agent],
                     job_id: job[:id],
                     forum_title: job[:forum_title],

data/lib/brainiac/prompts.rb

@@ -4,7 +4,7 @@
 #
 # Prompts are layered:
 #   PROMPT_CORE            — universal (identity, memory, brain, reflection)
-#   PROMPT_GITHUB_CHANNEL  — GitHub-specific rules (GFM, PR conventions)
+#   (GitHub prompts extracted to brainiac-github plugin)
 #
 # Each handler composes: PROMPT_CORE + channel rules + situation template.
 # Channel-specific prompts (Discord, Fizzy, etc.) are registered by plugins.
@@ -112,7 +112,7 @@ PROMPT_CORE = <<~PROMPT
   - Be specific in your query — tell the subagent exactly what to find and where to look
   - Include relevant file paths and repo locations in the query
   - Use `relevant_context` to pass information the subagent needs
-  - You can specify `agent_name` to use a specialized agent (e.g., "sheogorath" for Android research)
+  - You can specify `agent_name` to use a specialized agent (e.g., "robin" for Android research)
   - Run `ListAgents` first if you want to see available specialized agents
   - Up to 4 subagents can run in parallel
   - To discover project locations for cross-repo work, run: `brainiac list`
@@ -122,37 +122,11 @@ PROMPT_CORE = <<~PROMPT
   They're excellent researchers — use them as such.
 
   ## Image Reading Limits
-  Read at most 4–5 images per tool call. Summarize what you saw before reading more.
+  Read at most 4-5 images per tool call. Summarize what you saw before reading more.
   Loading too many images at once can exceed the API request size limit and crash your session.
 
 PROMPT
 
-# ---------------------------------------------------------------------------
-# PROMPT_PRE_POST_CHECK — inserted before PROMPT_REFLECTION so the agent
-# re-checks for new comments/messages before posting its response.
-# Channel-specific: plugins register pre-post checks, Discord skips.
-# ---------------------------------------------------------------------------
-
-PROMPT_PRE_POST_CHECK_GITHUB = <<~PROMPT
-  ## Pre-Post Comment Check (MANDATORY — do this BEFORE posting your comment)
-
-  Your session may have been running for a while. Before you post your final comment,
-  re-check the PR for new comments that arrived while you were working:
-
-  ```bash
-  gh pr view {{PR_NUMBER}} --comments --json comments
-  ```
-
-  If there are **new comments** that weren't in your original context:
-
-  1. **Read them carefully** — a reviewer may have added feedback or changed direction
-  2. **Adjust your work or response** to account for the new information
-  3. **Do NOT ignore new comments** — avoid posting a response that's already outdated
-
-  If no new comments appeared, proceed normally.
-
-PROMPT
-
 # ---------------------------------------------------------------------------
 # PROMPT_REFLECTION — appended AFTER the situation template so the agent
 # sees its task first and reflects only after completing it.
@@ -186,78 +160,13 @@ PROMPT_REFLECTION = <<~PROMPT
 
 PROMPT
 
-# ---------------------------------------------------------------------------
-# PROMPT_GITHUB_CHANNEL — GitHub-specific rules, prepended to GitHub templates
-# ---------------------------------------------------------------------------
-PROMPT_GITHUB_CHANNEL = <<~PROMPT
-  ## GitHub Channel Rules
-
-  ### Formatting
-  Use GitHub-Flavored Markdown for all comments:
-  - `## Heading` for sections
-  - `**bold**` for emphasis
-  - ``` ```language ``` for code blocks
-  - `- item` for lists
-
-  ### Scope
-  You are responding to activity on a GitHub PR. Focus on the code changes and review feedback.
-  When posting comments, post on the PR unless specifically asked to update the card.
-
-PROMPT
-
-PROMPT_GITHUB_PR_COMMENT = <<~'PROMPT'
-  There's a new comment from @{{COMMENT_CREATOR}} on your PR #{{PR_NUMBER}} for card #{{CARD_NUMBER}}.
-
-  Comment:
-  {{COMMENT_BODY}}
-
-  Please:
-  1. Read the comment and understand what's being requested
-  2. Make any necessary changes
-  3. Commit and push your updates
-  4. Reply on the PR summarizing what you changed
-
-  You are in the worktree at {{WORKTREE_PATH}}.
-PROMPT
-
-PROMPT_GITHUB_PR_REVIEW = <<~'PROMPT'
-  A code review has been submitted on your PR #{{PR_NUMBER}} for card #{{CARD_NUMBER}}.
-
-  {{REVIEW_CONTEXT}}
-
-  Please:
-  1. Read the review comments carefully
-  2. Address each piece of feedback
-  3. Make the necessary code changes
-  4. Commit and push your updates
-  5. Post a comment on the PR summarizing the changes
-
-  You are in the worktree at {{WORKTREE_PATH}}.
-PROMPT
-
 # ---------------------------------------------------------------------------
 # Channel constant mapping for render_prompt
+# NOTE: GitHub prompts have been extracted to brainiac-github plugin.
+#       The plugin registers via Brainiac.register_channel_prompt(:github, ...)
 # ---------------------------------------------------------------------------
-PROMPT_GITHUB_UAT = <<~'PROMPT'
-  PR #{{PR_NUMBER}} has been merged into main for card #{{CARD_NUMBER}}: "{{CARD_TITLE}}"
 
-  The card has been moved to the UAT column. The changes are now deployed to the UAT environment.
-
-  Your job: post a comment on card #{{CARD_NUMBER}} with clear, specific steps for how to manually test this feature in UAT. Include:
-  1. What URL(s) or screen(s) to visit
-  2. Step-by-step actions to verify the feature works
-  3. What the expected behavior should be
-  4. Any edge cases worth checking
-  5. Links to relevant pages if applicable (use the UAT/staging URL, not localhost)
-
-  Base your testing steps on the card title, the PR diff, and any card context provided. Be specific — "verify it works" is not a testing step.
-
-  Do NOT make any code changes. This is a read-only review task.
-PROMPT
-
-CHANNEL_PROMPTS = {
-  github: PROMPT_GITHUB_CHANNEL
-}.freeze
+CHANNEL_PROMPTS = {}.freeze
 
 # ---------------------------------------------------------------------------
 # render_prompt — composes PROMPT_CORE + channel rules + situation template
@@ -266,7 +175,7 @@ CHANNEL_PROMPTS = {
 # ---------------------------------------------------------------------------
 
 # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-def render_prompt(template, vars = {}, brain_context: "", card_context: "", agent_name: AI_AGENT_NAME, channel: :discord, board_key: nil)
+def render_prompt(template, vars = {}, brain_context: "", card_context: "", agent_name: AI_AGENT_NAME, channel: nil, board_key: nil)
   result = ""
   result += "#{brain_context}\n" unless brain_context.empty?
   result += card_context unless card_context.empty?
@@ -278,16 +187,12 @@ def render_prompt(template, vars = {}, brain_context: "", card_context: "", agen
 
   result += template
 
-  # Pre-post comment check: plugin-registered or built-in
+  # Pre-post comment check: plugin-registered
   plugin_pre_post = Brainiac.channel_pre_post_checks[channel]
-  if plugin_pre_post
-    result += plugin_pre_post
-  elsif channel == :github
-    result += PROMPT_PRE_POST_CHECK_GITHUB
-  end
+  result += plugin_pre_post if plugin_pre_post
 
-  # Reflection prompt — skip for Discord (causes crashes in post-task phase)
-  result += PROMPT_REFLECTION unless channel == :discord
+  # Reflection prompt — skip for now
+  # result += PROMPT_REFLECTION
 
   vars["KNOWLEDGE_DIR"] ||= KNOWLEDGE_DIR
   vars["MEMORY_DIR"] ||= memory_dir_for(agent_name)
@@ -345,30 +250,3 @@ def render_resume_prompt(comment_body:, comment_creator:, comment_id:, card_numb
 
   lines.join("\n")
 end
-
-# Lean resume prompt for Discord threads. The previous session has full context
-# (role, persona, knowledge, instructions). We only send the new message + channel history.
-def render_discord_resume_prompt(message_body:, discord_user:, response_file:, agent_name: AI_AGENT_NAME, card_id: nil)
-  memory_dir = memory_dir_for(agent_name)
-  if card_id
-    memory_file = File.join(memory_dir, "card-#{card_id}.md")
-    FileUtils.mkdir_p(memory_dir)
-    FileUtils.touch(memory_file)
-  end
-
-  lines = []
-  lines << "## Resumed Session — New Discord Message"
-  lines << ""
-  lines << "This is a continuation of your previous session in this thread."
-  lines << "All prior context, instructions, and your previous work are still in this conversation."
-  lines << ""
-  lines << "### New Message from #{discord_user}"
-  lines << ""
-  lines << message_body
-  lines << ""
-  lines << "---"
-  lines << "**IMPORTANT: Write your response to `#{response_file}`. Do NOT reply via stdout.**"
-  lines << "All your previous instructions still apply (memory, persona, one message per session, etc.)."
-
-  lines.join("\n")
-end

data/lib/brainiac/restart.rb

@@ -5,9 +5,6 @@
 # When an agent works on brainiac itself (modifies code), a restart is queued.
 # A background thread checks every 30s and only restarts when no other agents
 # are running, preventing mid-session kills.
-#
-# This is NOT Discord-specific — it was previously in the Discord handler
-# because Discord agents trigger restarts most often, but any source can queue one.
 
 BRAINIAC_RESTART_STATE = { queued: false, triggered_by: nil }
 BRAINIAC_RESTART_MUTEX = Mutex.new

data/lib/brainiac/routes/api.rb

@@ -30,16 +30,10 @@ def format_active_sessions
   end
 end
 
-def resolve_session_agent_name(card_key, info)
+def resolve_session_agent_name(_card_key, info)
   return info[:agent_name] if info[:agent_name]
 
-  parts = card_key.split("-")
-  agent_key = if parts[0] == "discord" && parts.size >= 4
-                parts[1]
-              else
-                "Unknown"
-              end
-  agent_display_name(agent_key)
+  agent_display_name("Unknown")
 end
 
 def format_recent_sessions
@@ -70,20 +64,6 @@ rescue Errno::EPERM
   halt 403, { error: "permission denied" }.to_json
 end
 
-def search_giphy(query, api_key)
-  uri = URI("https://api.giphy.com/v1/gifs/search")
-  uri.query = URI.encode_www_form(api_key: api_key, q: query, limit: 5, rating: "pg-13")
-  response = Net::HTTP.get_response(uri)
-
-  if response.code.to_i == 200
-    results = JSON.parse(response.body)["data"] || []
-    results.map { |g| { url: g.dig("images", "original", "url") || g["url"], title: g["title"] } }
-  else
-    LOG.warn "[GIF] Giphy API returned #{response.code}: #{response.body[0..200]}"
-    nil
-  end
-end
-
 # --- Projects ---
 
 get "/api/projects" do
@@ -108,7 +88,6 @@ post "/api/reload" do
   reload_projects!(force: true)
   reload_agent_registry!(force: true)
   reload_user_registry!(force: true)
-  reload_github_config!(force: true)
   ReloadHooks.run_all!
   { status: "reloaded", projects: PROJECTS.keys, agents: all_agent_names.to_a, registry: AGENT_REGISTRY.keys,
     users: USER_REGISTRY["users"].size }.to_json
@@ -283,13 +262,6 @@ get "/api/logs" do
   all_lines.join.gsub(/\e\[[\d;]*[a-zA-Z]/, "").gsub(/\e\[\?[\d;]*[a-zA-Z]/, "")
 end
 
-# --- GIF (handled by discord plugin when installed) ---
-
-get "/api/gif" do
-  content_type :json
-  halt 503, { error: "brainiac-discord plugin not installed (provides GIF API)" }.to_json
-end
-
 # --- Cron ---
 
 get "/api/cron/script" do
@@ -332,7 +304,8 @@ post "/api/cron/add" do
     script: payload["script"],
     model: payload["model"],
     effort: payload["effort"],
-    discord_channel_id: payload["discord_channel_id"],
+    notify_channel: payload["notify_channel"],
+    notify_target: payload["notify_target"],
     forum_title: payload["forum_title"],
     forum_reply_to_latest: payload["forum_reply_to_latest"] || false,
     repeat_count: payload["repeat_count"]
@@ -367,7 +340,8 @@ post "/api/cron/update" do
   result = update_cron_job(
     payload["id"],
     schedule: payload["schedule"],
-    discord_channel_id: payload["discord_channel_id"],
+    notify_target: payload["notify_target"],
+    notify_channel: payload["notify_channel"],
     forum_title: payload["forum_title"],
     forum_reply_to_latest: payload["forum_reply_to_latest"]
   )

data/lib/brainiac/sessions.rb

@@ -179,8 +179,7 @@ def register_session(card_key, pid, log_file: nil, message_id: nil, channel_id:
   end
 end
 
-# --- Session supersede (Discord follow-up within window kills previous run) ---
-
+# --- Session supersede (Channel follow-up within window kills previous run) ---
 SUPERSEDE_WINDOW = 60 # seconds
 
 # Find an active session for the same supersede key (agent+channel) started within the window.

data/lib/brainiac/version.rb

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

data/monitor/shared.rb

@@ -21,7 +21,7 @@ BRAINIAC_DIR = File.expand_path("~/.brainiac")
 # --- Agent Config ---
 
 # Load agent configuration from ~/.brainiac/waybar.json.
-# Returns { "galen" => { emoji: "🤖", color: "blue" }, ... }
+# Returns { "sherlock" => { emoji: "🤖", color: "blue" }, ... }
 def load_agent_config
   config = JSON.parse(File.read(CONFIG_PATH, encoding: "utf-8"))
   agents = {}