zillacore 0.0.1

data/certs/stowzilla.pem

@@ -0,0 +1,26 @@
+-----BEGIN CERTIFICATE-----
+MIIEdDCCAtygAwIBAgIBATANBgkqhkiG9w0BAQsFADBAMQ4wDAYDVQQDDAVhZ2Vu
+dDEZMBcGCgmSJomT8ixkARkWCXN0b3d6aWxsYTETMBEGCgmSJomT8ixkARkWA2Nv
+bTAeFw0yNjA2MDgxOTExNTlaFw0yNzA2MDgxOTExNTlaMEAxDjAMBgNVBAMMBWFn
+ZW50MRkwFwYKCZImiZPyLGQBGRYJc3Rvd3ppbGxhMRMwEQYKCZImiZPyLGQBGRYD
+Y29tMIIBojANBgkqhkiG9w0BAQEFAAOCAY8AMIIBigKCAYEAupBquKI/4WvXOgND
+pXyqH2GllZs1wG4TWWdn/DoMg45UoCwD+AWEuGrIdInBCpPN8vEJNJWPoM/RrU+b
+xRBZT4uUk00bnZRW2SYh5GJSqBoBR+rWc2DGkXyGfdRU2sQvkB0+is6ChgQ61WMM
+33LE9+loBlVsZ6EVtrc18Uh2OW0mJpe0hN2nmBrxZqqOZigxC4DKRMFHvpRkxSb6
+mD4kit1AcwX9NEWJsXxrPaetL/SB/VbXaEZX93XAvp6USaXvCWt4slkDS2mIvqtn
+9DtGC43LFC7SDGbnsG9PVenQgVCi8UWFPUAab0PqZSlmi3Qlbhw8qTGPp5Cbv4vz
+qjC2UGPOQigA/7lbbGRhCohMrjOVHMAQwkcgiIqtolUoYlnvPMIy+m3pdvgDv/PH
+bsZGvXQ7i0458xsmp1vaKthZocVAR+GboHbuIiYPUnO45ccXUQ00x6365tTe7mZi
+NvmUYdAGbQmVvFqyxF7IYA6sF74L2Lstu0knSfss557bAe1HAgMBAAGjeTB3MAkG
+A1UdEwQCMAAwCwYDVR0PBAQDAgSwMB0GA1UdDgQWBBSnxTL/lNBCeLqpeVIX6AUY
+kel4zjAeBgNVHREEFzAVgRNhZ2VudEBzdG93emlsbGEuY29tMB4GA1UdEgQXMBWB
+E2FnZW50QHN0b3d6aWxsYS5jb20wDQYJKoZIhvcNAQELBQADggGBACm9Fjit/UCv
+FxlKqeiCTIG94cIx+QrWAOJSx9knKydwUec1u04D/DbfZjTn3C2Bj227QgxeUn+6
+if3e2v7zAk1896hLmGYzML0+nxQPb0vmtdLR7HETUlSKTVabcv1fbwLyjsuGrBvk
+y51vOEzUEZ508a9yepLYqrQu1kOju4d57c9oA5l3H0mMKWz7av9tFj0B+STvuaWk
+HRYDWc5HgOEVTyV+w0uFt2Kw4OCb8C42uSvC5RfYYtw78MSP+5Ru+LXJ7XOtmuN0
+E6GVmofQ17ig9O3rgfFbMendSInrRmvPIGswvM1yivq9NOllFbdck2OJKPx6FCJF
+7SJIkXQfc9P4B5iASIV1d1FsE0YX+g3jHXPJK/4mGL5bAyBKzpMfQB/mg6vQBzkh
+aOKPwcreFj7TznBl89R5tNS9wZQfPVR98zgPyocddWhK18eQNMSBUnv4eeJ8PPbk
+DovL+G8ajHDZ9fjH/+GVYHEMuiVdLarXrKJpHC1VfGTTUAp4NSEpUQ==
+-----END CERTIFICATE-----

data/docs/waybar-config.md

@@ -0,0 +1,96 @@
+# Agent Display Configuration (Waybar / xbar)
+
+This file configures how agents appear in the status bar — waybar on Linux, xbar on macOS.
+
+**Location:** `~/.zillacore/waybar.json`
+
+## Example Configuration
+
+```json
+{
+  "agents": [
+    {
+      "name": "GLaDOS",
+      "emoji": "🤖",
+      "color": "blue"
+    },
+    {
+      "name": "Galen",
+      "emoji": "🛠️",
+      "color": "green"
+    },
+    {
+      "name": "Threepio",
+      "emoji": "📝",
+      "color": "yellow"
+    },
+    {
+      "name": "Sheogorath",
+      "emoji": "🎭",
+      "color": "purple"
+    },
+    {
+      "name": "Kaylee",
+      "emoji": "🔧",
+      "color": "pink"
+    },
+    {
+      "name": "Avon",
+      "emoji": "🔐",
+      "color": "red"
+    },
+    {
+      "name": "Sleeper Service",
+      "emoji": "💤",
+      "color": "cyan"
+    }
+  ],
+  "default_emoji": "❓",
+  "schema_version": "1.0"
+}
+```
+
+## Fields
+
+- **name**: Agent name (must match agent registry)
+- **emoji**: Display emoji for waybar
+- **color**: Terminal color for logs (red, green, blue, yellow, cyan, magenta, white)
+- **default_emoji**: Fallback emoji when agent is unknown
+- **schema_version**: Config format version
+
+## Usage
+
+Monitor scripts automatically load this file:
+- `monitor/waybar.rb` - Waybar status display (Linux)
+- `monitor/xbar.3s.rb` - xbar menu bar plugin (macOS)
+- `monitor/daemon.rb` - Background monitor daemon
+- `monitor/view-logs.rb` - Log viewer
+- `monitor/view-logs-rofi.rb` - Rofi log selector
+
+### Linux (Waybar)
+
+```bash
+ruby monitor/setup-waybar-module.rb   # One-time setup
+omarchy restart waybar                 # Restart waybar
+```
+
+### macOS (xbar)
+
+Requires [xbar](https://xbarapp.com) (free, formerly BitBar).
+
+```bash
+ruby monitor/setup-xbar-plugin.rb     # One-time setup (symlinks plugin)
+# Restart xbar to activate
+```
+
+The xbar plugin reads from the same daemon socket as waybar. Make sure the monitor daemon is running:
+
+```bash
+ruby monitor/daemon.rb &
+```
+
+After editing agent config, restart zillacore:
+```bash
+zillacore restart
+```
+

data/lib/user_registry.rb

@@ -0,0 +1,159 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "json"
+
+# UserRegistry - Centralized user identity tracking
+#
+# Resolves user identities across platforms (Discord, GitHub, Fizzy)
+# and provides canonical names, aliases, and relationships.
+#
+# Usage:
+#   registry = UserRegistry.new
+#   user = registry.find_by_discord_id('832331260088287242')
+#   puts user['canonical_name']  # => "Adam Dalton"
+#   puts user['identities']['github']['username']  # => "dalton"
+#
+class UserRegistry
+  USERS_FILE = File.expand_path("~/.zillacore/users.json")
+
+  def initialize
+    @data = load_data
+  end
+
+  # Find user by Discord user ID
+  def find_by_discord_id(user_id)
+    @data["users"].find { |u| u.dig("identities", "discord", "user_id") == user_id.to_s }
+  end
+
+  # Find user by Discord username
+  def find_by_discord_username(username)
+    @data["users"].find { |u| u.dig("identities", "discord", "username") == username.to_s }
+  end
+
+  # Find user by GitHub username
+  def find_by_github_username(username)
+    @data["users"].find { |u| u.dig("identities", "github", "username") == username.to_s }
+  end
+
+  # Find user by Fizzy username
+  def find_by_fizzy_username(username)
+    @data["users"].find { |u| u.dig("identities", "fizzy", "username") == username.to_s }
+  end
+
+  # Find user by canonical name
+  def find_by_canonical_name(name)
+    @data["users"].find { |u| u["canonical_name"].downcase == name.downcase }
+  end
+
+  # Find user by any identifier (tries all platforms)
+  def find(identifier)
+    find_by_discord_id(identifier) ||
+      find_by_discord_username(identifier) ||
+      find_by_github_username(identifier) ||
+      find_by_fizzy_username(identifier) ||
+      find_by_canonical_name(identifier)
+  end
+
+  # Get all users
+  def all
+    @data["users"]
+  end
+
+  # Get all human users (exclude AI agents)
+  def humans
+    @data["users"].reject { |u| u["notes"]&.include?("AI agent") }
+  end
+
+  # Get all AI agents
+  def agents
+    @data["users"].select { |u| u["notes"]&.include?("AI agent") }
+  end
+
+  # Reload data from disk
+  def reload!
+    @data = load_data
+  end
+
+  private
+
+  def load_data
+    return { "users" => [] } unless File.exist?(USERS_FILE)
+
+    JSON.parse(File.read(USERS_FILE))
+  rescue JSON::ParserError => e
+    warn "Failed to parse #{USERS_FILE}: #{e.message}"
+    { "users" => [] }
+  end
+end
+
+# CLI interface when run directly
+if __FILE__ == $PROGRAM_NAME
+  require "optparse"
+
+  options = {}
+  OptionParser.new do |opts|
+    opts.banner = "Usage: user_registry.rb [options] [identifier]"
+
+    opts.on("-d", "--discord-id ID", "Find by Discord user ID") do |id|
+      options[:discord_id] = id
+    end
+
+    opts.on("-u", "--discord-username USERNAME", "Find by Discord username") do |username|
+      options[:discord_username] = username
+    end
+
+    opts.on("-g", "--github USERNAME", "Find by GitHub username") do |username|
+      options[:github] = username
+    end
+
+    opts.on("-f", "--fizzy USERNAME", "Find by Fizzy username") do |username|
+      options[:fizzy] = username
+    end
+
+    opts.on("-l", "--list", "List all users") do
+      options[:list] = true
+    end
+
+    opts.on("--humans", "List only human users") do
+      options[:humans] = true
+    end
+
+    opts.on("--agents", "List only AI agents") do
+      options[:agents] = true
+    end
+
+    opts.on("-h", "--help", "Show this help") do
+      puts opts
+      exit
+    end
+  end.parse!
+
+  registry = UserRegistry.new
+
+  if options[:list]
+    puts JSON.pretty_generate(registry.all)
+  elsif options[:humans]
+    puts JSON.pretty_generate(registry.humans)
+  elsif options[:agents]
+    puts JSON.pretty_generate(registry.agents)
+  elsif options[:discord_id]
+    user = registry.find_by_discord_id(options[:discord_id])
+    puts user ? JSON.pretty_generate(user) : "User not found"
+  elsif options[:discord_username]
+    user = registry.find_by_discord_username(options[:discord_username])
+    puts user ? JSON.pretty_generate(user) : "User not found"
+  elsif options[:github]
+    user = registry.find_by_github_username(options[:github])
+    puts user ? JSON.pretty_generate(user) : "User not found"
+  elsif options[:fizzy]
+    user = registry.find_by_fizzy_username(options[:fizzy])
+    puts user ? JSON.pretty_generate(user) : "User not found"
+  elsif ARGV[0]
+    user = registry.find(ARGV[0])
+    puts user ? JSON.pretty_generate(user) : "User not found"
+  else
+    puts "No search criteria provided. Use --help for usage."
+    exit 1
+  end
+end

data/lib/zillacore/agents.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+# Agent registry, discovery, identity, mention detection, and env injection.
+#
+# The registry at ~/.zillacore/agents.json uses a generic `env` hash so any
+# environment variable can be set per-agent:
+#
+#   {
+#     "galen": {
+#       "fizzy_name": "Galen",
+#       "local": true,
+#       "env": {
+#         "FIZZY_TOKEN": "fizzy_abc...",
+#         "DISCORD_BOT_TOKEN": "Bot_abc..."
+#       }
+#     }
+#   }
+#
+# The "local" flag marks agents that this machine should dispatch work for
+# (card assignments). Agents without "local": true are still known for
+# mention detection, display names, tokens, and cross-agent interactions —
+# they just won't pick up card assignments on this machine.
+#
+# Legacy format with top-level `fizzy_token` / `discord_bot_token` keys is
+# auto-migrated into the `env` hash at load time.
+
+def load_agent_registry
+  if File.exist?(AGENT_REGISTRY_FILE)
+    raw_registry = JSON.parse(File.read(AGENT_REGISTRY_FILE))
+    LOG.info "Loaded agent registry (#{raw_registry.size} agents) from #{AGENT_REGISTRY_FILE}"
+
+    # Normalize keys: convert to lowercase, replace non-alphanumeric with hyphens
+    registry = {}
+    raw_registry.each do |key, entry|
+      normalized_key = key.downcase.gsub(/[^a-z0-9-]/, "-")
+      if registry.key?(normalized_key) && registry[normalized_key] != entry
+        LOG.warn "Duplicate agent key after normalization: '#{key}' → '#{normalized_key}' (already exists)"
+      end
+      registry[normalized_key] = entry
+    end
+
+    # Migrate legacy keys into env hash
+    registry.each_value do |entry|
+      next unless entry.is_a?(Hash)
+
+      entry["env"] ||= {}
+      # Migrate fizzy_token → FIZZY_TOKEN
+      if (ft = entry.delete("fizzy_token"))
+        entry["env"]["FIZZY_TOKEN"] ||= ft
+      end
+      # Migrate discord_bot_token → DISCORD_BOT_TOKEN
+      if (dt = entry.delete("discord_bot_token"))
+        entry["env"]["DISCORD_BOT_TOKEN"] ||= dt
+      end
+    end
+    return registry
+  end
+
+  if File.exist?(AGENT_TOKENS_FILE)
+    tokens = JSON.parse(File.read(AGENT_TOKENS_FILE))
+    LOG.info "Loaded legacy agent tokens (#{tokens.size} agents) from #{AGENT_TOKENS_FILE}"
+    return tokens.transform_values { |token| { "env" => { "FIZZY_TOKEN" => token } } }
+  end
+
+  {}
+rescue JSON::ParserError => e
+  LOG.error "Failed to parse agent registry: #{e.message}"
+  {}
+end
+
+AGENT_REGISTRY = load_agent_registry
+
+def reload_agent_registry!(force: false)
+  return unless file_changed?(AGENT_REGISTRY_FILE, force: force)
+
+  AGENT_REGISTRY.replace(load_agent_registry)
+  LOG.info "Reloaded agent registry: #{AGENT_REGISTRY.keys.join(", ")}"
+end
+
+# Get the env hash for an agent. Returns {} if none configured.
+def agent_env_for(agent_name)
+  return {} unless agent_name
+
+  key = agent_name.downcase.gsub(/[^a-z0-9-]/, "-")
+  entry = AGENT_REGISTRY[key]
+  return {} unless entry.is_a?(Hash)
+
+  entry["env"] || {}
+end
+
+# Get a specific env var for an agent. Returns nil if not set.
+def agent_env_var(agent_name, var_name)
+  agent_env_for(agent_name)[var_name]
+end
+
+# Convenience: get the Fizzy token for an agent.
+def fizzy_token_for(agent_name)
+  agent_env_var(agent_name, "FIZZY_TOKEN")
+end
+
+# Convenience: build env hash for fizzy CLI calls (backward compat).
+# Falls back to default agent token when the given agent has no token.
+def fizzy_env_for(agent_name)
+  token = fizzy_token_for(agent_name) || fizzy_token_for(AI_AGENT_NAME)
+  token ? { "FIZZY_TOKEN" => token } : {}
+end
+
+def default_fizzy_env
+  fizzy_env_for(AI_AGENT_NAME)
+end
+
+def fizzy_display_name(agent_name)
+  return agent_name unless agent_name
+
+  key = agent_name.downcase.gsub(/[^a-z0-9-]/, "-")
+  entry = AGENT_REGISTRY[key]
+  return agent_name unless entry.is_a?(Hash)
+
+  entry["fizzy_name"] || agent_name
+end
+
+def agent_roster
+  roster = {}
+  all_agent_names.each { |name| roster[name.downcase] = fizzy_display_name(name) }
+  roster
+end
+
+def discover_kiro_agents
+  return [] unless File.directory?(KIRO_AGENTS_DIR)
+
+  Dir.glob(File.join(KIRO_AGENTS_DIR, "*.json")).map { |path| File.basename(path, ".json") }
+rescue StandardError => e
+  LOG.error "Failed to scan kiro agents directory: #{e.message}"
+  []
+end
+
+def agent_name_for(project_config)
+  project_config["agent_name"] || AI_AGENT_NAME
+end
+
+def all_agent_names
+  names = Set.new([AI_AGENT_NAME])
+  PROJECTS.each_value { |config| names << config["agent_name"] if config["agent_name"] }
+  discover_kiro_agents.each { |name| names << name.capitalize }
+  # Include agents from the registry (with their fizzy_name if specified)
+  AGENT_REGISTRY.each do |key, entry|
+    names << (entry["fizzy_name"] || key.capitalize)
+  end
+  names
+end
+
+# Agents marked "local": true in the registry — only these should pick up
+# card assignments on this machine. All other agents are still "known" for
+# mention detection, tokens, and display names.
+def local_agent_names
+  names = Set.new
+  # The default AI_AGENT_NAME is always local (it's this machine's primary agent)
+  names << AI_AGENT_NAME
+  # Project-configured agents are local by definition
+  PROJECTS.each_value { |config| names << config["agent_name"] if config["agent_name"] }
+  # kiro-cli agent configs on disk are local
+  discover_kiro_agents.each { |name| names << name.capitalize }
+  # Registry agents only if explicitly marked local
+  AGENT_REGISTRY.each do |key, entry|
+    next unless entry.is_a?(Hash) && entry["local"]
+
+    names << (entry["fizzy_name"] || key.capitalize)
+  end
+  names
+end
+
+def detect_mentioned_agent(text)
+  downcased = text.downcase
+  # Exact full-name match first (highest priority)
+  all_agent_names.each do |name|
+    return name if downcased.include?("@#{name.downcase}")
+
+    # Fizzy renders mentions using first name only (e.g. "@Sleeper" not "@Sleeper Service").
+    # Fall back to matching the first word of multi-word agent names.
+    first_word = name.split.first.downcase
+    next if first_word == name.downcase # already checked above
+    return name if downcased.include?("@#{first_word}")
+  end
+  nil
+end
+
+def detect_mentioned_user_ids(text)
+  return [] unless FIZZY_CONFIG["authorized_users"]
+
+  mentioned_ids = []
+  FIZZY_CONFIG["authorized_users"].each do |user|
+    name = user["name"]
+    mentioned_ids << user["id"] if text.downcase.include?("@#{name.downcase}")
+  end
+  mentioned_ids
+end
+
+def comment_from_agent?(name)
+  return false unless name
+
+  downcased = name.downcase
+  all_agent_names.any? { |agent| agent.downcase == downcased }
+end

data/lib/zillacore/brain.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+# Brain (long-term memory via qmd) — query, context building, and git sync.
+
+BRAIN_SYNC_MUTEX = Mutex.new
+BRAIN_LAST_PULL = { at: nil }
+
+def memory_dir_for(agent_name)
+  File.join(MEMORY_BASE_DIR, agent_name.downcase.gsub(/[^a-z0-9-]/, "-"))
+end
+
+def persona_dir_for(agent_name)
+  File.join(PERSONA_BASE_DIR, agent_name.downcase.gsub(/[^a-z0-9-]/, "-"))
+end
+
+def persona_collection_for(agent_name)
+  "#{agent_name.downcase.gsub(/[^a-z0-9-]/, "-")}-persona"
+end
+
+# --- Brain git sync ---
+
+def brain_git_repo?
+  File.directory?(File.join(BRAIN_BASE_DIR, ".git"))
+end
+
+# Internal pull logic without mutex (for use inside synchronized blocks)
+def brain_pull_internal(force: false)
+  return unless brain_git_repo?
+
+  # Skip if we pulled within the last 30 seconds (avoid hammering on rapid-fire sessions)
+  unless force
+    last = BRAIN_LAST_PULL[:at]
+    return if last && (Time.now - last) < 30
+  end
+
+  # Stash any uncommitted changes, pull, then pop
+  status, = Open3.capture2("git", "status", "--porcelain", chdir: BRAIN_BASE_DIR)
+  has_changes = !status.strip.empty?
+
+  if has_changes
+    Open3.capture2("git", "add", "-A", chdir: BRAIN_BASE_DIR)
+    Open3.capture2("git", "stash", chdir: BRAIN_BASE_DIR)
+  end
+
+  output, pull_status = Open3.capture2e("git", "pull", "--rebase", "--autostash", chdir: BRAIN_BASE_DIR)
+  if pull_status.success?
+    LOG.info "[Brain] Pulled latest changes"
+  else
+    LOG.warn "[Brain] Pull failed: #{output.strip}"
+    # Abort rebase if it got stuck
+    Open3.capture2("git", "rebase", "--abort", chdir: BRAIN_BASE_DIR)
+  end
+
+  Open3.capture2("git", "stash", "pop", chdir: BRAIN_BASE_DIR) if has_changes
+
+  BRAIN_LAST_PULL[:at] = Time.now
+end
+
+# Pull latest brain changes. Safe to call frequently — skips if pulled recently.
+# Uses rebase to keep history clean and auto-resolves conflicts by keeping both sides.
+def brain_pull(force: false)
+  return unless brain_git_repo?
+
+  BRAIN_SYNC_MUTEX.synchronize do
+    brain_pull_internal(force: force)
+  end
+rescue StandardError => e
+  LOG.warn "[Brain] Pull error: #{e.message}"
+end
+
+# Commit and push any brain changes. Called after agent sessions complete.
+def brain_push(message: "brain update", retries: 3)
+  return unless brain_git_repo?
+
+  BRAIN_SYNC_MUTEX.synchronize do
+    # Check for changes
+    status, = Open3.capture2("git", "status", "--porcelain", chdir: BRAIN_BASE_DIR)
+    return if status.strip.empty?
+
+    Open3.capture2("git", "add", "-A", chdir: BRAIN_BASE_DIR)
+    Open3.capture2("git", "commit", "-m", message, chdir: BRAIN_BASE_DIR)
+
+    retries.times do |attempt|
+      brain_pull_internal(force: true) if attempt.positive?
+
+      _, push_status = Open3.capture2e("git", "push", chdir: BRAIN_BASE_DIR)
+      if push_status.success?
+        LOG.info "[Brain] Pushed changes#{" (retry #{attempt})" if attempt.positive?}"
+        break
+      end
+
+      sleep(2**attempt) if attempt < retries - 1
+    end
+
+    LOG.warn "[Brain] Push failed after #{retries} attempts"
+  end
+rescue StandardError => e
+  LOG.warn "[Brain] Push error: #{e.message}"
+end
+
+def query_brain(search_terms, agent_name: AI_AGENT_NAME, scope: :knowledge, max_results: 5)
+  return "" unless system("which qmd > /dev/null 2>&1")
+
+  collection = case scope
+               when :persona then persona_collection_for(agent_name)
+               else KNOWLEDGE_COLLECTION
+               end
+
+  output, status = Open3.capture2("qmd", "search", search_terms, "-c", collection, "-n", max_results.to_s, "--md")
+  return "" unless status.success? && !output.strip.empty?
+
+  output.strip
+rescue StandardError => e
+  LOG.warn "Brain query failed (#{scope}, #{agent_name}): #{e.message}"
+  ""
+end
+
+def extract_topics(card_title, comment_body, project_key)
+  text = [card_title, comment_body].compact.join(" ")
+  # Strip common noise words, extract meaningful terms
+  stopwords = %w[the a an is are was were be been being have has had do does did will would shall should
+                 may might can could this that these those it its i me my we our you your he she they them
+                 to of in for on with at by from as into through during before after above below between
+                 and or but not no nor so yet both either neither each every all any few more most other
+                 some such only own same than too very just don doesn didn won wasn weren isn aren hasn
+                 haven hadn couldn shouldn wouldn about also back even still already again further then
+                 once here there when where why how what which who whom whose if because since while
+                 please thanks thank need want like make sure get got going go let know think see look
+                 work try use find give tell ask seem feel become leave call keep put run move live
+                 update fix add create new change set up check out]
+  words = text.downcase.gsub(/[^a-z0-9\s_-]/, " ").split.uniq - stopwords
+  topics = words.select { |w| w.length > 2 }.first(8)
+  topics << project_key if project_key && !project_key.empty?
+  topics.compact.uniq
+end
+
+def build_brain_context(agent_name: AI_AGENT_NAME, card_title: "", card_number: nil, project_key: nil, comment_body: "", source: nil)
+  Thread.new { brain_pull }
+
+  topics = extract_topics(card_title, comment_body, project_key)
+  primary_query = topics.first(5).join(" ")
+  primary_query = "project conventions" if primary_query.empty?
+
+  fizzy_mentioned = [card_title, comment_body].any? { |s| s&.match?(/fizzy/i) }
+  fizzy_originated = source == :fizzy
+
+  search_queries = [primary_query]
+
+  knowledge_threads = [
+    Thread.new { query_brain(primary_query, scope: :knowledge, max_results: 3) },
+    Thread.new { query_brain(agent_name, scope: :knowledge, max_results: 2) }
+  ]
+  search_queries << agent_name
+
+  if fizzy_mentioned || fizzy_originated
+    knowledge_threads << Thread.new { query_brain("fizzy CLI commands", scope: :knowledge, max_results: 2) }
+    search_queries << "fizzy CLI commands"
+  end
+
+  persona_thread = Thread.new { query_brain("personality tone voice communication style", agent_name: agent_name, scope: :persona, max_results: 5) }
+
+  all_knowledge = knowledge_threads.map(&:value).reject(&:empty?)
+  persona_result = persona_thread.value
+
+  sections = []
+
+  unless persona_result.empty?
+    sections << <<~PERSONA
+      ## Brain — Persona (auto-retrieved, CRITICAL)
+      The following is YOUR personality, communication style, and voice.
+      You MUST use this to shape every response you write — tone, word choice, humor, attitude.
+      This is who you ARE. Do not respond in a generic or neutral voice.
+
+      #{persona_result}
+    PERSONA
+  end
+
+  unless all_knowledge.empty?
+    knowledge_text = all_knowledge.join("\n\n")
+    sections << <<~BRAIN
+      ## Brain — Knowledge (auto-retrieved for: #{search_queries.map { |q| %("#{q}") }.join(", ")})
+      The following is relevant technical knowledge from your long-term memory.
+      These are project conventions, coding patterns, lessons learned, and decisions
+      that past-you saved for exactly this kind of work. Use it to inform your implementation.
+      If these results don't look relevant to your current task, search manually with better terms.
+
+      #{knowledge_text}
+    BRAIN
+  end
+
+  # Auto-inject skills: semantically match skills against current task context
+  skill_search_context = [card_title, comment_body, primary_query].compact.reject(&:empty?).join(" ")
+  skill_section = auto_inject_skills(skill_search_context)
+  sections << skill_section unless skill_section.empty?
+
+  sections.join("\n")
+end