brainiac 0.0.23 → 0.0.26

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8bdf84241f89389aef9a1693abd00b1cfdf77d645c096081acb4ea0e8d1de8ed
-  data.tar.gz: 9ed60b3c1ba3fdcdcae4e3b05cfb15fa2a1a60c6311cd8add2c7fa9a3e4e839a
+  metadata.gz: 963f3a3319ca2ccff44fc003072a0566d3b76d06a42ea645d81693bb48ea2ab3
+  data.tar.gz: 7abb9b38680549aaf3da6068b459f0faf474f5862f7f235f1dabddfcb38d5e55
 SHA512:
-  metadata.gz: 7e5df006c01b492f2e1e9f9918a208b2bcdbdefcf0df032662b12d2f107872f1456ba37200ad70ebd19d3fa218da030a35681249ec4f232af56da4132bc7eef8
-  data.tar.gz: 24cc2728b08071c0ecc4c52bbabedf568446749322e27aad386c5b23395affce9e6b1c16c06feace6ba8487d261dc136a64db6325de1d75f1efc0ca320bef5f4
+  metadata.gz: dae8e213cb21a26f97de1406a5fe0bc1ce7dc5806e3b67079e2c0183b94888439f288243d86dc52fd9831d1ee61294a2f28fe9fe4f88dc03819c1d720a95db9b
+  data.tar.gz: 2e7cf53a24fd776e2eb7960c379dc49309d932412f5fe39a8a56dd90a6162dcf3a9924396a7386b67a0288c0034381343effb529e53b8bcf4b4f43b7fc454708

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    brainiac (0.0.23)
+    brainiac (0.0.26)
       puma (~> 7.2)
       rackup (~> 2.3)
       sinatra (~> 4.1)
@@ -84,7 +84,7 @@ DEPENDENCIES
 CHECKSUMS
   ast (2.4.3) sha256=954615157c1d6a382bc27d690d973195e79db7f55e9765ac7c481c60bdb4d383
   base64 (0.3.0) sha256=27337aeabad6ffae05c265c450490628ef3ebd4b67be58257393227588f5a97b
-  brainiac (0.0.23)
+  brainiac (0.0.26)
   json (2.19.9) sha256=9b9025b7cdddafa38d316eca0b2358488e42d417045c1b90d216a9fefe46b79a
   language_server-protocol (3.17.0.5) sha256=fd1e39a51a28bf3eec959379985a72e296e9f9acfce46f6a79d31ca8760803cc
   lint_roller (1.1.0) sha256=2c0c845b632a7d172cb849cc90c1bce937a28c5c8ccccb50dfd46a485003cc87

data/bin/brainiac

@@ -208,14 +208,7 @@ end
 def stop_server
   pid = find_server_pid
 
-  unless pid
-    puts "No running Brainiac server found."
-    return false
-  end
-
-  puts "Stopping Brainiac server (PID: #{pid})..."
-
-  # Also stop the monitor daemon
+  # Stop the monitor daemon regardless of server PID
   daemon_pid_file = "/tmp/brainiac-daemon.pid"
   if File.exist?(daemon_pid_file)
     daemon_pid = File.read(daemon_pid_file).strip.to_i
@@ -228,40 +221,61 @@ def stop_server
     File.delete(daemon_pid_file)
   end
 
-  begin
-    Process.kill("TERM", pid)
-
-    # Wait up to 5 seconds for graceful shutdown
-    5.times do
-      sleep 2
-      next if process_running?(pid)
+  # Kill the known server PID
+  if pid
+    puts "Stopping Brainiac server (PID: #{pid})..."
+    kill_pid(pid)
+  end
 
-      puts "✓ Server stopped."
-      FileUtils.rm_f(PID_FILE)
-      return true
-    end
+  # After killing the known PID, find anything still holding port 4567.
+  # This catches orphaned processes from self-restarts, stale PIDs, or child processes.
+  lingering = find_port_holders(4567) - [pid].compact
+  if lingering.any?
+    puts "Cleaning up #{lingering.size} orphaned process(es) on port 4567..."
+    lingering.each { |lpid| kill_pid(lpid, quiet: true) }
+  end
 
-    # Force kill if still running
-    puts "Server didn't stop gracefully, forcing..."
-    Process.kill("KILL", pid)
-    sleep 1
+  FileUtils.rm_f(PID_FILE)
 
-    FileUtils.rm_f(PID_FILE)
-    puts "✓ Server stopped (forced)."
+  if pid || lingering.any?
+    puts "✓ Server stopped."
     true
-  rescue Errno::ESRCH
-    puts "✓ Server already stopped."
-    FileUtils.rm_f(PID_FILE)
-    true
-  rescue Errno::EPERM
-    puts "Error: Permission denied. Try running with sudo or check process ownership."
-    false
-  rescue StandardError => e
-    puts "Error stopping server: #{e.message}"
+  else
+    puts "No running Brainiac server found."
     false
   end
 end
 
+# Kill a single process: TERM first, KILL if it doesn't exit within 5s.
+def kill_pid(pid, quiet: false)
+  Process.kill("TERM", pid)
+
+  5.times do
+    sleep 1
+    return true unless process_running?(pid)
+  end
+
+  puts "  PID #{pid} didn't stop gracefully, forcing..." unless quiet
+  Process.kill("KILL", pid)
+  sleep 1
+  true
+rescue Errno::ESRCH
+  true # Already dead
+rescue Errno::EPERM
+  puts "Error: Permission denied to stop PID #{pid}." unless quiet
+  false
+end
+
+# Find all PIDs listening on a given port via lsof.
+def find_port_holders(port)
+  output, status = Open3.capture2("lsof", "-ti", ":#{port}")
+  return [] unless status.success?
+
+  output.strip.split("\n").map(&:to_i).select(&:positive?)
+rescue StandardError
+  []
+end
+
 def update_handler_config(name, enabled)
   brainiac_config_path = File.join(BRAINIAC_DIR, "brainiac.json")
   config = if File.exist?(brainiac_config_path)
@@ -527,6 +541,84 @@ def generate_plugin_skill_md(plugin_name, pascal_name)
   SKILL
 end
 
+SCREENSHOT_CREDS_FILE = File.join(BRAINIAC_DIR, "tmp", "screenshot-creds.json")
+
+# Resolve all op:// references in deployments.json and write to a secure cache file.
+# This allows screenshot commands to work without re-authenticating with 1Password.
+def resolve_screenshot_credentials(quiet: false)
+  deployments_file = File.join(BRAINIAC_DIR, "deployments.json")
+  unless File.exist?(deployments_file)
+    puts "  ⚠ No deployments.json found, skipping credential resolution." unless quiet
+    return false
+  end
+
+  deployments = JSON.parse(File.read(deployments_file))
+  environments = deployments["environments"] || {}
+
+  # Collect all unique op:// references
+  op_refs = {}
+  environments.each_value do |env_config|
+    screenshot = env_config["screenshot"]
+    next unless screenshot
+
+    (screenshot["customers"] || {}).each_value { |ref| op_refs[ref] = nil }
+    (screenshot["employees"] || {}).each_value { |ref| op_refs[ref] = nil }
+  end
+
+  if op_refs.empty?
+    puts "  ⚠ No screenshot credentials to resolve." unless quiet
+    return false
+  end
+
+  puts "  Resolving #{op_refs.size} credential(s) from 1Password..." unless quiet
+
+  # Resolve each unique op:// reference
+  failed = []
+  op_refs.each_key do |ref|
+    password, status = Open3.capture2("op", "read", ref)
+    if status.success?
+      op_refs[ref] = password.chomp
+    else
+      failed << ref
+    end
+  end
+
+  if failed.any?
+    puts "  ❌ Failed to resolve #{failed.size} credential(s):" unless quiet
+    failed.each { |ref| puts "     #{ref}" } unless quiet
+    return false
+  end
+
+  # Write resolved credentials to cache file with restrictive permissions
+  cache_dir = File.join(BRAINIAC_DIR, "tmp")
+  FileUtils.mkdir_p(cache_dir)
+  File.write(SCREENSHOT_CREDS_FILE, JSON.pretty_generate(op_refs))
+  File.chmod(0o600, SCREENSHOT_CREDS_FILE)
+
+  puts "  ✓ Screenshot credentials cached (#{op_refs.size} resolved)" unless quiet
+  true
+rescue JSON::ParserError => e
+  puts "  ❌ Failed to parse deployments.json: #{e.message}" unless quiet
+  false
+end
+
+# Read a resolved credential from the cache file, falling back to `op read`.
+def read_screenshot_credential(op_ref)
+  # Try cache first
+  if File.exist?(SCREENSHOT_CREDS_FILE)
+    creds = JSON.parse(File.read(SCREENSHOT_CREDS_FILE))
+    return creds[op_ref] if creds[op_ref]
+  end
+
+  # Fallback: resolve directly via op read
+  password, status = Open3.capture2("op", "read", op_ref)
+  return password.chomp if status.success?
+
+  nil
+rescue JSON::ParserError
+  nil
+end
+
 def start_server(daemon: false)
   # Resolve the real path of the brainiac script (follows symlinks)
   receiver_path = File.join(BRAINIAC_ROOT, "receiver.rb")
@@ -544,6 +636,9 @@ def start_server(daemon: false)
     exit 1
   end
 
+  # Pre-resolve screenshot credentials from 1Password (so agents can screenshot without re-auth)
+  resolve_screenshot_credentials
+
   if daemon
     # Daemon mode: start in background (like the old behavior)
     log_dir = File.join(receiver_dir, "tmp")
@@ -1107,8 +1202,7 @@ when "unregister", "remove", "rm"
 when "list", "ls"
   list_projects
 
-when "projects"
-  # Support "brainiac projects list" as an alias for "brainiac list"
+when "projects", "project"
   projects_cmd = ARGV.shift
   case projects_cmd
   when "list", "ls", nil
@@ -1140,9 +1234,140 @@ when "projects"
     save_projects(projects)
 
     puts "✓ Set '#{project_key}' as the default project"
+  when "update", "set"
+    project_key = ARGV.shift
+    field = ARGV.shift
+    value = ARGV.join(" ") # Allow multi-word values (e.g. tags with spaces)
+
+    unless project_key && field
+      puts "Usage: brainiac projects update <key> <field> <value>"
+      puts ""
+      puts "Fields:"
+      puts "  repo_path <path>           Path to the project repository"
+      puts "  github_repo <owner/repo>   GitHub repository (e.g. stowzilla/brainiac)"
+      puts "  fizzy_tags <tag1,tag2>     Comma-separated Fizzy tags"
+      puts "  fizzy_board <board>        Default Fizzy board key"
+      puts "  cli_provider <provider>    CLI provider name (e.g. kiro, grok)"
+      puts "  agent_name <name>          Default agent for this project"
+      puts "  agent_model <model>        Default model (e.g. auto, opus, sonnet)"
+      puts "  default_branch <branch>    Default git branch (e.g. main, master)"
+      puts ""
+      puts "Examples:"
+      puts "  brainiac projects update brainiac fizzy_board stowzilla"
+      puts "  brainiac projects update marketplace cli_provider grok"
+      puts "  brainiac projects update brainiac fizzy_tags brainiac,core"
+      puts "  brainiac projects update marketplace agent_model opus"
+      exit 1
+    end
+
+    projects = load_projects
+    unless projects.key?(project_key)
+      puts "Error: Project '#{project_key}' not found."
+      puts "Available projects: #{projects.keys.join(", ")}"
+      exit 1
+    end
+
+    # Handle special field parsing
+    case field
+    when "fizzy_tags", "tags"
+      field = "fizzy_tags"
+      unless value && !value.empty?
+        puts "Error: Value required. Provide comma-separated tags."
+        exit 1
+      end
+      parsed_value = value.split(",").map(&:strip)
+    when "repo_path"
+      unless value && !value.empty?
+        puts "Error: Value required."
+        exit 1
+      end
+      parsed_value = File.expand_path(value)
+      puts "Warning: Path does not exist: #{parsed_value}" unless Dir.exist?(parsed_value)
+    else
+      # Handles known fields (github_repo, fizzy_board, cli_provider, agent_name, agent_model,
+      # default_branch) and arbitrary fields for forward-compatibility
+      unless value && !value.empty?
+        puts "Error: Value required."
+        exit 1
+      end
+      parsed_value = value
+    end
+
+    projects[project_key][field] = parsed_value
+    save_projects(projects)
+
+    display_value = parsed_value.is_a?(Array) ? parsed_value.join(", ") : parsed_value
+    puts "✓ Updated #{project_key}: #{field} = #{display_value}"
+
+  when "unset", "delete-field"
+    project_key = ARGV.shift
+    field = ARGV.shift
+
+    unless project_key && field
+      puts "Usage: brainiac projects unset <key> <field>"
+      puts ""
+      puts "Removes a field from a project's configuration."
+      puts ""
+      puts "Examples:"
+      puts "  brainiac projects unset marketplace fizzy_board"
+      puts "  brainiac projects unset brainiac default_branch"
+      exit 1
+    end
+
+    projects = load_projects
+    unless projects.key?(project_key)
+      puts "Error: Project '#{project_key}' not found."
+      exit 1
+    end
+
+    unless projects[project_key].key?(field)
+      puts "Error: Field '#{field}' not set on project '#{project_key}'."
+      exit 1
+    end
+
+    projects[project_key].delete(field)
+    save_projects(projects)
+    puts "✓ Removed #{field} from #{project_key}"
+
+  when "help", "--help", "-h"
+    puts <<~HELP
+      Usage: brainiac projects <command> [options]
+
+      Commands:
+        list                              List all registered projects (default)
+        show <key>                        Show detailed configuration for a project
+        default <key>                     Set the default project (fallback when no tags match)
+        update <key> <field> <value>      Update a project config field
+        unset <key> <field>               Remove a field from project config
+
+      Aliases:
+        brainiac project  Works the same as 'brainiac projects'
+        brainiac list     Shortcut for 'brainiac projects list'
+        brainiac show     Shortcut for 'brainiac projects show'
+
+      Update fields:
+        repo_path         Path to the project repository
+        github_repo       GitHub repository (owner/repo)
+        fizzy_tags        Comma-separated Fizzy tags
+        fizzy_board       Default Fizzy board key
+        cli_provider      CLI provider name (kiro, grok, etc.)
+        agent_name        Default agent for this project
+        agent_model       Default model (auto, opus, sonnet, haiku, etc.)
+        default_branch    Default git branch
+
+      Examples:
+        brainiac projects list
+        brainiac project show marketplace
+        brainiac projects default marketplace
+        brainiac projects update brainiac fizzy_board stowzilla
+        brainiac projects update marketplace agent_model opus
+        brainiac projects update brainiac fizzy_tags brainiac,core
+        brainiac projects unset marketplace fizzy_board
+    HELP
   else
     puts "Unknown projects command: #{projects_cmd}"
-    puts "Available: list, show, default"
+    puts "Available: list, show, default, update, unset, help"
+    puts "Run 'brainiac projects help' for more details."
     exit 1
   end
 
@@ -3161,16 +3386,404 @@ when "plugin"
     puts "  brainiac install #{plugin_name} --path #{output_dir}"
     puts "  brainiac restart"
 
+  when "list", "ls"
+    # Delegate to the same logic as `brainiac plugins`
+    plugins_file = File.join(BRAINIAC_DIR, "plugins.json")
+    plugins_config = if File.exist?(plugins_file)
+                       JSON.parse(File.read(plugins_file))
+                     else
+                       { "plugins" => [] }
+                     end
+
+    plugins = plugins_config["plugins"] || []
+    if plugins.empty?
+      puts "No plugins installed."
+      puts ""
+      puts "Install plugins with: brainiac install <name>"
+      puts "  Example: brainiac install whatsapp"
+      puts "  Example: brainiac install fizzy --path ~/Code/brainiac-fizzy"
+    else
+      puts "Installed plugins:"
+      plugins.each do |p|
+        entry = p.is_a?(Hash) ? p : { "name" => p.to_s }
+        name = entry["name"]
+        gem_name = entry["gem"] || "brainiac-#{name}"
+        local_path = entry["path"]
+        installed_at = entry["installed_at"] ? " (#{entry["installed_at"][0..9]})" : ""
+
+        if local_path
+          if Dir.exist?(local_path)
+            puts "  ✓ #{name} → #{local_path}#{installed_at}"
+          else
+            puts "  ✗ #{name} → #{local_path} (path missing)#{installed_at}"
+          end
+        else
+          loadable = begin
+            spec = Gem::Specification.find_by_name(gem_name)
+            "✓ #{name} (#{gem_name} #{spec.version})"
+          rescue Gem::MissingSpecError
+            "✗ #{name} (#{gem_name} — gem not found)"
+          end
+          puts "  #{loadable}#{installed_at}"
+        end
+      end
+    end
+
+  when "switch"
+    plugin_name = ARGV.shift
+    branch_name = ARGV.shift
+
+    unless plugin_name && branch_name
+      puts "Usage: brainiac plugin switch <name> <branch>"
+      puts ""
+      puts "Switches a local plugin to a different branch (via git worktrees)."
+      puts "Useful for testing plugin changes from a PR before releasing."
+      puts ""
+      puts "Examples:"
+      puts "  brainiac plugin switch fizzy fix-fallback-for-followups-20260813"
+      puts "  brainiac plugin switch fizzy main       # switch back to main"
+      puts ""
+      puts "After switching, restart the server: brainiac restart"
+      exit 1
+    end
+
+    plugin_name = plugin_name.sub(/^brainiac-/, "")
+
+    plugins_file = File.join(BRAINIAC_DIR, "plugins.json")
+    unless File.exist?(plugins_file)
+      puts "Error: No plugins installed (plugins.json not found)."
+      exit 1
+    end
+
+    plugins_config = JSON.parse(File.read(plugins_file))
+    plugin_idx = (plugins_config["plugins"] || []).index { |p| (p.is_a?(Hash) ? p["name"] : p.to_s) == plugin_name }
+
+    unless plugin_idx
+      puts "Error: Plugin '#{plugin_name}' is not installed."
+      exit 1
+    end
+
+    entry = plugins_config["plugins"][plugin_idx]
+    unless entry.is_a?(Hash) && entry["path"]
+      puts "Error: Plugin '#{plugin_name}' is not a local-path plugin."
+      puts "  Only plugins installed with --path support branch switching."
+      exit 1
+    end
+
+    current_path = entry["path"]
+    gem_name = "brainiac-#{plugin_name}"
+
+    # Determine the base repo path (strip worktree suffix like --branch-name)
+    base_path = current_path.sub(/--[^\/]+$/, "")
+    unless Dir.exist?(base_path)
+      puts "Error: Base repo not found at #{base_path}"
+      exit 1
+    end
+
+    # Get the default branch of the repo
+    default_branch, _, db_status = Open3.capture3("git", "symbolic-ref", "refs/remotes/origin/HEAD", "--short", chdir: base_path)
+    default_branch = default_branch.strip.sub("origin/", "") if db_status.success?
+    default_branch = "main" unless db_status.success? && !default_branch.empty?
+
+    # If switching to the default branch, just point back to the base path
+    if branch_name == default_branch
+      if current_path == base_path
+        puts "Plugin '#{plugin_name}' is already on #{default_branch}."
+        exit 0
+      end
+
+      plugins_config["plugins"][plugin_idx]["path"] = base_path
+      File.write(plugins_file, JSON.pretty_generate(plugins_config))
+      puts "✓ Switched plugin '#{plugin_name}' back to #{default_branch}"
+      puts "  Path: #{base_path}"
+      puts "  Restart the server to apply: brainiac restart"
+      exit 0
+    end
+
+    # Fetch latest to make sure the branch is available
+    puts "Fetching latest from origin..."
+    _out, _err, fetch_status = Open3.capture3("git", "fetch", "origin", chdir: base_path)
+    unless fetch_status.success?
+      puts "Warning: git fetch failed — continuing with local state."
+    end
+
+    # Check if a worktree already exists for this branch
+    worktree_list, _, wt_status = Open3.capture3("git", "worktree", "list", "--porcelain", chdir: base_path)
+    target_worktree = nil
+
+    if wt_status.success?
+      # Parse porcelain output to find worktrees on the target branch
+      worktrees = worktree_list.split("\n\n").map do |block|
+        wt = {}
+        block.each_line do |line|
+          case line
+          when /^worktree (.+)/
+            wt[:path] = Regexp.last_match(1).strip
+          when /^branch refs\/heads\/(.+)/
+            wt[:branch] = Regexp.last_match(1).strip
+          end
+        end
+        wt
+      end.select { |wt| wt[:path] && wt[:branch] }
+
+      target_worktree = worktrees.find { |wt| wt[:branch] == branch_name }
+    end
+
+    if target_worktree
+      # Worktree already exists — just update the path
+      new_path = target_worktree[:path]
+      if current_path == new_path
+        puts "Plugin '#{plugin_name}' is already on branch '#{branch_name}'."
+        exit 0
+      end
+
+      plugins_config["plugins"][plugin_idx]["path"] = new_path
+      File.write(plugins_file, JSON.pretty_generate(plugins_config))
+      puts "✓ Switched plugin '#{plugin_name}' to branch '#{branch_name}'"
+      puts "  Path: #{new_path}"
+      puts "  Restart the server to apply: brainiac restart"
+    else
+      # Check if branch exists remotely or locally
+      branch_exists = false
+      check_cmd, _, check_status = Open3.capture3("git", "rev-parse", "--verify", "origin/#{branch_name}", chdir: base_path)
+      branch_exists = check_status.success?
+
+      unless branch_exists
+        # Try local branch
+        _, _, local_status = Open3.capture3("git", "rev-parse", "--verify", branch_name, chdir: base_path)
+        branch_exists = local_status.success?
+      end
+
+      unless branch_exists
+        puts "Error: Branch '#{branch_name}' not found (checked local and origin)."
+        puts ""
+        puts "Available remote branches:"
+        branches_out, = Open3.capture3("git", "branch", "-r", "--list", "origin/*", chdir: base_path)
+        branches_out.each_line do |line|
+          branch = line.strip.sub("origin/", "")
+          next if branch.include?("HEAD")
+
+          puts "  #{branch}"
+        end
+        exit 1
+      end
+
+      # Create a new worktree
+      worktree_dir = "#{base_path}--#{branch_name}"
+      puts "Creating worktree at #{worktree_dir}..."
+
+      # If the branch exists on origin but not locally, track it
+      _, _, local_check = Open3.capture3("git", "rev-parse", "--verify", branch_name, chdir: base_path)
+      if !local_check.success? && check_status.success?
+        # Remote branch exists but not local — create tracking branch in worktree
+        _, stderr, wt_status = Open3.capture3("git", "worktree", "add", "--track", "-b", branch_name, worktree_dir, "origin/#{branch_name}", chdir: base_path)
+      else
+        # Local branch exists — use it directly
+        _, stderr, wt_status = Open3.capture3("git", "worktree", "add", worktree_dir, branch_name, chdir: base_path)
+      end
+
+      unless wt_status.success?
+        puts "Error: Failed to create worktree:"
+        puts "  #{stderr.strip}"
+        exit 1
+      end
+
+      plugins_config["plugins"][plugin_idx]["path"] = worktree_dir
+      File.write(plugins_file, JSON.pretty_generate(plugins_config))
+      puts "✓ Switched plugin '#{plugin_name}' to branch '#{branch_name}'"
+      puts "  Worktree: #{worktree_dir}"
+      puts "  Restart the server to apply: brainiac restart"
+    end
+
   else
     puts "Usage: brainiac plugin <command>"
     puts ""
     puts "Commands:"
+    puts "  list                         List installed plugins"
     puts "  new <name>                   Generate a new plugin gem skeleton"
+    puts "  switch <name> <branch>       Switch a local plugin to a different branch"
     puts ""
     puts "Managing installed plugins:"
     puts "  brainiac install <name>      Install a plugin"
     puts "  brainiac uninstall <name>    Remove a plugin"
-    puts "  brainiac plugins             List installed plugins"
+    puts "  brainiac plugins             List installed plugins (alias)"
+  end
+
+when "screenshot"
+  # Resolve screenshot credentials from cached file and delegate to project's screenshot script.
+  # Usage: brainiac screenshot [app-name] [page-path] [--env ENV] [extra args...]
+  #
+  # Credentials are resolved from 1Password at server start and cached in
+  # ~/.brainiac/tmp/screenshot-creds.json. Falls back to `op read` if cache is missing.
+  # Run `brainiac screenshot resolve` to manually refresh the cache.
+
+  deployments_file = File.join(BRAINIAC_DIR, "deployments.json")
+  abort "Error: #{deployments_file} not found. Run 'brainiac setup' or create it manually." unless File.exist?(deployments_file)
+
+  deployments = JSON.parse(File.read(deployments_file))
+  environments = deployments["environments"] || {}
+
+  sub = ARGV.shift
+  case sub
+  when "envs", "list"
+    environments.each do |key, env|
+      screenshot = env["screenshot"]
+      if screenshot
+        customers = (screenshot["customers"] || {}).keys
+        employees = (screenshot["employees"] || {}).keys
+        puts "  #{key} (#{env["label"]})"
+        puts "    Customers: #{customers.join(", ")}" if customers.any?
+        puts "    Employees: #{employees.join(", ")}" if employees.any?
+      else
+        puts "  #{key} (#{env["label"]}) — no screenshot config"
+      end
+    end
+
+  when "resolve"
+    puts "Resolving screenshot credentials from 1Password..."
+    if resolve_screenshot_credentials(quiet: false)
+      puts "\nCredentials cached at #{SCREENSHOT_CREDS_FILE}"
+      puts "Screenshots will use the cache — no 1Password re-auth needed."
+    else
+      abort "\nFailed to resolve credentials. Ensure `op` is signed in."
+    end
+
+  when "help", "--help", "-h", nil
+    puts <<~HELP
+      brainiac screenshot — Take screenshots with credentials from deployments.json
+
+      Usage:
+        brainiac screenshot <app-name> <page-path> [options]
+
+      Credentials are resolved from 1Password at server start and cached in
+      #{SCREENSHOT_CREDS_FILE} (mode 0600). Use `brainiac screenshot resolve`
+      to manually refresh the cache.
+
+      Options:
+        --env ENV           Environment to use (default: auto-detect from project owner)
+        --customer EMAIL    Use specific customer email (default: first in list)
+        --employee EMAIL    Use specific employee email (default: first in list)
+        --project KEY       Project key (default: current directory or default project)
+        All other args are passed through to screenshot-page.sh
+
+      Commands:
+        brainiac screenshot resolve     Resolve and cache credentials from 1Password
+        brainiac screenshot envs        List environments with screenshot config
+        brainiac screenshot help        Show this help
+
+      Examples:
+        brainiac screenshot ops-app /api-explorer
+        brainiac screenshot ops-app /inventory --env dev04
+        brainiac screenshot app /dashboard --env dev02
+    HELP
+
+  else
+    # Parse flags from remaining args
+    app_name = sub
+    page_path = ARGV.shift
+    abort "Error: page path required. Usage: brainiac screenshot <app-name> <page-path> [options]" unless page_path
+
+    env_name = nil
+    customer_email = nil
+    employee_email = nil
+    project_key = nil
+    passthrough_args = []
+
+    while (arg = ARGV.shift)
+      case arg
+      when "--env"
+        env_name = ARGV.shift
+      when "--customer"
+        customer_email = ARGV.shift
+      when "--employee"
+        employee_email = ARGV.shift
+      when "--project"
+        project_key = ARGV.shift
+      else
+        passthrough_args << arg
+        # If the flag takes a value, pass it through too
+        passthrough_args << ARGV.shift if arg.start_with?("--") && !arg.include?("=") && ARGV.first && !ARGV.first.start_with?("--")
+      end
+    end
+
+    # Determine environment (default: dev02 for Linux)
+    env_name ||= case RUBY_PLATFORM
+                 when /darwin/ then "dev01"
+                 else "dev02"
+                 end
+
+    env_config = environments[env_name]
+    abort "Error: Environment '#{env_name}' not found in deployments.json. Available: #{environments.keys.join(", ")}" unless env_config
+
+    screenshot_config = env_config["screenshot"]
+    abort "Error: No 'screenshot' config for environment '#{env_name}' in deployments.json." unless screenshot_config
+
+    customers = screenshot_config["customers"] || {}
+    employees = screenshot_config["employees"] || {}
+
+    # Resolve which email to use
+    if app_name == "ops-app"
+      email = employee_email || employees.keys.first
+      op_ref = employees[email]
+      abort "Error: Employee email '#{email}' not found in #{env_name} screenshot config. Available: #{employees.keys.join(", ")}" unless op_ref
+    else
+      email = customer_email || customers.keys.first
+      op_ref = customers[email]
+      abort "Error: Customer email '#{email}' not found in #{env_name} screenshot config. Available: #{customers.keys.join(", ")}" unless op_ref
+    end
+
+    # Resolve password (from cache or 1Password directly)
+    password = read_screenshot_credential(op_ref)
+    unless password
+      abort "Error: Failed to resolve password for #{op_ref}. Run 'brainiac screenshot resolve' or 'brainiac restart' to refresh the cache."
+    end
+
+    # Determine project path
+    projects = load_projects
+    if project_key
+      project = projects[project_key]
+      abort "Error: Project '#{project_key}' not found." unless project
+    else
+      # Try to find project from current directory or env config
+      project = projects.find { |_k, p| p["repo_path"] == Dir.pwd }&.last
+      project ||= projects[env_config["project"]]
+    end
+
+    abort "Error: Could not determine project. Use --project KEY." unless project
+    repo_path = project["repo_path"]
+    script_path = File.join(repo_path, "scripts", "screenshot-page.sh")
+    abort "Error: Screenshot script not found at #{script_path}" unless File.exist?(script_path)
+
+    # Build environment
+    screenshot_env = {
+      "SCREENSHOT_CUSTOMER_EMAIL" => (app_name == "ops-app" ? (customers.keys.first || email) : email),
+      "SCREENSHOT_CUSTOMER_PASSWORD" => password,
+      "SCREENSHOT_OPS_EMAIL" => (app_name == "ops-app" ? email : (employees.keys.first || email)),
+      "SCREENSHOT_OPS_PASSWORD" => password
+    }
+
+    # Also set environment-specific email vars
+    env_upper = env_name.upcase.tr("-", "_")
+    screenshot_env["SCREENSHOT_#{env_upper}_CUSTOMER_EMAIL"] = customers.keys.first if customers.any?
+
+    # Run the screenshot script
+    cmd = [script_path, app_name, page_path, "", ""] + passthrough_args
+    puts "Taking screenshot: #{app_name} #{page_path} (env: #{env_name}, user: #{email})"
+    puts "Running: #{cmd.join(" ")}"
+
+    pid = spawn(screenshot_env, *cmd, chdir: repo_path)
+    Process.wait(pid)
+
+    if $CHILD_STATUS.success?
+      # Find the most recent screenshot
+      attachments_dir = File.join(repo_path, ".fizzy-attachments")
+      if Dir.exist?(attachments_dir)
+        latest = Dir.glob(File.join(attachments_dir, "*.png")).max_by { |f| File.mtime(f) }
+        puts "\n✅ Screenshot saved: #{latest}" if latest
+      end
+    else
+      abort "\n❌ Screenshot failed (exit #{$CHILD_STATUS.exitstatus})"
+    end
   end
 
 when "version", "--version", "-v"
@@ -3200,8 +3813,8 @@ when "help", "--help", "-h", nil
         brainiac register [options]     Register current directory as a project
         brainiac unregister <key>       Unregister a project
         brainiac list                   List all registered projects
-        brainiac projects list          List all registered projects (alias)
-        brainiac projects default <key> Set the default project
+        brainiac projects <command>     Manage projects (list, show, default, help)
+        brainiac project <command>      Alias for 'brainiac projects'
         brainiac show <key>             Show project configuration
         brainiac plugin new <name>      Generate a new plugin gem skeleton
         brainiac update                  Update brainiac and all installed plugins
@@ -3214,6 +3827,7 @@ when "help", "--help", "-h", nil
         brainiac provider <command>     Manage CLI providers
         brainiac role <command>         Manage agent roles
         brainiac agent <command>        Manage agent registry (env, list, show)
+        brainiac screenshot <app> <path> Take screenshot with 1Password credentials
         brainiac config                 Configure Brainiac CLI
         brainiac path                   Show Brainiac config directory
         brainiac version                Show version
@@ -3224,6 +3838,7 @@ when "help", "--help", "-h", nil
 
       Plugin Commands:
         plugin new <name>                Generate a new plugin gem skeleton
+        plugin switch <name> <branch>    Switch a local plugin to a branch (for testing)
         install <name>                   Install a plugin (gem install brainiac-<name>)
         uninstall <name>                 Remove a plugin
         update [name]                    Update brainiac + all plugins, or a specific plugin

data/bin/brainiac-completion.bash

@@ -9,7 +9,7 @@ _brainiac() {
   local brainiac_dir="${BRAINIAC_DIR:-$HOME/.brainiac}"
 
   # Top-level commands (built-in + installed plugins)
-  local commands="server start stop restart logs status register unregister list show brain cron provider role agent config path version help setup projects card-map handler plugin install uninstall plugins"
+  local commands="server start stop restart logs status register unregister list show brain cron provider role agent config path version help setup projects project card-map handler plugin install uninstall plugins"
 
   # Add installed plugin names as top-level commands
   if [[ -f "$brainiac_dir/plugins.json" ]]; then
@@ -63,7 +63,18 @@ _brainiac() {
     plugin)
       case $cword in
         2)
-          COMPREPLY=($(compgen -W "new" -- "$cur"))
+          COMPREPLY=($(compgen -W "new switch list" -- "$cur"))
+          ;;
+        3)
+          # For "plugin switch", suggest installed plugin names
+          if [[ "${COMP_WORDS[2]}" == "switch" && -f "$brainiac_dir/plugins.json" ]]; then
+            local installed
+            installed=$(ruby -rjson -e '
+              config = JSON.parse(File.read(ARGV[0]))
+              (config["plugins"] || []).select { |p| p.is_a?(Hash) && p["path"] }.each { |p| puts p["name"] }
+            ' "$brainiac_dir/plugins.json" 2>/dev/null)
+            COMPREPLY=($(compgen -W "$installed" -- "$cur"))
+          fi
           ;;
       esac
       ;;
@@ -180,16 +191,40 @@ _brainiac() {
       esac
       ;;
 
-    projects)
+    projects|project)
       case $cword in
         2)
-          COMPREPLY=($(compgen -W "list default" -- "$cur"))
+          COMPREPLY=($(compgen -W "list show default update unset help" -- "$cur"))
           ;;
         3)
-          if [[ "${words[2]}" == "default" ]]; then
+          local subcmd="${words[2]}"
+          if [[ "$subcmd" == "default" || "$subcmd" == "show" || "$subcmd" == "update" || "$subcmd" == "unset" ]]; then
             COMPREPLY=($(compgen -W "$(_brainiac_projects)" -- "$cur"))
           fi
           ;;
+        4)
+          local subcmd="${words[2]}"
+          if [[ "$subcmd" == "update" || "$subcmd" == "unset" ]]; then
+            COMPREPLY=($(compgen -W "repo_path github_repo fizzy_tags fizzy_board cli_provider agent_name agent_model default_branch" -- "$cur"))
+          fi
+          ;;
+        5)
+          local subcmd="${words[2]}"
+          local field="${words[4]}"
+          if [[ "$subcmd" == "update" ]]; then
+            case "$field" in
+              cli_provider)
+                COMPREPLY=($(compgen -W "$(_brainiac_providers)" -- "$cur"))
+                ;;
+              agent_model)
+                COMPREPLY=($(compgen -W "auto opus sonnet haiku deepseek minimax qwen" -- "$cur"))
+                ;;
+              agent_name)
+                COMPREPLY=($(compgen -W "$(_brainiac_agents)" -- "$cur"))
+                ;;
+            esac
+          fi
+          ;;
       esac
       ;;
 

data/lib/brainiac/config.rb

@@ -157,7 +157,7 @@ DEFAULT_PROJECT = {
   "agent_effort_flag" => ENV["AGENT_EFFORT_FLAG"] || "--effort",
   "agent_effort" => ENV.fetch("AGENT_EFFORT", nil),
   "allowed_models" => {
-    "opus" => "claude-opus-4.6",
+    "opus" => "claude-opus-4.5",
     "sonnet" => "claude-sonnet-4.6",
     "haiku" => "claude-haiku-4.5",
     "deepseek" => "deepseek-3.2",

data/lib/brainiac/cron.rb

@@ -466,7 +466,10 @@ def handle_cron_completion(job, project, agent_name, agent_config_name, log_file
   update_cron_job_state(job)
 
   if File.exist?(response_file)
-    LOG.info "[Cron] Job #{job[:id]} completed. Response: #{File.read(response_file)[0..100]}..."
+    response_content = File.read(response_file).strip
+    LOG.info "[Cron] Job #{job[:id]} completed. Response: #{response_content[0..100]}..."
+
+    notify_cron_output(job, response_content, agent_name: agent_name) if job[:notify_target] && !response_content.empty?
   else
     LOG.warn "[Cron] Job #{job[:id]} produced no response"
   end

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

@@ -4,6 +4,31 @@
 #
 # All git-related utilities live here. Handlers call these instead of
 # reimplementing git worktree/branch logic.
+#
+# NOTE: Methods that need to be accessible from Sinatra route handlers
+# are wrapped in GitHelpers module and registered with Sinatra.
+
+# Module containing git helpers that need to be accessible from Sinatra routes.
+# These are registered as Sinatra helpers in receiver.rb so plugins can call them.
+module GitHelpers
+  def resolve_base_branch(repo_path:, card_number: nil, project_key: nil)
+    results = Brainiac.emit(:resolve_base_branch,
+                            repo_path: repo_path, card_number: card_number, project_key: project_key)
+    custom = results.compact.first
+    if custom
+      LOG.info "Using custom base branch '#{custom}' (from plugin hook)"
+      custom
+    else
+      "origin/#{get_default_branch(repo_path)}"
+    end
+  end
+
+  def resolve_pr_target(repo_path:, card_number: nil, project_key: nil)
+    results = Brainiac.emit(:resolve_pr_target,
+                            repo_path: repo_path, card_number: card_number, project_key: project_key)
+    results.compact.first
+  end
+end
 
 # Debounced repo git fetch — avoids fetching the same repo multiple times within a short window.
 REPO_LAST_FETCH = {}
@@ -106,6 +131,40 @@ def run_project_hook(repo_path, hook_name, extra_env: {})
   end
 end
 
+# Resolve the base branch for a new worktree.
+# Emits :resolve_base_branch hook — plugins can override the default (origin/main).
+# Returns a ref string (e.g., "origin/main", "epic/my-feature").
+#
+# @param repo_path [String] Path to the git repo
+# @param card_number [Integer, String, nil] Fizzy card number (if applicable)
+# @param project_key [String, nil] Brainiac project key
+# @return [String] Base ref for the worktree
+def resolve_base_branch(repo_path:, card_number: nil, project_key: nil)
+  results = Brainiac.emit(:resolve_base_branch,
+                          repo_path: repo_path, card_number: card_number, project_key: project_key)
+  # First non-nil result wins (plugins return a branch name or nil to skip)
+  custom = results.compact.first
+  if custom
+    LOG.info "Using custom base branch '#{custom}' (from plugin hook)"
+    custom
+  else
+    "origin/#{get_default_branch(repo_path)}"
+  end
+end
+
+# Resolve the PR target branch for a card.
+# Emits :resolve_pr_target hook — plugins can override the default branch.
+#
+# @param repo_path [String] Path to the git repo
+# @param card_number [Integer, String, nil] Fizzy card number
+# @param project_key [String, nil] Brainiac project key
+# @return [String, nil] Target branch name (without origin/ prefix), or nil for default
+def resolve_pr_target(repo_path:, card_number: nil, project_key: nil)
+  results = Brainiac.emit(:resolve_pr_target,
+                          repo_path: repo_path, card_number: card_number, project_key: project_key)
+  results.compact.first
+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)

data/lib/brainiac/helpers.rb

@@ -492,7 +492,11 @@ end
 def intent_skip?(message, agent_name:, source: nil, channel: nil, context: nil)
   return false unless message && agent_name && intent_config["enabled"]
 
+  # Some channels always require a response (e.g. PR comments are inherently directed at the agent).
+  bypass_channels = intent_config["bypass_channels"] || %w[github]
   intent_channel = channel || source&.to_s || "conversation"
+  return false if bypass_channels.any? { |bc| intent_channel.to_s.downcase.include?(bc) }
+
   unless check_intent(message, agent_name: agent_name, channel: intent_channel, context: context)
     LOG.info "[Intent] Skipping dispatch for #{agent_name} — message classified as not requiring response"
     return true
@@ -503,7 +507,7 @@ end
 
 def run_agent(prompt, project_config:, chdir: nil, log_name: "agent", model: nil, effort: nil, agent_name: nil, card_number: nil, comment_id: nil,
               source: nil, source_context: {}, skip_column_move: false, cli_provider: nil, resume: false,
-              message: nil, channel: nil, context: nil)
+              message: nil, channel: nil, context: nil, env: {})
   # Intent gate: if a raw message is provided, check whether the agent should respond.
   return nil if intent_skip?(message, agent_name: agent_name, source: source, channel: channel, context: context)
 
@@ -527,7 +531,7 @@ def run_agent(prompt, project_config:, chdir: nil, log_name: "agent", model: nil
   cmd = build_agent_cmd(resolved, agent_config_name: agent_config_name, model: model, effort: effort, prompt_file: prompt_file, resume: should_resume)
   prompt_mode = resolved["prompt_mode"] || "stdin"
 
-  spawn_env = agent_env_for(agent_name)
+  spawn_env = agent_env_for(agent_name).merge(env)
 
   LOG.info "Running #{resolved["agent_cli"]} in #{chdir}, logging to #{log_file}"
   LOG.info "Prompt written to #{prompt_file}"
@@ -585,7 +589,7 @@ def build_agent_cmd(resolved, agent_config_name: nil, model: nil, effort: nil, p
   # "auto" means "let the CLI choose" — skip passing it unless the provider explicitly maps it.
   if model && resolved["agent_model_flag"] && !resolved["agent_model_flag"].empty?
     allowed = resolved["allowed_models"] || {}
-    # Pass the model if it's a mapped value (e.g. "claude-opus-4.6") or the key itself is mapped
+    # Pass the model if it's a mapped value (e.g. "claude-opus-4.5") or the key itself is mapped
     is_known = allowed.value?(model) || allowed.key?(model)
     cmd.push(resolved["agent_model_flag"], model) if is_known
   end

data/lib/brainiac/hooks.rb

@@ -17,6 +17,8 @@
 #   :build_brain_context — When building brain context (plugins add source-specific queries)
 #   :pre_dispatch       — Before dispatching an agent (plugins can inject config)
 #   :post_comment       — After an agent posts a comment/response
+#   :resolve_base_branch — Resolve custom base branch for worktree creation
+#   :resolve_pr_target   — Resolve custom PR target branch (instead of default branch)
 #
 # Usage (in plugin .register):
 #   Brainiac.on(:agent_completed) do |ctx|

data/lib/brainiac/version.rb

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

data/monitor/shared.rb

@@ -205,7 +205,17 @@ def deploy_bash_script(env_key, worktree:, aws_profile: nil)
     fi
     rm -f "$logfile"
     echo
-    if [ $status -eq 0 ]; then echo "✅ Deploy complete"; else echo "❌ Deploy failed (exit $status)"; fi
+    if [ $status -eq 0 ]; then
+      echo "✅ Deploy complete"
+      curl -s -X POST http://localhost:4567/api/deployments/#{env_key.shellescape} \
+        -H "Content-Type: application/json" \
+        -d '{"worktree": #{worktree.to_json}, "deployed_by": "waybar"}' > /dev/null 2>&1
+    else
+      echo "❌ Deploy failed (exit $status)"
+      curl -s -X POST http://localhost:4567/api/deployments/#{env_key.shellescape}/failed \
+        -H "Content-Type: application/json" \
+        -d '{}' > /dev/null 2>&1
+    fi
     echo "Press Enter to close..."
     read
   BASH

data/monitor/xbar/deploy_env.rb

@@ -111,7 +111,17 @@ deploy_script = <<~BASH
   fi
   rm -f "$logfile"
   echo
-  if [ $status -eq 0 ]; then echo "✅ Deploy complete"; else echo "❌ Deploy failed (exit $status)"; fi
+  if [ $status -eq 0 ]; then
+    echo "✅ Deploy complete"
+    curl -s -X POST http://localhost:4567/api/deployments/#{Shellwords.escape(env_key)} \
+      -H "Content-Type: application/json" \
+      -d '{"worktree": #{worktree.to_json}, "deployed_by": "waybar"}' > /dev/null 2>&1
+  else
+    echo "❌ Deploy failed (exit $status)"
+    curl -s -X POST http://localhost:4567/api/deployments/#{Shellwords.escape(env_key)}/failed \
+      -H "Content-Type: application/json" \
+      -d '{}' > /dev/null 2>&1
+  fi
   echo
   echo "Press any key to close..."
   read -n 1

data/receiver.rb

@@ -114,8 +114,13 @@ else
   LOG.info "[Intent] Disabled (enable in brainiac.json → intent.enabled: true)"
 end
 
-# --- Dashboard authentication ---
+# --- Sinatra helpers ---
 
+# Register GitHelpers so plugins can call resolve_pr_target, resolve_base_branch
+# from within Sinatra route handlers
+helpers GitHelpers
+
+# Dashboard authentication helpers
 helpers do
   def authenticate_dashboard!
     return unless DASHBOARD_TOKEN # No token configured = no auth (local-only mode)

data/templates/cli-providers/kiro.json.example

@@ -7,7 +7,7 @@
   "prompt_mode": "stdin",
   "resume_flag": "--resume",
   "models": {
-    "opus": "claude-opus-4.6",
+    "opus": "claude-opus-4.5",
     "sonnet": "claude-sonnet-4.6",
     "haiku": "claude-haiku-4.5",
     "deepseek": "deepseek-3.2",

metadata

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