@openhands/extensions 0.28.0 → 0.30.0

package/skills/jira-issue-to-pr/scripts/main.py

@@ -2,19 +2,26 @@
 Jira issue-to-PR poller — reads all configuration from config.json in the same directory.
 
 config.json fields:
-  jira_base_url          e.g. "https://yourcompany.atlassian.net"
-  jira_email             Atlassian account email used for Basic auth
+  jira_mcp_server        Settings name of the connected Atlassian Rovo MCP server. When set,
+                         Jira is reached through it (OpenHands Cloud and Enterprise only)
+                         and no Jira credential is configured here
+  jira_cloud_id          Atlassian cloud id of the Jira site; required with jira_mcp_server
+  jira_base_url          e.g. "https://yourcompany.atlassian.net"; without jira_mcp_server
+  jira_email             Atlassian account email used for Basic auth; without jira_mcp_server
   jira_token_secret      Name of the OpenHands secret holding the Jira API token
   jira_label             Label to watch for (default: "create-pr")
   max_new_per_run        Max conversations dispatched per run (default: 5)
+  git_provider           Where the ticket's repository lives: "github" (default), "gitlab"
+                         or "bitbucket". It only changes what the conversation is asked
 
-The target GitHub repository is NOT configured here. Each Jira ticket body must include
-the repo in "owner/repo" format; the spawned agent extracts it from the ticket text.
+The target repository is NOT configured here. Each Jira ticket body must name it
+(owner/repo on GitHub, group/project or a URL on GitLab, workspace/repo on Bitbucket);
+the spawned agent extracts it from the ticket text.
 
 Runs against a local agent server (AGENT_SERVER_URL is injected) or on OpenHands Cloud
 (OPENHANDS_CLOUD_API_URL / OPENHANDS_API_KEY / SANDBOX_ID are injected instead).
 """
-import base64, json, os, re, sys, tempfile, urllib.error, urllib.request, uuid
+import base64, json, os, re, sys, tempfile, urllib.error, urllib.parse, urllib.request, uuid
 from datetime import datetime, timezone
 from pathlib import Path
 
@@ -23,11 +30,67 @@ _HERE = Path(__file__).parent
 with open(_HERE / "config.json") as _f:
     _cfg = json.load(_f)
 
-JIRA_BASE_URL      = _cfg["jira_base_url"].rstrip("/")
-JIRA_EMAIL         = _cfg["jira_email"]
+# Jira is reached through this connected MCP server when it is named, and through
+# Jira's REST API with an API token otherwise.
+JIRA_MCP_SERVER    = _cfg.get("jira_mcp_server")
+JIRA_CLOUD_ID      = _cfg["jira_cloud_id"] if JIRA_MCP_SERVER else None
+JIRA_BASE_URL      = None if JIRA_MCP_SERVER else _cfg["jira_base_url"].rstrip("/")
+JIRA_EMAIL         = None if JIRA_MCP_SERVER else _cfg["jira_email"]
 JIRA_TOKEN_SECRET  = _cfg.get("jira_token_secret", "JIRA_CLOUD_KEY")
 JIRA_LABEL         = _cfg.get("jira_label", "create-pr")
+# Atlassian renamed the comment tool in v2 of its MCP server and moves v1 connections
+# to the v2 tools on its own schedule, so a deployment can meet either name.
+JIRA_COMMENT_TOOLS = ("addOrEditJiraIssueComment", "addCommentToJiraIssue")
 MAX_NEW_PER_RUN    = int(_cfg.get("max_new_per_run", 5))
+GIT_PROVIDER       = _cfg.get("git_provider", "github")
+# What the conversation is told about the provider the ticket names its repository on.
+# Only the prompt differs: the conversation pushes with the user's connected integration,
+# and without one it delivers through the tools of the connected MCP server instead.
+GIT_PROVIDERS = {
+    "github": {
+        "name":      "GitHub",
+        "request":   "Pull Request",
+        "short":     "PR",
+        "reference": '"owner/repo" format (e.g. "acme-org/backend") or a full GitHub URL\n'
+                     '   (e.g. "https://github.com/acme-org/backend")',
+        "clone":     "https://github.com/<owner>/<repo>",
+        "delivery":  "",
+    },
+    "gitlab": {
+        "name":      "GitLab",
+        "request":   "Merge Request",
+        "short":     "MR",
+        "reference": '"group/project" format, subgroups included (e.g. "acme-org/platform/backend"),\n'
+                     '   or a full GitLab URL, which may be on a self-managed host\n'
+                     '   (e.g. "https://gitlab.example.com/acme-org/platform/backend")',
+        "clone":     "https://gitlab.com/<group>/<project>, or the host the ticket's URL names",
+        "delivery":  """
+Delivering through GitLab:
+- If GitLab tools from a connected MCP server are available to you, prefer them for reading
+  the issue and for opening the merge request.
+- Without a `GITLAB_TOKEN` you cannot push with git: create the branch with `add_branch`,
+  commit your changes with `add_commit` (one call, a file action per changed file), and open
+  the merge request with `save_merge_request`. A private project cannot be cloned without a
+  credential; read it with `list_repository_tree` and `get_repository_file` instead.
+""",
+    },
+    "bitbucket": {
+        "name":      "Bitbucket",
+        "request":   "Pull Request",
+        "short":     "PR",
+        "reference": '"workspace/repo" format (e.g. "acme-org/backend") or a full Bitbucket URL\n'
+                     '   (e.g. "https://bitbucket.org/acme-org/backend")',
+        "clone":     "https://bitbucket.org/<workspace>/<repo>",
+        "delivery":  """
+Delivering through Bitbucket:
+- Without a `BITBUCKET_TOKEN`, use the Bitbucket tools of the connected Atlassian Rovo MCP
+  server: read the repository with `getBitbucketRepoFileContent`, create the branch with
+  `createBitbucketRepoBranch`, commit your changes with `createBitbucketRepoCommit`, and open
+  the pull request with `createBitbucketRepoPullRequest`. Tools the server does not list
+  directly are reached through `discover` and `executeRead` / `executeWrite`.
+""",
+    },
+}
 # How often a conversation that OpenHands Cloud failed to start is started again.
 MAX_START_ATTEMPTS = 3
 
@@ -163,14 +226,39 @@ def extract_adf_text(adf):
     return " ".join(p for p in parts if p).strip()
 
 
+def call_mcp_tool(name, arguments):
+    """Call a tool on the connected MCP server and return its text output.
+
+    OpenHands makes the call with the credentials the user stored when connecting
+    the server, so this run holds no Jira credential of its own.
+    """
+    server = urllib.parse.quote(JIRA_MCP_SERVER, safe="")
+    result = _cloud_request("POST", f"/api/v1/mcp/servers/{server}/call-tool", {
+        "name": name, "arguments": arguments,
+    })
+    if result.get("is_error"):
+        raise RuntimeError(f"{name} failed: {str(result.get('text'))[:500]}")
+    return result.get("text") or ""
+
+
 def fetch_labeled_issues(auth_header):
-    """Return open Jira issues with JIRA_LABEL using the current v3 search endpoint."""
-    url  = f"{JIRA_BASE_URL}/rest/api/3/search/jql"
-    body = json.dumps({
+    """Return open Jira issues with JIRA_LABEL.
+
+    Uses the connected MCP server's JQL search, or the current v3 search endpoint.
+    """
+    search = {
         "jql":        f'labels = "{JIRA_LABEL}" AND statusCategory != Done',
         "fields":     ["key", "summary", "description", "status", "updated"],
         "maxResults": 50,
-    }).encode()
+    }
+    if JIRA_MCP_SERVER:
+        text = call_mcp_tool("searchJiraIssuesUsingJql", {"cloudId": JIRA_CLOUD_ID, **search})
+        try:
+            return json.loads(text).get("issues", [])
+        except (ValueError, AttributeError) as exc:
+            raise RuntimeError(f"Unexpected Jira search result: {text[:500]}") from exc
+    url  = f"{JIRA_BASE_URL}/rest/api/3/search/jql"
+    body = json.dumps(search).encode()
     req = urllib.request.Request(
         url, data=body,
         headers={
@@ -188,7 +276,19 @@ def fetch_labeled_issues(auth_header):
 
 
 def post_jira_comment(issue_key, auth_header, text):
-    """Post a plain-text comment on a Jira issue using ADF."""
+    """Post a plain-text comment on a Jira issue."""
+    if JIRA_MCP_SERVER:
+        errors = []
+        for tool in JIRA_COMMENT_TOOLS:
+            try:
+                call_mcp_tool(tool, {
+                    "cloudId": JIRA_CLOUD_ID, "issueIdOrKey": issue_key, "commentBody": text,
+                })
+                return
+            except RuntimeError as exc:
+                errors.append(str(exc))
+        print(f"Warning: failed to post Jira comment on {issue_key}: {'; '.join(errors)}")
+        return
     url  = f"{JIRA_BASE_URL}/rest/api/3/issue/{issue_key}/comment"
     body = json.dumps({
         "body": {
@@ -321,10 +421,21 @@ try:
         raise RuntimeError("The automation KV store is required on OpenHands Cloud, "
                            "but AUTOMATION_KV_TOKEN is not set for this run.")
 
-    jira_token  = get_secret(JIRA_TOKEN_SECRET)
-    auth_header = "Basic " + base64.b64encode(
-        f"{JIRA_EMAIL}:{jira_token}".encode()
-    ).decode()
+    if GIT_PROVIDER not in GIT_PROVIDERS:
+        raise RuntimeError(f"Unknown git_provider {GIT_PROVIDER!r}; "
+                           f"expected one of: {', '.join(GIT_PROVIDERS)}")
+    git = GIT_PROVIDERS[GIT_PROVIDER]
+
+    auth_header = None
+    if not JIRA_MCP_SERVER:
+        jira_token  = get_secret(JIRA_TOKEN_SECRET)
+        auth_header = "Basic " + base64.b64encode(
+            f"{JIRA_EMAIL}:{jira_token}".encode()
+        ).decode()
+    elif IS_LOCAL:
+        # Only OpenHands Cloud and Enterprise call a connected MCP server for a run.
+        raise RuntimeError("jira_mcp_server needs OpenHands Cloud or Enterprise; "
+                           "a local run reaches Jira with jira_token_secret.")
 
     state          = load_state()
     processed_keys = set(state.get("processed_keys", []))
@@ -343,7 +454,7 @@ try:
     if not IS_LOCAL:
         settle_cloud_starts(state, processed_keys, auth_header)
 
-    print(f"Polling {JIRA_BASE_URL} for issues labeled '{JIRA_LABEL}'…")
+    print(f"Polling {JIRA_BASE_URL or JIRA_MCP_SERVER} for issues labeled '{JIRA_LABEL}'…")
     issues = fetch_labeled_issues(auth_header)
     print(f"Total matching issues : {len(issues)}")
 
@@ -393,28 +504,27 @@ try:
         description = extract_adf_text(issue["fields"].get("description"))
         branch      = f"jira/{key.lower()}"
 
-        prompt = f"""Create a GitHub Pull Request for the following Jira issue.
+        prompt = f"""Create a {git['name']} {git['request']} for the following Jira issue.
 
 Jira Issue : {key}
 Summary    : {summary}
 Description: {description or "No description provided."}
 
 Steps:
-1. Find the target GitHub repository in the Description above. Look for a reference in
-   "owner/repo" format (e.g. "acme-org/backend") or a full GitHub URL
-   (e.g. "https://github.com/acme-org/backend"). Use that repository.
+1. Find the target {git['name']} repository in the Description above. Look for a reference in
+   {git['reference']}. Use that repository.
    If no repository is mentioned, create a file `jira/{key}/notes.md` with the issue
-   details and print a message explaining that no GitHub repo was found in the ticket.
-2. Clone the repository (e.g. https://github.com/<owner>/<repo>).
+   details and print a message explaining that no {git['name']} repo was found in the ticket.
+2. Clone the repository (e.g. {git['clone']}).
 3. Create branch `{branch}` from the default branch.
 4. Implement the changes described in the issue.
    If the description is vague or missing, create `jira/{key}/notes.md`
    with the issue key, summary, and description as a placeholder.
-5. Commit, push the branch, and open a Pull Request:
+5. Commit, push the branch, and open a {git['request']}:
    - Title : [{key}] {summary}
    - Body  : Reference the Jira issue key and describe the changes made.
-6. Print the PR URL when done.
-"""
+6. Print the {git['short']} URL when done.
+{git['delivery']}"""
         if IS_LOCAL:
             workdir = tempfile.mkdtemp(prefix=f"jira-{key.lower()}-")
             payload = {

package/skills/openhands-automation/references/custom-automation.md

@@ -249,6 +249,7 @@ uv pip install -q openhands-sdk openhands-workspace openhands-tools
 import os
 
 from openhands.sdk import Conversation
+from openhands.sdk.automation import automation_conversation_kwargs
 from openhands.tools.preset.default import get_default_agent
 from openhands.workspace import OpenHandsCloudWorkspace
 
@@ -266,13 +267,48 @@ with OpenHandsCloudWorkspace(
 ) as workspace:
     llm = workspace.get_llm()
     agent = get_default_agent(llm=llm, cli_mode=True)
-    conversation = Conversation(agent=agent, workspace=workspace)
+    conversation = Conversation(
+        agent=agent,
+        workspace=workspace,
+        **automation_conversation_kwargs(),
+    )
     conversation.send_message("Your automation prompt here")
     conversation.run()
     conversation.close()
 # OpenHandsCloudWorkspace.__exit__ fires the completion callback here.
 ```
 
+### Link automation conversations to run telemetry
+
+When an automation script starts a conversation, preserve the trace context that the automation service injected into the run. This links the conversation span to the triggering webhook, scheduler dispatch, and run record.
+
+- SDK conversations: pass `**automation_conversation_kwargs()` into every `Conversation(...)` call.
+- Direct agent-server API calls: merge `automation_observability_headers()` into the headers for each `POST /api/conversations` request.
+- If you add your own conversation tags, pass them through `conversation_tags={...}` instead of replacing the helper output.
+
+```python
+from openhands.sdk import Conversation
+from openhands.sdk.automation import (
+    automation_conversation_kwargs,
+    automation_observability_headers,
+)
+
+conversation = Conversation(
+    agent=agent,
+    workspace=workspace,
+    **automation_conversation_kwargs(),
+)
+
+headers = {
+    "X-Session-API-Key": api_key,
+    **automation_observability_headers(span_name="automation.conversation"),
+}
+# Use these headers when creating a backend conversation directly.
+# httpx.post(f"{agent_url}/api/conversations", headers=headers, json=payload)
+```
+
+The built-in prompt and plugin presets use this helper. Custom scripts should do the same for every new conversation so traces, observability metadata, and automation conversation tags stay attached.
+
 ### Selecting an LLM profile
 
 The automation service injects an `AUTOMATION_MODEL` environment variable holding the **LLM profile name** the automation should run with. This is the profile a user selects when editing the automation, or — when none is selected — a snapshot of the user's active profile taken when the automation was created. To honor it on every run, read `AUTOMATION_MODEL` and pass it to `workspace.get_llm(profile_name=...)`:
@@ -299,13 +335,27 @@ Conversations started during a run remain accessible in the OpenHands UI after t
 
 ```python
 # Default: conversation persists after close (users can view/continue it)
-conversation = Conversation(agent=agent, workspace=workspace)
+conversation = Conversation(
+    agent=agent,
+    workspace=workspace,
+    **automation_conversation_kwargs(),
+)
 
 # Explicitly persist (same as default)
-conversation = Conversation(agent=agent, workspace=workspace, delete_on_close=False)
+conversation = Conversation(
+    agent=agent,
+    workspace=workspace,
+    delete_on_close=False,
+    **automation_conversation_kwargs(),
+)
 
 # Delete conversation resources on close
-conversation = Conversation(agent=agent, workspace=workspace, delete_on_close=True)
+conversation = Conversation(
+    agent=agent,
+    workspace=workspace,
+    delete_on_close=True,
+    **automation_conversation_kwargs(),
+)
 ```
 
 The agent server itself persists until it times out or is manually deleted; this is managed by the automation service, not by the workspace.
@@ -339,7 +389,11 @@ else:
     with OpenHandsCloudWorkspace(local_agent_server_mode=True, cloud_api_url=api_url, cloud_api_key=api_key) as workspace:
         llm = workspace.get_llm()
         agent = get_default_agent(llm=llm, cli_mode=True)
-        conversation = Conversation(agent=agent, workspace=workspace)
+        conversation = Conversation(
+            agent=agent,
+            workspace=workspace,
+            **automation_conversation_kwargs(),
+        )
         conversation.send_message(f"Investigate these alerts and open GitHub issues: {alerts}")
         conversation.run()
         conversation.close()
@@ -358,7 +412,11 @@ from openhands.sdk.conversation.state import ConversationExecutionStatus
 with OpenHandsCloudWorkspace(local_agent_server_mode=True, cloud_api_url=api_url, cloud_api_key=api_key) as workspace:
     llm = workspace.get_llm()
     agent = get_default_agent(llm=llm, cli_mode=True)
-    conversation = Conversation(agent=agent, workspace=workspace)
+    conversation = Conversation(
+        agent=agent,
+        workspace=workspace,
+        **automation_conversation_kwargs(),
+    )
     conversation.send_message("Run a long analysis task")
     # Conversation is now running asynchronously in the agent server.
 
@@ -404,7 +462,12 @@ stop_hook = HookConfig(
 with OpenHandsCloudWorkspace(local_agent_server_mode=True, cloud_api_url=api_url, cloud_api_key=api_key) as workspace:
     llm = workspace.get_llm()
     agent = get_default_agent(llm=llm, cli_mode=True)
-    conversation = Conversation(agent=agent, workspace=workspace, hook_config=stop_hook)
+    conversation = Conversation(
+        agent=agent,
+        workspace=workspace,
+        hook_config=stop_hook,
+        **automation_conversation_kwargs(),
+    )
     conversation.send_message("Do some long-running work")
     # Don't call run() — the conversation runs asynchronously.
     # When the agent stops, the stop hook will fire the callback.
@@ -765,6 +828,7 @@ import os
 import json
 
 from openhands.sdk import Conversation
+from openhands.sdk.automation import automation_conversation_kwargs
 from openhands.tools.preset.default import get_default_agent
 from openhands.workspace import OpenHandsCloudWorkspace
 
@@ -781,7 +845,11 @@ with OpenHandsCloudWorkspace(
 ) as workspace:
     llm = workspace.get_llm()
     agent = get_default_agent(llm=llm, cli_mode=True)
-    conversation = Conversation(agent=agent, workspace=workspace)
+    conversation = Conversation(
+        agent=agent,
+        workspace=workspace,
+        **automation_conversation_kwargs(),
+    )
     conversation.send_message("Generate a weekly status report")
     conversation.run()
     conversation.close()

package/skills/slack-channel-monitor/README.md

@@ -37,12 +37,17 @@ This skill is activated by keywords:
   thread immediately on trigger detection
 - **Automatic summaries**: when the conversation reaches a terminal state the
   agent's final response is posted back to the thread; error/stuck states
-  receive a clear error notice
+  receive a clear error notice, and every result shows the LLM settings source
+  and concrete model
 - **Persistent state**: conversation tracking and poll timestamps are stored
   in `automation-state/slack_poller_{automation_id}.json` across runs
 
 ## Prerequisites
 
+The footer reports `default` and the concrete model from the server settings
+already used to start the conversation. Follow-up replies keep those recorded
+values because they reuse the same conversation.
+
 Set at least one of the following in **OpenHands Settings - Secrets**:
 
 | Secret | Token type | Minimum scopes |

package/skills/slack-channel-monitor/SKILL.md

@@ -251,14 +251,17 @@ Each cron run executes `main.py`, which runs **10 polling iterations** (every
      ignored.
    - Contains trigger phrase outside a tracked conversation → 👀 reaction, create
      a new conversation, post link.
+     - Records `default` and the concrete model from the server settings already
+       used to start the conversation, for the response footer.
      - Thread replies: agent receives full thread history for context.
      - Root messages: agent receives the trigger text only.
 6. **Checks conversation statuses**  -  for each active conversation where
    `time.time() - last_activity > 15 s`:
    - If status is `idle`, `finished`, `error`, or `stuck` → fetch the agent's
-     final response via `/api/conversations/{id}/agent_final_response` and post
-     it to the Slack thread using Slack's `markdown_text` field so Markdown
-     formatting renders correctly. Mark the record `watching` for five minutes
+     final response via `/api/conversations/{id}/agent_final_response`, append
+     the LLM profile and model, and post it to the Slack thread using Slack's
+     `markdown_text` field so Markdown formatting renders correctly. Mark the
+     record `watching` for five minutes
      so triggered follow-up replies can continue the same conversation.
 7. **Advances `last_poll`** to `now - 10 s` (overlap window prevents boundary
    races). If a conversation creation failed, pins `last_poll` further back to

package/skills/slack-channel-monitor/scripts/main.py

@@ -33,6 +33,7 @@ Optional secret:
 
 import json
 import os
+import re
 import sys
 import time
 import urllib.error
@@ -577,7 +578,12 @@ def _build_secrets_payload(agent_url: str, api_key: str) -> dict:
     return secrets
 
 
-def create_conversation(agent_url: str, api_key: str, initial_message: str) -> str:
+def create_conversation(
+    agent_url: str,
+    api_key: str,
+    initial_message: str,
+    agent: dict | None = None,
+) -> str:
     """Create a conversation and return its ID.
 
     The server auto-starts the agent when initial_message is provided
@@ -597,10 +603,9 @@ def create_conversation(agent_url: str, api_key: str, initial_message: str) -> s
     workspace_dir = os.path.join(root, "slack-monitor-conversations")
     os.makedirs(workspace_dir, exist_ok=True)
 
-    agent = _get_agent_dict(agent_url, api_key)
     payload: dict = {
         "workspace": {"working_dir": workspace_dir},
-        "agent": agent,
+        "agent": agent or _get_agent_dict(agent_url, api_key),
         "initial_message": {"content": [{"text": initial_message}]},
     }
 
@@ -639,6 +644,20 @@ def conversation_final_response(agent_url: str, api_key: str, conv_id: str) -> s
     return result.get("response", "")
 
 
+def _llm_provenance(profile: str, model: str) -> str:
+    return f"LLM profile: `{profile}` · Model: `{model}`"
+
+
+def _with_llm_provenance(body: str, profile: str, model: str) -> str:
+    provenance = _llm_provenance(profile, model)
+    body = "\n".join(
+        line
+        for line in (body or "").splitlines()
+        if not re.fullmatch(r"LLM profile: .* · Model: .*", line.strip())
+    ).strip()
+    return f"{body}\n\n{provenance}" if body else provenance
+
+
 # ── Message filtering ──────────────────────────────────────────────────────────
 
 def _is_human_message(msg: dict, bot_user_id: str, bot_message_ts: list[str]) -> bool:
@@ -937,7 +956,10 @@ def _process_trigger_message(
     )
 
     try:
-        conv_id = create_conversation(agent_url, api_key, initial_prompt)
+        agent = _get_agent_dict(agent_url, api_key)
+        conv_id = create_conversation(
+            agent_url, api_key, initial_prompt, agent=agent
+        )
         conv_url = f"{openhands_url}/conversations/{conv_id}"
 
         now = time.time()
@@ -946,6 +968,8 @@ def _process_trigger_message(
             "channel_id": channel_id,
             "thread_ts": thread_root,
             "status": "active",
+            "llm_profile": "default",
+            "llm_model": agent["llm"].get("model") or "unknown",
             "last_activity": now,
             "last_seen_reply_ts": msg_ts,
             "reply_poll_backoff_seconds": THREAD_REPLY_INITIAL_BACKOFF_SECONDS,
@@ -1003,6 +1027,14 @@ def _check_conversation_completion(
             )
         else:
             summary = final if final else "Success (no message available)."
+        # The values recorded when this script started the conversation; a
+        # thread follow-up reuses it, so they still describe its LLM. A record
+        # written before provenance was tracked cannot name either value.
+        summary = _with_llm_provenance(
+            summary,
+            rec.get("llm_profile") or "unknown",
+            rec.get("llm_model") or "unknown",
+        )
 
         ts_back = post_message(slack_token, channel_id, summary, thread_ts=thread_ts)
         if ts_back:

package/skills/ticket-to-code-change/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "ticket-to-code-change",
   "version": "1.0.0",
-  "description": "Create pull or merge requests from Jira or Linear tickets across GitHub, GitLab, and Bitbucket.",
+  "description": "Create pull or merge requests from Linear tickets across GitHub, GitLab, and Bitbucket.",
   "author": {
     "name": "OpenHands",
     "email": "contact@all-hands.dev"
@@ -10,7 +10,6 @@
   "repository": "https://github.com/OpenHands/extensions",
   "license": "MIT",
   "keywords": [
-    "jira",
     "linear",
     "github",
     "gitlab",

package/skills/ticket-to-code-change/.codex-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "ticket-to-code-change",
   "version": "1.0.0",
-  "description": "Create pull or merge requests from Jira or Linear tickets across GitHub, GitLab, and Bitbucket.",
+  "description": "Create pull or merge requests from Linear tickets across GitHub, GitLab, and Bitbucket.",
   "author": {
     "name": "OpenHands",
     "email": "contact@all-hands.dev"
@@ -10,7 +10,6 @@
   "repository": "https://github.com/OpenHands/extensions",
   "license": "MIT",
   "keywords": [
-    "jira",
     "linear",
     "github",
     "gitlab",

package/skills/ticket-to-code-change/.plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "ticket-to-code-change",
   "version": "1.0.0",
-  "description": "Create pull or merge requests from Jira or Linear tickets across GitHub, GitLab, and Bitbucket.",
+  "description": "Create pull or merge requests from Linear tickets across GitHub, GitLab, and Bitbucket.",
   "author": {
     "name": "OpenHands",
     "email": "contact@all-hands.dev"
@@ -10,7 +10,6 @@
   "repository": "https://github.com/OpenHands/extensions",
   "license": "MIT",
   "keywords": [
-    "jira",
     "linear",
     "github",
     "gitlab",

package/skills/ticket-to-code-change/SKILL.md

@@ -1,8 +1,9 @@
 ---
 name: ticket-to-code-change
 description: >
-  Set up a ticket-to-code-change automation using Jira or Linear as the issue
-  tracker and GitHub, GitLab, or Bitbucket as the source-control provider.
+  Set up a ticket-to-code-change automation using Linear as the issue tracker
+  and GitHub, GitLab, or Bitbucket as the source-control provider. The Jira
+  templates are served by the jira-issue-to-pr skill instead.
   Watches for implementation-ready tickets, starts an OpenHands conversation
   to implement and test the request, opens a pull or merge request, and links
   the result back to the ticket.
@@ -19,7 +20,8 @@ requests or merge requests.
 
 Ask the user for:
 
-1. The issue tracker: Jira Cloud or Linear.
+1. The issue tracker: Linear. Jira automations are set up with the
+   `jira-issue-to-pr` skill instead, which ships a poller.
 2. The source-control provider: GitHub, GitLab, or Bitbucket Cloud.
 3. The project or team to watch and the label or workflow state that means
    "implementation ready".

package/skills/ticket-to-code-change/commands/ticket-to-code-change-setup.md

@@ -1,6 +1,6 @@
 ---
 # auto-generated by sync_extensions.py
-description: Set up a ticket-to-code-change automation using Jira or Linear as the issue tracker and GitHub, GitLab, or Bitbucket as the source-control provider. Watches for implementation-ready tickets, starts an OpenHands conversation to implement and test the request, opens a pull or merge request, and links the result back to the ticket.
+description: Set up a ticket-to-code-change automation using Linear as the issue tracker and GitHub, GitLab, or Bitbucket as the source-control provider. The Jira templates are served by the jira-issue-to-pr skill instead. Watches for implementation-ready tickets, starts an OpenHands conversation to implement and test the request, opens a pull or merge request, and links the result back to the ticket.
 ---
 
 Read and follow the complete instructions in the SKILL.md file located in this skill's directory.