@aaronsb/jira-cloud-mcp 0.8.1 → 0.9.0

package/build/client/graphql-client.js

@@ -57,22 +57,42 @@ export async function discoverCloudId(host, email, apiToken) {
 export class GraphQLClient {
     authHeader;
     cloudId;
-    constructor(email, apiToken, cloudId) {
+    tenantedEndpoint;
+    constructor(email, apiToken, cloudId, host) {
         this.authHeader = buildAuthHeader(email, apiToken);
         this.cloudId = cloudId;
+        this.tenantedEndpoint = host
+            ? `https://${extractHostname(host)}/gateway/api/graphql`
+            : null;
     }
     getCloudId() {
         return this.cloudId;
     }
+    /** Site container ARI for Townsquare queries */
+    getSiteAri() {
+        return `ari:cloud:townsquare::site/${this.cloudId}`;
+    }
     async query(query, variables = {}) {
+        return this._fetch(AGG_ENDPOINT, query, variables, {
+            'X-ExperimentalApi': 'JiraPlan,JiraPlansSupport',
+        });
+    }
+    /** Query the tenanted endpoint ({host}/gateway/api/graphql) for site-scoped APIs like Townsquare */
+    async queryTenanted(query, variables = {}) {
+        if (!this.tenantedEndpoint) {
+            return { success: false, error: 'Tenanted endpoint not available (no host configured)' };
+        }
+        return this._fetch(this.tenantedEndpoint, query, variables);
+    }
+    async _fetch(endpoint, query, variables, extraHeaders) {
         try {
-            const response = await fetch(AGG_ENDPOINT, {
+            const response = await fetch(endpoint, {
                 method: 'POST',
                 headers: {
                     'Authorization': this.authHeader,
                     'Content-Type': 'application/json',
                     'Accept': 'application/json',
-                    'X-ExperimentalApi': 'JiraPlan,JiraPlansSupport',
+                    ...extraHeaders,
                 },
                 body: JSON.stringify({
                     query,

package/build/client/graphql-goals.js

@@ -0,0 +1,398 @@
+// --- Queries ---
+const GOALS_SEARCH_QUERY = `
+  query GoalsSearch($containerId: ID!, $searchString: String!, $sort: [TownsquareGoalSortEnum], $first: Int, $after: String) {
+    goals_search(containerId: $containerId, searchString: $searchString, sort: $sort, first: $first, after: $after) {
+      edges {
+        node {
+          id
+          name
+          key
+          url
+          state { value label }
+          owner { name }
+          parentGoal { name key }
+          subGoals(first: 50) {
+            edges { node { name key state { value } } }
+          }
+          workItems(first: 50) @optIn(to: "GraphStoreJiraEpicContributesToAtlasGoal") {
+            edges { node { ... on JiraIssue { key } } }
+          }
+        }
+      }
+      pageInfo {
+        hasNextPage
+        endCursor
+      }
+    }
+  }
+`;
+const GOAL_BY_KEY_QUERY = `
+  query GoalByKey($containerId: ID!, $goalKey: String!) {
+    goals_byKey(containerId: $containerId, goalKey: $goalKey) {
+      id
+      name
+      key
+      url
+      state { value label }
+      owner { name }
+      parentGoal { name key }
+      description
+      subGoals(first: 50) {
+        edges {
+          node {
+            id name key url
+            state { value label }
+            owner { name }
+            parentGoal { name key }
+            description
+          }
+        }
+      }
+      projects(first: 20) {
+        edges { node { name state { value } } }
+      }
+      workItems(first: 100) @optIn(to: "GraphStoreJiraEpicContributesToAtlasGoal") {
+        edges {
+          node {
+            ... on JiraIssue {
+              key
+              summary
+              status { name }
+              issueType { name }
+            }
+          }
+        }
+      }
+    }
+  }
+`;
+// --- Helpers ---
+/** Extract plain text from an ADF JSON string or return as-is if not ADF */
+function extractAdfText(raw) {
+    if (!raw)
+        return null;
+    try {
+        const doc = JSON.parse(raw);
+        if (doc?.type !== 'doc' || !Array.isArray(doc.content))
+            return raw;
+        return extractTextFromNodes(doc.content).trim() || null;
+    }
+    catch {
+        return raw;
+    }
+}
+function extractTextFromNodes(nodes) {
+    let text = '';
+    for (const node of nodes) {
+        if (node.text)
+            text += node.text;
+        if (Array.isArray(node.content))
+            text += extractTextFromNodes(node.content);
+        if (node.type === 'paragraph' || node.type === 'heading')
+            text += '\n';
+        if (node.type === 'hardBreak')
+            text += '\n';
+        if (node.type === 'listItem')
+            text += '- ';
+    }
+    return text;
+}
+/** Wrap plain text in ADF document format (required for Townsquare description/summary fields) */
+function toAdf(text) {
+    return JSON.stringify({
+        version: 1, type: 'doc',
+        content: [{ type: 'paragraph', content: [{ type: 'text', text }] }],
+    });
+}
+// --- Functions ---
+export async function searchGoals(client, searchString, sort = 'HIERARCHY_ASC', first = 50) {
+    const result = await client.queryTenanted(GOALS_SEARCH_QUERY, {
+        containerId: client.getSiteAri(),
+        searchString,
+        sort: [sort],
+        first,
+    });
+    if (!result.success || !result.data) {
+        return { success: false, error: result.error ?? 'No data returned' };
+    }
+    const edges = result.data.goals_search.edges;
+    const goals = edges.map(e => ({
+        id: e.node.id,
+        name: e.node.name,
+        key: e.node.key,
+        url: e.node.url,
+        state: e.node.state,
+        owner: e.node.owner,
+        parentGoal: e.node.parentGoal,
+        description: null,
+    }));
+    const workItemCounts = new Map();
+    for (const e of edges) {
+        const count = e.node.workItems?.edges?.filter(w => w.node.key).length ?? 0;
+        workItemCounts.set(e.node.key, count);
+    }
+    return { success: true, goals, workItemCounts };
+}
+export async function getGoalByKey(client, goalKey) {
+    const result = await client.queryTenanted(GOAL_BY_KEY_QUERY, {
+        containerId: client.getSiteAri(),
+        goalKey,
+    });
+    if (!result.success || !result.data) {
+        return { success: false, error: result.error ?? 'No data returned' };
+    }
+    const node = result.data.goals_byKey;
+    if (!node) {
+        return { success: false, error: `Goal ${goalKey} not found` };
+    }
+    const goal = {
+        id: node.id,
+        name: node.name,
+        key: node.key,
+        url: node.url,
+        state: node.state,
+        owner: node.owner,
+        parentGoal: node.parentGoal,
+        description: extractAdfText(node.description),
+        subGoals: (node.subGoals?.edges ?? []).map(e => ({
+            id: e.node.id,
+            name: e.node.name,
+            key: e.node.key,
+            url: e.node.url,
+            state: e.node.state,
+            owner: e.node.owner,
+            parentGoal: e.node.parentGoal,
+            description: extractAdfText(e.node.description),
+        })),
+        projects: (node.projects?.edges ?? []).map(e => e.node),
+        workItems: (node.workItems?.edges ?? [])
+            .filter(e => e.node.key)
+            .map(e => ({
+            key: e.node.key,
+            summary: e.node.summary ?? '',
+            status: e.node.status ?? { name: 'Unknown' },
+            issueType: e.node.issueType ?? { name: 'Unknown' },
+        })),
+    };
+    return { success: true, goal };
+}
+/**
+ * Resolve all Jira issue keys linked to a goal and optionally its sub-goals.
+ * Returns keys suitable for a `key in (...)` JQL query.
+ */
+export async function resolveGoalWorkItems(client, goalKey, includeSubGoals = true) {
+    const result = await getGoalByKey(client, goalKey);
+    if (!result.success || !result.goal) {
+        return { success: false, error: result.error };
+    }
+    const goal = result.goal;
+    const issueKeys = new Set(goal.workItems.map(w => w.key));
+    if (includeSubGoals && goal.subGoals.length > 0) {
+        // Fetch each sub-goal's work items
+        const subResults = await Promise.all(goal.subGoals.map(sg => getGoalByKey(client, sg.key)));
+        for (const sub of subResults) {
+            if (sub.success && sub.goal) {
+                for (const w of sub.goal.workItems) {
+                    issueKeys.add(w.key);
+                }
+            }
+        }
+    }
+    return { success: true, issueKeys: [...issueKeys], goal };
+}
+// --- Mutations ---
+const GOAL_TYPES_QUERY = `
+  query GoalTypes($containerId: ID!) {
+    goals_goalTypes(containerId: $containerId) {
+      edges { node { id } }
+    }
+  }
+`;
+// Session-level cache for goal type ARIs
+let cachedGoalTypeIds = null;
+async function resolveGoalTypes(client) {
+    if (cachedGoalTypeIds)
+        return cachedGoalTypeIds;
+    const result = await client.queryTenanted(GOAL_TYPES_QUERY, { containerId: client.getSiteAri() });
+    if (!result.success || !result.data)
+        return [];
+    cachedGoalTypeIds = result.data.goals_goalTypes.edges.map(e => e.node.id);
+    return cachedGoalTypeIds;
+}
+/** Resolve goal type: first type for top-level goals, last type for sub-goals */
+async function resolveGoalType(client, hasParent) {
+    const types = await resolveGoalTypes(client);
+    if (types.length === 0)
+        return null;
+    return hasParent ? types[types.length - 1] : types[0];
+}
+const GOAL_CREATE_MUTATION = `
+  mutation CreateGoal($input: TownsquareGoalsCreateInput!) {
+    goals_create(input: $input) {
+      success
+      errors { message }
+      goal { id name key url state { value label } }
+    }
+  }
+`;
+const GOAL_EDIT_MUTATION = `
+  mutation EditGoal($input: TownsquareGoalsEditInput!) {
+    goals_edit(input: $input) {
+      goal { id name key url state { value label } isArchived }
+    }
+  }
+`;
+const GOAL_CREATE_UPDATE_MUTATION = `
+  mutation CreateGoalUpdate($input: TownsquareGoalsCreateUpdateInput!) {
+    goals_createUpdate(input: $input) {
+      success
+      errors { message }
+      update { id url creationDate }
+    }
+  }
+`;
+const GOAL_LINK_WORK_ITEM_MUTATION = `
+  mutation LinkWorkItem($input: TownsquareGoalsLinkWorkItemInput!) {
+    goals_linkWorkItem(input: $input) {
+      goal { id name key }
+    }
+  }
+`;
+const GOAL_UNLINK_WORK_ITEM_MUTATION = `
+  mutation UnlinkWorkItem($input: TownsquareGoalsUnlinkWorkItemInput!) {
+    goals_unlinkWorkItem(input: $input) {
+      goal { id name key }
+    }
+  }
+`;
+/** Resolve a goal key to its ARI (needed for mutations) */
+async function resolveGoalId(client, goalKey) {
+    const result = await getGoalByKey(client, goalKey);
+    if (!result.success || !result.goal) {
+        return { success: false, error: result.error ?? `Goal ${goalKey} not found` };
+    }
+    return { success: true, goalId: result.goal.id };
+}
+export async function createGoal(client, opts) {
+    const hasParent = !!opts.parentGoalKey;
+    const goalTypeId = await resolveGoalType(client, hasParent);
+    if (!goalTypeId) {
+        return { success: false, error: 'Could not discover goal types for this instance. Goals may not be enabled.' };
+    }
+    const input = {
+        containerId: client.getSiteAri(),
+        name: opts.name,
+        goalTypeId,
+    };
+    if (opts.parentGoalKey) {
+        const parent = await resolveGoalId(client, opts.parentGoalKey);
+        if (!parent.success)
+            return { success: false, error: `Parent goal: ${parent.error}` };
+        input.parentGoalId = parent.goalId;
+    }
+    if (opts.targetDate) {
+        input.targetDate = { date: opts.targetDate, confidence: 'QUARTER' };
+    }
+    if (opts.description) {
+        input.description = toAdf(opts.description);
+    }
+    const result = await client.queryTenanted(GOAL_CREATE_MUTATION, { input });
+    if (!result.success || !result.data) {
+        return { success: false, error: result.error ?? 'Create failed' };
+    }
+    const mutation = result.data.goals_create;
+    if (!mutation.success || !mutation.goal) {
+        const msg = mutation.errors?.map(e => e.message).join('; ') ?? 'Unknown error';
+        return { success: false, error: msg };
+    }
+    return { success: true, goal: { name: mutation.goal.name, key: mutation.goal.key, url: mutation.goal.url } };
+}
+export async function editGoal(client, goalKey, opts) {
+    const resolved = await resolveGoalId(client, goalKey);
+    if (!resolved.success)
+        return { success: false, error: resolved.error };
+    const input = { goalId: resolved.goalId };
+    if (opts.name !== undefined)
+        input.name = opts.name;
+    if (opts.description !== undefined) {
+        input.description = toAdf(opts.description);
+    }
+    if (opts.targetDate !== undefined) {
+        input.targetDate = { date: opts.targetDate, confidence: 'QUARTER' };
+    }
+    if (opts.startDate !== undefined)
+        input.startDate = opts.startDate;
+    if (opts.archived !== undefined)
+        input.archived = opts.archived;
+    const result = await client.queryTenanted(GOAL_EDIT_MUTATION, { input });
+    if (!result.success)
+        return { success: false, error: result.error };
+    return { success: true };
+}
+export async function createGoalStatusUpdate(client, goalKey, status, summary) {
+    const resolved = await resolveGoalId(client, goalKey);
+    if (!resolved.success)
+        return { success: false, error: resolved.error };
+    const input = {
+        goalId: resolved.goalId,
+        status,
+    };
+    if (summary) {
+        input.summary = toAdf(summary);
+    }
+    const result = await client.queryTenanted(GOAL_CREATE_UPDATE_MUTATION, { input });
+    if (!result.success || !result.data) {
+        return { success: false, error: result.error ?? 'Status update failed' };
+    }
+    const mutation = result.data.goals_createUpdate;
+    if (!mutation.success) {
+        const msg = mutation.errors?.map(e => e.message).join('; ') ?? 'Status update failed (no error details)';
+        return { success: false, error: msg };
+    }
+    return { success: true };
+}
+const ISSUE_BY_KEY_QUERY = `
+  query IssueByKey($cloudId: ID!, $key: String!) {
+    jira { issueByKey(key: $key, cloudId: $cloudId) { id } }
+  }
+`;
+/** Resolve a Jira issue key to its ARI (needed for goal work item linking) */
+async function resolveIssueAri(client, issueKey) {
+    const result = await client.queryTenanted(ISSUE_BY_KEY_QUERY, { key: issueKey });
+    if (!result.success || !result.data?.jira?.issueByKey) {
+        return { success: false, error: `Issue ${issueKey} not found` };
+    }
+    return { success: true, issueAri: result.data.jira.issueByKey.id };
+}
+export async function linkWorkItem(client, goalKey, issueKey) {
+    const [resolved, issue] = await Promise.all([
+        resolveGoalId(client, goalKey),
+        resolveIssueAri(client, issueKey),
+    ]);
+    if (!resolved.success)
+        return { success: false, error: resolved.error };
+    if (!issue.success)
+        return { success: false, error: issue.error };
+    const result = await client.queryTenanted(GOAL_LINK_WORK_ITEM_MUTATION, {
+        input: { goalId: resolved.goalId, workItemId: issue.issueAri },
+    });
+    if (!result.success)
+        return { success: false, error: result.error };
+    return { success: true };
+}
+export async function unlinkWorkItem(client, goalKey, issueKey) {
+    const [resolved, issue] = await Promise.all([
+        resolveGoalId(client, goalKey),
+        resolveIssueAri(client, issueKey),
+    ]);
+    if (!resolved.success)
+        return { success: false, error: resolved.error };
+    if (!issue.success)
+        return { success: false, error: issue.error };
+    const result = await client.queryTenanted(GOAL_UNLINK_WORK_ITEM_MUTATION, {
+        input: { goalId: resolved.goalId, workItemId: issue.issueAri },
+    });
+    if (!result.success)
+        return { success: false, error: result.error };
+    return { success: true };
+}

package/build/handlers/analysis-handler.js

@@ -742,7 +742,7 @@ async function renderHierarchy(issues, graphqlClient) {
         }
     }
     if (parentKeys.size > MAX_HIERARCHY_ROOTS) {
-        lines.push('', `*Showing ${MAX_HIERARCHY_ROOTS} of ${parentKeys.size} root issues. Use analyze_jira_plan for a focused subtree.*`);
+        lines.push('', `*Showing ${MAX_HIERARCHY_ROOTS} of ${parentKeys.size} root issues. Use manage_jira_plan for a focused subtree.*`);
     }
     return lines.join('\n');
 }
@@ -858,11 +858,11 @@ export async function handleAnalysisRequest(jiraClient, request, graphqlClient,
     const dataRef = args.dataRef;
     if (dataRef && typeof dataRef === 'string' && dataRef.trim() !== '') {
         if (!cache) {
-            throw new McpError(ErrorCode.InvalidParams, 'dataRef requires the graph object cache (start a walk with analyze_jira_plan first).');
+            throw new McpError(ErrorCode.InvalidParams, 'dataRef requires the graph object cache (start a walk with manage_jira_plan first).');
         }
         const cached = cache.get(dataRef);
         if (!cached) {
-            throw new McpError(ErrorCode.InvalidParams, `No cached walk for "${dataRef}". Start one with analyze_jira_plan first.`);
+            throw new McpError(ErrorCode.InvalidParams, `No cached walk for "${dataRef}". Start one with manage_jira_plan first.`);
         }
         if (cached.state === 'walking') {
             return {

package/build/handlers/plan-handler.js

@@ -1,16 +1,60 @@
 import { ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';
+import { searchGoals, getGoalByKey, resolveGoalWorkItems, createGoal, editGoal, createGoalStatusUpdate, linkWorkItem, unlinkWorkItem } from '../client/graphql-goals.js';
 import { GraphQLHierarchyWalker, collectLeaves, computeDepth, walkTree } from '../client/graphql-hierarchy.js';
-import { planNextSteps } from '../utils/next-steps.js';
+import { planNextSteps, goalNextSteps } from '../utils/next-steps.js';
 import { normalizeArgs } from '../utils/normalize-args.js';
 const ALL_ROLLUPS = ['dates', 'points', 'progress', 'assignees'];
 const MAX_CHILDREN_DISPLAY = 20;
 export async function handlePlanRequest(_jiraClient, graphqlClient, request, cache) {
     const args = normalizeArgs(request.params?.arguments ?? {});
+    const operation = args.operation ?? 'analyze';
+    const goalKey = args.goalKey;
+    // Goal operations
+    if (operation === 'list_goals') {
+        return handleListGoals(graphqlClient, args);
+    }
+    if (operation === 'get_goal') {
+        if (!goalKey)
+            throw new McpError(ErrorCode.InvalidParams, 'goalKey is required for get_goal');
+        return handleGetGoal(graphqlClient, goalKey);
+    }
+    if (goalKey && operation === 'analyze') {
+        return handleAnalyzeGoal(graphqlClient, goalKey, args, cache);
+    }
+    if (operation === 'create_goal') {
+        return handleCreateGoal(graphqlClient, args);
+    }
+    if (operation === 'update_goal') {
+        if (!goalKey)
+            throw new McpError(ErrorCode.InvalidParams, 'goalKey is required for update_goal');
+        return handleUpdateGoal(graphqlClient, goalKey, args);
+    }
+    if (operation === 'update_goal_status') {
+        if (!goalKey)
+            throw new McpError(ErrorCode.InvalidParams, 'goalKey is required for update_goal_status');
+        return handleUpdateGoalStatus(graphqlClient, goalKey, args);
+    }
+    if (operation === 'link_work_item') {
+        if (!goalKey)
+            throw new McpError(ErrorCode.InvalidParams, 'goalKey is required for link_work_item');
+        const issueKeyArg = args.issueKey;
+        if (!issueKeyArg)
+            throw new McpError(ErrorCode.InvalidParams, 'issueKey is required for link_work_item');
+        return handleLinkWorkItem(graphqlClient, goalKey, issueKeyArg);
+    }
+    if (operation === 'unlink_work_item') {
+        if (!goalKey)
+            throw new McpError(ErrorCode.InvalidParams, 'goalKey is required for unlink_work_item');
+        const issueKeyArg = args.issueKey;
+        if (!issueKeyArg)
+            throw new McpError(ErrorCode.InvalidParams, 'issueKey is required for unlink_work_item');
+        return handleUnlinkWorkItem(graphqlClient, goalKey, issueKeyArg);
+    }
+    // Issue operations require issueKey
     const issueKey = args.issueKey;
     if (!issueKey) {
-        throw new McpError(ErrorCode.InvalidParams, 'issueKey is required for analyze_jira_plan');
+        throw new McpError(ErrorCode.InvalidParams, 'issueKey or goalKey is required for manage_jira_plan');
     }
-    const operation = args.operation ?? 'analyze';
     // Handle release operation
     if (operation === 'release') {
         if (!cache) {
@@ -349,3 +393,264 @@ export function renderRollupTree(node, lines, rollups, prefix, isLast) {
         renderRollupTree(child, lines, rollups, childPrefix, i === node.children.length - 1);
     });
 }
+// --- Goal operations ---
+async function handleListGoals(graphqlClient, args) {
+    const searchString = args.searchString ?? '';
+    const sort = args.sort ?? 'HIERARCHY_ASC';
+    const result = await searchGoals(graphqlClient, searchString, sort);
+    if (!result.success || !result.goals) {
+        const error = result.error ?? 'Unknown error';
+        if (error.includes('not found') || error.includes('Cannot route')) {
+            return { content: [{ type: 'text', text: 'No goals found. Goals may not be enabled on this instance.' }] };
+        }
+        return { content: [{ type: 'text', text: `Goal search failed: ${error}` }], isError: true };
+    }
+    if (result.goals.length === 0) {
+        const hint = searchString.includes('status =')
+            ? '\n\n*Note: TQL status filtering may be incomplete for some values. Try without the status filter to see all goals.*'
+            : '';
+        return { content: [{ type: 'text', text: `No goals found for search: "${searchString}"${hint}` }] };
+    }
+    const lines = [];
+    lines.push(`# Goals (${result.goals.length})`);
+    lines.push('');
+    for (const goal of result.goals) {
+        const workCount = result.workItemCounts?.get(goal.key) ?? 0;
+        const indent = goal.parentGoal ? '  ' : '';
+        const stateIcon = goalStateIcon(goal.state.value);
+        const owner = goal.owner ? ` — ${goal.owner.name}` : '';
+        const workLabel = workCount > 0 ? ` | ${workCount} linked issues` : '';
+        lines.push(`${indent}${stateIcon} **${goal.key}**: ${goal.name} [${goal.state.label}]${owner}${workLabel}`);
+    }
+    lines.push('');
+    lines.push(goalNextSteps('list_goals'));
+    return { content: [{ type: 'text', text: lines.join('\n') }] };
+}
+async function handleGetGoal(graphqlClient, goalKey) {
+    const result = await getGoalByKey(graphqlClient, goalKey);
+    if (!result.success || !result.goal) {
+        return { content: [{ type: 'text', text: `Goal ${goalKey} not found: ${result.error ?? 'unknown error'}` }], isError: true };
+    }
+    const goal = result.goal;
+    const lines = [];
+    lines.push(`# Goal: ${goal.key} — ${goal.name}`);
+    lines.push(`**State:** ${goal.state.label} | **Owner:** ${goal.owner?.name ?? 'Unassigned'}`);
+    if (goal.parentGoal) {
+        lines.push(`**Parent:** ${goal.parentGoal.key} — ${goal.parentGoal.name}`);
+    }
+    if (goal.description) {
+        lines.push(`**Description:** ${goal.description}`);
+    }
+    lines.push('');
+    if (goal.subGoals.length > 0) {
+        lines.push(`## Sub-Goals (${goal.subGoals.length})`);
+        lines.push('');
+        for (const sg of goal.subGoals) {
+            const stateIcon = goalStateIcon(sg.state.value);
+            lines.push(`${stateIcon} **${sg.key}**: ${sg.name} [${sg.state.label}]`);
+        }
+        lines.push('');
+    }
+    if (goal.projects.length > 0) {
+        lines.push(`## Projects (${goal.projects.length})`);
+        lines.push('');
+        for (const p of goal.projects) {
+            lines.push(`- ${p.name} [${p.state.value}]`);
+        }
+        lines.push('');
+    }
+    if (goal.workItems.length > 0) {
+        lines.push(`## Linked Issues (${goal.workItems.length})`);
+        lines.push('');
+        for (const w of goal.workItems) {
+            lines.push(`- **${w.key}** [${w.issueType.name}] ${w.summary} — ${w.status.name}`);
+        }
+        lines.push('');
+    }
+    else {
+        lines.push('*No linked Jira issues.*');
+        lines.push('');
+    }
+    lines.push(goalNextSteps('get_goal', goalKey, goal.workItems.length));
+    return { content: [{ type: 'text', text: lines.join('\n') }] };
+}
+async function handleAnalyzeGoal(graphqlClient, goalKey, args, cache) {
+    const result = await resolveGoalWorkItems(graphqlClient, goalKey);
+    if (!result.success || !result.goal) {
+        return { content: [{ type: 'text', text: `Failed to resolve goal ${goalKey}: ${result.error ?? 'unknown error'}` }], isError: true };
+    }
+    const goal = result.goal;
+    const issueKeys = result.issueKeys ?? [];
+    if (issueKeys.length === 0) {
+        const lines = [];
+        lines.push(`# Goal: ${goal.key} — ${goal.name} [${goal.state.label}]`);
+        lines.push('');
+        lines.push('No linked Jira issues to analyze. Cannot resolve linked Jira issues — the workItems API may have changed, or no issues are linked to this goal.');
+        lines.push('');
+        lines.push(goalNextSteps('analyze', goalKey, 0));
+        return { content: [{ type: 'text', text: lines.join('\n') }] };
+    }
+    // Goal context header
+    const header = [];
+    header.push(`# Goal: ${goal.key} — ${goal.name} [${goal.state.label}]`);
+    header.push(`**Owner:** ${goal.owner?.name ?? 'Unassigned'} | **Linked issues:** ${issueKeys.length}`);
+    if (goal.subGoals.length > 0) {
+        header.push(`**Sub-goals:** ${goal.subGoals.map(sg => `${sg.key} [${sg.state.value}]`).join(', ')}`);
+    }
+    header.push('');
+    // Walk each issue's hierarchy and compute rollups
+    const rollups = (Array.isArray(args.rollups) ? args.rollups : ALL_ROLLUPS);
+    // For goal analysis, walk each linked issue and merge results
+    const walker = new GraphQLHierarchyWalker(graphqlClient);
+    const allTrees = [];
+    const errors = [];
+    // Separate cached from uncached keys
+    const uncachedKeys = [];
+    for (const key of issueKeys) {
+        if (cache) {
+            const status = cache.getStatus(key);
+            if (status.state === 'complete' || status.state === 'stale') {
+                allTrees.push(cache.get(key).tree);
+                continue;
+            }
+        }
+        uncachedKeys.push(key);
+    }
+    // Walk uncached keys in parallel
+    const walkResults = await Promise.allSettled(uncachedKeys.map(key => walker.walkDown(key)));
+    for (let i = 0; i < walkResults.length; i++) {
+        const result = walkResults[i];
+        if (result.status === 'fulfilled') {
+            allTrees.push(result.value.tree);
+        }
+        else {
+            errors.push(uncachedKeys[i]);
+        }
+    }
+    if (allTrees.length === 0) {
+        header.push('All issue hierarchy walks failed. The linked issues may not be accessible.');
+        if (errors.length > 0)
+            header.push(`Failed keys: ${errors.join(', ')}`);
+        return { content: [{ type: 'text', text: header.join('\n') }] };
+    }
+    // Render each tree's rollup as a summary line
+    header.push(`## Issue Rollups (${allTrees.length} of ${issueKeys.length} resolved)`);
+    if (errors.length > 0) {
+        header.push(`*${errors.length} issues could not be walked: ${errors.join(', ')}*`);
+    }
+    header.push('');
+    let totalResolved = 0;
+    let totalItems = 0;
+    let totalPoints = 0;
+    let earnedPoints = 0;
+    for (const tree of allTrees) {
+        const rollup = GraphQLHierarchyWalker.computeRollups(tree);
+        totalResolved += rollup.resolvedItems;
+        totalItems += rollup.totalItems;
+        totalPoints += rollup.totalPoints;
+        earnedPoints += rollup.earnedPoints;
+        renderNodeLine(tree, header, rollups);
+    }
+    header.push('');
+    header.push('## Aggregate');
+    if (rollups.includes('progress')) {
+        const pct = totalItems > 0 ? Math.round(totalResolved / totalItems * 100) : 0;
+        header.push(`**Progress:** ${totalResolved}/${totalItems} resolved (${pct}%)`);
+    }
+    if (rollups.includes('points') && totalPoints > 0) {
+        header.push(`**Points:** ${earnedPoints}/${totalPoints} earned`);
+    }
+    header.push('');
+    header.push(goalNextSteps('analyze', goalKey, issueKeys.length));
+    return { content: [{ type: 'text', text: header.join('\n') }] };
+}
+function goalStateIcon(state) {
+    switch (state) {
+        case 'done': return '✓';
+        case 'on_track': return '●';
+        case 'at_risk': return '⚠';
+        case 'off_track': return '✗';
+        default: return '○';
+    }
+}
+// --- Goal mutations ---
+async function handleCreateGoal(graphqlClient, args) {
+    const name = args.name;
+    if (!name)
+        throw new McpError(ErrorCode.InvalidParams, 'name is required for create_goal');
+    const result = await createGoal(graphqlClient, {
+        name,
+        description: args.description,
+        parentGoalKey: args.parentGoalKey,
+        targetDate: args.targetDate,
+    });
+    if (!result.success || !result.goal) {
+        return { content: [{ type: 'text', text: `Failed to create goal: ${result.error}` }], isError: true };
+    }
+    const goal = result.goal;
+    const lines = [
+        `Goal created: **${goal.key}** — ${goal.name}`,
+        `URL: ${goal.url}`,
+        '',
+        goalNextSteps('create_goal', goal.key),
+    ];
+    return { content: [{ type: 'text', text: lines.join('\n') }] };
+}
+async function handleUpdateGoal(graphqlClient, goalKey, args) {
+    const result = await editGoal(graphqlClient, goalKey, {
+        name: args.name,
+        description: args.description,
+        targetDate: args.targetDate,
+        startDate: args.startDate,
+        archived: args.archived,
+    });
+    if (!result.success) {
+        return { content: [{ type: 'text', text: `Failed to update goal ${goalKey}: ${result.error}` }], isError: true };
+    }
+    const lines = [
+        `Goal ${goalKey} updated.`,
+        '',
+        goalNextSteps('update_goal', goalKey),
+    ];
+    return { content: [{ type: 'text', text: lines.join('\n') }] };
+}
+async function handleUpdateGoalStatus(graphqlClient, goalKey, args) {
+    const status = args.status;
+    if (!status)
+        throw new McpError(ErrorCode.InvalidParams, 'status is required for update_goal_status');
+    const result = await createGoalStatusUpdate(graphqlClient, goalKey, status, args.summary);
+    if (!result.success) {
+        return { content: [{ type: 'text', text: `Failed to update status for ${goalKey}: ${result.error}` }], isError: true };
+    }
+    const lines = [
+        `Goal ${goalKey} status updated to **${status}**.`,
+        args.summary ? `Summary: ${args.summary}` : '',
+        '',
+        goalNextSteps('update_goal_status', goalKey),
+    ].filter(Boolean);
+    return { content: [{ type: 'text', text: lines.join('\n') }] };
+}
+async function handleLinkWorkItem(graphqlClient, goalKey, issueKey) {
+    const result = await linkWorkItem(graphqlClient, goalKey, issueKey);
+    if (!result.success) {
+        return { content: [{ type: 'text', text: `Failed to link ${issueKey} to goal ${goalKey}: ${result.error}` }], isError: true };
+    }
+    const lines = [
+        `Linked **${issueKey}** to goal **${goalKey}**.`,
+        '',
+        goalNextSteps('link_work_item', goalKey),
+    ];
+    return { content: [{ type: 'text', text: lines.join('\n') }] };
+}
+async function handleUnlinkWorkItem(graphqlClient, goalKey, issueKey) {
+    const result = await unlinkWorkItem(graphqlClient, goalKey, issueKey);
+    if (!result.success) {
+        return { content: [{ type: 'text', text: `Failed to unlink ${issueKey} from goal ${goalKey}: ${result.error}` }], isError: true };
+    }
+    const lines = [
+        `Unlinked **${issueKey}** from goal **${goalKey}**.`,
+        '',
+        goalNextSteps('unlink_work_item', goalKey),
+    ];
+    return { content: [{ type: 'text', text: lines.join('\n') }] };
+}

package/build/handlers/resource-handlers.js

@@ -2,12 +2,14 @@ import { McpError, ErrorCode } from '@modelcontextprotocol/sdk/types.js';
 import { setupToolResourceHandlers } from './tool-resource-handlers.js';
 import { fieldDiscovery } from '../client/field-discovery.js';
 import { categoryLabel } from '../client/field-type-map.js';
+import { searchGoals } from '../client/graphql-goals.js';
 /**
  * Sets up resource handlers for the Jira MCP server
  * @param jiraClient The Jira client instance
+ * @param graphqlClient Optional GraphQL client for Townsquare goals
  * @returns Object containing resource handlers
  */
-export function setupResourceHandlers(jiraClient) {
+export function setupResourceHandlers(jiraClient, graphqlClient) {
     const toolResourceHandler = setupToolResourceHandlers();
     return {
         /**
@@ -87,7 +89,7 @@ export function setupResourceHandlers(jiraClient) {
             try {
                 // Handle static resources
                 if (uri === 'jira://instance/summary') {
-                    return await getInstanceSummary(jiraClient);
+                    return await getInstanceSummary(jiraClient, graphqlClient);
                 }
                 if (uri === 'jira://projects/distribution') {
                     return await getProjectDistribution(jiraClient);
@@ -139,7 +141,7 @@ export function setupResourceHandlers(jiraClient) {
 /**
  * Gets a summary of the Jira instance
  */
-async function getInstanceSummary(jiraClient) {
+async function getInstanceSummary(jiraClient, graphqlClient) {
     try {
         // Get projects
         const projects = await jiraClient.listProjects();
@@ -157,6 +159,29 @@ async function getInstanceSummary(jiraClient) {
                 timestamp: new Date().toISOString()
             }
         };
+        // Fetch goal summary counts if GraphQL client is available
+        if (graphqlClient) {
+            try {
+                const result = await searchGoals(graphqlClient, '', 'HIERARCHY_ASC', 200);
+                if (result.success && result.goals && result.goals.length > 0) {
+                    const goals = result.goals;
+                    const stateCounts = {};
+                    for (const g of goals) {
+                        stateCounts[g.state.value] = (stateCounts[g.state.value] ?? 0) + 1;
+                    }
+                    const themes = goals.filter(g => !g.parentGoal).length;
+                    summary.goals = {
+                        total: goals.length,
+                        themes,
+                        ...stateCounts,
+                        hint: 'Use manage_jira_plan with operation list_goals to explore the goal tree',
+                    };
+                }
+            }
+            catch {
+                // Goals not available on this instance — skip silently
+            }
+        }
         return {
             contents: [
                 {

package/build/index.js

@@ -102,7 +102,7 @@ class JiraServer {
             }
         }).catch(() => { });
         // CloudId discovery happens in run() before server connects — must complete
-        // before ListTools so analyze_jira_plan is registered if available.
+        // before ListTools so manage_jira_plan is registered if available.
         this.server.onerror = (error) => console.error('[MCP Error]', error);
         process.on('SIGINT', async () => {
             await this.server.close();
@@ -113,7 +113,7 @@ class JiraServer {
         // Set up required MCP protocol handlers
         this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
             tools: Object.entries(toolSchemas)
-                .filter(([key]) => key !== 'analyze_jira_plan' || this.graphqlClient !== null)
+                .filter(([key]) => key !== 'manage_jira_plan' || this.graphqlClient !== null)
                 .map(([key, schema]) => ({
                 name: key,
                 description: schema.description,
@@ -125,7 +125,7 @@ class JiraServer {
             })),
         }));
         // Set up resource handlers
-        const resourceHandlers = setupResourceHandlers(this.jiraClient);
+        const resourceHandlers = setupResourceHandlers(this.jiraClient, this.graphqlClient);
         this.server.setRequestHandler(ListResourcesRequestSchema, resourceHandlers.listResources);
         this.server.setRequestHandler(ListResourceTemplatesRequestSchema, resourceHandlers.listResourceTemplates);
         this.server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
@@ -165,7 +165,7 @@ class JiraServer {
                     ...toolHandlers,
                     queue_jira_operations: createQueueHandler(toolHandlers, JIRA_HOST),
                     ...(this.graphqlClient ? {
-                        analyze_jira_plan: (_client, req) => handlePlanRequest(this.jiraClient, this.graphqlClient, req, this.cache),
+                        manage_jira_plan: (_client, req) => handlePlanRequest(this.jiraClient, this.graphqlClient, req, this.cache),
                     } : {}),
                 };
                 const handler = handlers[name];
@@ -293,15 +293,15 @@ class JiraServer {
         try {
             const cloudId = await discoverCloudId(JIRA_HOST, JIRA_EMAIL, JIRA_API_TOKEN);
             if (cloudId) {
-                this.graphqlClient = new GraphQLClient(JIRA_EMAIL, JIRA_API_TOKEN, cloudId);
+                this.graphqlClient = new GraphQLClient(JIRA_EMAIL, JIRA_API_TOKEN, cloudId, JIRA_HOST);
                 console.error(`[jira-cloud] GraphQL client ready (cloudId: ${cloudId.slice(0, 8)}...)`);
             }
             else {
-                console.error('[jira-cloud] GraphQL/Plans unavailable — analyze_jira_plan disabled');
+                console.error('[jira-cloud] GraphQL/Plans unavailable — manage_jira_plan disabled');
             }
         }
         catch {
-            console.error('[jira-cloud] GraphQL discovery failed — analyze_jira_plan disabled');
+            console.error('[jira-cloud] GraphQL discovery failed — manage_jira_plan disabled');
         }
         const transport = new StdioServerTransport();
         await this.server.connect(transport);

package/build/schemas/tool-schemas.js

@@ -373,7 +373,7 @@ export const toolSchemas = {
                 },
                 dataRef: {
                     type: 'string',
-                    description: 'Root issue key of a cached hierarchy walk. Analyzes cached plan data without re-fetching from Jira. Start a walk with analyze_jira_plan first. Supports all metrics except flow. Takes precedence over jql/filterId.',
+                    description: 'Root issue key of a cached hierarchy walk. Analyzes cached plan data without re-fetching from Jira. Start a walk with manage_jira_plan first. Supports all metrics except flow. Takes precedence over jql/filterId.',
                 },
                 metrics: {
                     type: 'array',
@@ -408,20 +408,66 @@ export const toolSchemas = {
             required: [],
         },
     },
-    analyze_jira_plan: {
-        name: 'analyze_jira_plan',
-        description: 'Analyze hierarchy rollups for any parent issue. Walks the issue tree via GraphQL, computes rolled-up dates, points, progress, assignees, and detects date conflicts. Results are cached server-side for fast re-analysis. Works on any Jira instance (no Plans/Premium required). For flat-set metrics use analyze_jira_issues (with dataRef to analyze cached plan data); for structure without rollups use manage_jira_issue hierarchy.',
+    manage_jira_plan: {
+        name: 'manage_jira_plan',
+        description: 'Navigate and manage the strategic-to-execution hierarchy. Walks issue trees and Atlassian Goals via GraphQL. Read: analyze rollups (dates, points, progress, conflicts), discover goals (list_goals), get goal detail (get_goal). Write: create/update goals, post status updates, link/unlink Jira issues to goals. Results cached server-side. For flat-set metrics use analyze_jira_issues; for structure without rollups use manage_jira_issue hierarchy.',
         inputSchema: {
             type: 'object',
             properties: {
                 operation: {
                     type: 'string',
-                    enum: ['analyze', 'release'],
-                    description: 'Operation to perform. analyze (default): walk hierarchy and compute rollups. release: free cached walk data for this issueKey.',
+                    enum: ['analyze', 'release', 'list_goals', 'get_goal', 'create_goal', 'update_goal', 'update_goal_status', 'link_work_item', 'unlink_work_item'],
+                    description: 'Operation to perform. analyze: walk hierarchy and compute rollups. release: free cached walk. list_goals: search goals. get_goal: goal detail. create_goal: create a goal. update_goal: edit goal name/description/dates/archive. update_goal_status: post a status update (on_track/off_track/done). link_work_item: link a Jira issue to a goal. unlink_work_item: unlink a Jira issue from a goal.',
                 },
                 issueKey: {
                     type: 'string',
-                    description: 'Issue key at the root of the plan tree (e.g., PROJ-100). Required.',
+                    description: 'Issue key at the root of the plan tree (e.g., PROJ-100). Required for analyze/release unless goalKey is provided. Also used with link_work_item/unlink_work_item to specify the Jira issue.',
+                },
+                goalKey: {
+                    type: 'string',
+                    description: 'Atlassian Goal key (e.g., PRAEC-25). Used for get_goal, analyze, update_goal, update_goal_status, link_work_item, unlink_work_item.',
+                },
+                name: {
+                    type: 'string',
+                    description: 'Goal name. Required for create_goal. Optional for update_goal (renames the goal).',
+                },
+                description: {
+                    type: 'string',
+                    description: 'Goal description text. For create_goal and update_goal.',
+                },
+                status: {
+                    type: 'string',
+                    enum: ['on_track', 'off_track', 'at_risk', 'done', 'pending', 'paused'],
+                    description: 'Goal status for update_goal_status.',
+                },
+                summary: {
+                    type: 'string',
+                    description: 'Status update summary text for update_goal_status. Describes what changed and why.',
+                },
+                parentGoalKey: {
+                    type: 'string',
+                    description: 'Parent goal key for create_goal. Makes the new goal a sub-goal of this parent.',
+                },
+                targetDate: {
+                    type: 'string',
+                    description: 'Target date in ISO format (YYYY-MM-DD) for create_goal and update_goal.',
+                },
+                startDate: {
+                    type: 'string',
+                    description: 'Start date in ISO format (YYYY-MM-DD) for update_goal.',
+                },
+                archived: {
+                    type: 'boolean',
+                    description: 'Set to true to archive a goal, false to unarchive. For update_goal.',
+                },
+                searchString: {
+                    type: 'string',
+                    description: 'TQL search string for list_goals. Examples: \'name LIKE "Health"\', \'status = on_track\'. Empty string returns all goals.',
+                },
+                sort: {
+                    type: 'string',
+                    enum: ['HIERARCHY_ASC', 'HIERARCHY_DESC', 'NAME_ASC', 'NAME_DESC', 'TARGET_DATE_ASC', 'TARGET_DATE_DESC', 'LATEST_UPDATE_DATE_ASC', 'LATEST_UPDATE_DATE_DESC'],
+                    description: 'Sort order for list_goals. Default: HIERARCHY_ASC (groups parents with children).',
                 },
                 rollups: {
                     type: 'array',
@@ -433,7 +479,7 @@ export const toolSchemas = {
                 },
                 focus: {
                     type: 'string',
-                    description: 'Issue key to focus on within the cached plan. Shows the node, its parent, siblings, and children — a windowed view for navigating large plans. Requires a completed walk.',
+                    description: 'Issue key to focus on within the cached plan. Windowed view for navigating large plans.',
                 },
                 mode: {
                     type: 'string',
@@ -441,7 +487,7 @@ export const toolSchemas = {
                     description: 'Output mode. rollup (default): summary + entry points. gaps: conflicts and missing data only.',
                 },
             },
-            required: ['issueKey'],
+            required: [],
         },
     },
     queue_jira_operations: {

package/build/utils/next-steps.js

@@ -42,7 +42,7 @@ export function issueNextSteps(operation, issueKey) {
             steps.push({ description: 'View the updated issue', tool: 'manage_jira_issue', example: { operation: 'get', issueKey } }, { description: 'Log more time', tool: 'manage_jira_issue', example: { operation: 'worklog', issueKey, timeSpent: '<duration>' } }, { description: 'Adjust the remaining estimate', tool: 'manage_jira_issue', example: { operation: 'update', issueKey, remainingEstimate: '<duration>' } });
             break;
         case 'hierarchy':
-            steps.push({ description: 'View a specific issue from the tree', tool: 'manage_jira_issue', example: { operation: 'get', issueKey } }, { description: 'Analyze plan rollups (requires Jira Plans)', tool: 'analyze_jira_plan', example: { issueKey } }, { description: 'Search for issues in this project', tool: 'manage_jira_filter', example: { operation: 'execute_jql', jql: `project = "${issueKey?.split('-')[0]}"` } });
+            steps.push({ description: 'View a specific issue from the tree', tool: 'manage_jira_issue', example: { operation: 'get', issueKey } }, { description: 'Analyze plan rollups (requires Jira Plans)', tool: 'manage_jira_plan', example: { issueKey } }, { description: 'Search for issues in this project', tool: 'manage_jira_filter', example: { operation: 'execute_jql', jql: `project = "${issueKey?.split('-')[0]}"` } });
             break;
     }
     return steps.length > 0 ? formatSteps(steps) : '';
@@ -132,10 +132,10 @@ export function planNextSteps(issueKey, mode, conflicts, rollup) {
     const steps = [];
     steps.push({ description: 'View the issue details', tool: 'manage_jira_issue', example: { operation: 'get', issueKey } }, { description: 'Explore the hierarchy tree', tool: 'manage_jira_issue', example: { operation: 'hierarchy', issueKey } });
     if (mode !== 'gaps') {
-        steps.push({ description: 'Check for data gaps and conflicts', tool: 'analyze_jira_plan', example: { issueKey, mode: 'gaps' } });
+        steps.push({ description: 'Check for data gaps and conflicts', tool: 'manage_jira_plan', example: { issueKey, mode: 'gaps' } });
     }
     if (mode !== 'timeline') {
-        steps.push({ description: 'View the timeline', tool: 'analyze_jira_plan', example: { issueKey, mode: 'timeline' } });
+        steps.push({ description: 'View the timeline', tool: 'manage_jira_plan', example: { issueKey, mode: 'timeline' } });
     }
     steps.push({ description: 'Run flat metrics on children', tool: 'analyze_jira_issues', example: { jql: `parent = ${issueKey}`, metrics: ['summary'], groupBy: 'assignee' } });
     let result = formatSteps(steps);
@@ -174,6 +174,39 @@ export function conflictFixSteps(conflicts, rollup) {
     }
     return lines.join('\n');
 }
+export function goalNextSteps(operation, goalKey, workItemCount) {
+    const steps = [];
+    switch (operation) {
+        case 'list_goals':
+            steps.push({ description: 'Get detail on a specific goal', tool: 'manage_jira_plan', example: { operation: 'get_goal', goalKey: 'GOAL-KEY' } }, { description: 'Analyze a goal\'s linked issues', tool: 'manage_jira_plan', example: { operation: 'analyze', goalKey: 'GOAL-KEY' } });
+            break;
+        case 'get_goal':
+            if (goalKey && workItemCount && workItemCount > 0) {
+                steps.push({ description: 'Analyze this goal\'s linked issues', tool: 'manage_jira_plan', example: { operation: 'analyze', goalKey } });
+            }
+            steps.push({ description: 'Search for more goals', tool: 'manage_jira_plan', example: { operation: 'list_goals', searchString: '' } });
+            break;
+        case 'analyze':
+            if (goalKey) {
+                steps.push({ description: 'View goal detail', tool: 'manage_jira_plan', example: { operation: 'get_goal', goalKey } }, { description: 'Update goal status', tool: 'manage_jira_plan', example: { operation: 'update_goal_status', goalKey, status: 'on_track', summary: 'Progress update' } });
+            }
+            break;
+        case 'create_goal':
+        case 'update_goal':
+        case 'update_goal_status':
+            if (goalKey) {
+                steps.push({ description: 'View updated goal', tool: 'manage_jira_plan', example: { operation: 'get_goal', goalKey } });
+            }
+            break;
+        case 'link_work_item':
+        case 'unlink_work_item':
+            if (goalKey) {
+                steps.push({ description: 'View goal with updated links', tool: 'manage_jira_plan', example: { operation: 'get_goal', goalKey } }, { description: 'Analyze goal progress', tool: 'manage_jira_plan', example: { operation: 'analyze', goalKey } });
+            }
+            break;
+    }
+    return steps.length > 0 ? formatSteps(steps) : '';
+}
 export function analysisNextSteps(jql, issueKeys, truncated = false, groupBy, filterSource) {
     const steps = [];
     if (issueKeys.length > 0) {
@@ -195,7 +228,7 @@ export function analysisNextSteps(jql, issueKeys, truncated = false, groupBy, fi
     }
     // Suggest plan analysis when issue keys suggest hierarchical structure
     if (issueKeys.length > 0) {
-        steps.push({ description: 'Analyze plan rollups for a parent issue (requires Jira Plans)', tool: 'analyze_jira_plan', example: { issueKey: issueKeys[0] } });
+        steps.push({ description: 'Analyze plan rollups for a parent issue (requires Jira Plans)', tool: 'manage_jira_plan', example: { issueKey: issueKeys[0] } });
     }
     // Suggest saving as filter if not already using one
     if (!filterSource) {

package/package.json

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