brainiac 0.1.8 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ab0a2720abc8e0ea7c76d7a0c4f8ec6303a744dc8bdf7dfd6cd7d41b5d0671e2
-  data.tar.gz: beefb425e88f3418babaf504b5d0a4841c7d7cda03ef189951adb1fd42c747fd
+  metadata.gz: e63254b890e44045e1c05872417234f86e34fdcd36a737c7565c4ee7efc74426
+  data.tar.gz: 630399ccb91dc4ef99b6f14619710c5893b6194354dc3a89f3d491cc4b226bdb
 SHA512:
-  metadata.gz: 30ed5d2c72453ef0bf624c1bf34df92111bd1e5cab30c492fc483ad9ab241794ff177452b2bbc533e42d39b9199882382eda6930acc89a83f8f3a371020cd166
-  data.tar.gz: b5d1b984a1bf7e17e094da496b831f34c822c9368a1c8966b6dc3d30057101c913d69629cf94f9358b6ee196d4a84dd58fb744fe8d652f5280dbf344911efc2f
+  metadata.gz: d0a1f9cc0ca39aa87aec48c3b45132b7777e6dc6ca7f71006a78e6ebe00879c188d8cea9104822d2e32a3d1b65970d09d5271c558d5af10faa8d29a24bd182a5
+  data.tar.gz: '02884d9354a9b5946a28f58f0e0c70d4f98893554b773f1738aa6e2a9383850d4f7577c8d691c9ef11867f71a81c5327a5ac28922fc7b90a95311bb1ceb536c4'

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
@@ -652,9 +704,11 @@ def prior_session_exists?(chdir, agent_cli, session_dir: nil)
   return true if File.directory?(session_dir_local)
 
   # 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.
+  # This covers CLIs that don't leave a dotdir but do leave logs via brainiac. The logs
+  # don't say which CLI wrote them, so only trust them when the last-CLI marker says it was this one.
   tmp_dir = File.join(chdir, "tmp")
   return false unless File.directory?(tmp_dir)
+  return false unless last_cli_for(chdir) == cli_name
 
   Dir.glob(File.join(tmp_dir, "agent-*.log")).any? do |log|
     # Only count logs from the last 24 hours as valid "resumable" sessions
@@ -664,6 +718,40 @@ rescue StandardError
   false
 end
 
+# Marker recording which CLI binary last ran in a directory (written by run_agent).
+def last_cli_marker_path(chdir)
+  File.join(chdir, "tmp", ".brainiac-last-cli")
+end
+
+def last_cli_for(chdir)
+  return nil unless chdir
+
+  name = File.read(last_cli_marker_path(chdir)).strip
+  name.empty? ? nil : name
+rescue StandardError
+  nil
+end
+
+def record_last_cli(chdir, agent_cli)
+  key = cli_session_key(agent_cli)
+  return unless chdir && key
+
+  FileUtils.mkdir_p(File.join(chdir, "tmp"))
+  File.write(last_cli_marker_path(chdir), key)
+rescue StandardError => e
+  LOG.warn "[Dispatch] Could not record last CLI for #{chdir}: #{e.message}"
+end
+
+# True when a different CLI ran in this directory more recently than agent_cli.
+# A switched-to CLI never saw the other provider's turns, so resuming its own (older)
+# session would hand it a lean prompt with a stale or empty history. Start fresh instead
+# and let the full prompt (memory file + source context) carry the conversation.
+def cli_switched_since_last_run?(chdir, agent_cli)
+  last = last_cli_for(chdir)
+  key = cli_session_key(agent_cli)
+  !last.nil? && !key.nil? && last != key
+end
+
 # Check if a centralized session directory has sessions matching the given cwd.
 # Supports CLIs that store sessions as .jsonl files in date-partitioned directories (YYYY/MM/DD/)
 # with a first-line JSON metadata object containing a "payload.cwd" field.
@@ -725,6 +813,7 @@ end
 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 if cli_switched_since_last_run?(chdir, resolved["agent_cli"])
   return stored_cli_session_viable?(resolved, chdir) if resolved["resume_id_flag"]
   return false unless resolved["resume_flag"] || resolved["resume_args"]
 
@@ -753,6 +842,11 @@ end
 def resolve_resume(resume, resolved, chdir, session_id: nil)
   return false unless resume
 
+  if cli_switched_since_last_run?(chdir, resolved["agent_cli"])
+    LOG.info "[Dispatch] CLI switched from #{last_cli_for(chdir)} to #{resolved["agent_cli"]} in #{chdir} — starting fresh session"
+    return false
+  end
+
   if resolved["resume_id_flag"]
     id = session_id.to_s.empty? ? cli_session_id_for(agent_cli: resolved["agent_cli"], worktree: chdir) : session_id
     if id.to_s.empty?
@@ -772,16 +866,27 @@ def resolve_resume(resume, resolved, chdir, session_id: nil)
   false
 end
 
-# Some CLIs (e.g. grok --session-id) let the caller name a new session up front.
-# Mint a UUID only on the first run, when we are not resuming an existing id.
-def mint_cli_session_id(resolved, stored_session:, resuming:)
+# Some CLIs (e.g. claude/grok --session-id) let the caller name a new session up front.
+# Mint a UUID whenever we start fresh — including after a provider switch, when an older
+# stored id exists — so the stored id always points at the latest session for this CLI.
+def mint_cli_session_id(resolved, resuming:)
   return nil if resuming
   return nil unless resolved["new_session_id_flag"]
-  return nil unless stored_session.to_s.empty?
 
   SecureRandom.uuid
 end
 
+# Decide resume vs. fresh start for this dispatch, then record this CLI as the last
+# one to run here. Returns [should_resume, minted_session_id].
+def prepare_cli_session(resume, resolved, chdir)
+  stored_session = cli_session_id_for(agent_cli: resolved["agent_cli"], worktree: chdir)
+  # Auto-resume: only if the provider supports it AND a prior session exists for this CLI here.
+  should_resume = resolve_resume(resume, resolved, chdir, session_id: stored_session)
+  minted_session_id = mint_cli_session_id(resolved, resuming: should_resume)
+  record_last_cli(chdir, resolved["agent_cli"])
+  [should_resume, minted_session_id]
+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.
@@ -818,12 +923,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-]/, "-")
 
-  stored_session = cli_session_id_for(agent_cli: resolved["agent_cli"], worktree: chdir)
   work_item_id = find_work_item_by_worktree(chdir)&.first
-
-  # Auto-resume: only if the provider supports it AND a prior session exists for this CLI here.
-  should_resume = resolve_resume(resume, resolved, chdir, session_id: stored_session)
-  minted_session_id = mint_cli_session_id(resolved, stored_session: stored_session, resuming: should_resume)
+  should_resume, minted_session_id = prepare_cli_session(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)
@@ -984,7 +1085,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 +1449,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 +1474,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/version.rb

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

metadata

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