brainiac 0.0.15 → 0.0.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 677c29e7ddcf5d9718eda91175193e9ffa448be65fac5e698982009327ee3576
-  data.tar.gz: ec7c044b3661f5fdca2f462a305a53ab47c6cfd76299462fa5e3df0f83f28a3a
+  metadata.gz: 123ee48772d662b7c3326b4c90584f3aa85cfeecf0c481f564cb3f79efb4355a
+  data.tar.gz: d81be4471f1665ca426d9c02cc278f04e0fc67a272b6f9c5a82ce7ba05ef00ae
 SHA512:
-  metadata.gz: e4f3c2af97935afe5666ae722629f2a6a15af09fef73cc8ef969a11eccbf9c315cf50831e293a381cc6d2f4b2a383bce03a3fb673c4f9294ab17cb11f3656270
-  data.tar.gz: f70117f73d55be6914223bca9cbe331e0e9ecdece704349b71eb0c40f35fdcc8da8d2fdcf9cf297b7d9fa7b91b45350a09de12271332fcac7a28cda0d984c91c
+  metadata.gz: 76b8df7eefa48bb122f7d75ba0730f0b8ac328ad284f45e137297dd650b7f6781bcc6ad14bd1a0a4f1a31a9c24392bd183a4b5b236f086a19bc504257f2cf180
+  data.tar.gz: 7f089331037cc192f3cb284471b497e688d0831a38088f968cf4c5eabd175539a8b8f8e1986ad38739ee7a1efdb1beb81d3777d9f63e99c131fd74d47629dcd8

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    brainiac (0.0.15)
+    brainiac (0.0.16)
       puma (~> 7.2)
       rackup (~> 2.3)
       sinatra (~> 4.1)
@@ -84,7 +84,7 @@ DEPENDENCIES
 CHECKSUMS
   ast (2.4.3) sha256=954615157c1d6a382bc27d690d973195e79db7f55e9765ac7c481c60bdb4d383
   base64 (0.3.0) sha256=27337aeabad6ffae05c265c450490628ef3ebd4b67be58257393227588f5a97b
-  brainiac (0.0.15)
+  brainiac (0.0.16)
   json (2.19.9) sha256=9b9025b7cdddafa38d316eca0b2358488e42d417045c1b90d216a9fefe46b79a
   language_server-protocol (3.17.0.5) sha256=fd1e39a51a28bf3eec959379985a72e296e9f9acfce46f6a79d31ca8760803cc
   lint_roller (1.1.0) sha256=2c0c845b632a7d172cb849cc90c1bce937a28c5c8ccccb50dfd46a485003cc87

data/lib/brainiac/helpers.rb

@@ -402,11 +402,11 @@ end
 # Check if intent detection says to skip dispatching the agent.
 # Returns true if the message should be skipped, false otherwise.
 # Only runs if a raw message is provided, an agent is named, and intent is enabled.
-def intent_skip?(message, agent_name:, source: nil, channel: nil)
+def intent_skip?(message, agent_name:, source: nil, channel: nil, context: nil)
   return false unless message && agent_name && intent_config["enabled"]
 
   intent_channel = channel || source&.to_s || "conversation"
-  unless check_intent(message, agent_name: agent_name, channel: intent_channel)
+  unless check_intent(message, agent_name: agent_name, channel: intent_channel, context: context)
     LOG.info "[Intent] Skipping dispatch for #{agent_name} — message classified as not requiring response"
     return true
   end
@@ -416,9 +416,9 @@ 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,
-              message: nil, channel: nil)
+              message: nil, channel: nil, context: nil)
   # Intent gate: if a raw message is provided, check whether the agent should respond.
-  return nil if intent_skip?(message, agent_name: agent_name, source: source, channel: channel)
+  return nil if intent_skip?(message, agent_name: agent_name, source: source, channel: channel, context: context)
 
   resolved = resolve_project_cli_config(project_config, cli_provider_override: cli_provider, agent_name: agent_name)
   chdir ||= resolved["repo_path"]

data/lib/brainiac/intent.rb

@@ -38,17 +38,27 @@ INTENT_CONFIG_DEFAULTS = {
 INTENT_PROMPT_TEMPLATE = <<~PROMPT
   You are a message router for a {{CHANNEL}}. An AI agent named {{AGENT_NAME}} is participating in this conversation. Your job: determine if the latest message requires {{AGENT_NAME}} to take action or respond.
 
+  {{AGENT_ROSTER}}
+
   Rules:
-  - If the message is giving {{AGENT_NAME}} instructions, asking {{AGENT_NAME}} a question, or continuing a conversation WITH {{AGENT_NAME}} → yes
-  - If the message starts with or addresses someone else by name (e.g., "Adam, ...", "Hey Sarah", "Effie, ...") → no (it's directed at that person, not {{AGENT_NAME}})
+  - If the message addresses {{AGENT_NAME}} by name, gives {{AGENT_NAME}} instructions, or asks {{AGENT_NAME}} a question → yes
+  - If the message continues a conversation directed at {{AGENT_NAME}} (e.g. {{AGENT_NAME}} was the last to respond and the human follows up) → yes
+  - If the message starts with or addresses a DIFFERENT person/agent (not {{AGENT_NAME}}) → no
+  - If the message contains another agent's name (e.g. "Effie, ...", "Another one Effie", "Hey Galen") and does NOT contain "{{AGENT_NAME}}" → no
   - If the message is humans talking to each other and {{AGENT_NAME}} is not being addressed → no
-  - If the message is a simple acknowledgment (like "thanks", "ok", "got it") directed at {{AGENT_NAME}}'s previous work → no
-  - If the message is asking a question to another person or agent → no
+  - If the message is a simple acknowledgment ("thanks", "ok", "got it") directed at {{AGENT_NAME}}'s previous work → no
+  - If the message is asking a question to another person or agent (not {{AGENT_NAME}}) → no
   - If the message is responding to or commenting on what someone OTHER than {{AGENT_NAME}} just said → no
+  - If the conversation context shows a DIFFERENT agent was the last to respond, and the human's follow-up does not mention {{AGENT_NAME}} by name → no
   - If uncertain, lean toward yes (better to respond unnecessarily than miss a request)
 
+  Critical: "addresses someone else" means someone whose name is NOT {{AGENT_NAME}}. If the message says "{{AGENT_NAME}}, ..." that IS addressed to {{AGENT_NAME}} → yes.
+
   Respond with ONLY "yes" or "no" — nothing else.
 
+  Context:
+  {{CONTEXT}}
+
   Latest message:
   {{MESSAGE}}
 PROMPT
@@ -69,33 +79,114 @@ PENDING_WORK_PROMPT_TEMPLATE = <<~PROMPT
   {{MESSAGE}}
 PROMPT
 
+# Custom error for missing Ollama models — provides actionable install instructions.
+class OllamaModelNotFoundError < RuntimeError
+  attr_reader :model_name, :endpoint
+
+  def initialize(model_name, endpoint)
+    @model_name = model_name
+    @endpoint = endpoint
+    super(<<~MSG.strip)
+      Ollama model '#{model_name}' is not installed.
+
+      To install it, run:
+        ollama pull #{model_name}
+
+      Or change the model in ~/.brainiac/brainiac.json → intent.model
+
+      Available models can be listed with:
+        ollama list
+    MSG
+  end
+end
+
 # Load intent config from brainiac.json, merging with defaults.
 def intent_config
   raw = BRAINIAC_CONFIG["intent"] || {}
   INTENT_CONFIG_DEFAULTS.merge(raw)
 end
 
+# Validate that the configured intent model is available in Ollama.
+# Called at server startup — aborts with a helpful error if the model is missing.
+#
+# @param config [Hash] Intent configuration
+# @raise [OllamaModelNotFoundError] if the model isn't installed
+def validate_intent_model!(config)
+  base_uri = URI(config["endpoint"])
+  show_uri = URI("#{base_uri.scheme}://#{base_uri.host}:#{base_uri.port}/api/show")
+
+  http = Net::HTTP.new(show_uri.host, show_uri.port)
+  http.open_timeout = 5
+  http.read_timeout = 5
+
+  request = Net::HTTP::Post.new(show_uri.path, "Content-Type" => "application/json")
+  request.body = JSON.generate({ model: config["model"] })
+
+  response = http.request(request)
+
+  if response.code == "404" || (!response.is_a?(Net::HTTPSuccess) && response.body&.include?("not found"))
+    raise OllamaModelNotFoundError.new(config["model"], config["endpoint"])
+  end
+
+  true
+rescue Errno::ECONNREFUSED
+  raise "Ollama is not running at #{config["endpoint"]}. Start it with: ollama serve"
+rescue Net::OpenTimeout, Net::ReadTimeout
+  LOG.warn "[Intent] Could not validate model (Ollama timed out) — will check at first use"
+  true
+end
+
 # Check whether a message requires an agent to respond.
 #
 # @param message [String] The message text to classify
 # @param agent_name [String] The agent being addressed
 # @param channel [String] Context description (e.g., "Discord thread", "Fizzy card comment")
+# @param context [String, nil] Recent conversation history for flow detection
 # @return [Boolean] true if the agent should respond, false if it can be skipped
-def check_intent(message, agent_name:, channel: "conversation")
+def check_intent(message, agent_name:, channel: "conversation", context: nil)
   config = intent_config
   return true unless config["enabled"]
   return true if message.nil? || message.strip.empty?
 
+  # Deterministic pre-check: if the message explicitly names another agent
+  # and does NOT name this agent, skip without consulting the LLM.
+  # This handles the common case of "Effie, tell me another" when checking Galen.
+  if intent_names_other_agent?(message, agent_name)
+    LOG.info "[Intent] Deterministic skip for #{agent_name} — message addresses another agent"
+    return false
+  end
+
+  context_block = if context && !context.strip.empty?
+                    # Keep only last 5 messages for the small local model — enough to determine
+                    # conversational flow without overwhelming the context window.
+                    recent = context.strip.lines.last(5).join
+                    "Recent conversation (most recent last):\n#{recent}\n\n"
+                  else
+                    ""
+                  end
+
+  # Build agent roster for the prompt so the model knows which names are agents
+  roster_block = build_intent_agent_roster(agent_name)
+
   prompt = INTENT_PROMPT_TEMPLATE
            .gsub("{{AGENT_NAME}}", agent_name)
            .gsub("{{CHANNEL}}", channel)
+           .gsub("{{AGENT_ROSTER}}", roster_block)
+           .gsub("{{CONTEXT}}", context_block)
            .gsub("{{MESSAGE}}", message.strip)
 
   LOG.info "[Intent] Checking intent for #{agent_name} (#{channel}): #{message.strip.slice(0, 80)}..."
+  LOG.debug "[Intent] Full prompt:\n#{prompt}" if LOG.debug?
   response = query_local_llm(prompt, config)
   result = positive_intent?(response)
   LOG.info "[Intent] Result: #{result ? "RESPOND" : "SKIP"} (model: #{config["model"]})"
   result
+rescue OllamaModelNotFoundError => e
+  LOG.error "[Intent] #{e.message}"
+  LOG.error "[Intent] Disabling intent classification until model is installed."
+  BRAINIAC_CONFIG["intent"] ||= {}
+  BRAINIAC_CONFIG["intent"]["enabled"] = false
+  true
 rescue StandardError => e
   LOG.warn "[Intent] Classification failed (fail-open): #{e.message}"
   true
@@ -123,12 +214,17 @@ def query_local_llm(prompt, config)
   request.body = JSON.generate(payload)
 
   response = http.request(request)
-  raise "Ollama returned #{response.code}: #{response.body&.slice(0, 200)}" unless response.is_a?(Net::HTTPSuccess)
+
+  unless response.is_a?(Net::HTTPSuccess)
+    raise OllamaModelNotFoundError.new(config["model"], config["endpoint"]) if response.code == "404" && response.body&.include?("not found")
+
+    raise "Ollama returned #{response.code}: #{response.body&.slice(0, 200)}"
+  end
 
   body = JSON.parse(response.body)
   body["response"] || ""
 rescue Errno::ECONNREFUSED
-  raise "Ollama not running at #{config["endpoint"]}"
+  raise "Ollama not running at #{config["endpoint"]}. Start it with: ollama serve"
 rescue Net::OpenTimeout, Net::ReadTimeout
   raise "Ollama timed out after #{config["timeout"]}s"
 end
@@ -179,3 +275,102 @@ def pending_work_detected?(response)
   cleaned = response.to_s.strip.downcase.gsub(/[^a-z]/, "")
   cleaned == "yes"
 end
+
+# Deterministic check: does the message explicitly name another known agent
+# without mentioning this agent? If so, the message is clearly directed elsewhere.
+#
+# Only triggers when:
+# 1. The message contains another agent's display name (case-insensitive word boundary match)
+# 2. The message does NOT contain this agent's name
+#
+# This avoids the LLM entirely for obvious cases like "Effie, tell me another"
+# when evaluating whether Galen should respond.
+#
+# Determines if the message is DIRECTLY ADDRESSED to another agent (not just mentioning them).
+# Only triggers on vocative patterns — where the name is used to call someone, not refer to them.
+#
+# Patterns that indicate direct address (skip this agent):
+#   - "Effie, tell me a joke" (name + comma at start)
+#   - "hey Effie one more" (greeting + name)
+#   - "Another one Effie" (name at end, imperative)
+#   - "Effie tell me more" (name at start, imperative — no comma but first word)
+#
+# Patterns that are merely MENTIONING (do NOT skip):
+#   - "What do you think about Effie's answer?" (talking about Effie)
+#   - "Was Effie nice to you?" (asking about Effie)
+#   - "I liked what Effie said" (referencing Effie)
+#
+# @param message [String] The message text
+# @param agent_name [String] The agent being evaluated
+# @return [Boolean] true if another agent is directly addressed and this one isn't
+def intent_names_other_agent?(message, agent_name)
+  return false unless defined?(AGENT_REGISTRY) && !AGENT_REGISTRY.empty?
+
+  msg_lower = message.downcase.strip
+  agent_lower = agent_name.downcase
+
+  # If this agent IS named in the message, never deterministic skip
+  return false if msg_lower.match?(/\b#{Regexp.escape(agent_lower)}\b/)
+
+  # Check if any OTHER agent is directly addressed (not merely mentioned)
+  AGENT_REGISTRY.each do |key, entry|
+    display = entry.is_a?(Hash) ? (entry["display_name"] || key.capitalize) : key.capitalize
+    other_lower = display.downcase
+    next if other_lower == agent_lower
+    next unless msg_lower.match?(/\b#{Regexp.escape(other_lower)}\b/)
+
+    # Agent name is present — now determine if it's direct address or mere mention
+    return true if directly_addressed_to?(msg_lower, other_lower)
+  end
+
+  false
+end
+
+# Heuristics for detecting direct address (vocative use of a name).
+# Returns true when the name is used to CALL someone, not talk ABOUT them.
+#
+# @param msg [String] Lowercased, stripped message
+# @param name [String] Lowercased agent name to check
+# @return [Boolean]
+def directly_addressed_to?(msg, name)
+  escaped = Regexp.escape(name)
+
+  # Pattern 1: Name at the very start (with or without comma/colon)
+  # "Effie, tell me a joke" / "Effie tell me more" / "Effie: do the thing"
+  return true if msg.match?(/\A#{escaped}[\s,:!]/i)
+
+  # Pattern 2: Name at the very end (imperative directed at them)
+  # "Another one Effie" / "one more Effie"
+  # BUT NOT when preceded by a preposition — "agree with Effie?" is about Effie, not to her
+  if msg.match?(/\s#{escaped}\s*[.!?]?\z/i)
+    prepositions = /\b(?:with|about|from|to|for|of|by|like|than|as|at|on|against|toward|towards)\s+#{escaped}\s*[.!?]?\z/i
+    return true unless msg.match?(prepositions)
+  end
+
+  # Pattern 3: Greeting/vocative prefix + name
+  # "hey Effie" / "yo Effie" / "ok Effie" / "thanks Effie"
+  return true if msg.match?(/\b(?:hey|hi|yo|ok|okay|thanks|thank you|please)\s+#{escaped}\b/i)
+
+  # Pattern 4: Name followed by comma mid-sentence (vocative comma)
+  # "so Effie, what do you think?"
+  return true if msg.match?(/\b#{escaped}\s*,/i)
+
+  false
+end
+
+# Build a compact agent roster string for the intent prompt.
+# Helps the LLM identify which names in the conversation are agents.
+#
+# @param agent_name [String] The current agent (highlighted)
+# @return [String] Formatted roster for prompt injection
+def build_intent_agent_roster(agent_name)
+  return "" unless defined?(AGENT_REGISTRY) && !AGENT_REGISTRY.empty?
+
+  names = AGENT_REGISTRY.map do |key, entry|
+    entry.is_a?(Hash) ? (entry["display_name"] || key.capitalize) : key.capitalize
+  end.uniq
+
+  return "" if names.size <= 1
+
+  "Known agents in this system: #{names.join(", ")}. You are routing for #{agent_name}."
+end

data/lib/brainiac/version.rb

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

data/receiver.rb

@@ -101,6 +101,15 @@ end
 LOG.info "[Brainiac] Starting v#{BRAINIAC_VERSION} on port #{settings.port} (#{settings.environment})"
 if intent_config["enabled"]
   LOG.info "[Intent] Enabled — model: #{intent_config["model"]}, endpoint: #{intent_config["endpoint"]}"
+  begin
+    validate_intent_model!(intent_config)
+    LOG.info "[Intent] Model '#{intent_config["model"]}' verified ✓"
+  rescue OllamaModelNotFoundError => e
+    LOG.fatal "[Intent] FATAL: #{e.message}"
+    abort "\n#{e.message}\n"
+  rescue RuntimeError => e
+    LOG.warn "[Intent] Startup validation skipped: #{e.message}"
+  end
 else
   LOG.info "[Intent] Disabled (enable in brainiac.json → intent.enabled: true)"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: brainiac
 version: !ruby/object:Gem::Version
-  version: 0.0.15
+  version: 0.0.16
 platform: ruby
 authors:
 - Andy Davis