@aaronsb/jira-cloud-mcp 0.5.9 → 0.5.11

package/build/client/jira-client.js

@@ -104,6 +104,7 @@ export class JiraClient {
             people.push({ displayName: fields.reporter.displayName, accountId: fields.reporter.accountId, role: 'reporter' });
         }
         return {
+            id: issue.id,
             key: issue.key,
             summary: fields?.summary,
             description: fields?.description
@@ -410,6 +411,43 @@ export class JiraClient {
             url: attachment.content || '',
         }));
     }
+    async getBulkChangelogs(issueKeys, fieldIds = ['status']) {
+        const result = new Map();
+        let nextPageToken;
+        do {
+            const response = await this.client.issues.getBulkChangelogs({
+                issueIdsOrKeys: issueKeys,
+                fieldIds,
+                maxResults: 1000,
+                nextPageToken,
+            });
+            for (const issueLog of response.issueChangeLogs || []) {
+                const issueId = issueLog.issueId;
+                if (!issueId)
+                    continue;
+                const transitions = result.get(issueId) || [];
+                for (const history of issueLog.changeHistories || []) {
+                    for (const item of history.items || []) {
+                        if (item.field === 'status') {
+                            transitions.push({
+                                date: history.created || '',
+                                from: item.fromString || '',
+                                to: item.toString || '',
+                            });
+                        }
+                    }
+                }
+                result.set(issueId, transitions);
+            }
+            nextPageToken = response.nextPageToken ?? undefined;
+        } while (nextPageToken);
+        return result;
+    }
+    async getFilter(filterId) {
+        return await this.client.filters.getFilter({
+            id: parseInt(filterId, 10),
+        });
+    }
     async getFilterIssues(filterId) {
         const filter = await this.client.filters.getFilter({
             id: parseInt(filterId, 10)

package/build/docs/tool-documentation.js

@@ -528,6 +528,14 @@ function generateAnalysisToolDocumentation(schema) {
                     { description: "Summary only", code: { jql: "project = AA", metrics: ["summary"] } },
                 ],
             },
+            {
+                title: "Flow analysis — where do issues get stuck?",
+                description: "Analyze status transitions, time in status, and bounce patterns:",
+                steps: [
+                    { description: "Flow metrics", code: { jql: "project = AA AND resolution = Unresolved", metrics: ["flow"] } },
+                    { description: "Combined with summary", code: { jql: "project = AA", metrics: ["summary", "flow"], groupBy: "issuetype" } },
+                ],
+            },
             {
                 title: "Data cube — discover then compute",
                 description: "Two-phase analysis with computed columns:",

package/build/handlers/analysis-handler.js

@@ -3,6 +3,7 @@ import { evaluateRow, extractColumnRefs, parseComputeList } from '../utils/cube-
 import { analysisNextSteps } from '../utils/next-steps.js';
 import { normalizeArgs } from '../utils/normalize-args.js';
 const ALL_METRICS = ['points', 'time', 'schedule', 'cycle', 'distribution'];
+// flow is opt-in only — requires extra bulk changelog API call
 const VALID_GROUP_BY = ['project', 'assignee', 'priority', 'issuetype'];
 const MAX_ISSUES_HARD = 500; // absolute ceiling for detail metrics — beyond this, context explodes
 const MAX_ISSUES_DEFAULT = 100;
@@ -271,6 +272,100 @@ export function renderDistribution(issues, groupLimit = DEFAULT_GROUP_LIMIT) {
     lines.push(`**By type:** ${mapToString(byType, ' | ', groupLimit)}`);
     return lines.join('\n');
 }
+export async function renderFlow(jiraClient, issues) {
+    if (issues.length === 0)
+        return '## Flow\n\nNo issues to analyze.';
+    const issueKeys = issues.map(i => i.key);
+    // Build a map of issue key → issue ID for matching bulk response
+    const keyToId = new Map();
+    const idToKey = new Map();
+    for (const issue of issues) {
+        if (issue.id) {
+            keyToId.set(issue.key, issue.id);
+            idToKey.set(issue.id, issue.key);
+        }
+    }
+    const changelogs = await jiraClient.getBulkChangelogs(issueKeys);
+    // Aggregate per-status stats
+    const statusStats = new Map();
+    const issueBounceCounts = new Map(); // issueId → status → entry count
+    let totalTransitions = 0;
+    for (const [issueId, transitions] of changelogs) {
+        if (transitions.length === 0)
+            continue;
+        totalTransitions += transitions.length;
+        // Sort transitions by date
+        const sorted = [...transitions].sort((a, b) => new Date(a.date).getTime() - new Date(b.date).getTime());
+        // Track entries per status for this issue
+        const issueStatusEntries = new Map();
+        for (let i = 0; i < sorted.length; i++) {
+            const t = sorted[i];
+            const toStatus = t.to;
+            // Count entries into the target status
+            issueStatusEntries.set(toStatus, (issueStatusEntries.get(toStatus) || 0) + 1);
+            // Calculate time spent in the target status
+            const enteredAt = new Date(t.date).getTime();
+            const exitedAt = i + 1 < sorted.length
+                ? new Date(sorted[i + 1].date).getTime()
+                : Date.now();
+            const daysIn = (exitedAt - enteredAt) / (1000 * 60 * 60 * 24);
+            const stats = statusStats.get(toStatus) || { status: toStatus, entries: 0, totalDaysIn: 0, issueCount: 0, bounces: 0 };
+            stats.entries++;
+            stats.totalDaysIn += daysIn;
+            statusStats.set(toStatus, stats);
+        }
+        issueBounceCounts.set(issueId, issueStatusEntries);
+    }
+    // Count distinct issues and bounces per status
+    const issuesPerStatus = new Map();
+    for (const [issueId, statusEntries] of issueBounceCounts) {
+        for (const [status, count] of statusEntries) {
+            if (!issuesPerStatus.has(status))
+                issuesPerStatus.set(status, new Set());
+            issuesPerStatus.get(status).add(issueId);
+            const stats = statusStats.get(status);
+            if (stats && count > 1) {
+                stats.bounces += count - 1;
+            }
+        }
+    }
+    for (const [status, issueSet] of issuesPerStatus) {
+        const stats = statusStats.get(status);
+        if (stats)
+            stats.issueCount = issueSet.size;
+    }
+    if (statusStats.size === 0) {
+        return '## Flow\n\nNo status transitions found in these issues.';
+    }
+    // Render table
+    const lines = ['## Flow (Status Transitions)', ''];
+    lines.push(`${totalTransitions} transitions across ${changelogs.size} issues`);
+    lines.push('');
+    lines.push('| Status | Entries | Avg days in | Bounce rate | Issues |');
+    lines.push('|--------|--------:|------------:|------------:|-------:|');
+    const sorted = [...statusStats.values()].sort((a, b) => b.entries - a.entries);
+    for (const s of sorted) {
+        const avgDays = s.entries > 0 ? (s.totalDaysIn / s.entries).toFixed(1) : '—';
+        const bounceRate = s.issueCount > 0 ? Math.round((s.bounces / s.issueCount) * 100) : 0;
+        lines.push(`| ${s.status} | ${s.entries} | ${avgDays} | ${bounceRate}% | ${s.issueCount} |`);
+    }
+    // Top bouncers — issues with most re-entries to any status
+    const bouncerScores = [];
+    for (const [issueId, statusEntries] of issueBounceCounts) {
+        const totalBounces = [...statusEntries.values()].reduce((sum, count) => sum + Math.max(0, count - 1), 0);
+        if (totalBounces > 0) {
+            const key = idToKey.get(issueId) || issueId;
+            bouncerScores.push({ key, bounces: totalBounces });
+        }
+    }
+    if (bouncerScores.length > 0) {
+        bouncerScores.sort((a, b) => b.bounces - a.bounces);
+        const top = bouncerScores.slice(0, 5);
+        lines.push('');
+        lines.push(`**Top bouncers:** ${top.map(b => `${b.key} (${b.bounces}×)`).join(', ')}`);
+    }
+    return lines.join('\n');
+}
 /** Extract project keys from JQL like "project in (AA, GC, GD)" or "project = AA" */
 export function extractProjectKeys(jql) {
     // project in (AA, GC, GD)
@@ -592,9 +687,29 @@ async function handleCubeSetup(jiraClient, jql) {
 // ── Main Handler ───────────────────────────────────────────────────────
 export async function handleAnalysisRequest(jiraClient, request) {
     const args = normalizeArgs(request.params?.arguments || {});
-    const jql = args.jql;
-    if (!jql || typeof jql !== 'string' || jql.trim() === '') {
-        throw new McpError(ErrorCode.InvalidParams, 'jql parameter is required.');
+    // Resolve JQL: filterId takes precedence over inline jql
+    let jql;
+    let filterSource;
+    const filterId = args.filterId;
+    if (filterId && typeof filterId === 'string' && filterId.trim() !== '') {
+        let filter;
+        try {
+            filter = await jiraClient.getFilter(filterId);
+        }
+        catch {
+            throw new McpError(ErrorCode.InvalidParams, `Filter ${filterId} not found or not accessible. Use manage_jira_filter with operation "list" to see available filters.`);
+        }
+        if (!filter.jql) {
+            throw new McpError(ErrorCode.InvalidParams, `Filter ${filterId} has no JQL query.`);
+        }
+        jql = filter.jql;
+        filterSource = `${filter.name || filterId} (filter ${filterId})`;
+    }
+    else {
+        jql = args.jql;
+        if (!jql || typeof jql !== 'string' || jql.trim() === '') {
+            throw new McpError(ErrorCode.InvalidParams, 'Either jql or filterId parameter is required.');
+        }
     }
     // Parse requested metrics
     const requested = (args.metrics && Array.isArray(args.metrics))
@@ -602,9 +717,12 @@ export async function handleAnalysisRequest(jiraClient, request) {
         : [];
     const hasSummary = requested.includes('summary');
     const hasCubeSetup = requested.includes('cube_setup');
+    const hasFlow = requested.includes('flow');
     const fetchMetrics = requested.length > 0
         ? requested.filter(m => ALL_METRICS.includes(m))
         : ALL_METRICS;
+    // flow needs issue fetching but isn't in ALL_METRICS (opt-in only)
+    const needsIssueFetch = fetchMetrics.length > 0 || hasFlow;
     // Parse groupBy
     const groupBy = (typeof args.groupBy === 'string' && VALID_GROUP_BY.includes(args.groupBy))
         ? args.groupBy
@@ -620,22 +738,24 @@ export async function handleAnalysisRequest(jiraClient, request) {
     // Cube setup — discover dimensions from sample, no issue fetching
     if (hasCubeSetup) {
         const cubeText = await handleCubeSetup(jiraClient, jql);
-        const nextSteps = analysisNextSteps(jql, []);
+        const nextSteps = analysisNextSteps(jql, [], false, undefined, filterSource);
+        const banner = filterSource ? `*Using saved filter: ${filterSource}*\n\n` : '';
         return {
             content: [{
                     type: 'text',
-                    text: cubeText + '\n' + nextSteps,
+                    text: banner + cubeText + '\n' + nextSteps,
                 }],
         };
     }
-    // If only summary requested, skip issue fetching entirely
-    if (hasSummary && fetchMetrics.length === 0) {
+    // If only summary requested (no flow or detail metrics), skip issue fetching entirely
+    if (hasSummary && !needsIssueFetch) {
         const summaryText = await handleSummary(jiraClient, jql, groupBy, compute, groupLimit);
-        const nextSteps = analysisNextSteps(jql, [], false, groupBy);
+        const nextSteps = analysisNextSteps(jql, [], false, groupBy, filterSource);
+        const banner = filterSource ? `*Using saved filter: ${filterSource}*\n\n` : '';
         return {
             content: [{
                     type: 'text',
-                    text: summaryText + '\n' + nextSteps,
+                    text: banner + summaryText + '\n' + nextSteps,
                 }],
         };
     }
@@ -676,13 +796,17 @@ export async function handleAnalysisRequest(jiraClient, request) {
     }
     const now = new Date();
     const lines = [];
+    if (filterSource) {
+        lines.push(`*Using saved filter: ${filterSource}*`);
+        lines.push('');
+    }
     // Summary first if requested alongside other metrics
     if (hasSummary) {
         const summaryText = await handleSummary(jiraClient, jql, groupBy, compute, groupLimit);
         lines.push(summaryText);
     }
     // Header for fetch-based metrics
-    if (fetchMetrics.length > 0 && allIssues.length > 0) {
+    if ((fetchMetrics.length > 0 || hasFlow) && allIssues.length > 0) {
         if (hasSummary)
             lines.push('');
         lines.push(`# Detail: ${jql}`);
@@ -703,8 +827,13 @@ export async function handleAnalysisRequest(jiraClient, request) {
             lines.push(renderers[metric]());
         }
     }
+    // Flow is opt-in and requires async bulk changelog fetch
+    if (hasFlow && allIssues.length > 0) {
+        lines.push('');
+        lines.push(await renderFlow(jiraClient, allIssues));
+    }
     // Next steps
-    const nextSteps = analysisNextSteps(jql, allIssues.slice(0, 3).map(i => i.key), truncated, groupBy);
+    const nextSteps = analysisNextSteps(jql, allIssues.slice(0, 3).map(i => i.key), truncated, groupBy, filterSource);
     lines.push(nextSteps);
     return {
         content: [{

package/build/prompts/prompt-messages.js

@@ -10,40 +10,50 @@ const builders = {
     backlog_health({ project }) {
         return {
             description: `Backlog health check for ${project}`,
-            messages: [msg(`Analyze backlog health for project ${project}. Use the analyze_jira_issues and manage_jira_filter tools.
+            messages: [msg(`Analyze backlog health for project ${project}. Use the queue_jira_operations tool to run this as a pipeline.
 
-Step 1 — Summary with data quality signals:
-{"jql":"project = ${project} AND resolution = Unresolved","metrics":["summary"],"groupBy":"priority","compute":["rot_pct = backlog_rot / open * 100","stale_pct = stale / open * 100","gap_pct = no_estimate / open * 100"]}
+Use queue_jira_operations with this pipeline:
+Operation 0 — Save the query as a reusable filter:
+{"tool":"manage_jira_filter","args":{"operation":"create","name":"${project} backlog health","jql":"project = ${project} AND resolution = Unresolved"}}
 
-Step 2 — Cycle metrics for staleness distribution and status age:
-{"jql":"project = ${project} AND resolution = Unresolved","metrics":["cycle"],"maxResults":100}
+Operation 1 — Summary with data quality signals (uses $0.filterId):
+{"tool":"analyze_jira_issues","args":{"filterId":"$0.filterId","metrics":["summary"],"groupBy":"priority","compute":["rot_pct = backlog_rot / open * 100","stale_pct = stale / open * 100","gap_pct = no_estimate / open * 100"]}}
 
-Step 3 — Summarize findings:
+Operation 2 — Flow analysis for transition patterns and bottlenecks:
+{"tool":"analyze_jira_issues","args":{"filterId":"$0.filterId","metrics":["flow"],"maxResults":100}}
+
+After the pipeline completes, summarize findings:
 - What percentage of the backlog is rotting (no owner, no dates, untouched)?
 - What's stuck in the same status for 30+ days?
 - What's missing estimates or start dates?
 - Flag the worst offenders by issue key.
-- Recommend specific triage actions.`)],
+- Recommend specific triage actions.
+- The saved filter can be reused for follow-up analysis or shared with the team.`)],
         };
     },
     contributor_workload({ project }) {
         return {
             description: `Contributor workload for ${project}`,
-            messages: [msg(`Analyze contributor workload for project ${project}. Use the analyze_jira_issues tool.
+            messages: [msg(`Analyze contributor workload for project ${project}. Use queue_jira_operations to run the analysis pipeline in a single call.
+
+Use queue_jira_operations with this pipeline:
+Operation 0 — Save the base query as a filter:
+{"tool":"manage_jira_filter","args":{"operation":"create","name":"${project} workload","jql":"project = ${project} AND resolution = Unresolved"}}
 
-Step 1 — Assignee distribution with quality signals:
-{"jql":"project = ${project} AND resolution = Unresolved","metrics":["summary"],"groupBy":"assignee","compute":["stale_pct = stale / open * 100","blocked_pct = blocked / open * 100"]}
+Operation 1 — Assignee distribution with quality signals (uses $0.filterId):
+{"tool":"analyze_jira_issues","args":{"filterId":"$0.filterId","metrics":["summary"],"groupBy":"assignee","compute":["stale_pct = stale / open * 100","blocked_pct = blocked / open * 100"]}}
 
-Step 2 — For the top 3 assignees by open issue count, run scoped detail metrics:
+After the pipeline, for the top 3 assignees by open count, run scoped detail:
 {"jql":"project = ${project} AND resolution = Unresolved AND assignee = '{name}'","metrics":["cycle","schedule"]}
 
-This pattern keeps each detail query within the sample cap for precise results.
+This keeps each detail query within the sample cap for precise results.
 
-Step 3 — Summarize:
+Summarize:
 - Who has the most open work?
 - Who has the most stale or at-risk issues?
 - Are there load imbalances?
-- What needs reassignment or triage?`)],
+- What needs reassignment or triage?
+- The saved filter can be reused for follow-up workload checks.`)],
         };
     },
     sprint_review({ board_id }) {
@@ -52,16 +62,21 @@ Step 3 — Summarize:
             messages: [msg(`Prepare a sprint review for board ${board_id}. Use manage_jira_sprint and analyze_jira_issues tools.
 
 Step 1 — Find the active sprint:
-{"operation":"list","boardId":${board_id},"state":"active"}
+Use manage_jira_sprint: {"operation":"list","boardId":${board_id},"state":"active"}
+
+Step 2 — Use queue_jira_operations to run the analysis pipeline (use the sprint ID from step 1):
+Operation 0 — Save the sprint query as a filter:
+{"tool":"manage_jira_filter","args":{"operation":"create","name":"Sprint review board ${board_id}","jql":"sprint = {sprintId}"}}
 
-Step 2 — Analyze sprint issues (use the sprint ID from step 1):
-{"jql":"sprint = {sprintId}","metrics":["summary","points","schedule"],"compute":["done_pct = resolved_7d / total * 100"]}
+Operation 1 — Summary + velocity metrics:
+{"tool":"analyze_jira_issues","args":{"filterId":"$0.filterId","metrics":["summary","points","schedule"],"compute":["done_pct = resolved_7d / total * 100"]}}
 
 Step 3 — Summarize:
 - Current velocity vs planned
 - Scope changes (items added/removed mid-sprint)
 - At-risk items (overdue, blocked, stale)
-- Completion forecast — will the sprint goal be met?`)],
+- Completion forecast — will the sprint goal be met?
+- The saved filter persists for daily standups or end-of-sprint reporting.`)],
         };
     },
     narrow_analysis({ jql }) {

package/build/schemas/tool-schemas.js

@@ -326,21 +326,25 @@ export const toolSchemas = {
     },
     analyze_jira_issues: {
         name: 'analyze_jira_issues',
-        description: 'Compute project metrics over issues selected by JQL. For counting and breakdown questions ("how many by status/assignee/priority"), use metrics: ["summary"] with groupBy — this gives exact counts with no issue cap. Use detail metrics (points, time, schedule, cycle, distribution) only when you need per-issue analysis; these are capped at maxResults issues. Always prefer this tool over manage_jira_filter or manage_jira_project for quantitative questions. Read jira://analysis/recipes for composition patterns.',
+        description: 'Compute project metrics over issues selected by JQL or a saved filter. For counting and breakdown questions ("how many by status/assignee/priority"), use metrics: ["summary"] with groupBy — this gives exact counts with no issue cap. Use detail metrics (points, time, schedule, cycle, distribution) for per-issue analysis (capped at maxResults). Use flow for status transition patterns — how issues move through statuses, where they bounce, and how long they stay. Tip: save complex JQL as a filter with manage_jira_filter, then reuse the filterId here for repeated analysis. Read jira://analysis/recipes for composition patterns.',
         inputSchema: {
             type: 'object',
             properties: {
                 jql: {
                     type: 'string',
-                    description: 'JQL query selecting the issues to analyze. Examples: "project in (AA, GC, LGS)", "sprint in openSprints()", "assignee = currentUser() AND resolution = Unresolved".',
+                    description: 'JQL query selecting the issues to analyze. Either jql or filterId is required (filterId takes precedence). Examples: "project in (AA, GC, LGS)", "sprint in openSprints()", "assignee = currentUser() AND resolution = Unresolved".',
+                },
+                filterId: {
+                    type: 'string',
+                    description: 'ID of a saved Jira filter to use as the query source. The filter\'s JQL is resolved automatically. Use this to run different analyses against a saved query without repeating the JQL. Create filters with manage_jira_filter.',
                 },
                 metrics: {
                     type: 'array',
                     items: {
                         type: 'string',
-                        enum: ['summary', 'points', 'time', 'schedule', 'cycle', 'distribution', 'cube_setup'],
+                        enum: ['summary', 'points', 'time', 'schedule', 'cycle', 'distribution', 'flow', 'cube_setup'],
                     },
-                    description: 'Which metric groups to compute. summary = exact counts via count API (no issue cap, fastest) — use with groupBy for "how many by assignee/status/priority" questions. distribution = approximate counts from fetched issues (capped by maxResults — use summary + groupBy instead when you need exact counts). cube_setup = discover dimensions before cube queries. points = earned value/SPI. time = effort estimates. schedule = overdue/risk. cycle = lead time/throughput. Default: all detail metrics. For counting/breakdown questions, always prefer summary + groupBy over distribution.',
+                    description: 'Which metric groups to compute. summary = exact counts via count API (no issue cap, fastest) — use with groupBy for "how many by assignee/status/priority" questions. distribution = approximate counts from fetched issues (capped by maxResults — use summary + groupBy instead when you need exact counts). flow = status transition analysis from bulk changelogs — entries per status, avg time in each, bounce rates, top bouncers. cube_setup = discover dimensions before cube queries. points = earned value/SPI. time = effort estimates. schedule = overdue/risk. cycle = lead time/throughput. Default: all detail metrics (excluding flow — request flow explicitly). For counting/breakdown questions, always prefer summary + groupBy over distribution.',
                 },
                 groupBy: {
                     type: 'string',
@@ -364,12 +368,12 @@ export const toolSchemas = {
                     default: 100,
                 },
             },
-            required: ['jql'],
+            required: [],
         },
     },
     queue_jira_operations: {
         name: 'queue_jira_operations',
-        description: 'Execute multiple Jira operations in a single call. Operations run sequentially with result references ($0.key) and per-operation error strategies (bail/continue).',
+        description: 'Execute multiple Jira operations in a single call. Operations run sequentially with result references ($0.key) and per-operation error strategies (bail/continue). Powerful for analysis pipelines: create a filter, then run multiple analyze_jira_issues calls against $0.filterId with different groupBy/compute — all in one call.',
         inputSchema: {
             type: 'object',
             properties: {

package/build/utils/next-steps.js

@@ -61,7 +61,7 @@ export function filterNextSteps(operation, filterId, jql) {
             steps.push({ description: 'Run a filter', tool: 'manage_jira_filter', example: { operation: 'execute_filter', filterId: '<id>' } }, { description: 'Search with JQL directly', tool: 'manage_jira_filter', example: { operation: 'execute_jql', jql: '<query>' } });
             break;
         case 'create':
-            steps.push({ description: 'Execute the new filter', tool: 'manage_jira_filter', example: { operation: 'execute_filter', filterId } });
+            steps.push({ description: 'Execute the new filter', tool: 'manage_jira_filter', example: { operation: 'execute_filter', filterId } }, { description: 'Run analysis against this filter', tool: 'analyze_jira_issues', example: { filterId, metrics: ['summary'], groupBy: 'assignee' } });
             break;
     }
     return steps.length > 0 ? formatSteps(steps) : '';
@@ -125,7 +125,7 @@ export function boardNextSteps(operation, boardId) {
     }
     return steps.length > 0 ? formatSteps(steps) : '';
 }
-export function analysisNextSteps(jql, issueKeys, truncated = false, groupBy) {
+export function analysisNextSteps(jql, issueKeys, truncated = false, groupBy, filterSource) {
     const steps = [];
     if (issueKeys.length > 0) {
         steps.push({ description: 'Get details on a specific issue', tool: 'manage_jira_issue', example: { operation: 'get', issueKey: issueKeys[0] } });
@@ -144,5 +144,9 @@ export function analysisNextSteps(jql, issueKeys, truncated = false, groupBy) {
     if (truncated) {
         steps.push({ description: 'Distribution counts above are approximate (issue cap hit). For exact breakdowns use summary + groupBy', tool: 'analyze_jira_issues', example: { jql, metrics: ['summary'], groupBy: 'assignee' } }, { description: 'Or narrow JQL for precise detail metrics', tool: 'analyze_jira_issues', example: { jql: `${jql} AND assignee = currentUser()`, metrics: ['cycle'] } });
     }
+    // Suggest saving as filter if not already using one
+    if (!filterSource) {
+        steps.push({ description: 'Save this query as a filter for reuse across analyses', tool: 'manage_jira_filter', example: { operation: 'create', name: '<descriptive name>', jql } });
+    }
     return formatSteps(steps) + '\n- Read `jira://analysis/recipes` for data cube patterns and compute DSL examples';
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aaronsb/jira-cloud-mcp",
-  "version": "0.5.9",
+  "version": "0.5.11",
   "mcpName": "io.github.aaronsb/jira-cloud",
   "description": "Model Context Protocol (MCP) server for Jira Cloud - enables AI assistants to interact with Jira",
   "type": "module",