Commit 89f1c1c5eb23

@@ -0,0 +1,612 @@
+/**
+ * Action handlers for Jira extension
+ */
+
+import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { JiraDetails } from "./types";
+import {
+	buildCommentConfirmation,
+	buildCreateConfirmation,
+	buildTransitionConfirmation,
+	buildUpdateConfirmation,
+	extractIssueKey,
+	extractIssueKeys,
+	getErrorMessage,
+	parseIssueListJSON,
+} from "./utils";
+
+/**
+ * Get current Jira user
+ */
+export async function handleMe(
+	pi: ExtensionAPI,
+	params: any,
+	signal: AbortSignal | undefined,
+	onUpdate: any,
+	ctx: ExtensionContext,
+): Promise<any> {
+	const result = await pi.exec("jira", ["me"], { signal, timeout: 10000 });
+
+	if (result.code !== 0) {
+		return {
+			content: [{ type: "text", text: getErrorMessage(result.stderr, "Get current user") }],
+			details: { action: "me", error: result.stderr } as JiraDetails,
+			isError: true,
+		};
+	}
+
+	const user = result.stdout.trim();
+
+	return {
+		content: [{ type: "text", text: `Current user: ${user}` }],
+		details: { action: "me", output: user } as JiraDetails,
+	};
+}
+
+/**
+ * List Jira issues
+ */
+export async function handleList(
+	pi: ExtensionAPI,
+	params: any,
+	signal: AbortSignal | undefined,
+	onUpdate: any,
+	ctx: ExtensionContext,
+	currentUser: string,
+): Promise<any> {
+	// Build jira command - use --raw for JSON output
+	const args = ["issue", "list", "--raw"];
+
+	// Handle assignee
+	if (params.assignee) {
+		if (params.assignee === "me") {
+			// Get current user if not cached
+			if (!currentUser) {
+				const meResult = await pi.exec("jira", ["me"], { signal, timeout: 10000 });
+				if (meResult.code === 0) {
+					currentUser = meResult.stdout.trim();
+				}
+			}
+			args.push("-a", currentUser || params.assignee);
+		} else {
+			args.push("-a", params.assignee);
+		}
+	}
+
+	// Handle status
+	if (params.status) {
+		args.push("-s", params.status);
+	}
+
+	// Handle type
+	if (params.type) {
+		args.push("-t", params.type);
+	}
+
+	// Handle priority
+	if (params.priority) {
+		args.push("-p", params.priority);
+	}
+
+	// Handle epic filter (via JQL)
+	if (params.epic) {
+		// Use JQL for epic filtering
+		const jql = buildListJQL(params, currentUser);
+		args.length = 0; // Clear args
+		args.push("issue", "list", "--raw", "--jql", jql);
+	}
+
+	// Handle limit (jira CLI uses --paginate, not --limit)
+	if (params.limit) {
+		args.push("--paginate", String(params.limit));
+	} else {
+		args.push("--paginate", "20");
+	}
+
+	onUpdate?.({ content: [{ type: "text", text: "Fetching issues..." }] });
+
+	const result = await pi.exec("jira", args, { signal, timeout: 30000 });
+
+	if (result.code !== 0) {
+		return {
+			content: [{ type: "text", text: getErrorMessage(result.stderr, "List issues") }],
+			details: { action: "list", error: result.stderr } as JiraDetails,
+			isError: true,
+		};
+	}
+
+	// Parse JSON output
+	const issues = parseIssueListJSON(result.stdout);
+	
+	// Format for LLM
+	let output = "";
+	if (issues.length === 0) {
+		output = "No issues found";
+	} else {
+		output = issues.map(issue => {
+			const priority = issue.priority ? `[${issue.priority}]` : "";
+			const assignee = issue.assignee !== "Unassigned" ? `(@${issue.assignee})` : "";
+			return `${issue.key} [${issue.type}] ${priority} [${issue.status}] ${issue.summary} ${assignee}`;
+		}).join("\n");
+	}
+	
+	// Extract issue keys for tracking
+	const issueKeys = issues.map(i => i.key);
+
+	return {
+		content: [{ type: "text", text: output }],
+		details: { action: "list", output, issueKeys } as JiraDetails,
+	};
+}
+
+/**
+ * View Jira issue details
+ */
+export async function handleView(
+	pi: ExtensionAPI,
+	params: any,
+	signal: AbortSignal | undefined,
+	onUpdate: any,
+	ctx: ExtensionContext,
+): Promise<any> {
+	if (!params.key) {
+		return {
+			content: [{ type: "text", text: "Error: 'key' parameter is required for view action" }],
+			details: { action: "view", error: "missing_key" } as JiraDetails,
+			isError: true,
+		};
+	}
+
+	onUpdate?.({ content: [{ type: "text", text: `Fetching ${params.key}...` }] });
+
+	const result = await pi.exec("jira", ["issue", "view", params.key, "--plain"], { signal, timeout: 20000 });
+
+	if (result.code !== 0) {
+		return {
+			content: [{ type: "text", text: getErrorMessage(result.stderr, "View issue") }],
+			details: { action: "view", error: result.stderr, issueKey: params.key } as JiraDetails,
+			isError: true,
+		};
+	}
+
+	return {
+		content: [{ type: "text", text: result.stdout }],
+		details: { action: "view", output: result.stdout, issueKey: params.key } as JiraDetails,
+	};
+}
+
+/**
+ * Search Jira issues using JQL
+ */
+export async function handleSearch(
+	pi: ExtensionAPI,
+	params: any,
+	signal: AbortSignal | undefined,
+	onUpdate: any,
+	ctx: ExtensionContext,
+): Promise<any> {
+	if (!params.jql) {
+		return {
+			content: [{ type: "text", text: "Error: 'jql' parameter is required for search action" }],
+			details: { action: "search", error: "missing_jql" } as JiraDetails,
+			isError: true,
+		};
+	}
+
+	const args = ["issue", "list", "--raw", "--jql", params.jql];
+
+	if (params.limit) {
+		args.push("--paginate", String(params.limit));
+	} else {
+		args.push("--paginate", "50");
+	}
+
+	onUpdate?.({ content: [{ type: "text", text: "Searching..." }] });
+
+	const result = await pi.exec("jira", args, { signal, timeout: 30000 });
+
+	if (result.code !== 0) {
+		return {
+			content: [{ type: "text", text: getErrorMessage(result.stderr, "Search") }],
+			details: { action: "search", error: result.stderr } as JiraDetails,
+			isError: true,
+		};
+	}
+
+	// Parse JSON output
+	const issues = parseIssueListJSON(result.stdout);
+	
+	// Format for LLM
+	let output = "";
+	if (issues.length === 0) {
+		output = "No issues found";
+	} else {
+		output = issues.map(issue => {
+			const priority = issue.priority ? `[${issue.priority}]` : "";
+			const assignee = issue.assignee !== "Unassigned" ? `(@${issue.assignee})` : "";
+			return `${issue.key} [${issue.type}] ${priority} [${issue.status}] ${issue.summary} ${assignee}`;
+		}).join("\n");
+	}
+	
+	// Extract issue keys for tracking
+	const issueKeys = issues.map(i => i.key);
+
+	return {
+		content: [{ type: "text", text: output }],
+		details: { action: "search", output, issueKeys } as JiraDetails,
+	};
+}
+
+/**
+ * Create Jira issue (requires approval)
+ */
+export async function handleCreate(
+	pi: ExtensionAPI,
+	params: any,
+	signal: AbortSignal | undefined,
+	onUpdate: any,
+	ctx: ExtensionContext,
+	currentUser: string,
+): Promise<any> {
+	// Validate required parameters
+	if (!params.issueType) {
+		return {
+			content: [{ type: "text", text: "Error: 'issueType' parameter is required for create action" }],
+			details: { action: "create", error: "missing_type" } as JiraDetails,
+			isError: true,
+		};
+	}
+
+	if (!params.summary) {
+		return {
+			content: [{ type: "text", text: "Error: 'summary' parameter is required for create action" }],
+			details: { action: "create", error: "missing_summary" } as JiraDetails,
+			isError: true,
+		};
+	}
+
+	// APPROVAL GATE
+	if (ctx.hasUI) {
+		const confirmMessage = buildCreateConfirmation(params);
+
+		const confirmed = await ctx.ui.confirm("Create Jira Issue?", confirmMessage);
+
+		if (!confirmed) {
+			ctx.ui.notify("Create cancelled", "info");
+			return {
+				content: [{ type: "text", text: "Create operation cancelled by user" }],
+				details: { action: "create", cancelled: true } as JiraDetails,
+			};
+		}
+	}
+
+	// Build jira command
+	const args = ["issue", "create", "--type", params.issueType, "--summary", params.summary, "--no-input"];
+
+	if (params.description) {
+		args.push("--description", params.description);
+	}
+
+	if (params.priority) {
+		args.push("--priority", params.priority);
+	}
+
+	if (params.assignee) {
+		const assignee = params.assignee === "me" ? currentUser || params.assignee : params.assignee;
+		args.push("--assignee", assignee);
+	}
+
+	if (params.labels && params.labels.length > 0) {
+		args.push("--label", params.labels.join(","));
+	}
+
+	if (params.parent) {
+		args.push("--parent", params.parent);
+	}
+
+	// Note: epic linking might need to be done via edit after creation
+	// depending on jira-cli version
+
+	onUpdate?.({ content: [{ type: "text", text: "Creating issue..." }] });
+
+	const result = await pi.exec("jira", args, { signal, timeout: 30000 });
+
+	if (result.code !== 0) {
+		return {
+			content: [{ type: "text", text: getErrorMessage(result.stderr, "Create issue") }],
+			details: { action: "create", error: result.stderr } as JiraDetails,
+			isError: true,
+		};
+	}
+
+	// Extract issue key from output
+	const issueKey = extractIssueKey(result.stdout) || "unknown";
+
+	return {
+		content: [{ type: "text", text: `Created issue: ${issueKey}\n\n${result.stdout}` }],
+		details: { action: "create", output: result.stdout, issueKey } as JiraDetails,
+	};
+}
+
+/**
+ * Update Jira issue field (requires approval)
+ */
+export async function handleUpdate(
+	pi: ExtensionAPI,
+	params: any,
+	signal: AbortSignal | undefined,
+	onUpdate: any,
+	ctx: ExtensionContext,
+	currentUser: string,
+): Promise<any> {
+	if (!params.key) {
+		return {
+			content: [{ type: "text", text: "Error: 'key' parameter is required for update action" }],
+			details: { action: "update", error: "missing_key" } as JiraDetails,
+			isError: true,
+		};
+	}
+
+	if (!params.field) {
+		return {
+			content: [{ type: "text", text: "Error: 'field' parameter is required for update action" }],
+			details: { action: "update", error: "missing_field" } as JiraDetails,
+			isError: true,
+		};
+	}
+
+	if (!params.value) {
+		return {
+			content: [{ type: "text", text: "Error: 'value' parameter is required for update action" }],
+			details: { action: "update", error: "missing_value" } as JiraDetails,
+			isError: true,
+		};
+	}
+
+	// APPROVAL GATE
+	if (ctx.hasUI) {
+		const confirmMessage = buildUpdateConfirmation(params);
+
+		const confirmed = await ctx.ui.confirm(`Update ${params.key}?`, confirmMessage);
+
+		if (!confirmed) {
+			ctx.ui.notify("Update cancelled", "info");
+			return {
+				content: [{ type: "text", text: "Update operation cancelled by user" }],
+				details: { action: "update", cancelled: true, issueKey: params.key } as JiraDetails,
+			};
+		}
+	}
+
+	// Build command based on field
+	let args: string[];
+	const value = params.value === "me" ? currentUser || params.value : params.value;
+
+	switch (params.field) {
+		case "assignee":
+			args = ["issue", "assign", params.key, value];
+			break;
+
+		case "labels":
+			// Labels are comma-separated
+			args = ["issue", "edit", params.key, "--label", value];
+			break;
+
+		case "priority":
+		case "summary":
+		case "description":
+			args = ["issue", "edit", params.key, `--${params.field}`, value];
+			break;
+
+		default:
+			return {
+				content: [{ type: "text", text: `Error: Unsupported field: ${params.field}` }],
+				details: { action: "update", error: "unsupported_field", issueKey: params.key } as JiraDetails,
+				isError: true,
+			};
+	}
+
+	onUpdate?.({ content: [{ type: "text", text: `Updating ${params.key}...` }] });
+
+	const result = await pi.exec("jira", args, { signal, timeout: 20000 });
+
+	if (result.code !== 0) {
+		return {
+			content: [{ type: "text", text: getErrorMessage(result.stderr, "Update issue") }],
+			details: { action: "update", error: result.stderr, issueKey: params.key } as JiraDetails,
+			isError: true,
+		};
+	}
+
+	return {
+		content: [{ type: "text", text: `Updated ${params.key}: ${params.field} = ${value}\n\n${result.stdout}` }],
+		details: {
+			action: "update",
+			output: result.stdout,
+			issueKey: params.key,
+			field: params.field,
+			newValue: value,
+		} as JiraDetails,
+	};
+}
+
+/**
+ * Add comment to Jira issue (requires approval)
+ */
+export async function handleComment(
+	pi: ExtensionAPI,
+	params: any,
+	signal: AbortSignal | undefined,
+	onUpdate: any,
+	ctx: ExtensionContext,
+): Promise<any> {
+	if (!params.key) {
+		return {
+			content: [{ type: "text", text: "Error: 'key' parameter is required for comment action" }],
+			details: { action: "comment", error: "missing_key" } as JiraDetails,
+			isError: true,
+		};
+	}
+
+	if (!params.comment) {
+		return {
+			content: [{ type: "text", text: "Error: 'comment' parameter is required for comment action" }],
+			details: { action: "comment", error: "missing_comment" } as JiraDetails,
+			isError: true,
+		};
+	}
+
+	// APPROVAL GATE
+	if (ctx.hasUI) {
+		const confirmMessage = buildCommentConfirmation(params);
+
+		const confirmed = await ctx.ui.confirm(`Add comment to ${params.key}?`, confirmMessage);
+
+		if (!confirmed) {
+			ctx.ui.notify("Comment cancelled", "info");
+			return {
+				content: [{ type: "text", text: "Comment operation cancelled by user" }],
+				details: { action: "comment", cancelled: true, issueKey: params.key } as JiraDetails,
+			};
+		}
+	}
+
+	onUpdate?.({ content: [{ type: "text", text: `Adding comment to ${params.key}...` }] });
+
+	// Write comment to temp file to avoid shell escaping issues
+	const tmpFile = `/tmp/jira-comment-${Date.now()}.txt`;
+	await pi.exec("sh", ["-c", `echo ${JSON.stringify(params.comment)} > ${tmpFile}`], { signal });
+
+	const result = await pi.exec("sh", ["-c", `cat ${tmpFile} | jira issue comment add ${params.key}`], {
+		signal,
+		timeout: 20000,
+	});
+
+	// Clean up temp file
+	await pi.exec("rm", ["-f", tmpFile], { signal });
+
+	if (result.code !== 0) {
+		return {
+			content: [{ type: "text", text: getErrorMessage(result.stderr, "Add comment") }],
+			details: { action: "comment", error: result.stderr, issueKey: params.key } as JiraDetails,
+			isError: true,
+		};
+	}
+
+	return {
+		content: [{ type: "text", text: `Added comment to ${params.key}` }],
+		details: { action: "comment", output: result.stdout, issueKey: params.key } as JiraDetails,
+	};
+}
+
+/**
+ * Transition Jira issue to new state (requires approval)
+ */
+export async function handleTransition(
+	pi: ExtensionAPI,
+	params: any,
+	signal: AbortSignal | undefined,
+	onUpdate: any,
+	ctx: ExtensionContext,
+): Promise<any> {
+	if (!params.key) {
+		return {
+			content: [{ type: "text", text: "Error: 'key' parameter is required for transition action" }],
+			details: { action: "transition", error: "missing_key" } as JiraDetails,
+			isError: true,
+		};
+	}
+
+	if (!params.state) {
+		return {
+			content: [{ type: "text", text: "Error: 'state' parameter is required for transition action" }],
+			details: { action: "transition", error: "missing_state" } as JiraDetails,
+			isError: true,
+		};
+	}
+
+	// APPROVAL GATE
+	if (ctx.hasUI) {
+		const confirmMessage = buildTransitionConfirmation(params);
+
+		const confirmed = await ctx.ui.confirm(`Transition ${params.key}?`, confirmMessage);
+
+		if (!confirmed) {
+			ctx.ui.notify("Transition cancelled", "info");
+			return {
+				content: [{ type: "text", text: "Transition operation cancelled by user" }],
+				details: { action: "transition", cancelled: true, issueKey: params.key } as JiraDetails,
+			};
+		}
+	}
+
+	onUpdate?.({ content: [{ type: "text", text: `Moving ${params.key} to ${params.state}...` }] });
+
+	const result = await pi.exec("jira", ["issue", "move", params.key, params.state], { signal, timeout: 20000 });
+
+	if (result.code !== 0) {
+		return {
+			content: [{ type: "text", text: getErrorMessage(result.stderr, "Transition issue") }],
+			details: { action: "transition", error: result.stderr, issueKey: params.key } as JiraDetails,
+			isError: true,
+		};
+	}
+
+	return {
+		content: [{ type: "text", text: `Moved ${params.key} to ${params.state}` }],
+		details: {
+			action: "transition",
+			output: result.stdout,
+			issueKey: params.key,
+			toKey: params.state,
+		} as JiraDetails,
+	};
+}
+
+/**
+ * Helper: Build JQL query from list parameters
+ */
+function buildListJQL(params: any, currentUser: string): string {
+	const conditions: string[] = [];
+
+	if (params.assignee) {
+		const assignee = params.assignee === "me" ? currentUser || params.assignee : params.assignee;
+		conditions.push(`assignee = ${assignee}`);
+	}
+
+	if (params.status) {
+		// Handle ~Done syntax for "not Done"
+		if (params.status.startsWith("~")) {
+			conditions.push(`status != ${params.status.slice(1)}`);
+		} else {
+			// Handle comma-separated statuses
+			const statuses = params.status
+				.split(",")
+				.map((s: string) => `"${s.trim()}"`)
+				.join(",");
+			conditions.push(`status IN (${statuses})`);
+		}
+	}
+
+	if (params.type) {
+		const types = params.type
+			.split(",")
+			.map((t: string) => `"${t.trim()}"`)
+			.join(",");
+		conditions.push(`type IN (${types})`);
+	}
+
+	if (params.priority) {
+		const priorities = params.priority
+			.split(",")
+			.map((p: string) => `"${p.trim()}"`)
+			.join(",");
+		conditions.push(`priority IN (${priorities})`);
+	}
+
+	if (params.epic) {
+		conditions.push(`"Epic Link" = ${params.epic}`);
+	}
+
+	return conditions.join(" AND ");
+}

@@ -0,0 +1,142 @@
+/**
+ * Attachment-related action handlers for Jira extension
+ */
+
+import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { JiraDetails } from "./types";
+import { getErrorMessage } from "./utils";
+
+/**
+ * Attach file to issue
+ */
+export async function handleAttach(
+	pi: ExtensionAPI,
+	params: any,
+	signal: AbortSignal | undefined,
+	onUpdate: any,
+	ctx: ExtensionContext,
+): Promise<any> {
+	if (!params.key) {
+		return {
+			content: [{ type: "text", text: "Error: 'key' parameter is required for attach action" }],
+			details: { action: "attach", error: "missing_key" } as JiraDetails,
+			isError: true,
+		};
+	}
+
+	if (!params.file) {
+		return {
+			content: [{ type: "text", text: "Error: 'file' parameter is required for attach action" }],
+			details: { action: "attach", error: "missing_file" } as JiraDetails,
+			isError: true,
+		};
+	}
+
+	// Check if file exists
+	const checkResult = await pi.exec("test", ["-f", params.file], { signal });
+	if (checkResult.code !== 0) {
+		return {
+			content: [{ type: "text", text: `Error: File not found: ${params.file}` }],
+			details: { action: "attach", error: "file_not_found" } as JiraDetails,
+			isError: true,
+		};
+	}
+
+	// APPROVAL GATE
+	if (ctx.hasUI) {
+		const confirmMessage = `Issue: ${params.key}\nFile: ${params.file}\n\nThis will upload the file as an attachment.`;
+
+		const confirmed = await ctx.ui.confirm("Attach file?", confirmMessage);
+
+		if (!confirmed) {
+			ctx.ui.notify("Attach cancelled", "info");
+			return {
+				content: [{ type: "text", text: "Attach operation cancelled by user" }],
+				details: { action: "attach", cancelled: true, issueKey: params.key } as JiraDetails,
+			};
+		}
+	}
+
+	onUpdate?.({ content: [{ type: "text", text: `Attaching ${params.file} to ${params.key}...` }] });
+
+	// Attach file using jira CLI
+	const result = await pi.exec("jira", ["issue", "attach", params.key, params.file], { signal, timeout: 60000 });
+
+	if (result.code !== 0) {
+		return {
+			content: [{ type: "text", text: getErrorMessage(result.stderr, "Attach file") }],
+			details: { action: "attach", error: result.stderr, issueKey: params.key } as JiraDetails,
+			isError: true,
+		};
+	}
+
+	return {
+		content: [{ type: "text", text: `Attached ${params.file} to ${params.key}` }],
+		details: { action: "attach", output: result.stdout, issueKey: params.key } as JiraDetails,
+	};
+}
+
+/**
+ * List attachments for an issue
+ */
+export async function handleListAttachments(
+	pi: ExtensionAPI,
+	params: any,
+	signal: AbortSignal | undefined,
+	onUpdate: any,
+	ctx: ExtensionContext,
+): Promise<any> {
+	if (!params.key) {
+		return {
+			content: [{ type: "text", text: "Error: 'key' parameter is required for list-attachments action" }],
+			details: { action: "list-attachments", error: "missing_key" } as JiraDetails,
+			isError: true,
+		};
+	}
+
+	onUpdate?.({ content: [{ type: "text", text: `Fetching attachments for ${params.key}...` }] });
+
+	// View issue to get attachments
+	const result = await pi.exec("jira", ["issue", "view", params.key, "--plain"], { signal, timeout: 20000 });
+
+	if (result.code !== 0) {
+		return {
+			content: [{ type: "text", text: getErrorMessage(result.stderr, "List attachments") }],
+			details: { action: "list-attachments", error: result.stderr, issueKey: params.key } as JiraDetails,
+			isError: true,
+		};
+	}
+
+	// Parse output to find attachments section
+	// The jira CLI view output typically includes an "Attachments:" section
+	const lines = result.stdout.split("\n");
+	let inAttachments = false;
+	const attachments: string[] = [];
+
+	for (const line of lines) {
+		if (line.match(/^Attachments?:/i)) {
+			inAttachments = true;
+			continue;
+		}
+
+		if (inAttachments) {
+			// Stop at next section or empty line
+			if (line.match(/^[A-Z][a-z]+:/) || line.trim() === "") {
+				break;
+			}
+			if (line.trim()) {
+				attachments.push(line.trim());
+			}
+		}
+	}
+
+	const output =
+		attachments.length > 0
+			? `Attachments for ${params.key}:\n\n` + attachments.join("\n")
+			: `No attachments found for ${params.key}`;
+
+	return {
+		content: [{ type: "text", text: output }],
+		details: { action: "list-attachments", output, issueKey: params.key } as JiraDetails,
+	};
+}

@@ -0,0 +1,394 @@
+# Jira Extension - Design Notes
+
+## Offline Support Strategy
+
+### Current Challenge
+- Jira requires VPN connection to issues.redhat.com
+- API calls fail when offline or not on VPN
+- Users might want to queue operations while offline
+
+### Proposed Approach: Operation Queue in Session
+
+Store pending operations in session state (similar to git commits):
+
+```typescript
+interface QueuedOperation {
+  id: string;
+  action: "create" | "update" | "comment" | "transition";
+  params: any;
+  timestamp: number;
+  approved: boolean;  // User already approved
+}
+
+// Store in session via appendEntry
+pi.appendEntry("jira-queue", {
+  operations: [/* queued ops */]
+});
+```
+
+### Benefits
+1. **Session-based** - Survives restarts, respects branching
+2. **Already Approved** - User approved when offline, just need to execute
+3. **Git-like Workflow** - Make changes offline, "push" when online
+4. **Transparent** - User sees queued operations in session
+
+### Implementation Steps
+
+1. **Detect Offline** - Try `jira me` with short timeout
+2. **Queue Operation** - Store in session with approval flag
+3. **Show Queued** - Display pending operations to user
+4. **Sync Command** - `/jira-sync` to execute queued operations
+5. **Auto-sync** - Optionally sync on connectivity restore
+
+### Example Workflow
+
+```
+[OFFLINE]
+User: "Create a bug for X"
+Agent: <detects offline>
+→ Shows approval dialog (with "QUEUED" indicator)
+→ User confirms
+→ Stores in session queue
+→ Returns: "Queued for sync (1 pending operation)"
+
+[ONLINE]
+User: "/jira-sync"
+→ Executes queued operations
+→ Returns: "Synced 1 operation: Created SRVKP-1234"
+```
+
+### Conflict Resolution
+
+What if issue changed while offline?
+
+```typescript
+// Before executing queued operation
+const current = await viewIssue(op.params.key);
+
+if (hasConflict(current, op)) {
+  const confirmed = await ctx.ui.confirm(
+    "Conflict Detected",
+    `Issue ${op.params.key} changed since queued.\n\n` +
+    `Queued: ${op.params.field} = ${op.params.value}\n` +
+    `Current: ${current[op.params.field]}\n\n` +
+    `Continue with update?`
+  );
+  
+  if (!confirmed) {
+    // Skip this operation
+  }
+}
+```
+
+### Session Entry Structure
+
+```typescript
+// Queued operations
+{
+  type: "custom",
+  customType: "jira-queue",
+  timestamp: Date.now(),
+  data: {
+    operations: [
+      {
+        id: "op-1234",
+        action: "create",
+        params: { issueType: "Bug", summary: "..." },
+        timestamp: Date.now(),
+        approved: true
+      }
+    ]
+  }
+}
+
+// Sync results
+{
+  type: "custom",
+  customType: "jira-sync",
+  timestamp: Date.now(),
+  data: {
+    synced: 3,
+    failed: 0,
+    results: [
+      { id: "op-1234", success: true, issueKey: "SRVKP-5678" }
+    ]
+  }
+}
+```
+
+### When to Implement?
+
+**Wait for real need** - Implement when:
+1. You frequently work offline
+2. You make multiple Jira changes in one session
+3. VPN connectivity is unreliable
+
+For now, the extension fails gracefully with clear error messages about VPN/network.
+
+---
+
+## Batch Operations Strategy
+
+### Use Cases
+
+#### 1. Sprint Planning
+```
+User: "Add SRVKP-1234, SRVKP-1235, SRVKP-1236 to current sprint"
+→ Batch operation: transition multiple issues
+```
+
+#### 2. Bulk Labeling
+```
+User: "Add 'release-notes-pending' label to all issues in current sprint"
+→ Batch operation: update labels on multiple issues
+```
+
+#### 3. Team Assignment
+```
+User: "Assign all unassigned tasks in SRVKP to the team rotation"
+→ Batch operation: update assignee on multiple issues
+```
+
+#### 4. Status Updates
+```
+User: "Move all code-reviewed issues to QE Review"
+→ Batch operation: transition multiple issues
+```
+
+### Proposed Design
+
+Add a `batch` action that operates on multiple issues:
+
+```typescript
+{
+  action: "batch",
+  operation: "transition" | "update" | "comment",
+  issues: ["SRVKP-1234", "SRVKP-1235", "SRVKP-1236"],
+  // Operation-specific params
+  state: "In Progress",  // For transition
+  // OR
+  field: "labels",  // For update
+  value: "release-notes",
+  // OR
+  comment: "Bulk update comment"
+}
+```
+
+### Approval Pattern
+
+Show all changes in one dialog:
+
+```
+┌─────────────────────────────────────┐
+│ Batch Transition (3 issues)?       │
+│                                     │
+│ Issues:                             │
+│   • SRVKP-1234: Fix bug X          │
+│   • SRVKP-1235: Add feature Y      │
+│   • SRVKP-1236: Update docs Z      │
+│                                     │
+│ Change: To Do → In Progress         │
+│                                     │
+│ This will transition 3 issues.      │
+│                                     │
+│ [Yes] [No]                          │
+└─────────────────────────────────────┘
+```
+
+### Implementation
+
+```typescript
+async function handleBatch(pi, params, signal, onUpdate, ctx) {
+  // Validate
+  if (!params.issues || params.issues.length === 0) {
+    return error("No issues specified");
+  }
+  
+  // Get issue details for approval
+  const details = await fetchIssueDetails(params.issues);
+  
+  // Approval
+  if (ctx.hasUI) {
+    const confirmed = await ctx.ui.confirm(
+      `Batch ${params.operation} (${params.issues.length} issues)?`,
+      buildBatchConfirmation(params, details)
+    );
+    
+    if (!confirmed) {
+      return { cancelled: true };
+    }
+  }
+  
+  // Execute on each issue
+  const results = [];
+  for (const issueKey of params.issues) {
+    onUpdate?.({ 
+      content: [{ 
+        type: "text", 
+        text: `Processing ${issueKey}...` 
+      }] 
+    });
+    
+    const result = await executeOperation(
+      issueKey, 
+      params.operation, 
+      params
+    );
+    
+    results.push(result);
+  }
+  
+  // Return aggregated results
+  const succeeded = results.filter(r => r.success).length;
+  const failed = results.filter(r => !r.success).length;
+  
+  return {
+    content: [{
+      type: "text",
+      text: `Batch ${params.operation} complete:\n` +
+            `  Succeeded: ${succeeded}\n` +
+            `  Failed: ${failed}`
+    }],
+    details: {
+      action: "batch",
+      operation: params.operation,
+      results
+    }
+  };
+}
+```
+
+### When to Implement?
+
+**Wait for real need** - Implement when:
+1. You frequently need to update 5+ issues at once
+2. Sprint planning requires bulk operations
+3. Team workflows involve batch status changes
+
+For now, you can:
+- Make individual API calls (jira CLI is fast)
+- Use JQL search + manual batch via web UI if needed
+- Script batch operations outside of pi if critical
+
+---
+
+## Recommendations
+
+### Phase 1: Current Implementation ✅
+- All 8 core actions (me, list, view, search, create, update, comment, transition)
+- Approval gates for write operations
+- Custom rendering
+- State management
+- Error handling
+
+### Phase 2: Epic and Feature Support 🎯
+**NEXT PRIORITY** - You mentioned epics and features are important:
+
+```typescript
+// Add epic-specific actions
+{
+  action: "epic-view",
+  key: "SRVKP-1234"  // View epic with child issues
+}
+
+{
+  action: "epic-create",
+  summary: "Epic: Major feature",
+  description: "..."
+}
+
+{
+  action: "link-to-epic",
+  issue: "SRVKP-5678",
+  epic: "SRVKP-1234"
+}
+```
+
+### Phase 3: Attachments and Links 📎
+**SECOND PRIORITY** - You want these features:
+
+```typescript
+// Attachments
+{
+  action: "attach",
+  key: "SRVKP-1234",
+  file: "/path/to/file"
+}
+
+{
+  action: "list-attachments",
+  key: "SRVKP-1234"
+}
+
+// Issue links
+{
+  action: "link",
+  from: "SRVKP-1234",
+  to: "SRVKP-5678",
+  type: "blocks" | "relates to" | "duplicates"
+}
+```
+
+### Phase 4: Offline Support 📡
+**Wait for need** - Implement if:
+- VPN is unreliable
+- You work offline frequently
+- You want to queue multiple operations
+
+### Phase 5: Batch Operations 📦
+**Wait for need** - Implement if:
+- You regularly update 5+ issues
+- Sprint planning requires bulk ops
+- Clear use cases emerge
+
+---
+
+## Next Steps
+
+1. **Test the Extension**
+   - Try all 8 actions
+   - Verify approval dialogs work
+   - Test error handling (VPN off, wrong issue key, etc.)
+
+2. **Add Epic Support** (Phase 2)
+   - `epic-view` - View epic with child issues
+   - `epic-create` - Create new epic
+   - `link-to-epic` - Link issue to epic
+   - `unlink-from-epic` - Remove epic link
+
+3. **Add Feature Support**
+   - Ensure Feature type works in create
+   - Add Feature-specific fields if needed
+
+4. **Add Attachments** (Phase 3)
+   - `attach` - Attach file to issue
+   - `list-attachments` - List attachments
+   - `download-attachment` - Download file
+
+5. **Add Links** (Phase 3)
+   - `link` - Create issue link
+   - `unlink` - Remove issue link
+   - `list-links` - Show related issues
+
+---
+
+## Implementation Priority
+
+```
+NOW    → Test current 8 actions
+NEXT   → Epic support (epic-view, epic-create, link-to-epic)
+THEN   → Feature type validation
+THEN   → Attachments (attach, list-attachments)
+THEN   → Links (link, unlink, list-links)
+LATER  → Offline support (if needed)
+LATER  → Batch operations (if needed)
+```
+
+---
+
+## Questions?
+
+- **Offline**: Queue operations in session, sync when online (similar to git)
+- **Batch**: Useful but wait for real need; single operations are fast enough for now
+- **Epic**: Should be next priority since you use epics/features
+- **Attachments**: Second priority for documentation and screenshots

@@ -0,0 +1,133 @@
+/**
+ * Epic-related action handlers for Jira extension
+ */
+
+import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { JiraDetails } from "./types";
+import { getErrorMessage } from "./utils";
+
+/**
+ * View epic with all child issues
+ */
+export async function handleEpicView(
+	pi: ExtensionAPI,
+	params: any,
+	signal: AbortSignal | undefined,
+	onUpdate: any,
+	ctx: ExtensionContext,
+): Promise<any> {
+	if (!params.key) {
+		return {
+			content: [{ type: "text", text: "Error: 'key' parameter is required for epic-view action" }],
+			details: { action: "epic-view", error: "missing_key" } as JiraDetails,
+			isError: true,
+		};
+	}
+
+	onUpdate?.({ content: [{ type: "text", text: `Fetching epic ${params.key}...` }] });
+
+	// First, view the epic itself
+	const epicResult = await pi.exec("jira", ["issue", "view", params.key, "--plain"], { signal, timeout: 20000 });
+
+	if (epicResult.code !== 0) {
+		return {
+			content: [{ type: "text", text: getErrorMessage(epicResult.stderr, "View epic") }],
+			details: { action: "epic-view", error: epicResult.stderr, issueKey: params.key } as JiraDetails,
+			isError: true,
+		};
+	}
+
+	onUpdate?.({ content: [{ type: "text", text: `Fetching child issues for ${params.key}...` }] });
+
+	// Then, list all issues linked to this epic
+	const childrenResult = await pi.exec(
+		"jira",
+		["issue", "list", "--plain", "--jql", `"Epic Link" = ${params.key}`],
+		{ signal, timeout: 30000 },
+	);
+
+	let output = `Epic: ${params.key}\n\n`;
+	output += `${epicResult.stdout}\n\n`;
+	output += `=`.repeat(80) + "\n\n";
+	output += `Child Issues:\n\n`;
+
+	if (childrenResult.code === 0 && childrenResult.stdout.trim()) {
+		output += childrenResult.stdout;
+	} else {
+		output += "No child issues found.";
+	}
+
+	return {
+		content: [{ type: "text", text: output }],
+		details: { action: "epic-view", output, issueKey: params.key } as JiraDetails,
+	};
+}
+
+/**
+ * Link issue to epic
+ */
+export async function handleLinkToEpic(
+	pi: ExtensionAPI,
+	params: any,
+	signal: AbortSignal | undefined,
+	onUpdate: any,
+	ctx: ExtensionContext,
+): Promise<any> {
+	if (!params.issue) {
+		return {
+			content: [{ type: "text", text: "Error: 'issue' parameter is required for link-to-epic action" }],
+			details: { action: "link-to-epic", error: "missing_issue" } as JiraDetails,
+			isError: true,
+		};
+	}
+
+	if (!params.epic) {
+		return {
+			content: [{ type: "text", text: "Error: 'epic' parameter is required for link-to-epic action" }],
+			details: { action: "link-to-epic", error: "missing_epic" } as JiraDetails,
+			isError: true,
+		};
+	}
+
+	// APPROVAL GATE
+	if (ctx.hasUI) {
+		const confirmMessage = `Issue: ${params.issue}\nEpic: ${params.epic}\n\nThis will link the issue to the epic.`;
+
+		const confirmed = await ctx.ui.confirm(`Link ${params.issue} to epic?`, confirmMessage);
+
+		if (!confirmed) {
+			ctx.ui.notify("Link to epic cancelled", "info");
+			return {
+				content: [{ type: "text", text: "Link operation cancelled by user" }],
+				details: { action: "link-to-epic", cancelled: true } as JiraDetails,
+			};
+		}
+	}
+
+	onUpdate?.({ content: [{ type: "text", text: `Linking ${params.issue} to epic ${params.epic}...` }] });
+
+	// Link issue to epic using edit command
+	const result = await pi.exec("jira", ["issue", "edit", params.issue, "--epic", params.epic], {
+		signal,
+		timeout: 20000,
+	});
+
+	if (result.code !== 0) {
+		return {
+			content: [{ type: "text", text: getErrorMessage(result.stderr, "Link to epic") }],
+			details: { action: "link-to-epic", error: result.stderr } as JiraDetails,
+			isError: true,
+		};
+	}
+
+	return {
+		content: [{ type: "text", text: `Linked ${params.issue} to epic ${params.epic}` }],
+		details: {
+			action: "link-to-epic",
+			output: result.stdout,
+			issueKey: params.issue,
+			fromKey: params.issue,
+			toKey: params.epic,
+		} as JiraDetails,
+	};
+}

@@ -0,0 +1,913 @@
+/**
+ * Pi Extension: Jira Issue Management
+ *
+ * Provides Jira issue management for issues.redhat.com with:
+ * - Read operations: me, list, view, search
+ * - Write operations (with approval): create, update, comment, transition
+ * - Custom rendering for issues
+ * - State management for current user
+ *
+ * Configuration:
+ *   ~/.config/.jira/.config.yml - Jira CLI config
+ *   passage show redhat/issues/token/kyushu - API token
+ *
+ * Requirements:
+ *   - jira CLI: go install github.com/ankitpokhrel/jira-cli/cmd/jira@latest
+ *   - Red Hat VPN connection
+ */
+
+import type { ExtensionAPI, ExtensionContext, Theme } from "@mariozechner/pi-coding-agent";
+import { Text } from "@mariozechner/pi-tui";
+import { Type } from "@sinclair/typebox";
+import { StringEnum } from "@mariozechner/pi-ai";
+
+import type { JiraDetails } from "./types";
+import {
+	handleMe,
+	handleList,
+	handleView,
+	handleSearch,
+	handleCreate,
+	handleUpdate,
+	handleComment,
+	handleTransition,
+} from "./actions";
+import { handleEpicView, handleLinkToEpic } from "./epic-actions";
+import { handleLink, handleUnlink } from "./link-actions";
+import { handleAttach, handleListAttachments } from "./attachment-actions";
+import { parseIssueList, parseIssueListJSON, getStatusColor, getPriorityColor, truncate } from "./utils";
+
+export default function (pi: ExtensionAPI) {
+	// ========================================================================
+	// State Management
+	// ========================================================================
+
+	let currentUser = "";
+	let recentIssues: string[] = [];
+
+	// Reconstruct state from session
+	const reconstructState = (ctx: ExtensionContext) => {
+		currentUser = "";
+		recentIssues = [];
+
+		for (const entry of ctx.sessionManager.getBranch()) {
+			if (entry.type !== "message") continue;
+			const msg = entry.message;
+			if (msg.role !== "toolResult" || msg.toolName !== "jira") continue;
+
+			const details = msg.details as JiraDetails | undefined;
+			if (details?.action === "me" && details.output) {
+				currentUser = details.output.trim();
+			}
+
+			// Track recent issue keys
+			if (details?.issueKey && !recentIssues.includes(details.issueKey)) {
+				recentIssues.push(details.issueKey);
+			}
+			if (details?.issueKeys) {
+				for (const key of details.issueKeys) {
+					if (!recentIssues.includes(key)) {
+						recentIssues.push(key);
+					}
+				}
+			}
+		}
+
+		// Keep only last 20 issues
+		if (recentIssues.length > 20) {
+			recentIssues = recentIssues.slice(-20);
+		}
+	};
+
+	// Session events
+	pi.on("session_start", async (_event, ctx) => reconstructState(ctx));
+	pi.on("session_switch", async (_event, ctx) => reconstructState(ctx));
+	pi.on("session_fork", async (_event, ctx) => reconstructState(ctx));
+	pi.on("session_tree", async (_event, ctx) => reconstructState(ctx));
+
+	// ========================================================================
+	// Tool Registration
+	// ========================================================================
+
+	pi.registerTool({
+		name: "jira",
+		label: "Jira",
+		description:
+			"Manage Jira issues on issues.redhat.com. " +
+			"Actions: me (get current user), list (list issues), view (view issue details), " +
+			"search (JQL search), create (create issue), update (update field), " +
+			"comment (add comment), transition (change state). " +
+			"Use 'me' as assignee value to refer to current user. " +
+			"Write operations (create, update, comment, transition) require user approval.",
+
+		parameters: Type.Object({
+			action: StringEnum([
+				"me",
+				"list",
+				"view",
+				"search",
+				"create",
+				"update",
+				"comment",
+				"transition",
+				"epic-view",
+				"link-to-epic",
+				"link",
+				"unlink",
+				"attach",
+				"list-attachments",
+			] as const),
+
+			// List/Search parameters
+			assignee: Type.Optional(
+				Type.String({
+					description: "Filter by assignee (username or 'me' for current user)",
+				}),
+			),
+			status: Type.Optional(
+				Type.String({
+					description: "Filter by status (comma-separated, or '~Done' for not Done)",
+				}),
+			),
+			type: Type.Optional(
+				Type.String({
+					description: "Filter by type: Bug, Task, Story, Epic, Feature (comma-separated)",
+				}),
+			),
+			priority: Type.Optional(
+				Type.String({
+					description: "Filter by priority: Blocker, Critical, Major, Minor, Trivial (comma-separated)",
+				}),
+			),
+			limit: Type.Optional(
+				Type.Number({
+					description: "Maximum number of results (default 20 for list, 50 for search)",
+				}),
+			),
+			epic: Type.Optional(
+				Type.String({
+					description: "Filter by epic key (e.g., SRVKP-1234)",
+				}),
+			),
+
+			// View parameter
+			key: Type.Optional(
+				Type.String({
+					description: "Issue key (e.g., SRVKP-1234)",
+				}),
+			),
+
+			// Search parameter
+			jql: Type.Optional(
+				Type.String({
+					description: "JQL query for advanced search",
+				}),
+			),
+
+			// Create parameters
+			issueType: Type.Optional(
+				Type.String({
+					description: "Issue type: Bug, Task, Story, Epic, Feature, Sub-task",
+				}),
+			),
+			summary: Type.Optional(
+				Type.String({
+					description: "Issue title/summary",
+				}),
+			),
+			description: Type.Optional(
+				Type.String({
+					description: "Issue description",
+				}),
+			),
+			labels: Type.Optional(
+				Type.Array(Type.String(), {
+					description: "Issue labels",
+				}),
+			),
+			parent: Type.Optional(
+				Type.String({
+					description: "Parent issue key for sub-tasks",
+				}),
+			),
+
+			// Update parameters
+			field: Type.Optional(
+				Type.String({
+					description: "Field to update: assignee, priority, labels, summary, description",
+				}),
+			),
+			value: Type.Optional(
+				Type.String({
+					description: "New value for the field",
+				}),
+			),
+
+			// Comment parameter
+			comment: Type.Optional(
+				Type.String({
+					description: "Comment text",
+				}),
+			),
+
+			// Transition parameter
+			state: Type.Optional(
+				Type.String({
+					description: "New state: To Do, In Progress, Code Review, QE Review, Done, Blocked, etc.",
+				}),
+			),
+
+			// Epic parameters
+			issue: Type.Optional(
+				Type.String({
+					description: "Issue key to link to epic",
+				}),
+			),
+
+			// Link parameters
+			from: Type.Optional(
+				Type.String({
+					description: "Source issue key for linking",
+				}),
+			),
+			to: Type.Optional(
+				Type.String({
+					description: "Target issue key for linking",
+				}),
+			),
+			linkType: Type.Optional(
+				Type.String({
+					description: "Link type: blocks, is blocked by, relates to, duplicates, is duplicated by",
+				}),
+			),
+
+			// Attachment parameter
+			file: Type.Optional(
+				Type.String({
+					description: "File path to attach",
+				}),
+			),
+		}),
+
+		async execute(toolCallId, params, signal, onUpdate, ctx) {
+			try {
+				// Route to appropriate handler
+				switch (params.action) {
+					case "me":
+						return await handleMe(pi, params, signal, onUpdate, ctx);
+
+					case "list":
+						return await handleList(pi, params, signal, onUpdate, ctx, currentUser);
+
+					case "view":
+						return await handleView(pi, params, signal, onUpdate, ctx);
+
+					case "search":
+						return await handleSearch(pi, params, signal, onUpdate, ctx);
+
+					case "create":
+						return await handleCreate(pi, params, signal, onUpdate, ctx, currentUser);
+
+					case "update":
+						return await handleUpdate(pi, params, signal, onUpdate, ctx, currentUser);
+
+					case "comment":
+						return await handleComment(pi, params, signal, onUpdate, ctx);
+
+					case "transition":
+						return await handleTransition(pi, params, signal, onUpdate, ctx);
+
+					case "epic-view":
+						return await handleEpicView(pi, params, signal, onUpdate, ctx);
+
+					case "link-to-epic":
+						return await handleLinkToEpic(pi, params, signal, onUpdate, ctx);
+
+					case "link":
+						return await handleLink(pi, params, signal, onUpdate, ctx);
+
+					case "unlink":
+						return await handleUnlink(pi, params, signal, onUpdate, ctx);
+
+					case "attach":
+						return await handleAttach(pi, params, signal, onUpdate, ctx);
+
+					case "list-attachments":
+						return await handleListAttachments(pi, params, signal, onUpdate, ctx);
+
+					default:
+						return {
+							content: [{ type: "text", text: `Unknown action: ${params.action}` }],
+							details: { action: params.action, error: "unknown_action" } as JiraDetails,
+							isError: true,
+						};
+				}
+			} catch (error) {
+				return {
+					content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+					details: { action: params.action, error: String(error) } as JiraDetails,
+					isError: true,
+				};
+			}
+		},
+
+		// ====================================================================
+		// Custom Rendering
+		// ====================================================================
+
+		renderCall(args, theme) {
+			let text = theme.fg("toolTitle", theme.bold("jira "));
+			text += theme.fg("muted", args.action);
+
+			if (args.key) {
+				text += " " + theme.fg("accent", args.key);
+			}
+
+			if (args.summary) {
+				text += " " + theme.fg("dim", `"${truncate(args.summary, 50)}"`);
+			}
+
+			if (args.jql) {
+				text += " " + theme.fg("dim", `"${truncate(args.jql, 50)}"`);
+			}
+
+			return new Text(text, 0, 0);
+		},
+
+		renderResult(result, { expanded }, theme) {
+			const details = result.details as JiraDetails | undefined;
+
+			if (!details) {
+				const text = result.content[0];
+				return new Text(text?.type === "text" ? text.text : "", 0, 0);
+			}
+
+			if (details.error) {
+				return new Text(theme.fg("error", `✗ Error: ${details.error}`), 0, 0);
+			}
+
+			if (details.cancelled) {
+				return new Text(theme.fg("warning", "✗ Cancelled by user"), 0, 0);
+			}
+
+			switch (details.action) {
+				case "me":
+					return renderMe(details, theme);
+
+				case "list":
+				case "search":
+					return renderList(details, expanded, theme);
+
+				case "view":
+					return renderView(details, expanded, theme);
+
+				case "create":
+					return renderCreate(details, theme);
+
+				case "update":
+					return renderUpdate(details, theme);
+
+				case "comment":
+					return renderComment(details, theme);
+
+				case "transition":
+					return renderTransition(details, theme);
+
+				case "epic-view":
+					return renderEpicView(details, expanded, theme);
+
+				case "link-to-epic":
+					return renderLinkToEpic(details, theme);
+
+				case "link":
+					return renderLink(details, theme);
+
+				case "unlink":
+					return renderUnlink(details, theme);
+
+				case "attach":
+					return renderAttach(details, theme);
+
+				case "list-attachments":
+					return renderListAttachments(details, expanded, theme);
+
+				default:
+					return new Text(details.output || "", 0, 0);
+			}
+		},
+	});
+
+	// ========================================================================
+	// Slash Commands
+	// ========================================================================
+
+	// /jira - Show my open issues
+	pi.registerCommand("jira", {
+		description: "Show my open Jira issues in SRVKP project",
+		handler: async (_args, ctx) => {
+			if (!ctx.hasUI) {
+				ctx.ui.notify("/jira requires interactive mode", "error");
+				return;
+			}
+
+			// Get current user if not cached
+			if (!currentUser) {
+				const meResult = await pi.exec("jira", ["me"], { timeout: 10000 });
+				if (meResult.code === 0) {
+					currentUser = meResult.stdout.trim();
+				}
+			}
+
+			// List my open issues directly (default to SRVKP project)
+			const args = [
+				"issue",
+				"list",
+				"--raw",
+				"--project",
+				"SRVKP",
+				"-a",
+				currentUser || "currentUser()",
+				"-s",
+				"~Done",
+				"--paginate",
+				"20",
+			];
+
+			const result = await pi.exec("jira", args, { timeout: 30000 });
+
+			if (result.code !== 0) {
+				ctx.ui.notify(`Error: ${result.stderr}`, "error");
+				return;
+			}
+
+			const issues = parseIssueListJSON(result.stdout);
+
+			// Display results directly (like org-todos)
+			const lines: string[] = [];
+			lines.push("## 📋 My Open Issues (SRVKP)");
+			lines.push("");
+			lines.push(`_Command: \`jira ${args.join(" ")}\`_`);
+			lines.push("");
+
+			if (issues.length === 0) {
+				lines.push("*No open issues* ✨");
+			} else {
+				// Table format for better alignment
+				lines.push("| Key | Type | Priority | Status | Summary |");
+				lines.push("|-----|------|----------|--------|---------|");
+				for (const issue of issues) {
+					const priority = issue.priority || "-";
+					const summary = truncate(issue.summary, 80);
+					lines.push(`| ${issue.key} | ${issue.type} | ${priority} | ${issue.status} | ${summary} |`);
+				}
+			}
+
+			pi.sendMessage({
+				customType: "jira-list",
+				content: lines.join("\n"),
+				display: true,
+			});
+		},
+	});
+
+	// /jira-view <key> - View specific issue
+	pi.registerCommand("jira-view", {
+		description: "View a Jira issue (e.g., /jira-view SRVKP-1234)",
+		handler: async (args, ctx) => {
+			if (!args) {
+				ctx.ui.notify("Usage: /jira-view ISSUE-KEY", "error");
+				return;
+			}
+
+			const issueKey = args.trim();
+
+			// Validate issue key format (at least 2 uppercase letters, dash, numbers)
+			if (!/^[A-Z]{2,}-\d+$/.test(issueKey)) {
+				ctx.ui.notify(`Invalid issue key format: ${issueKey}`, "error");
+				return;
+			}
+
+			// View issue directly
+			const result = await pi.exec("jira", ["issue", "view", issueKey, "--plain"], { timeout: 20000 });
+
+			if (result.code !== 0) {
+				ctx.ui.notify(`Error: ${result.stderr}`, "error");
+				return;
+			}
+
+			// Display result directly
+			pi.sendMessage({
+				customType: "jira-view",
+				content: `## 🔍 ${issueKey}\n\n_Command: \`jira issue view ${issueKey} --plain\`_\n\n${result.stdout}`,
+				display: true,
+			});
+		},
+	});
+
+	// /jira-search <query> - Search with JQL
+	pi.registerCommand("jira-search", {
+		description: "Search Jira with JQL (defaults to SRVKP project)",
+		handler: async (args, ctx) => {
+			if (!args) {
+				ctx.ui.notify("Usage: /jira-search <JQL query>", "error");
+				return;
+			}
+
+			let jql = args.trim();
+
+			// Default to SRVKP project if no project specified in JQL
+			if (!jql.toLowerCase().includes("project")) {
+				jql = `project = SRVKP AND ${jql}`;
+			}
+
+			// Search directly
+			const result = await pi.exec("jira", ["issue", "list", "--raw", "--jql", jql, "--paginate", "50"], {
+				timeout: 30000,
+			});
+
+			if (result.code !== 0) {
+				ctx.ui.notify(`Error: ${result.stderr}`, "error");
+				return;
+			}
+
+			const issues = parseIssueListJSON(result.stdout);
+
+			// Display results directly
+			const lines: string[] = [];
+			lines.push(`## 🔎 Search Results`);
+			lines.push(`Query: \`${jql}\``);
+			lines.push("");
+
+			if (issues.length === 0) {
+				lines.push("*No issues found*");
+			} else {
+				// Table format
+				lines.push("| Key | Type | Priority | Status | Summary |");
+				lines.push("|-----|------|----------|--------|---------|");
+				for (const issue of issues) {
+					const priority = issue.priority || "-";
+					const summary = truncate(issue.summary, 80);
+					lines.push(`| ${issue.key} | ${issue.type} | ${priority} | ${issue.status} | ${summary} |`);
+				}
+			}
+
+			pi.sendMessage({
+				customType: "jira-search",
+				content: lines.join("\n"),
+				display: true,
+			});
+		},
+	});
+
+	// /jira-mine - My issues (shorthand)
+	pi.registerCommand("jira-mine", {
+		description: "Show all issues assigned to me in SRVKP",
+		handler: async (_args, ctx) => {
+			// Get current user if not cached
+			if (!currentUser) {
+				const meResult = await pi.exec("jira", ["me"], { timeout: 10000 });
+				if (meResult.code === 0) {
+					currentUser = meResult.stdout.trim();
+				}
+			}
+
+			// List all my issues directly (default to SRVKP)
+			const args = [
+				"issue",
+				"list",
+				"--raw",
+				"--project",
+				"SRVKP",
+				"-a",
+				currentUser || "currentUser()",
+				"--paginate",
+				"50",
+			];
+
+			const result = await pi.exec("jira", args, { timeout: 30000 });
+
+			if (result.code !== 0) {
+				ctx.ui.notify(`Error: ${result.stderr}`, "error");
+				return;
+			}
+
+			const issues = parseIssueListJSON(result.stdout);
+
+			// Display results directly
+			const lines: string[] = [];
+			lines.push("## 👤 My Issues (SRVKP)");
+			lines.push("");
+			lines.push(`_Command: \`jira ${args.join(" ")}\`_`);
+			lines.push("");
+
+			if (issues.length === 0) {
+				lines.push("*No issues assigned to you*");
+			} else {
+				// Group by status
+				const byStatus = new Map<string, typeof issues>();
+				for (const issue of issues) {
+					const status = issue.status;
+					if (!byStatus.has(status)) {
+						byStatus.set(status, []);
+					}
+					byStatus.get(status)!.push(issue);
+				}
+
+				for (const [status, statusIssues] of byStatus) {
+					lines.push(`### ${status} (${statusIssues.length})`);
+					lines.push("");
+					lines.push("| Key | Type | Priority | Summary |");
+					lines.push("|-----|------|----------|---------|");
+					for (const issue of statusIssues) {
+						const priority = issue.priority || "-";
+						const summary = truncate(issue.summary, 80);
+						lines.push(`| ${issue.key} | ${issue.type} | ${priority} | ${summary} |`);
+					}
+					lines.push("");
+				}
+			}
+
+			pi.sendMessage({
+				customType: "jira-mine",
+				content: lines.join("\n"),
+				display: true,
+			});
+		},
+	});
+
+	// /jira-blocked - Blocked issues
+	pi.registerCommand("jira-blocked", {
+		description: "Show blocked issues in SRVKP project",
+		handler: async (_args, ctx) => {
+			// Search for blocked issues directly (default to SRVKP)
+			const args = ["issue", "list", "--raw", "--project", "SRVKP", "-s", "Blocked,Waiting", "--paginate", "50"];
+
+			const result = await pi.exec("jira", args, { timeout: 30000 });
+
+			if (result.code !== 0) {
+				ctx.ui.notify(`Error: ${result.stderr}`, "error");
+				return;
+			}
+
+			const issues = parseIssueListJSON(result.stdout);
+
+			// Display results directly
+			const lines: string[] = [];
+			lines.push("## 🚫 Blocked Issues (SRVKP)");
+			lines.push("");
+			lines.push(`_Command: \`jira ${args.join(" ")}\`_`);
+			lines.push("");
+
+			if (issues.length === 0) {
+				lines.push("*No blocked issues* ✅");
+			} else {
+				// Table format
+				lines.push("| Key | Type | Priority | Status | Assignee | Summary |");
+				lines.push("|-----|------|----------|--------|----------|---------|");
+				for (const issue of issues) {
+					const priority = issue.priority || "-";
+					const assignee = issue.assignee || "Unassigned";
+					const summary = truncate(issue.summary, 60);
+					lines.push(`| ${issue.key} | ${issue.type} | ${priority} | ${issue.status} | ${assignee} | ${summary} |`);
+				}
+			}
+
+			pi.sendMessage({
+				customType: "jira-blocked",
+				content: lines.join("\n"),
+				display: true,
+			});
+		},
+	});
+
+	// /jira-recent - Recent issues from session
+	pi.registerCommand("jira-recent", {
+		description: "Show recently viewed issues from this session",
+		handler: async (_args, ctx) => {
+			if (!ctx.hasUI) {
+				ctx.ui.notify("/jira-recent requires interactive mode", "error");
+				return;
+			}
+
+			if (recentIssues.length === 0) {
+				ctx.ui.notify("No recent issues in this session", "info");
+				return;
+			}
+
+			const message =
+				`Recent Jira issues:\n` + recentIssues.map((key, i) => `${i + 1}. ${key}`).join("\n");
+
+			ctx.ui.notify(message, "info");
+		},
+	});
+
+	// ========================================================================
+	// Auto-detect Jira Issue Keys in User Input
+	// ========================================================================
+
+	pi.on("input", async (event, ctx) => {
+		// Only process interactive input
+		if (event.source !== "interactive") {
+			return { action: "continue" };
+		}
+
+		// Detect Jira issue keys (e.g., SRVKP-1234, KONFLUX-456, etc.)
+		const issueKeyPattern = /\b([A-Z]{2,}-\d+)\b/g;
+		const matches = event.text.match(issueKeyPattern);
+
+		if (!matches || matches.length === 0) {
+			return { action: "continue" };
+		}
+
+		// Remove duplicates
+		const uniqueKeys = [...new Set(matches)];
+
+		// If user just typed issue keys without context, offer to view them
+		const justKeys = event.text.trim().split(/\s+/).every((word) => /^[A-Z]{2,}-\d+$/.test(word));
+
+		if (justKeys && uniqueKeys.length <= 3 && ctx.hasUI) {
+			// Transform to view request
+			if (uniqueKeys.length === 1) {
+				return {
+					action: "transform",
+					text: `View Jira issue ${uniqueKeys[0]}`,
+				};
+			} else {
+				return {
+					action: "transform",
+					text: `View Jira issues: ${uniqueKeys.join(", ")}`,
+				};
+			}
+		}
+
+		// Otherwise, just continue (LLM will see the keys in context)
+		return { action: "continue" };
+	});
+}
+
+// ============================================================================
+// Rendering Functions
+// ============================================================================
+
+function renderMe(details: JiraDetails, theme: Theme): Text {
+	return new Text(theme.fg("muted", `User: ${theme.fg("accent", details.output || "")}`), 0, 0);
+}
+
+function renderList(details: JiraDetails, expanded: boolean, theme: Theme): Text {
+	if (!details.output) {
+		return new Text(theme.fg("dim", "No issues found"), 0, 0);
+	}
+
+	const issues = parseIssueList(details.output);
+
+	if (issues.length === 0) {
+		return new Text(theme.fg("dim", "No issues found"), 0, 0);
+	}
+
+	let text = theme.fg("muted", `${issues.length} issue(s):`);
+
+	const display = expanded ? issues : issues.slice(0, 5);
+
+	for (const issue of display) {
+		const key = theme.fg("accent", issue.key);
+		const status = getStatusColor(issue.status, theme);
+		const priority = issue.priority ? getPriorityColor(issue.priority, theme) : "";
+		const summary = expanded ? issue.summary : truncate(issue.summary, 60);
+
+		text += `\n${key} ${status}`;
+		if (priority) {
+			text += ` ${priority}`;
+		}
+		text += ` ${theme.fg("text", summary)}`;
+	}
+
+	if (!expanded && issues.length > 5) {
+		text += `\n${theme.fg("dim", `... ${issues.length - 5} more (expand for all)`)}`;
+	}
+
+	return new Text(text, 0, 0);
+}
+
+function renderView(details: JiraDetails, expanded: boolean, theme: Theme): Text {
+	if (!details.output) {
+		return new Text(theme.fg("dim", "No issue details"), 0, 0);
+	}
+
+	const issueKey = details.issueKey || "Issue";
+	const header = theme.fg("accent", theme.bold(issueKey));
+
+	if (expanded) {
+		// Show full output
+		return new Text(`${header}\n\n${details.output}`, 0, 0);
+	} else {
+		// Show summary (first 15 lines)
+		const lines = details.output.split("\n");
+		const preview = lines.slice(0, 15).join("\n");
+
+		let text = `${header}\n\n${preview}`;
+
+		if (lines.length > 15) {
+			text += `\n${theme.fg("dim", `... ${lines.length - 15} more lines (expand for full view)`)}`;
+		}
+
+		return new Text(text, 0, 0);
+	}
+}
+
+function renderCreate(details: JiraDetails, theme: Theme): Text {
+	const key = details.issueKey || "issue";
+	return new Text(theme.fg("success", "✓ Created ") + theme.fg("accent", theme.bold(key)), 0, 0);
+}
+
+function renderUpdate(details: JiraDetails, theme: Theme): Text {
+	const key = details.issueKey || "issue";
+	const field = details.field || "field";
+	const value = details.newValue || "value";
+
+	return new Text(
+		theme.fg("success", "✓ Updated ") + theme.fg("accent", key) + theme.fg("muted", ` (${field} → ${value})`),
+		0,
+		0,
+	);
+}
+
+function renderComment(details: JiraDetails, theme: Theme): Text {
+	const key = details.issueKey || "issue";
+	return new Text(theme.fg("success", "✓ Comment added to ") + theme.fg("accent", key), 0, 0);
+}
+
+function renderTransition(details: JiraDetails, theme: Theme): Text {
+	const key = details.issueKey || "issue";
+	const state = details.toKey || "new state";
+
+	return new Text(theme.fg("success", "✓ Moved ") + theme.fg("accent", key) + theme.fg("muted", ` → ${state}`), 0, 0);
+}
+
+function renderEpicView(details: JiraDetails, expanded: boolean, theme: Theme): Text {
+	if (!details.output) {
+		return new Text(theme.fg("dim", "No epic details"), 0, 0);
+	}
+
+	const issueKey = details.issueKey || "Epic";
+	const header = theme.fg("accent", theme.bold(`Epic: ${issueKey}`));
+
+	if (expanded) {
+		return new Text(`${header}\n\n${details.output}`, 0, 0);
+	} else {
+		// Show summary (first 20 lines)
+		const lines = details.output.split("\n");
+		const preview = lines.slice(0, 20).join("\n");
+
+		let text = `${header}\n\n${preview}`;
+
+		if (lines.length > 20) {
+			text += `\n${theme.fg("dim", `... ${lines.length - 20} more lines (expand for full view)`)}`;
+		}
+
+		return new Text(text, 0, 0);
+	}
+}
+
+function renderLinkToEpic(details: JiraDetails, theme: Theme): Text {
+	const issue = details.fromKey || "issue";
+	const epic = details.toKey || "epic";
+
+	return new Text(theme.fg("success", "✓ Linked ") + theme.fg("accent", issue) + theme.fg("muted", ` → epic ${epic}`), 0, 0);
+}
+
+function renderLink(details: JiraDetails, theme: Theme): Text {
+	const from = details.fromKey || "issue";
+	const to = details.toKey || "issue";
+
+	return new Text(theme.fg("success", "✓ Linked ") + theme.fg("accent", from) + theme.fg("muted", ` ↔ ${to}`), 0, 0);
+}
+
+function renderUnlink(details: JiraDetails, theme: Theme): Text {
+	const from = details.fromKey || "issue";
+	const to = details.toKey || "issue";
+
+	return new Text(theme.fg("success", "✓ Unlinked ") + theme.fg("accent", from) + theme.fg("muted", ` ↮ ${to}`), 0, 0);
+}
+
+function renderAttach(details: JiraDetails, theme: Theme): Text {
+	const key = details.issueKey || "issue";
+
+	return new Text(theme.fg("success", "✓ Attached file to ") + theme.fg("accent", key), 0, 0);
+}
+
+function renderListAttachments(details: JiraDetails, expanded: boolean, theme: Theme): Text {
+	if (!details.output) {
+		return new Text(theme.fg("dim", "No attachments"), 0, 0);
+	}
+
+	const issueKey = details.issueKey || "Issue";
+	const header = theme.fg("accent", `${issueKey} attachments:`);
+
+	if (expanded || details.output.split("\n").length <= 10) {
+		return new Text(`${header}\n${details.output}`, 0, 0);
+	} else {
+		const lines = details.output.split("\n");
+		const preview = lines.slice(0, 10).join("\n");
+		return new Text(`${header}\n${preview}\n${theme.fg("dim", `... ${lines.length - 10} more`)}`, 0, 0);
+	}
+}