brainiac 0.0.12 → 0.0.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7890616cf0466e9c991c0e1209ff482eae548c205d151746c3f3065d2c239033
-  data.tar.gz: 76f04a3697a1070932a9754281828fb6d49869c3efe1b0efc9a89c98f3ee9bba
+  metadata.gz: '04080c41c24921ed739b0d28ad15ce61b8eb5b5c12935d0cb0b1d72c6b0deeab'
+  data.tar.gz: bbb1dceb84ecaba924ada9189e8b63320828c035da4a6ff466ba8b47c4c30708
 SHA512:
-  metadata.gz: 975a3cff959457bd2bf6f622010d3f016643f36aea981874e9424fb278666eda22441fd9f0e5938806849eaa4165f62c2f1c5fd1be10ad32b501afcecfacfb1a
-  data.tar.gz: 2c94aeefd3190ad1c8f074665486988d1b0440b4cb104a5dae39d670bb5559db0d5abeb64a4d4da132c6ff8e2d385e004ee26d11568a6eaf7313a822f854065d
+  metadata.gz: '0699a2277c78aa2c33e57b6ee4394ac7be8d27bc483a9f3866dd27e644e40fbdea4b85168b3452c6cbbd4fce42da6e282a9609e93541802b2c751f9845c55ea2'
+  data.tar.gz: adcd7eab6269a33b278499e3b873b072f488f7b06b18378507fba456f883b1c525b7dd8d8ce82b13e6464ab5184007e0887dfa9a82a69910f8f8d0164660ff9b

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    brainiac (0.0.12)
+    brainiac (0.0.14)
       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.12)
+  brainiac (0.0.14)
   json (2.19.9) sha256=9b9025b7cdddafa38d316eca0b2358488e42d417045c1b90d216a9fefe46b79a
   language_server-protocol (3.17.0.5) sha256=fd1e39a51a28bf3eec959379985a72e296e9f9acfce46f6a79d31ca8760803cc
   lint_roller (1.1.0) sha256=2c0c845b632a7d172cb849cc90c1bce937a28c5c8ccccb50dfd46a485003cc87

data/README.md

@@ -43,7 +43,9 @@ All four channels support inline tags in message/comment text. Tags are stripped
 | ----------------------------------------------------------------------------- | ----- | ------- | ------ | ----------------------------------------------------------------------------------------------------- |
 | `[project:XYZ]`                                                               | —     | ✓       | —      | Override which project the agent works in (Discord only — Fizzy uses card tags, GitHub uses the repo) |
 | `[opus]` `[sonnet]` `[haiku]` `[deepseek]` `[minimax]` `[minimax21]` `[qwen]` | ✓     | ✓       | ✓      | Override the model for this dispatch                                                                  |
-| `[worktree:branch-name]`                                                      | ✓     | —       | —      | Direct the agent to a specific worktree instead of the card's default                                 |
+| `[worktree:branch-name]`                                                      | ✓     | ✓       | —      | Direct the agent to a specific worktree/branch (legacy syntax)                                        |
+| `[branch:branch-name]`                                                        | ✓     | ✓       | ✓      | Target an existing branch — reuses its worktree if a work item exists                                 |
+| `[workitem:wi-abc123]`                                                        | ✓     | ✓       | ✓      | Target a specific work item by ID — agent works in its worktree                                       |
 | `[plan]`                                                                      | ✓     | ✓       | —      | Activate planning mode — agent gathers requirements before coding                                     |
 
 Model keys come from the project's `allowed_models` config. Fizzy also supports model selection via card tags (e.g. adding an `opus` tag to the card).
@@ -868,6 +870,50 @@ curl http://localhost:4567/api/users/fladamd            # Find by identifier
 
 The registry reloads automatically on every webhook and via `POST /api/reload`.
 
+## Work Items
+
+Work items are the universal tracking unit in Brainiac — they connect a branch/worktree to one or more communication channels. A single work item can span Discord, Fizzy, and GitHub simultaneously.
+
+### Structure
+
+Work items are stored in `~/.brainiac/work_items.json`:
+
+```json
+{
+  "wi-a1b2c3d4": {
+    "id": "wi-a1b2c3d4",
+    "branch": "fizzy-42-fix-login",
+    "worktree": "/home/you/Code/marketplace--fizzy-42-fix-login",
+    "project": "marketplace",
+    "agent": "Sherlock",
+    "sources": {
+      "fizzy": { "card_internal_id": "uuid-here", "card_number": 42 },
+      "github": { "prs": [{"number": 8, "url": "https://github.com/org/repo/pull/8"}] },
+      "discord": { "thread_id": "1234567890" }
+    }
+  }
+}
+```
+
+The **branch** is the universal join key. When any channel needs to find a work item, it looks up by branch name. This means:
+
+- A Fizzy card assignment creates a work item with `sources.fizzy`
+- When a PR is opened for that branch, `sources.github` is attached automatically
+- A Discord `[branch:fizzy-42-fix-login]` message targets the same worktree
+
+### Targeting Work Items
+
+From Discord or any channel, use inline tags to target existing work items:
+
+- **`[branch:branch-name]`** — find the work item for this branch, work in its worktree
+- **`[workitem:wi-abc123]`** — target a work item by its ID directly
+
+This enables cross-channel workflows without creating duplicate worktrees.
+
+### Migration
+
+The old format (keyed by Fizzy card internal ID) is automatically migrated on first read. No manual intervention needed — existing `work_items.json` files are transparently upgraded to the new source-agnostic format.
+
 ## Worktree Management
 
 When a card is assigned, Brainiac creates a git worktree for the agent to work in. Two config files in the project root control how gitignored files are handled:

data/bin/brainiac

@@ -655,7 +655,8 @@ def list_projects
     default_marker = config["default"] ? " (default)" : ""
     puts "  #{key}#{default_marker}"
     puts "    Path: #{config["repo_path"]}"
-    puts "    Tags: #{config["tags"] || config["project_tags"].join(", ")}"
+    tags = config["tags"] || config["project_tags"]&.join(", ")
+    puts "    Tags: #{tags}" if tags
     puts "    GitHub: #{config["github_repo"]}" if config["github_repo"]
     puts "    Agent: #{config["agent_cli"]} (model: #{config["agent_model"]})"
     puts
@@ -2295,54 +2296,44 @@ when "update", "upgrade"
     end
 
     puts "Updating #{gem_name}..."
-    system("gem install #{gem_name}")
-    unless $CHILD_STATUS.success?
+    output, status = Open3.capture2e("gem install #{gem_name}")
+    puts output
+    unless status.success?
       puts ""
       puts "Failed to update #{gem_name}."
       exit 1
     end
 
-    # Show version change
-    Gem::Specification.reset
-    new_version = begin
-      spec = Gem::Specification.find_by_name(gem_name)
-      spec.version.to_s
-    rescue Gem::MissingSpecError
-      "unknown"
-    end
+    # Parse installed version from gem install output
+    new_version = output[/Successfully installed #{Regexp.escape(gem_name)}-(\S+)/, 1]
 
-    if current_version && current_version == new_version
-      puts "✓ #{gem_name} is already at the latest version (#{new_version})"
-    else
+    if new_version
       puts "✓ Updated #{gem_name}: #{current_version || "new"} → #{new_version}"
       puts "  Restart the server to activate: brainiac restart"
+    else
+      puts "✓ #{gem_name} is already at the latest version (#{current_version})"
     end
   else
     # Update brainiac itself: brainiac update
     current_version = BRAINIAC_VERSION
 
     puts "Updating brainiac gem..."
-    system("gem install brainiac")
-    unless $CHILD_STATUS.success?
+    output, status = Open3.capture2e("gem install brainiac")
+    puts output
+    unless status.success?
       puts ""
       puts "Failed to update brainiac."
       exit 1
     end
 
-    # Show version change
-    Gem::Specification.reset
-    new_version = begin
-      spec = Gem::Specification.find_by_name("brainiac")
-      spec.version.to_s
-    rescue Gem::MissingSpecError
-      "unknown"
-    end
+    # Parse installed version from gem install output
+    new_version = output[/Successfully installed brainiac-(\S+)/, 1]
 
-    if current_version == new_version
-      puts "✓ brainiac is already at the latest version (#{new_version})"
-    else
+    if new_version
       puts "✓ Updated brainiac: #{current_version} → #{new_version}"
       puts "  Restart the server to apply: brainiac restart"
+    else
+      puts "✓ brainiac is already at the latest version (#{current_version})"
     end
   end
 

data/lib/brainiac/config.rb

@@ -5,6 +5,7 @@ require "openssl"
 require "open3"
 require "fileutils"
 require "logger"
+require "securerandom"
 require "net/http"
 require "uri"
 
@@ -37,15 +38,48 @@ end
 BRAINIAC_CONFIG = load_brainiac_config
 
 # --- Default agent name ---
-# Priority: AI_AGENT_NAME env var → brainiac.json "default_agent" → error.
-AI_AGENT_NAME = ENV.fetch("AI_AGENT_NAME", nil) || BRAINIAC_CONFIG["default_agent"] || begin
+# Priority: AI_AGENT_NAME env var → brainiac.json "default_agent" → first agent in agents.json → error.
+def resolve_default_agent
+  # 1. Env var
+  name = ENV.fetch("AI_AGENT_NAME", nil)
+  return name if name
+
+  # 2. brainiac.json
+  name = BRAINIAC_CONFIG["default_agent"]
+  return name if name
+
+  # 3. First agent in agents.json
+  if File.exist?(AGENT_REGISTRY_FILE)
+    agents = begin
+      JSON.parse(File.read(AGENT_REGISTRY_FILE))
+    rescue StandardError
+      {}
+    end
+    first_agent = agents.values.first
+    if first_agent
+      agent_name = first_agent["fizzy_name"] || first_agent["display_name"] || agents.keys.first.capitalize
+      warn <<~MSG
+        [Brainiac] No default agent configured — using "#{agent_name}" (first agent in agents.json).
+        To set explicitly, either:
+          export AI_AGENT_NAME="#{agent_name}"
+        Or add to ~/.brainiac/brainiac.json:
+          { "default_agent": "#{agent_name}" }
+      MSG
+      return agent_name
+    end
+  end
+
+  # 4. Nothing found
   raise <<~MSG
-    No default agent configured. Set one of:
+    No default agent configured and no agents found in #{AGENT_REGISTRY_FILE}.
+    Set one of:
       1. Environment variable: export AI_AGENT_NAME="YourAgent"
       2. In ~/.brainiac/brainiac.json: { "default_agent": "YourAgent" }
   MSG
 end
 
+AI_AGENT_NAME = resolve_default_agent
+
 LOG_LEVEL = ENV.fetch("LOG_LEVEL", "info").downcase
 LOG = Logger.new($stdout)
 LOG.level = case LOG_LEVEL

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

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,6 +122,162 @@ def save_work_item_map(map)
   File.write(WORK_ITEM_MAP_FILE, JSON.pretty_generate(map))
 end
 
+# 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 slugify(title, max_length: 40)
   title.downcase.gsub(/[^a-z0-9\s-]/, "").strip.gsub(/\s+/, "-").slice(0, max_length).chomp("-")
 end
@@ -242,8 +399,27 @@ def resolve_resume(resume, resolved, chdir)
   false
 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)
+  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)
+    LOG.info "[Intent] Skipping dispatch for #{agent_name} — message classified as not requiring response"
+    return true
+  end
+
+  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)
+              source: nil, source_context: {}, skip_column_move: false, cli_provider: nil, resume: false,
+              message: nil, channel: 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)
+
   resolved = resolve_project_cli_config(project_config, cli_provider_override: cli_provider, agent_name: agent_name)
   chdir ||= resolved["repo_path"]
   model ||= resolved["agent_model"]

data/lib/brainiac/intent.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+# Local LLM-based intent detection.
+#
+# Uses a lightweight local model (via Ollama) to classify whether an incoming
+# message requires an agent to respond. This saves expensive API tokens by
+# filtering out messages that are just humans chatting, reactions, or noise.
+#
+# Also detects when an agent's own response implies pending work — if the agent
+# said "I'll do X" but the session ended without completing the work, this
+# signals that the agent should be re-dispatched.
+#
+# Configuration (in ~/.brainiac/brainiac.json):
+#
+#   "intent": {
+#     "enabled": true,
+#     "endpoint": "http://localhost:11434/api/generate",
+#     "model": "gemma3:4b",
+#     "timeout": 10,
+#     "temperature": 0.1
+#   }
+#
+# Plugins use this via:
+#   requires_response = check_intent(message, agent_name: "Galen", context: "Discord thread")
+#   return unless requires_response
+#
+# Returns true (agent should respond), false (skip), or true on any failure
+# (fail-open so we never accidentally ignore a real request).
+
+INTENT_CONFIG_DEFAULTS = {
+  "enabled" => false,
+  "endpoint" => "http://localhost:11434/api/generate",
+  "model" => "gemma3:4b",
+  "timeout" => 10,
+  "temperature" => 0.1
+}.freeze
+
+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.
+
+  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 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 uncertain, lean toward yes (better to respond unnecessarily than miss a request)
+
+  Respond with ONLY "yes" or "no" — nothing else.
+
+  Latest message:
+  {{MESSAGE}}
+PROMPT
+
+PENDING_WORK_PROMPT_TEMPLATE = <<~PROMPT
+  You are analyzing a message posted by an AI agent named {{AGENT_NAME}}. Your job: determine if this message indicates the agent intends to do more work that hasn't been completed yet.
+
+  Rules:
+  - If the agent says it will do something, is about to start work, or promises a follow-up action → yes
+  - If the agent is reporting completed work, summarizing what was done, or delivering a final answer → no
+  - If the agent is asking a clarifying question and waiting for a human response → no
+  - If the agent says things like "give me a sec", "I'll implement this", "let me do that", "working on it" → yes
+  - If uncertain, lean toward no (avoid unnecessary re-dispatches)
+
+  Respond with ONLY "yes" or "no" — nothing else.
+
+  Agent's message:
+  {{MESSAGE}}
+PROMPT
+
+# Load intent config from brainiac.json, merging with defaults.
+def intent_config
+  raw = BRAINIAC_CONFIG["intent"] || {}
+  INTENT_CONFIG_DEFAULTS.merge(raw)
+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")
+# @return [Boolean] true if the agent should respond, false if it can be skipped
+def check_intent(message, agent_name:, channel: "conversation")
+  config = intent_config
+  return true unless config["enabled"]
+  return true if message.nil? || message.strip.empty?
+
+  prompt = INTENT_PROMPT_TEMPLATE
+           .gsub("{{AGENT_NAME}}", agent_name)
+           .gsub("{{CHANNEL}}", channel)
+           .gsub("{{MESSAGE}}", message.strip)
+
+  LOG.info "[Intent] Checking intent for #{agent_name} (#{channel}): #{message.strip.slice(0, 80)}..."
+  response = query_local_llm(prompt, config)
+  result = positive_intent?(response)
+  LOG.info "[Intent] Result: #{result ? "RESPOND" : "SKIP"} (model: #{config["model"]})"
+  result
+rescue StandardError => e
+  LOG.warn "[Intent] Classification failed (fail-open): #{e.message}"
+  true
+end
+
+# Query the local LLM via Ollama's HTTP API.
+#
+# @param prompt [String] The classification prompt
+# @param config [Hash] Intent configuration
+# @return [String] Raw response text from the model
+def query_local_llm(prompt, config)
+  uri = URI(config["endpoint"])
+  payload = {
+    model: config["model"],
+    prompt: prompt,
+    stream: false,
+    options: { temperature: config["temperature"] }
+  }
+
+  http = Net::HTTP.new(uri.host, uri.port)
+  http.open_timeout = config["timeout"]
+  http.read_timeout = config["timeout"]
+
+  request = Net::HTTP::Post.new(uri.path, "Content-Type" => "application/json")
+  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)
+
+  body = JSON.parse(response.body)
+  body["response"] || ""
+rescue Errno::ECONNREFUSED
+  raise "Ollama not running at #{config["endpoint"]}"
+rescue Net::OpenTimeout, Net::ReadTimeout
+  raise "Ollama timed out after #{config["timeout"]}s"
+end
+
+# Parse the LLM's yes/no response into a boolean.
+# Fail-open: anything that isn't clearly "no" returns true.
+#
+# @param response [String] Raw response from the model
+# @return [Boolean]
+def positive_intent?(response)
+  cleaned = response.to_s.strip.downcase.gsub(/[^a-z]/, "")
+  cleaned != "no"
+end
+
+# Check whether an agent's own message implies pending work that wasn't completed.
+# Used to detect when an agent posted "I'll do X" but the session ended without
+# actually doing the work — signaling the agent should be re-dispatched.
+#
+# Fail-closed: returns false on any error (don't re-dispatch on classification failure).
+#
+# @param message [String] The agent's posted message
+# @param agent_name [String] The agent who posted it
+# @return [Boolean] true if the message implies uncommitted work
+def check_pending_work(message, agent_name:)
+  config = intent_config
+  return false unless config["enabled"]
+  return false if message.nil? || message.strip.empty?
+
+  prompt = PENDING_WORK_PROMPT_TEMPLATE
+           .gsub("{{AGENT_NAME}}", agent_name)
+           .gsub("{{MESSAGE}}", message.strip)
+
+  response = query_local_llm(prompt, config)
+  result = pending_work_detected?(response)
+  LOG.info "[Intent] Pending work detected in #{agent_name}'s message" if result
+  result
+rescue StandardError => e
+  LOG.warn "[Intent] Pending work check failed (fail-closed): #{e.message}"
+  false
+end
+
+# Parse the LLM's yes/no response for pending work detection.
+# Fail-closed: anything that isn't clearly "yes" returns false.
+#
+# @param response [String] Raw response from the model
+# @return [Boolean]
+def pending_work_detected?(response)
+  cleaned = response.to_s.strip.downcase.gsub(/[^a-z]/, "")
+  cleaned == "yes"
+end

data/lib/brainiac/routes/api.rb

@@ -354,6 +354,67 @@ post "/api/cron/reload" do
   { status: "reloaded", jobs: CRON_JOBS.size }.to_json
 end
 
+# --- Intent ---
+
+get "/api/intent/config" do
+  content_type :json
+  config = intent_config
+  status = if config["enabled"]
+             begin
+               uri = URI(config["endpoint"].sub("/api/generate", "/api/tags"))
+               http = Net::HTTP.new(uri.host, uri.port)
+               http.open_timeout = 3
+               http.read_timeout = 3
+               response = http.get(uri.path)
+               if response.is_a?(Net::HTTPSuccess)
+                 models = JSON.parse(response.body).fetch("models", []).map { |m| m["name"] }
+                 model_available = models.any? { |m| m.start_with?(config["model"].split(":").first) }
+                 model_available ? "ok" : "model_not_found"
+               else
+                 "ollama_error"
+               end
+             rescue Errno::ECONNREFUSED
+               "ollama_not_running"
+             rescue StandardError => e
+               "error: #{e.message}"
+             end
+           else
+             "disabled"
+           end
+  config.merge("status" => status).to_json
+end
+
+post "/api/intent/check" do
+  content_type :json
+  request.body.rewind
+  payload = JSON.parse(request.body.read)
+
+  message = payload["message"]
+  agent = payload["agent"] || AI_AGENT_NAME
+  channel = payload["channel"] || "conversation"
+
+  halt 400, { error: "Missing 'message' field" }.to_json unless message && !message.empty?
+
+  result = check_intent(message, agent_name: agent, channel: channel)
+  { should_respond: result, agent: agent, channel: channel }.to_json
+end
+
+post "/api/intent/pending-work" do
+  content_type :json
+  request.body.rewind
+  payload = JSON.parse(request.body.read)
+
+  message = payload["message"]
+  agent = payload["agent"] || AI_AGENT_NAME
+
+  halt 400, { error: "Missing 'message' field" }.to_json unless message && !message.empty?
+
+  result = check_pending_work(message, agent_name: agent)
+  { pending_work: result, agent: agent }.to_json
+end
+
+# --- Cron Logs ---
+
 get "/api/cron/logs" do
   content_type :json
   job_id = params["id"]

data/lib/brainiac/version.rb

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

data/lib/brainiac.rb

@@ -7,6 +7,7 @@ require_relative "brainiac/skills"
 require_relative "brainiac/sessions"
 require_relative "brainiac/prompts"
 require_relative "brainiac/helpers"
+require_relative "brainiac/intent"
 require_relative "brainiac/cron"
 require_relative "brainiac/plugins"
 

data/receiver.rb

@@ -24,6 +24,7 @@ require_relative "lib/brainiac/helpers"
 require_relative "lib/brainiac/notifications"
 require_relative "lib/brainiac/cron"
 require_relative "lib/brainiac/restart"
+require_relative "lib/brainiac/intent"
 require_relative "lib/brainiac/plugins"
 require_relative "lib/brainiac/handlers/shared/git"
 require_relative "lib/brainiac/handlers/shared/inline_tags"
@@ -98,6 +99,11 @@ configure do
 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"]}"
+else
+  LOG.info "[Intent] Disabled (enable in brainiac.json → intent.enabled: true)"
+end
 
 # --- Dashboard authentication ---
 

data/templates/brainiac.json.example

@@ -1,3 +1,10 @@
 {
-  "default_agent": "Sherlock"
+  "default_agent": "Sherlock",
+  "intent": {
+    "enabled": false,
+    "endpoint": "http://localhost:11434/api/generate",
+    "model": "gemma3:4b",
+    "timeout": 10,
+    "temperature": 0.1
+  }
 }

data/templates/hooks/pre-commit

@@ -0,0 +1,14 @@
+#!/bin/bash
+# Pre-commit hook: auto-run `bundle` when version.rb changes
+# This ensures Gemfile.lock stays in sync with gemspec version bumps.
+
+if git diff --cached --name-only | grep -q "version\.rb$"; then
+  echo "🔒 version.rb changed — running bundle to sync Gemfile.lock..."
+  bundle install --quiet
+  if [ $? -ne 0 ]; then
+    echo "❌ bundle install failed. Fix the issue and try again."
+    exit 1
+  fi
+  git add Gemfile.lock
+  echo "✅ Gemfile.lock updated and staged."
+fi

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: brainiac
 version: !ruby/object:Gem::Version
-  version: 0.0.12
+  version: 0.0.14
 platform: ruby
 authors:
 - Andy Davis
@@ -133,6 +133,7 @@ files:
 - lib/brainiac/handlers/shared/inline_tags.rb
 - lib/brainiac/helpers.rb
 - lib/brainiac/hooks.rb
+- lib/brainiac/intent.rb
 - lib/brainiac/notifications.rb
 - lib/brainiac/plugins.rb
 - lib/brainiac/prompts.rb
@@ -159,6 +160,7 @@ files:
 - templates/brainiac.json.example
 - templates/cli-providers/grok.json.example
 - templates/cli-providers/kiro.json.example
+- templates/hooks/pre-commit
 - templates/plugins.json.example
 - templates/roles/code-reviewer.md.example
 - templates/roles/general-engineer.md.example