brainiac 0.0.6 → 0.0.8

data/lib/brainiac/planning.rb

@@ -1,237 +0,0 @@
-# frozen_string_literal: true
-
-# Planning mode: interactive requirement gathering and task breakdown.
-#
-# Triggered by [plan] tag in Discord or 'plan' tag in Fizzy cards.
-# Agent asks clarifying questions, logs Q&A to memory, generates a plan
-# markdown file, and creates Fizzy steps for each task.
-
-PLANS_DIR = File.join(BRAINIAC_DIR, "plans")
-FileUtils.mkdir_p(PLANS_DIR)
-
-# Detect if a message/card should trigger planning mode.
-# Returns: { mode: :planning, card_id: '...', card_number: 123 } or nil
-def detect_planning_mode(text:, tags: [], card_internal_id: nil, card_number: nil)
-  # Discord: [plan] anywhere in message
-  # Fizzy: 'plan' tag on card
-  has_plan_tag = text.match?(/\[plan\]/i) || tags.any? { |t| (t.is_a?(Hash) ? t["name"] : t).to_s.downcase == "plan" }
-  return nil unless has_plan_tag
-
-  {
-    mode: :planning,
-    card_id: card_internal_id || "discord-#{Time.now.to_i}",
-    card_number: card_number
-  }
-end
-
-# Check if planning is complete for a given card.
-# Planning is complete when:
-# 1. A plan file exists at PLANS_DIR/card-{id}-plan.md
-# 2. Memory file indicates planning_complete: true
-def planning_complete?(card_id, agent_name)
-  memory_file = File.join(memory_dir_for(agent_name), "card-#{card_id}.md")
-  return false unless File.exist?(memory_file)
-
-  memory_content = File.read(memory_file)
-  memory_content.match?(/planning_complete:\s*true/i)
-end
-
-# Generate plan markdown from memory Q&A and create Fizzy steps.
-# This is called when the agent determines it has enough information.
-def finalize_plan(card_id:, card_number:, agent_name:, project_key:, repo_path:)
-  memory_file = File.join(memory_dir_for(agent_name), "card-#{card_id}.md")
-  unless File.exist?(memory_file)
-    LOG.error "[Planning] Cannot finalize plan — no memory file found for card #{card_id}"
-    return { success: false, error: "No memory file found" }
-  end
-
-  memory_content = File.read(memory_file)
-
-  # Extract Q&A from memory (agents should format it consistently)
-  # Expected format in memory:
-  # ## Planning Q&A
-  # Q: What's the goal?
-  # A: Build a feature that does X
-  # Q: Should it support Y?
-  # A: Yes, and also Z
-
-  plan_file = File.join(PLANS_DIR, "card-#{card_id}-plan.md")
-
-  # The agent should have already written the plan to the file during its session.
-  # This function just validates it exists and creates Fizzy steps.
-  unless File.exist?(plan_file)
-    LOG.error "[Planning] Plan file not found at #{plan_file}"
-    return { success: false, error: "Plan file not generated by agent" }
-  end
-
-  plan_content = File.read(plan_file)
-
-  # Parse tasks from plan markdown.
-  # Expected format:
-  # ## Task Breakdown
-  # ### Task 1: Title
-  # ### Task 2: Title
-  tasks = []
-  plan_content.scan(/^###\s+Task\s+\d+:\s+(.+)$/i) do |match|
-    tasks << match[0].strip
-  end
-
-  if tasks.empty?
-    LOG.warn "[Planning] No tasks found in plan file #{plan_file}"
-    return { success: false, error: "No tasks found in plan" }
-  end
-
-  # Create Fizzy steps for each task
-  if card_number
-    LOG.info "[Planning] Creating #{tasks.size} Fizzy steps for card ##{card_number}"
-    tasks.each do |task_title|
-      run_cmd("fizzy", "step", "create", "--card", card_number.to_s, "--content", task_title,
-              chdir: repo_path, env: fizzy_env_for(agent_name))
-      LOG.info "[Planning] Created step: #{task_title}"
-    rescue StandardError => e
-      LOG.error "[Planning] Failed to create step '#{task_title}': #{e.message}"
-    end
-  end
-
-  # Mark planning as complete in memory
-  updated_memory = memory_content.sub(/planning_complete:\s*false/i, "planning_complete: true")
-  updated_memory += "\n\nplanning_complete: true\n" unless updated_memory.include?("planning_complete: true")
-  File.write(memory_file, updated_memory)
-
-  LOG.info "[Planning] Plan finalized for card #{card_id}: #{plan_file}"
-  { success: true, plan_file: plan_file, tasks: tasks }
-end
-
-# Planning mode prompt — prepended to the core prompt.
-PROMPT_PLANNING_MODE = <<~PROMPT
-  ## Planning Mode (ACTIVE)
-
-  You are in **planning mode**. Your job is to gather requirements and break down the work into actionable tasks.
-
-  ### Your Role
-  - Ask clarifying questions to understand the problem, constraints, and desired outcome
-  - Continue asking until you have a clear picture (don't rush to a plan)
-  - Understand user intent naturally — "go ahead", "that's enough", "proceed" all mean the same thing
-  - When you have enough information OR the user signals they're ready, generate the plan
-
-  ### Question Guidelines
-  - Ask specific, focused questions (not generic "anything else?")
-  - Build on previous answers — reference what you've learned
-  - Prioritize questions that would significantly change the approach
-  - If you're 90% confident, proceed. If you're 60% confident, ask.
-
-  ### When to Stop Asking
-  The user will signal they're ready in natural language:
-  - "go ahead", "proceed", "that's enough", "looks good", "yeah do it"
-  - "I think you have enough", "start working", "make the plan"
-
-  You should also stop if:
-  - You've asked 5+ questions and have a clear understanding
-  - The user is getting impatient or frustrated
-  - The remaining unknowns are minor details you can decide yourself
-
-  ### Generating the Plan
-  When ready, create a plan file at `{{PLAN_FILE}}` with this structure:
-
-  ```markdown
-  # Feature: [Title]
-
-  ## Problem Statement
-  [What we're solving and why]
-
-  ## Requirements
-  - Requirement 1
-  - Requirement 2
-  - Requirement 3
-
-  ## Approach
-  [High-level strategy and key decisions]
-
-  ## Task Breakdown
-  ### Task 1: [Clear, actionable title]
-  - **Objective**: [What this task accomplishes]
-  - **Approach**: [How to implement it]
-  - **Demo**: [What "done" looks like]
-
-  ### Task 2: [Clear, actionable title]
-  - **Objective**: [What this task accomplishes]
-  - **Approach**: [How to implement it]
-  - **Demo**: [What "done" looks like]
-
-  [Continue for all tasks...]
-  ```
-
-  ### Memory Management
-  Log every question and answer to your memory file in this format:
-
-  ```
-  ## Planning Q&A
-  Q: [Your question]
-  A: [User's answer]
-
-  Q: [Next question]
-  A: [User's answer]
-  ```
-
-  Also track:
-  - `planning_complete: false` (update to `true` when plan is generated)
-  - Key decisions and constraints discovered
-  - Any blockers or unknowns that remain
-
-  ### After Planning
-  Once you've written the plan file:
-  1. Update memory with `planning_complete: true`
-  2. Post a comment summarizing the plan and linking to the file
-  3. The system will automatically create Fizzy steps from your task breakdown
-
-  ### Important
-  - You are READ-ONLY during planning — no code changes, no commits
-  - Focus on understanding the problem, not solving it yet
-  - The plan should be detailed enough that any agent could execute it
-  - Task titles should be clear and actionable (they become Fizzy step names)
-
-PROMPT
-
-# Render planning mode prompt with appropriate channel rules.
-def render_planning_prompt(situation_template, vars = {}, brain_context: "", card_context: "", agent_name: AI_AGENT_NAME, channel: :fizzy,
-                           board_key: nil)
-  result = ""
-  result += "#{brain_context}\n" unless brain_context.empty?
-  result += card_context unless card_context.empty?
-  result += PROMPT_CORE
-
-  # Add planning mode instructions BEFORE channel rules
-  plan_file = File.join(PLANS_DIR, "card-#{vars["CARD_ID"]}-plan.md")
-  planning_vars = vars.merge("PLAN_FILE" => plan_file)
-  result += PROMPT_PLANNING_MODE.gsub("{{PLAN_FILE}}", plan_file)
-
-  result += CHANNEL_PROMPTS.fetch(channel, PROMPT_FIZZY_CHANNEL)
-  result += situation_template
-  result += PROMPT_REFLECTION
-
-  planning_vars["KNOWLEDGE_DIR"] ||= KNOWLEDGE_DIR
-  planning_vars["MEMORY_DIR"] ||= memory_dir_for(agent_name)
-  planning_vars["PERSONA_DIR"] ||= persona_dir_for(agent_name)
-  planning_vars["PERSONA_COLLECTION"] ||= persona_collection_for(agent_name)
-  planning_vars["AGENT_NAME"] ||= agent_name
-
-  # Populate column IDs from board config, falling back to defaults
-  DEFAULT_COLUMN_IDS.each do |col_name, default_id|
-    var_name = "#{col_name.upcase}_COLUMN_ID"
-    planning_vars[var_name] ||= (board_key && board_column_id(board_key, col_name)) || default_id
-  end
-
-  # Touch memory file if CARD_ID is present — ensures file exists before agent tries to read it
-  if vars["CARD_ID"]
-    memory_file = File.join(planning_vars["MEMORY_DIR"], "card-#{vars["CARD_ID"]}.md")
-    FileUtils.mkdir_p(planning_vars["MEMORY_DIR"])
-    FileUtils.touch(memory_file)
-  end
-
-  roster = agent_roster
-  roster_lines = roster.map { |_key, display| "  - @#{display}" }.join("\n")
-  planning_vars["AGENT_ROSTER"] ||= roster_lines
-
-  planning_vars.each { |key, val| result.gsub!("{{#{key}}}", val.to_s) }
-  result
-end

data/lib/user_registry.rb

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

data/monitor/menubar.rb

@@ -1,295 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-# Brainiac macOS Menu Bar Plugin (xbar/SwiftBar)
-# Reads from monitor daemon socket and outputs xbar-format text
-# Mirrors monitor/waybar.rb patterns for macOS-native display
-
-require "json"
-require "net/http"
-require "shellwords"
-require "socket"
-require "time"
-require "uri"
-
-SERVER_URL = "http://localhost:4567"
-SOCKET_PATH = "/tmp/brainiac-monitor.sock"
-CONFIG_PATH = File.expand_path("~/.brainiac/waybar.json")
-DEFAULT_EMOJI = "❓"
-SELF_PATH = File.realpath(__FILE__)
-
-def load_config
-  JSON.parse(File.read(CONFIG_PATH))
-rescue StandardError => e
-  warn "Failed to load waybar.json: #{e.message}"
-  {}
-end
-
-CONFIG = load_config.freeze
-
-def load_agent_config
-  agents = {}
-  (CONFIG["agents"] || []).each do |agent|
-    agents[agent["name"].downcase] = { emoji: agent["emoji"], color: agent["color"] }
-  end
-  agents
-end
-
-AGENTS = load_agent_config.freeze
-FIZZY_ACCOUNT_ID = CONFIG["fizzy_account_id"]
-DISCORD_GUILD_ID = CONFIG["discord_guild_id"]
-
-def fetch_state
-  socket = UNIXSocket.new(SOCKET_PATH)
-  data = socket.read
-  socket.close
-  JSON.parse(data)
-rescue Errno::ENOENT
-  { "sessions" => [], "count" => 0, "recent" => [], "error" => "daemon not running" }
-rescue StandardError => e
-  { "sessions" => [], "count" => 0, "recent" => [], "error" => e.message }
-end
-
-def fetch_deployments
-  uri = URI("#{SERVER_URL}/api/deployments")
-  response = Net::HTTP.get_response(uri)
-  JSON.parse(response.body)["deployments"] || []
-rescue StandardError
-  nil
-end
-
-DEPLOY_RECENT_WINDOW = 30 * 60
-
-def deploy_dot(dep)
-  status = dep["last_deploy_status"]
-  if status == "deploying"
-    "🟠"
-  elsif status == "failed"
-    "💥"
-  elsif dep["status"] == "occupied"
-    deploy_time = dep["last_deploy_at"] || dep["deployed_at"]
-    recent = deploy_time && (Time.now - Time.parse(deploy_time)) < DEPLOY_RECENT_WINDOW
-    recent ? "🚀" : "🔴"
-  else
-    "🟢"
-  end
-end
-
-LOG_VIEWER_PATH = File.join(File.dirname(SELF_PATH), "view-logs-macos.rb")
-DEPLOY_SCRIPT_PATH = File.join(File.dirname(SELF_PATH), "deploy-env-macos.rb")
-
-ANSI_REGEX = /\e\[[0-9;]*[a-zA-Z]|\e\[\?[0-9;]*[a-zA-Z]/
-LOG_PREVIEW_LINES = 15
-LOG_LINE_MAX = 80
-LOG_FONT = "SFMono-Regular"
-LOG_SIZE = 12
-
-def tail_log(log_file, lines: LOG_PREVIEW_LINES)
-  return [] unless log_file && File.exist?(log_file)
-
-  raw = `tail -n 50 #{log_file.shellescape} 2>/dev/null`
-  raw.encode("UTF-8", invalid: :replace, undef: :replace, replace: "")
-     .lines
-     .map { |l| l.gsub(ANSI_REGEX, "").gsub(/[^[:print:]\t]/, "").strip }
-     .reject(&:empty?)
-     .last(lines)
-rescue StandardError
-  []
-end
-
-def format_log_line(text)
-  text.length > LOG_LINE_MAX ? "#{text[0, LOG_LINE_MAX]}…" : text
-end
-
-def format_elapsed(seconds)
-  return "#{seconds}s" if seconds < 60
-
-  minutes = seconds / 60
-  return "#{minutes}m" if minutes < 60
-
-  "#{minutes / 60}h"
-end
-
-def format_context(card_key)
-  return "" unless card_key
-
-  if card_key.start_with?("discord-")
-    "Discord"
-  elsif card_key.start_with?("card-")
-    "##{card_key.split("-")[1]}"
-  else
-    card_key
-  end
-end
-
-def time_ago(iso_string)
-  return nil unless iso_string
-
-  seconds = (Time.now - Time.parse(iso_string)).to_i
-  "#{format_elapsed(seconds)} ago"
-rescue StandardError
-  nil
-end
-
-def log_action(log_file)
-  return "" unless log_file
-
-  " | shell=#{LOG_VIEWER_PATH} param1=#{log_file} terminal=false refresh=false"
-end
-
-OPEN_SCRIPT = File.join(File.dirname(SELF_PATH), "open-action.sh")
-
-def full_log_action(log_file)
-  return "" unless log_file
-
-  " | shell=#{OPEN_SCRIPT} param1=#{log_file.shellescape} terminal=false refresh=false"
-end
-
-def prompt_url(card_key)
-  return nil unless card_key
-
-  if card_key.start_with?("card-")
-    card_num = card_key.split("-")[1]
-    "https://app.fizzy.do/#{FIZZY_ACCOUNT_ID}/cards/#{card_num}" if FIZZY_ACCOUNT_ID && card_num
-  elsif card_key.start_with?("discord-") && DISCORD_GUILD_ID
-    parts = card_key.split("-")
-    # discord-AGENT-CHANNEL_ID-MESSAGE_ID (agent name may contain hyphens, IDs are last two numeric parts)
-    channel_id = parts[-2]
-    message_id = parts[-1]
-    "https://discord.com/channels/#{DISCORD_GUILD_ID}/#{channel_id}/#{message_id}" if channel_id && message_id
-  end
-end
-
-def prompt_action(card_key)
-  url = prompt_url(card_key)
-  return "" unless url
-
-  " | shell=#{OPEN_SCRIPT} param1=#{url} terminal=false refresh=false"
-end
-
-def worktree_path(log_file, card_key)
-  return nil unless log_file && card_key&.start_with?("card-")
-
-  dir = File.dirname(log_file, 2)
-  dir if File.directory?(dir) && dir != "/"
-end
-
-def worktree_action(log_file, card_key)
-  path = worktree_path(log_file, card_key)
-  return "" unless path
-
-  " | shell=#{OPEN_SCRIPT} param1=#{path.shellescape} terminal=false refresh=false"
-end
-
-COLOR_MAP = {
-  "red" => "#ff5555", "green" => "#50fa7b", "blue" => "#8be9fd",
-  "yellow" => "#f1fa8c", "cyan" => "#8be9fd", "magenta" => "#ff79c6",
-  "purple" => "#bd93f9", "pink" => "#ff79c6", "white" => "#f8f8f2"
-}.freeze
-
-def hex_color(name)
-  COLOR_MAP[name] || name
-end
-
-def generate_output
-  state = fetch_state
-  deployments = fetch_deployments
-
-  return ["⚠️", "---", state["error"], "---", "Refresh | refresh=true"].join("\n") if state["error"] && !deployments
-
-  sessions = state["sessions"] || []
-  recent = state["recent"] || []
-  lines = []
-
-  # Title line — agent emojis + deploy dots
-  parts = []
-  parts << sessions.map { |s| AGENTS.dig(s["agent"]&.downcase, :emoji) || DEFAULT_EMOJI }.join(" ") if sessions.any?
-  parts << deployments.map { |d| deploy_dot(d) }.join if deployments&.any?
-  title = parts.any? ? parts.join(" ") : "💤"
-  lines << title
-  lines << "---"
-
-  # Active sessions
-  if sessions.any?
-    lines << "Active | size=12"
-    sessions.each do |s|
-      agent_key = (s["agent"] || "").downcase
-      emoji = AGENTS.dig(agent_key, :emoji) || DEFAULT_EMOJI
-      color = AGENTS.dig(agent_key, :color)
-      color_str = color ? " color=#{hex_color(color)}" : ""
-      context = format_context(s["card_key"])
-      elapsed = format_elapsed(s["elapsed_seconds"] || 0)
-      lines << "#{emoji} #{s["agent"]}: #{context} (#{elapsed}) |#{color_str}"
-
-      tail_log(s["log_file"]).each do |line|
-        lines << "-- #{format_log_line(line)} | font=#{LOG_FONT} size=#{LOG_SIZE}"
-      end
-      lines << "-- ---" if s["log_file"]
-      lines << "-- Tail Log#{log_action(s["log_file"])}" if s["log_file"]
-      lines << "-- View Full Log#{full_log_action(s["log_file"])}" if s["log_file"]
-      lines << "-- Open Prompt#{prompt_action(s["card_key"])}" unless prompt_url(s["card_key"]).nil?
-      wt = worktree_path(s["log_file"], s["card_key"])
-      lines << "-- Open Worktree#{worktree_action(s["log_file"], s["card_key"])}" if wt
-    end
-  else
-    lines << "No active sessions | size=12"
-  end
-
-  # Recent completed sessions
-  if recent.any?
-    lines << "---"
-    lines << "Recent | size=12"
-    recent.each do |s|
-      agent_key = (s["agent"] || "").downcase
-      emoji = AGENTS.dig(agent_key, :emoji) || DEFAULT_EMOJI
-      context = format_context(s["card_key"])
-      ago = time_ago(s["finished_at"]) || "?"
-      lines << "#{emoji} #{s["agent"]}: #{context} — #{ago}"
-
-      tail_log(s["log_file"]).each do |line|
-        lines << "-- #{format_log_line(line)} | font=#{LOG_FONT} size=#{LOG_SIZE}"
-      end
-      lines << "-- ---" if s["log_file"]
-      lines << "-- Tail Log#{log_action(s["log_file"])}" if s["log_file"]
-      lines << "-- View Full Log#{full_log_action(s["log_file"])}" if s["log_file"]
-      lines << "-- Open Prompt#{prompt_action(s["card_key"])}" unless prompt_url(s["card_key"]).nil?
-      wt = worktree_path(s["log_file"], s["card_key"])
-      lines << "-- Open Worktree#{worktree_action(s["log_file"], s["card_key"])}" if wt
-    end
-  end
-
-  # Deployments
-  if deployments&.any?
-    lines << "---"
-    lines << "Deployments | size=12"
-    deployments.each do |d|
-      label = d["label"] || d["env"]
-      env = d["env"]
-      dot = deploy_dot(d)
-      if d["status"] == "occupied"
-        card = d["card_number"] ? "##{d["card_number"]}" : d["branch"] || "unknown"
-        ago = time_ago(d["deployed_at"])
-        status_label = case d["last_deploy_status"]
-                       when "deploying" then " — deploying…"
-                       when "failed" then " — FAILED"
-                       else ""
-                       end
-        line = "#{dot} #{label}: #{card}#{status_label}#{" (#{ago})" if ago}"
-        url = d["url"]
-        lines << (url ? "#{line} | href=#{url}" : line)
-      else
-        ago = time_ago(d["cleared_at"])
-        last = d["last_card"] ? " (was ##{d["last_card"]})" : ""
-        lines << "#{dot} #{label}: Available#{" #{ago}" if ago}#{last}"
-      end
-      lines << "-- Deploy to #{label} | shell=#{DEPLOY_SCRIPT_PATH} param1=#{env} terminal=false refresh=true"
-      lines << "-- Open #{label} | shell=#{OPEN_SCRIPT} param1=#{d["url"]} terminal=false refresh=false" if d["status"] == "occupied" && d["url"]
-    end
-  end
-
-  lines << "---"
-  lines << "Refresh | refresh=true"
-  lines.join("\n")
-end
-
-puts generate_output