brainiac-fizzy 0.0.16 → 0.0.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6ed1ef3ae4c3db228a9a98a796579e7450e25fad4e19fa5ce075777e677342cc
-  data.tar.gz: 9e5ceac2510d64194bc498850871ca8105aeea24b742e9930ede13c761928f50
+  metadata.gz: 34a03eed47ca8ae2a7de8ec8351962c5a3aa59652d7466c14221d4919866519f
+  data.tar.gz: e18090ad45a15ce328c6c1fdabc267e32c29868bd28e36f6540af7ed1ace6436
 SHA512:
-  metadata.gz: 73f14f9e28f8eaba2558fac32e14116d0255fdb513cd2ba13753f1e5babe9a311807620832b75cd4b46282473e0603a1127a38483f18034177c0d983a84b5146
-  data.tar.gz: d45acdf7a664c1585b262230a0b1cf70eff969699fc80c270193ccedf0d902ed7876fc6d3eb353acf4768217bd88babced1f10db835b6aa7e13edde62b57b27c
+  metadata.gz: 4db395ff509a514e144c4237affb376ac43de3d2a04ed0a5e89a12f5260c7b02ad144344b3bab5e471f9a617df1af3bbcc99ed29c2151c2e3b61d99df6f5f9c4
+  data.tar.gz: d9c0cfdcec762022846ed40cc2e8713504f55c6206df41024c484ec9eade1378d60d82e3dd593ebdf76261d7cbcb8bde25f10dfb863830af2e76aca431b960c2

data/lib/brainiac/plugins/fizzy/cli.rb

@@ -12,6 +12,8 @@ module Brainiac
         BRAINIAC_DIR = ENV.fetch("BRAINIAC_DIR", File.join(Dir.home, ".brainiac"))
         FIZZY_CONFIG_FILE = File.join(BRAINIAC_DIR, "fizzy.json")
 
+        PROJECTS_FILE = File.join(BRAINIAC_DIR, "projects.json")
+
         class << self
           def run(args)
             command = args.shift
@@ -23,6 +25,8 @@ module Brainiac
               cmd_status
             when "setup"
               cmd_setup
+            when "board"
+              cmd_board(args)
             else
               print_help
             end
@@ -97,6 +101,463 @@ module Brainiac
             puts "Webhook URL: https://<your-ngrok>.ngrok-free.app/fizzy/<board-key>"
           end
 
+          def cmd_board(args)
+            sub = args.shift
+            case sub
+            when "setup", "add"
+              board_setup
+            when "list", "ls"
+              board_list
+            when "assign"
+              board_assign(args)
+            when "columns", "refresh"
+              board_columns(args)
+            when "webhook"
+              board_webhook(args)
+            else
+              puts "Usage: brainiac fizzy board <setup|list|assign|columns|webhook>"
+              puts ""
+              puts "Commands:"
+              puts "  setup                         Add a new board (interactive, fetches columns from Fizzy)"
+              puts "  list                          List configured boards and their columns"
+              puts "  assign <project> <board_key>  Assign a project to a board"
+              puts "  columns <board_key>           Refresh columns for a board from Fizzy"
+              puts "  webhook <board_key> [url]     Create/replace webhook and save the signing secret"
+            end
+          end
+
+          # --- board setup (split into phases) ---
+
+          def board_setup
+            puts "Fizzy Board Setup"
+            puts "================="
+            puts ""
+
+            board = board_setup_select_board
+            return unless board
+
+            board_key = board_setup_choose_key(board["name"])
+            column_map = board_setup_map_columns(board["id"], board["name"])
+            secret = board_setup_ask_secret(board_key)
+
+            config = board_setup_save(board_key, board["id"], column_map, secret)
+
+            puts ""
+            puts "✓ Board \"#{board["name"]}\" added as '#{board_key}' in #{FIZZY_CONFIG_FILE}"
+            puts "  Columns: #{column_map.keys.join(", ")}" unless column_map.empty?
+
+            board_setup_offer_webhook(config, board_key, board["id"])
+
+            puts ""
+            puts "Next steps:"
+            puts "  brainiac fizzy board assign <project-key> #{board_key}"
+          end
+
+          def board_setup_select_board
+            boards_json = run_fizzy("board", "list", "--all", "--json")
+            unless boards_json
+              puts "Error: Could not fetch boards from Fizzy CLI."
+              puts "  Ensure 'fizzy' is on your PATH and authenticated."
+              puts "  Run: fizzy doctor"
+              return nil
+            end
+
+            boards = JSON.parse(boards_json)["data"] || []
+            if boards.empty?
+              puts "No boards found in your Fizzy account."
+              return nil
+            end
+
+            puts "Available boards:"
+            boards.each_with_index do |board, i|
+              puts "  #{i + 1}) #{board["name"]} (#{board["id"]})"
+            end
+            puts ""
+            print "Select board number: "
+            choice = $stdin.gets&.chomp&.to_i
+            return puts("Cancelled.") unless choice&.positive? && choice <= boards.size
+
+            boards[choice - 1]
+          end
+
+          def board_setup_choose_key(board_name)
+            suggested_key = board_name.downcase.gsub(/[^a-z0-9]+/, "_").gsub(/^_|_$/, "")
+            print "Board key for config [#{suggested_key}]: "
+            board_key = $stdin.gets&.chomp
+            board_key = suggested_key if board_key.nil? || board_key.empty?
+            board_key
+          end
+
+          def board_setup_map_columns(board_id, board_name)
+            columns_json = run_fizzy("column", "list", "--board", board_id, "--json")
+            columns = columns_json ? (JSON.parse(columns_json)["data"] || []) : []
+            custom_columns = columns.reject { |c| c["pseudo"] }
+
+            puts ""
+            puts "Columns for \"#{board_name}\":"
+            if columns.empty?
+              puts "  (no columns found)"
+            else
+              columns.each do |col|
+                pseudo_tag = col["pseudo"] ? " [built-in]" : ""
+                puts "  • #{col["name"]} (#{col["id"]})#{pseudo_tag}"
+              end
+            end
+
+            puts ""
+            puts "Which columns should brainiac track? Enter config names for each."
+            puts "(These map to column transitions like right_now, needs_review, uat, etc.)"
+            puts "Leave blank to skip a column."
+            puts ""
+
+            prompt_column_mapping(custom_columns)
+          end
+
+          def board_setup_ask_secret(board_key)
+            puts ""
+            puts "Webhook setup:"
+            puts "  Fizzy generates the signing secret when you create a webhook."
+            print "Paste the webhook signing_secret from Fizzy (or 'skip' to set later): "
+            secret = $stdin.gets&.chomp
+            if secret.nil? || secret.empty? || secret == "skip"
+              puts "  ⚠ No secret set — you'll need to add it to fizzy.json manually later."
+              puts "    Create the webhook in Fizzy, then paste the signing_secret into:"
+              puts "    #{FIZZY_CONFIG_FILE} → boards.#{board_key}.webhook_secret"
+              nil
+            else
+              secret
+            end
+          end
+
+          def board_setup_save(board_key, board_id, column_map, secret)
+            config = load_fizzy_config
+            config["boards"] ||= {}
+            board_entry = { "board_id" => board_id, "columns" => column_map }
+            board_entry["webhook_secret"] = secret if secret
+            config["boards"][board_key] = board_entry
+            save_fizzy_config(config)
+            config
+          end
+
+          def board_setup_offer_webhook(config, board_key, board_id)
+            puts ""
+            print "Create webhook in Fizzy now? [Y/n]: "
+            answer = $stdin.gets&.chomp&.downcase
+            return if answer == "n"
+
+            webhook_url = prompt_webhook_url(board_key)
+            return unless webhook_url && !webhook_url.empty?
+
+            signing_secret = create_fizzy_webhook(board_id, board_key, webhook_url)
+            return unless signing_secret
+
+            config["boards"][board_key]["webhook_secret"] = signing_secret
+            save_fizzy_config(config)
+            puts "✓ Webhook created! Signing secret saved to fizzy.json."
+          end
+
+          # --- board list ---
+
+          def board_list
+            config = load_fizzy_config
+            boards = config["boards"] || {}
+
+            if boards.empty?
+              puts "No boards configured."
+              puts "Run 'brainiac fizzy board setup' to add one."
+              return
+            end
+
+            projects = load_projects_config
+
+            puts "Configured boards:"
+            boards.each do |key, board_config|
+              puts ""
+              puts "  #{key}:"
+              puts "    Board ID: #{board_config["board_id"]}"
+              puts "    Webhook:  #{board_config["webhook_secret"] ? "configured" : "not set"}"
+
+              columns = board_config["columns"] || {}
+              if columns.any?
+                puts "    Columns:"
+                columns.each { |name, id| puts "      #{name}: #{id}" }
+              else
+                puts "    Columns:  (none configured)"
+              end
+
+              assigned = projects.select { |_, cfg| cfg["fizzy_board"] == key }.keys
+              puts "    Projects: #{assigned.any? ? assigned.join(", ") : "(none)"}"
+            end
+          end
+
+          # --- board assign ---
+
+          def board_assign(args)
+            project_key = args.shift
+            board_key = args.shift
+
+            unless project_key && board_key
+              puts "Usage: brainiac fizzy board assign <project-key> <board-key>"
+              puts ""
+              puts "Available boards:"
+              config = load_fizzy_config
+              (config["boards"] || {}).each_key { |k| puts "  #{k}" }
+              puts ""
+              puts "Available projects:"
+              load_projects_config.each_key { |k| puts "  #{k}" }
+              return
+            end
+
+            config = load_fizzy_config
+            unless config.dig("boards", board_key)
+              puts "Error: Board '#{board_key}' not found in fizzy.json."
+              puts "Available: #{(config["boards"] || {}).keys.join(", ")}"
+              return
+            end
+
+            projects = load_projects_config
+            unless projects.key?(project_key)
+              puts "Error: Project '#{project_key}' not found in projects.json."
+              puts "Available: #{projects.keys.join(", ")}"
+              return
+            end
+
+            projects[project_key]["fizzy_board"] = board_key
+            save_projects_config(projects)
+
+            puts "✓ Assigned project '#{project_key}' to board '#{board_key}'"
+          end
+
+          # --- board columns ---
+
+          def board_columns(args)
+            board_key = args.shift
+            unless board_key
+              puts "Usage: brainiac fizzy board columns <board-key>"
+              puts ""
+              puts "Fetches current columns from Fizzy and lets you update the config."
+              return
+            end
+
+            config = load_fizzy_config
+            board_config = config.dig("boards", board_key)
+            unless board_config
+              puts "Error: Board '#{board_key}' not found in fizzy.json."
+              puts "Available: #{(config["boards"] || {}).keys.join(", ")}"
+              return
+            end
+
+            board_id = board_config["board_id"]
+            columns_json = run_fizzy("column", "list", "--board", board_id, "--json")
+            unless columns_json
+              puts "Error: Could not fetch columns from Fizzy."
+              return
+            end
+
+            columns = JSON.parse(columns_json)["data"] || []
+            custom_columns = columns.reject { |c| c["pseudo"] }
+            existing_map = board_config["columns"] || {}
+
+            puts "Columns for board '#{board_key}' (#{board_id}):"
+            puts ""
+
+            columns.each do |col|
+              pseudo_tag = col["pseudo"] ? " [built-in]" : ""
+              existing_key = existing_map.key(col["id"])
+              mapped = existing_key ? " → #{existing_key}" : ""
+              puts "  • #{col["name"]} (#{col["id"]})#{pseudo_tag}#{mapped}"
+            end
+
+            puts ""
+            puts "Update column mappings? (Enter new config keys, blank to keep, '-' to remove)"
+            puts ""
+
+            new_map = prompt_column_mapping(custom_columns, existing_map)
+
+            config["boards"][board_key]["columns"] = new_map
+            save_fizzy_config(config)
+
+            puts ""
+            puts "✓ Updated columns for '#{board_key}': #{new_map.keys.join(", ")}"
+          end
+
+          # --- board webhook (split into phases) ---
+
+          def board_webhook(args)
+            board_key = args.shift
+            webhook_url = args.shift
+
+            unless board_key
+              puts "Usage: brainiac fizzy board webhook <board-key> [payload-url]"
+              puts ""
+              puts "Creates a webhook in Fizzy for the board and saves the signing secret."
+              puts "If the board already has a webhook, deletes it first."
+              puts ""
+              puts "Available boards:"
+              config = load_fizzy_config
+              (config["boards"] || {}).each_key { |k| puts "  #{k}" }
+              return
+            end
+
+            config = load_fizzy_config
+            board_config = config.dig("boards", board_key)
+            unless board_config
+              puts "Error: Board '#{board_key}' not found in fizzy.json."
+              return
+            end
+
+            board_id = board_config["board_id"]
+
+            return if remove_existing_webhooks(board_id) == :cancelled
+
+            webhook_url ||= prompt_webhook_url(board_key)
+            if webhook_url.nil? || webhook_url.empty?
+              puts "Error: Payload URL is required."
+              return
+            end
+
+            board_webhook_create_and_save(config, board_key, board_id, webhook_url)
+          end
+
+          def remove_existing_webhooks(board_id)
+            existing_json = run_fizzy("webhook", "list", "--board", board_id, "--all", "--json")
+            return :proceed unless existing_json
+
+            existing = JSON.parse(existing_json)["data"] || []
+            brainiac_webhooks = existing.select { |w| w["name"]&.start_with?("brainiac") }
+            return :proceed unless brainiac_webhooks.any?
+
+            puts "Existing brainiac webhook(s) found:"
+            brainiac_webhooks.each do |w|
+              status = w["active"] ? "active" : "inactive"
+              puts "  • #{w["name"]} (#{status}) → #{w["payload_url"]}"
+            end
+            print "Delete existing and create new? [Y/n]: "
+            answer = $stdin.gets&.chomp&.downcase
+            if answer == "n"
+              puts "Cancelled."
+              return :cancelled
+            end
+            brainiac_webhooks.each do |w|
+              run_fizzy("webhook", "delete", w["id"], "--board", board_id)
+              puts "  Deleted: #{w["name"]}"
+            end
+            :proceed
+          end
+
+          def board_webhook_create_and_save(config, board_key, board_id, webhook_url)
+            signing_secret = create_fizzy_webhook(board_id, board_key, webhook_url)
+            webhook_id = @last_webhook_id
+
+            if signing_secret
+              config["boards"][board_key]["webhook_secret"] = signing_secret
+              save_fizzy_config(config)
+              puts "✓ Webhook created (ID: #{webhook_id})"
+              puts "  URL: #{webhook_url}"
+              puts "  Signing secret saved to fizzy.json"
+            else
+              puts "✓ Webhook created but no signing_secret in response."
+              puts "  Check: fizzy webhook show #{webhook_id} --board #{board_id}"
+            end
+          end
+
+          # --- shared helpers ---
+
+          def prompt_column_mapping(columns, existing_map = {})
+            column_map = {}
+            columns.each do |col|
+              existing_key = existing_map.key(col["id"])
+              suggested = existing_key || col["name"].downcase.gsub(/[^a-z0-9]+/, "_").gsub(/^_|_$/, "")
+              print "  \"#{col["name"]}\" → config key [#{suggested}]: "
+              key = $stdin.gets&.chomp
+              key = suggested if key.nil? || key.empty?
+              next if ["-", "skip"].include?(key)
+
+              column_map[key] = col["id"]
+            end
+            column_map
+          end
+
+          def prompt_webhook_url(board_key)
+            detected_url = detect_ngrok_url
+            if detected_url
+              default_url = "#{detected_url}/fizzy/#{board_key}"
+              print "Webhook payload URL [#{default_url}]: "
+              input = $stdin.gets&.chomp
+              input.nil? || input.empty? ? default_url : input
+            else
+              print "Webhook payload URL (e.g., https://your-ngrok.app/fizzy/#{board_key}): "
+              $stdin.gets&.chomp
+            end
+          end
+
+          def create_fizzy_webhook(board_id, board_key, webhook_url)
+            actions = "card_assigned,card_closed,card_published,card_reopened,card_triaged,comment_created"
+            webhook_json = run_fizzy("webhook", "create", "--board", board_id,
+                                     "--name", "brainiac-#{board_key}",
+                                     "--url", webhook_url,
+                                     "--actions", actions, "--json")
+            unless webhook_json
+              puts "⚠ Failed to create webhook. Create it manually in Fizzy."
+              return nil
+            end
+
+            webhook_data = JSON.parse(webhook_json)["data"]
+            @last_webhook_id = webhook_data&.dig("id")
+            webhook_data&.dig("signing_secret")
+          end
+
+          def load_fizzy_config
+            if File.exist?(FIZZY_CONFIG_FILE)
+              JSON.parse(File.read(FIZZY_CONFIG_FILE))
+            else
+              { "boards" => {}, "authorized_users" => [] }
+            end
+          rescue JSON::ParserError
+            { "boards" => {}, "authorized_users" => [] }
+          end
+
+          def save_fizzy_config(config)
+            File.write(FIZZY_CONFIG_FILE, JSON.pretty_generate(config))
+          end
+
+          def load_projects_config
+            if File.exist?(PROJECTS_FILE)
+              JSON.parse(File.read(PROJECTS_FILE))
+            else
+              {}
+            end
+          rescue JSON::ParserError
+            {}
+          end
+
+          def save_projects_config(projects)
+            File.write(PROJECTS_FILE, JSON.pretty_generate(projects))
+          end
+
+          def run_fizzy(*)
+            require "open3"
+            output, status = Open3.capture2("fizzy", *)
+            status.success? ? output : nil
+          rescue Errno::ENOENT
+            nil
+          end
+
+          def detect_ngrok_url
+            require "net/http"
+            uri = URI("http://127.0.0.1:4040/api/tunnels")
+            http = Net::HTTP.new(uri.host, uri.port)
+            http.open_timeout = 2
+            http.read_timeout = 2
+            response = http.get(uri.path)
+            data = JSON.parse(response.body)
+            tunnels = data["tunnels"] || []
+            https_tunnel = tunnels.find { |t| t["public_url"]&.start_with?("https://") }
+            https_tunnel&.dig("public_url")
+          rescue StandardError
+            nil
+          end
+
           def print_help
             puts <<~HELP
               Usage: brainiac fizzy <command>
@@ -105,6 +566,10 @@ module Brainiac
                 config                              Show Fizzy config
                 status                              Check Fizzy status via server API
                 setup                               Show setup guide
+                board setup                         Add a new board (interactive, fetches columns from Fizzy)
+                board list                          List configured boards and their columns
+                board assign <project> <board_key>  Assign a project to a board
+                board columns <board_key>           Refresh columns for a board from Fizzy
 
               Fizzy handles card assignment, comments, @mentions, cross-agent reviews,
               duplicate detection, and planning mode via webhooks.
@@ -155,7 +620,6 @@ module Brainiac
         config = JSON.parse(File.read(config_file))
         config["authorized_users"] ||= []
 
-        # Don't add if already present
         existing = config["authorized_users"].find { |u| u["id"] == user_id || u["name"]&.downcase == display_name.downcase }
         if existing
           puts "  ✓ #{display_name} already in authorized_users (id: #{existing["id"]})"

data/lib/brainiac/plugins/fizzy/config.rb

@@ -92,7 +92,7 @@ module Brainiac
             user && user["human"]
           end
 
-          def identify_project_by_tags(tags)
+          def identify_project_by_tags(tags, board_key: nil)
             tag_names = tags.map { |t| t.is_a?(Hash) ? t["name"] : t.to_s }.map(&:downcase)
 
             PROJECTS.each do |key, config|
@@ -100,7 +100,21 @@ module Brainiac
               return [key, config] if tag_names.intersect?(project_tags)
             end
 
-            # Fall back to default project
+            # Fall back to board's default_project if configured
+            if board_key
+              board_config = @boards[board_key]
+              if board_config && board_config["default_project"]
+                project_key = board_config["default_project"]
+                return [project_key, PROJECTS[project_key]] if PROJECTS.key?(project_key)
+              end
+
+              # Fall back to any project whose fizzy_board matches this board_key
+              PROJECTS.each do |key, config|
+                return [key, config] if config["fizzy_board"] == board_key
+              end
+            end
+
+            # Fall back to global default project
             default_key = default_project_key
             default_key ? [default_key, PROJECTS[default_key]] : nil
           end

data/lib/brainiac/plugins/fizzy/delegators.rb

@@ -72,8 +72,8 @@ def verify_signature!(request, payload_body, board_key: nil)
 end
 
 # Config delegators
-def identify_project_by_tags(tags)
-  Brainiac::Plugins::Fizzy::Config.identify_project_by_tags(tags)
+def identify_project_by_tags(tags, board_key: nil)
+  Brainiac::Plugins::Fizzy::Config.identify_project_by_tags(tags, board_key: board_key)
 end
 
 def board_config(board_key)
@@ -114,14 +114,14 @@ end
 
 # Webhook dispatch — routes incoming actions to the appropriate handler.
 # Called from within the Sinatra route block, so it must be a top-level method.
-def dispatch_webhook_action(action, payload)
+def dispatch_webhook_action(action, payload, board_key: nil)
   case action
   when "card_assigned"
-    handle_card_assigned(payload)
+    handle_card_assigned(payload, board_key: board_key)
   when "comment_created"
-    handle_comment(payload)
+    handle_comment(payload, board_key: board_key)
   when "card_published", "card_triaged"
-    Brainiac::Plugins::Fizzy.handle_publish_or_triage(action, payload)
+    Brainiac::Plugins::Fizzy.handle_publish_or_triage(action, payload, board_key: board_key)
   else
     LOG.info "[Fizzy] Ignoring unknown action: #{action}"
     [200, { status: "ignored", action: action }.to_json]

data/lib/brainiac/plugins/fizzy/handlers/assignment.rb

@@ -5,7 +5,7 @@
 # When a card is assigned to a local agent, creates a worktree, builds the prompt,
 # and dispatches the agent to begin work.
 
-def handle_card_assigned(payload)
+def handle_card_assigned(payload, board_key: nil)
   eventable = payload["eventable"] || {}
   assignees = eventable["assignees"] || []
 
@@ -23,10 +23,10 @@ def handle_card_assigned(payload)
   title = eventable["title"] || "untitled"
   tags = eventable["tags"] || []
 
-  project_result = identify_project_by_tags(tags)
+  project_result = identify_project_by_tags(tags, board_key: board_key)
   unless project_result
     tag_names = tags.map { |t| t.is_a?(Hash) ? t["name"] : t }.join(", ")
-    LOG.warn "No project found for card ##{card_number} with tags: #{tag_names}"
+    LOG.warn "No project found for card ##{card_number} with tags: #{tag_names} (board: #{board_key})"
     return [200, { status: "ignored", reason: "no matching project" }.to_json]
   end
 

data/lib/brainiac/plugins/fizzy/handlers/comments.rb

@@ -21,7 +21,7 @@ CommentContext = Struct.new(
   keyword_init: true
 )
 
-def handle_comment(payload)
+def handle_comment(payload, board_key: nil)
   eventable = payload["eventable"] || {}
   plain_text = eventable.dig("body", "plain_text") || ""
   card_internal_id = eventable.dig("card", "id")
@@ -44,7 +44,7 @@ def handle_comment(payload)
   card_info = lookup_fizzy_card_info(card_internal_id)
   comment_id = eventable["id"]
 
-  project_config, project_key = resolve_fizzy_project(card_info, card_internal_id, eventable)
+  project_config, project_key = resolve_fizzy_project(card_info, card_internal_id, eventable, board_key: board_key)
   return [200, { status: "ignored", reason: "no matching project" }.to_json] unless project_config
 
   tags = parse_inline_tags(plain_text)
@@ -285,14 +285,14 @@ def handle_cancel_command(eventable, card_internal_id)
   [200, { status: "cancelled", card: card_number_for_cancel || card_internal_id, sessions_killed: killed }.to_json]
 end
 
-def resolve_fizzy_project(card_info, card_internal_id, eventable)
+def resolve_fizzy_project(card_info, card_internal_id, eventable, board_key: nil)
   if card_info
     if card_info["project"]
       project_key = card_info["project"]
       project_config = PROJECTS[project_key] || DEFAULT_PROJECT
     else
       card_tags = eventable.dig("card", "tags") || []
-      project_result = identify_project_by_tags(card_tags)
+      project_result = identify_project_by_tags(card_tags, board_key: board_key)
       if project_result
         project_key, project_config = project_result
         card_info["project"] = project_key
@@ -305,7 +305,7 @@ def resolve_fizzy_project(card_info, card_internal_id, eventable)
     end
   else
     card_tags = eventable.dig("card", "tags") || []
-    project_result = identify_project_by_tags(card_tags)
+    project_result = identify_project_by_tags(card_tags, board_key: board_key)
     if project_result
       project_key, project_config = project_result
     else

data/lib/brainiac/plugins/fizzy/handlers/dedup.rb

@@ -5,7 +5,7 @@
 # When a new card is created, checks for similar existing cards using
 # trigram and semantic similarity. Posts a warning comment if duplicates found.
 
-def handle_card_published(payload)
+def handle_card_published(payload, board_key: nil)
   eventable = payload["eventable"] || {}
   card_number = eventable["number"]
   title = eventable["title"] || ""

data/lib/brainiac/plugins/fizzy/hooks.rb

@@ -336,9 +336,38 @@ module Brainiac
                 LOG.info "[Fizzy:CardIndex] Starting background backfill..."
                 CARD_INDEX.backfill
               end
+
+              # Auto-reactivate deactivated webhooks in background
+              Thread.new { check_and_reactivate_webhooks }
             end
           end
 
+          def check_and_reactivate_webhooks
+            boards = Config.boards
+            return if boards.empty?
+
+            env = Helpers.default_fizzy_env
+            boards.each do |board_key, board_config|
+              board_id = board_config["board_id"]
+              next unless board_id
+
+              output = run_cmd("fizzy", "webhook", "list", "--board", board_id, "--all", "--json", env: env)
+              webhooks = JSON.parse(output)["data"] || []
+
+              webhooks.each do |webhook|
+                next unless webhook["name"]&.start_with?("brainiac")
+                next if webhook["active"]
+
+                LOG.info "[Fizzy] Reactivating webhook '#{webhook["name"]}' on board '#{board_key}' (was inactive)"
+                run_cmd("fizzy", "webhook", "reactivate", webhook["id"], "--board", board_id, env: env)
+              end
+            rescue StandardError => e
+              LOG.warn "[Fizzy] Could not check webhooks for board '#{board_key}': #{e.message}"
+            end
+          rescue StandardError => e
+            LOG.warn "[Fizzy] Webhook reactivation check failed: #{e.message}"
+          end
+
           # Detect CLI provider from Fizzy card tags (e.g., cli-grok tag)
           def register_detect_cli_provider
             Brainiac.on(:detect_cli_provider) do |ctx|

data/lib/brainiac/plugins/fizzy/prompts.rb

@@ -23,8 +23,12 @@ module Brainiac
           ### Screenshots (MANDATORY for UI changes)
           If you touched any `.js`, `.jsx`, `.css`, or `.html` in a web app directory and `./scripts/screenshot-page.sh` exists, screenshot every affected page.
 
-          ### Retrieving Full Comment Text
-          If you need the full text of a truncated comment, run: `fizzy comment show COMMENT_ID --card CARD_NUMBER`
+          ### Fizzy CLI Tips
+          - Use `--jq` for filtering output (built-in, never pipe to external jq): `fizzy card list --jq '[.data[] | {number, title}]'`
+          - Use `fizzy search "query"` for cross-board full-text search
+          - Use `fizzy card list --search "term"` for structured filtering within a board
+          - Use `--agent` flag for raw JSON data without envelope when parsing output
+          - Retrieve full comment text: `fizzy comment show COMMENT_ID --card CARD_NUMBER`
 
           ### Card Memory Discipline (CRITICAL for long-running cards)
           When writing your memory file for a Fizzy card session, include:
@@ -40,8 +44,8 @@ module Brainiac
           Re-fetch the card to see if anything changed while you were working:
 
           ```bash
-          fizzy card show {{CARD_NUMBER}}
-          fizzy comment list --card {{CARD_NUMBER}}
+          fizzy card show {{CARD_NUMBER}} --jq '.data | {title, description, assignees: [.assignees[].name]}'
+          fizzy comment list --card {{CARD_NUMBER}} --jq '[.data[-5:] | .[] | {creator: .creator.name, body: .body.plain_text}]'
           ```
 
           Compare against the card context from the start of your session. Check for:

data/lib/brainiac/plugins/fizzy/version.rb

@@ -3,7 +3,7 @@
 module Brainiac
   module Plugins
     module Fizzy
-      VERSION = "0.0.16"
+      VERSION = "0.0.18"
     end
   end
 end

data/lib/brainiac/plugins/fizzy.rb

@@ -78,7 +78,7 @@ module Brainiac
             reload_projects!
             reload_agent_registry!
 
-            status_code, body = dispatch_webhook_action(action, payload)
+            status_code, body = dispatch_webhook_action(action, payload, board_key: board_key)
             LOG.info "[Fizzy] #{action} response: #{status_code} - #{body}"
             halt status_code, body
           rescue JSON::ParserError => e
@@ -175,7 +175,7 @@ module Brainiac
 
         public
 
-        def handle_publish_or_triage(action, payload)
+        def handle_publish_or_triage(action, payload, board_key: nil)
           eventable = payload["eventable"] || {}
           card_number = eventable["number"]&.to_s
 
@@ -189,10 +189,10 @@ module Brainiac
 
           if action == "card_published"
             assignees = eventable["assignees"] || []
-            return handle_card_assigned(payload) if assignees.any? { |a| local_agent_names.include?(a["name"]) }
+            return handle_card_assigned(payload, board_key: board_key) if assignees.any? { |a| local_agent_names.include?(a["name"]) }
           end
 
-          handle_card_published(payload)
+          handle_card_published(payload, board_key: board_key)
         end
       end
     end

metadata

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