@openhands/extensions 0.22.1 → 0.24.0

package/automations/catalog/github-issue-triage/manifest.json

@@ -1,6 +1,6 @@
 {
   "id": "github-issue-triage",
-  "version": "1.1.1",
+  "version": "1.3.0",
   "name": "GitHub issue triage",
   "category": "Project management",
   "description": "Prioritize open issues and establish acceptance criteria before marking them ready for development.",
@@ -54,7 +54,7 @@
       }
     },
     "bundle": {
-      "version": "1.1.1",
+      "version": "1.3.0",
       "entrypoint": "python3 worker.py",
       "timeout": 300,
       "files": {

package/automations/catalog/github-pr-reviewer/manifest.json

@@ -1,9 +1,9 @@
 {
   "id": "github-pr-reviewer",
-  "version": "1.1.1",
+  "version": "1.5.0",
   "name": "GitHub code review",
   "category": "Code review",
-  "description": "Review labeled pull-request heads, publish readable findings, and record exact-head test and review decisions.",
+  "description": "Review requested pull-request heads, record exact-head decisions, stop early on out-of-scope changes, and optionally request a code-aware human maintainer after approval or a maintainer-decision scope stop.",
   "requires": {
     "integrations": {},
     "features": [
@@ -13,7 +13,7 @@
   },
   "popularityRank": 100,
   "estimatedSetupMinutes": 4,
-  "exampleImplementation": "A scheduled scanner selects every labeled PR head and submits an idempotent subject turn. The profile-backed agent clones that exact head in its runtime, reuses the established review workflow, runs appropriate tests, publishes a readable native review, and records exact-head review and test statuses.",
+  "exampleImplementation": "A scheduled label scan or GitHub reviewer-request event selects a PR head and submits an idempotent subject turn. The profile-backed agent clones that exact head in its runtime, applies an early repository-ownership and product/architecture scope gate, then reuses the established review workflow, runs appropriate tests, and publishes a readable native review. A native approval, or a maintainer-decision scope stop, can then be handed to a code-aware human maintainer.",
   "impact": {
     "basis": "completed-runs",
     "one": "1 PR review sweep completed",
@@ -39,6 +39,21 @@
             "default": "UTC",
             "required": true
           }
+        },
+        "event": {
+          "on": {
+            "type": "select",
+            "label": "GitHub events",
+            "help": "Handle requests for the configured bot and its resulting native reviews.",
+            "default": "*",
+            "required": true,
+            "options": [
+              {
+                "value": "*",
+                "label": "Reviewer request and completion"
+              }
+            ]
+          }
         }
       },
       "args": {
@@ -61,6 +76,17 @@
             "maxLength": 50
           }
         },
+        "triggerReviewer": {
+          "type": "text",
+          "label": "Requested reviewer",
+          "help": "GitHub login whose review request starts an event-driven review.",
+          "default": "all-hands-bot",
+          "required": true,
+          "constraints": {
+            "minLength": 1,
+            "maxLength": 39
+          }
+        },
         "reviewTone": {
           "type": "select",
           "label": "Review tone",
@@ -82,6 +108,13 @@
             }
           ]
         },
+        "maintainers": {
+          "type": "text",
+          "label": "Maintainers",
+          "help": "Optional comma-separated GitHub collaborator logins. Include at least two so a maintainer-authored PR still has an eligible reviewer. After an exact-head approval, request one based on changed-path history and current review load.",
+          "default": "",
+          "required": false
+        },
         "githubTokenSecret": {
           "type": "text",
           "label": "GitHub token secret",
@@ -92,22 +125,26 @@
       }
     },
     "bundle": {
-      "version": "1.1.1",
+      "version": "1.5.0",
       "entrypoint": "python3 worker.py",
       "timeout": 300,
       "files": {
         "main.py": "skills/github-pr-reviewer/scripts/main.py",
         "agent_conversation.py": "skills/github/scripts/agent_conversation.py",
         "github_client.py": "skills/github/scripts/github_client.py",
+        "maintainer_handoff.py": "skills/github-pr-reviewer/scripts/maintainer_handoff.py",
         "worker.py": "skills/github-pr-reviewer/scripts/worker.py"
       },
       "config": {
         "repos": "{{form.repositories}}",
         "trigger_label": "{{form.triggerLabel}}",
+        "trigger_reviewer": "{{form.triggerReviewer}}",
         "review_tone": "{{form.reviewTone}}",
+        "maintainers": "{{form.maintainers}}",
         "github_token_secret": "{{form.githubTokenSecret}}"
       }
     },
-    "message": "Configure the repositories, review label, tone, credential name, agent profile, and schedule."
+    "filter": "contains({{form.repositories}}, repository.full_name) && contains(keys(@), 'pull_request') && ((action == 'review_requested' && requested_reviewer.login == '{{form.triggerReviewer}}') || (action == 'submitted' && contains(keys(@), 'review') && review.user.login == '{{form.triggerReviewer}}'))",
+    "message": "Configure the repositories, trigger, review tone, optional maintainer roster, credential name, and agent profile."
   }
 }

package/automations/catalog.schema.json

@@ -156,10 +156,6 @@
             "required": ["form"]
           },
           "then": { "not": { "required": ["filter"] } }
-        },
-        {
-          "if": { "required": ["bundle"] },
-          "then": { "not": { "required": ["filter"] } }
         }
       ]
     },

package/integrations/catalog/granola.json

@@ -0,0 +1,38 @@
+{
+  "id": "granola",
+  "name": "Granola",
+  "description": "Search and query your Granola meeting notes, transcripts, folders, and action items.",
+  "categories": [
+    "Meetings",
+    "Knowledge base"
+  ],
+  "appUrl": "https://www.granola.ai",
+  "docsUrl": "https://docs.granola.ai/help-center/sharing/integrations/mcp",
+  "notes": "Uses Granola's hosted MCP server. OAuth is handled by the server itself via browser sign-in with Dynamic Client Registration, so no client ID or client secret is required. MCP connects as an individual user and follows the active workspace selected in the Granola app; there is no API key access for MCP.",
+  "connectionOptions": [
+    {
+      "id": "oauth",
+      "provider": "mcp",
+      "transport": {
+        "kind": "shttp",
+        "url": "https://mcp.granola.ai/mcp"
+      },
+      "auth": {
+        "strategy": "oauth2",
+        "oauth": {
+          "clientAuthentication": "none"
+        }
+      }
+    }
+  ],
+  "iconBg": "#D1E043",
+  "iconColor": "var(--oh-surface-deep)",
+  "keywords": [
+    "meeting notes",
+    "transcripts",
+    "meetings",
+    "notes",
+    "action items"
+  ],
+  "installHint": "Sign in to Granola through the browser OAuth flow when prompted; no client credentials or API key are needed. MCP follows the active workspace selected in your Granola app, so switch workspaces there before querying if you belong to more than one. Some folder, search, and transcript tools require a paid Granola plan."
+}

package/integrations/catalog-index.js

@@ -66,20 +66,21 @@ import entry60 from "./catalog/fetch.json" with { type: "json" };
 import entry61 from "./catalog/filesystem.json" with { type: "json" };
 import entry62 from "./catalog/firecrawl.json" with { type: "json" };
 import entry63 from "./catalog/git.json" with { type: "json" };
-import entry64 from "./catalog/huggingface.json" with { type: "json" };
-import entry65 from "./catalog/kagi.json" with { type: "json" };
-import entry66 from "./catalog/memory.json" with { type: "json" };
-import entry67 from "./catalog/mongodb.json" with { type: "json" };
-import entry68 from "./catalog/neon.json" with { type: "json" };
-import entry69 from "./catalog/obsidian.json" with { type: "json" };
-import entry70 from "./catalog/paypal.json" with { type: "json" };
-import entry71 from "./catalog/playwright.json" with { type: "json" };
-import entry72 from "./catalog/redis.json" with { type: "json" };
-import entry73 from "./catalog/reportportal.json" with { type: "json" };
-import entry74 from "./catalog/resend.json" with { type: "json" };
-import entry75 from "./catalog/sequential-thinking.json" with { type: "json" };
-import entry76 from "./catalog/superhuman-mail.json" with { type: "json" };
-import entry77 from "./catalog/time.json" with { type: "json" };
+import entry64 from "./catalog/granola.json" with { type: "json" };
+import entry65 from "./catalog/huggingface.json" with { type: "json" };
+import entry66 from "./catalog/kagi.json" with { type: "json" };
+import entry67 from "./catalog/memory.json" with { type: "json" };
+import entry68 from "./catalog/mongodb.json" with { type: "json" };
+import entry69 from "./catalog/neon.json" with { type: "json" };
+import entry70 from "./catalog/obsidian.json" with { type: "json" };
+import entry71 from "./catalog/paypal.json" with { type: "json" };
+import entry72 from "./catalog/playwright.json" with { type: "json" };
+import entry73 from "./catalog/redis.json" with { type: "json" };
+import entry74 from "./catalog/reportportal.json" with { type: "json" };
+import entry75 from "./catalog/resend.json" with { type: "json" };
+import entry76 from "./catalog/sequential-thinking.json" with { type: "json" };
+import entry77 from "./catalog/superhuman-mail.json" with { type: "json" };
+import entry78 from "./catalog/time.json" with { type: "json" };
 
 export const INTEGRATION_CATALOG_ENTRIES = [
   entry0,
@@ -160,4 +161,5 @@ export const INTEGRATION_CATALOG_ENTRIES = [
   entry75,
   entry76,
   entry77,
+  entry78,
 ];

package/marketplaces/openhands-extensions.json

@@ -106,6 +106,20 @@
         "delegation"
       ]
     },
+    {
+      "name": "canvas-extension-api",
+      "source": "./skills/canvas-extension-api",
+      "description": "Build and validate Apps for Agent Canvas using the supported Canvas Extensions API v1 routed-page contract.",
+      "category": "agent-authoring",
+      "defaultEnabled": true,
+      "keywords": [
+        "agent-canvas",
+        "canvas-app",
+        "canvas-extension",
+        "register-page",
+        "app-development"
+      ]
+    },
     {
       "name": "openhands-sdk",
       "source": "./skills/openhands-sdk",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openhands/extensions",
-  "version": "0.22.1",
+  "version": "0.24.0",
   "description": "Public OpenHands extension catalogs for skills, plugins, integrations, and automation templates.",
   "license": "MIT",
   "type": "module",

package/plugins/openhands/skills/openhands-sdk/SKILL.md

@@ -82,6 +82,7 @@ print("All done!")
 - [API-based Sandbox](https://docs.openhands.dev/sdk/guides/agent-server/api-sandbox.md): Connect to hosted API-based agent server for fully managed infrastructure.
 - [Apptainer Sandbox](https://docs.openhands.dev/sdk/guides/agent-server/apptainer-sandbox.md): Run agent server in rootless Apptainer containers for HPC and shared computing environments.
 - [Ask Agent Questions](https://docs.openhands.dev/sdk/guides/convo-ask-agent.md): Get sidebar replies from the agent during conversation execution without interrupting the main flow.
+- [Ask Oracle](https://docs.openhands.dev/sdk/guides/agent-ask-oracle.md): Let an agent consult a saved Oracle LLM profile for stateless second-opinion advice.
 - [Assign Reviews](https://docs.openhands.dev/sdk/guides/github-workflows/assign-reviews.md): Automate PR management with intelligent reviewer assignment and workflow notifications using OpenHands Agent
 - [Browser Session Recording](https://docs.openhands.dev/sdk/guides/browser-session-recording.md): Record and replay your agent's browser sessions using rrweb.
 - [Browser Use](https://docs.openhands.dev/sdk/guides/agent-browser-use.md): Enable web browsing and interaction capabilities for your agent.
@@ -117,7 +118,7 @@ print("All done!")
 - [Model Context Protocol](https://docs.openhands.dev/sdk/guides/mcp.md): Model Context Protocol (MCP) enables dynamic tool integration from external servers. Agents can discover and use MCP-provided tools automatically.
 - [Model Routing](https://docs.openhands.dev/sdk/guides/llm-routing.md): Route agent's LLM requests to different models.
 - [Observability & Tracing](https://docs.openhands.dev/sdk/guides/observability.md): Enable OpenTelemetry tracing to monitor and debug your agent's execution with tools like Laminar, MLflow, Honeycomb, or any OTLP-compatible backend.
-- [OpenAI-Compatible Endpoint](https://docs.openhands.dev/sdk/guides/agent-server/openai-gateway.md): Call an OpenHands agent-server through the OpenAI Chat Completions protocol.
+- [OpenAI-Compatible Endpoint](https://docs.openhands.dev/sdk/guides/agent-server/openai-gateway.md): Call an OpenHands agent-server through the OpenAI Chat Completions or Responses protocol.
 - [OpenHands Cloud Workspace](https://docs.openhands.dev/sdk/guides/agent-server/cloud-workspace.md): Connect to OpenHands Cloud for fully managed sandbox environments with optional SaaS credential inheritance.
 - [Overview](https://docs.openhands.dev/sdk/guides/agent-server/overview.md): Run agents on remote servers with isolated workspaces for production deployments.
 - [Parallel Tool Execution](https://docs.openhands.dev/sdk/guides/parallel-tool-execution.md): Execute multiple tools concurrently within a single LLM response to improve throughput for independent operations.
@@ -131,6 +132,7 @@ print("All done!")
 - [Security & Action Confirmation](https://docs.openhands.dev/sdk/guides/security.md): Control agent action execution through confirmation policy and security analyzer.
 - [Send Message While Running](https://docs.openhands.dev/sdk/guides/convo-send-message-while-running.md): Interrupt running agents to provide additional context or corrections.
 - [Software Agent SDK](https://docs.openhands.dev/sdk.md): Build AI agents that write software. A clean, modular SDK with production-ready tools.
+- [Structured Output](https://docs.openhands.dev/sdk/guides/structured-output.md): Attach a schema to any tool so the LLM returns typed, validated fields alongside the tool's own arguments.
 - [Stuck Detector](https://docs.openhands.dev/sdk/guides/agent-stuck-detector.md): Detect and handle stuck agents automatically with timeout mechanisms.
 - [Task Tool Set](https://docs.openhands.dev/sdk/guides/task-tool-set.md): Delegate complex work to specialized sub-agents that run synchronously and return results to the parent agent.
 - [Theory of Mind (TOM) Agent](https://docs.openhands.dev/sdk/guides/agent-tom-agent.md): Enable your agent to understand user intent and preferences through Theory of Mind capabilities, providing personalized guidance based on user modeling.

package/plugins/pr-review/README.md

@@ -22,7 +22,8 @@ Then configure the required secrets (see [Installation](#installation) below).
 - **Inline Code Comments**: Posts review comments directly on specific lines of code
 - **Unified Review Style**: Rigorous code review combining pragmatic engineering analysis with data structure and simplicity focus
 - **A/B Testing**: Support for testing multiple LLM models
-- **Review Context Awareness**: Considers previous reviews and unresolved threads
+- **Review Context Awareness**: Considers linked issue acceptance criteria,
+  top-level PR discussion, previous reviews, and unresolved threads
 - **Evidence Enforcement**: Optional check that PR descriptions include concrete end-to-end proof the code works, not just test output
 - **Sub-Agent Delegation**: Split large PR reviews across multiple sub-agents, one per file, then consolidate findings (see [Known Limitations](#known-limitations-sub-agent-delegation))
 - **Observability**: Optional Laminar integration for tracing and evaluation

package/plugins/pr-review/scripts/agent_script.py

@@ -169,6 +169,61 @@ query($owner: String!, $repo: String!, $pr_number: Int!, $cursor: String) {
 }
 """
 
+LINKED_ISSUES_QUERY = """
+query(
+    $owner: String!
+    $repo: String!
+    $pr_number: Int!
+    $count: Int!
+    $cursor: String
+) {
+    repository(owner: $owner, name: $repo) {
+        pullRequest(number: $pr_number) {
+            closingIssuesReferences(last: $count, before: $cursor) {
+                pageInfo {
+                    hasPreviousPage
+                    startCursor
+                }
+                nodes {
+                    number
+                    title
+                    body
+                    repository { nameWithOwner }
+                }
+            }
+        }
+    }
+}
+"""
+
+ISSUE_COMMENTS_QUERY = """
+query(
+    $owner: String!
+    $repo: String!
+    $pr_number: Int!
+    $count: Int!
+    $cursor: String
+) {
+    repository(owner: $owner, name: $repo) {
+        pullRequest(number: $pr_number) {
+            comments(last: $count, before: $cursor) {
+                pageInfo {
+                    hasPreviousPage
+                    startCursor
+                }
+                nodes {
+                    id
+                    author { login __typename }
+                    authorAssociation
+                    body
+                    createdAt
+                }
+            }
+        }
+    }
+}
+"""
+
 
 def _get_required_env(name: str) -> str:
     value = os.getenv(name)
@@ -379,6 +434,58 @@ def get_pr_reviews(pr_number: str, max_reviews: int = 100) -> list[dict[str, Any
     return reviews
 
 
+def get_pr_issue_comments(
+    pr_number: str, max_comments: int = 100
+) -> list[dict[str, Any]]:
+    """Fetch the latest top-level PR comments in chronological order."""
+    repo = _get_required_env("REPO_NAME")
+    owner, repo_name = repo.split("/")
+    nodes = _paginate_graphql(
+        query=ISSUE_COMMENTS_QUERY,
+        variables={
+            "owner": owner,
+            "repo": repo_name,
+            "pr_number": int(pr_number),
+            "count": max_comments,
+        },
+        path_to_nodes=["pullRequest", "comments"],
+        max_items=max_comments,
+        item_name="top-level PR comments",
+    )
+    comments = [
+        {
+            "id": node.get("id"),
+            "user": {
+                "login": (node.get("author") or {}).get("login", "unknown"),
+                "type": (node.get("author") or {}).get("__typename", "User"),
+            },
+            "author_association": node.get("authorAssociation", "UNKNOWN"),
+            "body": node.get("body", ""),
+            "created_at": node.get("createdAt"),
+        }
+        for node in nodes
+    ]
+    return sorted(comments, key=lambda comment: comment.get("created_at") or "")
+
+
+def get_linked_issues(pr_number: str, max_issues: int = 5) -> list[dict[str, Any]]:
+    """Fetch the issues GitHub recognizes as closed by this PR."""
+    repo = _get_required_env("REPO_NAME")
+    owner, repo_name = repo.split("/")
+    return _paginate_graphql(
+        query=LINKED_ISSUES_QUERY,
+        variables={
+            "owner": owner,
+            "repo": repo_name,
+            "pr_number": int(pr_number),
+            "count": max_issues,
+        },
+        path_to_nodes=["pullRequest", "closingIssuesReferences"],
+        max_items=max_issues,
+        item_name="linked issues",
+    )
+
+
 def get_review_threads_graphql(pr_number: str) -> list[dict[str, Any]]:
     """Fetch the latest review threads with resolution status using GraphQL API.
 
@@ -419,44 +526,90 @@ def get_review_threads_graphql(pr_number: str) -> list[dict[str, Any]]:
 def format_review_context(
     reviews: list[dict[str, Any]],
     threads: list[dict[str, Any]],
+    issue_comments: list[dict[str, Any]] | None = None,
+    linked_issues: list[dict[str, Any]] | None = None,
     max_size: int = MAX_REVIEW_CONTEXT,
 ) -> str:
-    """Format review history into a context string for the agent.
-
-    Args:
-        reviews: List of review objects from get_pr_reviews()
-        threads: List of thread objects from get_review_threads_graphql()
-        max_size: Maximum size of the formatted context
-
-    Returns:
-        Formatted markdown string with review history
-    """
-    if not reviews and not threads:
+    """Format the highest-signal PR and linked-issue context for the agent."""
+    issue_comments = issue_comments or []
+    linked_issues = linked_issues or []
+    if not reviews and not threads and not issue_comments and not linked_issues:
         return ""
 
     sections: list[str] = []
     current_size = 0
 
     def _add_section(section: str) -> bool:
-        """Add a section if it fits within max_size. Returns True if added."""
         nonlocal current_size
-        section_size = len(section) + 1  # +1 for newline separator
+        section_size = len(section) + 1
         if current_size + section_size > max_size:
             return False
         sections.append(section)
         current_size += section_size
         return True
 
-    # Format reviews (high-level review decisions)
+    if linked_issues:
+        _add_section("### Linked Issues and Acceptance Criteria\n")
+        for issue in linked_issues:
+            title = issue.get("title") or "(untitled issue)"
+            number = issue.get("number", "?")
+            repository = (issue.get("repository") or {}).get("nameWithOwner")
+            body = (issue.get("body") or "").strip()
+            body_preview = body[:2000] + "..." if len(body) > 2000 else body
+            reference = f"{repository}#{number}" if repository else f"Issue #{number}"
+            section = f"**{reference}: {title}**"
+            if body_preview:
+                section += "\n" + "\n".join(
+                    f"> {line}" for line in body_preview.splitlines()
+                )
+            if not _add_section(section):
+                sections.append("... [remaining linked issues omitted] ...")
+                break
+
+    human_comments = [
+        comment
+        for comment in issue_comments
+        if ((comment.get("user") or {}).get("type") or "").lower() != "bot"
+        and ((comment.get("user") or {}).get("login") or "").lower() != "all-hands-bot"
+    ]
+    if human_comments:
+        _add_section("### Top-level PR Discussion\n")
+        for comment in human_comments[-12:]:
+            author = ((comment.get("user") or {}).get("login")) or "unknown"
+            association = comment.get("author_association") or "UNKNOWN"
+            body = (comment.get("body") or "").strip()
+            if not body:
+                continue
+            body_preview = body[:750] + "..." if len(body) > 750 else body
+            section = f"- **{author}** ({association})\n" + "\n".join(
+                f"  > {line}" for line in body_preview.splitlines()
+            )
+            if not _add_section(section):
+                sections.append("... [older PR discussion omitted] ...")
+                break
+
+    resolved_threads = [thread for thread in threads if thread.get("isResolved")]
+    unresolved_threads = [thread for thread in threads if not thread.get("isResolved")]
+
+    if unresolved_threads:
+        _add_section(
+            "### Unresolved Review Threads\n\n"
+            "*These concerns may still need to be addressed:*"
+        )
+        for index, thread in enumerate(unresolved_threads):
+            if not _add_section("\n".join(_format_thread(thread))):
+                remaining = len(unresolved_threads) - index
+                sections.append(
+                    f"... [{remaining} unresolved review threads omitted] ..."
+                )
+                break
+
     if reviews:
-        review_lines: list[str] = ["### Previous Reviews\n"]
+        review_lines: list[str] = ["### Previous Review Decisions\n"]
         for review in reviews:
-            user_data = review.get("user") or {}
-            user = user_data.get("login", "unknown")
+            user = ((review.get("user") or {}).get("login")) or "unknown"
             state = review.get("state") or "UNKNOWN"
             body = (review.get("body") or "").strip()
-
-            # Map state to emoji for visual clarity
             state_emoji = {
                 "APPROVED": "✅",
                 "CHANGES_REQUESTED": "🔴",
@@ -464,72 +617,29 @@ def format_review_context(
                 "DISMISSED": "❌",
                 "PENDING": "⏳",
             }.get(state, "❓")
-
             review_lines.append(f"- {state_emoji} **{user}** ({state})")
             if body:
-                # Indent the body and truncate if too long
                 body_preview = body[:500] + "..." if len(body) > 500 else body
-                indented = "\n".join(f"  > {line}" for line in body_preview.split("\n"))
-                review_lines.append(indented)
+                review_lines.extend(f"  > {line}" for line in body_preview.splitlines())
             review_lines.append("")
-
-        review_section = "\n".join(review_lines)
-        if not _add_section(review_section):
-            # Even reviews section doesn't fit, return truncation message
-            return (
-                f"... [review context truncated, "
-                f"content exceeds {max_size:,} chars] ..."
-            )
-
-    # Format review threads with resolution status
-    if threads:
-        resolved_threads = [t for t in threads if t.get("isResolved")]
-        unresolved_threads = [t for t in threads if not t.get("isResolved")]
-
-        # Unresolved threads (higher priority)
-        if unresolved_threads:
-            header = (
-                "### Unresolved Review Threads\n\n"
-                "*These threads have not been resolved and may need attention:*\n"
-            )
-            if not _add_section(header):
-                count = len(unresolved_threads)
+        if not _add_section("\n".join(review_lines)):
+            sections.append("... [previous review decisions omitted] ...")
+
+    if (
+        resolved_threads
+        and current_size < max_size
+        and _add_section(
+            "### Resolved Review Threads\n\n"
+            "*Use these as context; do not repeat resolved findings:*"
+        )
+    ):
+        for index, thread in enumerate(resolved_threads):
+            if not _add_section("\n".join(_format_thread(thread))):
+                remaining = len(resolved_threads) - index
                 sections.append(
-                    f"\n... [truncated, {count} unresolved threads omitted] ..."
+                    f"... [{remaining} resolved review threads omitted] ..."
                 )
-            else:
-                threads_added = 0
-                for thread in unresolved_threads:
-                    thread_lines = _format_thread(thread)
-                    thread_section = "\n".join(thread_lines)
-                    if not _add_section(thread_section):
-                        remaining = len(unresolved_threads) - threads_added
-                        sections.append(
-                            f"\n... [truncated, {remaining} unresolved "
-                            "threads omitted] ..."
-                        )
-                        break
-                    threads_added += 1
-
-        # Resolved threads (lower priority, add if space remains)
-        if resolved_threads and current_size < max_size:
-            header = (
-                "### Resolved Review Threads\n\n"
-                "*These threads have been resolved but provide context:*\n"
-            )
-            if _add_section(header):
-                threads_added = 0
-                for thread in resolved_threads:
-                    thread_lines = _format_thread(thread)
-                    thread_section = "\n".join(thread_lines)
-                    if not _add_section(thread_section):
-                        remaining = len(resolved_threads) - threads_added
-                        sections.append(
-                            f"\n... [truncated, {remaining} resolved "
-                            "threads omitted] ..."
-                        )
-                        break
-                    threads_added += 1
+                break
 
     return "\n".join(sections)
 
@@ -650,7 +760,8 @@ def _fetch_with_fallback(
 def get_pr_review_context(pr_number: str) -> str:
     """Get all review context for a PR.
 
-    Fetches reviews and review threads, then formats them into a context string.
+    Fetches linked issues, top-level discussion, reviews, and review threads,
+    then formats them into a context string.
 
     Args:
         pr_number: The PR number
@@ -662,8 +773,14 @@ def get_pr_review_context(pr_number: str) -> str:
     threads = _fetch_with_fallback(
         "review threads", lambda: get_review_threads_graphql(pr_number)
     )
+    comments = _fetch_with_fallback(
+        "top-level PR comments", lambda: get_pr_issue_comments(pr_number)
+    )
+    linked_issues = _fetch_with_fallback(
+        "linked issues", lambda: get_linked_issues(pr_number)
+    )
 
-    return format_review_context(reviews, threads)
+    return format_review_context(reviews, threads, comments, linked_issues)
 
 
 def get_pr_files(pr_number: str) -> list[dict[str, Any]]: