brainiac 0.0.6 → 0.0.8

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

@@ -0,0 +1,190 @@
+# 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
+
+# Clean up all worktrees associated with a work item (primary + cross-agent review).
+# Safe: skips worktrees with uncommitted changes.
+def cleanup_work_item_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
+
+  # Find worktrees that contain the work item number in their name (any naming convention)
+  candidates = Dir.glob(File.join(repo_dir, "#{repo_base}--*#{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.
+#
+# Messages from any channel 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
@@ -187,7 +195,7 @@ ZOHO_TRIAGE_DIR = File.join(BRAINIAC_DIR, "tmp", "zoho", "triage")
 FileUtils.mkdir_p(ZOHO_TRIAGE_DIR)
 
 ZOHO_TRIAGE_PROMPT = <<~PROMPT
-  You are triaging a support email. Decide whether this email needs a Fizzy card or not.
+  You are triaging a support email. Decide whether this email needs a card or not.
 
   ## Email
   **From:** {{FROM}}
@@ -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"
   }
   ```
 
@@ -248,41 +256,22 @@ ZOHO_TRIAGE_PROMPT = <<~PROMPT
 PROMPT
 
 # Dispatch an agent to triage a support email. The agent decides whether to create
-# a Fizzy card or just notify Discord.
+# a card or just notify Discord.
 def dispatch_zoho_triage(email, rule)
   agent_name = rule["dispatch_agent"]
   timestamp = Time.now.strftime("%Y%m%d-%H%M%S")
   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
@@ -384,7 +390,7 @@ def execute_zoho_triage_decision(decision, email, rule)
   end
 end
 
-# Create a Fizzy card from the triage decision
+# Create a card from the triage decision
 def create_zoho_triage_card(decision, email, channel_id, token)
   board_id = ZOHO_CONFIG["triage_board_id"]
   unless board_id
@@ -398,90 +404,34 @@ def create_zoho_triage_card(decision, email, channel_id, token)
   tags = ["support"]
   tags << decision["project_tag"] if decision["project_tag"]
 
-  # Resolve tag IDs
-  tag_ids = resolve_zoho_triage_tags(tags)
-
-  # Create the card
-  cmd = ["fizzy", "card", "create", "--board", board_id, "--title", title, "--description", description]
-  cmd.push("--tag-ids", tag_ids.join(",")) unless tag_ids.empty?
-
-  # Use the triage agent's env for fizzy token
-  agent_name = "Threepio"
-  agent_env = agent_env_for(agent_name)
-  spawn_env = agent_env.empty? ? {} : agent_env
-
-  output, status = Open3.capture2e(spawn_env, *cmd)
-  unless status.success?
-    LOG.error "[Zoho:Triage] Failed to create card: #{output}"
-    notify_zoho_match(email, { "label" => "Support Email (card creation failed)", "emoji" => "❌" }.merge(rule_defaults(nil)))
-    return
-  end
-
-  # Parse card number from response
-  card_data = JSON.parse(output)
-  card_number = card_data.dig("data", "number")
-  card_url = card_data.dig("data", "url")
-  LOG.info "[Zoho:Triage] Created card ##{card_number}: #{title}"
-
-  # Assign to the appropriate agent
-  assign_zoho_triage_card(card_number, decision["assign_to"], spawn_env) if card_number && decision["assign_to"]
-
-  # Notify Discord
-  if channel_id && token
-    msg = "🎫 **Support Card Created: [##{card_number}](#{card_url})**\n"
-    msg += "**Title:** #{title}\n"
-    msg += "**Assigned to:** #{decision["assign_to"] || "unassigned"}\n"
-    msg += "**Tags:** #{tags.join(", ")}\n"
-    msg += "**From:** #{email["fromAddress"]}"
-    send_discord_message(channel_id, msg, token: token)
+  # Emit hook — work item plugin handles card creation (card management plugins)
+  results = Brainiac.emit(:create_work_item,
+                          board_id: board_id,
+                          title: title,
+                          description: description,
+                          tags: tags,
+                          assign_to: decision["assign_to"])
+
+  card_info = results.compact.first
+  if card_info
+    card_number = card_info[:number]
+    card_url = card_info[:url]
+    LOG.info "[Zoho:Triage] Created card ##{card_number}: #{title}"
+
+    # Notify Discord
+    if channel_id && token
+      msg = "🎫 **Support Card Created: [##{card_number}](#{card_url})**\n"
+      msg += "**Title:** #{title}\n"
+      msg += "**Assigned to:** #{decision["assign_to"] || "unassigned"}\n"
+      msg += "**Tags:** #{tags.join(", ")}\n"
+      msg += "**From:** #{email["fromAddress"]}"
+      send_discord_message(channel_id, msg, token: token)
+    end
+  else
+    LOG.warn "[Zoho:Triage] No work item plugin handled card creation"
+    notify_zoho_match(email, { "label" => "Support Email (no card plugin)", "emoji" => "⚠️" }.merge(rule_defaults(nil)))
   end
 rescue StandardError => e
   LOG.error "[Zoho:Triage] Error creating card: #{e.message}\n#{e.backtrace.first(3).join("\n")}"
   notify_zoho_match(email, { "label" => "Support Email", "emoji" => "🆘" }.merge(rule_defaults(nil)))
 end
-
-# Resolve tag names to IDs by querying Fizzy
-def resolve_zoho_triage_tags(tag_names)
-  agent_env = agent_env_for("Threepio")
-  spawn_env = agent_env.empty? ? {} : agent_env
-
-  output, status = Open3.capture2e(spawn_env, "fizzy", "tag", "list", "--all")
-  return [] unless status.success?
-
-  all_tags = JSON.parse(output)["data"] || []
-  tag_names.filter_map do |name|
-    tag = all_tags.find { |t| t["title"].downcase == name.downcase }
-    tag&.dig("id")
-  end
-rescue StandardError => e
-  LOG.warn "[Zoho:Triage] Failed to resolve tags: #{e.message}"
-  []
-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"
-  }
-
-  user_id = agent_user_ids[agent_name]
-  unless user_id
-    LOG.warn "[Zoho:Triage] Unknown agent for assignment: #{agent_name}"
-    return
-  end
-
-  output, status = Open3.capture2e(spawn_env, "fizzy", "card", "assign", card_number.to_s, "--user", user_id)
-  if status.success?
-    LOG.info "[Zoho:Triage] Assigned card ##{card_number} to #{agent_name}"
-  else
-    LOG.warn "[Zoho:Triage] Failed to assign card ##{card_number}: #{output}"
-  end
-end
-
-def rule_defaults(rule)
-  { "discord_channel_id" => rule&.dig("discord_channel_id") || ZOHO_CONFIG["default_discord_channel_id"],
-    "notify_as" => rule&.dig("notify_as") || ZOHO_CONFIG["notify_as"] }
-end