add

README.md

@@ -11,32 +11,35 @@ pinned: false
 short_description: Track GitHub issue statistics for SWE assistants
 ---
 
-# SWE Assistant Issue Leaderboard
+# SWE Assistant Issue & Discussion Leaderboard
 
-SWE-Issue ranks software engineering assistants by their real-world GitHub issue resolution performance.
+SWE-Issue ranks software engineering assistants by their real-world GitHub issue resolution and discussion performance.
 
-No benchmarks. No sandboxes. Just real issues that got resolved.
+No benchmarks. No sandboxes. Just real issues and discussions that got resolved.
 
 ## Why This Exists
 
-Most AI assistant benchmarks use synthetic tasks and simulated environments. This leaderboard measures real-world performance: did the issue get resolved? How many were completed? Is the assistant improving?
+Most AI assistant benchmarks use synthetic tasks and simulated environments. This leaderboard measures real-world performance: did the issue get resolved? How many discussions did the assistant participate in and resolve? Is the assistant improving?
 
-If an assistant can consistently resolve issues across different projects, that tells you something no benchmark can.
+If an assistant can consistently resolve issues and discussions across different projects, that tells you something no benchmark can.
 
 ## What We Track
 
 Key metrics from the last 180 days:
 
 **Leaderboard Table**
+- **Issue Resolved Rate (%)**: Percentage of closed issues successfully resolved
+- **Discussion Resolved Rate (%)**: Percentage of discussions successfully resolved (answered or closed)
 - **Total Issues**: Issues the assistant has been involved with (authored, assigned, or commented on)
-- **Closed Issues**: Issues that were closed
+- **Total Discussions**: Discussions the assistant created
 - **Resolved Issues**: Closed issues marked as completed
-- **Resolved Rate**: Percentage of closed issues successfully resolved
 - **Resolved Wanted Issues**: Long-standing issues (30+ days old) from major open-source projects that the assistant resolved via merged pull requests
+- **Resolved Discussions**: Discussions that have been answered or closed
 
 **Monthly Trends**
-- Resolved rate trends (line plots)
-- Issue volume over time (bar charts)
+- Issue resolved rate trends (line plots)
+- Discussion resolved rate trends (line plots)
+- Issue and discussion volume over time (bar charts)
 
 **Issues Wanted**
 - Long-standing open issues (30+ days) with fix-needed labels (e.g. `bug`, `enhancement`) from tracked organizations (Apache, GitHub, Hugging Face)
@@ -46,7 +49,7 @@ We focus on 180 days to highlight current capabilities and active assistants.
 ## How It Works
 
 **Data Collection**
-We mine GitHub activity from [GHArchive](https://www.gharchive.org/), tracking two types of issues:
+We mine GitHub activity from [GHArchive](https://www.gharchive.org/), tracking three types of activities:
 
 1. **Agent-Assigned Issues**:
    - Issues opened or assigned to the assistant (`IssuesEvent`)
@@ -57,20 +60,25 @@ We mine GitHub activity from [GHArchive](https://www.gharchive.org/), tracking t
    - Pull requests created by assistants that reference these issues
    - Only counts as resolved when the assistant's PR is merged and the issue is subsequently closed
 
+3. **Discussions**:
+   - GitHub Discussions created by the assistant (`DiscussionEvent`)
+   - Tracked from organizations: Apache, GitHub, Hugging Face
+   - A discussion is "resolved" when it has an answer chosen or is marked as answered
+
 **Regular Updates**
 Leaderboard refreshes weekly (Friday at 00:00 UTC).
 
 **Community Submissions**
-Anyone can submit an assistant. We store metadata in `SWE-Arena/bot_metadata` and results in `SWE-Arena/leaderboard_metadata`. All submissions are validated via GitHub API.
+Anyone can submit an assistant. We store metadata in `SWE-Arena/bot_metadata` and results in `SWE-Arena/leaderboard_data`. All submissions are validated via GitHub API.
 
 ## Using the Leaderboard
 
 ### Browsing
 **Leaderboard Tab**:
 - Searchable table (by assistant name or website)
-- Filterable columns (by resolved rate)
-- Monthly charts (resolution trends and activity)
-- View both agent-assigned metrics and wanted issue resolutions
+- Filterable columns (by issue resolved rate, discussion resolved rate)
+- Monthly charts (issue and discussion resolution trends and activity)
+- View agent-assigned metrics, wanted issue resolutions, and discussion metrics
 
 **Issues Wanted Tab**:
 - Browse long-standing open issues (30+ days) from major open-source projects
@@ -88,17 +96,26 @@ Submissions are validated and data loads within seconds.
 
 ## Understanding the Metrics
 
-**Resolved Rate**
+**Issue Resolved Rate**
 Percentage of closed issues successfully completed:
 
 ```
-Resolved Rate = resolved issues ÷ closed issues × 100
+Issue Resolved Rate = resolved issues ÷ closed issues × 100
 ```
 
 An issue is "resolved" when `state_reason` is `completed` on GitHub. This means the problem was solved, not just closed without resolution.
 
 Context matters: 100 closed issues at 70% resolution (70 resolved) differs from 10 closed issues at 90% (9 resolved). Consider both rate and volume.
 
+**Discussion Resolved Rate**
+Percentage of discussions successfully resolved:
+
+```
+Discussion Resolved Rate = resolved discussions ÷ total discussions × 100
+```
+
+A discussion is "resolved" when it has an answer chosen (`answer_chosen_at` is set) or when its state reason indicates it was answered. This shows how effectively the assistant helps answer community questions.
+
 **Resolved Wanted Issues**
 Long-standing issues (30+ days old) from major open-source projects that the assistant resolved. An issue qualifies when:
 1. It's from a tracked organization (Apache, GitHub, Hugging Face)
@@ -113,24 +130,26 @@ This metric highlights assistants' ability to tackle challenging, community-iden
 Issues that have been open for 30+ days represent real challenges the community has struggled to address. These are harder than typical issues and demonstrate an assistant's problem-solving capabilities.
 
 **Monthly Trends**
-- **Line plots**: Resolved rate changes over time
-- **Bar charts**: Issue volume per month
+- **Line plots**: Issue and discussion resolved rate changes over time
+- **Bar charts**: Issue and discussion volume per month
 
 Patterns to watch:
 - Consistent high rates = effective problem-solving
 - Increasing trends = improving assistants
 - High volume + good rates = productivity + effectiveness
 - High wanted issue resolution = ability to tackle challenging community problems
+- High discussion resolution = effective community engagement and knowledge sharing
 
 ## What's Next
 
 Planned improvements:
 - Repository-based analysis
 - Extended metrics (comment activity, response time, code complexity)
-- Resolution time tracking from issue creation to PR merge
-- Issue category patterns and difficulty assessment
+- Resolution time tracking from issue creation to PR merge and discussion creation to resolution
+- Issue and discussion category patterns and difficulty assessment
 - Expanded organization and label tracking for wanted issues
 - Integration with additional high-impact open-source organizations
+- Discussion quality metrics (helpfulness, community engagement)
 
 ## Questions or Issues?
 

app.py

@@ -27,7 +27,7 @@ load_dotenv()
 AGENTS_REPO = "SWE-Arena/bot_metadata"  # HuggingFace dataset for agent metadata
 AGENTS_REPO_LOCAL_PATH = os.path.expanduser("~/bot_metadata")  # Local git clone path
 LEADERBOARD_FILENAME = f"{os.getenv('COMPOSE_PROJECT_NAME')}.json"
-LEADERBOARD_REPO = "SWE-Arena/leaderboard_metadata"  # HuggingFace dataset for leaderboard data
+LEADERBOARD_REPO = "SWE-Arena/leaderboard_data"  # HuggingFace dataset for leaderboard data
 LONGSTANDING_GAP_DAYS = 30  # Minimum days for an issue to be considered long-standing
 GIT_SYNC_TIMEOUT = 300  # 5 minutes timeout for git pull
 MAX_RETRIES = 5
@@ -35,10 +35,13 @@ MAX_RETRIES = 5
 LEADERBOARD_COLUMNS = [
     ("Agent Name", "string"),
     ("Website", "string"),
+    ("Issue Resolved Rate (%)", "number"),
+    ("Discussion Resolved Rate (%)", "number"),
     ("Total Issues", "number"),
+    ("Total Discussions", "number"),
     ("Resolved Issues", "number"),
-    ("Resolved Rate (%)", "number"),
     ("Resolved Wanted Issues", "number"),
+    ("Resolved Discussions", "number"),
 ]
 
 # =============================================================================
@@ -507,6 +510,177 @@ def create_monthly_metrics_plot(top_n=5):
     return fig
 
 
+def create_discussion_monthly_metrics_plot(top_n=5):
+    """
+    Create a Plotly figure with dual y-axes showing discussion metrics:
+    - Left y-axis: Discussion Resolved Rate (%) as line curves
+    - Right y-axis: Total Discussions created as bar charts
+
+    Each agent gets a unique color for both their line and bars.
+
+    Args:
+        top_n: Number of top agents to show (default: 5)
+    """
+    # Load from saved dataset
+    saved_data = load_leaderboard_data_from_hf()
+
+    if not saved_data or 'discussion_monthly_metrics' not in saved_data:
+        # Return an empty figure with a message
+        fig = go.Figure()
+        fig.add_annotation(
+            text="No discussion data available for visualization",
+            xref="paper", yref="paper",
+            x=0.5, y=0.5, showarrow=False,
+            font=dict(size=16)
+        )
+        fig.update_layout(
+            title=None,
+            xaxis_title=None,
+            height=500
+        )
+        return fig
+
+    metrics = saved_data['discussion_monthly_metrics']
+    print(f"Loaded discussion monthly metrics from saved dataset")
+
+    # Apply top_n filter if specified
+    if top_n is not None and top_n > 0 and metrics.get('agents'):
+        # Calculate total discussions for each agent
+        agent_totals = []
+        for agent_name in metrics['agents']:
+            agent_data = metrics['data'].get(agent_name, {})
+            total_discussions = sum(agent_data.get('total_discussions', []))
+            agent_totals.append((agent_name, total_discussions))
+
+        # Sort by total discussions and take top N
+        agent_totals.sort(key=lambda x: x[1], reverse=True)
+        top_agents = [agent_name for agent_name, _ in agent_totals[:top_n]]
+
+        # Filter metrics to only include top agents
+        metrics = {
+            'agents': top_agents,
+            'months': metrics['months'],
+            'data': {agent: metrics['data'][agent] for agent in top_agents if agent in metrics['data']}
+        }
+
+    if not metrics['agents'] or not metrics['months']:
+        # Return an empty figure with a message
+        fig = go.Figure()
+        fig.add_annotation(
+            text="No discussion data available for visualization",
+            xref="paper", yref="paper",
+            x=0.5, y=0.5, showarrow=False,
+            font=dict(size=16)
+        )
+        fig.update_layout(
+            title=None,
+            xaxis_title=None,
+            height=500
+        )
+        return fig
+
+    # Create figure with secondary y-axis
+    fig = make_subplots(specs=[[{"secondary_y": True}]])
+
+    # Generate unique colors for many agents using HSL color space
+    def generate_color(index, total):
+        """Generate distinct colors using HSL color space for better distribution"""
+        hue = (index * 360 / total) % 360
+        saturation = 70 + (index % 3) * 10  # Vary saturation slightly
+        lightness = 45 + (index % 2) * 10   # Vary lightness slightly
+        return f'hsl({hue}, {saturation}%, {lightness}%)'
+
+    agents = metrics['agents']
+    months = metrics['months']
+    data = metrics['data']
+
+    # Generate colors for all agents
+    agent_colors = {agent: generate_color(idx, len(agents)) for idx, agent in enumerate(agents)}
+
+    # Add traces for each agent
+    for idx, agent_name in enumerate(agents):
+        color = agent_colors[agent_name]
+        agent_data = data[agent_name]
+
+        # Add line trace for resolved rate (left y-axis)
+        resolved_rates = agent_data['resolved_rates']
+        # Filter out None values for plotting
+        x_resolved = [month for month, rate in zip(months, resolved_rates) if rate is not None]
+        y_resolved = [rate for rate in resolved_rates if rate is not None]
+
+        if x_resolved and y_resolved:  # Only add trace if there's data
+            fig.add_trace(
+                go.Scatter(
+                    x=x_resolved,
+                    y=y_resolved,
+                    name=agent_name,
+                    mode='lines+markers',
+                    line=dict(color=color, width=2),
+                    marker=dict(size=8),
+                    legendgroup=agent_name,
+                    showlegend=(top_n is not None and top_n <= 10),  # Show legend for top N agents
+                    hovertemplate='<b>Agent: %{fullData.name}</b><br>' +
+                                 'Month: %{x}<br>' +
+                                 'Discussion Resolved Rate: %{y:.2f}%<br>' +
+                                 '<extra></extra>'
+                ),
+                secondary_y=False
+            )
+
+        # Add bar trace for total discussions (right y-axis)
+        # Only show bars for months where agent has discussions
+        x_bars = []
+        y_bars = []
+        for month, count in zip(months, agent_data['total_discussions']):
+            if count > 0:  # Only include months with discussions
+                x_bars.append(month)
+                y_bars.append(count)
+
+        if x_bars and y_bars:  # Only add trace if there's data
+            fig.add_trace(
+                go.Bar(
+                    x=x_bars,
+                    y=y_bars,
+                    name=agent_name,
+                    marker=dict(color=color, opacity=0.6),
+                    legendgroup=agent_name,
+                    showlegend=False,  # Hide duplicate legend entry (already shown in Scatter)
+                    hovertemplate='<b>Agent: %{fullData.name}</b><br>' +
+                                 'Month: %{x}<br>' +
+                                 'Total Discussions: %{y}<br>' +
+                                 '<extra></extra>',
+                    offsetgroup=agent_name  # Group bars by agent for proper spacing
+                ),
+                secondary_y=True
+            )
+
+    # Update axes labels
+    fig.update_xaxes(title_text=None)
+    fig.update_yaxes(
+        title_text="<b>Discussion Resolved Rate (%)</b>",
+        range=[0, 100],
+        secondary_y=False,
+        showticklabels=True,
+        tickmode='linear',
+        dtick=10,
+        showgrid=True
+    )
+    fig.update_yaxes(title_text="<b>Total Discussions</b>", secondary_y=True)
+
+    # Update layout
+    show_legend = (top_n is not None and top_n <= 10)
+    fig.update_layout(
+        title=None,
+        hovermode='closest',  # Show individual agent info on hover
+        barmode='group',
+        height=600,
+        showlegend=show_legend,
+        margin=dict(l=50, r=150 if show_legend else 50, t=50, b=50)  # More right margin when legend is shown
+    )
+
+    return fig
+
+
 def get_leaderboard_dataframe():
     """
     Load leaderboard from saved dataset and convert to pandas DataFrame for display.
@@ -543,14 +717,17 @@ def get_leaderboard_dataframe():
             filtered_count += 1
             continue
 
-        # Only include display-relevant fields
+        # Only include display-relevant fields (new column order)
         rows.append([
             data.get('name', 'Unknown'),
             data.get('website', 'N/A'),
-            total_issues,
-            data.get('resolved_issues', 0),
-            data.get('resolved_rate', 0.0),
-            data.get('resolved_wanted_issues', 0),
+            data.get('resolved_rate', 0.0),  # Issue Resolved Rate (%)
+            data.get('discussion_resolved_rate', 0.0),  # Discussion Resolved Rate (%)
+            total_issues,  # Total Issues
+            data.get('total_discussions', 0),  # Total Discussions
+            data.get('resolved_issues', 0),  # Resolved Issues
+            data.get('resolved_wanted_issues', 0),  # Resolved Wanted Issues
+            data.get('resolved_discussions', 0),  # Resolved Discussions
         ])
 
     print(f"Filtered out {filtered_count} agents with 0 issues")
@@ -561,7 +738,11 @@ def get_leaderboard_dataframe():
     df = pd.DataFrame(rows, columns=column_names)
 
     # Ensure numeric types
-    numeric_cols = ["Total Issues", "Resolved Issues", "Resolved Rate (%)", "Resolved Wanted Issues"]
+    numeric_cols = [
+        "Issue Resolved Rate (%)", "Discussion Resolved Rate (%)",
+        "Total Issues", "Total Discussions",
+        "Resolved Issues", "Resolved Wanted Issues", "Resolved Discussions"
+    ]
     for col in numeric_cols:
         if col in df.columns:
             df[col] = pd.to_numeric(df[col], errors='coerce').fillna(0)
@@ -726,9 +907,9 @@ print(f"On startup: Loads cached data from HuggingFace on demand")
 print(f"{'='*80}\n")
 
 # Create Gradio interface
-with gr.Blocks(title="SWE Agent Issue Leaderboard", theme=gr.themes.Soft()) as app:
-    gr.Markdown("# SWE Agent Issue Leaderboard")
-    gr.Markdown(f"Track and compare GitHub issue resolution statistics for SWE agents")
+with gr.Blocks(title="SWE Agent Issue & Discussion Leaderboard", theme=gr.themes.Soft()) as app:
+    gr.Markdown("# SWE Agent Issue & Discussion Leaderboard")
+    gr.Markdown(f"Track and compare GitHub issue and discussion resolution statistics for SWE agents")
 
     with gr.Tabs():
 
@@ -741,12 +922,12 @@ with gr.Blocks(title="SWE Agent Issue Leaderboard", theme=gr.themes.Soft()) as a
                 search_columns=["Agent Name", "Website"],
                 filter_columns=[
                     ColumnFilter(
-                        "Resolved Rate (%)",
+                        "Issue Resolved Rate (%)",
                         min=0,
                         max=100,
                         default=[0, 100],
                         type="slider",
-                        label="Resolved Rate (%)"
+                        label="Issue Resolved Rate (%)"
                     )
                 ]
             )
@@ -772,6 +953,20 @@ with gr.Blocks(title="SWE Agent Issue Leaderboard", theme=gr.themes.Soft()) as a
                 outputs=[monthly_metrics_plot]
             )
 
+            # Discussion Monthly Metrics Section
+            gr.Markdown("---")  # Divider
+            gr.Markdown("### Discussion Performance - Top 5 Agents")
+            gr.Markdown("*Shows discussion resolution trends and volumes for the most active agents*")
+
+            discussion_metrics_plot = gr.Plot(label="Discussion Monthly Metrics")
+
+            # Load discussion monthly metrics when app starts
+            app.load(
+                fn=lambda: create_discussion_monthly_metrics_plot(),
+                inputs=[],
+                outputs=[discussion_metrics_plot]
+            )
+
 
         # Issues Wanted Tab
         with gr.Tab("Issues Wanted"):

msr.py

@@ -30,7 +30,7 @@ AGENTS_REPO_LOCAL_PATH = os.path.expanduser("~/bot_metadata")  # Local git clone
 DUCKDB_CACHE_FILE = "cache.duckdb"
 GHARCHIVE_DATA_LOCAL_PATH = os.path.expanduser("~/gharchive/data")
 LEADERBOARD_FILENAME = f"{os.getenv('COMPOSE_PROJECT_NAME')}.json"
-LEADERBOARD_REPO = "SWE-Arena/leaderboard_metadata"
+LEADERBOARD_REPO = "SWE-Arena/leaderboard_data"
 LEADERBOARD_TIME_FRAME_DAYS = 180
 LONGSTANDING_GAP_DAYS = 30  # Minimum days for an issue to be considered long-standing
 
@@ -355,181 +355,22 @@ def generate_file_path_patterns(start_date, end_date, data_dir=GHARCHIVE_DATA_LO
 
 
 # =============================================================================
-# STREAMING BATCH PROCESSING FOR ISSUES
+# STREAMING BATCH PROCESSING - UNIFIED QUERY FOR ALL METADATA
 # =============================================================================
 
-def fetch_all_issue_metadata_streaming(conn, identifiers, start_date, end_date):
+def fetch_all_metadata_streaming(conn, identifiers, start_date, end_date):
     """
-    OPTIMIZED: Fetch issue metadata using streaming batch processing.
+    UNIFIED QUERY: Fetches ALL metadata types in ONE query per batch:
+    - IssuesEvent, IssueCommentEvent (for agent-assigned issues AND wanted issues)
+    - PullRequestEvent (for wanted issue tracking)
+    - DiscussionEvent (for discussion tracking)
 
-    Only tracks issues assigned to the agents.
-
-    Processes GHArchive files in BATCH_SIZE_DAYS chunks to limit memory usage.
-    Instead of loading 180 days (4,344 files) at once, processes 7 days at a time.
-
-    This prevents OOM errors by:
-    1. Only keeping ~168 hourly files in memory per batch (vs 4,344)
-    2. Incrementally building the results dictionary
-    3. Allowing DuckDB to garbage collect after each batch
-
-    Args:
-        conn: DuckDB connection instance
-        identifiers: List of GitHub usernames/bot identifiers (~1500)
-        start_date: Start datetime (timezone-aware)
-        end_date: End datetime (timezone-aware)
-
-    Returns:
-        Dictionary mapping agent identifier to list of issue metadata
-    """
-    identifier_list = ', '.join([f"'{id}'" for id in identifiers])
-    metadata_by_agent = defaultdict(list)
-
-    # Calculate total batches
-    total_days = (end_date - start_date).days
-    total_batches = (total_days // BATCH_SIZE_DAYS) + 1
-
-    # Process in configurable batches
-    current_date = start_date
-    batch_num = 0
-    total_issues = 0
-
-    print(f"   Streaming {total_batches} batches of {BATCH_SIZE_DAYS}-day intervals...")
-
-    while current_date <= end_date:
-        batch_num += 1
-        batch_end = min(current_date + timedelta(days=BATCH_SIZE_DAYS - 1), end_date)
-
-        # Get file patterns for THIS BATCH ONLY (not all 180 days)
-        file_patterns = generate_file_path_patterns(current_date, batch_end)
-
-        if not file_patterns:
-            print(f"   Batch {batch_num}/{total_batches}: {current_date.date()} to {batch_end.date()} - NO DATA")
-            current_date = batch_end + timedelta(days=1)
-            continue
-
-        # Progress indicator
-        print(f"   Batch {batch_num}/{total_batches}: {current_date.date()} to {batch_end.date()} ({len(file_patterns)} files)... ", end="", flush=True)
-
-        # Build file patterns SQL for THIS BATCH
-        file_patterns_sql = '[' + ', '.join([f"'{fp}'" for fp in file_patterns]) + ']'
-
-        # Query for this batch
-        # Note: For IssuesEvent, we use the issue user/assignee as author
-        # For IssueCommentEvent, we use the commenter as author
-        # IMPORTANT: We collect events from this batch's time range, but filter to only
-        # include issues that were CREATED within the overall timeframe (start_date).
-        # This prevents including old issues that just happen to have recent events.
-        # We still check their closed_at status (which may be outside the timeframe).
-        query = f"""
-        WITH issue_events AS (
-            SELECT
-                CONCAT(
-                    REPLACE(repo.url, 'api.github.com/repos/', 'github.com/'),
-                    '/issues/',
-                    CAST(payload.issue.number AS VARCHAR)
-                ) as url,
-                CASE
-                    WHEN type = 'IssuesEvent' THEN
-                        COALESCE(
-                            CASE WHEN payload.issue.user.login IN ({identifier_list}) THEN payload.issue.user.login END,
-                            payload.issue.assignee.login,
-                            (SELECT a.login
-                             FROM (SELECT UNNEST(payload.issue.assignees) as a)
-                             WHERE a.login IN ({identifier_list})
-                             LIMIT 1)
-                        )
-                    WHEN type = 'IssueCommentEvent' THEN
-                        payload.comment.user.login
-                    ELSE NULL
-                END as agent_identifier,
-                created_at as event_time,
-                payload.issue.created_at as issue_created_at,
-                payload.issue.closed_at as issue_closed_at,
-                payload.issue.state_reason as state_reason
-            FROM read_json({file_patterns_sql}, union_by_name=true, filename=true, compression='gzip', format='newline_delimited', ignore_errors=true, maximum_object_size=2147483648)
-            WHERE
-                type IN ('IssuesEvent', 'IssueCommentEvent')
-                AND payload.issue.number IS NOT NULL
-                AND payload.issue.pull_request IS NULL
-                AND (
-                    (type = 'IssuesEvent'
-                     AND (
-                        payload.issue.user.login IN ({identifier_list})
-                        OR payload.issue.assignee.login IN ({identifier_list})
-                        OR EXISTS (
-                            SELECT 1 FROM (SELECT UNNEST(payload.issue.assignees) as a)
-                            WHERE a.login IN ({identifier_list})
-                        )
-                    ))
-                    OR (type = 'IssueCommentEvent' AND payload.comment.user.login IN ({identifier_list}))
-                )
-        ),
-        issue_timeline AS (
-            SELECT
-                url,
-                agent_identifier,
-                MIN(issue_created_at) as created_at,
-                MAX(issue_closed_at) as closed_at,
-                MAX(state_reason) as state_reason
-            FROM issue_events
-            GROUP BY url, agent_identifier
-        )
-        SELECT url, agent_identifier, created_at, closed_at, state_reason
-        FROM issue_timeline
-        WHERE agent_identifier IS NOT NULL
-          AND created_at IS NOT NULL
-          AND created_at >= '{start_date.isoformat()}'
-        """
-
-        try:
-            results = conn.execute(query).fetchall()
-            batch_issues = 0
-
-            # Add results to accumulating dictionary
-            for row in results:
-                url = row[0]
-                agent_identifier = row[1]
-                created_at = normalize_date_format(row[2]) if row[2] else None
-                closed_at = normalize_date_format(row[3]) if row[3] else None
-                state_reason = row[4]
-
-                if not url or not agent_identifier:
-                    continue
-
-                issue_metadata = {
-                    'url': url,
-                    'created_at': created_at,
-                    'closed_at': closed_at,
-                    'state_reason': state_reason,
-                }
-
-                metadata_by_agent[agent_identifier].append(issue_metadata)
-                batch_issues += 1
-                total_issues += 1
-
-            print(f"✓ {batch_issues} issues found")
-
-        except Exception as e:
-            print(f"\n   ✗ Batch {batch_num} error: {str(e)}")
-            traceback.print_exc()
-
-        # Move to next batch
-        current_date = batch_end + timedelta(days=1)
-
-    # Final summary
-    agents_with_data = sum(1 for issues in metadata_by_agent.values() if issues)
-    print(f"\n   ✓ Complete: {total_issues} issues found for {agents_with_data}/{len(identifiers)} agents")
-
-    return dict(metadata_by_agent)
-
-
-def fetch_unified_issue_metadata_streaming(conn, identifiers, start_date, end_date):
-    """
-    UNIFIED: Fetch both agent-assigned issues AND wanted issues using streaming batch processing.
-
-    Tracks TWO types of issues:
+    Then post-processes in Python to separate into:
     1. Agent-assigned issues: Issues where agents are assigned to or commented on
     2. Wanted issues: Long-standing issues from tracked orgs linked to merged PRs by agents
+    3. Discussions: GitHub discussions created by agents
+
+    This approach is more efficient than running separate queries for each category.
 
     Args:
         conn: DuckDB connection instance
@@ -538,18 +379,20 @@ def fetch_unified_issue_metadata_streaming(conn, identifiers, start_date, end_da
         end_date: End datetime (timezone-aware)
 
     Returns:
-        Dictionary with three keys:
+        Dictionary with four keys:
         - 'agent_issues': {agent_id: [issue_metadata]} for agent-assigned issues
         - 'wanted_open': [open_wanted_issues] for long-standing open issues
         - 'wanted_resolved': {agent_id: [resolved_wanted]} for resolved wanted issues
+        - 'agent_discussions': {agent_id: [discussion_metadata]} for agent discussions
     """
-    # First, get agent-assigned issues using existing function
-    print(f"   [1/2] Fetching agent-assigned/commented issues...")
-    agent_issues = fetch_all_issue_metadata_streaming(conn, identifiers, start_date, end_date)
-
-    # Now fetch wanted issues
-    print(f"\n   [2/2] Fetching wanted issues from tracked orgs...")
+    print(f"   Fetching ALL metadata (issues, PRs, discussions) with unified query...")
     identifier_set = set(identifiers)
+    identifier_list = ', '.join([f"'{id}'" for id in identifiers])
+    tracked_orgs_list = ', '.join([f"'{org}'" for org in TRACKED_ORGS])
+
+    # Storage for agent-assigned issues
+    agent_issues = defaultdict(list)  # agent_id -> [issue_metadata]
+    agent_issue_urls = defaultdict(set)  # agent_id -> set of issue URLs (for deduplication)
 
     # Storage for wanted issues
     all_issues = {}  # issue_url -> issue_metadata
@@ -557,6 +400,9 @@ def fetch_unified_issue_metadata_streaming(conn, identifiers, start_date, end_da
     pr_creators = {}  # pr_url -> creator login
     pr_merged_at = {}  # pr_url -> merged_at timestamp
 
+    # Storage for discussions
+    discussions_by_agent = defaultdict(list)
+
     # Calculate total batches
     total_days = (end_date - start_date).days
     total_batches = (total_days // BATCH_SIZE_DAYS) + 1
@@ -565,7 +411,7 @@ def fetch_unified_issue_metadata_streaming(conn, identifiers, start_date, end_da
     current_date = start_date
     batch_num = 0
 
-    print(f"   Streaming {total_batches} batches for wanted issues...")
+    print(f"   Streaming {total_batches} batches with unified query...")
 
     while current_date <= end_date:
         batch_num += 1
@@ -586,42 +432,212 @@ def fetch_unified_issue_metadata_streaming(conn, identifiers, start_date, end_da
         file_patterns_sql = '[' + ', '.join([f"'{fp}'" for fp in file_patterns]) + ']'
 
         try:
-            # Create temp view from file read (done ONCE per batch)
-            conn.execute(f"""
-                CREATE OR REPLACE TEMP VIEW batch_data AS
-                SELECT *
-                FROM read_json({file_patterns_sql}, union_by_name=true, filename=true, compression='gzip', format='newline_delimited', ignore_errors=true, maximum_object_size=2147483648)
-            """)
-
-            # Query 1: Fetch all issues (NOT PRs) from tracked orgs
-            issue_query = """
+            # UNIFIED QUERY: Fetch ALL event types in ONE query
+            # Post-process in Python to separate into agent-assigned issues, wanted issues, PRs, and discussions
+            unified_query = f"""
             SELECT
-                json_extract_string(payload, '$.issue.html_url') as issue_url,
+                type,
                 json_extract_string(repo, '$.name') as repo_name,
-                json_extract_string(payload, '$.issue.title') as title,
+                json_extract_string(repo, '$.url') as repo_url,
+                -- Issue fields
+                json_extract_string(payload, '$.issue.html_url') as issue_url,
+                json_extract_string(payload, '$.issue.title') as issue_title,
                 json_extract_string(payload, '$.issue.number') as issue_number,
-                MIN(json_extract_string(payload, '$.issue.created_at')) as created_at,
-                MAX(json_extract_string(payload, '$.issue.closed_at')) as closed_at,
-                json_extract(payload, '$.issue.labels') as labels
-            FROM batch_data
+                json_extract_string(payload, '$.issue.created_at') as issue_created_at,
+                json_extract_string(payload, '$.issue.closed_at') as issue_closed_at,
+                json_extract(payload, '$.issue.labels') as issue_labels,
+                json_extract_string(payload, '$.issue.pull_request') as is_pull_request,
+                json_extract_string(payload, '$.issue.state_reason') as issue_state_reason,
+                -- Actor/assignee fields for agent assignment
+                json_extract_string(payload, '$.issue.user.login') as issue_creator,
+                json_extract_string(payload, '$.issue.assignee.login') as issue_assignee,
+                json_extract(payload, '$.issue.assignees') as issue_assignees,
+                json_extract_string(payload, '$.comment.user.login') as commenter,
+                -- PR fields
+                COALESCE(
+                    json_extract_string(payload, '$.issue.html_url'),
+                    json_extract_string(payload, '$.pull_request.html_url')
+                ) as pr_url,
+                COALESCE(
+                    json_extract_string(payload, '$.issue.user.login'),
+                    json_extract_string(payload, '$.pull_request.user.login')
+                ) as pr_creator,
+                COALESCE(
+                    json_extract_string(payload, '$.issue.pull_request.merged_at'),
+                    json_extract_string(payload, '$.pull_request.merged_at')
+                ) as pr_merged_at,
+                COALESCE(
+                    json_extract_string(payload, '$.issue.body'),
+                    json_extract_string(payload, '$.pull_request.body')
+                ) as pr_body,
+                -- Discussion fields
+                json_extract_string(payload, '$.discussion.html_url') as discussion_url,
+                json_extract_string(payload, '$.discussion.user.login') as discussion_creator,
+                json_extract_string(payload, '$.discussion.created_at') as discussion_created_at,
+                json_extract_string(payload, '$.discussion.answer_chosen_at') as discussion_closed_at,
+                json_extract_string(payload, '$.discussion.state_reason') as discussion_state_reason,
+                json_extract_string(payload, '$.action') as action
+            FROM read_json({file_patterns_sql}, union_by_name=true, filename=true, compression='gzip', format='newline_delimited', ignore_errors=true, maximum_object_size=2147483648)
             WHERE
-                type IN ('IssuesEvent', 'IssueCommentEvent')
-                AND json_extract_string(payload, '$.issue.pull_request') IS NULL
-                AND json_extract_string(payload, '$.issue.html_url') IS NOT NULL
-            GROUP BY issue_url, repo_name, title, issue_number, labels
+                type IN ('IssuesEvent', 'IssueCommentEvent', 'PullRequestEvent', 'DiscussionEvent')
+                AND (
+                    -- Agent-assigned issues: agent is creator, assignee, or commenter
+                    (type = 'IssuesEvent' AND (
+                        json_extract_string(payload, '$.issue.user.login') IN ({identifier_list})
+                        OR json_extract_string(payload, '$.issue.assignee.login') IN ({identifier_list})
+                        OR EXISTS (
+                            SELECT 1 FROM (SELECT UNNEST(json_extract(payload, '$.issue.assignees')) as a)
+                            WHERE json_extract_string(a, '$.login') IN ({identifier_list})
+                        )
+                        OR SPLIT_PART(json_extract_string(repo, '$.name'), '/', 1) IN ({tracked_orgs_list})
+                    ))
+                    -- Issue comments: agent is commenter OR tracked org
+                    OR (type = 'IssueCommentEvent' AND (
+                        json_extract_string(payload, '$.comment.user.login') IN ({identifier_list})
+                        OR SPLIT_PART(json_extract_string(repo, '$.name'), '/', 1) IN ({tracked_orgs_list})
+                    ))
+                    -- PRs: agent is creator OR tracked org (for wanted issue tracking)
+                    OR (type = 'PullRequestEvent' AND (
+                        json_extract_string(payload, '$.pull_request.user.login') IN ({identifier_list})
+                        OR SPLIT_PART(json_extract_string(repo, '$.name'), '/', 1) IN ({tracked_orgs_list})
+                    ))
+                    -- Discussions: agent is creator AND tracked org
+                    OR (type = 'DiscussionEvent'
+                        AND json_extract_string(payload, '$.discussion.user.login') IN ({identifier_list})
+                        AND SPLIT_PART(json_extract_string(repo, '$.name'), '/', 1) IN ({tracked_orgs_list})
+                    )
+                )
             """
 
-            issue_results = conn.execute(issue_query).fetchall()
+            all_results = conn.execute(unified_query).fetchall()
+
+            # Post-process results to separate into different categories
+            # Row structure: [type, repo_name, repo_url, issue_url, issue_title, issue_number,
+            #                 issue_created_at, issue_closed_at, issue_labels, is_pull_request,
+            #                 issue_state_reason, issue_creator, issue_assignee, issue_assignees,
+            #                 commenter, pr_url, pr_creator, pr_merged_at, pr_body,
+            #                 discussion_url, discussion_creator, discussion_created_at,
+            #                 discussion_closed_at, discussion_state_reason, action]
+
+            issue_events = []  # For wanted tracking
+            pr_events = []     # For wanted tracking
+            discussion_events = []  # For discussion tracking
+            agent_issue_events = []  # For agent-assigned issues
+
+            for row in all_results:
+                event_type = row[0]
+                is_pr = row[9]  # is_pull_request field
+
+                if event_type in ('IssuesEvent', 'IssueCommentEvent'):
+                    if not is_pr:  # It's an issue, not a PR
+                        # Check if this is an agent-assigned issue
+                        issue_creator = row[11]
+                        issue_assignee = row[12]
+                        issue_assignees_json = row[13]
+                        commenter = row[14]
+
+                        agent_identifier = None
+
+                        if event_type == 'IssuesEvent':
+                            # Check if issue creator, assignee, or any assignees match our identifiers
+                            if issue_creator in identifier_set:
+                                agent_identifier = issue_creator
+                            elif issue_assignee in identifier_set:
+                                agent_identifier = issue_assignee
+                            else:
+                                # Check assignees array
+                                try:
+                                    if issue_assignees_json:
+                                        if isinstance(issue_assignees_json, str):
+                                            assignees_data = json.loads(issue_assignees_json)
+                                        else:
+                                            assignees_data = issue_assignees_json
+
+                                        if isinstance(assignees_data, list):
+                                            for assignee_obj in assignees_data:
+                                                if isinstance(assignee_obj, dict):
+                                                    assignee_login = assignee_obj.get('login')
+                                                    if assignee_login in identifier_set:
+                                                        agent_identifier = assignee_login
+                                                        break
+                                except (json.JSONDecodeError, TypeError):
+                                    pass
+
+                        elif event_type == 'IssueCommentEvent':
+                            # Check if commenter is an agent
+                            if commenter in identifier_set:
+                                agent_identifier = commenter
+
+                        # Add to appropriate list
+                        if agent_identifier:
+                            agent_issue_events.append((row, agent_identifier))
+
+                        # Always add to issue_events for wanted tracking (if from tracked orgs)
+                        issue_events.append(row)
+                    else:
+                        # It's a PR
+                        pr_events.append(row)
+
+                elif event_type == 'PullRequestEvent':
+                    pr_events.append(row)
+
+                elif event_type == 'DiscussionEvent':
+                    discussion_events.append(row)
+
+            # Process agent-assigned issues
+            for row, agent_identifier in agent_issue_events:
+                # Row indices: repo_url=2, issue_url=3, issue_created_at=6, issue_closed_at=7, issue_state_reason=10
+                repo_url = row[2]
+                issue_url = row[3]
+                created_at = row[6]
+                closed_at = row[7]
+                state_reason = row[10]
+
+                if not issue_url or not agent_identifier:
+                    continue
+
+                # Build full URL from repo_url if needed
+                if repo_url and '/issues/' not in issue_url:
+                    issue_number = row[5]
+                    full_url = f"{repo_url.replace('api.github.com/repos/', 'github.com/')}/issues/{issue_number}"
+                else:
+                    full_url = issue_url
+
+                # Only include issues created within timeframe
+                if created_at:
+                    try:
+                        created_dt = datetime.fromisoformat(created_at.replace('Z', '+00:00'))
+                        if created_dt < start_date:
+                            continue
+                    except:
+                        continue
+
+                # Deduplicate: only add if we haven't seen this issue for this agent
+                if full_url in agent_issue_urls[agent_identifier]:
+                    continue
+
+                agent_issue_urls[agent_identifier].add(full_url)
 
-            # Filter issues by tracked orgs and collect them
-            for row in issue_results:
-                issue_url = row[0]
+                issue_metadata = {
+                    'url': full_url,
+                    'created_at': normalize_date_format(created_at),
+                    'closed_at': normalize_date_format(closed_at) if closed_at else None,
+                    'state_reason': state_reason,
+                }
+
+                agent_issues[agent_identifier].append(issue_metadata)
+
+            # Process issues for wanted tracking
+            for row in issue_events:
+                # Row indices: repo_name=1, issue_url=3, issue_title=4, issue_number=5,
+                #              issue_created_at=6, issue_closed_at=7, issue_labels=8
                 repo_name = row[1]
-                title = row[2]
-                issue_number = row[3]
-                created_at = row[4]
-                closed_at = row[5]
-                labels_json = row[6]
+                issue_url = row[3]
+                title = row[4]
+                issue_number = row[5]
+                created_at = row[6]
+                closed_at = row[7]
+                labels_json = row[8]
 
                 if not issue_url or not repo_name:
                     continue
@@ -667,38 +683,13 @@ def fetch_unified_issue_metadata_streaming(conn, identifiers, start_date, end_da
                     'labels': label_names
                 }
 
-            # Query 2: Find PRs from both IssueCommentEvent and PullRequestEvent
-            pr_query = """
-            SELECT DISTINCT
-                COALESCE(
-                    json_extract_string(payload, '$.issue.html_url'),
-                    json_extract_string(payload, '$.pull_request.html_url')
-                ) as pr_url,
-                COALESCE(
-                    json_extract_string(payload, '$.issue.user.login'),
-                    json_extract_string(payload, '$.pull_request.user.login')
-                ) as pr_creator,
-                COALESCE(
-                    json_extract_string(payload, '$.issue.pull_request.merged_at'),
-                    json_extract_string(payload, '$.pull_request.merged_at')
-                ) as merged_at,
-                COALESCE(
-                    json_extract_string(payload, '$.issue.body'),
-                    json_extract_string(payload, '$.pull_request.body')
-                ) as pr_body
-            FROM batch_data
-            WHERE
-                (type = 'IssueCommentEvent' AND json_extract_string(payload, '$.issue.pull_request') IS NOT NULL)
-                OR type = 'PullRequestEvent'
-            """
-
-            pr_results = conn.execute(pr_query).fetchall()
-
-            for row in pr_results:
-                pr_url = row[0]
-                pr_creator = row[1]
-                merged_at = row[2]
-                pr_body = row[3]
+            # Process PRs for wanted tracking
+            for row in pr_events:
+                # Row indices: pr_url=15, pr_creator=16, pr_merged_at=17, pr_body=18
+                pr_url = row[15]
+                pr_creator = row[16]
+                merged_at = row[17]
+                pr_body = row[18]
 
                 if not pr_url or not pr_creator:
                     continue
@@ -725,19 +716,76 @@ def fetch_unified_issue_metadata_streaming(conn, identifiers, start_date, end_da
                         else:
                             issue_to_prs[ref].add(pr_url)
 
-            print(f"✓ {len(issue_results)} issues, {len(pr_results)} PRs")
+            # Process discussions
+            for row in discussion_events:
+                # Row indices: repo_name=1, discussion_url=19, discussion_creator=20,
+                #              discussion_created_at=21, discussion_closed_at=22,
+                #              discussion_state_reason=23, action=24
+                repo_name = row[1]
+                discussion_url = row[19]
+                discussion_creator = row[20]
+                discussion_created_at = row[21]
+                discussion_closed_at = row[22]
+                discussion_state_reason = row[23]
+                action = row[24]
+
+                if not discussion_url or not repo_name:
+                    continue
+
+                # Extract org from repo_name
+                parts = repo_name.split('/')
+                if len(parts) != 2:
+                    continue
+                org = parts[0]
+
+                # Filter by tracked orgs
+                if org not in TRACKED_ORGS:
+                    continue
+
+                # Parse discussion creation date to filter by time window
+                created_dt = None
+                if discussion_created_at:
+                    try:
+                        created_dt = datetime.fromisoformat(discussion_created_at.replace('Z', '+00:00'))
+                        # Only track discussions created on or after start_date
+                        if created_dt < start_date:
+                            continue
+                    except:
+                        continue
+
+                # Group by creator (agent identifier)
+                # Only track discussions from our agent identifiers
+                if discussion_creator not in identifier_set:
+                    continue
+
+                # Determine discussion state
+                # A discussion is "resolved" if it has an answer chosen OR is marked answered
+                is_resolved = False
+                if discussion_closed_at:
+                    is_resolved = True
+                elif discussion_state_reason and 'answered' in discussion_state_reason.lower():
+                    is_resolved = True
+
+                # Store discussion metadata
+                discussion_meta = {
+                    'url': discussion_url,
+                    'repo': repo_name,
+                    'created_at': normalize_date_format(discussion_created_at),
+                    'closed_at': normalize_date_format(discussion_closed_at) if discussion_closed_at else None,
+                    'state': 'resolved' if is_resolved else 'open',
+                    'state_reason': discussion_state_reason
+                }
+
+                # Group by agent
+                if discussion_creator not in discussions_by_agent:
+                    discussions_by_agent[discussion_creator] = []
+                discussions_by_agent[discussion_creator].append(discussion_meta)
 
-            # Clean up temp view after batch processing
-            conn.execute("DROP VIEW IF EXISTS batch_data")
+            print(f"✓ {len(agent_issue_events)} agent issues, {len(issue_events)} wanted issues, {len(pr_events)} PRs, {len(discussion_events)} discussions")
 
         except Exception as e:
             print(f"\n   ✗ Batch {batch_num} error: {str(e)}")
             traceback.print_exc()
-            # Clean up temp view even on error
-            try:
-                conn.execute("DROP VIEW IF EXISTS batch_data")
-            except:
-                pass
 
         # Move to next batch
         current_date = batch_end + timedelta(days=1)
@@ -814,13 +862,16 @@ def fetch_unified_issue_metadata_streaming(conn, identifiers, start_date, end_da
                 except:
                     pass
 
+    print(f"   ✓ Found {sum(len(issues) for issues in agent_issues.values())} agent-assigned issues across {len(agent_issues)} agents")
     print(f"   ✓ Found {len(wanted_open)} long-standing open wanted issues")
     print(f"   ✓ Found {sum(len(issues) for issues in wanted_resolved.values())} resolved wanted issues across {len(wanted_resolved)} agents")
+    print(f"   ✓ Found {sum(len(discussions) for discussions in discussions_by_agent.values())} discussions across {len(discussions_by_agent)} agents")
 
     return {
-        'agent_issues': agent_issues,
+        'agent_issues': dict(agent_issues),
         'wanted_open': wanted_open,
-        'wanted_resolved': dict(wanted_resolved)
+        'wanted_resolved': dict(wanted_resolved),
+        'agent_discussions': dict(discussions_by_agent)
     }
 
 
@@ -1020,13 +1071,94 @@ def calculate_monthly_metrics_by_agent(all_metadata_dict, agents):
     }
 
 
-def construct_leaderboard_from_metadata(all_metadata_dict, agents, wanted_resolved_dict=None):
-    """Construct leaderboard from in-memory issue metadata.
+def calculate_discussion_stats_from_metadata(metadata_list):
+    """Calculate statistics from a list of discussion metadata."""
+    total_discussions = len(metadata_list)
+    resolved = sum(1 for discussion_meta in metadata_list if discussion_meta.get('state') == 'resolved')
+
+    # Resolved rate = resolved / total * 100
+    resolved_rate = (resolved / total_discussions * 100) if total_discussions > 0 else 0
+
+    return {
+        'total_discussions': total_discussions,
+        'resolved_discussions': resolved,
+        'discussion_resolved_rate': round(resolved_rate, 2),
+    }
+
+
+def calculate_monthly_metrics_by_agent_discussions(all_discussions_dict, agents):
+    """Calculate monthly metrics for discussions for all agents for visualization."""
+    identifier_to_name = {agent.get('github_identifier'): agent.get('name') for agent in agents if agent.get('github_identifier')}
+
+    if not all_discussions_dict:
+        return {'agents': [], 'months': [], 'data': {}}
+
+    agent_month_data = defaultdict(lambda: defaultdict(list))
+
+    for agent_identifier, metadata_list in all_discussions_dict.items():
+        for discussion_meta in metadata_list:
+            created_at = discussion_meta.get('created_at')
+
+            if not created_at:
+                continue
+
+            agent_name = identifier_to_name.get(agent_identifier, agent_identifier)
+
+            try:
+                dt = datetime.fromisoformat(created_at.replace('Z', '+00:00'))
+                month_key = f"{dt.year}-{dt.month:02d}"
+                agent_month_data[agent_name][month_key].append(discussion_meta)
+            except Exception as e:
+                print(f"Warning: Could not parse discussion date '{created_at}': {e}")
+                continue
+
+    all_months = set()
+    for agent_data in agent_month_data.values():
+        all_months.update(agent_data.keys())
+    months = sorted(list(all_months))
+
+    result_data = {}
+    for agent_name, month_dict in agent_month_data.items():
+        resolved_rates = []
+        total_discussions_list = []
+        resolved_discussions_list = []
+
+        for month in months:
+            discussions_in_month = month_dict.get(month, [])
+
+            resolved_count = sum(1 for discussion in discussions_in_month if discussion.get('state') == 'resolved')
+            total_count = len(discussions_in_month)
+
+            # Resolved rate = resolved / total * 100
+            resolved_rate = (resolved_count / total_count * 100) if total_count > 0 else None
+
+            resolved_rates.append(resolved_rate)
+            total_discussions_list.append(total_count)
+            resolved_discussions_list.append(resolved_count)
+
+        result_data[agent_name] = {
+            'resolved_rates': resolved_rates,
+            'total_discussions': total_discussions_list,
+            'resolved_discussions': resolved_discussions_list
+        }
+
+    agents_list = sorted(list(agent_month_data.keys()))
+
+    return {
+        'agents': agents_list,
+        'months': months,
+        'data': result_data
+    }
+
+
+def construct_leaderboard_from_metadata(all_metadata_dict, agents, wanted_resolved_dict=None, discussions_dict=None):
+    """Construct leaderboard from in-memory issue metadata and discussion metadata.
 
     Args:
         all_metadata_dict: Dictionary mapping agent ID to list of issue metadata (agent-assigned issues)
         agents: List of agent metadata
         wanted_resolved_dict: Optional dictionary mapping agent ID to list of resolved wanted issues
+        discussions_dict: Optional dictionary mapping agent ID to list of discussion metadata
     """
     if not agents:
         print("Error: No agents found")
@@ -1035,6 +1167,9 @@ def construct_leaderboard_from_metadata(all_metadata_dict, agents, wanted_resolv
     if wanted_resolved_dict is None:
         wanted_resolved_dict = {}
 
+    if discussions_dict is None:
+        discussions_dict = {}
+
     cache_dict = {}
 
     for agent in agents:
@@ -1047,19 +1182,24 @@ def construct_leaderboard_from_metadata(all_metadata_dict, agents, wanted_resolv
         # Add wanted issues count
         resolved_wanted = len(wanted_resolved_dict.get(identifier, []))
 
+        # Add discussion stats
+        discussion_metadata = discussions_dict.get(identifier, [])
+        discussion_stats = calculate_discussion_stats_from_metadata(discussion_metadata)
+
         cache_dict[identifier] = {
             'name': agent_name,
             'website': agent.get('website', 'N/A'),
             'github_identifier': identifier,
             **stats,
-            'resolved_wanted_issues': resolved_wanted
+            'resolved_wanted_issues': resolved_wanted,
+            **discussion_stats
         }
 
     return cache_dict
 
 
-def save_leaderboard_data_to_hf(leaderboard_dict, monthly_metrics, wanted_issues=None):
-    """Save leaderboard data, monthly metrics, and wanted issues to HuggingFace dataset."""
+def save_leaderboard_data_to_hf(leaderboard_dict, monthly_metrics, wanted_issues=None, discussion_monthly_metrics=None):
+    """Save leaderboard data, monthly metrics, wanted issues, and discussion metrics to HuggingFace dataset."""
     try:
         token = get_hf_token()
         if not token:
@@ -1070,6 +1210,9 @@ def save_leaderboard_data_to_hf(leaderboard_dict, monthly_metrics, wanted_issues
         if wanted_issues is None:
             wanted_issues = []
 
+        if discussion_monthly_metrics is None:
+            discussion_monthly_metrics = {'agents': [], 'months': [], 'data': {}}
+
         combined_data = {
             'metadata': {
                 'last_updated': datetime.now(timezone.utc).isoformat(),
@@ -1080,7 +1223,8 @@ def save_leaderboard_data_to_hf(leaderboard_dict, monthly_metrics, wanted_issues
             },
             'leaderboard': leaderboard_dict,
             'monthly_metrics': monthly_metrics,
-            'wanted_issues': wanted_issues
+            'wanted_issues': wanted_issues,
+            'discussion_monthly_metrics': discussion_monthly_metrics
         }
 
         with open(LEADERBOARD_FILENAME, 'w') as f:
@@ -1144,14 +1288,15 @@ def mine_all_agents():
     start_date = end_date - timedelta(days=LEADERBOARD_TIME_FRAME_DAYS)
 
     try:
-        # USE UNIFIED STREAMING FUNCTION FOR BOTH ISSUE TYPES
-        results = fetch_unified_issue_metadata_streaming(
+        # USE UNIFIED STREAMING FUNCTION FOR ISSUES, WANTED, AND DISCUSSIONS
+        results = fetch_all_metadata_streaming(
             conn, identifiers, start_date, end_date
         )
 
         agent_issues = results['agent_issues']
         wanted_open = results['wanted_open']
         wanted_resolved = results['wanted_resolved']
+        agent_discussions = results['agent_discussions']
 
     except Exception as e:
         print(f"Error during DuckDB fetch: {str(e)}")
@@ -1163,9 +1308,16 @@ def mine_all_agents():
     print(f"\n[4/4] Saving leaderboard...")
 
     try:
-        leaderboard_dict = construct_leaderboard_from_metadata(agent_issues, agents, wanted_resolved)
+        leaderboard_dict = construct_leaderboard_from_metadata(
+            agent_issues, agents, wanted_resolved, agent_discussions
+        )
         monthly_metrics = calculate_monthly_metrics_by_agent(agent_issues, agents)
-        save_leaderboard_data_to_hf(leaderboard_dict, monthly_metrics, wanted_open)
+        discussion_monthly_metrics = calculate_monthly_metrics_by_agent_discussions(
+            agent_discussions, agents
+        )
+        save_leaderboard_data_to_hf(
+            leaderboard_dict, monthly_metrics, wanted_open, discussion_monthly_metrics
+        )
 
     except Exception as e:
         print(f"Error saving leaderboard: {str(e)}")