@aaronsb/jira-cloud-mcp 0.5.11 → 0.6.1

package/build/handlers/analysis-handler.js

@@ -1,10 +1,12 @@
 import { ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';
+import { GraphQLHierarchyWalker, walkTree } from '../client/graphql-hierarchy.js';
+import { renderRollupTree } from '../handlers/plan-handler.js';
 import { evaluateRow, extractColumnRefs, parseComputeList } from '../utils/cube-dsl.js';
 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'];
+// flow and hierarchy are opt-in only
+const VALID_GROUP_BY = ['project', 'assignee', 'priority', 'issuetype', 'parent', 'sprint'];
 const MAX_ISSUES_HARD = 500; // absolute ceiling for detail metrics — beyond this, context explodes
 const MAX_ISSUES_DEFAULT = 100;
 const CUBE_SAMPLE_PCT = 0.2; // 20% of total issues
@@ -270,6 +272,10 @@ export function renderDistribution(issues, groupLimit = DEFAULT_GROUP_LIMIT) {
     lines.push(`**By priority:** ${mapToString(byPriority, ' | ', groupLimit)}`);
     const byType = countBy(issues, i => i.issueType || 'Unknown');
     lines.push(`**By type:** ${mapToString(byType, ' | ', groupLimit)}`);
+    const bySprint = countBy(issues, i => i.sprint || '(no sprint)');
+    if (bySprint.size > 1 || !bySprint.has('(no sprint)')) {
+        lines.push(`**By sprint:** ${mapToString(bySprint, ' | ', groupLimit)}`);
+    }
     return lines.join('\n');
 }
 export async function renderFlow(jiraClient, issues) {
@@ -433,6 +439,10 @@ export function groupByJqlClause(dimension, values) {
             return values.map(v => `priority = "${v}"`);
         case 'issuetype':
             return values.map(v => `issuetype = "${v}"`);
+        case 'parent':
+            return values.map(v => v === '(no parent)' ? 'issue not in childIssuesOf("")' : `parent = ${v}`);
+        case 'sprint':
+            return values.map(v => v === '(no sprint)' ? 'sprint is EMPTY' : `sprint = "${v}"`);
     }
 }
 async function buildCountRow(jiraClient, label, baseJql, implicitMeasureNames, implicitMeasureDefs) {
@@ -592,6 +602,8 @@ export function extractDimensions(issues, groupLimit = DEFAULT_GROUP_LIMIT) {
         { name: 'assignee', extractor: i => i.assignee || 'Unassigned' },
         { name: 'priority', extractor: i => i.priority || 'None' },
         { name: 'issuetype', extractor: i => i.issueType || 'Unknown' },
+        { name: 'parent', extractor: i => i.parent || '(no parent)' },
+        { name: 'sprint', extractor: i => i.sprint || '(no sprint)' },
     ];
     return dims.map(({ name, extractor }) => {
         const counts = new Map();
@@ -684,9 +696,185 @@ async function handleCubeSetup(jiraClient, jql) {
     const dimensions = extractDimensions(issues);
     return renderCubeSetup(jql, issues.length, dimensions);
 }
+// ── Hierarchy Metric ──────────────────────────────────────────────────
+const MAX_HIERARCHY_ROOTS = 3;
+const HIERARCHY_MAX_DEPTH = 3;
+const HIERARCHY_MAX_ITEMS = 50;
+async function renderHierarchy(issues, graphqlClient) {
+    const lines = ['## Hierarchy Rollups'];
+    // Find root issues: those with parents not in the result set
+    const issueKeys = new Set(issues.map(i => i.key));
+    const parentKeys = new Set();
+    for (const issue of issues) {
+        if (issue.parent && !issueKeys.has(issue.parent)) {
+            parentKeys.add(issue.parent);
+        }
+    }
+    // Also include issues in the set that have no parent (they are roots)
+    for (const issue of issues) {
+        if (!issue.parent) {
+            parentKeys.add(issue.key);
+        }
+    }
+    // If no hierarchy detected, say so
+    if (parentKeys.size === 0) {
+        lines.push('', '*No parent-child relationships detected in this issue set.*');
+        return lines.join('\n');
+    }
+    // Walk each root (cap at MAX_HIERARCHY_ROOTS)
+    const roots = [...parentKeys].slice(0, MAX_HIERARCHY_ROOTS);
+    const walker = new GraphQLHierarchyWalker(graphqlClient);
+    for (const rootKey of roots) {
+        try {
+            const { tree } = await walker.walkDown(rootKey, HIERARCHY_MAX_DEPTH, HIERARCHY_MAX_ITEMS);
+            const rollup = GraphQLHierarchyWalker.computeRollups(tree);
+            lines.push('');
+            lines.push(`### ${rootKey}: ${tree.issue.summary}`);
+            lines.push(`Progress: ${rollup.resolvedItems}/${rollup.totalItems} (${rollup.progressPct}%) | Points: ${rollup.totalPoints} (${rollup.earnedPoints} earned)`);
+            if (rollup.rolledUpStart || rollup.rolledUpEnd) {
+                lines.push(`Dates: ${rollup.rolledUpStart ?? '—'} – ${rollup.rolledUpEnd ?? '—'}`);
+            }
+            if (rollup.conflicts.length > 0) {
+                lines.push(`Conflicts: ${rollup.conflicts.map(c => `${c.issueKey}: ${c.message}`).join('; ')}`);
+            }
+            lines.push('');
+            renderRollupTree(tree, lines, ['dates', 'points', 'progress'], '', true);
+        }
+        catch {
+            lines.push('', `*Could not walk hierarchy for ${rootKey}*`);
+        }
+    }
+    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.*`);
+    }
+    return lines.join('\n');
+}
+// ── Cache → Issue Mapping ─────────────────────────────────────────────
+/** Map a GraphIssue from cache to JiraIssueDetails for metric renderers */
+function graphIssueToDetails(issue) {
+    const statusCategoryMap = {
+        'To Do': 'new',
+        'In Progress': 'indeterminate',
+        'Done': 'done',
+    };
+    return {
+        key: issue.key,
+        summary: issue.summary,
+        description: '',
+        issueType: issue.issueType,
+        priority: null,
+        parent: issue.parentKey,
+        assignee: issue.assignee,
+        reporter: '',
+        status: issue.status,
+        statusCategory: statusCategoryMap[issue.statusCategory] ?? 'unknown',
+        resolution: issue.isResolved ? 'Done' : null,
+        labels: [],
+        created: '',
+        updated: '',
+        resolutionDate: null,
+        statusCategoryChanged: null,
+        dueDate: issue.dueDate,
+        startDate: issue.startDate,
+        storyPoints: issue.storyPoints,
+        sprint: null,
+        timeEstimate: null,
+        issueLinks: [],
+    };
+}
+/** Flatten a cached hierarchy tree to JiraIssueDetails[] for existing metric renderers */
+export function flattenCacheToIssueDetails(tree) {
+    const issues = [];
+    walkTree(tree, (node) => {
+        issues.push(graphIssueToDetails(node.issue));
+    });
+    return issues;
+}
+// ── DataRef Handler (cached plan data) ─────────────────────────────────
+async function handleDataRefAnalysis(cached, args, graphqlClient, groupLimit = DEFAULT_GROUP_LIMIT) {
+    const allIssues = flattenCacheToIssueDetails(cached.tree);
+    const requested = (args.metrics && Array.isArray(args.metrics))
+        ? args.metrics
+        : [];
+    const fetchMetrics = requested.length > 0
+        ? requested.filter(m => ALL_METRICS.includes(m))
+        : ALL_METRICS;
+    const hasHierarchy = requested.includes('hierarchy');
+    const now = new Date();
+    const lines = [];
+    lines.push(`# Analysis: ${cached.rootKey} (from cache)`);
+    lines.push(`Analyzing ${allIssues.length} issues from cached hierarchy walk`);
+    lines.push('');
+    const renderers = {
+        points: () => renderPoints(allIssues),
+        time: () => renderTime(allIssues),
+        schedule: () => renderSchedule(allIssues, now),
+        cycle: () => renderCycle(allIssues, now),
+        distribution: () => renderDistribution(allIssues, groupLimit),
+    };
+    for (const metric of fetchMetrics) {
+        if (renderers[metric]) {
+            lines.push(renderers[metric]());
+            lines.push('');
+        }
+    }
+    // Hierarchy renders the cached tree directly (no re-walk)
+    if (hasHierarchy) {
+        lines.push('## Hierarchy Rollups');
+        lines.push('');
+        const rollup = GraphQLHierarchyWalker.computeRollups(cached.tree);
+        lines.push(`Progress: ${rollup.resolvedItems}/${rollup.totalItems} (${rollup.progressPct}%) | Points: ${rollup.totalPoints} (${rollup.earnedPoints} earned)`);
+        if (rollup.rolledUpStart || rollup.rolledUpEnd) {
+            lines.push(`Dates: ${rollup.rolledUpStart ?? '—'} – ${rollup.rolledUpEnd ?? '—'}`);
+        }
+        lines.push('');
+        renderRollupTree(cached.tree, lines, ['dates', 'points', 'progress'], '', true);
+    }
+    // Flow not supported from cache — no changelog data
+    if (requested.includes('flow')) {
+        lines.push('');
+        lines.push('## Flow\n\n*Flow metric requires changelog data and is not available from cached plan data. Use jql or filterId instead.*');
+    }
+    // Summary not supported from cache — needs count API
+    if (requested.includes('summary')) {
+        lines.push('');
+        lines.push('## Summary\n\n*Summary metric uses the count API and is not available from cached plan data. Use jql or filterId instead.*');
+    }
+    const nextSteps = analysisNextSteps(`dataRef:${cached.rootKey}`, allIssues.slice(0, 3).map(i => i.key), false, undefined);
+    lines.push(nextSteps);
+    return {
+        content: [{
+                type: 'text',
+                text: lines.join('\n'),
+            }],
+    };
+}
 // ── Main Handler ───────────────────────────────────────────────────────
-export async function handleAnalysisRequest(jiraClient, request) {
+export async function handleAnalysisRequest(jiraClient, request, graphqlClient, cache) {
     const args = normalizeArgs(request.params?.arguments || {});
+    // Parse groupLimit early — needed by dataRef path and summary path
+    const rawGroupLimit = Number(args.groupLimit);
+    const groupLimit = rawGroupLimit > 0 ? rawGroupLimit : DEFAULT_GROUP_LIMIT;
+    // dataRef: analyze cached plan data instead of fetching from Jira
+    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).');
+        }
+        const cached = cache.get(dataRef);
+        if (!cached) {
+            throw new McpError(ErrorCode.InvalidParams, `No cached walk for "${dataRef}". Start one with analyze_jira_plan first.`);
+        }
+        if (cached.state === 'walking') {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Walk for ${dataRef} is still in progress (${cached.itemCount} items so far). Try again shortly.`,
+                    }],
+            };
+        }
+        return handleDataRefAnalysis(cached, args, graphqlClient, groupLimit);
+    }
     // Resolve JQL: filterId takes precedence over inline jql
     let jql;
     let filterSource;
@@ -708,7 +896,7 @@ export async function handleAnalysisRequest(jiraClient, request) {
     else {
         jql = args.jql;
         if (!jql || typeof jql !== 'string' || jql.trim() === '') {
-            throw new McpError(ErrorCode.InvalidParams, 'Either jql or filterId parameter is required.');
+            throw new McpError(ErrorCode.InvalidParams, 'Either jql, filterId, or dataRef parameter is required.');
         }
     }
     // Parse requested metrics
@@ -718,11 +906,12 @@ export async function handleAnalysisRequest(jiraClient, request) {
     const hasSummary = requested.includes('summary');
     const hasCubeSetup = requested.includes('cube_setup');
     const hasFlow = requested.includes('flow');
+    const hasHierarchy = requested.includes('hierarchy');
     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;
+    // flow and hierarchy need issue fetching but aren't in ALL_METRICS (opt-in only)
+    const needsIssueFetch = fetchMetrics.length > 0 || hasFlow || hasHierarchy;
     // Parse groupBy
     const groupBy = (typeof args.groupBy === 'string' && VALID_GROUP_BY.includes(args.groupBy))
         ? args.groupBy
@@ -732,9 +921,6 @@ export async function handleAnalysisRequest(jiraClient, request) {
     if (args.compute && Array.isArray(args.compute) && args.compute.length > 0) {
         compute = parseComputeList(args.compute);
     }
-    // Parse groupLimit — soft cap on group/dimension values (no hard cap for summary metrics)
-    const rawGroupLimit = Number(args.groupLimit);
-    const groupLimit = rawGroupLimit > 0 ? rawGroupLimit : DEFAULT_GROUP_LIMIT;
     // Cube setup — discover dimensions from sample, no issue fetching
     if (hasCubeSetup) {
         const cubeText = await handleCubeSetup(jiraClient, jql);
@@ -832,6 +1018,16 @@ export async function handleAnalysisRequest(jiraClient, request) {
         lines.push('');
         lines.push(await renderFlow(jiraClient, allIssues));
     }
+    // Hierarchy is opt-in and requires GraphQL client
+    if (hasHierarchy && allIssues.length > 0) {
+        lines.push('');
+        if (graphqlClient) {
+            lines.push(await renderHierarchy(allIssues, graphqlClient));
+        }
+        else {
+            lines.push('## Hierarchy\n\n*Hierarchy metric requires GraphQL (cloudId discovery). Not available for this instance.*');
+        }
+    }
     // Next steps
     const nextSteps = analysisNextSteps(jql, allIssues.slice(0, 3).map(i => i.key), truncated, groupBy, filterSource);
     lines.push(nextSteps);

package/build/handlers/plan-handler.js

@@ -0,0 +1,351 @@
+import { ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';
+import { GraphQLHierarchyWalker, collectLeaves, computeDepth, walkTree } from '../client/graphql-hierarchy.js';
+import { planNextSteps } 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 issueKey = args.issueKey;
+    if (!issueKey) {
+        throw new McpError(ErrorCode.InvalidParams, 'issueKey is required for analyze_jira_plan');
+    }
+    const operation = args.operation ?? 'analyze';
+    // Handle release operation
+    if (operation === 'release') {
+        if (!cache) {
+            return { content: [{ type: 'text', text: 'Cache not available.' }] };
+        }
+        const released = cache.release(issueKey);
+        return {
+            content: [{
+                    type: 'text',
+                    text: released
+                        ? `Released cached walk for ${issueKey}.`
+                        : `No cached walk found for ${issueKey}.`,
+                }],
+        };
+    }
+    const rollups = (Array.isArray(args.rollups) ? args.rollups : ALL_ROLLUPS);
+    const mode = args.mode ?? 'rollup';
+    const focus = args.focus;
+    // Try cache-first path
+    if (cache) {
+        const status = cache.getStatus(issueKey);
+        if (status.state === 'error') {
+            cache.release(issueKey);
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Walk failed for ${issueKey}: ${status.error ?? 'unknown error'}. Cleared from cache — call again to retry.`,
+                    }],
+                isError: true,
+            };
+        }
+        if (status.state === 'walking') {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Walking hierarchy for ${issueKey}... ${status.itemCount} items collected so far.\nCall again to check progress or wait for completion.`,
+                    }],
+            };
+        }
+        if (status.state === 'not_found') {
+            cache.startWalk(issueKey, graphqlClient);
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Started hierarchy walk for ${issueKey}. Call again to check progress.\n\n*The walk runs in the background — subsequent calls will show progress or full results once complete.*`,
+                    }],
+            };
+        }
+        if (status.state === 'complete' || status.state === 'stale') {
+            const cached = cache.get(issueKey);
+            const staleNote = status.stale
+                ? '> **Note:** This data may be stale. Call again to refresh, or use `operation: "release"` to clear.\n\n'
+                : '';
+            if (status.stale) {
+                cache.startWalk(issueKey, graphqlClient);
+            }
+            // Focus mode: windowed view of a specific node
+            if (focus) {
+                const output = renderFocusView(cached.tree, focus, rollups);
+                return { content: [{ type: 'text', text: staleNote + output }] };
+            }
+            // Default: summary + entry points (bounded)
+            const rollupResult = GraphQLHierarchyWalker.computeRollups(cached.tree);
+            const output = mode === 'gaps'
+                ? renderGapsSummary(cached.tree, rollups, rollupResult)
+                : renderOverview(cached.tree, issueKey, cached.itemCount, rollups, rollupResult);
+            return {
+                content: [{
+                        type: 'text',
+                        text: staleNote + output + planNextSteps(issueKey, mode, rollupResult.conflicts, rollupResult),
+                    }],
+            };
+        }
+    }
+    // Fallback: no cache, walk synchronously with original limits
+    const walker = new GraphQLHierarchyWalker(graphqlClient);
+    let tree;
+    let totalItems;
+    try {
+        ({ tree, totalItems } = await walker.walkDown(issueKey));
+    }
+    catch (err) {
+        const message = err.message;
+        if (message.includes('not found')) {
+            throw new McpError(ErrorCode.InvalidParams, `Issue ${issueKey} not found.`);
+        }
+        throw new McpError(ErrorCode.InternalError, `Hierarchy walk failed: ${message}`);
+    }
+    const rollupResult = GraphQLHierarchyWalker.computeRollups(tree);
+    const output = renderOverview(tree, issueKey, totalItems, rollups);
+    return {
+        content: [{
+                type: 'text',
+                text: output + planNextSteps(issueKey, mode, rollupResult.conflicts, rollupResult),
+            }],
+    };
+}
+// --- Rendering: Overview (summary + entry points) ---
+function renderOverview(tree, issueKey, totalItems, rollups, rollupResult) {
+    const lines = [];
+    const depth = computeDepth(tree);
+    rollupResult ??= GraphQLHierarchyWalker.computeRollups(tree);
+    lines.push(`# Plan: ${issueKey} — ${tree.issue.summary}`);
+    lines.push(`${totalItems} items, ${depth} levels deep | cached`);
+    lines.push('');
+    renderSummaryBlock(tree, lines, rollups, rollupResult);
+    lines.push('');
+    // Entry points: immediate children with their rollup summaries
+    if (tree.children.length > 0) {
+        lines.push('## Children');
+        lines.push('');
+        const shown = tree.children.slice(0, MAX_CHILDREN_DISPLAY);
+        for (const child of shown) {
+            renderNodeLine(child, lines, rollups);
+        }
+        if (tree.children.length > MAX_CHILDREN_DISPLAY) {
+            lines.push(`*...and ${tree.children.length - MAX_CHILDREN_DISPLAY} more — use \`focus\` to navigate*`);
+        }
+        lines.push('');
+        lines.push('*Use `focus: "ISSUE-KEY"` to explore any node and its neighborhood.*');
+    }
+    return lines.join('\n');
+}
+// --- Rendering: Focus (windowed view of a specific node) ---
+function findInTree(node, key, parent = null) {
+    if (node.issue.key === key)
+        return { node, parent };
+    for (const child of node.children) {
+        const found = findInTree(child, key, node);
+        if (found)
+            return found;
+    }
+    return null;
+}
+function renderFocusView(tree, focusKey, rollups) {
+    const found = findInTree(tree, focusKey);
+    if (!found) {
+        return `Issue ${focusKey} not found in cached hierarchy. Available root: ${tree.issue.key}`;
+    }
+    const focusNode = found.node;
+    const parentNode = found.parent;
+    const lines = [];
+    const rollupResult = GraphQLHierarchyWalker.computeRollups(focusNode);
+    lines.push(`# Focus: ${focusNode.issue.key} — ${focusNode.issue.summary}`);
+    lines.push(`[${focusNode.issue.issueType}] ${focusNode.issue.status}`);
+    lines.push('');
+    // Parent context
+    if (parentNode) {
+        const parentRollup = GraphQLHierarchyWalker.computeRollups(parentNode);
+        lines.push(`**Parent:** ${parentNode.issue.key} — ${parentNode.issue.summary} [${parentNode.issue.issueType}]`);
+        lines.push(`  Progress: ${parentRollup.resolvedItems}/${parentRollup.totalItems} (${parentRollup.progressPct}%)`);
+        lines.push('');
+    }
+    // This node's details
+    renderSummaryBlock(focusNode, lines, rollups, rollupResult);
+    lines.push('');
+    // Siblings (if has parent)
+    if (parentNode) {
+        const siblings = parentNode.children.filter(c => c.issue.key !== focusKey);
+        if (siblings.length > 0) {
+            lines.push(`## Siblings (${siblings.length})`);
+            lines.push('');
+            const shown = siblings.slice(0, MAX_CHILDREN_DISPLAY);
+            for (const sib of shown) {
+                renderNodeLine(sib, lines, rollups);
+            }
+            if (siblings.length > MAX_CHILDREN_DISPLAY) {
+                lines.push(`*...and ${siblings.length - MAX_CHILDREN_DISPLAY} more*`);
+            }
+            lines.push('');
+        }
+    }
+    // Children
+    if (focusNode.children.length > 0) {
+        lines.push(`## Children (${focusNode.children.length})`);
+        lines.push('');
+        const shown = focusNode.children.slice(0, MAX_CHILDREN_DISPLAY);
+        for (const child of shown) {
+            renderNodeLine(child, lines, rollups);
+        }
+        if (focusNode.children.length > MAX_CHILDREN_DISPLAY) {
+            lines.push(`*...and ${focusNode.children.length - MAX_CHILDREN_DISPLAY} more*`);
+        }
+    }
+    else {
+        lines.push('*Leaf node — no children*');
+    }
+    return lines.join('\n');
+}
+/** Render a single node as a compact line with rollup summary */
+function renderNodeLine(node, lines, rollups) {
+    const statusCat = node.issue.statusCategory.toLowerCase();
+    const icon = statusCat === 'done' ? '✓' : statusCat === 'in progress' ? '●' : '○';
+    const parts = [];
+    parts.push(`${icon} **${node.issue.key}**: ${node.issue.summary} [${node.issue.issueType}]`);
+    const details = [];
+    if (node.children.length > 0) {
+        const rollup = GraphQLHierarchyWalker.computeRollups(node);
+        if (rollups.includes('progress')) {
+            details.push(`${rollup.resolvedItems}/${rollup.totalItems} (${rollup.progressPct}%)`);
+        }
+        if (rollups.includes('points') && rollup.totalPoints > 0) {
+            details.push(`${rollup.earnedPoints}/${rollup.totalPoints} pts`);
+        }
+        if (rollups.includes('dates') && (rollup.rolledUpStart || rollup.rolledUpEnd)) {
+            details.push(`${rollup.rolledUpStart ?? '—'} – ${rollup.rolledUpEnd ?? '—'}`);
+        }
+        if (rollup.conflicts.length > 0) {
+            details.push(`${rollup.conflicts.length} conflicts`);
+        }
+    }
+    else {
+        if (node.issue.assignee)
+            details.push(node.issue.assignee);
+        if (rollups.includes('dates') && (node.issue.startDate || node.issue.dueDate)) {
+            details.push(`${node.issue.startDate ?? '—'} – ${node.issue.dueDate ?? '—'}`);
+        }
+        if (rollups.includes('points') && node.issue.storyPoints != null) {
+            details.push(`${node.issue.storyPoints} pts`);
+        }
+    }
+    if (details.length > 0) {
+        lines.push(`- ${parts[0]}`);
+        lines.push(`  ${details.join(' | ')}`);
+    }
+    else {
+        lines.push(`- ${parts[0]}`);
+    }
+}
+// --- Rendering: Gaps summary (bounded) ---
+function renderGapsSummary(tree, rollups, rollupResult) {
+    const lines = [];
+    rollupResult ??= GraphQLHierarchyWalker.computeRollups(tree);
+    lines.push(`# Gaps: ${tree.issue.key} — ${tree.issue.summary}`);
+    lines.push('');
+    const gaps = [];
+    for (const c of rollupResult.conflicts) {
+        gaps.push(`- **${c.issueKey}** [${c.type}]: ${c.message}`);
+    }
+    walkTree(tree, (node) => {
+        if (node.children.length === 0)
+            return;
+        if (rollups.includes('dates')) {
+            const undated = node.children.filter(c => !c.issue.startDate && !c.issue.dueDate);
+            const dated = node.children.length - undated.length;
+            if (undated.length > 0 && dated > 0) {
+                gaps.push(`- **${node.issue.key}**: ${undated.length}/${node.children.length} children have no dates`);
+            }
+        }
+        if (rollups.includes('points')) {
+            const unestimated = node.children.filter(c => c.issue.storyPoints == null);
+            const estimated = node.children.length - unestimated.length;
+            if (unestimated.length > 0 && estimated > 0) {
+                gaps.push(`- **${node.issue.key}**: ${unestimated.length}/${node.children.length} children have no story points`);
+            }
+        }
+        if (rollups.includes('assignees')) {
+            const unassigned = node.children.filter(c => !c.issue.assignee && !c.issue.isResolved);
+            if (unassigned.length > 0) {
+                gaps.push(`- **${node.issue.key}**: ${unassigned.length} active children unassigned`);
+            }
+        }
+    });
+    if (gaps.length === 0) {
+        lines.push('No gaps or conflicts detected.');
+    }
+    else {
+        const unique = [...new Set(gaps)];
+        // Cap output to first 30 gaps
+        const shown = unique.slice(0, 30);
+        lines.push(...shown);
+        if (unique.length > 30) {
+            lines.push(`\n*...and ${unique.length - 30} more. Use \`focus\` on a specific subtree to narrow down.*`);
+        }
+    }
+    return lines.join('\n');
+}
+// --- Shared rendering ---
+function renderSummaryBlock(tree, lines, rollups, result) {
+    if (rollups.includes('dates')) {
+        const own = `${tree.issue.startDate ?? '—'} – ${tree.issue.dueDate ?? '—'}`;
+        const derived = `${result.rolledUpStart ?? '—'} – ${result.rolledUpEnd ?? '—'}`;
+        lines.push(`**Dates:** own ${own} | rolled-up ${derived}`);
+    }
+    if (rollups.includes('points') && result.totalPoints > 0) {
+        lines.push(`**Points:** ${result.totalPoints} total, ${result.earnedPoints} earned`);
+    }
+    if (rollups.includes('progress')) {
+        lines.push(`**Progress:** ${result.resolvedItems}/${result.totalItems} resolved (${result.progressPct}%)`);
+    }
+    if (rollups.includes('assignees') && result.assignees.length > 0) {
+        lines.push(`**Team:** ${result.assignees.join(', ')}${result.unassignedCount > 0 ? ` | ${result.unassignedCount} unassigned` : ''}`);
+    }
+    if (result.conflicts.length > 0) {
+        lines.push(`**Conflicts:** ${result.conflicts.length} detected`);
+    }
+}
+/** Full tree renderer — kept for analysis-handler hierarchy metric (small trees only) */
+export function renderRollupTree(node, lines, rollups, prefix, isLast) {
+    const connector = prefix === '' ? '' : (isLast ? '└── ' : '├── ');
+    const statusCat = node.issue.statusCategory.toLowerCase();
+    const icon = statusCat === 'done' ? '✓' : statusCat === 'in progress' ? '●' : '○';
+    const label = `${icon} **${node.issue.key}**: ${node.issue.summary} [${node.issue.issueType}]`;
+    lines.push(`${prefix}${connector}${label}`);
+    const indent = prefix + (prefix === '' ? '' : (isLast ? '    ' : '│   '));
+    if (rollups.includes('dates')) {
+        const start = node.issue.startDate ?? '—';
+        const due = node.issue.dueDate ?? '—';
+        if (start !== '—' || due !== '—' || node.children.length > 0) {
+            let dateLine = `${indent}  ${start} – ${due}`;
+            if (node.children.length > 0) {
+                const childRollup = GraphQLHierarchyWalker.computeRollups(node);
+                if (childRollup.rolledUpStart || childRollup.rolledUpEnd) {
+                    dateLine += ` | rolled-up ${childRollup.rolledUpStart ?? '—'} – ${childRollup.rolledUpEnd ?? '—'}`;
+                }
+                const conflict = childRollup.conflicts.find(c => c.issueKey === node.issue.key);
+                if (conflict)
+                    dateLine += ` ⚠️ ${conflict.message}`;
+            }
+            lines.push(dateLine);
+        }
+    }
+    if (rollups.includes('points') && node.issue.storyPoints != null) {
+        lines.push(`${indent}  ${node.issue.storyPoints} pts`);
+    }
+    if (rollups.includes('progress') && node.children.length > 0) {
+        const leaves = collectLeaves(node);
+        const resolved = leaves.filter(l => l.isResolved).length;
+        lines.push(`${indent}  Progress: ${resolved}/${leaves.length} (${leaves.length > 0 ? Math.round(resolved / leaves.length * 100) : 0}%)`);
+    }
+    if (rollups.includes('assignees') && node.children.length === 0 && node.issue.assignee) {
+        lines.push(`${indent}  ${node.issue.assignee}`);
+    }
+    const childPrefix = prefix + (prefix === '' ? '' : (isLast ? '    ' : '│   '));
+    node.children.forEach((child, i) => {
+        renderRollupTree(child, lines, rollups, childPrefix, i === node.children.length - 1);
+    });
+}