jirametrics 2.27 → 2.28

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c87212eebf4e22145b8e66741174658bffc3cb1e47bd45bfe3f7590586a42200
-  data.tar.gz: 00fb6c4375e7e6858359fa754af42c697028198dedd2ae8100c98d0564f59db8
+  metadata.gz: d93d43ce61e0fcec89c5ee737044cff4007b1f0079be2c6be774c56cb15130e8
+  data.tar.gz: ffbe1b15fc8aa08f928e7c322cf53dc5a1646b9da01b7b9e81e8b5bd2c44650d
 SHA512:
-  metadata.gz: aad3747a78dcf530df02244720c676632816a30688045d95c9a701ba946a5573f81a2e3955c5035e745fb197f5c6cff58491a63d35db68b3abf35817c78dc0b8
-  data.tar.gz: fcf17a8c2a4c91e4de45ff15150d1de9147c890d9e80354b490bec2b27fb17ef2b20e7bc6073c503e88fd0ad188c414002d8312500b22dd5207b043d3c253be7
+  metadata.gz: 66d0c9c0db9b11c4278935a8342cae5f9b6b4e34fffc46d1bad6b719b6ca779374191f05f4139caf28995e8014ab77cfea79945df9abe546405abf9e381e4311
+  data.tar.gz: 3f10707f9b44c14dd8dae67ce73cd208cb7554cee147d502f3b99315b49cb524aa6f12662c1624720f204e814a5686e37393f907da8ec43f1befc88398a79cc7

data/bin/jirametrics-mcp

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'jirametrics'
+JiraMetrics.start(['mcp'] + ARGV)

data/lib/jirametrics/cumulative_flow_diagram.rb

@@ -70,7 +70,7 @@ class CumulativeFlowDiagram < ChartBase
         CT and TP cannot be calculated and are hidden; only WIP is shown.
       </div>
       <div class="p">
-        See also: This article on [how to read a CFD](https://blog.mikebowler.ca/2026/03/27/cumulative-flow-diagram/).
+        See also: This article on <a href="https://blog.mikebowler.ca/2026/03/27/cumulative-flow-diagram/">how to read a CFD</a>.
       </div>      
     HTML
     instance_eval(&block)

data/lib/jirametrics/daily_view.rb

@@ -87,13 +87,14 @@ class DailyView < ChartBase
       lines << ["#{marker} Blocked by flag"] if blocked_stalled.flag
       lines << ["#{marker} Blocked by status: #{blocked_stalled.status}"] if blocked_stalled.blocked_by_status?
       blocked_stalled.blocking_issue_keys&.each do |key|
-        blocking_issue = issues.find { |i| i.key == key }
+        blocking_issue = issues.find_by_key key: key, include_hidden: true
         if blocking_issue
-          lines << "<section><div class=\"foldable startFolded\">#{marker} Blocked by issue: #{key}</div>"
+          lines << "<section><div class=\"foldable startFolded\">#{marker} Blocked by issue: " \
+            "#{make_issue_label issue: blocking_issue, done: blocking_issue.done?}</div>"
           lines << blocking_issue
           lines << '</section>'
         else
-          lines << ["#{marker} Blocked by issue: #{key}"]
+          lines << ["#{marker} Blocked by issue: #{key} (no description found)"]
         end
       end
     elsif blocked_stalled.stalled_by_status?

data/lib/jirametrics/downloader_for_cloud.rb

@@ -108,11 +108,24 @@ class DownloaderForCloud < Downloader
       }
       issue = Issue.new(raw: issue_json, board: board)
       data = issue_datas.find { |d| d.key == issue.key }
+      unless data
+        log "  Skipping #{issue.key}: returned by Jira but key not in request (issue may have been moved)"
+        next
+      end
       data.up_to_date = true
       data.last_modified = issue.updated
       data.issue = issue
     end
 
+    # Mark any unmatched requests as up_to_date to prevent infinite re-fetching.
+    # This happens when Jira returns a different key (moved issue) leaving the original unmatched.
+    issue_datas.each do |data|
+      next if data.up_to_date
+
+      log "  Skipping #{data.key}: not returned by Jira (issue may have been deleted or moved)"
+      data.up_to_date = true
+    end
+
     issue_datas
   end
 
@@ -168,15 +181,20 @@ class DownloaderForCloud < Downloader
 
     issue_data_hash = search_for_issues jql: jql, board_id: board.id, path: path
 
+    checked_for_related = Set.new
+    in_related_phase = false
+
     loop do
       related_issue_keys = Set.new
       stale = issue_data_hash.values.reject { |data| data.up_to_date }
       unless stale.empty?
-        log_start '  Downloading more issues '
+        log_start '  Downloading more issues ' unless in_related_phase
         stale.each_slice(100) do |slice|
           slice = bulk_fetch_issues(issue_datas: slice, board: board, in_initial_query: true)
           progress_dot
           slice.each do |data|
+            next unless data.issue
+
             @file_system.save_json(
               json: data.issue.raw, filename: data.cache_path
             )
@@ -184,22 +202,25 @@ class DownloaderForCloud < Downloader
             # to parse the file just to find the timestamp
             @file_system.utime time: data.issue.updated, file: data.cache_path
 
-            issue = data.issue
-            next unless issue
-
-            parent_key = issue.parent_key(project_config: @download_config.project_config)
-            related_issue_keys << parent_key if parent_key
-
-            # Sub-tasks
-            issue.raw['fields']['subtasks']&.each do |raw_subtask|
-              related_issue_keys << raw_subtask['key']
-            end
+            collect_related_issue_keys issue: data.issue, related_issue_keys: related_issue_keys
+            checked_for_related << data.key
           end
         end
-        end_progress
+        end_progress unless in_related_phase
       end
 
-      # Remove all the ones we already downloaded
+      # Also scan up-to-date cached issues we haven't checked yet — they may reference
+      # related issues that are not in the primary query result.
+      issue_data_hash.each_value do |data|
+        next if checked_for_related.include?(data.key)
+        next unless @file_system.file_exist?(data.cache_path)
+
+        checked_for_related << data.key
+        raw = @file_system.load_json(data.cache_path)
+        collect_related_issue_keys issue: Issue.new(raw: raw, board: board), related_issue_keys: related_issue_keys
+      end
+
+      # Remove all the ones we already have
       related_issue_keys.reject! { |key| issue_data_hash[key] }
 
       related_issue_keys.each do |key|
@@ -211,9 +232,15 @@ class DownloaderForCloud < Downloader
       end
       break if related_issue_keys.empty?
 
-      log "  Downloading linked issues for board #{board.id}", both: true
+      unless in_related_phase
+        in_related_phase = true
+        log "  Identifying related issues (parents, subtasks, links) for board #{board.id}", both: true
+        log_start '  Downloading more issues '
+      end
     end
 
+    end_progress if in_related_phase
+
     delete_issues_from_cache_that_are_not_in_server(
       issue_data_hash: issue_data_hash, path: path
     )
@@ -238,6 +265,22 @@ class DownloaderForCloud < Downloader
     end
   end
 
+  def collect_related_issue_keys issue:, related_issue_keys:
+    parent_key = issue.parent_key(project_config: @download_config.project_config)
+    related_issue_keys << parent_key if parent_key
+
+    issue.raw['fields']['subtasks']&.each do |raw_subtask|
+      related_issue_keys << raw_subtask['key']
+    end
+
+    issue.raw['fields']['issuelinks']&.each do |link|
+      next if link['type']['name'] == 'Cloners'
+
+      linked = link['inwardIssue'] || link['outwardIssue']
+      related_issue_keys << linked['key'] if linked
+    end
+  end
+
   def last_modified filename:
     File.mtime(filename) if File.exist?(filename)
   end

data/lib/jirametrics/html/index.js

@@ -35,7 +35,7 @@ function makeFoldable() {
     const toggleButton = document.createElement(element.tagName); //'button');
     toggleButton.id = toggleId;
     toggleButton.className = 'foldable-toggle-btn';
-    toggleButton.innerHTML = '▼ ' + element.textContent;
+    toggleButton.innerHTML = '▼ ' + element.innerHTML;
     
     // Create a content container
     const contentContainer = document.createElement('div');

data/lib/jirametrics/issue.rb

@@ -210,7 +210,25 @@ class Issue
   end
 
   def first_time_visible_on_board
-    first_time_in_status(*board.visible_columns.collect(&:status_ids).flatten)
+    visible_status_ids = board.visible_columns.collect(&:status_ids).flatten
+    return first_time_in_status(*visible_status_ids) unless board.scrum?
+
+    # For scrum boards, an issue is only visible when BOTH conditions are true simultaneously:
+    # 1. Its status is in a visible column
+    # 2. It is in an active sprint
+    # At each moment one condition becomes true, check if the other is already true.
+    candidates = []
+
+    status_changes.each do |change|
+      next unless visible_status_ids.include?(change.value_id)
+      candidates << change if in_active_sprint_at?(change.time)
+    end
+
+    sprint_entry_events.each do |effective_time, representative_change|
+      candidates << representative_change if in_visible_status_at?(effective_time, visible_status_ids)
+    end
+
+    candidates.min_by(&:time)
   end
 
   def reasons_not_visible_on_board
@@ -815,6 +833,72 @@ class Issue
 
   private
 
+  # Returns [[effective_time, change_item]] for each moment the issue entered an active sprint.
+  # Skips sprints that were removed before they activated.
+  def sprint_entry_events
+    data_clazz = Struct.new(:sprint_id, :sprint_start, :add_time, :change)
+    events = []
+    in_sprint = []
+
+    @changes.each do |change|
+      next unless change.sprint?
+
+      (change.value_id - change.old_value_id).each do |sprint_id|
+        sprint_start, = find_sprint_start_end(sprint_id: sprint_id, change: change)
+        in_sprint << data_clazz.new(sprint_id, sprint_start, change.time, change) if sprint_start
+      end
+
+      (change.old_value_id - change.value_id).each do |sprint_id|
+        data = in_sprint.find { |d| d.sprint_id == sprint_id }
+        next unless data
+
+        in_sprint.delete(data)
+        next if data.sprint_start >= change.time # sprint hadn't activated before removal
+
+        effective_time = [data.add_time, data.sprint_start].max
+        events << [effective_time, sprint_change_at(effective_time, data.change)]
+      end
+    end
+
+    in_sprint.each do |data|
+      effective_time = [data.add_time, data.sprint_start].max
+      events << [effective_time, sprint_change_at(effective_time, data.change)]
+    end
+
+    events
+  end
+
+  def sprint_change_at effective_time, change
+    return change if effective_time == change.time
+
+    ChangeItem.new(
+      raw: { 'field' => 'Sprint', 'toString' => 'Sprint activated', 'to' => '0', 'from' => nil, 'fromString' => nil },
+      author_raw: nil,
+      time: effective_time,
+      artificial: true
+    )
+  end
+
+  def in_active_sprint_at? time
+    active_ids = []
+    @changes.each do |change|
+      break if change.time > time
+      next unless change.sprint?
+
+      (change.value_id - change.old_value_id).each do |sprint_id|
+        sprint_start, = find_sprint_start_end(sprint_id: sprint_id, change: change)
+        active_ids << sprint_id if sprint_start && sprint_start <= time
+      end
+      (change.old_value_id - change.value_id).each { |id| active_ids.delete(id) }
+    end
+    active_ids.any?
+  end
+
+  def in_visible_status_at? time, visible_status_ids
+    last = status_changes.reverse.find { |c| c.time <= time }
+    last && visible_status_ids.include?(last.value_id)
+  end
+
   def load_history_into_changes
     @raw['changelog']['histories']&.each do |history|
       created = parse_time(history['created'])

data/lib/jirametrics/mcp_server.rb

@@ -4,17 +4,27 @@ require 'mcp'
 require 'mcp/server/transports/stdio_transport'
 
 class McpServer
-  def initialize projects:, timezone_offset: '+00:00'
+  def initialize projects:, aggregates: {}, timezone_offset: '+00:00'
     @projects = projects
+    @aggregates = aggregates
     @timezone_offset = timezone_offset
   end
 
   def run
+    canonical_tools = [ListProjectsTool, AgingWorkTool, CompletedWorkTool, NotYetStartedTool, StatusTimeAnalysisTool]
+    alias_tools = ALIASES.map do |alias_name, canonical|
+      schema = canonical.input_schema
+      Class.new(canonical) do
+        tool_name alias_name
+        input_schema schema
+      end
+    end
+
     server = MCP::Server.new(
       name: 'jirametrics',
       version: Gem.loaded_specs['jirametrics']&.version&.to_s || '0.0.0',
-      tools: [AgingWorkTool, CompletedWorkTool, NotYetStartedTool],
-      server_context: { projects: @projects, timezone_offset: @timezone_offset }
+      tools: canonical_tools + alias_tools,
+      server_context: { projects: @projects, aggregates: @aggregates, timezone_offset: @timezone_offset }
     )
 
     transport = MCP::Server::Transports::StdioTransport.new(server)
@@ -51,6 +61,80 @@ class McpServer
     }
   }.freeze
 
+  def self.resolve_projects server_context, project_filter
+    return nil if project_filter.nil?
+
+    aggregates = server_context[:aggregates] || {}
+    aggregates[project_filter] || [project_filter]
+  end
+
+  def self.column_name_for board, status_id
+    board.visible_columns.find { |c| c.status_ids.include?(status_id) }&.name
+  end
+
+  def self.time_per_column issue, end_time
+    changes = issue.status_changes
+    _, stopped = issue.started_stopped_times
+    effective_end = stopped && stopped < end_time ? stopped : end_time
+    board = issue.board
+
+    result = Hash.new(0.0)
+
+    if changes.empty?
+      col = column_name_for(board, issue.status.id) || issue.status.name
+      duration = effective_end - issue.created
+      result[col] += duration if duration.positive?
+      return result
+    end
+
+    first_change = changes.first
+    initial_col = column_name_for(board, first_change.old_value_id) || first_change.old_value
+    initial_duration = first_change.time - issue.created
+    result[initial_col] += initial_duration if initial_duration.positive?
+
+    changes.each_cons(2) do |prev_change, next_change|
+      col = column_name_for(board, prev_change.value_id) || prev_change.value
+      duration = next_change.time - prev_change.time
+      result[col] += duration if duration.positive?
+    end
+
+    last_change = changes.last
+    final_col = column_name_for(board, last_change.value_id) || last_change.value
+    final_duration = effective_end - last_change.time
+    result[final_col] += final_duration if final_duration.positive?
+
+    result
+  end
+
+  def self.time_per_status issue, end_time
+    changes = issue.status_changes
+    _, stopped = issue.started_stopped_times
+    effective_end = stopped && stopped < end_time ? stopped : end_time
+
+    result = Hash.new(0.0)
+
+    if changes.empty?
+      duration = effective_end - issue.created
+      result[issue.status.name] += duration if duration.positive?
+      return result
+    end
+
+    first_change = changes.first
+    initial_duration = first_change.time - issue.created
+    result[first_change.old_value] += initial_duration if initial_duration.positive?
+
+    changes.each_cons(2) do |prev_change, next_change|
+      duration = next_change.time - prev_change.time
+      result[prev_change.value] += duration if duration.positive?
+    end
+
+    last_change = changes.last
+    final_duration = effective_end - last_change.time
+    result[last_change.value] += final_duration if final_duration.positive?
+
+    result
+  end
+
   def self.flow_efficiency_percent issue, end_time
     active_time, total_time = issue.flow_efficiency_numbers(end_time: end_time)
     total_time.positive? ? (active_time / total_time * 100).round(1) : nil
@@ -79,6 +163,31 @@ class McpServer
     true
   end
 
+  class ListProjectsTool < MCP::Tool
+    tool_name 'list_projects'
+    description 'Lists all available projects with basic metadata. Call this first when the user asks a ' \
+                'question that could apply to multiple projects, so you can clarify which one they mean.'
+
+    input_schema(type: 'object', properties: {})
+
+    def self.call(server_context:, **)
+      lines = server_context[:projects].map do |project_name, project_data|
+        "#{project_name} | #{project_data[:issues].size} issues | Data through: #{project_data[:today]}"
+      end
+
+      aggregates = server_context[:aggregates] || {}
+      unless aggregates.empty?
+        lines << ''
+        lines << 'Aggregate groups (can be used as a project filter):'
+        aggregates.each do |name, constituent_names|
+          lines << "#{name} | includes: #{constituent_names.join(', ')}"
+        end
+      end
+
+      MCP::Tool::Response.new([{ type: 'text', text: lines.join("\n") }])
+    end
+  end
+
   class AgingWorkTool < MCP::Tool
     tool_name 'aging_work'
     description 'Returns all issues that have been started but not yet completed (work in progress), ' \
@@ -95,22 +204,35 @@ class McpServer
           type: 'string',
           description: 'Only return issues from this project name. Omit to return all projects.'
         },
+        current_status: {
+          type: 'string',
+          description: 'Only return issues currently in this status (e.g. "Review", "In Progress").'
+        },
+        current_column: {
+          type: 'string',
+          description: 'Only return issues whose current status maps to this board column (e.g. "In Progress").'
+        },
         **HISTORY_FILTER_SCHEMA
       }
     )
 
-    def self.call(server_context:, min_age_days: nil, project: nil,
+    def self.call(server_context:, min_age_days: nil, project: nil, project_name: nil,
+                  current_status: nil, current_column: nil,
                   history_field: nil, history_value: nil, ever_blocked: nil, ever_stalled: nil,
-                  currently_blocked: nil, currently_stalled: nil)
+                  currently_blocked: nil, currently_stalled: nil, **)
+      project ||= project_name
       rows = []
+      allowed_projects = McpServer.resolve_projects(server_context, project)
 
       server_context[:projects].each do |project_name, project_data|
-        next if project && project_name != project
+        next if allowed_projects && !allowed_projects.include?(project_name)
 
         today = project_data[:today]
         project_data[:issues].each do |issue|
           started, stopped = issue.started_stopped_times
           next unless started && !stopped
+          next if current_status && issue.status.name != current_status
+          next if current_column && McpServer.column_name_for(issue.board, issue.status.id) != current_column
 
           age = (today - started.to_date).to_i + 1
           next if min_age_days && age < min_age_days
@@ -203,14 +325,16 @@ class McpServer
       }
     end
 
-    def self.call(server_context:, days_back: nil, project: nil,
+    def self.call(server_context:, days_back: nil, project: nil, project_name: nil,
                   completed_status: nil, completed_resolution: nil,
                   history_field: nil, history_value: nil, ever_blocked: nil, ever_stalled: nil,
-                  currently_blocked: nil, currently_stalled: nil)
+                  currently_blocked: nil, currently_stalled: nil, **)
+      project ||= project_name
       rows = []
+      allowed_projects = McpServer.resolve_projects(server_context, project)
 
       server_context[:projects].each do |project_name, project_data|
-        next if project && project_name != project
+        next if allowed_projects && !allowed_projects.include?(project_name)
 
         today = project_data[:today]
         cutoff = today - days_back if days_back
@@ -256,21 +380,33 @@ class McpServer
           type: 'string',
           description: 'Only return issues from this project name. Omit to return all projects.'
         },
+        current_status: {
+          type: 'string',
+          description: 'Only return issues currently in this status (e.g. "To Do", "Backlog").'
+        },
+        current_column: {
+          type: 'string',
+          description: 'Only return issues whose current status maps to this board column.'
+        },
         **HISTORY_FILTER_SCHEMA
       }
     )
 
-    def self.call(server_context:, project: nil,
+    def self.call(server_context:, project: nil, project_name: nil, current_status: nil, current_column: nil,
                   history_field: nil, history_value: nil, ever_blocked: nil, ever_stalled: nil,
-                  currently_blocked: nil, currently_stalled: nil)
+                  currently_blocked: nil, currently_stalled: nil, **)
+      project ||= project_name
       rows = []
+      allowed_projects = McpServer.resolve_projects(server_context, project)
 
       server_context[:projects].each do |project_name, project_data|
-        next if project && project_name != project
+        next if allowed_projects && !allowed_projects.include?(project_name)
 
         project_data[:issues].each do |issue|
           started, stopped = issue.started_stopped_times
           next if started || stopped
+          next if current_status && issue.status.name != current_status
+          next if current_column && McpServer.column_name_for(issue.board, issue.status.id) != current_column
           unless McpServer.matches_history?(issue, project_data[:end_time],
                                             history_field, history_value, ever_blocked, ever_stalled,
                                             currently_blocked, currently_stalled)
@@ -302,4 +438,94 @@ class McpServer
       MCP::Tool::Response.new([{ type: 'text', text: text }])
     end
   end
+
+  class StatusTimeAnalysisTool < MCP::Tool
+    tool_name 'status_time_analysis'
+    description 'Aggregates the time issues spend in each status or column, ranked by average days. ' \
+                'Useful for identifying bottlenecks. Before calling this tool, always ask the user ' \
+                'which issues they want to include: aging (in progress), completed, not yet started, ' \
+                'or all. Do not assume — the answer changes the result significantly.'
+
+    input_schema(
+      type: 'object',
+      properties: {
+        project: {
+          type: 'string',
+          description: 'Only include issues from this project name. Omit to include all projects.'
+        },
+        issue_state: {
+          type: 'string',
+          enum: %w[all aging completed not_started],
+          description: 'Which issues to include: "aging" (in progress), "completed", ' \
+                       '"not_started" (backlog), or "all" (default).'
+        },
+        group_by: {
+          type: 'string',
+          enum: %w[status column],
+          description: 'Whether to group results by status name (default) or board column.'
+        }
+      }
+    )
+
+    def self.select_issues issue, issue_state
+      started, stopped = issue.started_stopped_times
+      case issue_state
+      when 'aging' then started && !stopped
+      when 'completed' then !!stopped
+      when 'not_started' then !started && !stopped
+      else true
+      end
+    end
+
+    def self.call(server_context:, project: nil, project_name: nil, issue_state: 'all', group_by: 'status',
+                  column: nil, **)
+      project ||= project_name
+      group_by = 'column' if column
+
+      totals = Hash.new { |h, k| h[k] = { total_seconds: 0.0, visit_count: 0 } }
+      allowed_projects = McpServer.resolve_projects(server_context, project)
+
+      server_context[:projects].each do |project_name, project_data|
+        next if allowed_projects && !allowed_projects.include?(project_name)
+
+        project_data[:issues].each do |issue|
+          next unless select_issues(issue, issue_state)
+
+          time_map = if group_by == 'column'
+                       McpServer.time_per_column(issue, project_data[:end_time])
+                     else
+                       McpServer.time_per_status(issue, project_data[:end_time])
+                     end
+
+          time_map.each do |name, seconds|
+            totals[name][:total_seconds] += seconds
+            totals[name][:visit_count] += 1
+          end
+        end
+      end
+
+      return MCP::Tool::Response.new([{ type: 'text', text: 'No data found.' }]) if totals.empty?
+
+      rows = totals.map do |name, data|
+        total_days = (data[:total_seconds] / 86_400.0).round(1)
+        avg_days = (data[:total_seconds] / data[:visit_count] / 86_400.0).round(1)
+        { name: name, total_days: total_days, avg_days: avg_days, visit_count: data[:visit_count] }
+      end
+      rows.sort_by! { |r| -r[:avg_days] }
+
+      label = group_by == 'column' ? 'Column' : 'Status'
+      lines = rows.map do |r|
+        "#{label}: #{r[:name]} | Avg: #{r[:avg_days]}d | Total: #{r[:total_days]}d | Issues: #{r[:visit_count]}"
+      end
+      MCP::Tool::Response.new([{ type: 'text', text: lines.join("\n") }])
+    end
+  end
+
+  # Alternative tool names used by AI agents other than Claude.
+  # Each entry maps an alias name to the canonical tool class it delegates to.
+  # The alias inherits the canonical tool's schema and call behaviour automatically.
+  # To add a new alias, append one line: 'alias_name' => CanonicalToolClass
+  ALIASES = {
+    'board_list' => ListProjectsTool
+  }.freeze
 end

data/lib/jirametrics/project_config.rb

@@ -98,6 +98,12 @@ class ProjectConfig
     !!@aggregate_config
   end
 
+  def aggregate_project_names
+    return [] unless aggregated_project?
+
+    @aggregate_config.included_projects.filter_map(&:name)
+  end
+
   def download &block
     raise 'Not allowed to have multiple download blocks in one project' if @download_config
     raise 'Not allowed to have both an aggregate and a download section. Pick only one.' if @aggregate_config

data/lib/jirametrics.rb

@@ -56,12 +56,19 @@ class JiraMetrics < Thor
   option :name
   desc 'mcp', 'Start in MCP (Model Context Protocol) server mode'
   def mcp
+    # Redirect stdout to stderr for the entire startup phase so that any
+    # incidental output (from config files, gem loading, etc.) does not
+    # corrupt the JSON-RPC channel before the MCP transport takes over.
+    original_stdout = $stdout.dup
+    $stdout.reopen($stderr)
+
     load_config options[:config]
     require 'jirametrics/mcp_server'
 
     Exporter.instance.file_system.log_only = true
 
     projects = {}
+    aggregates = {}
     Exporter.instance.each_project_config(name_filter: options[:name] || '*') do |project|
       project.evaluate_next_level
       project.run load_only: true
@@ -71,13 +78,19 @@ class JiraMetrics < Thor
         end_time: project.time_range.end
       }
     rescue StandardError => e
-      next if e.message.start_with? 'This is an aggregated project'
+      if e.message.start_with? 'This is an aggregated project'
+        names = project.aggregate_project_names
+        aggregates[project.name] = names if names.any?
+        next
+      end
       next if e.message.start_with? 'No data found'
 
       raise
     end
 
-    McpServer.new(projects: projects, timezone_offset: Exporter.instance.timezone_offset).run
+    $stdout.reopen(original_stdout)
+    original_stdout.close
+    McpServer.new(projects: projects, aggregates: aggregates, timezone_offset: Exporter.instance.timezone_offset).run
   end
 
   option :config

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jirametrics
 version: !ruby/object:Gem::Version
-  version: '2.27'
+  version: '2.28'
 platform: ruby
 authors:
 - Mike Bowler
@@ -83,10 +83,12 @@ description: Extract metrics from Jira and export to either a report or to CSV f
 email: mbowler@gargoylesoftware.com
 executables:
 - jirametrics
+- jirametrics-mcp
 extensions: []
 extra_rdoc_files: []
 files:
 - bin/jirametrics
+- bin/jirametrics-mcp
 - lib/jirametrics.rb
 - lib/jirametrics/aggregate_config.rb
 - lib/jirametrics/aging_work_bar_chart.rb