diff --git a/backend/alembic/versions/095_add_jira_credential_type.py b/backend/alembic/versions/095_add_jira_credential_type.py
new file mode 100644
index 00000000..67922ced
--- /dev/null
+++ b/backend/alembic/versions/095_add_jira_credential_type.py
@@ -0,0 +1,24 @@
+"""add jira credential type
+
+Revision ID: 095_add_jira_credential_type
+Revises: 093_add_codex_node_support
+Create Date: 2026-07-06 00:00:00.000000
+"""
+
+from collections.abc import Sequence
+
+from alembic import op
+
+revision: str = "095_add_jira_credential_type"
+down_revision: str | Sequence[str] | None = "093_add_codex_node_support"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+
+def upgrade() -> None:
+    op.execute("ALTER TYPE credential_type ADD VALUE IF NOT EXISTS 'jira'")
+
+
+def downgrade() -> None:
+    # PostgreSQL enum values cannot be removed safely without rebuilding the type.
+    pass
diff --git a/backend/alembic/versions/096_merge_jira_file_heads.py b/backend/alembic/versions/096_merge_jira_file_heads.py
new file mode 100644
index 00000000..509374e1
--- /dev/null
+++ b/backend/alembic/versions/096_merge_jira_file_heads.py
@@ -0,0 +1,24 @@
+"""Merge Jira and file team share migration heads.
+
+Revision ID: 096_merge_jira_file_heads
+Revises: 095_add_jira_credential_type, 094_add_file_team_shares
+Create Date: 2026-07-09 00:00:00.000000
+"""
+
+from collections.abc import Sequence
+
+revision: str = "096_merge_jira_file_heads"
+down_revision: tuple[str, str] = (
+    "095_add_jira_credential_type",
+    "094_add_file_team_shares",
+)
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+
+def upgrade() -> None:
+    """Merge the Jira and file team share migration branches."""
+
+
+def downgrade() -> None:
+    """Split the migration graph back into its parent branches."""
diff --git a/backend/app/api/credentials.py b/backend/app/api/credentials.py
index 4b5d93ff..fbee64ac 100644
--- a/backend/app/api/credentials.py
+++ b/backend/app/api/credentials.py
@@ -124,6 +124,14 @@ def merge_credential_config_for_update(
 
         return merged_config
 
+    if credential_type == CredentialType.jira:
+        merged_config = dict(existing_config)
+        for key in ("email", "api_token", "base_url", "api_version", "deployment"):
+            incoming_value = str(incoming_config.get(key, "") or "").strip()
+            if incoming_value:
+                merged_config[key] = incoming_value
+        return merged_config
+
     if credential_type != CredentialType.github:
         return incoming_config
 
@@ -181,6 +189,9 @@ def get_masked_value(credential_type: CredentialType, config: dict) -> str | Non
     ):
         api_key = config.get("api_key", "")
         return mask_api_key(api_key)
+    elif credential_type == CredentialType.jira:
+        api_token = str(config.get("api_token", "")).strip()
+        return mask_api_key(api_token)
     elif credential_type == CredentialType.qdrant:
         openai_api_key = config.get("openai_api_key", "")
         return mask_api_key(openai_api_key)
@@ -274,6 +285,17 @@ def get_public_credential_fields(
     if credential_type == CredentialType.linear:
         auth_mode = str(config.get("auth_mode", "api_key")).strip() or "api_key"
         return {"auth_mode": auth_mode}
+    if credential_type == CredentialType.jira:
+        base_url = str(config.get("base_url", "")).strip() or None
+        email = str(config.get("email", "")).strip() or None
+        api_version = str(config.get("api_version", "") or "").strip() or None
+        deployment = str(config.get("deployment", "") or "").strip() or "cloud"
+        return {
+            "base_url": base_url,
+            "email": email,
+            "api_version": api_version,
+            "deployment": deployment,
+        }
     if credential_type == CredentialType.codex:
         auth_mode = str(config.get("auth_mode", "access_token")).strip() or "access_token"
         fields: dict[str, str | None] = {"auth_mode": auth_mode}
@@ -799,6 +821,7 @@ async def run_credential_connection_test(
     """Test whether a credential configuration can reach the external service."""
     if test_data.type not in {
         CredentialType.supabase,
+        CredentialType.jira,
         CredentialType.linear,
         CredentialType.notion,
         CredentialType.clickhouse,
@@ -827,6 +850,8 @@ async def run_credential_connection_test(
             config = _merge_supabase_test_config(config, stored_config)
         elif test_data.type == CredentialType.linear:
             config = _merge_linear_test_config(config, stored_config)
+        elif test_data.type == CredentialType.jira:
+            config = {**stored_config, **{k: v for k, v in config.items() if v}}
         elif test_data.type == CredentialType.clickhouse:
             config = _merge_clickhouse_test_config(config, stored_config)
         elif test_data.type == CredentialType.sentry:
@@ -861,6 +886,21 @@ async def run_credential_connection_test(
                 )
             return CredentialTestResponse(success=True, message="Connection successful")
 
+        if test_data.type == CredentialType.jira:
+            from app.services.jira_service import JiraService
+
+            service = JiraService(config)
+            try:
+                user = service.test_connection()
+            finally:
+                service.close()
+            user_name = str(
+                user.get("displayName") or user.get("emailAddress") or user.get("accountId") or ""
+            )
+            if user_name:
+                return CredentialTestResponse(success=True, message=f"Connected as {user_name}")
+            return CredentialTestResponse(success=True, message="Connection successful")
+
         if test_data.type == CredentialType.clickhouse:
             from app.services.clickhouse_service import ClickHouseService
 
@@ -1332,6 +1372,35 @@ def validate_credential_config(
                     status_code=status.HTTP_400_BAD_REQUEST,
                     detail="GitHub credential base_url must be a valid http(s) URL",
                 )
+    elif credential_type == CredentialType.jira:
+        if "email" not in config or not str(config["email"]).strip():
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail="Jira credential requires email",
+            )
+        if "api_token" not in config or not str(config["api_token"]).strip():
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail="Jira credential requires api_token",
+            )
+        jira_base_url = str(config.get("base_url", "") or "").strip()
+        if not jira_base_url:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail="Jira credential requires base_url",
+            )
+        parsed = urlparse(jira_base_url)
+        if parsed.scheme not in {"http", "https"} or not parsed.netloc:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail="Jira credential base_url must be a valid http(s) URL",
+            )
+        deployment = str(config.get("deployment", "") or "cloud").strip()
+        if deployment not in {"cloud", "data_center"}:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail="Jira credential deployment must be cloud or data_center",
+            )
     elif credential_type == CredentialType.sentry:
         if "api_token" not in config or not str(config["api_token"]).strip():
             raise HTTPException(
diff --git a/backend/app/db/models.py b/backend/app/db/models.py
index 2024b0ca..18095f50 100644
--- a/backend/app/db/models.py
+++ b/backend/app/db/models.py
@@ -30,6 +30,7 @@ class CredentialType(str, PyEnum):
     codex = "codex"
     google = "google"
     github = "github"
+    jira = "jira"
     linear = "linear"
     custom = "custom"
     bearer = "bearer"
diff --git a/backend/app/models/schemas.py b/backend/app/models/schemas.py
index decf235d..bca699a4 100644
--- a/backend/app/models/schemas.py
+++ b/backend/app/models/schemas.py
@@ -473,6 +473,7 @@ class CredentialType(str, Enum):
     codex = "codex"
     google = "google"
     github = "github"
+    jira = "jira"
     linear = "linear"
     custom = "custom"
     bearer = "bearer"
@@ -518,6 +519,14 @@ class CredentialConfigGitHub(BaseModel):
     base_url: str | None = None
 
 
+class CredentialConfigJira(BaseModel):
+    email: str
+    api_token: str
+    base_url: str
+    deployment: str | None = None
+    api_version: str | None = None
+
+
 class CredentialConfigLinear(BaseModel):
     api_key: str | None = None
     auth_mode: str | None = None
diff --git a/backend/app/services/jira_service.py b/backend/app/services/jira_service.py
new file mode 100644
index 00000000..837ab9bc
--- /dev/null
+++ b/backend/app/services/jira_service.py
@@ -0,0 +1,538 @@
+from __future__ import annotations
+
+from typing import Any
+from urllib.parse import urljoin
+
+import httpx
+
+from app.http_identity import merge_outbound_headers
+
+_DEFAULT_API_VERSION = "3"
+_DEFAULT_DEPLOYMENT = "cloud"
+_DEFAULT_SEARCH_FIELDS = ["key", "summary", "status", "assignee", "issuetype"]
+_DEFAULT_SEARCH_JQL = "updated >= -30d ORDER BY updated DESC"
+_MAX_ERROR_DETAIL_CHARS = 500
+_UNSET = object()
+
+
+class JiraService:
+    """Small REST client for common Jira project, issue, comment, attachment, and user operations."""
+
+    def __init__(self, config: dict[str, Any], client: httpx.Client | None = None) -> None:
+        self._config = dict(config)
+        self._base_url = self._normalize_base_url(str(self._config.get("base_url", "") or ""))
+        self._deployment = self._normalize_deployment(self._config)
+        self._api_version = self._normalize_api_version(self._config, self._deployment)
+        self._client = client or httpx.Client(
+            headers=merge_outbound_headers({"Accept": "application/json"}),
+            timeout=httpx.Timeout(30.0),
+            follow_redirects=True,
+        )
+        self._owns_client = client is None
+
+    def close(self) -> None:
+        """Close the internally owned HTTP client, if any."""
+        if self._owns_client and not self._client.is_closed:
+            self._client.close()
+
+    def test_connection(self) -> dict[str, Any]:
+        """Verify the credential by fetching the current Jira user."""
+        return self.get_myself()
+
+    def get_myself(self) -> dict[str, Any]:
+        """Return the authenticated Jira user."""
+        return self._expect_object(self._request("GET", "/myself"), "myself")
+
+    def list_projects(self, limit: int = 50, start_at: int = 0) -> dict[str, Any]:
+        """List Jira projects visible to the authenticated user."""
+        normalized_limit = self._normalize_limit(limit)
+        offset = max(start_at, 0)
+        if self._is_data_center:
+            payload = self._request("GET", "/project")
+            projects = self._expect_project_list(payload)
+            page = projects[offset : offset + normalized_limit]
+            total = len(projects)
+            return {
+                "values": page,
+                "startAt": offset,
+                "maxResults": normalized_limit,
+                "total": total,
+                "isLast": offset + normalized_limit >= total,
+            }
+        payload = self._request(
+            "GET",
+            "/project/search",
+            params={"maxResults": normalized_limit, "startAt": offset},
+        )
+        return self._expect_object(payload, "project.search")
+
+    def search_issues(
+        self,
+        jql: str,
+        limit: int = 50,
+        *,
+        next_page_token: str | None = None,
+        start_at: int = 0,
+        fields: list[str] | None = None,
+    ) -> dict[str, Any]:
+        """Search issues with JQL."""
+        body: dict[str, Any] = {
+            "jql": jql or _DEFAULT_SEARCH_JQL,
+            "maxResults": self._normalize_limit(limit),
+            "fields": fields or list(_DEFAULT_SEARCH_FIELDS),
+        }
+        if self._is_data_center:
+            body["startAt"] = max(start_at, 0)
+            payload = self._request("POST", "/search", json=body)
+            return self._expect_object(payload, "issue.search")
+        if next_page_token:
+            body["nextPageToken"] = next_page_token
+        payload = self._request("POST", "/search/jql", json=body)
+        return self._expect_object(payload, "issue.search")
+
+    def get_issue(self, issue_key: str) -> dict[str, Any]:
+        """Fetch one Jira issue by key or ID."""
+        payload = self._request("GET", f"/issue/{issue_key}")
+        return self._expect_object(payload, "issue")
+
+    def create_issue(
+        self,
+        project_key: str,
+        issue_type: str,
+        summary: str,
+        description: str | None = None,
+        assignee_account_id: str | None = None,
+        labels: list[str] | None = None,
+        issue_type_id: str | None = None,
+    ) -> dict[str, Any]:
+        """Create a Jira issue."""
+        issuetype: dict[str, str]
+        if issue_type_id:
+            issuetype = {"id": issue_type_id}
+        else:
+            issuetype = {"name": issue_type}
+        fields: dict[str, Any] = {
+            "project": {"key": project_key},
+            "issuetype": issuetype,
+            "summary": summary,
+        }
+        if description:
+            fields["description"] = self._text_document_payload(description)
+        if assignee_account_id:
+            fields["assignee"] = self._user_identity_payload(assignee_account_id)
+        if labels:
+            fields["labels"] = labels
+        return self._expect_object(
+            self._request("POST", "/issue", json={"fields": fields}), "issue"
+        )
+
+    def update_issue(
+        self,
+        issue_key: str,
+        *,
+        summary: Any = _UNSET,
+        description: Any = _UNSET,
+        assignee_account_id: Any = _UNSET,
+        labels: Any = _UNSET,
+    ) -> dict[str, Any]:
+        """Update fields on an existing Jira issue."""
+        fields: dict[str, Any] = {}
+        if summary is not _UNSET:
+            fields["summary"] = summary
+        if description is not _UNSET:
+            fields["description"] = (
+                None if description is None else self._text_document_payload(description)
+            )
+        if assignee_account_id is not _UNSET:
+            fields["assignee"] = (
+                None
+                if assignee_account_id is None
+                else self._user_identity_payload(assignee_account_id)
+            )
+        if labels is not _UNSET:
+            fields["labels"] = labels
+        if not fields:
+            raise ValueError("Jira updateIssue requires at least one field to update")
+        self._request("PUT", f"/issue/{issue_key}", json={"fields": fields}, expect_json=False)
+        return self.get_issue(issue_key)
+
+    def delete_issue(self, issue_key: str) -> bool:
+        """Delete a Jira issue."""
+        self._request("DELETE", f"/issue/{issue_key}", expect_json=False)
+        return True
+
+    def get_issue_changelog(
+        self, issue_key: str, limit: int = 50, start_at: int = 0
+    ) -> dict[str, Any]:
+        """Return the changelog entries for a Jira issue."""
+        normalized_limit = self._normalize_limit(limit)
+        offset = max(start_at, 0)
+        if self._api_version == "2":
+            return self._get_issue_changelog_v2(issue_key, normalized_limit, offset)
+        payload = self._request(
+            "GET",
+            f"/issue/{issue_key}/changelog",
+            params={"maxResults": normalized_limit, "startAt": offset},
+        )
+        return self._expect_object(payload, "issue.changelog")
+
+    def notify_issue(
+        self,
+        issue_key: str,
+        *,
+        subject: str,
+        text_body: str,
+        html_body: str | None = None,
+        to: dict[str, Any] | None = None,
+    ) -> bool:
+        """Send a Jira issue notification."""
+        payload: dict[str, Any] = {
+            "subject": subject,
+            "textBody": text_body,
+            "to": to or {"assignee": True},
+        }
+        if html_body:
+            payload["htmlBody"] = html_body
+        self._request("POST", f"/issue/{issue_key}/notify", json=payload, expect_json=False)
+        return True
+
+    def list_comments(self, issue_key: str, limit: int = 50, start_at: int = 0) -> dict[str, Any]:
+        """List comments on a Jira issue."""
+        payload = self._request(
+            "GET",
+            f"/issue/{issue_key}/comment",
+            params={"maxResults": self._normalize_limit(limit), "startAt": max(start_at, 0)},
+        )
+        return self._expect_object(payload, "issue.comments")
+
+    def create_comment(self, issue_key: str, body: str) -> dict[str, Any]:
+        """Add a comment to a Jira issue."""
+        payload = self._request(
+            "POST",
+            f"/issue/{issue_key}/comment",
+            json={"body": self._text_document_payload(body)},
+        )
+        return self._expect_object(payload, "comment")
+
+    def get_comment(self, issue_key: str, comment_id: str) -> dict[str, Any]:
+        """Fetch one comment on a Jira issue."""
+        payload = self._request("GET", f"/issue/{issue_key}/comment/{comment_id}")
+        return self._expect_object(payload, "comment")
+
+    def update_comment(self, issue_key: str, comment_id: str, body: str) -> dict[str, Any]:
+        """Update a comment on a Jira issue."""
+        payload = self._request(
+            "PUT",
+            f"/issue/{issue_key}/comment/{comment_id}",
+            json={"body": self._text_document_payload(body)},
+        )
+        return self._expect_object(payload, "comment")
+
+    def delete_comment(self, issue_key: str, comment_id: str) -> bool:
+        """Delete a comment from a Jira issue."""
+        self._request("DELETE", f"/issue/{issue_key}/comment/{comment_id}", expect_json=False)
+        return True
+
+    def list_transitions(self, issue_key: str) -> list[dict[str, Any]]:
+        """List available transitions for a Jira issue."""
+        payload = self._expect_object(
+            self._request("GET", f"/issue/{issue_key}/transitions"),
+            "issue.transitions",
+        )
+        transitions = payload.get("transitions")
+        if not isinstance(transitions, list):
+            raise ValueError("Jira API returned an invalid transitions payload")
+        return [transition for transition in transitions if isinstance(transition, dict)]
+
+    def transition_issue(self, issue_key: str, transition_id: str) -> dict[str, Any]:
+        """Transition a Jira issue using a transition ID."""
+        self._request(
+            "POST",
+            f"/issue/{issue_key}/transitions",
+            json={"transition": {"id": transition_id}},
+            expect_json=False,
+        )
+        issue = self.get_issue(issue_key)
+        return {"transitionId": transition_id, "issue": issue}
+
+    def add_attachment(
+        self,
+        issue_key: str,
+        *,
+        filename: str,
+        content: bytes,
+        mime_type: str | None = None,
+    ) -> list[dict[str, Any]]:
+        """Add a file attachment to a Jira issue."""
+        payload = self._request(
+            "POST",
+            f"/issue/{issue_key}/attachments",
+            files={"file": (filename, content, mime_type or "application/octet-stream")},
+            headers={"X-Atlassian-Token": "no-check"},
+        )
+        if not isinstance(payload, list):
+            raise ValueError("Jira API returned an invalid attachment upload payload")
+        return [attachment for attachment in payload if isinstance(attachment, dict)]
+
+    def get_attachment(self, attachment_id: str) -> dict[str, Any]:
+        """Fetch one Jira attachment metadata object."""
+        payload = self._request("GET", f"/attachment/{attachment_id}")
+        return self._expect_object(payload, "attachment")
+
+    def list_attachments(
+        self, issue_key: str, limit: int = 50, start_at: int = 0
+    ) -> dict[str, Any]:
+        """List attachment metadata for a Jira issue."""
+        issue = self.get_issue_with_fields(issue_key, ["attachment"])
+        fields = issue.get("fields")
+        attachments = fields.get("attachment") if isinstance(fields, dict) else []
+        if not isinstance(attachments, list):
+            raise ValueError("Jira API returned an invalid issue attachment payload")
+        normalized = [attachment for attachment in attachments if isinstance(attachment, dict)]
+        normalized_limit = self._normalize_limit(limit)
+        offset = max(start_at, 0)
+        page = normalized[offset : offset + normalized_limit]
+        total = len(normalized)
+        return {
+            "attachments": page,
+            "startAt": offset,
+            "maxResults": normalized_limit,
+            "total": total,
+            "isLast": offset + normalized_limit >= total,
+        }
+
+    def delete_attachment(self, attachment_id: str) -> bool:
+        """Delete a Jira attachment by ID."""
+        self._request("DELETE", f"/attachment/{attachment_id}", expect_json=False)
+        return True
+
+    def download_attachment(self, content_url: str) -> bytes:
+        """Download raw attachment content from Jira's content URL."""
+        payload = self._request_absolute(
+            "GET",
+            content_url,
+            headers={"Accept": "*/*"},
+            expect_json=False,
+        )
+        if not isinstance(payload, bytes):
+            raise ValueError("Jira API returned invalid attachment content")
+        return payload
+
+    def get_user(self, account_id: str) -> dict[str, Any]:
+        """Fetch a Jira user by account ID or Data Center username."""
+        payload = self._request("GET", "/user", params=self._user_identity_params(account_id))
+        return self._expect_object(payload, "user")
+
+    def create_user(
+        self,
+        email_address: str,
+        *,
+        username: str | None = None,
+        display_name: str | None = None,
+        products: list[str] | None = None,
+    ) -> dict[str, Any]:
+        """Create a Jira user."""
+        payload: dict[str, Any] = {"emailAddress": email_address}
+        if self._is_data_center:
+            payload["name"] = username or email_address
+        if display_name:
+            payload["displayName"] = display_name
+        if products and not self._is_data_center:
+            payload["products"] = products
+        result = self._request("POST", "/user", json=payload)
+        return self._expect_object(result, "user")
+
+    def delete_user(self, account_id: str) -> bool:
+        """Delete a Jira user by account ID or Data Center username."""
+        self._request(
+            "DELETE", "/user", params=self._user_identity_params(account_id), expect_json=False
+        )
+        return True
+
+    def get_issue_with_fields(self, issue_key: str, fields: list[str]) -> dict[str, Any]:
+        """Fetch one Jira issue with a restricted fields list."""
+        payload = self._request(
+            "GET",
+            f"/issue/{issue_key}",
+            params={"fields": ",".join(fields)},
+        )
+        return self._expect_object(payload, "issue")
+
+    def _get_issue_changelog_v2(self, issue_key: str, limit: int, start_at: int) -> dict[str, Any]:
+        payload = self._request(
+            "GET",
+            f"/issue/{issue_key}",
+            params={"expand": "changelog", "fields": "none"},
+        )
+        issue = self._expect_object(payload, "issue")
+        changelog = issue.get("changelog")
+        if not isinstance(changelog, dict):
+            raise ValueError("Jira API returned an invalid issue.changelog payload")
+        histories = changelog.get("histories")
+        if not isinstance(histories, list):
+            raise ValueError("Jira API returned an invalid issue.changelog payload")
+        normalized = [history for history in histories if isinstance(history, dict)]
+        total = int(changelog.get("total") or len(normalized))
+        page = normalized[start_at : start_at + limit]
+        return {
+            "histories": page,
+            "startAt": start_at,
+            "maxResults": limit,
+            "total": total,
+            "isLast": start_at + limit >= total,
+        }
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        *,
+        params: dict[str, Any] | None = None,
+        json: dict[str, Any] | None = None,
+        files: dict[str, Any] | None = None,
+        headers: dict[str, str] | None = None,
+        expect_json: bool = True,
+    ) -> Any:
+        return self._request_absolute(
+            method,
+            self._url(path),
+            params=params,
+            json=json,
+            files=files,
+            headers=headers,
+            expect_json=expect_json,
+        )
+
+    def _request_absolute(
+        self,
+        method: str,
+        url: str,
+        *,
+        params: dict[str, Any] | None = None,
+        json: dict[str, Any] | None = None,
+        files: dict[str, Any] | None = None,
+        headers: dict[str, str] | None = None,
+        expect_json: bool = True,
+    ) -> Any:
+        email = str(self._config.get("email", "") or "").strip()
+        api_token = str(
+            self._config.get("api_token", "") or self._config.get("api_key", "") or ""
+        ).strip()
+        if not email or not api_token:
+            raise ValueError("Jira credential requires email and api_token")
+        request_headers = {"Accept": "application/json"}
+        if files is None:
+            request_headers["Content-Type"] = "application/json"
+        if headers:
+            request_headers.update(headers)
+        try:
+            response = self._client.request(
+                method,
+                url,
+                params=params,
+                json=json,
+                files=files,
+                auth=(email, api_token),
+                headers=request_headers,
+            )
+            response.raise_for_status()
+        except httpx.HTTPStatusError as exc:
+            detail = self._truncate_error_detail(response.text)
+            raise ValueError(
+                f"Jira API request failed with status {response.status_code}: {detail}"
+            ) from exc
+        except httpx.RequestError as exc:
+            raise ValueError(f"Jira API request failed: {exc}") from exc
+        if not expect_json:
+            return response.content
+        if response.status_code == 204 or not response.content:
+            return {}
+        try:
+            payload = response.json()
+        except ValueError as exc:
+            raise ValueError("Jira API returned non-JSON response") from exc
+        return payload
+
+    def _url(self, path: str) -> str:
+        return urljoin(f"{self._base_url}/rest/api/{self._api_version}/", path.lstrip("/"))
+
+    @property
+    def _is_data_center(self) -> bool:
+        return self._deployment == "data_center"
+
+    def _user_identity_payload(self, value: str) -> dict[str, str]:
+        if self._is_data_center:
+            return {"name": value}
+        return {"accountId": value}
+
+    def _user_identity_params(self, value: str) -> dict[str, str]:
+        if self._is_data_center:
+            return {"username": value}
+        return {"accountId": value}
+
+    def _text_document_payload(self, text: str) -> str | dict[str, Any]:
+        if self._api_version == "2":
+            return text
+        return self._adf_text_document(text)
+
+    @staticmethod
+    def _normalize_base_url(base_url: str) -> str:
+        normalized = base_url.strip().rstrip("/")
+        if not normalized:
+            raise ValueError("Jira credential requires base_url")
+        return normalized
+
+    @staticmethod
+    def _normalize_deployment(config: dict[str, Any]) -> str:
+        raw_deployment = str(config.get("deployment", "") or "").strip().lower().replace("-", "_")
+        if raw_deployment in {"data_center", "datacenter", "server", "self_hosted"}:
+            return "data_center"
+        if raw_deployment == "cloud":
+            return "cloud"
+        if not raw_deployment and str(config.get("api_version", "") or "").strip() == "2":
+            return "data_center"
+        return _DEFAULT_DEPLOYMENT
+
+    @staticmethod
+    def _normalize_api_version(config: dict[str, Any], deployment: str) -> str:
+        if deployment == "data_center":
+            return "2"
+        return str(config.get("api_version") or _DEFAULT_API_VERSION).strip()
+
+    @staticmethod
+    def _normalize_limit(limit: int) -> int:
+        return max(1, min(int(limit), 100))
+
+    @staticmethod
+    def _expect_object(payload: Any, label: str) -> dict[str, Any]:
+        if not isinstance(payload, dict):
+            raise ValueError(f"Jira API returned an invalid {label} payload")
+        return payload
+
+    @staticmethod
+    def _expect_project_list(payload: Any) -> list[dict[str, Any]]:
+        if not isinstance(payload, list):
+            raise ValueError("Jira API returned an invalid project list payload")
+        return [project for project in payload if isinstance(project, dict)]
+
+    @staticmethod
+    def _adf_text_document(text: str) -> dict[str, Any]:
+        lines = text.split("\n")
+        content: list[dict[str, Any]] = []
+        for line in lines:
+            paragraph: dict[str, Any] = {"type": "paragraph"}
+            if line:
+                paragraph["content"] = [{"type": "text", "text": line}]
+            else:
+                paragraph["content"] = []
+            content.append(paragraph)
+        if not content:
+            content = [{"type": "paragraph", "content": []}]
+        return {"type": "doc", "version": 1, "content": content}
+
+    @staticmethod
+    def _truncate_error_detail(detail: str) -> str:
+        normalized = detail.strip()
+        if len(normalized) <= _MAX_ERROR_DETAIL_CHARS:
+            return normalized
+        return f"{normalized[:_MAX_ERROR_DETAIL_CHARS]}..."
diff --git a/backend/app/services/node_execution/nodes/jira_node.py b/backend/app/services/node_execution/nodes/jira_node.py
new file mode 100644
index 00000000..a6a56435
--- /dev/null
+++ b/backend/app/services/node_execution/nodes/jira_node.py
@@ -0,0 +1,459 @@
+from __future__ import annotations
+
+import json
+from base64 import b64decode, b64encode
+from importlib import import_module
+from mimetypes import guess_type
+from typing import Any
+
+from app.services.jira_service import _DEFAULT_SEARCH_JQL, _UNSET
+from app.services.node_execution.base import NodeExecutionContext
+
+
+def execute(ctx: NodeExecutionContext) -> object:
+    """Execute the Jira node."""
+    _workflow_executor = import_module("app.services.workflow_executor")
+    _coerce_boolean = _workflow_executor._coerce_boolean
+    self = ctx.executor
+    node_id = ctx.node_id
+    inputs = ctx.inputs
+    node_data = ctx.node_data
+
+    from app.config import settings
+    from app.db.models import CredentialType
+    from app.db.session import SessionLocal
+    from app.services.encryption import decrypt_config
+    from app.services.jira_service import JiraService
+
+    credential_id = node_data.get("credentialId")
+    if not credential_id:
+        raise ValueError("Jira node requires a credential")
+
+    jira_config: dict[str, Any] = {}
+    with SessionLocal() as db:
+        cred = self._get_accessible_credential(db, credential_id)
+        if cred:
+            if cred.type != CredentialType.jira:
+                raise ValueError("Jira node requires a Jira credential")
+            jira_config = decrypt_config(cred.encrypted_config)
+    if not jira_config:
+        raise ValueError("Jira credential not found or invalid")
+
+    operation = str(node_data.get("jiraOperation", "") or "").strip()
+    if not operation:
+        raise ValueError("Jira node requires an operation")
+
+    def _field(name: str, default: str = "") -> str:
+        raw_value = node_data.get(name, default)
+        if raw_value is None or str(raw_value).strip() == "":
+            return default
+        return self.evaluate_message_template(str(raw_value), inputs, node_id).strip()
+
+    def _limit() -> int:
+        try:
+            return max(1, min(int(float(_field("jiraLimit", "50") or "50")), 100))
+        except (TypeError, ValueError):
+            return 50
+
+    def _start_at() -> int:
+        try:
+            return max(0, int(float(_field("jiraStartAt", "0") or "0")))
+        except (TypeError, ValueError):
+            return 0
+
+    def _next_page_token() -> str | None:
+        token = _field("jiraNextPageToken")
+        return token or None
+
+    def _search_fields() -> list[str] | None:
+        return _string_list_field("jiraFields")
+
+    def _labels() -> list[str] | None:
+        raw_labels = _field("jiraLabels")
+        if not raw_labels:
+            return None
+        try:
+            parsed = json.loads(raw_labels)
+        except json.JSONDecodeError:
+            return [label.strip() for label in raw_labels.split(",") if label.strip()]
+        if not isinstance(parsed, list) or not all(isinstance(label, str) for label in parsed):
+            raise ValueError("Jira labels must be a JSON array of strings or comma-separated text")
+        return parsed
+
+    def _json_object_field(name: str, default: dict[str, Any] | None = None) -> dict[str, Any]:
+        raw_value = _field(name)
+        if not raw_value:
+            return default or {}
+        try:
+            parsed = json.loads(raw_value)
+        except json.JSONDecodeError as exc:
+            raise ValueError(f"Jira {name} must be a JSON object") from exc
+        if not isinstance(parsed, dict):
+            raise ValueError(f"Jira {name} must be a JSON object")
+        return parsed
+
+    def _string_list_field(name: str) -> list[str] | None:
+        raw_value = _field(name)
+        if not raw_value:
+            return None
+        try:
+            parsed = json.loads(raw_value)
+        except json.JSONDecodeError:
+            return [item.strip() for item in raw_value.split(",") if item.strip()]
+        if not isinstance(parsed, list) or not all(isinstance(item, str) for item in parsed):
+            raise ValueError(f"Jira {name} must be a JSON array of strings or comma-separated text")
+        return parsed
+
+    def _attachment_content() -> bytes:
+        base64_content = _field("jiraAttachmentBase64")
+        if not base64_content:
+            raise ValueError("Jira addAttachment requires base64 content")
+        base64_payload = base64_content
+        if base64_payload.startswith("data:"):
+            comma_index = base64_payload.find(",")
+            if comma_index == -1:
+                raise ValueError("Jira attachment content must be valid base64 or a data URL")
+            base64_payload = base64_payload[comma_index + 1 :].strip()
+        try:
+            content = b64decode(base64_payload, validate=True)
+        except Exception as exc:
+            raise ValueError("Jira attachment content must be valid base64") from exc
+        max_bytes = settings.file_max_size_mb * 1024 * 1024
+        if len(content) > max_bytes:
+            raise ValueError(f"Jira attachment exceeds size limit ({settings.file_max_size_mb} MB)")
+        return content
+
+    def _with_optional_binary(attachment: dict[str, Any]) -> dict[str, Any]:
+        output = dict(attachment)
+        if not _coerce_boolean(node_data.get("jiraIncludeBinary"), default=False):
+            return output
+        content_url = str(attachment.get("content") or "").strip()
+        if not content_url:
+            raise ValueError("Jira attachment metadata does not include a content URL")
+        content = service.download_attachment(content_url)
+        output["content_base64"] = b64encode(content).decode("ascii")
+        return output
+
+    def _update_field(name: str) -> Any:
+        if name not in node_data:
+            return _UNSET
+        raw_value = node_data.get(name)
+        if raw_value is None or str(raw_value).strip() == "":
+            return _UNSET
+        resolved = self.evaluate_message_template(str(raw_value), inputs, node_id).strip()
+        if resolved.lower() == "null":
+            return None
+        return resolved
+
+    def _update_labels() -> Any:
+        if "jiraLabels" not in node_data:
+            return _UNSET
+        raw_value = node_data.get("jiraLabels")
+        if raw_value is None or str(raw_value).strip() == "":
+            return _UNSET
+        return _labels()
+
+    service = JiraService(jira_config)
+    try:
+        if operation == "getMyself":
+            output = {"success": True, "operation": operation, "user": service.get_myself()}
+        elif operation == "listProjects":
+            result = service.list_projects(_limit(), _start_at())
+            values = result.get("values") if isinstance(result.get("values"), list) else []
+            output = {
+                "success": True,
+                "operation": operation,
+                "projects": values,
+                "count": len(values),
+                "pagination": _pagination(result),
+            }
+        elif operation == "searchIssues":
+            result = service.search_issues(
+                _field("jiraJql", _DEFAULT_SEARCH_JQL),
+                _limit(),
+                next_page_token=_next_page_token(),
+                start_at=_start_at(),
+                fields=_search_fields(),
+            )
+            issues = result.get("issues") if isinstance(result.get("issues"), list) else []
+            output = {
+                "success": True,
+                "operation": operation,
+                "issues": issues,
+                "count": len(issues),
+                "pagination": _search_pagination(result, _limit()),
+            }
+        elif operation == "getIssue":
+            issue_key = _field("jiraIssueKey")
+            if not issue_key:
+                raise ValueError("Jira getIssue requires an issue key or ID")
+            issue = service.get_issue(issue_key)
+            output = {
+                "success": True,
+                "operation": operation,
+                "issue": issue,
+                "key": issue.get("key"),
+            }
+        elif operation == "createIssue":
+            project_key = _field("jiraProjectKey")
+            summary = _field("jiraSummary")
+            if not project_key or not summary:
+                raise ValueError("Jira createIssue requires project key and summary")
+            issue = service.create_issue(
+                project_key,
+                _field("jiraIssueType", "Task") or "Task",
+                summary,
+                description=_field("jiraDescription") or None,
+                assignee_account_id=_field("jiraAssigneeAccountId") or None,
+                labels=_labels(),
+                issue_type_id=_field("jiraIssueTypeId") or None,
+            )
+            output = {
+                "success": True,
+                "operation": operation,
+                "issue": issue,
+                "key": issue.get("key"),
+            }
+        elif operation == "updateIssue":
+            issue_key = _field("jiraIssueKey")
+            if not issue_key:
+                raise ValueError("Jira updateIssue requires an issue key or ID")
+            issue = service.update_issue(
+                issue_key,
+                summary=_update_field("jiraSummary"),
+                description=_update_field("jiraDescription"),
+                assignee_account_id=_update_field("jiraAssigneeAccountId"),
+                labels=_update_labels(),
+            )
+            output = {
+                "success": True,
+                "operation": operation,
+                "issue": issue,
+                "key": issue.get("key"),
+            }
+        elif operation == "deleteIssue":
+            issue_key = _field("jiraIssueKey")
+            if not issue_key:
+                raise ValueError("Jira deleteIssue requires an issue key or ID")
+            output = {
+                "success": True,
+                "operation": operation,
+                "deleted": service.delete_issue(issue_key),
+            }
+        elif operation == "getIssueChangelog":
+            issue_key = _field("jiraIssueKey")
+            if not issue_key:
+                raise ValueError("Jira getIssueChangelog requires an issue key or ID")
+            result = service.get_issue_changelog(issue_key, _limit(), _start_at())
+            values = result.get("values")
+            if not isinstance(values, list):
+                values = result.get("histories")
+            histories = values if isinstance(values, list) else []
+            output = {
+                "success": True,
+                "operation": operation,
+                "changelog": histories,
+                "count": len(histories),
+                "pagination": _pagination(result),
+            }
+        elif operation == "notifyIssue":
+            issue_key = _field("jiraIssueKey")
+            subject = _field("jiraNotifySubject")
+            text_body = _field("jiraNotifyTextBody")
+            if not issue_key or not subject or not text_body:
+                raise ValueError("Jira notifyIssue requires issue key, subject, and text body")
+            output = {
+                "success": True,
+                "operation": operation,
+                "notified": service.notify_issue(
+                    issue_key,
+                    subject=subject,
+                    text_body=text_body,
+                    html_body=_field("jiraNotifyHtmlBody") or None,
+                    to=_json_object_field("jiraNotifyTo", {"assignee": True}),
+                ),
+            }
+        elif operation == "listComments":
+            issue_key = _field("jiraIssueKey")
+            if not issue_key:
+                raise ValueError("Jira listComments requires an issue key or ID")
+            result = service.list_comments(issue_key, _limit(), _start_at())
+            comments = result.get("comments") if isinstance(result.get("comments"), list) else []
+            output = {
+                "success": True,
+                "operation": operation,
+                "comments": comments,
+                "count": len(comments),
+                "pagination": _pagination(result),
+            }
+        elif operation == "createComment":
+            issue_key = _field("jiraIssueKey")
+            body = _field("jiraCommentBody")
+            if not issue_key or not body:
+                raise ValueError("Jira createComment requires an issue key and comment body")
+            output = {
+                "success": True,
+                "operation": operation,
+                "comment": service.create_comment(issue_key, body),
+            }
+        elif operation == "getComment":
+            issue_key = _field("jiraIssueKey")
+            comment_id = _field("jiraCommentId")
+            if not issue_key or not comment_id:
+                raise ValueError("Jira getComment requires an issue key and comment ID")
+            output = {
+                "success": True,
+                "operation": operation,
+                "comment": service.get_comment(issue_key, comment_id),
+            }
+        elif operation == "updateComment":
+            issue_key = _field("jiraIssueKey")
+            comment_id = _field("jiraCommentId")
+            body = _field("jiraCommentBody")
+            if not issue_key or not comment_id or not body:
+                raise ValueError("Jira updateComment requires an issue key, comment ID, and body")
+            output = {
+                "success": True,
+                "operation": operation,
+                "comment": service.update_comment(issue_key, comment_id, body),
+            }
+        elif operation == "deleteComment":
+            issue_key = _field("jiraIssueKey")
+            comment_id = _field("jiraCommentId")
+            if not issue_key or not comment_id:
+                raise ValueError("Jira deleteComment requires an issue key and comment ID")
+            output = {
+                "success": True,
+                "operation": operation,
+                "deleted": service.delete_comment(issue_key, comment_id),
+            }
+        elif operation == "listTransitions":
+            issue_key = _field("jiraIssueKey")
+            if not issue_key:
+                raise ValueError("Jira listTransitions requires an issue key or ID")
+            transitions = service.list_transitions(issue_key)
+            output = {
+                "success": True,
+                "operation": operation,
+                "transitions": transitions,
+                "count": len(transitions),
+            }
+        elif operation == "transitionIssue":
+            issue_key = _field("jiraIssueKey")
+            transition_id = _field("jiraTransitionId")
+            if not issue_key or not transition_id:
+                raise ValueError("Jira transitionIssue requires an issue key and transition ID")
+            transition = service.transition_issue(issue_key, transition_id)
+            issue = transition.get("issue") if isinstance(transition.get("issue"), dict) else {}
+            output = {
+                "success": True,
+                "operation": operation,
+                "transition": {"transitionId": transition.get("transitionId")},
+                "issue": issue,
+                "key": issue.get("key"),
+            }
+        elif operation == "addAttachment":
+            issue_key = _field("jiraIssueKey")
+            filename = _field("jiraAttachmentFilename")
+            if not issue_key or not filename:
+                raise ValueError("Jira addAttachment requires an issue key and filename")
+            mime_type = _field("jiraAttachmentMimeType") or guess_type(filename)[0]
+            attachments = service.add_attachment(
+                issue_key,
+                filename=filename,
+                content=_attachment_content(),
+                mime_type=mime_type,
+            )
+            output = {
+                "success": True,
+                "operation": operation,
+                "attachments": attachments,
+                "count": len(attachments),
+            }
+        elif operation == "getAttachment":
+            attachment_id = _field("jiraAttachmentId")
+            if not attachment_id:
+                raise ValueError("Jira getAttachment requires an attachment ID")
+            output = {
+                "success": True,
+                "operation": operation,
+                "attachment": _with_optional_binary(service.get_attachment(attachment_id)),
+            }
+        elif operation == "listAttachments":
+            issue_key = _field("jiraIssueKey")
+            if not issue_key:
+                raise ValueError("Jira listAttachments requires an issue key or ID")
+            result = service.list_attachments(issue_key, _limit(), _start_at())
+            attachments = [
+                _with_optional_binary(attachment)
+                for attachment in result.get("attachments", [])
+                if isinstance(attachment, dict)
+            ]
+            output = {
+                "success": True,
+                "operation": operation,
+                "attachments": attachments,
+                "count": len(attachments),
+                "pagination": _pagination(result),
+            }
+        elif operation == "deleteAttachment":
+            attachment_id = _field("jiraAttachmentId")
+            if not attachment_id:
+                raise ValueError("Jira deleteAttachment requires an attachment ID")
+            output = {
+                "success": True,
+                "operation": operation,
+                "deleted": service.delete_attachment(attachment_id),
+            }
+        elif operation == "getUser":
+            account_id = _field("jiraAccountId")
+            if not account_id:
+                raise ValueError("Jira getUser requires an account ID")
+            output = {"success": True, "operation": operation, "user": service.get_user(account_id)}
+        elif operation == "createUser":
+            email_address = _field("jiraUserEmail")
+            if not email_address:
+                raise ValueError("Jira createUser requires an email address")
+            output = {
+                "success": True,
+                "operation": operation,
+                "user": service.create_user(
+                    email_address,
+                    username=_field("jiraUsername") or None,
+                    display_name=_field("jiraUserDisplayName") or None,
+                    products=_string_list_field("jiraUserProducts"),
+                ),
+            }
+        elif operation == "deleteUser":
+            account_id = _field("jiraAccountId")
+            if not account_id:
+                raise ValueError("Jira deleteUser requires an account ID")
+            output = {
+                "success": True,
+                "operation": operation,
+                "deleted": service.delete_user(account_id),
+            }
+        else:
+            raise ValueError(f"Unknown Jira operation: {operation}")
+    finally:
+        service.close()
+    return output
+
+
+def _pagination(result: dict[str, Any]) -> dict[str, Any]:
+    return {
+        "startAt": result.get("startAt"),
+        "maxResults": result.get("maxResults"),
+        "total": result.get("total"),
+        "isLast": result.get("isLast"),
+    }
+
+
+def _search_pagination(result: dict[str, Any], limit: int) -> dict[str, Any]:
+    if "total" in result or "startAt" in result:
+        return _pagination(result)
+    return {
+        "maxResults": limit,
+        "nextPageToken": result.get("nextPageToken"),
+        "isLast": result.get("isLast"),
+    }
diff --git a/backend/app/services/node_execution/registry.py b/backend/app/services/node_execution/registry.py
index 67a1971b..98fae1d5 100644
--- a/backend/app/services/node_execution/registry.py
+++ b/backend/app/services/node_execution/registry.py
@@ -32,6 +32,7 @@
     "http": "http_node",
     "imapTrigger": "imap_trigger_node",
     "jsonOutputMapper": "json_output_mapper_node",
+    "jira": "jira_node",
     "linear": "linear_node",
     "llm": "llm_node",
     "loop": "loop_node",
diff --git a/backend/app/services/workflow_dsl_prompt.py b/backend/app/services/workflow_dsl_prompt.py
index 2293ed78..51b218cc 100644
--- a/backend/app/services/workflow_dsl_prompt.py
+++ b/backend/app/services/workflow_dsl_prompt.py
@@ -696,7 +696,7 @@
 }
 ```
 
-### 4. agent (AI Agent with Tool Calling)
+### 5. agent (AI Agent with Tool Calling)
 - **Purpose**: LLM with optional user-defined Python tools and/or MCP (Model Context Protocol) connections. The LLM can call tools to perform computations, then use results in its response.
 - **Inputs**: 1 | **Outputs**: 1
 - **Data fields**:
@@ -1012,14 +1012,14 @@
 }
 ```
 
-### 5. condition (If/Else Branch)
+### 6. condition (If/Else Branch)
 - **Purpose**: Branch workflow based on condition
 - **Inputs**: 1 | **Outputs**: 2 (true path: output-0, false path: output-1)
 - **Data fields**:
   - `label`: Node identifier
   - `condition`: JavaScript-like expression (e.g., `$previousNodeLabel.text.length > 0`)
 
-### 6. switch (Multi-way Branch)
+### 7. switch (Multi-way Branch)
 - **Purpose**: Route to different paths based on value matching
 - **Inputs**: 1 | **Outputs**: N+1 (N cases + default)
 - **Data fields**:
@@ -1027,7 +1027,7 @@
   - `expression`: Value to evaluate (e.g., `$previousNodeLabel.category`)
   - `cases`: Array of case values ["case1", "case2"]
 
-### 7. execute (Call Another Workflow)
+### 8. execute (Call Another Workflow)
 - **Purpose**: Call/execute another workflow (sub-workflow)
 - **Inputs**: 1 | **Outputs**: 1
 - **Data fields**:
@@ -1156,7 +1156,7 @@
 - Each mapping's `value` should be an expression like `$nodeName.field`
 - **When target workflow needs multiple inputs, add corresponding `inputFields` to your textInput node!**
 
-### 8. output (End Point with Optional Async Continuation)
+### 9. output (End Point with Optional Async Continuation)
 - **Purpose**: Final output of the workflow, returns response to caller
 - **Inputs**: 1 | **Outputs**: 1 (optional, for async post-processing)
 - **Data fields**:
@@ -1207,14 +1207,14 @@
 - If multiple terminal nodes produce outputs (e.g. `output` + `jsonOutputMapper`, or two mappers), the runtime uses the normal per-label map — **unwrapping applies only when the sole terminal is one `jsonOutputMapper`**.
 - Same loop restriction as `output`: **never** place `jsonOutputMapper` inside a loop iteration branch (only after `done`).
 
-### 9. wait (Delay)
+### 10. wait (Delay)
 - **Purpose**: Pause execution for specified time
 - **Inputs**: 1 | **Outputs**: 1
 - **Data fields**:
   - `label`: Node identifier
   - `duration`: Milliseconds to wait (e.g., 1000 for 1 second)
 
-### 10. http (HTTP Request) - CAN BE A STARTING POINT!
+### 11. http (HTTP Request) - CAN BE A STARTING POINT!
 - **Purpose**: Make HTTP requests using cURL syntax
 - **Inputs**: 0 or 1 | **Outputs**: 1
 - **⚠️ STARTING POINT**: HTTP nodes can START a workflow without any preceding node! Perfect for fetching static URLs without user input.
@@ -1246,7 +1246,7 @@
 - `$httpNodeLabel.body.fieldName` - Access parsed JSON fields from body
 - `$httpNodeLabel.headers` - Response headers object
 
-### 11. merge (Combine Inputs) - USE ONLY WHEN EXPLICITLY REQUESTED!
+### 12. merge (Combine Inputs) - USE ONLY WHEN EXPLICITLY REQUESTED!
 - **Purpose**: Wait for multiple parallel branches and combine their outputs
 - **Inputs**: N (configurable) | **Outputs**: 1
 - **Data fields**:
@@ -1258,7 +1258,7 @@
 - DO NOT use merge for simple parallel workflows that end with separate outputs
 - If user wants parallel operations with separate results, use separate output nodes instead
 
-### 12. set (Data Transformation) ⭐ USE THIS FOR TRANSFORMATIONS!
+### 13. set (Data Transformation) ⭐ USE THIS FOR TRANSFORMATIONS!
 - **Purpose**: Transform input data - uppercase, lowercase, substring, concatenation, random numbers, etc.
 - **Inputs**: 1 | **Outputs**: 1
 - **Data fields**:
@@ -1285,14 +1285,14 @@
 3. Functions return their native type - randomInt returns a number, no conversion needed
 4. For modulo/math on set node output: `$generateRandom.randomNumber % 2 == 0` (use the key name, e.g., "randomNumber")
 
-### 13. sticky (Note)
+### 14. sticky (Note)
 - **Purpose**: Add documentation notes to canvas (not executed)
 - **Inputs**: 0 | **Outputs**: 0
 - **Data fields**:
   - `label`: Node identifier
   - `note`: Markdown text content
 
-### 14. errorHandler (Global Error Catcher) - ONLY ADD WHEN EXPLICITLY REQUESTED!
+### 15. errorHandler (Global Error Catcher) - ONLY ADD WHEN EXPLICITLY REQUESTED!
 - **Purpose**: Catches errors from ANY node in the workflow. If present on canvas, executes when any node fails.
 - **Inputs**: 0 (triggered automatically on error) | **Outputs**: 1
 - **Data fields**:
@@ -1401,7 +1401,7 @@
 }
 ```
 
-### 15. slack (Send Slack Message)
+### 16. slack (Send Slack Message)
 - **Purpose**: Send a message to Slack channel via webhook
 - **Inputs**: 1 | **Outputs**: 1
 - **Data fields**:
@@ -1452,7 +1452,7 @@
 }
 ```
 
-### 16. sendEmail (Send Email via SMTP)
+### 17. sendEmail (Send Email via SMTP)
 - **Purpose**: Send an email using SMTP credentials
 - **Inputs**: 1 | **Outputs**: 1
 - **Data fields**:
@@ -1513,7 +1513,7 @@
 }
 ```
 
-### 17. variable (Set Variable)
+### 18. variable (Set Variable)
 - **Purpose**: Set or update a variable that can be accessed from ANY node via `$vars.variableName` (workflow-local) or `$global.variableName` (persistent, user-scoped)
 - **Inputs**: 1 | **Outputs**: 1
 - **Data fields**:
@@ -1646,7 +1646,7 @@
 2. **Inside loop body**: Use another `variable` node with `.add()` to append items
 3. **After loop (done branch)**: Access collected items via `$vars.variableName`
 
-### 18. loop (Iterate Over Array)
+### 19. loop (Iterate Over Array)
 - **Purpose**: Iterate over an array of items, executing downstream nodes for each item
 - **Inputs**: 2 handles
   - Default input (receives initial array data)
@@ -1743,7 +1743,7 @@
    - The workflow validator will REJECT any workflow with output nodes in loop branches
    - Use `set` or `variable` nodes for ALL intermediate processing inside loops
 
-### 19. disableNode (Disable Another Node)
+### 20. disableNode (Disable Another Node)
 - **Purpose**: Disable another node in the workflow permanently. When executed, sets the target node's `active` to `false` and updates the workflow in the database.
 - **Inputs**: 1 | **Outputs**: 1
 - **Data fields**:
@@ -1788,7 +1788,7 @@
 5. If false: output says still waiting
 6. After disable runs, the cron node's `active` becomes `false` and it won't trigger anymore
 
-### 20. redis (Redis Operations)
+### 21. redis (Redis Operations)
 - **Purpose**: Perform Redis operations (set, get, check key existence, delete)
 - **Inputs**: 1 | **Outputs**: 1
 - **Data fields**:
@@ -1886,7 +1886,7 @@
 - `$redisNodeLabel.key` - The key that was operated on
 - `$redisNodeLabel.ttl` - TTL value (for set operation with TTL)
 
-### 21. rag (Vector Store / RAG Operations)
+### 22. rag (Vector Store / RAG Operations)
 - **Purpose**: Insert documents into or search documents from a vector store (Qdrant or Postgres/pgvector) for RAG (Retrieval Augmented Generation)
 - **Inputs**: 1 | **Outputs**: 1
 - **Data fields**:
@@ -1990,7 +1990,7 @@
 }
 ```
 
-### 22. grist (Grist Spreadsheet Operations)
+### 23. grist (Grist Spreadsheet Operations)
 - **Purpose**: Read, write, and manage data in Grist spreadsheets (open-source spreadsheet platform)
 - **Inputs**: 1 | **Outputs**: 1
 - **Data fields**:
@@ -2173,7 +2173,7 @@
 - `$gristNodeLabel.tables` - Array of tables (for listTables)
 - `$gristNodeLabel.columns` - Array of columns with id and label (use listColumns to discover column IDs)
 
-### 23. googleSheets (Google Sheets Operations)
+### 24. googleSheets (Google Sheets Operations)
 - **Purpose**: Read, write, append, clear, and inspect Google Sheets spreadsheets via OAuth2
 - **Inputs**: 1 | **Outputs**: 1
 - **Data fields**:
@@ -2305,7 +2305,7 @@
 - `$sheetInfo.title` — Spreadsheet title
 - `$sheetInfo.sheets` — Array of {sheetId, title} objects
 
-### 24. bigquery (Google BigQuery Operations)
+### 25. bigquery (Google BigQuery Operations)
 - **Purpose**: Run SQL queries against Google BigQuery data warehouses and stream-insert rows into tables via OAuth2
 - **Inputs**: 1 | **Outputs**: 1
 - **Credential required**: `bigquery` credential type (OAuth2 — client_id + client_secret, then Connect via browser popup)
@@ -2597,7 +2597,7 @@
 - `$queryTasks.count` — result count
 - `$createTask.success` — boolean success indicator
 
-### 25. dataTable (DataTable Operations)
+### 26. dataTable (DataTable Operations)
 - **Purpose**: Read, write, and manage data in Heym DataTables (first-party structured storage)
 - **Inputs**: 1 | **Outputs**: 1
 - **No credential required** — DataTable operates on internal Heym database
@@ -2690,7 +2690,7 @@
 - `$nodeLabel.found` - Boolean (for getById)
 - `$nodeLabel.operation` - Operation name (e.g. "count"; "insert"/"update" for upsert)
 
-### 24. throwError (Stop Workflow with Error)
+### 27. throwError (Stop Workflow with Error)
 - **Purpose**: Immediately stop workflow execution and return an error response with a custom HTTP status code
 - **Inputs**: 1 | **Outputs**: 0 (workflow stops here)
 - **Data fields**:
@@ -2765,7 +2765,7 @@
 }
 ```
 
-### 25. rabbitmq (RabbitMQ Message Queue)
+### 28. rabbitmq (RabbitMQ Message Queue)
 - **Purpose**: Send or receive messages from RabbitMQ queues and exchanges
 - **Inputs**: 1 | **Outputs**: 1
 - **Data fields**:
@@ -2878,7 +2878,7 @@
 }
 ```
 
-### 26. crawler (Web Scraping with FlareSolverr)
+### 29. crawler (Web Scraping with FlareSolverr)
 - **Purpose**: Scrape web pages using FlareSolverr with optional HTML extraction via CSS selectors
 - **Inputs**: 1 | **Outputs**: 1
 - **Data fields**:
@@ -3018,7 +3018,7 @@
 ```
 This returns: `["news/my-article.html", "blog/another-post.html", ...]`
 
-### 27. consoleLog (Backend Console Log)
+### 30. consoleLog (Backend Console Log)
 - **Purpose**: Writes a value to the backend (server) console for debugging. Logs do NOT appear in the browser.
 - **⛔ WHEN TO CREATE**: Add this node **ONLY** when the user explicitly requests backend/console logging. If this intent is NOT present, do **NOT** create any consoleLog node.
 - **Inputs**: 1 | **Outputs**: 1
@@ -3031,7 +3031,7 @@
 { "type": "consoleLog", "data": { "label": "debugStep", "logMessage": "$userInput.body.text" } }
 ```
 
-### 28. playwright (Browser Automation)
+### 31. playwright (Browser Automation)
 - **Purpose**: Execute browser automation steps (navigate, click, type, fill, etc.) using Playwright. Steps are defined in the node and executed in order at runtime. Supports optional auth bootstrap from cookies/storageState plus fallback login steps.
 - **Inputs**: 1 | **Outputs**: 1
 - **Data fields**:
@@ -3146,7 +3146,7 @@
 **Note**: Add steps in the Properties Panel. Steps are executed in order at runtime. Execution requires at least one step in `playwrightSteps`.
 If `playwrightAuthEnabled` is true, the first item in `playwrightSteps` must be `navigate`, auth bootstrap works only with step-based execution, and `playwrightAuthFallbackSteps` should leave the browser on the authenticated page expected by the remaining main steps.
 
-### 29. drive (Drive File Management)
+### 32. drive (Drive File Management)
 - **Purpose**: List and manage files generated by skills — retrieve metadata, delete, password-protect, set expiry (TTL), limit downloads, or share/unshare with teams
 - **Inputs**: 1 | **Outputs**: 1
 - **No credential required** — operates on files owned by the workflow owner
@@ -3334,7 +3334,7 @@
 - `$agentLabel._generated_files[0].mime_type` - MIME type
 - `$agentLabel._generated_files[0].size_bytes` - File size in bytes
 
-### 30. mcpCall (Direct MCP Tool Call)
+### 33. mcpCall (Direct MCP Tool Call)
 - **Purpose**: Call a specific MCP tool directly without an LLM deciding which tool to use
 - **Inputs**: 1 | **Outputs**: 1
 - **WHEN TO USE**: When you know exactly which MCP tool to call. Deterministic — no LLM loop.
@@ -3368,7 +3368,7 @@
 **Downstream access:**
 - `$searchCall.result` → tool result (object or string)
 
-### 31. chartOutput (Dashboard Widget Chart) - TERMINAL NODE FOR DASHBOARD WIDGETS
+### 34. chartOutput (Dashboard Widget Chart) - TERMINAL NODE FOR DASHBOARD WIDGETS
 - **Purpose**: Terminal node that turns upstream rows into a chart for a dashboard widget.
 - **Inputs**: 1 | **Outputs**: 0 (it is the LAST node in a dashboard-widget workflow)
 - **WHEN TO USE**: Only in dashboard-widget workflows. The node before it must produce an array of
@@ -3836,7 +3836,7 @@
 **If a function is NOT in the documentation above, it DOES NOT EXIST!**
 Use ONLY: `str()`, `int()`, `float()`, `bool()`, `list()`, `dict(key=value)`, `len()`, `abs()`, `min()`, `max()`, `round()`, `sum()`, `sorted()`, `randomInt()`, `range()`, `array()`, `notNull()`, `upper()`, `lower()`, `strip()`, `capitalize()`, `title()`, `split()`, `join()`, `replace()`, `regexReplace()`, `hash()`, and the documented string/array/object methods.
 
-### 32. s3 (Amazon S3 Operations)
+### 35. s3 (Amazon S3 Operations)
 - **Type**: `s3`
 - **Purpose**: Manage buckets and folders; list, upload, download, copy, and delete objects in Amazon S3
 - **Inputs**: 1 | **Outputs**: 1
@@ -3931,7 +3931,7 @@
 }
 ```
 
-### 33. linear (Linear Workspace and Issue Operations)
+### 36. linear (Linear Workspace and Issue Operations)
 - **Type**: `linear`
 - **Inputs**: 1, **Outputs**: 1
 - **Credential required**: `linear` credential type containing a Linear personal API key or
@@ -3990,7 +3990,7 @@
 }
 ```
 
-### 34. sentry (Sentry REST Operations)
+### 37. sentry (Sentry REST Operations)
 - **Type**: `sentry`
 - **Purpose**: Manage Sentry organizations, projects, teams, issues, events, and releases
 - **Inputs**: 1 | **Outputs**: 1
@@ -4037,7 +4037,97 @@
 }
 ```
 
-### 35. github (GitHub REST Operations)
+### 38. jira (Jira REST Operations)
+- **Type**: `jira`
+- **Purpose**: Manage Jira projects, issues, comments, attachments, users, notifications, and workflow transitions
+- **Inputs**: 1 | **Outputs**: 1
+- **Required setup**: `credentialId` must point to an owned Jira credential with email,
+  API token, Jira base URL, and deployment mode (`cloud` or `data_center`)
+- **Operations**:
+  - `getMyself`: authenticated Jira user
+  - `listProjects`: projects visible to the user
+  - `searchIssues`: search issues with `jiraJql`; Cloud uses `/search/jql` and
+    `jiraNextPageToken`, Data Center uses `/search` and `jiraStartAt`; defaults to
+    `updated >= -30d ORDER BY updated DESC`; optional `jiraFields` (defaults to
+    `key`, `summary`, `status`, `assignee`, `issuetype`)
+  - `getIssue`: fetch by key or ID such as `ENG-123`
+  - `createIssue`: requires `jiraProjectKey` and `jiraSummary`; optional `jiraIssueType`,
+    `jiraIssueTypeId`, `jiraDescription`, `jiraAssigneeAccountId` (Cloud accountId or
+    Data Center username), and `jiraLabels`
+  - `updateIssue`: requires `jiraIssueKey` and at least one changed field
+  - `deleteIssue`: requires `jiraIssueKey`
+  - `getIssueChangelog`: changelog entries for `jiraIssueKey`
+  - `notifyIssue`: requires `jiraIssueKey`, `jiraNotifySubject`, and `jiraNotifyTextBody`
+  - `listComments`: comments for `jiraIssueKey`
+  - `createComment`: requires `jiraIssueKey` and `jiraCommentBody`
+  - `getComment`: requires `jiraIssueKey` and `jiraCommentId`
+  - `updateComment`: requires `jiraIssueKey`, `jiraCommentId`, and `jiraCommentBody`
+  - `deleteComment`: requires `jiraIssueKey` and `jiraCommentId`
+  - `listTransitions`: available transitions for `jiraIssueKey`
+  - `transitionIssue`: requires `jiraIssueKey` and `jiraTransitionId`
+  - `addAttachment`: requires `jiraIssueKey`, `jiraAttachmentFilename`, and `jiraAttachmentBase64`
+  - `getAttachment`: requires `jiraAttachmentId`; optional `jiraIncludeBinary`
+  - `listAttachments`: requires `jiraIssueKey`; optional `jiraIncludeBinary`
+  - `deleteAttachment`: requires `jiraAttachmentId`
+  - `getUser`: requires `jiraAccountId` (Cloud accountId or Data Center username)
+  - `createUser`: requires `jiraUserEmail`; optional `jiraUsername`, `jiraUserDisplayName`,
+    and `jiraUserProducts` (admin permissions; username applies to Data Center, products
+    apply to Jira Cloud)
+  - `deleteUser`: requires `jiraAccountId` (Cloud accountId or Data Center username; admin permissions)
+- **Fields**: `jiraOperation`, `jiraProjectKey`, `jiraIssueKey`, `jiraIssueType`,
+  `jiraIssueTypeId`, `jiraSummary`, `jiraDescription`, `jiraJql`, `jiraFields`,
+  `jiraAssigneeAccountId`, `jiraLabels`, `jiraCommentBody`, `jiraCommentId`,
+  `jiraTransitionId`, `jiraNotifySubject`, `jiraAttachmentId`, `jiraAttachmentFilename`,
+  `jiraAttachmentBase64`, `jiraAttachmentMimeType`,
+  `jiraNotifyTextBody`, `jiraNotifyHtmlBody`, `jiraNotifyTo`, `jiraAccountId`,
+  `jiraUsername`, `jiraUserEmail`, `jiraUserDisplayName`, `jiraUserProducts`,
+  `jiraLimit` (1-100), `jiraStartAt`, `jiraNextPageToken`
+- Text fields support expressions. `jiraIncludeBinary` is a static boolean toggle and can be
+  marked as agent-provided when the Jira node is attached to an Agent tool handle.
+  `jiraLabels`, `jiraUserProducts`, and `jiraFields` may be a
+  JSON array of strings or comma-separated text. `jiraNotifyTo` must be a JSON object and
+  defaults to `{"assignee":true}` when omitted. `searchIssues` pagination uses
+  `pagination.nextPageToken` on Cloud and `pagination.startAt` on Data Center.
+- Jira REST API v3 sends issue descriptions and comments as Atlassian Document Format (ADF);
+  Data Center REST API v2 sends plain text. `getIssueChangelog` uses
+  `/issue/{key}/changelog` on Cloud and expanded issue changelog data on Data Center.
+- List outputs contain `{success, operation, count, projects|issues|comments|changelog|attachments, pagination}`.
+  `searchIssues` uses cursor pagination (`pagination.nextPageToken`) on Cloud and offset
+  pagination (`pagination.startAt`) on Data Center. Other paginated lists use `startAt`.
+  `listAttachments` pagination is client-side after fetching all issue attachments.
+- Issue outputs contain `{success, operation, issue, key}`.
+- Comment get/create/update outputs `{success, operation, comment}`; comment delete outputs
+  `{success, operation, deleted}`.
+- `listTransitions` outputs `{success, operation, transitions, count}` without pagination.
+  `transitionIssue` outputs `{success, operation, transition, issue, key}`.
+- Attachment add outputs `{success, operation, attachments, count}`. List attachments also
+  includes `pagination`. Attachment get outputs `{success, operation, attachment}` and includes
+  `attachment.content_base64` when `jiraIncludeBinary` is true. Attachment delete outputs
+  `{success, operation, deleted}`.
+- User get/create outputs `{success, operation, user}`; delete outputs `{success, operation, deleted}`.
+- Notify outputs `{success, operation, notified}`.
+- Set update fields to `null` to clear description or assignee.
+
+**Example — create a Jira issue:**
+```json
+{
+  "id": "jira-1",
+  "type": "jira",
+  "position": {"x": 500, "y": 100},
+  "data": {
+    "label": "createJiraIssue",
+    "credentialId": "YOUR_CREDENTIAL_ID",
+    "jiraOperation": "createIssue",
+    "jiraProjectKey": "ENG",
+    "jiraIssueType": "Task",
+    "jiraSummary": "$input.title",
+    "jiraDescription": "$input.description",
+    "jiraLabels": "[\"automation\"]"
+  }
+}
+```
+
+### 39. github (GitHub REST Operations)
 - **Type**: `github`
 - **Purpose**: Manage repositories, users, issues, pull requests, reviews, releases, Actions
   workflows, traffic insights, and repository files
@@ -4110,7 +4200,7 @@
 }
 ```
 
-### 36. codex (OpenAI Codex Coding Agent)
+### 40. codex (OpenAI Codex Coding Agent)
 - **Type**: `codex`
 - **Purpose**: Run a coding task against a Git repository using the Codex CLI inside Heym's
   isolated runner. This node is access-token-only; do not use OpenAI API keys.
@@ -4337,7 +4427,7 @@
 21. **MULTIPLE INPUT FIELDS** - textInput nodes support multiple input fields via `inputFields` array. Define fields like `[{"key": "text"}, {"key": "base64"}]`. Access via `$nodeLabel.body.fieldKey`. Input values are sent in the `body` object.
 22. **⚠️ NO UNNECESSARY textInput!** - NEVER add textInput unless user explicitly needs to provide input data. For static URLs, scheduled tasks, or fixed operations, START DIRECTLY with http, cron, or other nodes. textInput is ONLY for workflows that receive dynamic data from users/API callers.
 23. **⚠️ PRESERVE CREDENTIALS & MODEL** - When modifying an existing workflow, ALWAYS preserve existing `credentialId` and `model` values in nodes. NEVER replace, remove, or change credential IDs or model names unless the user explicitly asks to use a different credential or model. If a node already has a `credentialId` or `model`, keep them exactly as is.
-23a. **⚠️ CREDENTIALS & INTEGRATIONS - OWNED ONLY (NO SHARED)** - For **every** node field that references a credential or secret (`credentialId`, `githubCredentialId`, `fallbackCredentialId`, `guardrailCredentialId`, Playwright `aiStep` credential, etc.), use ONLY credentials **owned** by the workflow owner. **NEVER** put shared credentials (shared with you by another user or via team share) in generated JSON—the UI labels these as shared; they must not appear in AI output. Use placeholders such as `YOUR_CREDENTIAL_ID`, `codex-credential-uuid`, `github-credential-uuid`, `slack-credential-uuid`, `telegram-credential-uuid`, or `imap-credential-uuid` and let the user pick an owned credential in the editor. Applies to: `llm`, `agent`, `codex`, `slack`, `telegram`, `slackTrigger`, `telegramTrigger`, `imapTrigger`, `sendEmail`, `redis`, `grist`, `github`, `linear`, `googleSheets`, `bigquery`, `supabase`, `notion`, `rabbitmq`, `crawler`, `playwright` (including `aiStep`), and any other integration that stores a credential id. When modifying an existing workflow (rule 23), still preserve existing ids if they are already non-shared; when **adding** new nodes, never insert shared credential UUIDs.
+23a. **⚠️ CREDENTIALS & INTEGRATIONS - OWNED ONLY (NO SHARED)** - For **every** node field that references a credential or secret (`credentialId`, `githubCredentialId`, `fallbackCredentialId`, `guardrailCredentialId`, Playwright `aiStep` credential, etc.), use ONLY credentials **owned** by the workflow owner. **NEVER** put shared credentials (shared with you by another user or via team share) in generated JSON—the UI labels these as shared; they must not appear in AI output. Use placeholders such as `YOUR_CREDENTIAL_ID`, `codex-credential-uuid`, `github-credential-uuid`, `jira-credential-uuid`, `slack-credential-uuid`, `telegram-credential-uuid`, or `imap-credential-uuid` and let the user pick an owned credential in the editor. Applies to: `llm`, `agent`, `codex`, `slack`, `telegram`, `slackTrigger`, `telegramTrigger`, `imapTrigger`, `sendEmail`, `redis`, `grist`, `github`, `jira`, `linear`, `googleSheets`, `bigquery`, `supabase`, `notion`, `rabbitmq`, `crawler`, `playwright` (including `aiStep`), and any other integration that stores a credential id. When modifying an existing workflow (rule 23), still preserve existing ids if they are already non-shared; when **adding** new nodes, never insert shared credential UUIDs.
 24. **EXECUTE NODE OUTPUT** - Execute node returns `{status, outputs, workflow_id, execution_time_ms}`. Access the called workflow's result via `$executeNodeLabel.outputs.output.result`. The `outputs.output` object contains the result from the executed workflow's output node.
 25. **EXECUTE NODE MULTIPLE INPUTS** - When calling a workflow that expects multiple input fields: (1) Add matching `inputFields` to your textInput node to collect all required data, (2) Use `executeInputMappings` array to map each field. Example: If target needs `text` and `imageUrl`, your textInput should have `inputFields: [{"key": "prompt"}, {"key": "image"}]`, then execute node uses `"executeInputMappings": [{"key": "text", "value": "$userInput.body.prompt"}, {"key": "imageUrl", "value": "$userInput.body.image"}]`
 26. **REQUEST BODY, HEADERS & QUERY** - When workflow is executed via API, textInput nodes receive `body`, `headers` and `query` objects. Access via `$textInputLabel.body.fieldName`, `$textInputLabel.headers.headerName` and `$textInputLabel.query.paramName`. Useful for accessing raw request data, authentication, and dynamic behavior.
diff --git a/backend/tests/test_alembic_migrations.py b/backend/tests/test_alembic_migrations.py
index fa4173cd..1c400bef 100644
--- a/backend/tests/test_alembic_migrations.py
+++ b/backend/tests/test_alembic_migrations.py
@@ -15,7 +15,12 @@ def setUp(self) -> None:
         self.script = ScriptDirectory.from_config(config)
 
     def test_revision_graph_has_one_head(self) -> None:
-        self.assertEqual(self.script.get_heads(), ["094_add_file_team_shares"])
+        self.assertEqual(self.script.get_heads(), ["096_merge_jira_file_heads"])
+
+    def test_revision_ids_fit_default_alembic_version_column(self) -> None:
+        for revision in self.script.walk_revisions():
+            with self.subTest(revision=revision.revision):
+                self.assertLessEqual(len(revision.revision), 32)
 
     def test_plugins_revision_follows_workflow_timeout(self) -> None:
         plugins_revision = self.script.get_revision("090_add_plugins_table")
@@ -41,12 +46,27 @@ def test_codex_revision_follows_sentry_revision(self) -> None:
         self.assertIsNotNone(codex_revision)
         self.assertEqual(codex_revision.down_revision, "092_add_sentry_credential_type")
 
+    def test_jira_revision_follows_codex_revision(self) -> None:
+        jira_revision = self.script.get_revision("095_add_jira_credential_type")
+
+        self.assertIsNotNone(jira_revision)
+        self.assertEqual(jira_revision.down_revision, "093_add_codex_node_support")
+
     def test_file_team_shares_revision_follows_codex_revision(self) -> None:
         file_team_shares_revision = self.script.get_revision("094_add_file_team_shares")
 
         self.assertIsNotNone(file_team_shares_revision)
         self.assertEqual(file_team_shares_revision.down_revision, "093_add_codex_node_support")
 
+    def test_jira_and_file_team_share_heads_are_merged(self) -> None:
+        merge_revision = self.script.get_revision("096_merge_jira_file_heads")
+
+        self.assertIsNotNone(merge_revision)
+        self.assertEqual(
+            set(merge_revision.down_revision),
+            {"095_add_jira_credential_type", "094_add_file_team_shares"},
+        )
+
     def test_github_and_supabase_revisions_are_merged(self) -> None:
         merge_revision = self.script.get_revision("080_merge_github_supabase_heads")
 
diff --git a/backend/tests/test_build_assistant_prompt_node_templates.py b/backend/tests/test_build_assistant_prompt_node_templates.py
index f1d93266..eba11b87 100644
--- a/backend/tests/test_build_assistant_prompt_node_templates.py
+++ b/backend/tests/test_build_assistant_prompt_node_templates.py
@@ -70,7 +70,7 @@ def test_includes_websocket_guidance(self) -> None:
     def test_includes_amazon_s3_guidance(self) -> None:
         prompt = build_assistant_prompt()
 
-        self.assertIn("### 32. s3 (Amazon S3 Operations)", prompt)
+        self.assertIn("### 35. s3 (Amazon S3 Operations)", prompt)
         self.assertIn('"type": "s3"', prompt)
         self.assertIn("s3Operation", prompt)
         self.assertIn("s3ContentType", prompt)
@@ -84,7 +84,7 @@ def test_includes_amazon_s3_guidance(self) -> None:
     def test_includes_github_guidance(self) -> None:
         prompt = build_assistant_prompt()
 
-        self.assertIn("### 35. github (GitHub REST Operations)", prompt)
+        self.assertIn("### 39. github (GitHub REST Operations)", prompt)
         self.assertIn('"type": "github"', prompt)
         self.assertIn("githubOperation", prompt)
         self.assertIn("createIssue", prompt)
@@ -95,7 +95,7 @@ def test_includes_github_guidance(self) -> None:
     def test_includes_sentry_guidance(self) -> None:
         prompt = build_assistant_prompt()
 
-        self.assertIn("### 34. sentry (Sentry REST Operations)", prompt)
+        self.assertIn("### 37. sentry (Sentry REST Operations)", prompt)
         self.assertIn('"type": "sentry"', prompt)
         self.assertIn("sentryOperation", prompt)
         self.assertIn("listIssues", prompt)
@@ -105,7 +105,7 @@ def test_includes_sentry_guidance(self) -> None:
     def test_includes_linear_guidance(self) -> None:
         prompt = build_assistant_prompt()
 
-        self.assertIn("### 33. linear (Linear Workspace and Issue Operations)", prompt)
+        self.assertIn("### 36. linear (Linear Workspace and Issue Operations)", prompt)
         self.assertIn('"type": "linear"', prompt)
         self.assertIn("linearOperation", prompt)
         self.assertIn("linearTeamId", prompt)
diff --git a/backend/tests/test_jira_node.py b/backend/tests/test_jira_node.py
new file mode 100644
index 00000000..f91cc4b5
--- /dev/null
+++ b/backend/tests/test_jira_node.py
@@ -0,0 +1,1290 @@
+"""Unit tests for JiraService and the Jira node handler."""
+
+import unittest
+from collections.abc import Iterator
+from contextlib import contextmanager
+from unittest.mock import MagicMock, patch
+
+import httpx
+
+from app.db.models import CredentialType
+from app.services.jira_service import JiraService
+from app.services.node_execution.base import NodeExecutionContext
+from app.services.node_execution.nodes.jira_node import execute
+
+
+def _response(
+    payload: object | None = None,
+    status_code: int = 200,
+    method: str = "GET",
+    url: str = "https://example.atlassian.net/rest/api/3/myself",
+) -> httpx.Response:
+    request = httpx.Request(method, url)
+    if payload is None:
+        return httpx.Response(status_code=status_code, request=request)
+    return httpx.Response(status_code=status_code, json=payload, request=request)
+
+
+class JiraServiceTests(unittest.TestCase):
+    def test_get_myself_uses_basic_auth_and_base_url(self) -> None:
+        client = MagicMock()
+        client.request.return_value = _response({"accountId": "acct-1", "displayName": "Ada"})
+        service = JiraService(
+            {
+                "email": "ada@example.com",
+                "api_token": "jira-token",
+                "base_url": "https://example.atlassian.net",
+            },
+            client=client,
+        )
+
+        result = service.get_myself()
+
+        self.assertEqual(result["displayName"], "Ada")
+        client.request.assert_called_once()
+        self.assertEqual(
+            client.request.call_args.args[:2],
+            ("GET", "https://example.atlassian.net/rest/api/3/myself"),
+        )
+        self.assertEqual(client.request.call_args.kwargs["auth"], ("ada@example.com", "jira-token"))
+
+    def test_create_issue_sends_adf_description_and_labels(self) -> None:
+        client = MagicMock()
+        client.request.return_value = _response(
+            {"id": "10001", "key": "ENG-1"},
+            method="POST",
+            url="https://example.atlassian.net/rest/api/3/issue",
+        )
+        service = JiraService(
+            {
+                "email": "ada@example.com",
+                "api_token": "jira-token",
+                "base_url": "https://example.atlassian.net",
+            },
+            client=client,
+        )
+
+        issue = service.create_issue(
+            "ENG",
+            "Bug",
+            "Fix checkout",
+            description="Checkout is broken",
+            assignee_account_id="acct-1",
+            labels=["automation"],
+        )
+
+        self.assertEqual(issue["key"], "ENG-1")
+        fields = client.request.call_args.kwargs["json"]["fields"]
+        self.assertEqual(fields["project"], {"key": "ENG"})
+        self.assertEqual(fields["issuetype"], {"name": "Bug"})
+        self.assertEqual(fields["summary"], "Fix checkout")
+        self.assertEqual(fields["assignee"], {"accountId": "acct-1"})
+        self.assertEqual(fields["labels"], ["automation"])
+        self.assertEqual(fields["description"]["type"], "doc")
+        self.assertEqual(len(fields["description"]["content"]), 1)
+
+    def test_create_issue_sends_plain_text_description_for_api_v2(self) -> None:
+        client = MagicMock()
+        client.request.return_value = _response(
+            {"id": "10001", "key": "ENG-1"},
+            method="POST",
+            url="https://example.atlassian.net/rest/api/2/issue",
+        )
+        service = JiraService(
+            {
+                "email": "ada@example.com",
+                "api_token": "jira-token",
+                "base_url": "https://example.atlassian.net",
+                "api_version": "2",
+            },
+            client=client,
+        )
+
+        service.create_issue("ENG", "Bug", "Fix checkout", description="Checkout is broken")
+
+        fields = client.request.call_args.kwargs["json"]["fields"]
+        self.assertEqual(fields["description"], "Checkout is broken")
+
+    def test_create_issue_uses_username_assignee_for_data_center(self) -> None:
+        client = MagicMock()
+        client.request.return_value = _response(
+            {"id": "10001", "key": "ENG-1"},
+            method="POST",
+            url="https://jira.example.com/rest/api/2/issue",
+        )
+        service = JiraService(
+            {
+                "email": "ada@example.com",
+                "api_token": "jira-token",
+                "base_url": "https://jira.example.com",
+                "deployment": "data_center",
+            },
+            client=client,
+        )
+
+        service.create_issue("ENG", "Bug", "Fix checkout", assignee_account_id="ada")
+
+        fields = client.request.call_args.kwargs["json"]["fields"]
+        self.assertEqual(fields["assignee"], {"name": "ada"})
+
+    def test_list_projects_uses_array_endpoint_for_data_center(self) -> None:
+        client = MagicMock()
+        client.request.return_value = _response(
+            [
+                {"id": "10000", "key": "ENG"},
+                {"id": "10001", "key": "OPS"},
+                {"id": "10002", "key": "DOCS"},
+            ],
+            url="https://jira.example.com/rest/api/2/project",
+        )
+        service = JiraService(
+            {
+                "email": "ada@example.com",
+                "api_token": "jira-token",
+                "base_url": "https://jira.example.com",
+                "deployment": "data_center",
+            },
+            client=client,
+        )
+
+        result = service.list_projects(limit=1, start_at=1)
+
+        self.assertEqual(result["values"], [{"id": "10001", "key": "OPS"}])
+        self.assertEqual(result["startAt"], 1)
+        self.assertEqual(result["maxResults"], 1)
+        self.assertEqual(result["total"], 3)
+        self.assertFalse(result["isLast"])
+        self.assertEqual(
+            client.request.call_args.args[:2],
+            ("GET", "https://jira.example.com/rest/api/2/project"),
+        )
+        self.assertIsNone(client.request.call_args.kwargs["params"])
+
+    def test_create_issue_prefers_issue_type_id(self) -> None:
+        client = MagicMock()
+        client.request.return_value = _response(
+            {"id": "10001", "key": "ENG-1"},
+            method="POST",
+            url="https://example.atlassian.net/rest/api/3/issue",
+        )
+        service = JiraService(
+            {
+                "email": "ada@example.com",
+                "api_token": "jira-token",
+                "base_url": "https://example.atlassian.net",
+            },
+            client=client,
+        )
+
+        service.create_issue("ENG", "Bug", "Fix checkout", issue_type_id="10001")
+
+        fields = client.request.call_args.kwargs["json"]["fields"]
+        self.assertEqual(fields["issuetype"], {"id": "10001"})
+
+    def test_search_issues_uses_bounded_default_jql(self) -> None:
+        client = MagicMock()
+        client.request.return_value = _response({"issues": [], "isLast": True}, method="POST")
+        service = JiraService(
+            {
+                "email": "ada@example.com",
+                "api_token": "jira-token",
+                "base_url": "https://example.atlassian.net",
+            },
+            client=client,
+        )
+
+        service.search_issues("")
+
+        self.assertEqual(
+            client.request.call_args.kwargs["json"]["jql"],
+            "updated >= -30d ORDER BY updated DESC",
+        )
+
+    def test_search_issues_uses_search_jql_post(self) -> None:
+        client = MagicMock()
+        client.request.return_value = _response(
+            {
+                "issues": [{"id": "10001", "key": "ENG-1"}],
+                "nextPageToken": "token-2",
+                "isLast": False,
+            },
+            method="POST",
+            url="https://example.atlassian.net/rest/api/3/search/jql",
+        )
+        service = JiraService(
+            {
+                "email": "ada@example.com",
+                "api_token": "jira-token",
+                "base_url": "https://example.atlassian.net",
+            },
+            client=client,
+        )
+
+        result = service.search_issues(
+            "project = ENG",
+            25,
+            next_page_token="token-1",
+            fields=["key", "summary"],
+        )
+
+        self.assertEqual(result["nextPageToken"], "token-2")
+        self.assertEqual(
+            client.request.call_args.args[:2],
+            ("POST", "https://example.atlassian.net/rest/api/3/search/jql"),
+        )
+        self.assertEqual(
+            client.request.call_args.kwargs["json"],
+            {
+                "jql": "project = ENG",
+                "maxResults": 25,
+                "fields": ["key", "summary"],
+                "nextPageToken": "token-1",
+            },
+        )
+
+    def test_search_issues_uses_offset_search_for_data_center(self) -> None:
+        client = MagicMock()
+        client.request.return_value = _response(
+            {"issues": [{"id": "10001", "key": "ENG-1"}], "startAt": 10, "total": 11},
+            method="POST",
+            url="https://jira.example.com/rest/api/2/search",
+        )
+        service = JiraService(
+            {
+                "email": "ada@example.com",
+                "api_token": "jira-token",
+                "base_url": "https://jira.example.com",
+                "deployment": "data_center",
+            },
+            client=client,
+        )
+
+        result = service.search_issues(
+            "project = ENG",
+            25,
+            next_page_token="ignored-for-data-center",
+            start_at=10,
+            fields=["key", "summary"],
+        )
+
+        self.assertEqual(result["total"], 11)
+        self.assertEqual(
+            client.request.call_args.args[:2],
+            ("POST", "https://jira.example.com/rest/api/2/search"),
+        )
+        self.assertEqual(
+            client.request.call_args.kwargs["json"],
+            {
+                "jql": "project = ENG",
+                "maxResults": 25,
+                "fields": ["key", "summary"],
+                "startAt": 10,
+            },
+        )
+
+    def test_adf_text_document_splits_newlines(self) -> None:
+        document = JiraService._adf_text_document("line one\nline two")
+        self.assertEqual(len(document["content"]), 2)
+        self.assertEqual(document["content"][0]["content"][0]["text"], "line one")
+        self.assertEqual(document["content"][1]["content"][0]["text"], "line two")
+
+    def test_update_issue_requires_at_least_one_field(self) -> None:
+        service = JiraService(
+            {
+                "email": "ada@example.com",
+                "api_token": "jira-token",
+                "base_url": "https://example.atlassian.net",
+            },
+            client=MagicMock(),
+        )
+
+        with self.assertRaisesRegex(ValueError, "at least one field"):
+            service.update_issue("ENG-1")
+
+    def test_get_issue_changelog_uses_pagination(self) -> None:
+        client = MagicMock()
+        client.request.return_value = _response({"values": [{"id": "10001"}], "total": 1})
+        service = JiraService(
+            {
+                "email": "ada@example.com",
+                "api_token": "jira-token",
+                "base_url": "https://example.atlassian.net",
+            },
+            client=client,
+        )
+
+        result = service.get_issue_changelog("ENG-1", limit=25, start_at=10)
+
+        self.assertEqual(result["total"], 1)
+        self.assertEqual(
+            client.request.call_args.args[:2],
+            ("GET", "https://example.atlassian.net/rest/api/3/issue/ENG-1/changelog"),
+        )
+        self.assertEqual(
+            client.request.call_args.kwargs["params"], {"maxResults": 25, "startAt": 10}
+        )
+
+    def test_get_issue_changelog_uses_expanded_issue_for_api_v2(self) -> None:
+        client = MagicMock()
+        client.request.return_value = _response(
+            {
+                "changelog": {
+                    "histories": [{"id": "10001"}, {"id": "10002"}, {"id": "10003"}],
+                    "total": 3,
+                }
+            }
+        )
+        service = JiraService(
+            {
+                "email": "ada@example.com",
+                "api_token": "jira-token",
+                "base_url": "https://example.atlassian.net",
+                "api_version": "2",
+            },
+            client=client,
+        )
+
+        result = service.get_issue_changelog("ENG-1", limit=1, start_at=1)
+
+        self.assertEqual(result["histories"], [{"id": "10002"}])
+        self.assertEqual(result["total"], 3)
+        self.assertFalse(result["isLast"])
+        self.assertEqual(
+            client.request.call_args.args[:2],
+            ("GET", "https://example.atlassian.net/rest/api/2/issue/ENG-1"),
+        )
+        self.assertEqual(
+            client.request.call_args.kwargs["params"],
+            {"expand": "changelog", "fields": "none"},
+        )
+
+    def test_notify_issue_sends_recipient_payload(self) -> None:
+        client = MagicMock()
+        client.request.return_value = _response(None, status_code=204, method="POST")
+        service = JiraService(
+            {
+                "email": "ada@example.com",
+                "api_token": "jira-token",
+                "base_url": "https://example.atlassian.net",
+            },
+            client=client,
+        )
+
+        notified = service.notify_issue(
+            "ENG-1",
+            subject="Heads up",
+            text_body="Issue changed",
+            to={"watchers": True},
+        )
+
+        self.assertTrue(notified)
+        self.assertEqual(
+            client.request.call_args.args[:2],
+            ("POST", "https://example.atlassian.net/rest/api/3/issue/ENG-1/notify"),
+        )
+        self.assertEqual(
+            client.request.call_args.kwargs["json"],
+            {"subject": "Heads up", "textBody": "Issue changed", "to": {"watchers": True}},
+        )
+
+    def test_update_comment_sends_adf_body(self) -> None:
+        client = MagicMock()
+        client.request.return_value = _response({"id": "10001", "body": {}}, method="PUT")
+        service = JiraService(
+            {
+                "email": "ada@example.com",
+                "api_token": "jira-token",
+                "base_url": "https://example.atlassian.net",
+            },
+            client=client,
+        )
+
+        comment = service.update_comment("ENG-1", "10001", "Updated")
+
+        self.assertEqual(comment["id"], "10001")
+        self.assertEqual(
+            client.request.call_args.args[:2],
+            ("PUT", "https://example.atlassian.net/rest/api/3/issue/ENG-1/comment/10001"),
+        )
+        self.assertEqual(client.request.call_args.kwargs["json"]["body"]["type"], "doc")
+
+    def test_update_comment_sends_plain_text_body_for_api_v2(self) -> None:
+        client = MagicMock()
+        client.request.return_value = _response({"id": "10001", "body": "Updated"}, method="PUT")
+        service = JiraService(
+            {
+                "email": "ada@example.com",
+                "api_token": "jira-token",
+                "base_url": "https://example.atlassian.net",
+                "api_version": "2",
+            },
+            client=client,
+        )
+
+        service.update_comment("ENG-1", "10001", "Updated")
+
+        self.assertEqual(client.request.call_args.kwargs["json"]["body"], "Updated")
+
+    def test_create_user_sends_optional_fields(self) -> None:
+        client = MagicMock()
+        client.request.return_value = _response({"accountId": "acct-1"}, method="POST")
+        service = JiraService(
+            {
+                "email": "ada@example.com",
+                "api_token": "jira-token",
+                "base_url": "https://example.atlassian.net",
+            },
+            client=client,
+        )
+
+        user = service.create_user(
+            "ada@example.com",
+            username="ada",
+            display_name="Ada",
+            products=["jira-software"],
+        )
+
+        self.assertEqual(user["accountId"], "acct-1")
+        self.assertEqual(
+            client.request.call_args.args[:2],
+            ("POST", "https://example.atlassian.net/rest/api/3/user"),
+        )
+        self.assertEqual(
+            client.request.call_args.kwargs["json"],
+            {
+                "emailAddress": "ada@example.com",
+                "displayName": "Ada",
+                "products": ["jira-software"],
+            },
+        )
+
+    def test_get_and_delete_user_use_username_for_data_center(self) -> None:
+        client = MagicMock()
+        client.request.side_effect = [
+            _response({"name": "ada"}, url="https://jira.example.com/rest/api/2/user"),
+            _response(None, status_code=204, method="DELETE"),
+        ]
+        service = JiraService(
+            {
+                "email": "ada@example.com",
+                "api_token": "jira-token",
+                "base_url": "https://jira.example.com",
+                "deployment": "data_center",
+            },
+            client=client,
+        )
+
+        user = service.get_user("ada")
+        deleted = service.delete_user("ada")
+
+        self.assertEqual(user["name"], "ada")
+        self.assertTrue(deleted)
+        self.assertEqual(client.request.call_args_list[0].kwargs["params"], {"username": "ada"})
+        self.assertEqual(client.request.call_args_list[1].kwargs["params"], {"username": "ada"})
+
+    def test_create_user_sends_data_center_payload(self) -> None:
+        client = MagicMock()
+        client.request.return_value = _response({"name": "ada"}, method="POST")
+        service = JiraService(
+            {
+                "email": "admin@example.com",
+                "api_token": "jira-token",
+                "base_url": "https://jira.example.com",
+                "deployment": "data_center",
+            },
+            client=client,
+        )
+
+        user = service.create_user(
+            "ada@example.com",
+            username="ada",
+            display_name="Ada",
+            products=["jira-software"],
+        )
+
+        self.assertEqual(user["name"], "ada")
+        self.assertEqual(
+            client.request.call_args.args[:2],
+            ("POST", "https://jira.example.com/rest/api/2/user"),
+        )
+        self.assertEqual(
+            client.request.call_args.kwargs["json"],
+            {"emailAddress": "ada@example.com", "name": "ada", "displayName": "Ada"},
+        )
+
+    def test_add_attachment_sends_multipart_payload(self) -> None:
+        client = MagicMock()
+        client.request.return_value = _response(
+            [{"id": "att-1", "filename": "report.txt"}],
+            method="POST",
+            url="https://example.atlassian.net/rest/api/3/issue/ENG-1/attachments",
+        )
+        service = JiraService(
+            {
+                "email": "ada@example.com",
+                "api_token": "jira-token",
+                "base_url": "https://example.atlassian.net",
+            },
+            client=client,
+        )
+
+        attachments = service.add_attachment(
+            "ENG-1",
+            filename="report.txt",
+            content=b"hello",
+            mime_type="text/plain",
+        )
+
+        self.assertEqual(attachments[0]["id"], "att-1")
+        self.assertEqual(
+            client.request.call_args.args[:2],
+            ("POST", "https://example.atlassian.net/rest/api/3/issue/ENG-1/attachments"),
+        )
+        self.assertEqual(client.request.call_args.kwargs["files"]["file"][0], "report.txt")
+        self.assertEqual(client.request.call_args.kwargs["files"]["file"][1], b"hello")
+        self.assertEqual(client.request.call_args.kwargs["files"]["file"][2], "text/plain")
+        self.assertEqual(
+            client.request.call_args.kwargs["headers"]["X-Atlassian-Token"],
+            "no-check",
+        )
+
+    def test_list_attachments_reads_issue_attachment_field(self) -> None:
+        client = MagicMock()
+        client.request.return_value = _response(
+            {"fields": {"attachment": [{"id": "att-1"}, {"id": "att-2"}]}}
+        )
+        service = JiraService(
+            {
+                "email": "ada@example.com",
+                "api_token": "jira-token",
+                "base_url": "https://example.atlassian.net",
+            },
+            client=client,
+        )
+
+        result = service.list_attachments("ENG-1", limit=1, start_at=1)
+
+        self.assertEqual(result["attachments"], [{"id": "att-2"}])
+        self.assertEqual(result["startAt"], 1)
+        self.assertEqual(result["total"], 2)
+        self.assertTrue(result["isLast"])
+        self.assertEqual(client.request.call_args.kwargs["params"], {"fields": "attachment"})
+
+    def test_transition_issue_refetches_issue(self) -> None:
+        client = MagicMock()
+        client.request.side_effect = [
+            _response(None, status_code=204, method="POST"),
+            _response({"id": "10001", "key": "ENG-1", "fields": {"status": {"name": "Done"}}}),
+        ]
+        service = JiraService(
+            {
+                "email": "ada@example.com",
+                "api_token": "jira-token",
+                "base_url": "https://example.atlassian.net",
+            },
+            client=client,
+        )
+
+        result = service.transition_issue("ENG-1", "31")
+
+        self.assertEqual(result["transitionId"], "31")
+        self.assertEqual(result["issue"]["key"], "ENG-1")
+
+    def test_http_error_detail_is_truncated(self) -> None:
+        client = MagicMock()
+        request = httpx.Request("GET", "https://example.atlassian.net/rest/api/3/myself")
+        client.request.return_value = httpx.Response(
+            400,
+            content=("x" * 700).encode(),
+            request=request,
+        )
+        service = JiraService(
+            {
+                "email": "ada@example.com",
+                "api_token": "jira-token",
+                "base_url": "https://example.atlassian.net",
+            },
+            client=client,
+        )
+
+        with self.assertRaisesRegex(ValueError, r"\.\.\.$"):
+            service.get_myself()
+
+    def test_non_json_response_raises_readable_error(self) -> None:
+        client = MagicMock()
+        request = httpx.Request("GET", "https://example.atlassian.net/rest/api/3/myself")
+        client.request.return_value = httpx.Response(200, content=b"not json", request=request)
+        service = JiraService(
+            {
+                "email": "ada@example.com",
+                "api_token": "jira-token",
+                "base_url": "https://example.atlassian.net",
+            },
+            client=client,
+        )
+
+        with self.assertRaisesRegex(ValueError, "non-JSON"):
+            service.get_myself()
+
+
+class JiraNodeHandlerTests(unittest.TestCase):
+    def test_create_issue_resolves_fields_and_calls_service(self) -> None:
+        ctx = _make_ctx(
+            {
+                "credentialId": "cred-1",
+                "jiraOperation": "createIssue",
+                "jiraProjectKey": "ENG",
+                "jiraIssueType": "Bug",
+                "jiraSummary": "$input.title",
+                "jiraDescription": "$input.description",
+                "jiraLabels": '["automation"]',
+            },
+            {"title": "Fix checkout", "description": "Checkout is broken"},
+        )
+        mock_service = MagicMock()
+        mock_service.create_issue.return_value = {"id": "10001", "key": "ENG-1"}
+
+        with _mock_jira_credential(CredentialType.jira):
+            with patch("app.services.jira_service.JiraService", return_value=mock_service):
+                result = execute(ctx)
+
+        mock_service.create_issue.assert_called_once_with(
+            "ENG",
+            "Bug",
+            "Fix checkout",
+            description="Checkout is broken",
+            assignee_account_id=None,
+            labels=["automation"],
+            issue_type_id=None,
+        )
+        self.assertEqual(result["key"], "ENG-1")
+
+    def test_rejects_non_jira_credential(self) -> None:
+        ctx = _make_ctx(
+            {"credentialId": "cred-1", "jiraOperation": "listProjects"},
+            credential_type=CredentialType.github,
+        )
+
+        with _mock_jira_credential(CredentialType.github):
+            with self.assertRaisesRegex(ValueError, "Jira credential"):
+                execute(ctx)
+
+    def test_update_issue_propagates_service_validation_error(self) -> None:
+        ctx = _make_ctx(
+            {
+                "credentialId": "cred-1",
+                "jiraOperation": "updateIssue",
+                "jiraIssueKey": "ENG-1",
+            }
+        )
+        mock_service = MagicMock()
+        mock_service.update_issue.side_effect = ValueError(
+            "Jira updateIssue requires at least one field to update"
+        )
+
+        with _mock_jira_credential(CredentialType.jira):
+            with patch("app.services.jira_service.JiraService", return_value=mock_service):
+                with self.assertRaisesRegex(ValueError, "at least one field"):
+                    execute(ctx)
+
+        mock_service.update_issue.assert_called_once()
+
+    def test_notify_issue_resolves_payload_fields(self) -> None:
+        ctx = _make_ctx(
+            {
+                "credentialId": "cred-1",
+                "jiraOperation": "notifyIssue",
+                "jiraIssueKey": "ENG-1",
+                "jiraNotifySubject": "$input.subject",
+                "jiraNotifyTextBody": "$input.body",
+                "jiraNotifyTo": '{"watchers":true}',
+            },
+            {"subject": "Heads up", "body": "Issue changed"},
+        )
+        mock_service = MagicMock()
+        mock_service.notify_issue.return_value = True
+
+        with _mock_jira_credential(CredentialType.jira):
+            with patch("app.services.jira_service.JiraService", return_value=mock_service):
+                result = execute(ctx)
+
+        mock_service.notify_issue.assert_called_once_with(
+            "ENG-1",
+            subject="Heads up",
+            text_body="Issue changed",
+            html_body=None,
+            to={"watchers": True},
+        )
+        self.assertTrue(result["notified"])
+
+    def test_update_comment_requires_comment_id_and_body(self) -> None:
+        ctx = _make_ctx(
+            {
+                "credentialId": "cred-1",
+                "jiraOperation": "updateComment",
+                "jiraIssueKey": "ENG-1",
+                "jiraCommentId": "10001",
+                "jiraCommentBody": "$input.body",
+            },
+            {"body": "Updated comment"},
+        )
+        mock_service = MagicMock()
+        mock_service.update_comment.return_value = {"id": "10001"}
+
+        with _mock_jira_credential(CredentialType.jira):
+            with patch("app.services.jira_service.JiraService", return_value=mock_service):
+                result = execute(ctx)
+
+        mock_service.update_comment.assert_called_once_with("ENG-1", "10001", "Updated comment")
+        self.assertEqual(result["comment"]["id"], "10001")
+
+    def test_create_user_parses_product_list(self) -> None:
+        ctx = _make_ctx(
+            {
+                "credentialId": "cred-1",
+                "jiraOperation": "createUser",
+                "jiraUserEmail": "$input.email",
+                "jiraUsername": "$input.username",
+                "jiraUserDisplayName": "Ada",
+                "jiraUserProducts": '["jira-software"]',
+            },
+            {"email": "ada@example.com", "username": "ada"},
+        )
+        mock_service = MagicMock()
+        mock_service.create_user.return_value = {"accountId": "acct-1"}
+
+        with _mock_jira_credential(CredentialType.jira):
+            with patch("app.services.jira_service.JiraService", return_value=mock_service):
+                result = execute(ctx)
+
+        mock_service.create_user.assert_called_once_with(
+            "ada@example.com",
+            username="ada",
+            display_name="Ada",
+            products=["jira-software"],
+        )
+        self.assertEqual(result["user"]["accountId"], "acct-1")
+
+    def test_add_attachment_decodes_base64_content(self) -> None:
+        ctx = _make_ctx(
+            {
+                "credentialId": "cred-1",
+                "jiraOperation": "addAttachment",
+                "jiraIssueKey": "ENG-1",
+                "jiraAttachmentFilename": "report.txt",
+                "jiraAttachmentBase64": "aGVsbG8=",
+                "jiraAttachmentMimeType": "text/plain",
+            }
+        )
+        mock_service = MagicMock()
+        mock_service.add_attachment.return_value = [{"id": "att-1"}]
+
+        with _mock_jira_credential(CredentialType.jira):
+            with patch("app.services.jira_service.JiraService", return_value=mock_service):
+                result = execute(ctx)
+
+        mock_service.add_attachment.assert_called_once_with(
+            "ENG-1",
+            filename="report.txt",
+            content=b"hello",
+            mime_type="text/plain",
+        )
+        self.assertEqual(result["attachments"], [{"id": "att-1"}])
+
+    def test_get_attachment_can_include_binary_content(self) -> None:
+        ctx = _make_ctx(
+            {
+                "credentialId": "cred-1",
+                "jiraOperation": "getAttachment",
+                "jiraAttachmentId": "att-1",
+                "jiraIncludeBinary": True,
+            }
+        )
+        mock_service = MagicMock()
+        mock_service.get_attachment.return_value = {
+            "id": "att-1",
+            "content": "https://example.atlassian.net/secure/attachment/att-1/report.txt",
+        }
+        mock_service.download_attachment.return_value = b"hello"
+
+        with _mock_jira_credential(CredentialType.jira):
+            with patch("app.services.jira_service.JiraService", return_value=mock_service):
+                result = execute(ctx)
+
+        mock_service.download_attachment.assert_called_once()
+        self.assertEqual(result["attachment"]["content_base64"], "aGVsbG8=")
+
+    def test_get_issue_changelog_returns_values(self) -> None:
+        ctx = _make_ctx(
+            {
+                "credentialId": "cred-1",
+                "jiraOperation": "getIssueChangelog",
+                "jiraIssueKey": "ENG-1",
+            }
+        )
+        mock_service = MagicMock()
+        mock_service.get_issue_changelog.return_value = {
+            "values": [{"id": "10001", "items": []}],
+            "total": 1,
+        }
+
+        with _mock_jira_credential(CredentialType.jira):
+            with patch("app.services.jira_service.JiraService", return_value=mock_service):
+                result = execute(ctx)
+
+        self.assertEqual(result["count"], 1)
+        self.assertEqual(result["changelog"], [{"id": "10001", "items": []}])
+
+    def test_search_issues_passes_next_page_token_and_fields(self) -> None:
+        ctx = _make_ctx(
+            {
+                "credentialId": "cred-1",
+                "jiraOperation": "searchIssues",
+                "jiraJql": "$input.jql",
+                "jiraNextPageToken": "token-1",
+                "jiraFields": '["key","summary"]',
+                "jiraLimit": "25",
+            },
+            {"jql": "project = ENG"},
+        )
+        mock_service = MagicMock()
+        mock_service.search_issues.return_value = {
+            "issues": [{"id": "10001", "key": "ENG-1"}],
+            "nextPageToken": "token-2",
+            "isLast": False,
+        }
+
+        with _mock_jira_credential(CredentialType.jira):
+            with patch("app.services.jira_service.JiraService", return_value=mock_service):
+                result = execute(ctx)
+
+        mock_service.search_issues.assert_called_once_with(
+            "project = ENG",
+            25,
+            next_page_token="token-1",
+            start_at=0,
+            fields=["key", "summary"],
+        )
+        self.assertEqual(result["pagination"]["nextPageToken"], "token-2")
+        self.assertEqual(result["count"], 1)
+
+    def test_create_issue_uses_issue_type_id_when_provided(self) -> None:
+        ctx = _make_ctx(
+            {
+                "credentialId": "cred-1",
+                "jiraOperation": "createIssue",
+                "jiraProjectKey": "ENG",
+                "jiraIssueType": "Bug",
+                "jiraIssueTypeId": "10001",
+                "jiraSummary": "Fix checkout",
+            }
+        )
+        mock_service = MagicMock()
+        mock_service.create_issue.return_value = {"id": "10001", "key": "ENG-1"}
+
+        with _mock_jira_credential(CredentialType.jira):
+            with patch("app.services.jira_service.JiraService", return_value=mock_service):
+                execute(ctx)
+
+        mock_service.create_issue.assert_called_once_with(
+            "ENG",
+            "Bug",
+            "Fix checkout",
+            description=None,
+            assignee_account_id=None,
+            labels=None,
+            issue_type_id="10001",
+        )
+
+    def test_transition_issue_returns_updated_issue(self) -> None:
+        ctx = _make_ctx(
+            {
+                "credentialId": "cred-1",
+                "jiraOperation": "transitionIssue",
+                "jiraIssueKey": "ENG-1",
+                "jiraTransitionId": "31",
+            }
+        )
+        mock_service = MagicMock()
+        mock_service.transition_issue.return_value = {
+            "transitionId": "31",
+            "issue": {"id": "10001", "key": "ENG-1"},
+        }
+
+        with _mock_jira_credential(CredentialType.jira):
+            with patch("app.services.jira_service.JiraService", return_value=mock_service):
+                result = execute(ctx)
+
+        self.assertEqual(result["key"], "ENG-1")
+        self.assertEqual(result["transition"]["transitionId"], "31")
+
+    def test_get_myself_returns_user(self) -> None:
+        ctx = _make_ctx({"credentialId": "cred-1", "jiraOperation": "getMyself"})
+        mock_service = MagicMock()
+        mock_service.get_myself.return_value = {"accountId": "acct-1", "displayName": "Ada"}
+
+        with _mock_jira_credential(CredentialType.jira):
+            with patch("app.services.jira_service.JiraService", return_value=mock_service):
+                result = execute(ctx)
+
+        mock_service.get_myself.assert_called_once_with()
+        self.assertEqual(result["user"]["displayName"], "Ada")
+
+    def test_list_projects_returns_projects_and_pagination(self) -> None:
+        ctx = _make_ctx(
+            {
+                "credentialId": "cred-1",
+                "jiraOperation": "listProjects",
+                "jiraLimit": "25",
+                "jiraStartAt": "10",
+            }
+        )
+        mock_service = MagicMock()
+        mock_service.list_projects.return_value = {
+            "values": [{"id": "10000", "key": "ENG"}],
+            "startAt": 10,
+            "maxResults": 25,
+            "total": 1,
+            "isLast": True,
+        }
+
+        with _mock_jira_credential(CredentialType.jira):
+            with patch("app.services.jira_service.JiraService", return_value=mock_service):
+                result = execute(ctx)
+
+        mock_service.list_projects.assert_called_once_with(25, 10)
+        self.assertEqual(result["count"], 1)
+        self.assertEqual(result["projects"][0]["key"], "ENG")
+
+    def test_get_issue_returns_issue(self) -> None:
+        ctx = _make_ctx(
+            {
+                "credentialId": "cred-1",
+                "jiraOperation": "getIssue",
+                "jiraIssueKey": "ENG-1",
+            }
+        )
+        mock_service = MagicMock()
+        mock_service.get_issue.return_value = {"id": "10001", "key": "ENG-1"}
+
+        with _mock_jira_credential(CredentialType.jira):
+            with patch("app.services.jira_service.JiraService", return_value=mock_service):
+                result = execute(ctx)
+
+        mock_service.get_issue.assert_called_once_with("ENG-1")
+        self.assertEqual(result["key"], "ENG-1")
+
+    def test_delete_issue_returns_deleted_flag(self) -> None:
+        ctx = _make_ctx(
+            {
+                "credentialId": "cred-1",
+                "jiraOperation": "deleteIssue",
+                "jiraIssueKey": "ENG-1",
+            }
+        )
+        mock_service = MagicMock()
+        mock_service.delete_issue.return_value = True
+
+        with _mock_jira_credential(CredentialType.jira):
+            with patch("app.services.jira_service.JiraService", return_value=mock_service):
+                result = execute(ctx)
+
+        mock_service.delete_issue.assert_called_once_with("ENG-1")
+        self.assertTrue(result["deleted"])
+
+    def test_list_comments_returns_comments(self) -> None:
+        ctx = _make_ctx(
+            {
+                "credentialId": "cred-1",
+                "jiraOperation": "listComments",
+                "jiraIssueKey": "ENG-1",
+                "jiraLimit": "25",
+                "jiraStartAt": "5",
+            }
+        )
+        mock_service = MagicMock()
+        mock_service.list_comments.return_value = {
+            "comments": [{"id": "10001", "body": {}}],
+            "startAt": 5,
+            "maxResults": 25,
+            "total": 1,
+            "isLast": True,
+        }
+
+        with _mock_jira_credential(CredentialType.jira):
+            with patch("app.services.jira_service.JiraService", return_value=mock_service):
+                result = execute(ctx)
+
+        mock_service.list_comments.assert_called_once_with("ENG-1", 25, 5)
+        self.assertEqual(result["count"], 1)
+
+    def test_create_comment_resolves_body(self) -> None:
+        ctx = _make_ctx(
+            {
+                "credentialId": "cred-1",
+                "jiraOperation": "createComment",
+                "jiraIssueKey": "ENG-1",
+                "jiraCommentBody": "$input.body",
+            },
+            {"body": "New comment"},
+        )
+        mock_service = MagicMock()
+        mock_service.create_comment.return_value = {"id": "10001"}
+
+        with _mock_jira_credential(CredentialType.jira):
+            with patch("app.services.jira_service.JiraService", return_value=mock_service):
+                result = execute(ctx)
+
+        mock_service.create_comment.assert_called_once_with("ENG-1", "New comment")
+        self.assertEqual(result["comment"]["id"], "10001")
+
+    def test_list_transitions_returns_transitions(self) -> None:
+        ctx = _make_ctx(
+            {
+                "credentialId": "cred-1",
+                "jiraOperation": "listTransitions",
+                "jiraIssueKey": "ENG-1",
+            }
+        )
+        mock_service = MagicMock()
+        mock_service.list_transitions.return_value = [{"id": "31", "name": "Done"}]
+
+        with _mock_jira_credential(CredentialType.jira):
+            with patch("app.services.jira_service.JiraService", return_value=mock_service):
+                result = execute(ctx)
+
+        mock_service.list_transitions.assert_called_once_with("ENG-1")
+        self.assertEqual(result["count"], 1)
+
+    def test_delete_attachment_returns_deleted_flag(self) -> None:
+        ctx = _make_ctx(
+            {
+                "credentialId": "cred-1",
+                "jiraOperation": "deleteAttachment",
+                "jiraAttachmentId": "att-1",
+            }
+        )
+        mock_service = MagicMock()
+        mock_service.delete_attachment.return_value = True
+
+        with _mock_jira_credential(CredentialType.jira):
+            with patch("app.services.jira_service.JiraService", return_value=mock_service):
+                result = execute(ctx)
+
+        mock_service.delete_attachment.assert_called_once_with("att-1")
+        self.assertTrue(result["deleted"])
+
+    def test_get_user_returns_user(self) -> None:
+        ctx = _make_ctx(
+            {
+                "credentialId": "cred-1",
+                "jiraOperation": "getUser",
+                "jiraAccountId": "acct-1",
+            }
+        )
+        mock_service = MagicMock()
+        mock_service.get_user.return_value = {"accountId": "acct-1"}
+
+        with _mock_jira_credential(CredentialType.jira):
+            with patch("app.services.jira_service.JiraService", return_value=mock_service):
+                result = execute(ctx)
+
+        mock_service.get_user.assert_called_once_with("acct-1")
+        self.assertEqual(result["user"]["accountId"], "acct-1")
+
+    def test_delete_user_returns_deleted_flag(self) -> None:
+        ctx = _make_ctx(
+            {
+                "credentialId": "cred-1",
+                "jiraOperation": "deleteUser",
+                "jiraAccountId": "acct-1",
+            }
+        )
+        mock_service = MagicMock()
+        mock_service.delete_user.return_value = True
+
+        with _mock_jira_credential(CredentialType.jira):
+            with patch("app.services.jira_service.JiraService", return_value=mock_service):
+                result = execute(ctx)
+
+        mock_service.delete_user.assert_called_once_with("acct-1")
+        self.assertTrue(result["deleted"])
+
+    def test_update_issue_null_expression_clears_assignee(self) -> None:
+        ctx = _make_ctx(
+            {
+                "credentialId": "cred-1",
+                "jiraOperation": "updateIssue",
+                "jiraIssueKey": "ENG-1",
+                "jiraAssigneeAccountId": "null",
+            }
+        )
+        mock_service = MagicMock()
+        mock_service.update_issue.return_value = {"id": "10001", "key": "ENG-1"}
+
+        with _mock_jira_credential(CredentialType.jira):
+            with patch("app.services.jira_service.JiraService", return_value=mock_service):
+                result = execute(ctx)
+
+        mock_service.update_issue.assert_called_once()
+        self.assertIsNone(mock_service.update_issue.call_args.kwargs["assignee_account_id"])
+        self.assertEqual(result["key"], "ENG-1")
+
+    def test_add_attachment_decodes_data_url_content(self) -> None:
+        ctx = _make_ctx(
+            {
+                "credentialId": "cred-1",
+                "jiraOperation": "addAttachment",
+                "jiraIssueKey": "ENG-1",
+                "jiraAttachmentFilename": "report.txt",
+                "jiraAttachmentBase64": "data:text/plain;base64,aGVsbG8=",
+            }
+        )
+        mock_service = MagicMock()
+        mock_service.add_attachment.return_value = [{"id": "att-1"}]
+
+        with _mock_jira_credential(CredentialType.jira):
+            with patch("app.services.jira_service.JiraService", return_value=mock_service):
+                execute(ctx)
+
+        mock_service.add_attachment.assert_called_once_with(
+            "ENG-1",
+            filename="report.txt",
+            content=b"hello",
+            mime_type="text/plain",
+        )
+
+    def test_list_attachments_can_include_binary_content(self) -> None:
+        ctx = _make_ctx(
+            {
+                "credentialId": "cred-1",
+                "jiraOperation": "listAttachments",
+                "jiraIssueKey": "ENG-1",
+                "jiraIncludeBinary": True,
+                "jiraStartAt": "1",
+            }
+        )
+        mock_service = MagicMock()
+        mock_service.list_attachments.return_value = {
+            "attachments": [
+                {
+                    "id": "att-2",
+                    "content": "https://example.atlassian.net/secure/attachment/att-2/report.txt",
+                }
+            ],
+            "startAt": 1,
+            "maxResults": 50,
+            "total": 2,
+            "isLast": True,
+        }
+        mock_service.download_attachment.return_value = b"hello"
+
+        with _mock_jira_credential(CredentialType.jira):
+            with patch("app.services.jira_service.JiraService", return_value=mock_service):
+                result = execute(ctx)
+
+        mock_service.list_attachments.assert_called_once_with("ENG-1", 50, 1)
+        mock_service.download_attachment.assert_called_once()
+        self.assertEqual(result["attachments"][0]["content_base64"], "aGVsbG8=")
+
+    def test_create_issue_parses_comma_separated_labels(self) -> None:
+        ctx = _make_ctx(
+            {
+                "credentialId": "cred-1",
+                "jiraOperation": "createIssue",
+                "jiraProjectKey": "ENG",
+                "jiraSummary": "Fix checkout",
+                "jiraLabels": "automation, bug",
+            }
+        )
+        mock_service = MagicMock()
+        mock_service.create_issue.return_value = {"id": "10001", "key": "ENG-1"}
+
+        with _mock_jira_credential(CredentialType.jira):
+            with patch("app.services.jira_service.JiraService", return_value=mock_service):
+                execute(ctx)
+
+        mock_service.create_issue.assert_called_once_with(
+            "ENG",
+            "Task",
+            "Fix checkout",
+            description=None,
+            assignee_account_id=None,
+            labels=["automation", "bug"],
+            issue_type_id=None,
+        )
+
+    def test_search_issues_parses_comma_separated_fields(self) -> None:
+        ctx = _make_ctx(
+            {
+                "credentialId": "cred-1",
+                "jiraOperation": "searchIssues",
+                "jiraJql": "project = ENG",
+                "jiraFields": "key, summary, status",
+            }
+        )
+        mock_service = MagicMock()
+        mock_service.search_issues.return_value = {"issues": [], "isLast": True}
+
+        with _mock_jira_credential(CredentialType.jira):
+            with patch("app.services.jira_service.JiraService", return_value=mock_service):
+                execute(ctx)
+
+        mock_service.search_issues.assert_called_once_with(
+            "project = ENG",
+            50,
+            next_page_token=None,
+            start_at=0,
+            fields=["key", "summary", "status"],
+        )
+
+
+def _make_ctx(
+    node_data: dict,
+    inputs: dict | None = None,
+    credential_type: CredentialType = CredentialType.jira,
+) -> NodeExecutionContext:
+    executor = MagicMock()
+
+    def evaluate_message_template(value: str, current_inputs: dict, _node_id: str) -> str:
+        if value.startswith("$input."):
+            return str(current_inputs.get(value.removeprefix("$input."), ""))
+        return value
+
+    executor.evaluate_message_template.side_effect = evaluate_message_template
+    executor._get_accessible_credential.return_value = MagicMock(
+        encrypted_config="{}",
+        type=credential_type,
+    )
+    return NodeExecutionContext(
+        executor=executor,
+        node_id="jira-1",
+        inputs=inputs or {},
+        allow_branch_skip=False,
+        start_time=0,
+        node={"id": "jira-1", "type": "jira", "data": node_data},
+        node_type="jira",
+        node_data=node_data,
+        node_label="jiraNode",
+    )
+
+
+@contextmanager
+def _mock_jira_credential(credential_type: CredentialType) -> Iterator[None]:
+    db = MagicMock()
+    db.__enter__ = MagicMock(return_value=db)
+    db.__exit__ = MagicMock(return_value=False)
+    db.query.return_value.filter.return_value.first.return_value = MagicMock(
+        encrypted_config="{}",
+        type=credential_type,
+    )
+    with patch("app.db.session.SessionLocal", return_value=db):
+        with patch(
+            "app.services.encryption.decrypt_config",
+            return_value={
+                "email": "ada@example.com",
+                "api_token": "jira-token",
+                "base_url": "https://example.atlassian.net",
+            },
+        ):
+            yield
diff --git a/frontend/e2e/jira-node-properties.spec.ts b/frontend/e2e/jira-node-properties.spec.ts
new file mode 100644
index 00000000..31e247dc
--- /dev/null
+++ b/frontend/e2e/jira-node-properties.spec.ts
@@ -0,0 +1,235 @@
+import { expect, test } from "@playwright/test";
+
+import { createWorkflow, deleteWorkflow, prepareAuthenticatedPage } from "./support";
+
+test.beforeEach(async ({ page }) => {
+  await prepareAuthenticatedPage(page);
+});
+
+test("shows Jira node operation-specific fields", async ({ page }) => {
+  const workflow = await createWorkflow(
+    page,
+    `Jira Node Properties ${Date.now()}`,
+    [
+      {
+        id: "jira-node",
+        type: "jira",
+        position: { x: 120, y: 160 },
+        data: {
+          label: "jira",
+          credentialId: "",
+          jiraOperation: "createIssue",
+          jiraProjectKey: "",
+          jiraIssueType: "Task",
+          jiraSummary: "",
+          jiraDescription: "$input.text",
+        },
+      },
+    ],
+  );
+
+  try {
+    await page.goto(`/workflows/${workflow.id}`);
+    await expect(page.locator(".vue-flow__node")).toHaveCount(1);
+    await page.getByRole("button", { name: "Properties", exact: true }).click();
+    await page.locator('.vue-flow__node[data-id="jira-node"]').click();
+
+    const panel = page.locator(".properties-panel");
+    await expect(panel.getByTestId("jira-credential-field")).toBeVisible();
+    await expect(panel.getByTestId("jira-operation-field")).toBeVisible();
+    await expect(panel.getByTestId("jira-project-key-field")).toBeVisible();
+    await expect(panel.getByTestId("jira-issue-type-field")).toBeVisible();
+    await expect(panel.getByTestId("jira-summary-field")).toBeVisible();
+    await expect(panel.getByTestId("jira-description-field")).toBeVisible();
+  } finally {
+    await deleteWorkflow(page, workflow.id);
+  }
+});
+
+test("shows Jira notify operation fields", async ({ page }) => {
+  const workflow = await createWorkflow(
+    page,
+    `Jira Notify Properties ${Date.now()}`,
+    [
+      {
+        id: "jira-node",
+        type: "jira",
+        position: { x: 120, y: 160 },
+        data: {
+          label: "jira",
+          credentialId: "",
+          jiraOperation: "notifyIssue",
+          jiraIssueKey: "ENG-1",
+          jiraNotifySubject: "Issue update",
+          jiraNotifyTextBody: "$input.text",
+          jiraNotifyTo: "{\"assignee\":true}",
+        },
+      },
+    ],
+  );
+
+  try {
+    await page.goto(`/workflows/${workflow.id}`);
+    await expect(page.locator(".vue-flow__node")).toHaveCount(1);
+    await page.getByRole("button", { name: "Properties", exact: true }).click();
+    await page.locator('.vue-flow__node[data-id="jira-node"]').click();
+
+    const panel = page.locator(".properties-panel");
+    await expect(panel.getByTestId("jira-issue-key-field")).toBeVisible();
+    await expect(panel.getByTestId("jira-notify-subject-field")).toBeVisible();
+    await expect(panel.getByTestId("jira-notify-text-body-field")).toBeVisible();
+    await expect(panel.getByTestId("jira-notify-to-field")).toBeVisible();
+  } finally {
+    await deleteWorkflow(page, workflow.id);
+  }
+});
+
+test("shows Jira attachment operation fields", async ({ page }) => {
+  const workflow = await createWorkflow(
+    page,
+    `Jira Attachment Properties ${Date.now()}`,
+    [
+      {
+        id: "jira-node",
+        type: "jira",
+        position: { x: 120, y: 160 },
+        data: {
+          label: "jira",
+          credentialId: "",
+          jiraOperation: "addAttachment",
+          jiraIssueKey: "ENG-1",
+          jiraAttachmentFilename: "report.txt",
+          jiraAttachmentBase64: "aGVsbG8=",
+        },
+      },
+    ],
+  );
+
+  try {
+    await page.goto(`/workflows/${workflow.id}`);
+    await expect(page.locator(".vue-flow__node")).toHaveCount(1);
+    await page.getByRole("button", { name: "Properties", exact: true }).click();
+    await page.locator('.vue-flow__node[data-id="jira-node"]').click();
+
+    const panel = page.locator(".properties-panel");
+    await expect(panel.getByTestId("jira-issue-key-field")).toBeVisible();
+    await expect(panel.getByTestId("jira-attachment-filename-field")).toBeVisible();
+    await expect(panel.getByTestId("jira-attachment-base64-field")).toBeVisible();
+    await expect(panel.getByTestId("jira-attachment-mime-type-field")).toBeVisible();
+  } finally {
+    await deleteWorkflow(page, workflow.id);
+  }
+});
+
+test("shows Jira search operation fields", async ({ page }) => {
+  const workflow = await createWorkflow(
+    page,
+    `Jira Search Properties ${Date.now()}`,
+    [
+      {
+        id: "jira-node",
+        type: "jira",
+        position: { x: 120, y: 160 },
+        data: {
+          label: "jira",
+          credentialId: "",
+          jiraOperation: "searchIssues",
+          jiraJql: "project = ENG AND updated >= -30d ORDER BY updated DESC",
+          jiraFields: "[\"key\",\"summary\"]",
+          jiraLimit: "25",
+          jiraNextPageToken: "",
+        },
+      },
+    ],
+  );
+
+  try {
+    await page.goto(`/workflows/${workflow.id}`);
+    await expect(page.locator(".vue-flow__node")).toHaveCount(1);
+    await page.getByRole("button", { name: "Properties", exact: true }).click();
+    await page.locator('.vue-flow__node[data-id="jira-node"]').click();
+
+    const panel = page.locator(".properties-panel");
+    await expect(panel.getByTestId("jira-jql-field")).toBeVisible();
+    await expect(panel.getByTestId("jira-fields-field")).toBeVisible();
+    await expect(panel.getByText("Limit", { exact: true })).toBeVisible();
+    await expect(panel.getByText("Next Page Token", { exact: true })).toBeVisible();
+    await expect(panel.getByText("Start At", { exact: true })).toBeVisible();
+  } finally {
+    await deleteWorkflow(page, workflow.id);
+  }
+});
+
+test("shows Jira list attachments operation fields", async ({ page }) => {
+  const workflow = await createWorkflow(
+    page,
+    `Jira List Attachments Properties ${Date.now()}`,
+    [
+      {
+        id: "jira-node",
+        type: "jira",
+        position: { x: 120, y: 160 },
+        data: {
+          label: "jira",
+          credentialId: "",
+          jiraOperation: "listAttachments",
+          jiraIssueKey: "ENG-1",
+          jiraLimit: "25",
+          jiraStartAt: "0",
+          jiraIncludeBinary: true,
+        },
+      },
+    ],
+  );
+
+  try {
+    await page.goto(`/workflows/${workflow.id}`);
+    await expect(page.locator(".vue-flow__node")).toHaveCount(1);
+    await page.getByRole("button", { name: "Properties", exact: true }).click();
+    await page.locator('.vue-flow__node[data-id="jira-node"]').click();
+
+    const panel = page.locator(".properties-panel");
+    await expect(panel.getByTestId("jira-issue-key-field")).toBeVisible();
+    await expect(panel.getByText("Limit", { exact: true })).toBeVisible();
+    await expect(panel.getByText("Start At", { exact: true })).toBeVisible();
+    await expect(panel.getByText("Include binary content as base64")).toBeVisible();
+  } finally {
+    await deleteWorkflow(page, workflow.id);
+  }
+});
+
+test("shows Jira create user identity fields", async ({ page }) => {
+  const workflow = await createWorkflow(
+    page,
+    `Jira Create User Properties ${Date.now()}`,
+    [
+      {
+        id: "jira-node",
+        type: "jira",
+        position: { x: 120, y: 160 },
+        data: {
+          label: "jira",
+          credentialId: "",
+          jiraOperation: "createUser",
+          jiraUserEmail: "ada@example.com",
+          jiraUsername: "ada",
+          jiraUserDisplayName: "Ada Lovelace",
+        },
+      },
+    ],
+  );
+
+  try {
+    await page.goto(`/workflows/${workflow.id}`);
+    await expect(page.locator(".vue-flow__node")).toHaveCount(1);
+    await page.getByRole("button", { name: "Properties", exact: true }).click();
+    await page.locator('.vue-flow__node[data-id="jira-node"]').click();
+
+    const panel = page.locator(".properties-panel");
+    await expect(panel.getByTestId("jira-user-email-field")).toBeVisible();
+    await expect(panel.getByTestId("jira-username-field")).toBeVisible();
+    await expect(panel.getByTestId("jira-user-display-name-field")).toBeVisible();
+  } finally {
+    await deleteWorkflow(page, workflow.id);
+  }
+});
diff --git a/frontend/src/components/Canvas/WorkflowCanvas.vue b/frontend/src/components/Canvas/WorkflowCanvas.vue
index 58acc745..911c01ae 100644
--- a/frontend/src/components/Canvas/WorkflowCanvas.vue
+++ b/frontend/src/components/Canvas/WorkflowCanvas.vue
@@ -1081,6 +1081,7 @@ function getDefaultNodeData(type: NodeType): WorkflowNode["data"] {
     rag: { label: "rag", vectorStoreId: "", ragOperation: undefined, documentContent: "$input.text", documentMetadata: "{}", queryText: "$input.text", searchLimit: 5, metadataFilters: "{}" },
     grist: { label: "grist", credentialId: "", gristOperation: undefined, gristDocId: "", gristTableId: "", gristRecordId: "", gristRecordData: "{}", gristRecordsData: "[]", gristFilter: "{}", gristSort: "", gristLimit: 100, gristRecordIds: "[]" },
     github: { label: "github", credentialId: "", githubOperation: "getRepository", githubOwner: "", githubRepo: "", githubOrganization: "", githubInviteEmail: "", githubIssueNumber: "", githubTitle: undefined, githubBody: undefined, githubCommentBody: "$input.text", githubState: undefined, githubStateReason: undefined, githubAssignee: "", githubCreator: "", githubMentioned: "", githubLabelsFilter: "", githubSince: "", githubSort: "", githubDirection: "", githubLabels: undefined, githubAssignees: undefined, githubLockReason: "", githubHead: "", githubBase: "main", githubPullRequestNumber: "", githubReviewId: "", githubReviewEvent: "APPROVE", githubReviewBody: "", githubCommitId: "", githubDraft: undefined, githubPrerelease: undefined, githubFilePath: "", githubFileContent: "$input.text", githubCommitMessage: "", githubBranch: "", githubPerPage: "30", githubTagName: "", githubReleaseId: "", githubWorkflowId: "", githubWorkflowInputs: undefined, githubWaitTimeoutSeconds: "600", githubPollIntervalSeconds: "5" },
+    jira: { label: "jira", credentialId: "", jiraOperation: "searchIssues", jiraProjectKey: "", jiraIssueKey: "", jiraIssueType: "Task", jiraIssueTypeId: "", jiraSummary: "", jiraDescription: "$input.text", jiraJql: "updated >= -30d ORDER BY updated DESC", jiraFields: "", jiraAssigneeAccountId: "", jiraLabels: "", jiraCommentBody: "$input.text", jiraCommentId: "", jiraTransitionId: "", jiraAttachmentId: "", jiraAttachmentFilename: "", jiraAttachmentBase64: "", jiraAttachmentMimeType: "", jiraIncludeBinary: false, jiraNotifySubject: "", jiraNotifyTextBody: "$input.text", jiraNotifyHtmlBody: "", jiraNotifyTo: "{\"assignee\":true}", jiraAccountId: "", jiraUsername: "", jiraUserEmail: "", jiraUserDisplayName: "", jiraUserProducts: "", jiraLimit: "50", jiraStartAt: "0", jiraNextPageToken: "" },
     linear: { label: "linear", credentialId: "", linearOperation: "listIssues", linearTeamId: "", linearProjectId: "", linearIssueId: "", linearIssueLinkUrl: "", linearTitle: "", linearDescription: "$input.text", linearStateId: "", linearAssigneeId: "", linearPriority: "", linearCommentId: "", linearCommentBody: "$input.text", linearParentCommentId: "", linearLimit: "50", linearReturnAll: false },
     googleSheets: { label: "googleSheets", credentialId: "", gsOperation: undefined, gsSpreadsheetId: "", gsSheetName: "Sheet1", gsStartRow: "1", gsUpdateRow: "1", gsMaxRows: "0", gsHasHeader: true, gsRowCount: "1", gsKeepHeader: false, gsAppendPlacement: "append", gsValuesInputMode: "raw", gsValuesSelectiveRows: "1", gsValuesSelectiveCols: "3", gsValues: "[]" },
     bigquery: { label: "bigquery", credentialId: "", bqOperation: undefined, bqProjectId: "", bqQuery: "", bqMaxResults: "1000", bqDatasetId: "", bqTableId: "", bqRowsInputMode: "raw", bqRows: "[]", bqMappings: [{ key: "field", value: "$input.text" }] },
diff --git a/frontend/src/components/Credentials/CredentialDialog.vue b/frontend/src/components/Credentials/CredentialDialog.vue
index 9787aeaa..32767d5a 100644
--- a/frontend/src/components/Credentials/CredentialDialog.vue
+++ b/frontend/src/components/Credentials/CredentialDialog.vue
@@ -48,6 +48,32 @@ const codexSigningIn = ref(false);
 const codexSignInError = ref("");
 const codexSignedInAccount = ref("");
 const baseUrl = ref("");
+const jiraEmail = ref("");
+const jiraDeployment = ref<"cloud" | "data_center">("cloud");
+const jiraApiVersion = ref("3");
+const jiraTesting = ref(false);
+const jiraTestSuccess = ref<boolean | null>(null);
+const jiraTestMessage = ref("");
+const jiraUserLabel = computed((): string =>
+  jiraDeployment.value === "data_center" ? "Jira Username" : "Jira Email",
+);
+const jiraUserPlaceholder = computed((): string =>
+  jiraDeployment.value === "data_center" ? "jira-user" : "you@example.com",
+);
+const jiraSecretLabel = computed((): string =>
+  jiraDeployment.value === "data_center" ? "Password" : "API Token",
+);
+const jiraSecretPlaceholder = computed((): string => {
+  if (isEditing.value) {
+    return "••••••• (re-enter to update)";
+  }
+  return jiraDeployment.value === "data_center" ? "Jira password" : "Atlassian API token";
+});
+const jiraAuthHelpText = computed((): string =>
+  jiraDeployment.value === "data_center"
+    ? "Data Center / Server currently supports Basic auth with username and password. Personal access tokens and Bearer auth are not supported yet."
+    : "Jira Cloud uses an Atlassian account email and API token.",
+);
 const bearerToken = ref("");
 const headerKey = ref("");
 const headerValue = ref("");
@@ -188,6 +214,7 @@ const typeOptions = [
   { value: "codex", label: CREDENTIAL_TYPE_LABELS.codex },
   { value: "google", label: CREDENTIAL_TYPE_LABELS.google },
   { value: "github", label: CREDENTIAL_TYPE_LABELS.github },
+  { value: "jira", label: CREDENTIAL_TYPE_LABELS.jira },
   { value: "linear", label: CREDENTIAL_TYPE_LABELS.linear },
   { value: "elevenlabs", label: CREDENTIAL_TYPE_LABELS.elevenlabs },
   { value: "custom", label: CREDENTIAL_TYPE_LABELS.custom },
@@ -236,7 +263,23 @@ watch(
             : "chatgpt";
         codexSignedInAccount.value =
           props.credential.public_fields?.account_id || "";
-        baseUrl.value = "";
+        baseUrl.value =
+          props.credential.type === "jira"
+            ? props.credential.public_fields?.base_url ?? ""
+            : "";
+        jiraEmail.value =
+          props.credential.type === "jira"
+            ? props.credential.public_fields?.email ?? ""
+            : "";
+        jiraDeployment.value =
+          props.credential.type === "jira" &&
+          props.credential.public_fields?.deployment === "data_center"
+            ? "data_center"
+            : "cloud";
+        jiraApiVersion.value =
+          props.credential.type === "jira"
+            ? props.credential.public_fields?.api_version ?? "3"
+            : "3";
         bearerToken.value = "";
         headerKey.value = props.credential.header_key || "";
         headerValue.value = "";
@@ -344,6 +387,9 @@ watch(
         resetCodexOAuthState();
         codexSignedInAccount.value = "";
         baseUrl.value = "";
+        jiraEmail.value = "";
+        jiraDeployment.value = "cloud";
+        jiraApiVersion.value = "3";
         bearerToken.value = "";
         headerKey.value = "";
         headerValue.value = "";
@@ -425,6 +471,9 @@ watch(
       linearTesting.value = false;
       linearTestSuccess.value = null;
       linearTestMessage.value = "";
+      jiraTesting.value = false;
+      jiraTestSuccess.value = null;
+      jiraTestMessage.value = "";
       notionTesting.value = false;
       notionTestSuccess.value = null;
       notionTestMessage.value = "";
@@ -460,6 +509,11 @@ const isValid = computed(() => {
     type.value === "elevenlabs"
   ) {
     return !!apiKey.value.trim() || isEditing.value;
+  } else if (type.value === "jira") {
+    if (isEditing.value) {
+      return !!jiraEmail.value.trim() && !!baseUrl.value.trim();
+    }
+    return !!jiraEmail.value.trim() && !!apiKey.value.trim() && !!baseUrl.value.trim();
   } else if (type.value === "codex") {
     if (codexAuthMode.value === "chatgpt") {
       return !!codexOAuthConfig.value || isEditing.value;
@@ -592,6 +646,16 @@ const canTestLinearConnection = computed((): boolean => {
   return isEditing.value && !!props.credential?.id;
 });
 
+const canTestJiraConnection = computed((): boolean => {
+  if (type.value !== "jira") {
+    return false;
+  }
+  if (jiraEmail.value.trim() && baseUrl.value.trim() && apiKey.value.trim()) {
+    return true;
+  }
+  return isEditing.value && !!props.credential?.id && !!jiraEmail.value.trim() && !!baseUrl.value.trim();
+});
+
 function resetCodexOAuthState(): void {
   codexOAuthConfig.value = null;
   codexOAuthState.value = "";
@@ -656,6 +720,18 @@ function buildConfig(): CredentialConfig {
       api_key: apiKey.value,
       ...(trimmedBaseUrl ? { base_url: trimmedBaseUrl } : {}),
     };
+  } else if (type.value === "jira") {
+    const config: Record<string, string> = {
+      email: jiraEmail.value.trim(),
+      api_token: apiKey.value.trim(),
+      base_url: baseUrl.value.trim(),
+      deployment: jiraDeployment.value,
+    };
+    const apiVersion = jiraDeployment.value === "data_center" ? "2" : jiraApiVersion.value.trim();
+    if (apiVersion) {
+      config.api_version = apiVersion;
+    }
+    return config;
   } else if (type.value === "sentry") {
     const trimmedBaseUrl = baseUrl.value.trim();
     return {
@@ -1021,6 +1097,47 @@ async function testLinearConnection(): Promise<void> {
   }
 }
 
+async function testJiraConnection(): Promise<void> {
+  if (!canTestJiraConnection.value) {
+    error.value =
+      jiraDeployment.value === "data_center"
+        ? "Enter Jira username, password, and base URL to test the connection."
+        : "Enter Jira email, API token, and base URL to test the connection.";
+    return;
+  }
+
+  jiraTesting.value = true;
+  jiraTestSuccess.value = null;
+  jiraTestMessage.value = "";
+  error.value = "";
+
+  try {
+    const result = await credentialsApi.testConnection({
+      type: "jira",
+      config: {
+        email: jiraEmail.value.trim(),
+        api_token: apiKey.value.trim(),
+        base_url: baseUrl.value.trim(),
+        deployment: jiraDeployment.value,
+        api_version: jiraDeployment.value === "data_center" ? "2" : jiraApiVersion.value.trim(),
+      },
+      credential_id: isEditing.value ? props.credential?.id : undefined,
+    });
+    jiraTestSuccess.value = result.success;
+    jiraTestMessage.value = result.message;
+    if (!result.success) {
+      error.value = result.message;
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Connection test failed";
+    jiraTestSuccess.value = false;
+    jiraTestMessage.value = message;
+    error.value = message;
+  } finally {
+    jiraTesting.value = false;
+  }
+}
+
 async function testNotionConnection(): Promise<void> {
   const connectedCredentialId =
     props.credential?.id || notionConnectedCredential.value?.id;
@@ -1587,6 +1704,100 @@ async function handleSave(): Promise<void> {
         </div>
       </template>
 
+      <template v-if="type === 'jira'">
+        <div class="space-y-2">
+          <Label for="cred-jira-email">{{ jiraUserLabel }}</Label>
+          <Input
+            id="cred-jira-email"
+            v-model="jiraEmail"
+            :placeholder="jiraUserPlaceholder"
+            :disabled="saving"
+          />
+        </div>
+        <div class="space-y-2">
+          <Label for="cred-jira-api-token">{{ jiraSecretLabel }}</Label>
+          <div class="relative">
+            <Input
+              id="cred-jira-api-token"
+              v-model="apiKey"
+              :type="showApiKey ? 'text' : 'password'"
+              :placeholder="jiraSecretPlaceholder"
+              :disabled="saving"
+              class="pr-10"
+            />
+            <button
+              type="button"
+              class="absolute right-2 top-1/2 -translate-y-1/2 text-muted-foreground hover:text-foreground"
+              @click="showApiKey = !showApiKey"
+            >
+              <EyeOff
+                v-if="showApiKey"
+                class="w-4 h-4"
+              />
+              <Eye
+                v-else
+                class="w-4 h-4"
+              />
+            </button>
+          </div>
+        </div>
+        <div class="space-y-2">
+          <Label for="cred-jira-base-url">Jira Base URL</Label>
+          <Input
+            id="cred-jira-base-url"
+            v-model="baseUrl"
+            placeholder="https://your-domain.atlassian.net"
+            :disabled="saving"
+          />
+        </div>
+        <div class="space-y-2">
+          <Label for="cred-jira-deployment">Deployment</Label>
+          <Select
+            id="cred-jira-deployment"
+            v-model="jiraDeployment"
+            :options="[
+              { value: 'cloud', label: 'Jira Cloud' },
+              { value: 'data_center', label: 'Jira Data Center / Server' },
+            ]"
+            :disabled="saving"
+          />
+        </div>
+        <div class="space-y-2">
+          <Label for="cred-jira-api-version">REST API Version</Label>
+          <Input
+            id="cred-jira-api-version"
+            :model-value="jiraDeployment === 'data_center' ? '2' : jiraApiVersion"
+            placeholder="3"
+            :disabled="saving || jiraDeployment === 'data_center'"
+            @update:model-value="jiraApiVersion = String($event)"
+          />
+          <p class="text-xs text-muted-foreground">
+            {{ jiraAuthHelpText }} Use the Jira site URL, not a REST path. Jira Cloud defaults to
+            v3; Data Center and Server use REST API v2.
+          </p>
+        </div>
+        <div class="flex items-center gap-3">
+          <Button
+            type="button"
+            variant="outline"
+            size="sm"
+            data-testid="jira-test-connection-button"
+            :loading="jiraTesting"
+            :disabled="saving || jiraTesting || !canTestJiraConnection"
+            @click="testJiraConnection"
+          >
+            Test Connection
+          </Button>
+          <p
+            v-if="jiraTestMessage"
+            class="text-xs"
+            :class="jiraTestSuccess ? 'text-emerald-600' : 'text-destructive'"
+          >
+            {{ jiraTestMessage }}
+          </p>
+        </div>
+      </template>
+
       <template v-if="type === 'linear'">
         <div class="space-y-2">
           <Label>Authentication</Label>
diff --git a/frontend/src/components/Credentials/CredentialsPanel.vue b/frontend/src/components/Credentials/CredentialsPanel.vue
index 50a9ae8f..dd6d2b4c 100644
--- a/frontend/src/components/Credentials/CredentialsPanel.vue
+++ b/frontend/src/components/Credentials/CredentialsPanel.vue
@@ -60,6 +60,7 @@ function getTypeIcon(type: CredentialType): typeof Brain {
     case "google":
       return Brain;
     case "github":
+    case "jira":
     case "linear":
     case "sentry":
       return Key;
@@ -94,6 +95,8 @@ function getTypeColor(type: CredentialType): string {
       return "bg-blue-500/10 text-blue-500";
     case "github":
       return "bg-slate-500/10 text-slate-500";
+    case "jira":
+      return "bg-blue-500/10 text-blue-500";
     case "linear":
       return "bg-violet-500/10 text-violet-500";
     case "sentry":
diff --git a/frontend/src/components/Nodes/BaseNode.vue b/frontend/src/components/Nodes/BaseNode.vue
index 3972fd8e..1860f1c9 100644
--- a/frontend/src/components/Nodes/BaseNode.vue
+++ b/frontend/src/components/Nodes/BaseNode.vue
@@ -58,6 +58,7 @@ const icons = {
   rag: Search,
   grist: Table2,
   github: Github,
+  jira: ListTodo,
   linear: ListTodo,
   googleSheets: Sheet,
   bigquery: Database,
@@ -114,6 +115,7 @@ const nodeColorMap = {
   rag: "node-rag",
   grist: "node-grist",
   github: "node-github",
+  jira: "node-jira",
   linear: "node-linear",
   googleSheets: "node-google-sheets",
   bigquery: "node-google-sheets",
diff --git a/frontend/src/components/Panels/NodePanel.vue b/frontend/src/components/Panels/NodePanel.vue
index 88844bf2..aaa62bba 100644
--- a/frontend/src/components/Panels/NodePanel.vue
+++ b/frontend/src/components/Panels/NodePanel.vue
@@ -246,6 +246,7 @@ const icons = {
   rag: Search,
   grist: Table2,
   github: Github,
+  jira: ListTodo,
   linear: ListTodo,
   googleSheets: Sheet,
   bigquery: Database,
diff --git a/frontend/src/components/Panels/propertiesPanel/nodes/JiraNodeProperties.vue b/frontend/src/components/Panels/propertiesPanel/nodes/JiraNodeProperties.vue
new file mode 100644
index 00000000..e3ed1e34
--- /dev/null
+++ b/frontend/src/components/Panels/propertiesPanel/nodes/JiraNodeProperties.vue
@@ -0,0 +1,780 @@
+<script setup lang="ts">
+import { AlertTriangle } from "lucide-vue-next";
+import AgentFieldToggle from "@/components/ui/AgentFieldToggle.vue";
+import ExpressionInput from "@/components/ui/ExpressionInput.vue";
+import Label from "@/components/ui/Label.vue";
+import SearchableSelect from "@/components/ui/SearchableSelect.vue";
+import Select from "@/components/ui/Select.vue";
+import { usePropertiesPanelContext } from "../usePropertiesPanelController";
+
+const {
+  workflowStore,
+  jiraLimitExpressionInputRef,
+  jiraStartAtExpressionInputRef,
+  jiraNextPageTokenExpressionInputRef,
+  jiraFieldsExpressionInputRef,
+  jiraProjectKeyExpressionInputRef,
+  jiraIssueKeyExpressionInputRef,
+  jiraIssueTypeExpressionInputRef,
+  jiraIssueTypeIdExpressionInputRef,
+  jiraSummaryExpressionInputRef,
+  jiraDescriptionExpressionInputRef,
+  jiraJqlExpressionInputRef,
+  jiraAssigneeAccountIdExpressionInputRef,
+  jiraLabelsExpressionInputRef,
+  jiraCommentBodyExpressionInputRef,
+  jiraCommentIdExpressionInputRef,
+  jiraTransitionIdExpressionInputRef,
+  jiraAttachmentIdExpressionInputRef,
+  jiraAttachmentFilenameExpressionInputRef,
+  jiraAttachmentBase64ExpressionInputRef,
+  jiraAttachmentMimeTypeExpressionInputRef,
+  jiraNotifySubjectExpressionInputRef,
+  jiraNotifyTextBodyExpressionInputRef,
+  jiraNotifyHtmlBodyExpressionInputRef,
+  jiraNotifyToExpressionInputRef,
+  jiraAccountIdExpressionInputRef,
+  jiraUsernameExpressionInputRef,
+  jiraUserEmailExpressionInputRef,
+  jiraUserDisplayNameExpressionInputRef,
+  jiraUserProductsExpressionInputRef,
+  selectedNode,
+  isJiraPaginatedOperation,
+  isJiraSearchOperation,
+  isJiraStartAtPaginatedOperation,
+  isJiraIssueKeyOperation,
+  isJiraCommentIdOperation,
+  isJiraAttachmentIdOperation,
+  isJiraAccountIdOperation,
+  jiraExpressionNavBindings,
+  handleJiraExpressionFieldNavigate,
+  onJiraRegisterExpressionFieldIndex,
+  jiraCredentialOptions,
+  jiraOperationGroups,
+  updateNodeData,
+} = usePropertiesPanelContext();
+</script>
+
+<template>
+  <template v-if="selectedNode">
+    <div
+      class="space-y-2"
+      data-testid="jira-credential-field"
+    >
+      <Label>Jira Credential</Label>
+      <Select
+        :model-value="selectedNode.data.credentialId || ''"
+        :options="jiraCredentialOptions"
+        @update:model-value="updateNodeData('credentialId', $event)"
+      />
+      <p
+        v-if="!selectedNode.data.credentialId"
+        class="text-xs text-amber-500 flex items-center gap-1"
+      >
+        <AlertTriangle class="h-3 w-3" />
+        Credential is required.
+      </p>
+    </div>
+
+    <div
+      class="space-y-2"
+      data-testid="jira-operation-field"
+    >
+      <Label>Operation</Label>
+      <SearchableSelect
+        :model-value="selectedNode.data.jiraOperation || 'searchIssues'"
+        :groups="jiraOperationGroups"
+        search-placeholder="Search Jira operations..."
+        @update:model-value="updateNodeData('jiraOperation', $event)"
+      />
+    </div>
+
+    <div
+      v-if="selectedNode.data.jiraOperation === 'createIssue'"
+      class="space-y-2"
+      data-testid="jira-project-key-field"
+    >
+      <Label>Project Key <span>*</span></Label>
+      <ExpressionInput
+        ref="jiraProjectKeyExpressionInputRef"
+        :model-value="selectedNode.data.jiraProjectKey || ''"
+        placeholder="ENG"
+        single-line
+        :nodes="workflowStore.nodes"
+        :node-results="workflowStore.nodeResults"
+        :edges="workflowStore.edges"
+        :current-node-id="selectedNode.id"
+        field-key="jiraProjectKey"
+        v-bind="jiraExpressionNavBindings('jiraProjectKey')"
+        @update:model-value="updateNodeData('jiraProjectKey', $event)"
+        @navigate="handleJiraExpressionFieldNavigate"
+        @register-field-index="onJiraRegisterExpressionFieldIndex"
+      />
+    </div>
+
+    <div
+      v-if="isJiraIssueKeyOperation()"
+      class="space-y-2"
+      data-testid="jira-issue-key-field"
+    >
+      <Label>Issue Key or ID <span>*</span></Label>
+      <ExpressionInput
+        ref="jiraIssueKeyExpressionInputRef"
+        :model-value="selectedNode.data.jiraIssueKey || ''"
+        placeholder="ENG-123"
+        single-line
+        :nodes="workflowStore.nodes"
+        :node-results="workflowStore.nodeResults"
+        :edges="workflowStore.edges"
+        :current-node-id="selectedNode.id"
+        field-key="jiraIssueKey"
+        v-bind="jiraExpressionNavBindings('jiraIssueKey')"
+        @update:model-value="updateNodeData('jiraIssueKey', $event)"
+        @navigate="handleJiraExpressionFieldNavigate"
+        @register-field-index="onJiraRegisterExpressionFieldIndex"
+      />
+    </div>
+
+    <div
+      v-if="selectedNode.data.jiraOperation === 'searchIssues'"
+      class="space-y-2"
+      data-testid="jira-jql-field"
+    >
+      <Label>JQL</Label>
+      <ExpressionInput
+        ref="jiraJqlExpressionInputRef"
+        :model-value="selectedNode.data.jiraJql || 'updated >= -30d ORDER BY updated DESC'"
+        placeholder="project = ENG AND updated >= -30d ORDER BY updated DESC"
+        :nodes="workflowStore.nodes"
+        :node-results="workflowStore.nodeResults"
+        :edges="workflowStore.edges"
+        :current-node-id="selectedNode.id"
+        field-key="jiraJql"
+        v-bind="jiraExpressionNavBindings('jiraJql')"
+        @update:model-value="updateNodeData('jiraJql', $event)"
+        @navigate="handleJiraExpressionFieldNavigate"
+        @register-field-index="onJiraRegisterExpressionFieldIndex"
+      />
+    </div>
+
+    <div
+      v-if="selectedNode.data.jiraOperation === 'searchIssues'"
+      class="space-y-2"
+      data-testid="jira-fields-field"
+    >
+      <Label>Issue Fields</Label>
+      <ExpressionInput
+        ref="jiraFieldsExpressionInputRef"
+        :model-value="selectedNode.data.jiraFields || ''"
+        placeholder="[&quot;key&quot;, &quot;summary&quot;, &quot;status&quot;] or comma-separated"
+        single-line
+        :nodes="workflowStore.nodes"
+        :node-results="workflowStore.nodeResults"
+        :edges="workflowStore.edges"
+        :current-node-id="selectedNode.id"
+        field-key="jiraFields"
+        v-bind="jiraExpressionNavBindings('jiraFields')"
+        @update:model-value="updateNodeData('jiraFields', $event)"
+        @navigate="handleJiraExpressionFieldNavigate"
+        @register-field-index="onJiraRegisterExpressionFieldIndex"
+      />
+      <p class="text-xs text-muted-foreground">
+        Optional. Defaults to key, summary, status, assignee, and issuetype.
+      </p>
+    </div>
+
+    <div
+      v-if="selectedNode.data.jiraOperation === 'createIssue'"
+      class="space-y-2"
+      data-testid="jira-issue-type-field"
+    >
+      <Label>Issue Type</Label>
+      <ExpressionInput
+        ref="jiraIssueTypeExpressionInputRef"
+        :model-value="selectedNode.data.jiraIssueType || 'Task'"
+        placeholder="Task"
+        single-line
+        :nodes="workflowStore.nodes"
+        :node-results="workflowStore.nodeResults"
+        :edges="workflowStore.edges"
+        :current-node-id="selectedNode.id"
+        field-key="jiraIssueType"
+        v-bind="jiraExpressionNavBindings('jiraIssueType')"
+        @update:model-value="updateNodeData('jiraIssueType', $event)"
+        @navigate="handleJiraExpressionFieldNavigate"
+        @register-field-index="onJiraRegisterExpressionFieldIndex"
+      />
+    </div>
+
+    <div
+      v-if="selectedNode.data.jiraOperation === 'createIssue'"
+      class="space-y-2"
+      data-testid="jira-issue-type-id-field"
+    >
+      <Label>Issue Type ID</Label>
+      <ExpressionInput
+        ref="jiraIssueTypeIdExpressionInputRef"
+        :model-value="selectedNode.data.jiraIssueTypeId || ''"
+        placeholder="10001"
+        single-line
+        :nodes="workflowStore.nodes"
+        :node-results="workflowStore.nodeResults"
+        :edges="workflowStore.edges"
+        :current-node-id="selectedNode.id"
+        field-key="jiraIssueTypeId"
+        v-bind="jiraExpressionNavBindings('jiraIssueTypeId')"
+        @update:model-value="updateNodeData('jiraIssueTypeId', $event)"
+        @navigate="handleJiraExpressionFieldNavigate"
+        @register-field-index="onJiraRegisterExpressionFieldIndex"
+      />
+      <p class="text-xs text-muted-foreground">
+        Optional. When set, overrides Issue Type name (useful for localized Jira sites).
+      </p>
+    </div>
+
+    <div
+      v-if="selectedNode.data.jiraOperation === 'createIssue' || selectedNode.data.jiraOperation === 'updateIssue'"
+      class="space-y-2"
+      data-testid="jira-summary-field"
+    >
+      <Label>Summary <span v-if="selectedNode.data.jiraOperation === 'createIssue'">*</span></Label>
+      <ExpressionInput
+        ref="jiraSummaryExpressionInputRef"
+        :model-value="selectedNode.data.jiraSummary || ''"
+        placeholder="Issue summary"
+        single-line
+        :nodes="workflowStore.nodes"
+        :node-results="workflowStore.nodeResults"
+        :edges="workflowStore.edges"
+        :current-node-id="selectedNode.id"
+        field-key="jiraSummary"
+        v-bind="jiraExpressionNavBindings('jiraSummary')"
+        @update:model-value="updateNodeData('jiraSummary', $event)"
+        @navigate="handleJiraExpressionFieldNavigate"
+        @register-field-index="onJiraRegisterExpressionFieldIndex"
+      />
+    </div>
+
+    <div
+      v-if="selectedNode.data.jiraOperation === 'createIssue' || selectedNode.data.jiraOperation === 'updateIssue'"
+      class="space-y-2"
+      data-testid="jira-description-field"
+    >
+      <Label>Description</Label>
+      <ExpressionInput
+        ref="jiraDescriptionExpressionInputRef"
+        :model-value="selectedNode.data.jiraDescription || ''"
+        placeholder="$input.text"
+        :nodes="workflowStore.nodes"
+        :node-results="workflowStore.nodeResults"
+        :edges="workflowStore.edges"
+        :current-node-id="selectedNode.id"
+        field-key="jiraDescription"
+        v-bind="jiraExpressionNavBindings('jiraDescription')"
+        @update:model-value="updateNodeData('jiraDescription', $event)"
+        @navigate="handleJiraExpressionFieldNavigate"
+        @register-field-index="onJiraRegisterExpressionFieldIndex"
+      />
+    </div>
+
+    <div
+      v-if="selectedNode.data.jiraOperation === 'createIssue' || selectedNode.data.jiraOperation === 'updateIssue'"
+      class="space-y-2"
+      data-testid="jira-assignee-field"
+    >
+      <Label>Assignee Account ID / Username</Label>
+      <ExpressionInput
+        ref="jiraAssigneeAccountIdExpressionInputRef"
+        :model-value="selectedNode.data.jiraAssigneeAccountId || ''"
+        placeholder="Jira accountId, username, or null"
+        single-line
+        :nodes="workflowStore.nodes"
+        :node-results="workflowStore.nodeResults"
+        :edges="workflowStore.edges"
+        :current-node-id="selectedNode.id"
+        field-key="jiraAssigneeAccountId"
+        v-bind="jiraExpressionNavBindings('jiraAssigneeAccountId')"
+        @update:model-value="updateNodeData('jiraAssigneeAccountId', $event)"
+        @navigate="handleJiraExpressionFieldNavigate"
+        @register-field-index="onJiraRegisterExpressionFieldIndex"
+      />
+    </div>
+
+    <div
+      v-if="selectedNode.data.jiraOperation === 'createIssue' || selectedNode.data.jiraOperation === 'updateIssue'"
+      class="space-y-2"
+      data-testid="jira-labels-field"
+    >
+      <Label>Labels</Label>
+      <ExpressionInput
+        ref="jiraLabelsExpressionInputRef"
+        :model-value="selectedNode.data.jiraLabels || ''"
+        placeholder="[&quot;automation&quot;, &quot;support&quot;] or comma-separated"
+        single-line
+        :nodes="workflowStore.nodes"
+        :node-results="workflowStore.nodeResults"
+        :edges="workflowStore.edges"
+        :current-node-id="selectedNode.id"
+        field-key="jiraLabels"
+        v-bind="jiraExpressionNavBindings('jiraLabels')"
+        @update:model-value="updateNodeData('jiraLabels', $event)"
+        @navigate="handleJiraExpressionFieldNavigate"
+        @register-field-index="onJiraRegisterExpressionFieldIndex"
+      />
+    </div>
+
+    <div
+      v-if="isJiraCommentIdOperation()"
+      class="space-y-2"
+      data-testid="jira-comment-id-field"
+    >
+      <Label>Comment ID <span>*</span></Label>
+      <ExpressionInput
+        ref="jiraCommentIdExpressionInputRef"
+        :model-value="selectedNode.data.jiraCommentId || ''"
+        placeholder="10001"
+        single-line
+        :nodes="workflowStore.nodes"
+        :node-results="workflowStore.nodeResults"
+        :edges="workflowStore.edges"
+        :current-node-id="selectedNode.id"
+        field-key="jiraCommentId"
+        v-bind="jiraExpressionNavBindings('jiraCommentId')"
+        @update:model-value="updateNodeData('jiraCommentId', $event)"
+        @navigate="handleJiraExpressionFieldNavigate"
+        @register-field-index="onJiraRegisterExpressionFieldIndex"
+      />
+    </div>
+
+    <div
+      v-if="selectedNode.data.jiraOperation === 'createComment' || selectedNode.data.jiraOperation === 'updateComment'"
+      class="space-y-2"
+      data-testid="jira-comment-body-field"
+    >
+      <Label>Comment Body <span>*</span></Label>
+      <ExpressionInput
+        ref="jiraCommentBodyExpressionInputRef"
+        :model-value="selectedNode.data.jiraCommentBody || ''"
+        placeholder="$input.text"
+        :nodes="workflowStore.nodes"
+        :node-results="workflowStore.nodeResults"
+        :edges="workflowStore.edges"
+        :current-node-id="selectedNode.id"
+        field-key="jiraCommentBody"
+        v-bind="jiraExpressionNavBindings('jiraCommentBody')"
+        @update:model-value="updateNodeData('jiraCommentBody', $event)"
+        @navigate="handleJiraExpressionFieldNavigate"
+        @register-field-index="onJiraRegisterExpressionFieldIndex"
+      />
+    </div>
+
+    <template v-if="selectedNode.data.jiraOperation === 'notifyIssue'">
+      <div
+        class="space-y-2"
+        data-testid="jira-notify-subject-field"
+      >
+        <Label>Subject <span>*</span></Label>
+        <ExpressionInput
+          ref="jiraNotifySubjectExpressionInputRef"
+          :model-value="selectedNode.data.jiraNotifySubject || ''"
+          placeholder="Issue update"
+          single-line
+          :nodes="workflowStore.nodes"
+          :node-results="workflowStore.nodeResults"
+          :edges="workflowStore.edges"
+          :current-node-id="selectedNode.id"
+          field-key="jiraNotifySubject"
+          v-bind="jiraExpressionNavBindings('jiraNotifySubject')"
+          @update:model-value="updateNodeData('jiraNotifySubject', $event)"
+          @navigate="handleJiraExpressionFieldNavigate"
+          @register-field-index="onJiraRegisterExpressionFieldIndex"
+        />
+      </div>
+
+      <div
+        class="space-y-2"
+        data-testid="jira-notify-text-body-field"
+      >
+        <Label>Text Body <span>*</span></Label>
+        <ExpressionInput
+          ref="jiraNotifyTextBodyExpressionInputRef"
+          :model-value="selectedNode.data.jiraNotifyTextBody || ''"
+          placeholder="$input.text"
+          :nodes="workflowStore.nodes"
+          :node-results="workflowStore.nodeResults"
+          :edges="workflowStore.edges"
+          :current-node-id="selectedNode.id"
+          field-key="jiraNotifyTextBody"
+          v-bind="jiraExpressionNavBindings('jiraNotifyTextBody')"
+          @update:model-value="updateNodeData('jiraNotifyTextBody', $event)"
+          @navigate="handleJiraExpressionFieldNavigate"
+          @register-field-index="onJiraRegisterExpressionFieldIndex"
+        />
+      </div>
+
+      <div
+        class="space-y-2"
+        data-testid="jira-notify-html-body-field"
+      >
+        <Label>HTML Body</Label>
+        <ExpressionInput
+          ref="jiraNotifyHtmlBodyExpressionInputRef"
+          :model-value="selectedNode.data.jiraNotifyHtmlBody || ''"
+          placeholder="<p>$input.text</p>"
+          :nodes="workflowStore.nodes"
+          :node-results="workflowStore.nodeResults"
+          :edges="workflowStore.edges"
+          :current-node-id="selectedNode.id"
+          field-key="jiraNotifyHtmlBody"
+          v-bind="jiraExpressionNavBindings('jiraNotifyHtmlBody')"
+          @update:model-value="updateNodeData('jiraNotifyHtmlBody', $event)"
+          @navigate="handleJiraExpressionFieldNavigate"
+          @register-field-index="onJiraRegisterExpressionFieldIndex"
+        />
+      </div>
+
+      <div
+        class="space-y-2"
+        data-testid="jira-notify-to-field"
+      >
+        <Label>Recipients JSON</Label>
+        <ExpressionInput
+          ref="jiraNotifyToExpressionInputRef"
+          :model-value="selectedNode.data.jiraNotifyTo || '{&quot;assignee&quot;:true}'"
+          placeholder="{&quot;assignee&quot;:true,&quot;watchers&quot;:true}"
+          :nodes="workflowStore.nodes"
+          :node-results="workflowStore.nodeResults"
+          :edges="workflowStore.edges"
+          :current-node-id="selectedNode.id"
+          field-key="jiraNotifyTo"
+          v-bind="jiraExpressionNavBindings('jiraNotifyTo')"
+          @update:model-value="updateNodeData('jiraNotifyTo', $event)"
+          @navigate="handleJiraExpressionFieldNavigate"
+          @register-field-index="onJiraRegisterExpressionFieldIndex"
+        />
+      </div>
+    </template>
+
+    <div
+      v-if="selectedNode.data.jiraOperation === 'transitionIssue'"
+      class="space-y-2"
+      data-testid="jira-transition-id-field"
+    >
+      <Label>Transition ID <span>*</span></Label>
+      <ExpressionInput
+        ref="jiraTransitionIdExpressionInputRef"
+        :model-value="selectedNode.data.jiraTransitionId || ''"
+        placeholder="31"
+        single-line
+        :nodes="workflowStore.nodes"
+        :node-results="workflowStore.nodeResults"
+        :edges="workflowStore.edges"
+        :current-node-id="selectedNode.id"
+        field-key="jiraTransitionId"
+        v-bind="jiraExpressionNavBindings('jiraTransitionId')"
+        @update:model-value="updateNodeData('jiraTransitionId', $event)"
+        @navigate="handleJiraExpressionFieldNavigate"
+        @register-field-index="onJiraRegisterExpressionFieldIndex"
+      />
+    </div>
+
+    <div
+      v-if="isJiraAttachmentIdOperation()"
+      class="space-y-2"
+      data-testid="jira-attachment-id-field"
+    >
+      <Label>Attachment ID <span>*</span></Label>
+      <ExpressionInput
+        ref="jiraAttachmentIdExpressionInputRef"
+        :model-value="selectedNode.data.jiraAttachmentId || ''"
+        placeholder="10001"
+        single-line
+        :nodes="workflowStore.nodes"
+        :node-results="workflowStore.nodeResults"
+        :edges="workflowStore.edges"
+        :current-node-id="selectedNode.id"
+        field-key="jiraAttachmentId"
+        v-bind="jiraExpressionNavBindings('jiraAttachmentId')"
+        @update:model-value="updateNodeData('jiraAttachmentId', $event)"
+        @navigate="handleJiraExpressionFieldNavigate"
+        @register-field-index="onJiraRegisterExpressionFieldIndex"
+      />
+    </div>
+
+    <template v-if="selectedNode.data.jiraOperation === 'addAttachment'">
+      <div
+        class="space-y-2"
+        data-testid="jira-attachment-filename-field"
+      >
+        <Label>Filename <span>*</span></Label>
+        <ExpressionInput
+          ref="jiraAttachmentFilenameExpressionInputRef"
+          :model-value="selectedNode.data.jiraAttachmentFilename || ''"
+          placeholder="report.txt"
+          single-line
+          :nodes="workflowStore.nodes"
+          :node-results="workflowStore.nodeResults"
+          :edges="workflowStore.edges"
+          :current-node-id="selectedNode.id"
+          field-key="jiraAttachmentFilename"
+          v-bind="jiraExpressionNavBindings('jiraAttachmentFilename')"
+          @update:model-value="updateNodeData('jiraAttachmentFilename', $event)"
+          @navigate="handleJiraExpressionFieldNavigate"
+          @register-field-index="onJiraRegisterExpressionFieldIndex"
+        />
+      </div>
+
+      <div
+        class="space-y-2"
+        data-testid="jira-attachment-base64-field"
+      >
+        <Label>Base64 Content <span>*</span></Label>
+        <ExpressionInput
+          ref="jiraAttachmentBase64ExpressionInputRef"
+          :model-value="selectedNode.data.jiraAttachmentBase64 || ''"
+          placeholder="$input.file_base64"
+          :nodes="workflowStore.nodes"
+          :node-results="workflowStore.nodeResults"
+          :edges="workflowStore.edges"
+          :current-node-id="selectedNode.id"
+          field-key="jiraAttachmentBase64"
+          v-bind="jiraExpressionNavBindings('jiraAttachmentBase64')"
+          @update:model-value="updateNodeData('jiraAttachmentBase64', $event)"
+          @navigate="handleJiraExpressionFieldNavigate"
+          @register-field-index="onJiraRegisterExpressionFieldIndex"
+        />
+      </div>
+
+      <div
+        class="space-y-2"
+        data-testid="jira-attachment-mime-type-field"
+      >
+        <Label>MIME Type</Label>
+        <ExpressionInput
+          ref="jiraAttachmentMimeTypeExpressionInputRef"
+          :model-value="selectedNode.data.jiraAttachmentMimeType || ''"
+          placeholder="text/plain"
+          single-line
+          :nodes="workflowStore.nodes"
+          :node-results="workflowStore.nodeResults"
+          :edges="workflowStore.edges"
+          :current-node-id="selectedNode.id"
+          field-key="jiraAttachmentMimeType"
+          v-bind="jiraExpressionNavBindings('jiraAttachmentMimeType')"
+          @update:model-value="updateNodeData('jiraAttachmentMimeType', $event)"
+          @navigate="handleJiraExpressionFieldNavigate"
+          @register-field-index="onJiraRegisterExpressionFieldIndex"
+        />
+      </div>
+    </template>
+
+    <label
+      v-if="selectedNode.data.jiraOperation === 'getAttachment' || selectedNode.data.jiraOperation === 'listAttachments'"
+      class="flex items-center gap-2 text-sm"
+    >
+      <input
+        type="checkbox"
+        :checked="!!selectedNode.data.jiraIncludeBinary"
+        @change="updateNodeData('jiraIncludeBinary', ($event.target as HTMLInputElement).checked)"
+      >
+      <span>Include binary content as base64</span>
+      <AgentFieldToggle
+        :node-id="selectedNode.id"
+        field-key="jiraIncludeBinary"
+      />
+    </label>
+
+    <div
+      v-if="isJiraAccountIdOperation()"
+      class="space-y-2"
+      data-testid="jira-account-id-field"
+    >
+      <p
+        v-if="selectedNode.data.jiraOperation === 'deleteUser'"
+        class="text-xs text-amber-500 flex items-center gap-1"
+      >
+        <AlertTriangle class="h-3 w-3" />
+        Delete User typically requires Jira admin permissions.
+      </p>
+      <Label>Account ID / Username <span>*</span></Label>
+      <ExpressionInput
+        ref="jiraAccountIdExpressionInputRef"
+        :model-value="selectedNode.data.jiraAccountId || ''"
+        placeholder="712020:... or username"
+        single-line
+        :nodes="workflowStore.nodes"
+        :node-results="workflowStore.nodeResults"
+        :edges="workflowStore.edges"
+        :current-node-id="selectedNode.id"
+        field-key="jiraAccountId"
+        v-bind="jiraExpressionNavBindings('jiraAccountId')"
+        @update:model-value="updateNodeData('jiraAccountId', $event)"
+        @navigate="handleJiraExpressionFieldNavigate"
+        @register-field-index="onJiraRegisterExpressionFieldIndex"
+      />
+    </div>
+
+    <template v-if="selectedNode.data.jiraOperation === 'createUser'">
+      <p class="text-xs text-amber-500 flex items-center gap-1">
+        <AlertTriangle class="h-3 w-3" />
+        Create User typically requires Jira admin permissions.
+      </p>
+      <div
+        class="space-y-2"
+        data-testid="jira-user-email-field"
+      >
+        <Label>User Email <span>*</span></Label>
+        <ExpressionInput
+          ref="jiraUserEmailExpressionInputRef"
+          :model-value="selectedNode.data.jiraUserEmail || ''"
+          placeholder="user@example.com"
+          single-line
+          :nodes="workflowStore.nodes"
+          :node-results="workflowStore.nodeResults"
+          :edges="workflowStore.edges"
+          :current-node-id="selectedNode.id"
+          field-key="jiraUserEmail"
+          v-bind="jiraExpressionNavBindings('jiraUserEmail')"
+          @update:model-value="updateNodeData('jiraUserEmail', $event)"
+          @navigate="handleJiraExpressionFieldNavigate"
+          @register-field-index="onJiraRegisterExpressionFieldIndex"
+        />
+      </div>
+
+      <div
+        class="space-y-2"
+        data-testid="jira-username-field"
+      >
+        <Label>Username</Label>
+        <ExpressionInput
+          ref="jiraUsernameExpressionInputRef"
+          :model-value="selectedNode.data.jiraUsername || ''"
+          placeholder="ada"
+          single-line
+          :nodes="workflowStore.nodes"
+          :node-results="workflowStore.nodeResults"
+          :edges="workflowStore.edges"
+          :current-node-id="selectedNode.id"
+          field-key="jiraUsername"
+          v-bind="jiraExpressionNavBindings('jiraUsername')"
+          @update:model-value="updateNodeData('jiraUsername', $event)"
+          @navigate="handleJiraExpressionFieldNavigate"
+          @register-field-index="onJiraRegisterExpressionFieldIndex"
+        />
+        <p class="text-xs text-muted-foreground">
+          Optional. Used as the Data Center / Server username; falls back to User Email.
+        </p>
+      </div>
+
+      <div
+        class="space-y-2"
+        data-testid="jira-user-display-name-field"
+      >
+        <Label>Display Name</Label>
+        <ExpressionInput
+          ref="jiraUserDisplayNameExpressionInputRef"
+          :model-value="selectedNode.data.jiraUserDisplayName || ''"
+          placeholder="Ada Lovelace"
+          single-line
+          :nodes="workflowStore.nodes"
+          :node-results="workflowStore.nodeResults"
+          :edges="workflowStore.edges"
+          :current-node-id="selectedNode.id"
+          field-key="jiraUserDisplayName"
+          v-bind="jiraExpressionNavBindings('jiraUserDisplayName')"
+          @update:model-value="updateNodeData('jiraUserDisplayName', $event)"
+          @navigate="handleJiraExpressionFieldNavigate"
+          @register-field-index="onJiraRegisterExpressionFieldIndex"
+        />
+      </div>
+
+      <div
+        class="space-y-2"
+        data-testid="jira-user-products-field"
+      >
+        <Label>Products</Label>
+        <ExpressionInput
+          ref="jiraUserProductsExpressionInputRef"
+          :model-value="selectedNode.data.jiraUserProducts || ''"
+          placeholder="[&quot;jira-software&quot;] or comma-separated"
+          single-line
+          :nodes="workflowStore.nodes"
+          :node-results="workflowStore.nodeResults"
+          :edges="workflowStore.edges"
+          :current-node-id="selectedNode.id"
+          field-key="jiraUserProducts"
+          v-bind="jiraExpressionNavBindings('jiraUserProducts')"
+          @update:model-value="updateNodeData('jiraUserProducts', $event)"
+          @navigate="handleJiraExpressionFieldNavigate"
+          @register-field-index="onJiraRegisterExpressionFieldIndex"
+        />
+      </div>
+    </template>
+
+    <div
+      v-if="isJiraPaginatedOperation()"
+      class="grid grid-cols-2 gap-3"
+    >
+      <div class="space-y-2">
+        <Label>Limit</Label>
+        <ExpressionInput
+          ref="jiraLimitExpressionInputRef"
+          :model-value="selectedNode.data.jiraLimit || '50'"
+          placeholder="50"
+          single-line
+          :nodes="workflowStore.nodes"
+          :node-results="workflowStore.nodeResults"
+          :edges="workflowStore.edges"
+          :current-node-id="selectedNode.id"
+          field-key="jiraLimit"
+          v-bind="jiraExpressionNavBindings('jiraLimit')"
+          @update:model-value="updateNodeData('jiraLimit', $event)"
+          @navigate="handleJiraExpressionFieldNavigate"
+          @register-field-index="onJiraRegisterExpressionFieldIndex"
+        />
+      </div>
+      <div
+        v-if="isJiraSearchOperation()"
+        class="space-y-2"
+      >
+        <Label>Next Page Token</Label>
+        <ExpressionInput
+          ref="jiraNextPageTokenExpressionInputRef"
+          :model-value="selectedNode.data.jiraNextPageToken || ''"
+          placeholder="Leave empty for first page"
+          single-line
+          :nodes="workflowStore.nodes"
+          :node-results="workflowStore.nodeResults"
+          :edges="workflowStore.edges"
+          :current-node-id="selectedNode.id"
+          field-key="jiraNextPageToken"
+          v-bind="jiraExpressionNavBindings('jiraNextPageToken')"
+          @update:model-value="updateNodeData('jiraNextPageToken', $event)"
+          @navigate="handleJiraExpressionFieldNavigate"
+          @register-field-index="onJiraRegisterExpressionFieldIndex"
+        />
+      </div>
+      <div
+        v-if="isJiraStartAtPaginatedOperation()"
+        class="space-y-2"
+      >
+        <Label>Start At</Label>
+        <ExpressionInput
+          ref="jiraStartAtExpressionInputRef"
+          :model-value="selectedNode.data.jiraStartAt || '0'"
+          placeholder="0"
+          single-line
+          :nodes="workflowStore.nodes"
+          :node-results="workflowStore.nodeResults"
+          :edges="workflowStore.edges"
+          :current-node-id="selectedNode.id"
+          field-key="jiraStartAt"
+          v-bind="jiraExpressionNavBindings('jiraStartAt')"
+          @update:model-value="updateNodeData('jiraStartAt', $event)"
+          @navigate="handleJiraExpressionFieldNavigate"
+          @register-field-index="onJiraRegisterExpressionFieldIndex"
+        />
+      </div>
+    </div>
+  </template>
+</template>
diff --git a/frontend/src/components/Panels/propertiesPanel/nodes/NodePropertiesForm.vue b/frontend/src/components/Panels/propertiesPanel/nodes/NodePropertiesForm.vue
index aa3cb4d0..69a92973 100644
--- a/frontend/src/components/Panels/propertiesPanel/nodes/NodePropertiesForm.vue
+++ b/frontend/src/components/Panels/propertiesPanel/nodes/NodePropertiesForm.vue
@@ -32,6 +32,7 @@ import DisableNodeNodeProperties from "./DisableNodeNodeProperties.vue";
 import RedisNodeProperties from "./RedisNodeProperties.vue";
 import RagNodeProperties from "./RagNodeProperties.vue";
 import GristNodeProperties from "./GristNodeProperties.vue";
+import JiraNodeProperties from "./JiraNodeProperties.vue";
 import LinearNodeProperties from "./LinearNodeProperties.vue";
 import GithubNodeProperties from "./GithubNodeProperties.vue";
 import GoogleSheetsNodeProperties from "./GoogleSheetsNodeProperties.vue";
@@ -89,6 +90,7 @@ const { selectedNode } = usePropertiesPanelContext();
   <RedisNodeProperties v-else-if="selectedNode?.type === 'redis'" />
   <RagNodeProperties v-else-if="selectedNode?.type === 'rag'" />
   <GristNodeProperties v-else-if="selectedNode?.type === 'grist'" />
+  <JiraNodeProperties v-else-if="selectedNode?.type === 'jira'" />
   <LinearNodeProperties v-else-if="selectedNode?.type === 'linear'" />
   <GithubNodeProperties v-else-if="selectedNode?.type === 'github'" />
   <GoogleSheetsNodeProperties v-else-if="selectedNode?.type === 'googleSheets'" />
diff --git a/frontend/src/components/Panels/propertiesPanel/operationOptions.ts b/frontend/src/components/Panels/propertiesPanel/operationOptions.ts
index b153cb54..cb737644 100644
--- a/frontend/src/components/Panels/propertiesPanel/operationOptions.ts
+++ b/frontend/src/components/Panels/propertiesPanel/operationOptions.ts
@@ -64,6 +64,97 @@ export const linearOperationGroups: OperationOptionGroup[] = [
 export const linearOperationOptions: OperationOption[] =
   flattenOperationGroups(linearOperationGroups);
 
+export const jiraOperationGroups: OperationOptionGroup[] = [
+  {
+    label: "Account and Projects",
+    options: [
+      { value: "getMyself", label: "Get Myself" },
+      { value: "listProjects", label: "List Projects" },
+    ],
+  },
+  {
+    label: "Attachments",
+    options: [
+      { value: "addAttachment", label: "Add Attachment" },
+      { value: "deleteAttachment", label: "Delete Attachment" },
+      { value: "getAttachment", label: "Get Attachment" },
+      { value: "listAttachments", label: "List Attachments" },
+    ],
+  },
+  {
+    label: "Comments",
+    options: [
+      { value: "createComment", label: "Create Comment" },
+      { value: "deleteComment", label: "Delete Comment" },
+      { value: "getComment", label: "Get Comment" },
+      { value: "listComments", label: "List Comments" },
+      { value: "updateComment", label: "Update Comment" },
+    ],
+  },
+  {
+    label: "Issues",
+    options: [
+      { value: "createIssue", label: "Create Issue" },
+      { value: "deleteIssue", label: "Delete Issue" },
+      { value: "getIssue", label: "Get Issue" },
+      { value: "getIssueChangelog", label: "Get Issue Changelog" },
+      { value: "listTransitions", label: "List Transitions" },
+      { value: "notifyIssue", label: "Notify Issue" },
+      { value: "searchIssues", label: "Search Issues" },
+      { value: "transitionIssue", label: "Transition Issue" },
+      { value: "updateIssue", label: "Update Issue" },
+    ],
+  },
+  {
+    label: "Users",
+    options: [
+      { value: "createUser", label: "Create User" },
+      { value: "deleteUser", label: "Delete User" },
+      { value: "getUser", label: "Get User" },
+    ],
+  },
+];
+
+export const jiraOperationOptions: OperationOption[] =
+  flattenOperationGroups(jiraOperationGroups);
+
+export const jiraPaginatedOperations = new Set([
+  "listProjects",
+  "searchIssues",
+  "getIssueChangelog",
+  "listComments",
+  "listAttachments",
+]);
+
+export const jiraStartAtPaginatedOperations = new Set([
+  "listProjects",
+  "searchIssues",
+  "getIssueChangelog",
+  "listComments",
+  "listAttachments",
+]);
+
+export const jiraIssueKeyOperations = new Set([
+  "getIssue",
+  "updateIssue",
+  "deleteIssue",
+  "getIssueChangelog",
+  "notifyIssue",
+  "listComments",
+  "createComment",
+  "getComment",
+  "updateComment",
+  "deleteComment",
+  "listTransitions",
+  "transitionIssue",
+  "addAttachment",
+  "listAttachments",
+]);
+
+export const jiraCommentIdOperations = new Set(["getComment", "updateComment", "deleteComment"]);
+export const jiraAttachmentIdOperations = new Set(["getAttachment", "deleteAttachment"]);
+export const jiraAccountIdOperations = new Set(["getUser", "deleteUser"]);
+
 export const githubOperationGroups: OperationOptionGroup[] = [
   {
     label: "Repository",
diff --git a/frontend/src/components/Panels/propertiesPanel/usePropertiesPanelController.ts b/frontend/src/components/Panels/propertiesPanel/usePropertiesPanelController.ts
index c252f03d..ccb92310 100644
--- a/frontend/src/components/Panels/propertiesPanel/usePropertiesPanelController.ts
+++ b/frontend/src/components/Panels/propertiesPanel/usePropertiesPanelController.ts
@@ -24,6 +24,7 @@ import { sortSkillFiles } from "@/lib/skillFilePreview";
 import { isRetryAttemptNodeResult } from "@/lib/executionLog";
 import { findEnclosingLoopIdForListSize, findNodeResultIndexForLoopIteration, mapNodeResultsToEnclosingLoopIterations, selectedLoopIterationIndexForNode } from "@/lib/loopNodeDisplay";
 import { getGitHubExpressionFields, type GitHubExpressionFieldKey } from "@/lib/githubExpressionFields";
+import { getJiraExpressionFields, type JiraExpressionFieldKey } from "@/lib/jiraExpressionFields";
 import { getLinearExpressionFields, type LinearExpressionFieldKey } from "@/lib/linearExpressionFields";
 import { getNotionExpressionFields, type NotionExpressionFieldKey } from "@/lib/notionExpressionFields";
 import { getSentryExpressionFields, type SentryExpressionFieldKey } from "@/lib/sentryExpressionFields";
@@ -51,6 +52,14 @@ import {
   githubOperationOptions,
   googleSheetsOperationOptions,
   gristOperationOptions,
+  jiraOperationGroups,
+  jiraAccountIdOperations,
+  jiraAttachmentIdOperations,
+  jiraCommentIdOperations,
+  jiraIssueKeyOperations,
+  jiraOperationOptions,
+  jiraPaginatedOperations,
+  jiraStartAtPaginatedOperations,
   linearOperationGroups,
   linearOperationOptions,
   notionOperationGroups,
@@ -117,6 +126,7 @@ export function usePropertiesPanelController() {
     rag: Search,
     grist: Table2,
     github: Github,
+    jira: ListTodo,
     linear: ListTodo,
     googleSheets: Sheet,
     bigquery: Database,
@@ -173,6 +183,7 @@ export function usePropertiesPanelController() {
     rag: "node-rag",
     grist: "node-grist",
     github: "node-github",
+    jira: "node-jira",
     linear: "node-linear",
     googleSheets: "node-google-sheets",
     bigquery: "node-google-sheets",
@@ -229,6 +240,7 @@ export function usePropertiesPanelController() {
     rag: "rag-node",
     grist: "grist-node",
     github: "github-node",
+    jira: "jira-node",
     linear: "linear-node",
     googleSheets: "google-sheets-node",
     bigquery: "bigquery-node",
@@ -549,6 +561,7 @@ export function usePropertiesPanelController() {
   const gristCredentials = ref<CredentialListItem[]>([]);
   const codexCredentials = ref<CredentialListItem[]>([]);
   const githubCredentials = ref<CredentialListItem[]>([]);
+  const jiraCredentials = ref<CredentialListItem[]>([]);
   const linearCredentials = ref<CredentialListItem[]>([]);
   const googleSheetsCredentials = ref<CredentialListItem[]>([]);
   const bigqueryCredentials = ref<CredentialListItem[]>([]);
@@ -691,6 +704,36 @@ export function usePropertiesPanelController() {
   const sentryReleaseRefsExpressionInputRef = ref<ExpandableFieldRef | null>(null);
   const sentryPayloadExpressionInputRef = ref<ExpandableFieldRef | null>(null);
   const currentSentryExpressionFieldIndex = ref(0);
+  const jiraLimitExpressionInputRef = ref<ExpandableFieldRef | null>(null);
+  const jiraStartAtExpressionInputRef = ref<ExpandableFieldRef | null>(null);
+  const jiraNextPageTokenExpressionInputRef = ref<ExpandableFieldRef | null>(null);
+  const jiraFieldsExpressionInputRef = ref<ExpandableFieldRef | null>(null);
+  const jiraProjectKeyExpressionInputRef = ref<ExpandableFieldRef | null>(null);
+  const jiraIssueKeyExpressionInputRef = ref<ExpandableFieldRef | null>(null);
+  const jiraIssueTypeExpressionInputRef = ref<ExpandableFieldRef | null>(null);
+  const jiraIssueTypeIdExpressionInputRef = ref<ExpandableFieldRef | null>(null);
+  const jiraSummaryExpressionInputRef = ref<ExpandableFieldRef | null>(null);
+  const jiraDescriptionExpressionInputRef = ref<ExpandableFieldRef | null>(null);
+  const jiraJqlExpressionInputRef = ref<ExpandableFieldRef | null>(null);
+  const jiraAssigneeAccountIdExpressionInputRef = ref<ExpandableFieldRef | null>(null);
+  const jiraLabelsExpressionInputRef = ref<ExpandableFieldRef | null>(null);
+  const jiraCommentBodyExpressionInputRef = ref<ExpandableFieldRef | null>(null);
+  const jiraCommentIdExpressionInputRef = ref<ExpandableFieldRef | null>(null);
+  const jiraTransitionIdExpressionInputRef = ref<ExpandableFieldRef | null>(null);
+  const jiraAttachmentIdExpressionInputRef = ref<ExpandableFieldRef | null>(null);
+  const jiraAttachmentFilenameExpressionInputRef = ref<ExpandableFieldRef | null>(null);
+  const jiraAttachmentBase64ExpressionInputRef = ref<ExpandableFieldRef | null>(null);
+  const jiraAttachmentMimeTypeExpressionInputRef = ref<ExpandableFieldRef | null>(null);
+  const jiraNotifySubjectExpressionInputRef = ref<ExpandableFieldRef | null>(null);
+  const jiraNotifyTextBodyExpressionInputRef = ref<ExpandableFieldRef | null>(null);
+  const jiraNotifyHtmlBodyExpressionInputRef = ref<ExpandableFieldRef | null>(null);
+  const jiraNotifyToExpressionInputRef = ref<ExpandableFieldRef | null>(null);
+  const jiraAccountIdExpressionInputRef = ref<ExpandableFieldRef | null>(null);
+  const jiraUsernameExpressionInputRef = ref<ExpandableFieldRef | null>(null);
+  const jiraUserEmailExpressionInputRef = ref<ExpandableFieldRef | null>(null);
+  const jiraUserDisplayNameExpressionInputRef = ref<ExpandableFieldRef | null>(null);
+  const jiraUserProductsExpressionInputRef = ref<ExpandableFieldRef | null>(null);
+  const currentJiraExpressionFieldIndex = ref(0);
   const linearLimitExpressionInputRef = ref<ExpandableFieldRef | null>(null);
   const linearAfterExpressionInputRef = ref<ExpandableFieldRef | null>(null);
   const linearTeamIdExpressionInputRef = ref<ExpandableFieldRef | null>(null);
@@ -1027,6 +1070,14 @@ export function usePropertiesPanelController() {
         }
       }
 
+      if (type === "jira") {
+        try {
+          jiraCredentials.value = await credentialsApi.listByType("jira");
+        } catch {
+          jiraCredentials.value = [];
+        }
+      }
+
       if (type === "codex") {
         try {
           codexCredentials.value = await credentialsApi.listByType("codex");
@@ -2618,6 +2669,28 @@ export function usePropertiesPanelController() {
         }
       };
       nextTick(() => tryOpenDialog());
+    } else if (nodeType === "jira") {
+      const startIndex = resolveJiraExpressionStartIndex();
+      currentJiraExpressionFieldIndex.value = startIndex;
+      const tryOpenDialog = (attempts = 0): void => {
+        if (attempts > 20) {
+          return;
+        }
+        const n = workflowStore.selectedNode;
+        if (!n || n.type !== "jira") {
+          return;
+        }
+        if (jiraExpressionFieldCount.value === 0) {
+          return;
+        }
+        const field = jiraExpressionFields.value[startIndex];
+        if (field && jiraExpressionInputRefForKey(field.key)) {
+          nextTick(() => openJiraExpressionFieldAtIndex(startIndex));
+        } else {
+          setTimeout(() => tryOpenDialog(attempts + 1), 100);
+        }
+      };
+      nextTick(() => tryOpenDialog());
     } else if (nodeType === "linear") {
       const startIndex = resolveLinearExpressionStartIndex();
       currentLinearExpressionFieldIndex.value = startIndex;
@@ -2947,6 +3020,7 @@ export function usePropertiesPanelController() {
       case "rag":
       case "codex":
       case "github":
+      case "jira":
       case "linear":
       case "throwError":
       case "crawler":
@@ -3281,6 +3355,7 @@ export function usePropertiesPanelController() {
       currentMCPCallExpressionFieldIndex.value = 0;
       currentGitHubExpressionFieldIndex.value = 0;
       currentSentryExpressionFieldIndex.value = 0;
+      currentJiraExpressionFieldIndex.value = 0;
       currentLinearExpressionFieldIndex.value = 0;
       currentNotionExpressionFieldIndex.value = 0;
       playwrightExprRefsBySlotKey.value = {};
@@ -3986,6 +4061,17 @@ export function usePropertiesPanelController() {
 
   const sentryExpressionFieldCount = computed((): number => sentryExpressionFields.value.length);
 
+  const jiraExpressionFields = computed(() => {
+    const n = workflowStore.selectedNode;
+    if (!n || n.type !== "jira") {
+      return [];
+    }
+    const operation = (n.data.jiraOperation as string | undefined) || "searchIssues";
+    return getJiraExpressionFields(operation);
+  });
+
+  const jiraExpressionFieldCount = computed((): number => jiraExpressionFields.value.length);
+
   const linearExpressionFields = computed(() => {
     const n = workflowStore.selectedNode;
     if (!n || n.type !== "linear") {
@@ -3999,6 +4085,210 @@ export function usePropertiesPanelController() {
 
   const linearExpressionFieldCount = computed((): number => linearExpressionFields.value.length);
 
+  function selectedJiraOperation(): string {
+    return (workflowStore.selectedNode?.data.jiraOperation as string | undefined) || "searchIssues";
+  }
+
+  function isJiraPaginatedOperation(): boolean {
+    return jiraPaginatedOperations.has(selectedJiraOperation());
+  }
+
+  function isJiraSearchOperation(): boolean {
+    return selectedJiraOperation() === "searchIssues";
+  }
+
+  function isJiraStartAtPaginatedOperation(): boolean {
+    return jiraStartAtPaginatedOperations.has(selectedJiraOperation());
+  }
+
+  function isJiraIssueKeyOperation(): boolean {
+    return jiraIssueKeyOperations.has(selectedJiraOperation());
+  }
+
+  function isJiraCommentIdOperation(): boolean {
+    return jiraCommentIdOperations.has(selectedJiraOperation());
+  }
+
+  function isJiraAttachmentIdOperation(): boolean {
+    return jiraAttachmentIdOperations.has(selectedJiraOperation());
+  }
+
+  function isJiraAccountIdOperation(): boolean {
+    return jiraAccountIdOperations.has(selectedJiraOperation());
+  }
+
+  function jiraExpressionFieldIndex(key: JiraExpressionFieldKey): number {
+    const index = jiraExpressionFields.value.findIndex((field) => field.key === key);
+    return index >= 0 ? index : -1;
+  }
+
+  function jiraExpressionFieldLabel(key: JiraExpressionFieldKey): string {
+    return jiraExpressionFields.value.find((field) => field.key === key)?.label ?? "";
+  }
+
+  function jiraExpressionNavBindings(key: JiraExpressionFieldKey): {
+    navigationEnabled: boolean;
+    navigationIndex: number;
+    navigationTotal: number;
+    dialogNodeLabel: string;
+    dialogKeyLabel: string;
+  } {
+    const index = jiraExpressionFieldIndex(key);
+    return {
+      navigationEnabled: jiraExpressionFieldCount.value > 1 && index >= 0,
+      navigationIndex: index >= 0 ? index : 0,
+      navigationTotal: jiraExpressionFieldCount.value,
+      dialogNodeLabel: selectedNodeEvaluateDialogLabel.value,
+      dialogKeyLabel: jiraExpressionFieldLabel(key),
+    };
+  }
+
+  function jiraExpressionInputRefForKey(key: JiraExpressionFieldKey): ExpandableFieldRef | null {
+    switch (key) {
+      case "jiraLimit":
+        return jiraLimitExpressionInputRef.value;
+      case "jiraStartAt":
+        return jiraStartAtExpressionInputRef.value;
+      case "jiraNextPageToken":
+        return jiraNextPageTokenExpressionInputRef.value;
+      case "jiraFields":
+        return jiraFieldsExpressionInputRef.value;
+      case "jiraProjectKey":
+        return jiraProjectKeyExpressionInputRef.value;
+      case "jiraIssueKey":
+        return jiraIssueKeyExpressionInputRef.value;
+      case "jiraIssueType":
+        return jiraIssueTypeExpressionInputRef.value;
+      case "jiraIssueTypeId":
+        return jiraIssueTypeIdExpressionInputRef.value;
+      case "jiraSummary":
+        return jiraSummaryExpressionInputRef.value;
+      case "jiraDescription":
+        return jiraDescriptionExpressionInputRef.value;
+      case "jiraJql":
+        return jiraJqlExpressionInputRef.value;
+      case "jiraAssigneeAccountId":
+        return jiraAssigneeAccountIdExpressionInputRef.value;
+      case "jiraLabels":
+        return jiraLabelsExpressionInputRef.value;
+      case "jiraCommentBody":
+        return jiraCommentBodyExpressionInputRef.value;
+      case "jiraCommentId":
+        return jiraCommentIdExpressionInputRef.value;
+      case "jiraTransitionId":
+        return jiraTransitionIdExpressionInputRef.value;
+      case "jiraAttachmentId":
+        return jiraAttachmentIdExpressionInputRef.value;
+      case "jiraAttachmentFilename":
+        return jiraAttachmentFilenameExpressionInputRef.value;
+      case "jiraAttachmentBase64":
+        return jiraAttachmentBase64ExpressionInputRef.value;
+      case "jiraAttachmentMimeType":
+        return jiraAttachmentMimeTypeExpressionInputRef.value;
+      case "jiraNotifySubject":
+        return jiraNotifySubjectExpressionInputRef.value;
+      case "jiraNotifyTextBody":
+        return jiraNotifyTextBodyExpressionInputRef.value;
+      case "jiraNotifyHtmlBody":
+        return jiraNotifyHtmlBodyExpressionInputRef.value;
+      case "jiraNotifyTo":
+        return jiraNotifyToExpressionInputRef.value;
+      case "jiraAccountId":
+        return jiraAccountIdExpressionInputRef.value;
+      case "jiraUsername":
+        return jiraUsernameExpressionInputRef.value;
+      case "jiraUserEmail":
+        return jiraUserEmailExpressionInputRef.value;
+      case "jiraUserDisplayName":
+        return jiraUserDisplayNameExpressionInputRef.value;
+      case "jiraUserProducts":
+        return jiraUserProductsExpressionInputRef.value;
+      default:
+        return null;
+    }
+  }
+
+  function resolveJiraExpressionStartIndex(): number {
+    const focusField = workflowStore.focusField;
+    if (focusField) {
+      const index = jiraExpressionFieldIndex(focusField as JiraExpressionFieldKey);
+      if (index >= 0) {
+        return index;
+      }
+    }
+    return 0;
+  }
+
+  function openJiraExpressionFieldAtIndex(index: number): boolean {
+    const n = selectedNode.value;
+    if (!n || n.type !== "jira") {
+      return false;
+    }
+    const field = jiraExpressionFields.value[index];
+    if (!field) {
+      return false;
+    }
+    currentJiraExpressionFieldIndex.value = index;
+    const input = jiraExpressionInputRefForKey(field.key);
+    if (!input) {
+      return false;
+    }
+    input.openExpandDialog();
+    return true;
+  }
+
+  function closeJiraExpressionDialogs(): void {
+    jiraLimitExpressionInputRef.value?.closeExpandDialog();
+    jiraStartAtExpressionInputRef.value?.closeExpandDialog();
+    jiraNextPageTokenExpressionInputRef.value?.closeExpandDialog();
+    jiraFieldsExpressionInputRef.value?.closeExpandDialog();
+    jiraProjectKeyExpressionInputRef.value?.closeExpandDialog();
+    jiraIssueKeyExpressionInputRef.value?.closeExpandDialog();
+    jiraIssueTypeExpressionInputRef.value?.closeExpandDialog();
+    jiraIssueTypeIdExpressionInputRef.value?.closeExpandDialog();
+    jiraSummaryExpressionInputRef.value?.closeExpandDialog();
+    jiraDescriptionExpressionInputRef.value?.closeExpandDialog();
+    jiraJqlExpressionInputRef.value?.closeExpandDialog();
+    jiraAssigneeAccountIdExpressionInputRef.value?.closeExpandDialog();
+    jiraLabelsExpressionInputRef.value?.closeExpandDialog();
+    jiraCommentBodyExpressionInputRef.value?.closeExpandDialog();
+    jiraCommentIdExpressionInputRef.value?.closeExpandDialog();
+    jiraTransitionIdExpressionInputRef.value?.closeExpandDialog();
+    jiraAttachmentIdExpressionInputRef.value?.closeExpandDialog();
+    jiraAttachmentFilenameExpressionInputRef.value?.closeExpandDialog();
+    jiraAttachmentBase64ExpressionInputRef.value?.closeExpandDialog();
+    jiraAttachmentMimeTypeExpressionInputRef.value?.closeExpandDialog();
+    jiraNotifySubjectExpressionInputRef.value?.closeExpandDialog();
+    jiraNotifyTextBodyExpressionInputRef.value?.closeExpandDialog();
+    jiraNotifyHtmlBodyExpressionInputRef.value?.closeExpandDialog();
+    jiraNotifyToExpressionInputRef.value?.closeExpandDialog();
+    jiraAccountIdExpressionInputRef.value?.closeExpandDialog();
+    jiraUsernameExpressionInputRef.value?.closeExpandDialog();
+    jiraUserEmailExpressionInputRef.value?.closeExpandDialog();
+    jiraUserDisplayNameExpressionInputRef.value?.closeExpandDialog();
+    jiraUserProductsExpressionInputRef.value?.closeExpandDialog();
+  }
+
+  function handleJiraExpressionFieldNavigate(direction: "prev" | "next"): void {
+    const total = jiraExpressionFieldCount.value;
+    const newIndex =
+      direction === "prev"
+        ? currentJiraExpressionFieldIndex.value - 1
+        : currentJiraExpressionFieldIndex.value + 1;
+    if (newIndex < 0 || newIndex >= total) {
+      return;
+    }
+    closeJiraExpressionDialogs();
+    currentJiraExpressionFieldIndex.value = newIndex;
+    nextTick(() => {
+      openJiraExpressionFieldAtIndex(newIndex);
+    });
+  }
+
+  function onJiraRegisterExpressionFieldIndex(index: number): void {
+    currentJiraExpressionFieldIndex.value = index;
+  }
+
   const linearPaginatedOperations = new Set([
     "listTeams",
     "listProjects",
@@ -5506,6 +5796,21 @@ export function usePropertiesPanelController() {
     );
   });
 
+  const jiraCredentialOptions = computed(() => {
+    const node = selectedNode.value;
+    const selectedCredentialId =
+      node && node.type === "jira"
+        ? (node.data.credentialId as string | undefined)
+        : undefined;
+
+    return buildCredentialOptions(
+      jiraCredentials.value,
+      selectedCredentialId,
+      "Select Jira credential...",
+      "Shared Jira credential (from owner)",
+    );
+  });
+
   const githubStateOptions = [
     { value: "open", label: "Open" },
     { value: "closed", label: "Closed" },
@@ -8279,6 +8584,35 @@ export function usePropertiesPanelController() {
     sentryReleaseProjectsExpressionInputRef,
     sentryReleaseRefsExpressionInputRef,
     sentryPayloadExpressionInputRef,
+    jiraLimitExpressionInputRef,
+    jiraStartAtExpressionInputRef,
+    jiraNextPageTokenExpressionInputRef,
+    jiraFieldsExpressionInputRef,
+    jiraProjectKeyExpressionInputRef,
+    jiraIssueKeyExpressionInputRef,
+    jiraIssueTypeExpressionInputRef,
+    jiraIssueTypeIdExpressionInputRef,
+    jiraSummaryExpressionInputRef,
+    jiraDescriptionExpressionInputRef,
+    jiraJqlExpressionInputRef,
+    jiraAssigneeAccountIdExpressionInputRef,
+    jiraLabelsExpressionInputRef,
+    jiraCommentBodyExpressionInputRef,
+    jiraCommentIdExpressionInputRef,
+    jiraTransitionIdExpressionInputRef,
+    jiraAttachmentIdExpressionInputRef,
+    jiraAttachmentFilenameExpressionInputRef,
+    jiraAttachmentBase64ExpressionInputRef,
+    jiraAttachmentMimeTypeExpressionInputRef,
+    jiraNotifySubjectExpressionInputRef,
+    jiraNotifyTextBodyExpressionInputRef,
+    jiraNotifyHtmlBodyExpressionInputRef,
+    jiraNotifyToExpressionInputRef,
+    jiraAccountIdExpressionInputRef,
+    jiraUsernameExpressionInputRef,
+    jiraUserEmailExpressionInputRef,
+    jiraUserDisplayNameExpressionInputRef,
+    jiraUserProductsExpressionInputRef,
     linearLimitExpressionInputRef,
     linearAfterExpressionInputRef,
     linearTeamIdExpressionInputRef,
@@ -8437,6 +8771,16 @@ export function usePropertiesPanelController() {
     isLinearPaginatedOperation,
     isLinearIssueIdOperation,
     isLinearCommentIdOperation,
+    isJiraPaginatedOperation,
+    isJiraSearchOperation,
+    isJiraStartAtPaginatedOperation,
+    isJiraIssueKeyOperation,
+    isJiraCommentIdOperation,
+    isJiraAttachmentIdOperation,
+    isJiraAccountIdOperation,
+    jiraExpressionNavBindings,
+    handleJiraExpressionFieldNavigate,
+    onJiraRegisterExpressionFieldIndex,
     linearExpressionNavBindings,
     handleLinearExpressionFieldNavigate,
     onLinearRegisterExpressionFieldIndex,
@@ -8489,6 +8833,9 @@ export function usePropertiesPanelController() {
     codexPublishModeOptions,
     codexPublishModeDescriptions,
     githubCredentialOptions,
+    jiraCredentialOptions,
+    jiraOperationOptions,
+    jiraOperationGroups,
     linearCredentialOptions,
     linearOperationOptions,
     linearOperationGroups,
diff --git a/frontend/src/docs/content/nodes/jira-node.md b/frontend/src/docs/content/nodes/jira-node.md
new file mode 100644
index 00000000..7acdda18
--- /dev/null
+++ b/frontend/src/docs/content/nodes/jira-node.md
@@ -0,0 +1,214 @@
+# Jira Node
+
+The **Jira** node connects workflows to the Jira REST API for project, issue, comment, attachment, user, notification, and transition automation. The default operation is **Search Issues**.
+
+## Overview
+
+| Property | Value |
+|----------|-------|
+| Inputs | 1 |
+| Outputs | 1 |
+| Credential | Jira (Cloud email/API token or Data Center username/password, base URL, deployment mode, optional REST API version) |
+| Output | `$nodeLabel.*` |
+
+## Credential
+
+Create a **Jira** credential in the [Credentials Tab](../tabs/credentials-tab.md). Stored config keys are `email`, `api_token`, `base_url`, `deployment`, and optional `api_version`. For Jira Cloud, `email` stores the Atlassian account email and `api_token` stores the Atlassian API token. For Jira Data Center / Server, those same keys store the Basic auth username and password. See [Third-Party Integrations](../reference/integrations.md#jira) for setup steps.
+
+| Field | Config key | Description |
+| --- | --- | --- |
+| Jira Email / Username | `email` | Jira Cloud Atlassian account email, or Jira Data Center / Server username |
+| API Token / Password | `api_token` | Jira Cloud Atlassian API token, or Jira Data Center / Server password for Basic auth |
+| Base URL | `base_url` | Jira site URL, for example `https://your-domain.atlassian.net` |
+| Deployment | `deployment` | `cloud` for Jira Cloud or `data_center` for Jira Data Center / Server |
+| REST API Version | `api_version` | Defaults to `3` for Jira Cloud. Data Center / Server uses REST API v2 |
+
+Data Center / Server personal access tokens and Bearer auth are not supported by the Jira credential yet.
+
+Use **Test Connection** to verify the credential against the current Jira user.
+
+## Operations
+
+| Operation | Required fields | Output |
+| --- | --- | --- |
+| Get Myself | — | `user` |
+| List Projects | Optional Limit, Start At | `projects`, `count`, `pagination` |
+| Search Issues | Optional JQL, Issue Fields, Limit, Next Page Token, Start At | `issues`, `count`, `pagination` |
+| Get Issue | Issue Key or ID | `issue`, `key` |
+| Create Issue | Project Key, Summary | `issue`, `key` |
+| Update Issue | Issue Key or ID and at least one changed field | `issue`, `key` |
+| Delete Issue | Issue Key or ID | `deleted` |
+| Get Issue Changelog | Issue Key or ID; optional Limit, Start At | `changelog`, `count`, `pagination` |
+| Notify Issue | Issue Key or ID, Subject, Text Body | `notified` |
+| List Comments | Issue Key or ID; optional Limit, Start At | `comments`, `count`, `pagination` |
+| Create Comment | Issue Key or ID, Comment Body | `comment` |
+| Get Comment | Issue Key or ID, Comment ID | `comment` |
+| Update Comment | Issue Key or ID, Comment ID, Comment Body | `comment` |
+| Delete Comment | Issue Key or ID, Comment ID | `deleted` |
+| Add Attachment | Issue Key or ID, Filename, Base64 content | `attachments`, `count` |
+| Get Attachment | Attachment ID; optional Include Binary | `attachment` |
+| List Attachments | Issue Key or ID; optional Limit, Start At, Include Binary | `attachments`, `count`, `pagination` |
+| Delete Attachment | Attachment ID | `deleted` |
+| List Transitions | Issue Key or ID | `transitions`, `count` |
+| Transition Issue | Issue Key or ID, Transition ID | `transition`, `issue`, `key` |
+| Get User | Account ID / Username | `user` |
+| Create User | User Email | `user` |
+| Delete User | Account ID / Username | `deleted` |
+
+Expression-capable text fields support [expressions](../reference/expression-dsl.md) such as `$input.text`. `jiraIncludeBinary` is a boolean toggle and does not support expressions, but it can be marked as agent-provided when the Jira node is attached to an Agent tool handle.
+
+## Issue and update fields
+
+- **Project Key** is the short project key such as `ENG`. Use List Projects to discover keys.
+- **Issue Key or ID** accepts keys such as `ENG-123` or numeric issue IDs. Use Search Issues or List Projects to discover values.
+- **Transition ID** comes from List Transitions. Each transition object includes an `id` field.
+- **Comment ID** and **Attachment ID** come from List Comments, List Attachments, or prior create/get responses.
+- **Account ID / Username** is the Jira Cloud `accountId` value or the Jira Data Center / Server username. Get Myself or Get User can help you discover it.
+- Issue **description** and comment **body** text are sent as Atlassian Document Format on REST
+  API v3; when the credential deployment is Data Center / Server, they are sent as plain text.
+  In v3, newline characters become separate paragraphs.
+- **Get Issue Changelog** uses Jira Cloud's paginated changelog endpoint. For Data Center / Server, it reads expanded issue changelog data and applies the configured offset/limit to the returned histories.
+- On **Update Issue**, leave optional fields empty to preserve their current values.
+- Set **Description** or **Assignee Account ID / Username** to `null` on update to clear those fields. Labels cannot be cleared with `null`.
+- **Recipients JSON** on Notify Issue defaults to `{"assignee":true}` when omitted. Common keys include `assignee`, `reporter`, `watchers`, and `voters` (for example `{"assignee":true,"watchers":true}`).
+- **Add Attachment** accepts raw base64 or data URL content and is limited by the platform file size setting (default 99 MB).
+
+## Pagination
+
+- **Search Issues** uses cursor pagination via `jiraNextPageToken` for Jira Cloud. Read `pagination.nextPageToken` from the previous run and pass it into the next Search Issues node.
+- **Search Issues** uses offset pagination via `jiraStartAt` for Jira Data Center / Server. Read `pagination.startAt`, `pagination.maxResults`, and `pagination.total` to calculate the next page.
+- **List Projects**, **Get Issue Changelog**, **List Comments**, and **List Attachments** use offset pagination with `jiraLimit` and `jiraStartAt`. Paged results return `pagination.startAt`, `pagination.maxResults`, `pagination.total`, and `pagination.isLast`.
+- **List Attachments** fetches all attachments from the issue first, then slices the result client-side. Pagination fields still describe the returned page, but large issues may incur an extra fetch cost.
+- **List Transitions** does not paginate.
+
+## Key Fields
+
+| Field | Used by | Notes |
+| --- | --- | --- |
+| `credentialId` | All operations | Owned Jira credential UUID |
+| `jiraOperation` | All operations | Defaults to `searchIssues` |
+| `jiraProjectKey` | Create Issue | Project key such as `ENG` |
+| `jiraIssueKey` | Issue, comment, attachment, notification, and transition operations | Issue key such as `ENG-123` or numeric issue ID |
+| `jiraIssueType` | Create Issue | Defaults to `Task` |
+| `jiraIssueTypeId` | Create Issue | Optional issue type ID; overrides `jiraIssueType` when set |
+| `jiraSummary` | Create/Update Issue | Required for Create Issue |
+| `jiraDescription` | Create/Update Issue | Sent as ADF on REST API v3 or plain text on REST API v2; use `null` on update to clear description |
+| `jiraJql` | Search Issues | Defaults to `updated >= -30d ORDER BY updated DESC` |
+| `jiraFields` | Search Issues | Optional JSON array or comma-separated issue fields; defaults to `key`, `summary`, `status`, `assignee`, and `issuetype` when empty |
+| `jiraAssigneeAccountId` | Create/Update Issue | Jira Cloud accountId or Data Center / Server username; use `null` on update to clear assignee |
+| `jiraLabels` | Create/Update Issue | JSON array or comma-separated text |
+| `jiraCommentBody` | Create/Update Comment | Sent as ADF on REST API v3 or plain text on REST API v2 |
+| `jiraCommentId` | Get/Update/Delete Comment | Jira comment ID |
+| `jiraTransitionId` | Transition Issue | Discover with List Transitions |
+| `jiraAttachmentId` | Get/Delete Attachment | Jira attachment ID |
+| `jiraAttachmentFilename` | Add Attachment | Uploaded filename |
+| `jiraAttachmentBase64` | Add Attachment | Raw base64 or data URL content; subject to file size limit |
+| `jiraAttachmentMimeType` | Add Attachment | Optional MIME type; inferred from filename when empty |
+| `jiraIncludeBinary` | Get/List Attachment | Boolean toggle; adds `content_base64` when enabled |
+| `jiraNotifySubject` | Notify Issue | Required notification subject |
+| `jiraNotifyTextBody` | Notify Issue | Required plain-text notification body |
+| `jiraNotifyHtmlBody` | Notify Issue | Optional HTML body |
+| `jiraNotifyTo` | Notify Issue | Recipients JSON; defaults to `{"assignee":true}` |
+| `jiraAccountId` | Get/Delete User | Jira Cloud accountId or Data Center / Server username |
+| `jiraUserEmail` | Create User | New user email address |
+| `jiraUsername` | Create User | Optional Data Center / Server username; falls back to `jiraUserEmail` |
+| `jiraUserDisplayName` | Create User | Optional display name |
+| `jiraUserProducts` | Create User | JSON array or comma-separated product keys; Jira Cloud only |
+| `jiraLimit` | Search Issues, List Projects, Get Issue Changelog, List Comments, List Attachments | Defaults to `50`; range 1–100 |
+| `jiraStartAt` | Search Issues on Data Center / Server, List Projects, Get Issue Changelog, List Comments, List Attachments | Offset pagination start index |
+| `jiraNextPageToken` | Search Issues on Jira Cloud | Cursor token from a previous search response |
+
+## Examples
+
+Create an issue from upstream input:
+
+- Operation: `createIssue`
+- Project Key: `ENG`
+- Issue Type: `Task`
+- Summary: `$input.title`
+- Description: `$input.description`
+- Labels: `["automation"]`
+
+Update an issue and clear the assignee:
+
+- Operation: `updateIssue`
+- Issue Key or ID: `ENG-123`
+- Summary: `$input.title`
+- Assignee Account ID / Username: `null`
+
+Search issues with custom fields and cursor pagination:
+
+- Operation: `searchIssues`
+- JQL: `project = ENG AND updated >= -30d ORDER BY updated DESC`
+- Issue Fields: `["key","summary","status"]`
+- Limit: `25`
+- Next Page Token: `$searchJira.pagination.nextPageToken`
+
+Search issues on Data Center with offset pagination:
+
+- Operation: `searchIssues`
+- JQL: `project = ENG ORDER BY updated DESC`
+- Limit: `25`
+- Start At: `25`
+
+Transition an issue after listing available transitions:
+
+- Operation: `listTransitions`
+- Issue Key or ID: `ENG-123`
+- Then run **Transition Issue** with Transition ID: `$listTransitions.transitions[0].id`
+
+Notify watchers about an issue update:
+
+- Operation: `notifyIssue`
+- Issue Key or ID: `ENG-123`
+- Subject: `Issue updated`
+- Text Body: `$input.text`
+- Recipients JSON: `{"assignee":true,"watchers":true}`
+
+## Output
+
+Every successful operation sets:
+
+- `$jira.success`
+- `$jira.operation`
+
+**Get Myself** exposes `user`.
+
+**Paginated list operations** expose `count`, a collection field, and `pagination`:
+
+| Operation | Collection key | Pagination shape |
+| --- | --- | --- |
+| List Projects | `projects` | `{ startAt, maxResults, total, isLast }` |
+| Search Issues | `issues` | Cloud: `{ maxResults, nextPageToken, isLast }`; Data Center: `{ startAt, maxResults, total, isLast }` |
+| Get Issue Changelog | `changelog` | `{ startAt, maxResults, total, isLast }` |
+| List Comments | `comments` | `{ startAt, maxResults, total, isLast }` |
+| List Attachments | `attachments` | `{ startAt, maxResults, total, isLast }` |
+
+**List Transitions** exposes `transitions` and `count` without pagination.
+
+**Issue mutations and reads** expose the Jira issue payload plus `key` where applicable.
+
+**Comment** get/create/update expose `comment`; delete exposes `deleted`.
+
+**Transition Issue** exposes `transition` as `{ transitionId }`, plus the refreshed `issue` and `key`.
+
+**Attachment add** exposes `attachments` and `count`. **Get Attachment** exposes `attachment`; **List Attachments** exposes `attachments`, `count`, and `pagination`. When **Include Binary** is enabled, each attachment object may include `content_base64`. Delete exposes `deleted`.
+
+**User** get/create expose `user`; delete exposes `deleted`.
+
+**Notify Issue** exposes `notified`.
+
+Common access patterns:
+
+- `$searchJira.issues[0].key`
+- `$searchJira.pagination.nextPageToken`
+- `$createJiraIssue.key`
+- `$listTransitions.transitions[0].id`
+- `$getAttachment.attachment.content_base64`
+
+## Related
+
+- [Credentials Tab](../tabs/credentials-tab.md)
+- [Third-Party Integrations](../reference/integrations.md#jira)
+- [Node Types](../reference/node-types.md)
+- [Expression DSL](../reference/expression-dsl.md)
diff --git a/frontend/src/docs/content/reference/credentials-sharing.md b/frontend/src/docs/content/reference/credentials-sharing.md
index 485a08a6..5a77724e 100644
--- a/frontend/src/docs/content/reference/credentials-sharing.md
+++ b/frontend/src/docs/content/reference/credentials-sharing.md
@@ -55,6 +55,7 @@ Some nodes store `credentialId` (UUID) in `node.data`:
 |-----------|-------|-------------|
 | [LLM](../nodes/llm-node.md), [Agent](../nodes/agent-node.md), [RAG](../nodes/rag-node.md), Image Gen | `credentialId` | LLM API credential |
 | [Codex](../nodes/codex-node.md) | `credentialId`, `githubCredentialId` | Codex access token credential and GitHub credential |
+| [Jira](../nodes/jira-node.md) | `credentialId` | Jira Cloud email/API token or Data Center username/password credential |
 | [Notion](../nodes/notion-node.md) | `credentialId` | Notion internal token or OAuth workspace credential |
 | [Sentry](../nodes/sentry-node.md) | `credentialId` | Sentry auth token and optional base URL |
 | [Supabase](../nodes/supabase-node.md) | `credentialId` | Supabase project URL and API key |
@@ -77,5 +78,5 @@ After execution, `mask_sensitive_output()` replaces credential values in outputs
 - [Third-Party Integrations](./integrations.md) – Detailed setup for each credential type
 - [Teams](./teams.md) – Share with teams
 - [Expression DSL](./expression-dsl.md) – `$credentials` syntax
-- [Node Types](./node-types.md) – Nodes that use credentials ([LLM](../nodes/llm-node.md), [Agent](../nodes/agent-node.md), [Codex](../nodes/codex-node.md), [Linear](../nodes/linear-node.md), [RAG](../nodes/rag-node.md), [Playwright](../nodes/playwright-node.md), [HTTP](../nodes/http-node.md), [Notion](../nodes/notion-node.md), [Sentry](../nodes/sentry-node.md), [Supabase](../nodes/supabase-node.md), [ClickHouse](../nodes/clickhouse-node.md), [Telegram](../nodes/telegram-node.md), [Telegram Trigger](../nodes/telegram-trigger-node.md), [Discord](../nodes/discord-node.md), [Discord Trigger](../nodes/discord-trigger-node.md), [Slack](../nodes/slack-node.md))
+- [Node Types](./node-types.md) – Nodes that use credentials ([LLM](../nodes/llm-node.md), [Agent](../nodes/agent-node.md), [Codex](../nodes/codex-node.md), [Jira](../nodes/jira-node.md), [Linear](../nodes/linear-node.md), [RAG](../nodes/rag-node.md), [Playwright](../nodes/playwright-node.md), [HTTP](../nodes/http-node.md), [Notion](../nodes/notion-node.md), [Sentry](../nodes/sentry-node.md), [Supabase](../nodes/supabase-node.md), [ClickHouse](../nodes/clickhouse-node.md), [Telegram](../nodes/telegram-node.md), [Telegram Trigger](../nodes/telegram-trigger-node.md), [Discord](../nodes/discord-node.md), [Discord Trigger](../nodes/discord-trigger-node.md), [Slack](../nodes/slack-node.md))
 - [Agent Node](../nodes/agent-node.md) – Uses `credentialId` for LLM
diff --git a/frontend/src/docs/content/reference/credentials.md b/frontend/src/docs/content/reference/credentials.md
index da17cbce..bbf367f5 100644
--- a/frontend/src/docs/content/reference/credentials.md
+++ b/frontend/src/docs/content/reference/credentials.md
@@ -15,6 +15,7 @@ Credentials store API keys and secrets used by workflow nodes. You add them in t
 | [LLM](../nodes/llm-node.md), [Agent](../nodes/agent-node.md) | OpenAI, Google, Custom | API key for the model |
 | [Codex](../nodes/codex-node.md) | OpenAI Codex + GitHub | ChatGPT subscription sign-in (OAuth) or a Codex access token for the runner, plus a GitHub PAT for repository operations |
 | [Agent](../nodes/agent-node.md), [HTTP](../nodes/http-node.md), [GitHub](../nodes/github-node.md) | GitHub | GitHub personal access token (PAT) for GitHub API calls, GitHub node operations, and MCP integrations |
+| [Jira](../nodes/jira-node.md) | Jira | Cloud email/API token or Data Center username/password, Jira site base URL, deployment mode, and optional REST API version |
 | [Linear](../nodes/linear-node.md) | Linear | Personal API key or OAuth2 for teams, projects, issues, and comments |
 | [HTTP](../nodes/http-node.md) | Bearer, Header | Auth for requests |
 | [Telegram](../nodes/telegram-node.md), [Telegram Trigger](../nodes/telegram-trigger-node.md) | Telegram | Bot token and optional webhook secret |
@@ -42,7 +43,7 @@ Enterprise Server instead of GitHub.com. When you edit a GitHub credential to ro
 leaving `base_url` empty preserves the existing Enterprise endpoint. Enter a new URL only when
 you want to change that endpoint.
 
-Linear, Supabase, Notion, Sentry, and ClickHouse credentials expose **Test Connection** in the credential dialog. For Linear,
+Jira, Linear, Supabase, Notion, Sentry, and ClickHouse credentials expose **Test Connection** in the credential dialog. For Jira, the check calls Jira's current user endpoint. For Linear,
 the check calls the Linear API with `getViewer` and confirms the API key or OAuth token is valid.
 When editing, you can test without re-entering the API key if the stored secret is still present. For Notion,
 choose **Internal token** or **OAuth** in the dialog; OAuth uses the Client ID and Client Secret
@@ -55,6 +56,8 @@ Some nodes allow expressions for auth. Use [Expression DSL](./expression-dsl.md)
 
 Codex credentials are intentionally excluded from `$credentials`. Whether you sign in with ChatGPT (subscription, no per-token API cost) or paste a Codex `access_token`, the tokens are only passed to the local Codex runner process. ChatGPT sign-in tokens are refreshed automatically as they expire.
 
+Jira credentials are also excluded from `$credentials`. The [Jira node](../nodes/jira-node.md) loads the credential by `credentialId` at run time. For custom Jira REST calls not covered by the Jira node, use the [HTTP node](../nodes/http-node.md) with Jira Basic Auth (`email:api_token` for Jira Cloud or `username:password` for Data Center / Server), for example `curl -u you@example.com:YOUR_API_TOKEN https://your-domain.atlassian.net/rest/api/3/myself`. You can also use a [Header](../nodes/http-node.md) credential with `Authorization: Basic <base64(user:secret)>`. Jira Data Center / Server personal access tokens and Bearer auth are not supported by the Jira credential yet.
+
 | Credential type | Value exposed to `$credentials.Name` |
 |-----------------|--------------------------------------|
 | Bearer | Bearer token string |
@@ -76,6 +79,7 @@ Use the Notion **node** for native database, page, and block operations. Use `$c
 
 - [Credentials Tab](../tabs/credentials-tab.md) – Add, edit, delete credentials
 - [GitHub Node](../nodes/github-node.md) – Native GitHub REST operations
+- [Jira Node](../nodes/jira-node.md) – Jira project, issue, comment, attachment, user, notification, and transition automation
 - [Linear Node](../nodes/linear-node.md) – Linear GraphQL workspace and issue automation
 - [Notion Node](../nodes/notion-node.md) – Search and manage Notion content
 - [Sentry Node](../nodes/sentry-node.md) – Sentry organization, project, team, issue, event, and release automation
diff --git a/frontend/src/docs/content/reference/features.md b/frontend/src/docs/content/reference/features.md
index 8afa795b..e09f1936 100644
--- a/frontend/src/docs/content/reference/features.md
+++ b/frontend/src/docs/content/reference/features.md
@@ -8,7 +8,7 @@ A comprehensive overview of all Heym capabilities. Each section describes a feat
 
 ### [Introduction](../getting-started/introduction.md)
 
-Heym is an AI-native low-code automation platform with a visual workflow editor. You build automations by connecting nodes on a canvas—no coding required for most use cases. It supports visual workflows, AI-powered nodes ([LLM](../nodes/llm-node.md), [Agent Node](../nodes/agent-node.md), [Qdrant RAG](../nodes/rag-node.md)), an [AI Assistant](./ai-assistant.md), integrations ([HTTP](../nodes/http-node.md), [GitHub](../nodes/github-node.md), [Notion](../nodes/notion-node.md), [WebSocket Send](../nodes/websocket-send-node.md), [Telegram](../nodes/telegram-node.md), [Slack](../nodes/slack-node.md), inbound [IMAP Trigger](../nodes/imap-trigger-node.md) email, outbound [Send Email](../nodes/send-email-node.md)), scheduling with [Cron](../nodes/cron-node.md), and [Portal](./portal.md) chat portals for end users.
+Heym is an AI-native low-code automation platform with a visual workflow editor. You build automations by connecting nodes on a canvas—no coding required for most use cases. It supports visual workflows, AI-powered nodes ([LLM](../nodes/llm-node.md), [Agent Node](../nodes/agent-node.md), [Qdrant RAG](../nodes/rag-node.md)), an [AI Assistant](./ai-assistant.md), integrations ([HTTP](../nodes/http-node.md), [GitHub](../nodes/github-node.md), [Jira](../nodes/jira-node.md), [Notion](../nodes/notion-node.md), [WebSocket Send](../nodes/websocket-send-node.md), [Telegram](../nodes/telegram-node.md), [Slack](../nodes/slack-node.md), inbound [IMAP Trigger](../nodes/imap-trigger-node.md) email, outbound [Send Email](../nodes/send-email-node.md)), scheduling with [Cron](../nodes/cron-node.md), and [Portal](./portal.md) chat portals for end users.
 
 See also [Core Concepts](../getting-started/core-concepts.md), [Node Types](./node-types.md), and [Third-Party Integrations](./integrations.md).
 
@@ -264,6 +264,12 @@ The GitHub node provides 40 native GitHub REST actions covering repositories, or
 
 Pairs with [Agent Node](../nodes/agent-node.md), [HTTP](../nodes/http-node.md), [Set](../nodes/set-node.md), and [Third-Party Integrations](./integrations.md).
 
+#### [Jira](../nodes/jira-node.md)
+
+The Jira node connects workflows to Jira Cloud or Jira Data Center / Server REST APIs for project, issue, comment, attachment, user, notification, and transition automation. It can list projects, search issues with JQL, create or update issues, inspect changelogs, notify stakeholders, manage comments and attachments, fetch or manage users, list available transitions, and move issues through a transition ID. Use a Jira credential with Atlassian email, API token, site base URL, and deployment mode.
+
+Pairs with [LLM](../nodes/llm-node.md), [Agent Node](../nodes/agent-node.md), [Slack](../nodes/slack-node.md), and [Third-Party Integrations](./integrations.md) for support intake, bug triage, and release workflows.
+
 #### [Linear](../nodes/linear-node.md)
 
 The Linear node connects workflows to Linear's GraphQL API for workspace and issue automation. It can list teams, projects, issues, workflow states, team members, and comments; create, update, delete, and link issues; and create, update, resolve, unresolve, or delete comments. Use a Linear personal API key or OAuth2 credential, then discover team, project, state, and assignee UUIDs from list operations before creating or updating issues.
@@ -382,7 +388,7 @@ Pairs with [Condition](../nodes/condition-node.md), [Error Handler](../nodes/err
 
 ### [Node Types](./node-types.md)
 
-Heym provides a variety of node types: triggers such as [Input](../nodes/input-node.md), [Cron](../nodes/cron-node.md), [Telegram Trigger](../nodes/telegram-trigger-node.md), [Discord Trigger](../nodes/discord-trigger-node.md), [IMAP Trigger](../nodes/imap-trigger-node.md), [Slack Trigger](../nodes/slack-trigger-node.md), [RabbitMQ](../nodes/rabbitmq-node.md), and [Error Handler](../nodes/error-handler-node.md); AI nodes such as [LLM](../nodes/llm-node.md), [Agent Node](../nodes/agent-node.md), [Codex](../nodes/codex-node.md), [Qdrant RAG](../nodes/rag-node.md), and [MCP Call](../nodes/mcp-call-node.md); logic nodes like [Condition](../nodes/condition-node.md), [Switch](../nodes/switch-node.md), [Merge](../nodes/merge-node.md), and [Loop](../nodes/loop-node.md); data nodes like [Set](../nodes/set-node.md), [Variable](../nodes/variable-node.md), and [Execute](../nodes/execute-node.md); integrations such as [HTTP](../nodes/http-node.md), [GitHub](../nodes/github-node.md), [Linear](../nodes/linear-node.md), [Notion](../nodes/notion-node.md), [Sentry](../nodes/sentry-node.md), [Telegram](../nodes/telegram-node.md), [Slack](../nodes/slack-node.md), [Discord](../nodes/discord-node.md), [Send Email](../nodes/send-email-node.md), [Redis](../nodes/redis-node.md), [Grist](../nodes/grist-node.md), [Google Sheets](../nodes/google-sheets-node.md), [BigQuery](../nodes/bigquery-node.md), [Supabase](../nodes/supabase-node.md), [ClickHouse](../nodes/clickhouse-node.md), [DataTable](../nodes/datatable-node.md), and [Drive](../nodes/drive-node.md); automation nodes like [Crawler](../nodes/crawler-node.md) and [Playwright](../nodes/playwright-node.md); and utilities such as [Wait](../nodes/wait-node.md), [Output](../nodes/output-node.md), [JSON output mapper](../nodes/json-output-mapper-node.md), [Console Log](../nodes/console-log-node.md), [Throw Error](../nodes/throw-error-node.md), [Disable Node](../nodes/disable-node.md), and [Sticky Note](../nodes/sticky-note-node.md). Use expressions like `$input.text` and `$nodeLabel.field` in node configuration.
+Heym provides a variety of node types: triggers such as [Input](../nodes/input-node.md), [Cron](../nodes/cron-node.md), [Telegram Trigger](../nodes/telegram-trigger-node.md), [Discord Trigger](../nodes/discord-trigger-node.md), [IMAP Trigger](../nodes/imap-trigger-node.md), [Slack Trigger](../nodes/slack-trigger-node.md), [RabbitMQ](../nodes/rabbitmq-node.md), and [Error Handler](../nodes/error-handler-node.md); AI nodes such as [LLM](../nodes/llm-node.md), [Agent Node](../nodes/agent-node.md), [Codex](../nodes/codex-node.md), [Qdrant RAG](../nodes/rag-node.md), and [MCP Call](../nodes/mcp-call-node.md); logic nodes like [Condition](../nodes/condition-node.md), [Switch](../nodes/switch-node.md), [Merge](../nodes/merge-node.md), and [Loop](../nodes/loop-node.md); data nodes like [Set](../nodes/set-node.md), [Variable](../nodes/variable-node.md), and [Execute](../nodes/execute-node.md); integrations such as [HTTP](../nodes/http-node.md), [GitHub](../nodes/github-node.md), [Jira](../nodes/jira-node.md), [Linear](../nodes/linear-node.md), [Notion](../nodes/notion-node.md), [Sentry](../nodes/sentry-node.md), [Telegram](../nodes/telegram-node.md), [Slack](../nodes/slack-node.md), [Discord](../nodes/discord-node.md), [Send Email](../nodes/send-email-node.md), [Redis](../nodes/redis-node.md), [Grist](../nodes/grist-node.md), [Google Sheets](../nodes/google-sheets-node.md), [BigQuery](../nodes/bigquery-node.md), [Supabase](../nodes/supabase-node.md), [ClickHouse](../nodes/clickhouse-node.md), [DataTable](../nodes/datatable-node.md), and [Drive](../nodes/drive-node.md); automation nodes like [Crawler](../nodes/crawler-node.md) and [Playwright](../nodes/playwright-node.md); and utilities such as [Wait](../nodes/wait-node.md), [Output](../nodes/output-node.md), [JSON output mapper](../nodes/json-output-mapper-node.md), [Console Log](../nodes/console-log-node.md), [Throw Error](../nodes/throw-error-node.md), [Disable Node](../nodes/disable-node.md), and [Sticky Note](../nodes/sticky-note-node.md). Use expressions like `$input.text` and `$nodeLabel.field` in node configuration.
 
 See also [Triggers](./triggers.md), [Third-Party Integrations](./integrations.md), and [Parallel Execution](./parallel-execution.md).
 
@@ -597,7 +603,7 @@ See also [Execution Tokens](./execution-tokens.md), [Guardrails](./guardrails.md
 
 ### [Third-Party Integrations](./integrations.md)
 
-Heym connects to external services through credentials stored in the [Credentials](../tabs/credentials-tab.md) tab (encrypted at rest). Supported types include OpenAI, Google, GitHub for the [GitHub node](../nodes/github-node.md) and MCP integrations, Notion for the [Notion node](../nodes/notion-node.md), Custom LLM, Cohere, RAG: Qdrant + OpenAI, RAG: Psql + OpenAI, [Grist](../nodes/grist-node.md), SMTP for [Send Email](../nodes/send-email-node.md), [RabbitMQ](../nodes/rabbitmq-node.md), [Redis](../nodes/redis-node.md), [Telegram](../nodes/telegram-node.md), [Slack](../nodes/slack-node.md), Bearer, Header, and FlareSolverr for [Crawler](../nodes/crawler-node.md). Each type documents required fields; credentials can be shared with users or [teams](./teams.md) and referenced by name in nodes or as `$credentials.Name` in expressions.
+Heym connects to external services through credentials stored in the [Credentials](../tabs/credentials-tab.md) tab (encrypted at rest). Supported types include OpenAI, Google, GitHub for the [GitHub node](../nodes/github-node.md) and MCP integrations, Jira for the [Jira node](../nodes/jira-node.md), Notion for the [Notion node](../nodes/notion-node.md), Custom LLM, Cohere, RAG: Qdrant + OpenAI, RAG: Psql + OpenAI, [Grist](../nodes/grist-node.md), SMTP for [Send Email](../nodes/send-email-node.md), [RabbitMQ](../nodes/rabbitmq-node.md), [Redis](../nodes/redis-node.md), [Telegram](../nodes/telegram-node.md), [Slack](../nodes/slack-node.md), Bearer, Header, and FlareSolverr for [Crawler](../nodes/crawler-node.md). Each type documents required fields; credentials can be shared with users or [teams](./teams.md) and referenced by name in nodes or as `$credentials.Name` in expressions.
 
 See also [Credentials](./credentials.md), [Credentials Sharing](./credentials-sharing.md), and [Teams](./teams.md).
 
diff --git a/frontend/src/docs/content/reference/integrations.md b/frontend/src/docs/content/reference/integrations.md
index 472bf19a..d1427b49 100644
--- a/frontend/src/docs/content/reference/integrations.md
+++ b/frontend/src/docs/content/reference/integrations.md
@@ -14,6 +14,7 @@ Some integration nodes do **not** require credentials. [WebSocket Trigger](../no
 | **OpenAI Codex** | [Codex](../nodes/codex-node.md) | `access_token` |
 | **Google** | [LLM](../nodes/llm-node.md), [Agent](../nodes/agent-node.md) | `api_key` |
 | **GitHub** | [GitHub](../nodes/github-node.md), [Codex](../nodes/codex-node.md), [Agent](../nodes/agent-node.md), [HTTP](../nodes/http-node.md) | `api_key`, optional `base_url` |
+| **Jira** | [Jira node](../nodes/jira-node.md) | `email`, `api_token`, `base_url`, `deployment`, optional `api_version` |
 | **Linear** | [Linear node](../nodes/linear-node.md) | `api_key`, or `client_id` + `client_secret` OAuth2 |
 | **Sentry** | [Sentry node](../nodes/sentry-node.md) | `api_token`, optional `base_url` |
 | **Custom** | [LLM](../nodes/llm-node.md), [Agent](../nodes/agent-node.md) | `api_key`, `base_url` |
@@ -152,6 +153,54 @@ OAuth tokens (`access_token`, `refresh_token`, `token_expiry`) are stored and re
 
 ---
 
+## Jira
+
+The Jira credential stores Jira Basic auth credentials, Jira site base URL, deployment mode, and optional REST API version for the [Jira node](../nodes/jira-node.md). Use `cloud` for Jira Cloud or `data_center` for Jira Data Center / Server.
+
+### Setup
+
+**Jira Cloud**
+
+1. In Atlassian account settings, create an API token.
+2. In Heym Dashboard → **Credentials** → **New** → type **Jira**.
+3. Enter the Atlassian email, API token, and Jira site URL such as `https://your-domain.atlassian.net`.
+4. Use **Test Connection** to verify the credential.
+
+**Jira Data Center / Server**
+
+1. Select **Jira Data Center / Server** as the deployment.
+2. Enter the Jira username and password used for Basic auth.
+3. Enter the Jira site URL, for example `https://jira.example.com`.
+4. Use **Test Connection** to verify the credential.
+
+### Fields
+
+| Field | Description |
+| --- | --- |
+| `email` | Jira Cloud Atlassian account email, or Jira Data Center / Server username |
+| `api_token` | Jira Cloud Atlassian API token, or Jira Data Center / Server password for Basic auth |
+| `base_url` | Jira site base URL |
+| `deployment` | `cloud` for Jira Cloud or `data_center` for Jira Data Center / Server |
+| `api_version` | REST API version; defaults to `3` for Jira Cloud. Data Center / Server uses v2 |
+
+### Notes
+
+- The Jira node sends issue descriptions and comments as Atlassian Document Format text
+  documents for Jira Cloud REST API v3. Data Center / Server credentials send plain text.
+- Data Center / Server currently supports username/password Basic auth only. Personal access
+  tokens and Bearer auth are not supported yet.
+- Attachment upload accepts base64 or data URL content and is subject to the platform file size limit (default 99 MB). Attachment download can return base64 content when enabled.
+- User creation, deletion, and issue notification require the authenticated Jira account to have the relevant Jira site or organization permissions.
+- Use List Projects, Search Issues, and List Transitions to discover project keys, issue keys, and transition IDs.
+- For custom endpoints not covered by the Jira node, use the [HTTP node](../nodes/http-node.md) with Jira Basic Auth (`email:api_token` for Cloud or `username:password` for Data Center / Server) in the cURL command, or a Header credential with the matching `Authorization: Basic <base64(user:secret)>` value.
+
+See also:
+
+- [Jira node](../nodes/jira-node.md)
+- [Credentials](./credentials.md)
+
+---
+
 ## Sentry
 
 The Sentry credential stores an auth token for the [Sentry node](../nodes/sentry-node.md). Heym uses Sentry's REST API for organization, project, team, issue, event, and release operations.
diff --git a/frontend/src/docs/content/reference/node-types.md b/frontend/src/docs/content/reference/node-types.md
index b879de46..9f6174ef 100644
--- a/frontend/src/docs/content/reference/node-types.md
+++ b/frontend/src/docs/content/reference/node-types.md
@@ -59,6 +59,7 @@ See [Triggers](./triggers.md) for all entry points.
 | [Redis](../nodes/redis-node.md) | Redis operations (set, get, hasKey, deleteKey) | 1 | 1 |
 | [Grist](../nodes/grist-node.md) | Read/write Grist spreadsheets | 1 | 1 |
 | [GitHub](../nodes/github-node.md) | Manage repositories, users, issues, pull requests, reviews, releases, Actions workflows, and files through the GitHub REST API | 1 | 1 |
+| [Jira](../nodes/jira-node.md) | Manage Jira projects, issues, comments, attachments, users, notifications, and workflow transitions through the Jira REST API | 1 | 1 |
 | [Linear](../nodes/linear-node.md) | Manage Linear teams, projects, issues, workflow states, and comments through GraphQL | 1 | 1 |
 | [Google Sheets](../nodes/google-sheets-node.md) | Read/write Google Sheets via OAuth2 | 1 | 1 |
 | [BigQuery](../nodes/bigquery-node.md) | Run SQL queries and insert rows in BigQuery | 1 | 1 |
diff --git a/frontend/src/docs/manifest.ts b/frontend/src/docs/manifest.ts
index 312d8f31..32990400 100644
--- a/frontend/src/docs/manifest.ts
+++ b/frontend/src/docs/manifest.ts
@@ -65,6 +65,7 @@ export const DOCS_MANIFEST: Record<string, DocCategory> = {
       { slug: "redis-node", title: "Redis" },
       { slug: "grist-node", title: "Grist" },
       { slug: "github-node", title: "GitHub" },
+      { slug: "jira-node", title: "Jira" },
       { slug: "linear-node", title: "Linear" },
       { slug: "google-sheets-node", title: "Google Sheets" },
       { slug: "bigquery-node", title: "BigQuery" },
diff --git a/frontend/src/lib/jiraExpressionFields.test.ts b/frontend/src/lib/jiraExpressionFields.test.ts
new file mode 100644
index 00000000..8942b69f
--- /dev/null
+++ b/frontend/src/lib/jiraExpressionFields.test.ts
@@ -0,0 +1,177 @@
+import { describe, expect, it } from "vitest";
+
+import { getJiraExpressionFields } from "@/lib/jiraExpressionFields";
+
+describe("getJiraExpressionFields", () => {
+  it("returns no fields for getMyself", () => {
+    expect(getJiraExpressionFields("getMyself")).toEqual([]);
+  });
+
+  it("includes pagination fields for listProjects", () => {
+    const keys = getJiraExpressionFields("listProjects").map((field) => field.key);
+
+    expect(keys).toEqual(["jiraLimit", "jiraStartAt"]);
+  });
+
+  it("includes pagination, JQL, and fields for searchIssues", () => {
+    const keys = getJiraExpressionFields("searchIssues").map((field) => field.key);
+
+    expect(keys).toEqual([
+      "jiraLimit",
+      "jiraNextPageToken",
+      "jiraStartAt",
+      "jiraJql",
+      "jiraFields",
+    ]);
+  });
+
+  it("includes issue key for getIssue", () => {
+    const keys = getJiraExpressionFields("getIssue").map((field) => field.key);
+
+    expect(keys).toEqual(["jiraIssueKey"]);
+  });
+
+  it("includes issue mutation fields for createIssue", () => {
+    const keys = getJiraExpressionFields("createIssue").map((field) => field.key);
+
+    expect(keys).toEqual([
+      "jiraProjectKey",
+      "jiraIssueType",
+      "jiraIssueTypeId",
+      "jiraSummary",
+      "jiraDescription",
+      "jiraAssigneeAccountId",
+      "jiraLabels",
+    ]);
+  });
+
+  it("includes issue key and mutation fields for updateIssue", () => {
+    const keys = getJiraExpressionFields("updateIssue").map((field) => field.key);
+
+    expect(keys).toEqual([
+      "jiraIssueKey",
+      "jiraSummary",
+      "jiraDescription",
+      "jiraAssigneeAccountId",
+      "jiraLabels",
+    ]);
+  });
+
+  it("includes issue key for deleteIssue", () => {
+    const keys = getJiraExpressionFields("deleteIssue").map((field) => field.key);
+
+    expect(keys).toEqual(["jiraIssueKey"]);
+  });
+
+  it("includes pagination and issue key for getIssueChangelog", () => {
+    const keys = getJiraExpressionFields("getIssueChangelog").map((field) => field.key);
+
+    expect(keys).toEqual(["jiraLimit", "jiraStartAt", "jiraIssueKey"]);
+  });
+
+  it("includes notification fields for notifyIssue", () => {
+    const keys = getJiraExpressionFields("notifyIssue").map((field) => field.key);
+
+    expect(keys).toEqual([
+      "jiraIssueKey",
+      "jiraNotifySubject",
+      "jiraNotifyTextBody",
+      "jiraNotifyHtmlBody",
+      "jiraNotifyTo",
+    ]);
+  });
+
+  it("includes pagination and issue key for listComments", () => {
+    const keys = getJiraExpressionFields("listComments").map((field) => field.key);
+
+    expect(keys).toEqual(["jiraLimit", "jiraStartAt", "jiraIssueKey"]);
+  });
+
+  it("includes issue key and comment body for createComment", () => {
+    const keys = getJiraExpressionFields("createComment").map((field) => field.key);
+
+    expect(keys).toEqual(["jiraIssueKey", "jiraCommentBody"]);
+  });
+
+  it("includes issue key and comment id for getComment", () => {
+    const keys = getJiraExpressionFields("getComment").map((field) => field.key);
+
+    expect(keys).toEqual(["jiraIssueKey", "jiraCommentId"]);
+  });
+
+  it("includes comment id and body fields for updateComment", () => {
+    const keys = getJiraExpressionFields("updateComment").map((field) => field.key);
+
+    expect(keys).toEqual(["jiraIssueKey", "jiraCommentId", "jiraCommentBody"]);
+  });
+
+  it("includes issue key and comment id for deleteComment", () => {
+    const keys = getJiraExpressionFields("deleteComment").map((field) => field.key);
+
+    expect(keys).toEqual(["jiraIssueKey", "jiraCommentId"]);
+  });
+
+  it("includes issue key for listTransitions", () => {
+    const keys = getJiraExpressionFields("listTransitions").map((field) => field.key);
+
+    expect(keys).toEqual(["jiraIssueKey"]);
+  });
+
+  it("includes issue key and transition id for transitionIssue", () => {
+    const keys = getJiraExpressionFields("transitionIssue").map((field) => field.key);
+
+    expect(keys).toEqual(["jiraIssueKey", "jiraTransitionId"]);
+  });
+
+  it("includes attachment upload fields for addAttachment", () => {
+    const keys = getJiraExpressionFields("addAttachment").map((field) => field.key);
+
+    expect(keys).toEqual([
+      "jiraIssueKey",
+      "jiraAttachmentFilename",
+      "jiraAttachmentBase64",
+      "jiraAttachmentMimeType",
+    ]);
+  });
+
+  it("includes attachment id field for getAttachment", () => {
+    const keys = getJiraExpressionFields("getAttachment").map((field) => field.key);
+
+    expect(keys).toEqual(["jiraAttachmentId"]);
+  });
+
+  it("includes pagination and issue key for listAttachments", () => {
+    const keys = getJiraExpressionFields("listAttachments").map((field) => field.key);
+
+    expect(keys).toEqual(["jiraLimit", "jiraStartAt", "jiraIssueKey"]);
+  });
+
+  it("includes attachment id field for deleteAttachment", () => {
+    const keys = getJiraExpressionFields("deleteAttachment").map((field) => field.key);
+
+    expect(keys).toEqual(["jiraAttachmentId"]);
+  });
+
+  it("includes account id for getUser", () => {
+    const keys = getJiraExpressionFields("getUser").map((field) => field.key);
+
+    expect(keys).toEqual(["jiraAccountId"]);
+  });
+
+  it("includes user fields for createUser", () => {
+    const keys = getJiraExpressionFields("createUser").map((field) => field.key);
+
+    expect(keys).toEqual([
+      "jiraUserEmail",
+      "jiraUsername",
+      "jiraUserDisplayName",
+      "jiraUserProducts",
+    ]);
+  });
+
+  it("includes account id for deleteUser", () => {
+    const keys = getJiraExpressionFields("deleteUser").map((field) => field.key);
+
+    expect(keys).toEqual(["jiraAccountId"]);
+  });
+});
diff --git a/frontend/src/lib/jiraExpressionFields.ts b/frontend/src/lib/jiraExpressionFields.ts
new file mode 100644
index 00000000..c16cfe9b
--- /dev/null
+++ b/frontend/src/lib/jiraExpressionFields.ts
@@ -0,0 +1,124 @@
+import {
+  jiraAccountIdOperations,
+  jiraAttachmentIdOperations,
+  jiraCommentIdOperations,
+  jiraIssueKeyOperations,
+  jiraPaginatedOperations,
+  jiraStartAtPaginatedOperations,
+} from "@/components/Panels/propertiesPanel/operationOptions";
+
+export type JiraExpressionFieldKey =
+  | "jiraLimit"
+  | "jiraStartAt"
+  | "jiraNextPageToken"
+  | "jiraFields"
+  | "jiraProjectKey"
+  | "jiraIssueKey"
+  | "jiraIssueType"
+  | "jiraIssueTypeId"
+  | "jiraSummary"
+  | "jiraDescription"
+  | "jiraJql"
+  | "jiraAssigneeAccountId"
+  | "jiraLabels"
+  | "jiraCommentBody"
+  | "jiraCommentId"
+  | "jiraTransitionId"
+  | "jiraAttachmentId"
+  | "jiraAttachmentFilename"
+  | "jiraAttachmentBase64"
+  | "jiraAttachmentMimeType"
+  | "jiraNotifySubject"
+  | "jiraNotifyTextBody"
+  | "jiraNotifyHtmlBody"
+  | "jiraNotifyTo"
+  | "jiraAccountId"
+  | "jiraUsername"
+  | "jiraUserEmail"
+  | "jiraUserDisplayName"
+  | "jiraUserProducts";
+
+export interface JiraExpressionField {
+  key: JiraExpressionFieldKey;
+  label: string;
+}
+
+/** Returns ordered expression-evaluate dialog slots for the given Jira operation. */
+export function getJiraExpressionFields(operation: string): JiraExpressionField[] {
+  const op = operation || "searchIssues";
+  const fields: JiraExpressionField[] = [];
+
+  if (jiraPaginatedOperations.has(op)) {
+    fields.push({ key: "jiraLimit", label: "Limit" });
+    if (op === "searchIssues") {
+      fields.push({ key: "jiraNextPageToken", label: "Next Page Token" });
+    }
+    if (jiraStartAtPaginatedOperations.has(op)) {
+      fields.push({ key: "jiraStartAt", label: "Start At" });
+    }
+  }
+
+  if (op === "createIssue") {
+    fields.push({ key: "jiraProjectKey", label: "Project Key" });
+    fields.push({ key: "jiraIssueType", label: "Issue Type" });
+    fields.push({ key: "jiraIssueTypeId", label: "Issue Type ID" });
+  }
+
+  if (jiraIssueKeyOperations.has(op)) {
+    fields.push({ key: "jiraIssueKey", label: "Issue Key or ID" });
+  }
+
+  if (op === "searchIssues") {
+    fields.push({ key: "jiraJql", label: "JQL" });
+    fields.push({ key: "jiraFields", label: "Issue Fields" });
+  }
+
+  if (op === "createIssue" || op === "updateIssue") {
+    fields.push({ key: "jiraSummary", label: "Summary" });
+    fields.push({ key: "jiraDescription", label: "Description" });
+    fields.push({ key: "jiraAssigneeAccountId", label: "Assignee Account ID / Username" });
+    fields.push({ key: "jiraLabels", label: "Labels" });
+  }
+
+  if (jiraCommentIdOperations.has(op)) {
+    fields.push({ key: "jiraCommentId", label: "Comment ID" });
+  }
+
+  if (op === "createComment" || op === "updateComment") {
+    fields.push({ key: "jiraCommentBody", label: "Comment Body" });
+  }
+
+  if (op === "transitionIssue") {
+    fields.push({ key: "jiraTransitionId", label: "Transition ID" });
+  }
+
+  if (jiraAttachmentIdOperations.has(op)) {
+    fields.push({ key: "jiraAttachmentId", label: "Attachment ID" });
+  }
+
+  if (op === "addAttachment") {
+    fields.push({ key: "jiraAttachmentFilename", label: "Attachment Filename" });
+    fields.push({ key: "jiraAttachmentBase64", label: "Attachment Base64" });
+    fields.push({ key: "jiraAttachmentMimeType", label: "Attachment MIME Type" });
+  }
+
+  if (op === "notifyIssue") {
+    fields.push({ key: "jiraNotifySubject", label: "Subject" });
+    fields.push({ key: "jiraNotifyTextBody", label: "Text Body" });
+    fields.push({ key: "jiraNotifyHtmlBody", label: "HTML Body" });
+    fields.push({ key: "jiraNotifyTo", label: "Recipients JSON" });
+  }
+
+  if (jiraAccountIdOperations.has(op)) {
+    fields.push({ key: "jiraAccountId", label: "Account ID / Username" });
+  }
+
+  if (op === "createUser") {
+    fields.push({ key: "jiraUserEmail", label: "User Email" });
+    fields.push({ key: "jiraUsername", label: "Username" });
+    fields.push({ key: "jiraUserDisplayName", label: "Display Name" });
+    fields.push({ key: "jiraUserProducts", label: "Products" });
+  }
+
+  return fields;
+}
diff --git a/frontend/src/lib/nodeIcons.ts b/frontend/src/lib/nodeIcons.ts
index 38cba5c3..e61ae8a1 100644
--- a/frontend/src/lib/nodeIcons.ts
+++ b/frontend/src/lib/nodeIcons.ts
@@ -80,6 +80,7 @@ export const nodeIcons: Record<NodeType, ReturnType<typeof Type>> = {
   rag: Search,
   grist: Table2,
   github: Github,
+  jira: ListTodo,
   linear: ListTodo,
   googleSheets: Sheet,
   bigquery: Database,
@@ -137,6 +138,7 @@ export const nodeIconColorClass: Record<NodeType, string> = {
   rag: "text-node-rag",
   grist: "text-node-grist",
   github: "text-node-github",
+  jira: "text-node-jira",
   linear: "text-node-linear",
   googleSheets: "text-node-google-sheets",
   bigquery: "text-node-google-sheets",
diff --git a/frontend/src/stores/workflow.ts b/frontend/src/stores/workflow.ts
index 087985f6..f8ee4197 100644
--- a/frontend/src/stores/workflow.ts
+++ b/frontend/src/stores/workflow.ts
@@ -2455,6 +2455,163 @@ export const useWorkflowStore = defineStore("workflow", () => {
         }
       }
 
+      if (node.type === "jira") {
+        const operation = node.data.jiraOperation;
+        if (!node.data.credentialId || !isValidUUID(node.data.credentialId)) {
+          errors.push({
+            nodeId: node.id,
+            nodeLabel: node.data.label,
+            nodeType: "Jira",
+            message: "Credential is not selected",
+          });
+        }
+        if (!operation) {
+          errors.push({
+            nodeId: node.id,
+            nodeLabel: node.data.label,
+            nodeType: "Jira",
+            message: "Operation is not selected",
+          });
+        }
+        if (
+          operation === "createIssue" &&
+          (!node.data.jiraProjectKey?.trim() || !node.data.jiraSummary?.trim())
+        ) {
+          errors.push({
+            nodeId: node.id,
+            nodeLabel: node.data.label,
+            nodeType: "Jira",
+            message: "Project key and summary are required to create an issue",
+          });
+        }
+        if (operation === "updateIssue") {
+          const hasUpdateField =
+            !!node.data.jiraSummary?.trim() ||
+            !!node.data.jiraDescription?.trim() ||
+            !!node.data.jiraAssigneeAccountId?.trim() ||
+            !!node.data.jiraLabels?.trim();
+          if (!hasUpdateField) {
+            errors.push({
+              nodeId: node.id,
+              nodeLabel: node.data.label,
+              nodeType: "Jira",
+              message: "At least one field to update is required",
+            });
+          }
+        }
+        if (
+          (
+            operation === "getIssue" ||
+            operation === "updateIssue" ||
+            operation === "deleteIssue" ||
+            operation === "getIssueChangelog" ||
+            operation === "notifyIssue" ||
+            operation === "listComments" ||
+            operation === "createComment" ||
+            operation === "getComment" ||
+            operation === "updateComment" ||
+            operation === "deleteComment" ||
+            operation === "listTransitions" ||
+            operation === "transitionIssue" ||
+            operation === "addAttachment" ||
+            operation === "listAttachments"
+          ) &&
+          !node.data.jiraIssueKey?.trim()
+        ) {
+          errors.push({
+            nodeId: node.id,
+            nodeLabel: node.data.label,
+            nodeType: "Jira",
+            message: "Issue key or ID is required for this operation",
+          });
+        }
+        if (
+          (operation === "getComment" ||
+            operation === "updateComment" ||
+            operation === "deleteComment") &&
+          !node.data.jiraCommentId?.trim()
+        ) {
+          errors.push({
+            nodeId: node.id,
+            nodeLabel: node.data.label,
+            nodeType: "Jira",
+            message: "Comment ID is required",
+          });
+        }
+        if (
+          (operation === "createComment" || operation === "updateComment") &&
+          !node.data.jiraCommentBody?.trim()
+        ) {
+          errors.push({
+            nodeId: node.id,
+            nodeLabel: node.data.label,
+            nodeType: "Jira",
+            message: "Comment body is required",
+          });
+        }
+        if (
+          operation === "notifyIssue" &&
+          (!node.data.jiraNotifySubject?.trim() || !node.data.jiraNotifyTextBody?.trim())
+        ) {
+          errors.push({
+            nodeId: node.id,
+            nodeLabel: node.data.label,
+            nodeType: "Jira",
+            message: "Notification subject and text body are required",
+          });
+        }
+        if (operation === "transitionIssue" && !node.data.jiraTransitionId?.trim()) {
+          errors.push({
+            nodeId: node.id,
+            nodeLabel: node.data.label,
+            nodeType: "Jira",
+            message: "Transition ID is required",
+          });
+        }
+        if (
+          (operation === "getAttachment" || operation === "deleteAttachment") &&
+          !node.data.jiraAttachmentId?.trim()
+        ) {
+          errors.push({
+            nodeId: node.id,
+            nodeLabel: node.data.label,
+            nodeType: "Jira",
+            message: "Attachment ID is required",
+          });
+        }
+        if (
+          operation === "addAttachment" &&
+          (!node.data.jiraAttachmentFilename?.trim() ||
+            !node.data.jiraAttachmentBase64?.trim())
+        ) {
+          errors.push({
+            nodeId: node.id,
+            nodeLabel: node.data.label,
+            nodeType: "Jira",
+            message: "Attachment filename and base64 content are required",
+          });
+        }
+        if (
+          (operation === "getUser" || operation === "deleteUser") &&
+          !node.data.jiraAccountId?.trim()
+        ) {
+          errors.push({
+            nodeId: node.id,
+            nodeLabel: node.data.label,
+            nodeType: "Jira",
+            message: "Account ID is required",
+          });
+        }
+        if (operation === "createUser" && !node.data.jiraUserEmail?.trim()) {
+          errors.push({
+            nodeId: node.id,
+            nodeLabel: node.data.label,
+            nodeType: "Jira",
+            message: "User email is required",
+          });
+        }
+      }
+
       if (node.type === "sentry") {
         const operation = node.data.sentryOperation;
 
diff --git a/frontend/src/styles/globals.css b/frontend/src/styles/globals.css
index 3e9cd0af..1fef03f5 100644
--- a/frontend/src/styles/globals.css
+++ b/frontend/src/styles/globals.css
@@ -67,6 +67,7 @@
     --node-rag: 252 87% 62%;
     --node-grist: 162 94% 35%;
     --node-github: 222 47% 25%;
+    --node-jira: 217 91% 50%;
     --node-linear: 252 83% 58%;
     --node-google-sheets: 153 82% 33%;
     --node-datatable: 190 95% 39%;
@@ -141,6 +142,7 @@
     --node-rag: 252 87% 67%;
     --node-grist: 162 94% 45%;
     --node-github: 210 30% 78%;
+    --node-jira: 217 91% 62%;
     --node-linear: 252 83% 68%;
     --node-google-sheets: 153 82% 42%;
     --node-datatable: 190 95% 49%;
diff --git a/frontend/src/types/credential.ts b/frontend/src/types/credential.ts
index 72fad014..44e712ac 100644
--- a/frontend/src/types/credential.ts
+++ b/frontend/src/types/credential.ts
@@ -3,6 +3,7 @@ export type CredentialType =
   | "codex"
   | "google"
   | "github"
+  | "jira"
   | "linear"
   | "custom"
   | "bearer"
@@ -96,6 +97,14 @@ export interface CredentialConfigGitHub {
   base_url?: string;
 }
 
+export interface CredentialConfigJira {
+  email: string;
+  api_token: string;
+  base_url: string;
+  deployment?: "cloud" | "data_center";
+  api_version?: string;
+}
+
 export interface CredentialConfigLinear {
   api_key?: string;
   auth_mode?: "api_key" | "oauth";
@@ -249,6 +258,7 @@ export type CredentialConfig =
   | CredentialConfigCodex
   | CredentialConfigGoogle
   | CredentialConfigGitHub
+  | CredentialConfigJira
   | CredentialConfigLinear
   | CredentialConfigCustom
   | CredentialConfigBearer
@@ -348,6 +358,7 @@ export const CREDENTIAL_TYPE_LABELS: Record<CredentialType, string> = {
   codex: "OpenAI Codex",
   google: "Google AI",
   github: "GitHub",
+  jira: "Jira",
   linear: "Linear",
   custom: "Custom (OpenAI Compatible)",
   bearer: "Authorization Bearer Token",
@@ -381,6 +392,7 @@ export const CREDENTIAL_TYPE_DESCRIPTIONS: Record<CredentialType, string> = {
   codex: "Use a ChatGPT/Codex access token for the local Codex runner",
   google: "Connect to Google AI for Gemini models",
   github: "Store a GitHub personal access token for GitHub API, MCP, and agent workflows",
+  jira: "Connect to Jira for project, issue, comment, attachment, user, notification, and transition automation",
   linear: "Connect to Linear for workspace, project, issue, and comment automation",
   custom: "Connect to any OpenAI-compatible API endpoint",
   bearer: "Store a Bearer token for Authorization header",
diff --git a/frontend/src/types/node.ts b/frontend/src/types/node.ts
index f82837aa..920027f7 100644
--- a/frontend/src/types/node.ts
+++ b/frontend/src/types/node.ts
@@ -635,6 +635,50 @@ export const NODE_DEFINITIONS: Record<NodeType, NodeDefinition> = {
       linearReturnAll: false,
     },
   },
+  jira: {
+    type: "jira",
+    label: "Jira",
+    description: "Manage Jira projects, issues, comments, attachments, users, notifications, and transitions",
+    color: "node-jira",
+    icon: "ListTodo",
+    inputs: 1,
+    outputs: 1,
+    defaultData: {
+      label: "jira",
+      credentialId: "",
+      jiraOperation: "searchIssues",
+      jiraProjectKey: "",
+      jiraIssueKey: "",
+      jiraIssueType: "Task",
+      jiraIssueTypeId: "",
+      jiraSummary: "",
+      jiraDescription: "$input.text",
+      jiraJql: "updated >= -30d ORDER BY updated DESC",
+      jiraFields: "",
+      jiraAssigneeAccountId: "",
+      jiraLabels: "",
+      jiraCommentBody: "$input.text",
+      jiraCommentId: "",
+      jiraTransitionId: "",
+      jiraAttachmentId: "",
+      jiraAttachmentFilename: "",
+      jiraAttachmentBase64: "",
+      jiraAttachmentMimeType: "",
+      jiraIncludeBinary: false,
+      jiraNotifySubject: "",
+      jiraNotifyTextBody: "$input.text",
+      jiraNotifyHtmlBody: "",
+      jiraNotifyTo: "{\"assignee\":true}",
+      jiraAccountId: "",
+      jiraUsername: "",
+      jiraUserEmail: "",
+      jiraUserDisplayName: "",
+      jiraUserProducts: "",
+      jiraLimit: "50",
+      jiraStartAt: "0",
+      jiraNextPageToken: "",
+    },
+  },
   googleSheets: {
     type: "googleSheets",
     label: "Google Sheets",
diff --git a/frontend/src/types/workflow.ts b/frontend/src/types/workflow.ts
index b6afe125..c2eb30c2 100644
--- a/frontend/src/types/workflow.ts
+++ b/frontend/src/types/workflow.ts
@@ -160,6 +160,7 @@ export type NodeType =
   | "rag"
   | "grist"
   | "github"
+  | "jira"
   | "linear"
   | "googleSheets"
   | "bigquery"
@@ -622,6 +623,60 @@ export interface NodeData {
   linearLimit?: string;
   linearAfter?: string;
   linearReturnAll?: boolean;
+  jiraOperation?:
+    | "getMyself"
+    | "listProjects"
+    | "searchIssues"
+    | "getIssue"
+    | "createIssue"
+    | "updateIssue"
+    | "deleteIssue"
+    | "getIssueChangelog"
+    | "notifyIssue"
+    | "listComments"
+    | "createComment"
+    | "getComment"
+    | "updateComment"
+    | "deleteComment"
+    | "listTransitions"
+    | "transitionIssue"
+    | "addAttachment"
+    | "getAttachment"
+    | "listAttachments"
+    | "deleteAttachment"
+    | "getUser"
+    | "createUser"
+    | "deleteUser";
+  jiraProjectKey?: string;
+  jiraIssueKey?: string;
+  jiraIssueType?: string;
+  jiraIssueTypeId?: string;
+  jiraSummary?: string;
+  jiraDescription?: string;
+  jiraJql?: string;
+  jiraFields?: string;
+  jiraAssigneeAccountId?: string;
+  jiraLabels?: string;
+  jiraCommentBody?: string;
+  jiraCommentId?: string;
+  jiraTransitionId?: string;
+  jiraAttachmentId?: string;
+  jiraAttachmentFilename?: string;
+  jiraAttachmentBase64?: string;
+  jiraAttachmentMimeType?: string;
+  jiraIncludeBinary?: boolean;
+  jiraNotifySubject?: string;
+  jiraNotifyTextBody?: string;
+  jiraNotifyHtmlBody?: string;
+  jiraNotifyTo?: string;
+  jiraAccountId?: string;
+  jiraUsername?: string;
+  jiraUserEmail?: string;
+  jiraUserDisplayName?: string;
+  jiraUserProducts?: string;
+  jiraLimit?: string;
+  jiraStartAt?: string;
+  jiraNextPageToken?: string;
   errorMessage?: string;
   httpStatusCode?: number;
   retryEnabled?: boolean;