brainiac 0.0.5 → 0.0.7

data/lib/brainiac/handlers/shared/git.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+# Shared git operations: worktree lifecycle, branching, fetching, cleanup.
+#
+# All git-related utilities live here. Handlers call these instead of
+# reimplementing git worktree/branch logic.
+
+# Debounced repo git fetch — avoids fetching the same repo multiple times within a short window.
+REPO_LAST_FETCH = {}
+REPO_FETCH_DEBOUNCE = 300 # 5 minutes
+
+def debounced_repo_fetch(repo_path)
+  last = REPO_LAST_FETCH[repo_path]
+  if last && (Time.now - last) < REPO_FETCH_DEBOUNCE
+    LOG.info "Skipping git fetch for #{repo_path} — fetched #{(Time.now - last).to_i}s ago"
+    return
+  end
+
+  run_cmd("git", "fetch", "origin", chdir: repo_path)
+  REPO_LAST_FETCH[repo_path] = Time.now
+end
+
+def get_default_branch(repo_path)
+  default_branch = run_cmd("git", "rev-parse", "--abbrev-ref", "HEAD", chdir: repo_path).strip
+  begin
+    run_cmd("git", "symbolic-ref", "--short", "refs/remotes/origin/HEAD", chdir: repo_path).strip.sub("origin/", "")
+  rescue StandardError
+    default_branch
+  end
+end
+
+# Capture git HEAD and working tree status for a directory.
+def capture_git_state(chdir)
+  head, = Open3.capture2("git", "rev-parse", "HEAD", chdir: chdir)
+  status, = Open3.capture2("git", "status", "--porcelain", chdir: chdir)
+  [head.strip, status.strip]
+rescue StandardError
+  [nil, nil]
+end
+
+# Trust the version manager config in a directory (supports mise and asdf)
+def trust_version_manager(path, chdir:)
+  if system("which mise >/dev/null 2>&1")
+    run_cmd("mise", "trust", path, chdir: chdir)
+  elsif system("which asdf >/dev/null 2>&1")
+    LOG.info "asdf detected — no explicit trust needed for #{path}"
+  else
+    LOG.info "No version manager (mise/asdf) found — skipping trust for #{path}"
+  end
+rescue StandardError => e
+  LOG.warn "Could not trust version manager in #{path}: #{e.message}"
+end
+
+# Copy gitignored files matching .worktreeinclude patterns from repo to worktree.
+# Symlink directories matching .worktreelink patterns instead of copying.
+def apply_worktree_includes(repo_path, worktree_path)
+  copied = 0
+  linked = 0
+
+  [".worktreeinclude", ".worktreelink"].each do |filename|
+    config_file = File.join(repo_path, filename)
+    next unless File.exist?(config_file)
+
+    symlink_mode = filename == ".worktreelink"
+    patterns = File.readlines(config_file).map(&:strip).reject { |l| l.empty? || l.start_with?("#") }
+    next if patterns.empty?
+
+    patterns.each do |pattern|
+      Dir.glob(pattern, File::FNM_DOTMATCH, base: repo_path).each do |match|
+        src = File.join(repo_path, match)
+        dest = File.join(worktree_path, match)
+        next if File.exist?(dest) || File.symlink?(dest)
+
+        _, _, st = Open3.capture3("git", "check-ignore", "-q", match, chdir: repo_path)
+        next unless st.success?
+
+        FileUtils.mkdir_p(File.dirname(dest))
+
+        if symlink_mode && File.directory?(src)
+          FileUtils.ln_s(src, dest)
+          linked += 1
+          LOG.info "Symlinked #{match} from main repo"
+        elsif File.file?(src)
+          FileUtils.cp(src, dest)
+          copied += 1
+        end
+      end
+    end
+  end
+
+  LOG.info "Worktree include: copied #{copied} file(s), symlinked #{linked} dir(s) for #{worktree_path}" if copied.positive? || linked.positive?
+end
+
+# Run a project-level hook script from .brainiac/<hook_name> if it exists.
+def run_project_hook(repo_path, hook_name, extra_env: {})
+  hook = File.join(repo_path, ".brainiac", hook_name)
+  return unless File.exist?(hook)
+
+  env = { "REPO_PATH" => repo_path }.merge(extra_env)
+  LOG.info "Running .brainiac/#{hook_name} hook for #{repo_path}"
+  output, status = Open3.capture2e(env, "bash", hook, chdir: repo_path)
+  if status.success?
+    LOG.info ".brainiac/#{hook_name} completed successfully"
+  else
+    LOG.warn ".brainiac/#{hook_name} failed (exit #{status.exitstatus}): #{output.strip}"
+  end
+end
+
+# Create or reuse a git worktree for a given branch.
+# Returns the worktree path on success.
+def create_or_reuse_worktree(repo_path:, branch:, base_ref: nil, worktree_path: nil)
+  worktree_path ||= File.join(File.dirname(repo_path), "#{File.basename(repo_path)}--#{branch}")
+  base_ref ||= "origin/#{get_default_branch(repo_path)}"
+
+  worktree_list = run_cmd("git", "worktree", "list", "--porcelain", chdir: repo_path)
+
+  if File.directory?(worktree_path)
+    is_tracked = worktree_list.include?(worktree_path)
+
+    if is_tracked
+      LOG.info "Worktree directory #{worktree_path} is tracked by git"
+    else
+      LOG.warn "Orphaned worktree directory found at #{worktree_path}, removing it"
+      begin
+        FileUtils.rm_rf(worktree_path)
+        LOG.info "Successfully removed orphaned directory"
+      rescue StandardError => e
+        LOG.error "Failed to remove orphaned directory: #{e.message}"
+        raise
+      end
+    end
+  end
+
+  branch_exists = system("git", "rev-parse", "--verify", branch, chdir: repo_path, out: File::NULL, err: File::NULL)
+
+  if branch_exists
+    LOG.info "Branch #{branch} already exists, checking for existing worktree"
+    worktree_list = run_cmd("git", "worktree", "list", "--porcelain", chdir: repo_path)
+    has_worktree = worktree_list.lines.any? { |line| line.strip == "worktree #{worktree_path}" }
+
+    if has_worktree && File.directory?(worktree_path)
+      LOG.info "Reusing existing worktree at #{worktree_path}"
+    else
+      LOG.info "Creating worktree from existing branch #{branch}"
+      run_cmd("git", "worktree", "add", worktree_path, branch, chdir: repo_path)
+    end
+  else
+    LOG.info "Creating new branch #{branch} and worktree"
+    run_cmd("git", "worktree", "add", "-b", branch, worktree_path, base_ref, chdir: repo_path)
+  end
+
+  trust_version_manager(worktree_path, chdir: worktree_path)
+  apply_worktree_includes(repo_path, worktree_path)
+  run_project_hook(repo_path, "worktree-setup", extra_env: { "WORKTREE_PATH" => worktree_path })
+
+  worktree_path
+end
+
+# Find an existing worktree for a card by scanning the filesystem.
+def find_worktree_for_card(card_number, repo_path:)
+  return nil unless card_number
+
+  repo_dir = File.dirname(repo_path)
+  repo_base = File.basename(repo_path)
+  candidates = Dir.glob(File.join(repo_dir, "#{repo_base}--fizzy-#{card_number}-*")).select { |d| File.directory?(d) }
+  return nil if candidates.empty?
+
+  worktree = candidates.first
+  branch = File.basename(worktree).sub("#{repo_base}--", "")
+  { worktree: worktree, branch: branch }
+end
+
+# Clean up all worktrees associated with a card (primary + cross-agent review).
+# Safe: skips worktrees with uncommitted changes.
+def cleanup_card_worktrees(card_number, repo_path:, primary_worktree: nil, primary_branch: nil)
+  return unless card_number
+
+  repo_dir = File.dirname(repo_path)
+  repo_base = File.basename(repo_path)
+  cleaned = 0
+
+  candidates = Dir.glob(File.join(repo_dir, "#{repo_base}--*fizzy-#{card_number}-*")).select { |d| File.directory?(d) }
+  candidates << primary_worktree if primary_worktree && File.directory?(primary_worktree) && !candidates.include?(primary_worktree)
+
+  candidates.uniq.each do |wt_path|
+    status_output, = Open3.capture3("git", "status", "--porcelain", chdir: wt_path)
+    if status_output.strip.empty?
+      branch_name = File.basename(wt_path).sub("#{repo_base}--", "")
+      begin
+        run_cmd("git", "worktree", "remove", wt_path, "--force", chdir: repo_path)
+        run_cmd("git", "branch", "-D", branch_name, chdir: repo_path)
+        cleaned += 1
+        LOG.info "Cleaned up worktree #{wt_path} (branch: #{branch_name})"
+      rescue StandardError => e
+        LOG.warn "Failed to clean up worktree #{wt_path}: #{e.message}"
+      end
+    else
+      LOG.warn "Worktree #{wt_path} has uncommitted changes — skipping cleanup"
+    end
+  end
+
+  LOG.info "Card ##{card_number}: cleaned up #{cleaned} worktree(s)" if cleaned.positive?
+end

data/lib/brainiac/handlers/shared/inline_tags.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+# Shared inline tag parsing for handler messages.
+#
+# Both Discord and Fizzy messages can contain inline tags like:
+#   [project:my-project], [opus], [effort:high], [cli:grok], [chat], [plan]
+#
+# This module provides a single parser that extracts all tags and returns
+# a structured result with the cleaned text.
+
+# Parse inline tags from message text.
+# Returns a hash:
+#   {
+#     project: "my-project" or nil,
+#     model_tag: "opus" or nil (raw tag, not resolved model ID),
+#     effort: "high" or nil,
+#     cli_provider: "grok" or nil,
+#     chat_mode: true/false,
+#     planning: true/false,
+#     deploy_intent: "dev01" / :auto / nil,
+#     worktree_override: "branch-name" or nil,
+#     clean_text: "the message with all tags stripped"
+#   }
+def parse_inline_tags(text)
+  result = {
+    project: nil,
+    model_tag: nil,
+    effort: nil,
+    cli_provider: nil,
+    chat_mode: false,
+    planning: false,
+    deploy_intent: nil,
+    worktree_override: nil,
+    clean_text: text.dup
+  }
+
+  # [project:my-project]
+  if (match = result[:clean_text].match(/\[project:(\S+)\]/i))
+    result[:project] = match[1]
+    result[:clean_text].sub!(match[0], "")
+  end
+
+  # [effort:high]
+  if (match = result[:clean_text].match(/\[effort:(\w+)\]/i))
+    result[:effort] = match[1].downcase
+    result[:clean_text].sub!(match[0], "")
+  end
+
+  # [cli:grok]
+  if (match = result[:clean_text].match(/\[cli:(\w+)\]/i))
+    result[:cli_provider] = match[1].downcase
+    result[:clean_text].sub!(match[0], "")
+  end
+
+  # [chat], [question], [?]
+  if result[:clean_text].match?(/\[(chat|question|\?)\]/i)
+    result[:chat_mode] = true
+    result[:clean_text].sub!(/\[(chat|question|\?)\]/i, "")
+  end
+
+  # [plan]
+  if result[:clean_text].match?(/\[plan\]/i)
+    result[:planning] = true
+    result[:clean_text].sub!(/\[plan\]/i, "")
+  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
+
+  # [worktree:branch-name]
+  if (match = result[:clean_text].match(/\[worktree:([^\]]+)\]/))
+    result[:worktree_override] = match[1].strip
+    result[:clean_text].sub!(match[0], "")
+  end
+
+  # 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.
+  if (match = result[:clean_text].match(/\[(\w+)\]/))
+    result[:model_tag] = match[1].downcase
+    result[:clean_text].sub!(match[0], "")
+  end
+
+  result[:clean_text].strip!
+  result
+end

data/lib/brainiac/handlers/zoho.rb

@@ -86,28 +86,34 @@ end
 
 # Match an email against configured rules. Returns the first matching rule or nil.
 # If no rules match, returns a fallback rule (if configured) so nothing is missed.
-def match_zoho_rule(email)
-  rules = ZOHO_CONFIG["rules"] || []
-  rules.each do |rule|
-    next if rule["enabled"] == false
-
-    matches = true
-    if rule["from_contains"] && !rule["from_contains"].empty? && !email["fromAddress"].to_s.downcase.include?(rule["from_contains"].downcase)
-      matches = false
-    end
-    matches = false if rule["to_contains"] && !rule["to_contains"].empty? && !email["toAddress"].to_s.downcase.include?(rule["to_contains"].downcase)
-    if rule["subject_contains"] && !rule["subject_contains"].empty? && !email["subject"].to_s.downcase.include?(rule["subject_contains"].downcase)
-      matches = false
-    end
-    if rule["body_contains"] && !rule["body_contains"].empty?
-      body = email["summary"].to_s + email["html"].to_s
-      matches = false unless body.downcase.include?(rule["body_contains"].downcase)
-    end
-    matches = false if matches && zoho_email_excluded?(email, rule["exclude_words"])
+def zoho_rule_matches?(rule, email)
+  return false if rule["enabled"] == false
+
+  %w[from_contains to_contains subject_contains].each do |field|
+    pattern = rule[field]
+    next if pattern.nil? || pattern.empty?
+
+    email_field = case field
+                  when "from_contains" then email["fromAddress"]
+                  when "to_contains" then email["toAddress"]
+                  when "subject_contains" then email["subject"]
+                  end
+    return false unless email_field.to_s.downcase.include?(pattern.downcase)
+  end
 
-    return rule if matches
+  if rule["body_contains"] && !rule["body_contains"].empty?
+    body = "#{email["summary"]}#{email["html"]}"
+    return false unless body.downcase.include?(rule["body_contains"].downcase)
   end
 
+  !zoho_email_excluded?(email, rule["exclude_words"])
+end
+
+def match_zoho_rule(email)
+  rules = ZOHO_CONFIG["rules"] || []
+  matched = rules.find { |rule| zoho_rule_matches?(rule, email) }
+  return matched if matched
+
   # Fallback: post unmatched emails so nothing slips through
   fallback = zoho_fallback_rule
   return nil if fallback && zoho_email_excluded?(email, ZOHO_CONFIG.dig("fallback", "exclude_words"))
@@ -126,6 +132,23 @@ def zoho_fallback_rule
     "notify_as" => fallback["notify_as"] }
 end
 
+# Extract body text from email payload for notification display.
+def extract_zoho_body_text(email, rule)
+  body_text = email["summary"].to_s.strip
+  if body_text.empty?
+    raw_html = (email["html"] || email["content"] || email["body"] || "").to_s
+    body_text = raw_html.gsub(/<[^>]+>/, " ").gsub(/&nbsp;/i, " ").gsub(/\s+/, " ").strip
+  end
+
+  body_text = fetch_zoho_email_content(email["messageId"]).to_s if body_text.empty? && rule["show_body"] && email["messageId"]
+
+  return nil if body_text.empty?
+
+  max_len = rule["show_body"] ? 1800 : 500
+  body_text = "#{body_text[0..max_len]}..." if body_text.length > max_len
+  body_text
+end
+
 # Format a Discord notification for a matched email.
 def format_zoho_notification(email, rule)
   label = rule["label"] || "Zoho Mail"
@@ -135,23 +158,8 @@ def format_zoho_notification(email, rule)
   parts << "**From:** #{email["fromAddress"]}" if email["fromAddress"]
   parts << "**To:** #{email["toAddress"]}" if email["toAddress"]
 
-  # Include body content — try webhook payload first, then fetch via API
-  body_text = email["summary"].to_s.strip
-  if body_text.empty?
-    raw_html = (email["html"] || email["content"] || email["body"] || "").to_s
-    body_text = raw_html.gsub(/<[^>]+>/, " ").gsub(/&nbsp;/i, " ").gsub(/\s+/, " ").strip
-  end
-
-  # If still empty and show_body requested, fetch via Zoho Mail API
-  body_text = fetch_zoho_email_content(email["messageId"]).to_s if body_text.empty? && rule["show_body"] && email["messageId"]
-
-  if !body_text.empty? && rule["show_body"]
-    body_text = "#{body_text[0..1800]}..." if body_text.length > 1800
-    parts << "```\n#{body_text}\n```"
-  elsif !body_text.empty?
-    body_text = "#{body_text[0..500]}..." if body_text.length > 500
-    parts << "```\n#{body_text}\n```"
-  end
+  body_text = extract_zoho_body_text(email, rule)
+  parts << "```\n#{body_text}\n```" if body_text
 
   parts.join("\n")
 end
@@ -226,7 +234,7 @@ ZOHO_TRIAGE_PROMPT = <<~PROMPT
     "title": "Brief descriptive title for the card",
     "description": "HTML description with relevant details from the email",
     "project_tag": "project-tag-name or null",
-    "assign_to": "Galen|Avon|Sheogorath"
+    "assign_to": "agent-name from the assignment rules above"
   }
   ```
 
@@ -255,34 +263,15 @@ def dispatch_zoho_triage(email, rule)
   response_file = File.join(ZOHO_TRIAGE_DIR, "triage-#{timestamp}.json")
   log_file = File.join(ZOHO_TRIAGE_DIR, "triage-#{timestamp}.log")
 
-  body = (email["summary"] || email["html"] || "").to_s.gsub(/\s+/, " ").strip
-  body = body[0..2000] if body.length > 2000
-
-  prompt = ZOHO_TRIAGE_PROMPT
-           .gsub("{{FROM}}", email["fromAddress"].to_s)
-           .gsub("{{TO}}", email["toAddress"].to_s)
-           .gsub("{{SUBJECT}}", email["subject"].to_s)
-           .gsub("{{BODY}}", body)
-           .gsub("{{PROJECT_TAGS}}", zoho_triage_project_tags)
-           .gsub("{{AGENT_ASSIGNMENT}}", zoho_triage_agent_assignment)
-
-  prompt += "\n\nWrite your JSON response to: #{response_file}\n"
-
-  prompt_file = File.join(ZOHO_TRIAGE_DIR, "triage-prompt-#{timestamp}.md")
-  File.write(prompt_file, prompt)
+  prompt_file = write_zoho_triage_prompt(email, response_file, timestamp)
 
   agent_key = agent_name.downcase.gsub(/[^a-z0-9-]/, "-")
   project_config = default_project_config
+  resolved = resolve_project_cli_config(project_config || DEFAULT_PROJECT)
 
-  resolved = project_config ? resolve_project_cli_config(project_config) : {}
-  agent_cli = resolved["agent_cli"] || "kiro-cli"
-  agent_cli_args = resolved["agent_cli_args"] || "chat --trust-all-tools --no-interactive"
-  resolved["agent_model_flag"] || "--model"
-
-  cmd = [agent_cli]
+  cmd = [resolved["agent_cli"]]
   cmd.push("--agent", agent_key)
-  cmd.concat(agent_cli_args.split)
-  add_trust_tools!(cmd, agent_cli_args)
+  cmd.concat(resolved["agent_cli_args"].split)
 
   spawn_env = {}
   agent_env = agent_env_for(agent_name)
@@ -294,12 +283,32 @@ def dispatch_zoho_triage(email, rule)
   LOG.info "[Zoho:Triage] Command: #{cmd.join(" ")}"
 
   pid = spawn(spawn_env, *cmd,
-              chdir: work_dir,
-              in: prompt_file,
-              out: [log_file, "w"],
-              err: %i[child out])
+              chdir: work_dir, in: prompt_file,
+              out: [log_file, "w"], err: %i[child out])
 
-  # Monitor in background — process the triage decision when agent finishes
+  monitor_zoho_triage(pid, response_file, log_file, prompt_file, email, rule)
+  pid
+end
+
+def write_zoho_triage_prompt(email, response_file, timestamp)
+  body = (email["summary"] || email["html"] || "").to_s.gsub(/\s+/, " ").strip
+  body = body[0..2000] if body.length > 2000
+
+  prompt = ZOHO_TRIAGE_PROMPT
+           .gsub("{{FROM}}", email["fromAddress"].to_s)
+           .gsub("{{TO}}", email["toAddress"].to_s)
+           .gsub("{{SUBJECT}}", email["subject"].to_s)
+           .gsub("{{BODY}}", body)
+           .gsub("{{PROJECT_TAGS}}", zoho_triage_project_tags)
+           .gsub("{{AGENT_ASSIGNMENT}}", zoho_triage_agent_assignment)
+  prompt += "\n\nWrite your JSON response to: #{response_file}\n"
+
+  prompt_file = File.join(ZOHO_TRIAGE_DIR, "triage-prompt-#{timestamp}.md")
+  File.write(prompt_file, prompt)
+  prompt_file
+end
+
+def monitor_zoho_triage(pid, response_file, log_file, prompt_file, email, rule)
   Thread.new do
     Process.wait(pid)
     exit_status = $CHILD_STATUS
@@ -313,14 +322,11 @@ def dispatch_zoho_triage(email, rule)
       notify_zoho_match(email, rule)
     end
 
-    # Cleanup prompt file after a delay
     Thread.new do
       sleep 300
       FileUtils.rm_f(prompt_file)
     end
   end
-
-  pid
 end
 
 # Read the triage response — try the response file first, then extract from log
@@ -460,16 +466,13 @@ end
 
 # Assign a card to the appropriate agent
 def assign_zoho_triage_card(card_number, agent_name, spawn_env)
-  # Map agent names to Fizzy user IDs
-  agent_user_ids = {
-    "Galen" => "03fja52opiykf0mua7aeqv8uk",
-    "Avon" => "03fnwe6kl4g2t8xw0djbfkv96",
-    "Sheogorath" => "03fnwjyt6gighy98ld46u2hni"
-  }
+  # Resolve agent name to Fizzy user ID from fizzy.json authorized_users
+  users = FIZZY_CONFIG["authorized_users"] || []
+  user = users.find { |u| u["name"]&.downcase == agent_name.downcase }
+  user_id = user&.dig("id")
 
-  user_id = agent_user_ids[agent_name]
   unless user_id
-    LOG.warn "[Zoho:Triage] Unknown agent for assignment: #{agent_name}"
+    LOG.warn "[Zoho:Triage] Unknown agent for assignment: #{agent_name} (not found in fizzy.json authorized_users)"
     return
   end
 

data/lib/brainiac/helpers.rb

@@ -5,45 +5,6 @@
 require "English"
 CLI_PROVIDERS_DIR = File.join(BRAINIAC_DIR, "cli-providers")
 
-# --trust-all-tools alone doesn't bypass the non-interactive deny list in kiro-cli 1.29.8+.
-# Adding --trust-tools with explicit tool names ensures write/exec tools are approved.
-# This is now configured in the kiro provider's default_args instead of being hardcoded here.
-TRUSTED_TOOLS = "execute_bash,fs_write,fs_read,code,grep,glob,web_search,web_fetch,use_subagent,use_aws"
-
-# Clean up all worktrees associated with a card: the primary worktree and any
-# cross-agent review worktrees (e.g. glados-fizzy-123-*, threepio-fizzy-123-*).
-# Safe: skips worktrees with uncommitted changes.
-def cleanup_card_worktrees(card_number, repo_path:, primary_worktree: nil, primary_branch: nil)
-  return unless card_number
-
-  repo_dir = File.dirname(repo_path)
-  repo_base = File.basename(repo_path)
-  cleaned = 0
-
-  # Collect all worktree dirs for this card: primary + cross-agent review
-  candidates = Dir.glob(File.join(repo_dir, "#{repo_base}--*fizzy-#{card_number}-*")).select { |d| File.directory?(d) }
-  candidates << primary_worktree if primary_worktree && File.directory?(primary_worktree) && !candidates.include?(primary_worktree)
-
-  candidates.uniq.each do |wt_path|
-    status_output, = Open3.capture3("git", "status", "--porcelain", chdir: wt_path)
-    if status_output.strip.empty?
-      branch_name = File.basename(wt_path).sub("#{repo_base}--", "")
-      begin
-        run_cmd("git", "worktree", "remove", wt_path, "--force", chdir: repo_path)
-        run_cmd("git", "branch", "-D", branch_name, chdir: repo_path)
-        cleaned += 1
-        LOG.info "Cleaned up worktree #{wt_path} (branch: #{branch_name})"
-      rescue StandardError => e
-        LOG.warn "Failed to clean up worktree #{wt_path}: #{e.message}"
-      end
-    else
-      LOG.warn "Worktree #{wt_path} has uncommitted changes — skipping cleanup"
-    end
-  end
-
-  LOG.info "Card ##{card_number}: cleaned up #{cleaned} worktree(s)" if cleaned.positive?
-end
-
 # Load a CLI provider config from ~/.brainiac/cli-providers/<name>.json.
 # Returns a hash with normalized keys, or {} if not found.
 def load_cli_provider(provider_name)
@@ -126,64 +87,6 @@ def detect_cli_provider(text: "", tags: [])
   nil
 end
 
-# Copy gitignored files matching .worktreeinclude patterns from repo to worktree.
-# Symlink directories matching .worktreelink patterns instead of copying.
-# Both files use .gitignore syntax. Only gitignored files/dirs are processed.
-def apply_worktree_includes(repo_path, worktree_path)
-  copied = 0
-  linked = 0
-
-  [".worktreeinclude", ".worktreelink"].each do |filename|
-    config_file = File.join(repo_path, filename)
-    next unless File.exist?(config_file)
-
-    symlink_mode = filename == ".worktreelink"
-    patterns = File.readlines(config_file).map(&:strip).reject { |l| l.empty? || l.start_with?("#") }
-    next if patterns.empty?
-
-    patterns.each do |pattern|
-      Dir.glob(pattern, File::FNM_DOTMATCH, base: repo_path).each do |match|
-        src = File.join(repo_path, match)
-        dest = File.join(worktree_path, match)
-        next if File.exist?(dest) || File.symlink?(dest)
-
-        # Only process gitignored files/dirs
-        _, _, st = Open3.capture3("git", "check-ignore", "-q", match, chdir: repo_path)
-        next unless st.success?
-
-        FileUtils.mkdir_p(File.dirname(dest))
-
-        if symlink_mode && File.directory?(src)
-          FileUtils.ln_s(src, dest)
-          linked += 1
-          LOG.info "Symlinked #{match} from main repo"
-        elsif File.file?(src)
-          FileUtils.cp(src, dest)
-          copied += 1
-        end
-      end
-    end
-  end
-
-  LOG.info "Worktree include: copied #{copied} file(s), symlinked #{linked} dir(s) for #{worktree_path}" if copied.positive? || linked.positive?
-end
-
-# Run a project-level hook script from .brainiac/<hook_name> if it exists.
-# Passes REPO_PATH (and optionally WORKTREE_PATH) as environment variables.
-def run_project_hook(repo_path, hook_name, extra_env: {})
-  hook = File.join(repo_path, ".brainiac", hook_name)
-  return unless File.exist?(hook)
-
-  env = { "REPO_PATH" => repo_path }.merge(extra_env)
-  LOG.info "Running .brainiac/#{hook_name} hook for #{repo_path}"
-  output, status = Open3.capture2e(env, "bash", hook, chdir: repo_path)
-  if status.success?
-    LOG.info ".brainiac/#{hook_name} completed successfully"
-  else
-    LOG.warn ".brainiac/#{hook_name} failed (exit #{status.exitstatus}): #{output.strip}"
-  end
-end
-
 def default_project_key
   # Find the project marked as default
   default = PROJECTS.find { |_key, config| config["default"] == true }
@@ -292,19 +195,6 @@ def run_cmd(*cmd, chdir:, env: {})
   stdout
 end
 
-# Trust the version manager config in a directory (supports mise and asdf)
-def trust_version_manager(path, chdir:)
-  if system("which mise >/dev/null 2>&1")
-    run_cmd("mise", "trust", path, chdir: chdir)
-  elsif system("which asdf >/dev/null 2>&1")
-    LOG.info "asdf detected — no explicit trust needed for #{path}"
-  else
-    LOG.info "No version manager (mise/asdf) found — skipping trust for #{path}"
-  end
-rescue StandardError => e
-  LOG.warn "Could not trust version manager in #{path}: #{e.message}"
-end
-
 # Cards that have been merged to main — skip Needs Review moves for these.
 # Keyed by card number (string), value is Time. Entries expire after 10 minutes.
 MERGED_CARDS = {}
@@ -703,7 +593,8 @@ def handle_fizzy_post_session(fizzy_card, exit_status, signaled, agent_name, chd
   return unless source == :fizzy && fizzy_card && exit_status&.zero? && !signaled
 
   unless skip_column_move || card_merged?(fizzy_card)
-    move_card_to_column(fizzy_card, "needs_review", project_config: project_config, agent_name: agent_name)
+    move_card_to_column(fizzy_card, "needs_review", project_config: project_config,
+                                                    agent_name: agent_name)
   end
 
   append_fizzy_comment_footer(fizzy_card, project_config: project_config, agent_name: agent_name)
@@ -747,16 +638,6 @@ def handle_plan_finalization(prompt_file, agent_name, project_config)
   end
 end
 
-# Capture git HEAD and working tree status for a directory.
-# Returns [head_sha, status_porcelain] or [nil, nil] on failure.
-def capture_git_state(chdir)
-  head, = Open3.capture2("git", "rev-parse", "HEAD", chdir: chdir)
-  status, = Open3.capture2("git", "status", "--porcelain", chdir: chdir)
-  [head.strip, status.strip]
-rescue StandardError
-  [nil, nil]
-end
-
 def check_brainiac_restart(head_before, status_before, chdir, project_key_for_restart, agent_config_name)
   return unless project_key_for_restart == "brainiac" && head_before