brainiac 0.1.7 → 0.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ad5658a53a073cc5742607142f389a1330fc44a3600ecb01d945a207c03b74e5
-  data.tar.gz: ae9b2d130fad6a9af04ab08572f1f12cef0578e303543dc565b0d8f6c3606bab
+  metadata.gz: cedcfe4e4dfa26034cf0ded9746d8ff5bade886ec3d83774580d8334777d4d3c
+  data.tar.gz: 96d1702d994f06f0a4f41870de6652258fc700a9f9df1b6193c347b2cce3b365
 SHA512:
-  metadata.gz: 8110a8ecae79f591c43b8bd7ea5730886491c8db09d4d3e7ee3950d4d4a19680fa054705ea7c4d53a333c431542b2c25a2c2658dd08630c4532a64c387328dbe
-  data.tar.gz: 20954f902702102b9b91e761295cb4de86b9b3e153df613f34225cf1b36f4d7a337be7f8dbe521a3f525d9156e6b4e9d806a879f6810b96a4b02bde9582d2ce9
+  metadata.gz: 16a5c9937e67afe78bcba468dea8a4b75c73864c4a320b8d2da930a966bd618797b6285f765f772a99394d8925ba9438fe2b9012ccb94730908e97642148cdbb
+  data.tar.gz: 95cd9275779731da352b0356e1da275f12511b960037512e829614a6b5e2a4a97e3b00ba0ceeefbdbcc8eff71a3f0717b9cc43fb3ee4d21b2b706361e4dfccc0

data/bin/brainiac

@@ -263,7 +263,10 @@ def wait_for_agents_to_finish
   end
 end
 
-# rubocop:disable Naming/PredicateMethod
+# stop_server is a command (it stops the server) that happens to return a
+# boolean success flag; renaming it to a predicate (stop_server?) would be
+# semantically wrong, so suppress the predicate-naming cop for this definition.
+# rubocop:disable-next Naming/PredicateMethod
 def stop_server
   pid = find_server_pid
 
@@ -304,7 +307,6 @@ def stop_server
     false
   end
 end
-# rubocop:enable Naming/PredicateMethod
 
 # Kill a single process: TERM first, KILL if it doesn't exit within 5s.
 def kill_pid(pid, quiet: false)

data/lib/brainiac/helpers.rb

@@ -107,9 +107,8 @@ end
 # Returns the provider name (e.g. "grok") or nil.
 def detect_cli_provider(text: "", tags: [])
   # Inline tag: [cli:grok] — works in any channel
-  if (match = text.match(/\[cli:(\w+)\]/i))
-    return match[1].downcase
-  end
+  inline = inline_cli_provider_tag(text)
+  return inline if inline
 
   # Plugin hook: let plugins detect from their own metadata (e.g., card tags)
   results = Brainiac.emit(:detect_cli_provider, text: text, tags: tags)
@@ -119,6 +118,11 @@ def detect_cli_provider(text: "", tags: [])
   nil
 end
 
+# The provider named by an inline [cli:X] tag in text, or nil. Text only — no plugin hooks.
+def inline_cli_provider_tag(text)
+  text.to_s.match(/\[cli:(\w+)\]/i)&.[](1)&.downcase
+end
+
 def default_project_key
   # Find the project marked as default
   default = PROJECTS.find { |_key, config| config["default"] == true }
@@ -354,9 +358,11 @@ def register_work_item(branch:, worktree: nil, project: nil, agent: nil, source:
 end
 
 # Update dispatch overrides on a work item (cli_provider, model, effort, profile).
-# Only non-nil values are stored; nil values are removed from existing overrides.
+# Non-nil values are stored; nil values leave the existing override untouched.
+# Keys listed in clear: (e.g. [:model]) are removed from the stored overrides.
 # Returns true if the work item was found and updated, false otherwise.
-def update_work_item_overrides(cli_provider: nil, model: nil, effort: nil, profile: nil, work_item_id: nil, branch: nil) # rubocop:disable Naming/PredicateMethod
+def update_work_item_overrides(cli_provider: nil, model: nil, effort: nil, profile: nil, work_item_id: nil, branch: nil, # rubocop:disable Naming/PredicateMethod
+                               clear: [])
   map = load_work_item_map
 
   target_id = work_item_id
@@ -376,6 +382,7 @@ def update_work_item_overrides(cli_provider: nil, model: nil, effort: nil, profi
   overrides["model"] = model if model
   overrides["effort"] = effort if effort
   overrides["profile"] = profile if profile
+  Array(clear).each { |key| overrides.delete(key.to_s) }
   overrides.compact!
 
   if overrides.empty?
@@ -425,33 +432,78 @@ end
 # Unknown profile names are never persisted, so a typo can't pin a work item to a
 # profile that doesn't exist (profile_spawn_env ignores it for this dispatch too).
 #
+# A stored model is a provider-specific ID (kiro's "opus" is "claude-opus-4.5", claude's is
+# "opus"), so switching providers with [cli:X] drops it and the new provider's default
+# applies, unless the same message also carries a model tag. default_cli_provider: is the
+# provider a work item with no stored cli_provider was running on; without it, any inline
+# [cli:X] on such a work item counts as a switch.
+#
 # Returns: { cli_provider:, model:, effort:, profile: } (each String or nil)
 def resolve_work_item_overrides(work_item_id: nil, branch: nil, inline_cli_provider: nil, inline_model: nil, inline_effort: nil,
-                                inline_profile: nil)
+                                inline_profile: nil, default_cli_provider: nil)
   stored = work_item_overrides_for(work_item_id: work_item_id, branch: branch)
   inline_profile = inline_profile&.to_s&.downcase
   persist_profile = inline_profile && profile_entry(inline_profile) ? inline_profile : nil
+  switched = cli_provider_switched?(inline_cli_provider, stored["cli_provider"] || default_cli_provider)
+  stored_model = switched ? nil : stored["model"]
 
   # Inline tags override stored values
   resolved = {
     cli_provider: inline_cli_provider || stored["cli_provider"],
-    model: inline_model || stored["model"],
+    model: inline_model || stored_model,
     effort: inline_effort || stored["effort"],
     profile: inline_profile || stored["profile"]
   }
 
   # Persist any new inline overrides to the work item for future dispatches
-  new_overrides = {}
-  new_overrides[:cli_provider] = inline_cli_provider if inline_cli_provider
-  new_overrides[:model] = inline_model if inline_model
-  new_overrides[:effort] = inline_effort if inline_effort
-  new_overrides[:profile] = persist_profile if persist_profile
+  new_overrides = { cli_provider: inline_cli_provider, model: inline_model, effort: inline_effort,
+                    profile: persist_profile }.compact
+  new_overrides[:clear] = [:model] if switched && !inline_model && stored["model"]
 
   update_work_item_overrides(work_item_id: work_item_id, branch: branch, **new_overrides) if new_overrides.any? && (work_item_id || branch)
 
   resolved
 end
 
+# True when an inline [cli:X] names a different provider than the one previously in use.
+def cli_provider_switched?(inline_cli_provider, previous_cli_provider)
+  !inline_cli_provider.nil? && inline_cli_provider != previous_cli_provider
+end
+
+# One-stop override resolution for a dispatch: parses [cli:X]/[model]/[effort:X]/[p:X] from
+# the message text (and plugin card tags), merges them with the work item's stored overrides,
+# and persists any new inline values. The model and effort are resolved against the provider
+# that will actually run (inline > stored > agent/project default), so a [sonnet] tag can't be
+# looked up in the wrong provider's model map. Plugins should prefer this over calling
+# detect_model/detect_effort and resolve_work_item_overrides by hand.
+#
+# Returns: { cli_provider:, model:, explicit_model:, effort:, profile: }
+#   cli_provider is nil when nothing overrides the agent/project default.
+#   explicit_model is true when the model came from a tag (see detect_model_explicit).
+def resolve_dispatch_overrides(project_config, text: "", tags: [], agent_name: nil, work_item_id: nil, branch: nil)
+  stored = work_item_overrides_for(work_item_id: work_item_id, branch: branch)
+  inline_cli = detect_cli_provider(text: text, tags: tags)
+  default_cli = agent_cli_provider_for(agent_name) || project_config["cli_provider"]
+  effective_cli = inline_cli || stored["cli_provider"]
+
+  model, explicit_model = detect_model_explicit(project_config, tags: tags, text: text,
+                                                                cli_provider_override: effective_cli, agent_name: agent_name)
+  effort, explicit_effort = detect_effort_explicit(project_config, tags: tags, text: text,
+                                                                   cli_provider_override: effective_cli, agent_name: agent_name)
+
+  resolved = resolve_work_item_overrides(work_item_id: work_item_id, branch: branch, inline_cli_provider: inline_cli,
+                                         inline_model: explicit_model ? model : nil,
+                                         inline_effort: explicit_effort ? effort : nil,
+                                         inline_profile: detect_profile(text: text, tags: tags),
+                                         default_cli_provider: default_cli)
+  # Nothing tagged or stored (or the stored model was dropped by a switch): use the
+  # effective provider's defaults, already resolved above.
+  resolved[:model] ||= model
+  resolved[:effort] ||= effort
+  resolved[:explicit_model] = explicit_model
+  resolved
+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
@@ -984,7 +1036,11 @@ def append_model_to_cmd(cmd, model, resolved)
   # This handles cases where different projects use "auto" but each CLI provider maps it differently.
   effective_model = allowed.key?(model) ? allowed[model] : model
   is_known = allowed.value?(effective_model) || allowed.key?(effective_model)
-  cmd.push(resolved["agent_model_flag"], effective_model) if is_known
+  if is_known
+    cmd.push(resolved["agent_model_flag"], effective_model)
+  else
+    LOG.warn "[Model] Dropping model '#{model}': not in #{resolved["agent_cli"]}'s model map; using the CLI's default"
+  end
 end
 
 # A model is only "explicit" if the caller actually supplied one (i.e. it came from a
@@ -1344,8 +1400,9 @@ end
 # while a fell-back-to-default value must NOT write — otherwise every no-tag dispatch
 # would clobber each account's per-account default back to the project default.
 def detect_model_explicit(project_config, tags: [], text: "", cli_provider_override: nil, agent_name: nil)
-  # If no explicit CLI provider override, check if the agent has one configured
-  effective_cli_provider = cli_provider_override || agent_cli_provider_for(agent_name)
+  # Without an explicit override, a [cli:X] in the same text picks the model map (so
+  # "[cli:claude] [sonnet]" resolves through claude's map), then the agent's provider.
+  effective_cli_provider = cli_provider_override || inline_cli_provider_tag(text) || agent_cli_provider_for(agent_name)
   resolved = resolve_project_cli_config(project_config, cli_provider_override: effective_cli_provider, agent_name: agent_name)
   allowed_models = resolved["allowed_models"] || {}
   return [resolved["agent_model"], false] if allowed_models.empty?
@@ -1368,22 +1425,29 @@ end
 # If the requested level isn't supported by the current model, returns the closest
 # lower level from allowed_efforts.
 def detect_effort(project_config, tags: [], text: "", cli_provider_override: nil, agent_name: nil)
-  effective_cli_provider = cli_provider_override || agent_cli_provider_for(agent_name)
+  detect_effort_explicit(project_config, tags: tags, text: text,
+                                         cli_provider_override: cli_provider_override, agent_name: agent_name).first
+end
+
+# Like detect_effort, but returns [level, explicit_bool] where explicit is true only when
+# the level came from an [effort:X] tag or a plugin's card tag (not the provider default).
+def detect_effort_explicit(project_config, tags: [], text: "", cli_provider_override: nil, agent_name: nil)
+  effective_cli_provider = cli_provider_override || inline_cli_provider_tag(text) || agent_cli_provider_for(agent_name)
   resolved = resolve_project_cli_config(project_config, cli_provider_override: effective_cli_provider, agent_name: agent_name)
   allowed = resolved["allowed_efforts"] || %w[low medium high xhigh max]
 
   # Inline tag: [effort:high] — works in any channel
   if (match = text.match(/\[effort:(\w+)\]/i))
     level = match[1].downcase
-    return resolve_effort_level(level, allowed) if allowed.include?(level)
+    return [resolve_effort_level(level, allowed), true] if allowed.include?(level)
   end
 
   # Plugin hook: let plugins detect from their own metadata (e.g., card tags)
   results = Brainiac.emit(:detect_effort, tags: tags, allowed: allowed)
   plugin_result = results.compact.first
-  return resolve_effort_level(plugin_result, allowed) if plugin_result
+  return [resolve_effort_level(plugin_result, allowed), true] if plugin_result
 
-  resolved["agent_effort"]
+  [resolved["agent_effort"], false]
 end
 
 # Detect a profile ([profile:X]/[p:X]) from inline text OR card tags.

data/lib/brainiac/plugins.rb

@@ -40,45 +40,49 @@ end
 # Load all installed plugin gems and call their register hooks.
 # Called once during server startup, after core handlers are loaded.
 def load_plugins!(app)
-  # rubocop:disable Metrics/BlockLength
-  installed_plugins.each do |name|
-    gem_name = "brainiac-#{name}"
-    entry = plugin_entry(name)
-    begin
-      # If plugin has a local path, add its lib/ to load path before requiring
-      if entry.is_a?(Hash) && entry["path"]
-        lib_path = File.join(entry["path"], "lib")
-        $LOAD_PATH.unshift(lib_path) unless $LOAD_PATH.include?(lib_path)
-        LOG.info "[Plugins] Loading #{gem_name} from local path: #{entry["path"]}"
-      end
-
-      # Try both naming conventions: brainiac-fizzy and brainiac_fizzy
-      begin
-        require gem_name
-      rescue LoadError
-        require gem_name.tr("-", "_")
-      end
-
-      plugin_module = resolve_plugin_module(name)
-      if plugin_module.respond_to?(:register)
-        plugin_module.register(app)
-        LOG.info "[Plugins] Loaded #{gem_name}"
-      else
-        LOG.warn "[Plugins] #{gem_name} loaded but no register method found"
-      end
-    rescue LoadError => e
-      LOG.error "[Plugins] Could not load #{gem_name}: #{e.message}"
-      if entry.is_a?(Hash) && entry["path"]
-        LOG.error "[Plugins]   Local path: #{entry["path"]}"
-      else
-        LOG.error "[Plugins]   Is the gem installed? Run: gem install #{gem_name}"
-      end
-    rescue StandardError => e
-      LOG.error "[Plugins] Error registering #{gem_name}: #{e.message}"
-      LOG.error "[Plugins]   #{e.backtrace.first(3).join("\n  ")}"
-    end
+  installed_plugins.each { |name| load_plugin!(app, name) }
+end
+
+# Require a single plugin gem and call its register hook.
+# Isolated per-plugin so one failing plugin doesn't abort the rest.
+def load_plugin!(app, name)
+  gem_name = "brainiac-#{name}"
+  entry = plugin_entry(name)
+
+  require_plugin_gem(gem_name, entry)
+
+  plugin_module = resolve_plugin_module(name)
+  if plugin_module.respond_to?(:register)
+    plugin_module.register(app)
+    LOG.info "[Plugins] Loaded #{gem_name}"
+  else
+    LOG.warn "[Plugins] #{gem_name} loaded but no register method found"
   end
-  # rubocop:enable Metrics/BlockLength
+rescue LoadError => e
+  LOG.error "[Plugins] Could not load #{gem_name}: #{e.message}"
+  if entry.is_a?(Hash) && entry["path"]
+    LOG.error "[Plugins]   Local path: #{entry["path"]}"
+  else
+    LOG.error "[Plugins]   Is the gem installed? Run: gem install #{gem_name}"
+  end
+rescue StandardError => e
+  LOG.error "[Plugins] Error registering #{gem_name}: #{e.message}"
+  LOG.error "[Plugins]   #{e.backtrace.first(3).join("\n  ")}"
+end
+
+# Require a plugin gem, honoring a local path override and both the
+# hyphen (brainiac-fizzy) and underscore (brainiac_fizzy) naming conventions.
+def require_plugin_gem(gem_name, entry)
+  # If plugin has a local path, add its lib/ to load path before requiring
+  if entry.is_a?(Hash) && entry["path"]
+    lib_path = File.join(entry["path"], "lib")
+    $LOAD_PATH.unshift(lib_path) unless $LOAD_PATH.include?(lib_path)
+    LOG.info "[Plugins] Loading #{gem_name} from local path: #{entry["path"]}"
+  end
+
+  require gem_name
+rescue LoadError
+  require gem_name.tr("-", "_")
 end
 
 # Resolve the plugin module for a given name.

data/lib/brainiac/prompts.rb

@@ -18,6 +18,13 @@ PROMPT_CORE = <<~PROMPT
   Getting the casing wrong means the mention won't link or notify properly.
   {{AGENT_ROSTER}}
 
+  ## Conversation Focus (CRITICAL)
+  Your PRIMARY task is ALWAYS the most recent message/comment you've received.
+  - Context and history are reference material — they inform your response but don't define your task
+  - If the user asks a question, answer THAT question — don't summarize previous work
+  - If the user requests a change, make THAT change — don't rehash what you've already done
+  - Previous sessions and memory help you understand context, but the current request is what you're here to do
+
   ## Memory (CRITICAL — read this first)
   You have no persistent memory between sessions. Every time you are invoked, you start completely fresh.
   Memory files MAY exist at `{{MEMORY_DIR}}/` — this is inside the brain, so they survive worktree deletion.
@@ -174,8 +181,8 @@ CHANNEL_PROMPTS = {}.freeze
 #   channel: :discord, :github, or plugin-registered channels (e.g., :fizzy, :linear)
 # ---------------------------------------------------------------------------
 
-# rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-def render_prompt(template, vars = {}, brain_context: "", card_context: "", agent_name: AI_AGENT_NAME, channel: nil, board_key: nil)
+def render_prompt(template, vars = {}, brain_context: "", card_context: "", comment_history: "", 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?
@@ -187,6 +194,10 @@ def render_prompt(template, vars = {}, brain_context: "", card_context: "", agen
 
   result += template
 
+  # Comment history (for follow-up scenarios): placed AFTER the triggering comment
+  # so the agent sees the current request first, then can reference history as needed
+  result += comment_history unless comment_history.empty?
+
   # Pre-post comment check: plugin-registered
   plugin_pre_post = Brainiac.channel_pre_post_checks[channel]
   result += plugin_pre_post if plugin_pre_post
@@ -194,6 +205,15 @@ def render_prompt(template, vars = {}, brain_context: "", card_context: "", agen
   # Reflection prompt — skip for now
   # result += PROMPT_REFLECTION
 
+  populate_prompt_vars(vars, agent_name: agent_name, board_key: board_key)
+
+  vars.each { |key, val| result.gsub!("{{#{key}}}", val.to_s) }
+  result
+end
+
+# Populate the default template variables (dirs, column IDs, roster) and touch
+# the agent's memory file. Extracted from render_prompt to keep complexity down.
+def populate_prompt_vars(vars, agent_name:, board_key:)
   vars["KNOWLEDGE_DIR"] ||= KNOWLEDGE_DIR
   vars["MEMORY_DIR"] ||= memory_dir_for(agent_name)
   vars["PERSONA_DIR"] ||= persona_dir_for(agent_name)
@@ -215,14 +235,9 @@ def render_prompt(template, vars = {}, brain_context: "", card_context: "", agen
     FileUtils.touch(memory_file)
   end
 
-  roster = agent_roster
-  roster_lines = roster.map { |_key, display| "  - @#{display}" }.join("\n")
+  roster_lines = agent_roster.map { |_key, display| "  - @#{display}" }.join("\n")
   vars["AGENT_ROSTER"] ||= roster_lines
-
-  vars.each { |key, val| result.gsub!("{{#{key}}}", val.to_s) }
-  result
 end
-# rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
 # Lean prompt for resumed sessions. The previous session already has the full context
 # (role, persona, knowledge, core instructions, channel prompts). We only send the new

data/lib/brainiac/version.rb

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

metadata

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