docs: Cursor Origin integration

docs/SUMMARY.md

@@ -75,6 +75,7 @@
   * [GitHub integration](learn/integrations/github-integration.md "GitHub")
   * [GitHub Actions authentication](learn/integrations/github-actions-authentication.md "GitHub Actions auth")
   * [GitLab integration](learn/integrations/gitlab-integration.md "GitLab")
+  * [Cursor Origin integration](learn/integrations/cursor-origin-integration.md "Cursor Origin")
   * [Other Git providers](learn/integrations/other-git-providers.md)
   * [Slack integration](learn/integrations/slack-integration.md "Slack")
   * [Microsoft Teams integration](learn/integrations/microsoft-teams-integration.md "Microsoft Teams")

docs/learn/account-and-access/account-management.md

@@ -38,7 +38,7 @@ You can create a project in two ways from the **New Project** page — import an
 
 {% tabs %}
 {% tab title="Import a Git repository" %}
-Choose **Import a Git repository** and select a Git provider (GitHub or GitLab) to import a repository. Argos links the project to that repository, which enables [pull request comments](../review-workflow/pull-request-comments.md) and status checks.
+Choose **Import a Git repository** and select a Git provider (GitHub, GitLab or Cursor Origin) to import a repository. Argos links the project to that repository, which enables [pull request comments](../review-workflow/pull-request-comments.md) and status checks.
 {% endtab %}
 
 {% tab title="Create without Git" %}

docs/learn/integrations/README.md

@@ -6,12 +6,13 @@ description: >-
 
 # Integrations
 
-Argos integrates with your Git provider to post build statuses on pull requests, and with Slack, Microsoft Teams, or Discord to notify your team. Which notifications go where is decided by [automations](../review-workflow/automations.md).
+Argos integrates with your Git provider — GitHub, GitLab or Cursor Origin — to post build statuses on pull requests, and with Slack, Microsoft Teams, or Discord to notify your team. Which notifications go where is decided by [automations](../review-workflow/automations.md).
 
 ### Git providers
 
 * [GitHub integration](github-integration.md) – Install the Argos GitHub App for statuses, comments, and merge queue support
 * [GitLab integration](gitlab-integration.md) – Connect GitLab to get statuses on merge requests
+* [Cursor Origin integration](cursor-origin-integration.md) – Install the Argos Origin app for check runs and comments on Origin pull requests
 * [Other Git providers](other-git-providers.md) – Bitbucket and Azure DevOps status, and how to use Argos without a native integration
 
 ### CI authentication

docs/learn/integrations/cursor-origin-integration.md

@@ -0,0 +1,102 @@
+---
+description: >-
+  Connect Argos to Cursor Origin for check runs and comments on your Origin
+  pull requests, and baseline selection from your commit history.
+---
+
+# Cursor Origin integration
+
+Connect Argos to [Cursor Origin](https://cursor.com/docs/origin), Cursor's git hosting, to get visual testing results on every Origin pull request. Argos reads commit history to pick the right baseline build and reports results back to Origin as check runs and pull request comments.
+
+### What Argos does on Origin
+
+* Adds check runs on the pull request's head commit, so Argos results can be required before merging in Origin's branch protections.
+* Posts [pull request comments](../review-workflow/pull-request-comments.md) with the latest build results and links back to Argos.
+* Analyzes commit history to find the right merge base and select the correct [baseline build](../platform-fundamentals/baseline-build.md) for visual comparisons.
+* Finds the pull request a build belongs to from its branch, so Argos works from any CI, even one that does not know about pull requests.
+
+This is why Argos asks for repository access: it reads commits to find merge bases, and writes check runs and comments to report results.
+
+{% hint style="info" %}
+Origin apps only reach repositories hosted on Origin. A repository [mirrored from GitHub](https://cursor.com/docs/origin/mirror-github) into Origin stays on the [GitHub integration](github-integration.md): keep it connected to GitHub in Argos.
+{% endhint %}
+
+### Install the Argos app on Origin
+
+Argos provides an Origin app that connects to your Origin codebase. Installing it links your Origin namespace to your Argos team or personal account.
+
+{% stepper %}
+{% step %}
+#### Start the installation from Argos
+
+1. From the dashboard, select your team or your personal account from the scope selector.
+2. Select the **Settings** tab and go to the **Integrations** section.
+3. Scroll to **Cursor Origin** and select **Install Argos on Origin**.
+
+You need to be an owner of the Argos account, and an admin of the Origin codebase.
+{% endstep %}
+
+{% step %}
+#### Approve the installation on Origin
+
+Origin shows the permissions Argos requests. Choose whether Argos reaches all repositories of your codebase or only selected ones, then select **Install**.
+
+Origin sends you back to Argos once the installation is approved. The **Cursor Origin** section now shows your Origin namespace.
+{% endstep %}
+
+{% step %}
+#### Import an Origin repository to Argos
+
+1. Select the **Projects** tab.
+2. Select **Create a new Project** at the top right.
+3. Select **Continue with Cursor Origin**.
+4. Pick the repository. The new project appears in your projects list.
+
+A repository created on Origin after the installation shows up after you select **Refresh** in the list.
+{% endstep %}
+{% endstepper %}
+
+### Connect an existing Argos project to Origin
+
+To link an Origin repository to a project that already exists in Argos, go to **Project Settings → Git → Connected Git Repository**, select **Cursor Origin** and pick the repository. The app must be [installed](#install-the-argos-app-on-origin) first.
+
+### Send builds from your CI
+
+Origin has no CI of its own: run your tests on the CI you connect to Origin, such as [Buildkite](https://buildkite.com/) or [Depot](https://depot.dev/), and upload screenshots with the Argos SDK or the [CLI](../../sdks-reference/argos-command-line-interface-cli.md) as on any other CI. Authenticate with `ARGOS_TOKEN`.
+
+The Argos SDK reads the commit and branch from your CI environment or from `git`. When your CI does not know the pull request, Argos asks Origin which open pull request has this branch as its head, so builds land on the right pull request without any extra configuration. And when the pull request is opened after the branch was built — the usual order on Origin, where Buildkite does not rebuild a commit it already ran — Argos attaches the builds of its head commit to the pull request and posts the comment. To override detection, set the `ARGOS_COMMIT` (full 40-character SHA), `ARGOS_BRANCH` and `ARGOS_PR_NUMBER` environment variables.
+
+{% hint style="info" %}
+Buildkite is the tested setup: install the [Buildkite app on Origin](https://buildkite.com/docs/pipelines/source-control/origin), create a pipeline from the Origin repository, and add a step running your tests and the Argos upload with `ARGOS_TOKEN` in its environment. Builds run on Buildkite hosted agents check out the Origin repository with its full history, so Argos finds the merge base as it does on GitHub.
+{% endhint %}
+
+### Check run names
+
+Argos reports results as check runs in the `argos` check suite. The check run key depends on your setup:
+
+| Key                                 | When it is used                                                                                                                                           |
+| ----------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `argos`                             | The default — one Argos project on the repository, default build name.                                                                                    |
+| `argos/<build-name>`                | The build has a custom name (for example `argos/e2e` with `--build-name e2e`), as in [monorepo setups](../how-to-guides/ci-pipelines/monorepos-setup.md). |
+| `argos/<project-name>`              | Several Argos projects share the same repository — the project name disambiguates them.                                                                   |
+| `argos/<project-name>/<build-name>` | Several projects share the repository and the build has a custom name.                                                                                    |
+| `argos/summary`                     | The [summary check](../review-workflow/summary-checks.md) that combines all Argos builds on a commit.                                                      |
+
+Use these exact keys when you configure required checks in your repository's **Rules and Protections** on Origin.
+
+### Update the repositories shared with Argos
+
+Repository access is managed on Origin: open [cursor.com/codebase/settings/apps](https://cursor.com/codebase/settings/apps), select the Argos app and change the selected repositories. Argos picks the change up automatically; select **Refresh** in the repository list if a repository is missing.
+
+### Required permissions
+
+Argos asks for the following Origin permissions:
+
+* **Read repository contents, branches, and commits** — used to find a common commit ancestor between branches
+* **Read pull requests** — used to link builds to pull requests
+* **Read and create pull request comments** — used to post and update the Argos comment
+* **Read and create check suites and runs** — used to report build results
+
+If you would rather not grant content access, you can decline it when you install the app: Argos then relies on the base commit and parent commits sent by the SDK, like the [GitHub integration without content permission](github-integration.md#github-integration-without-content-permission).
+
+We take your security and privacy seriously. If you have any concerns or questions, please [contact us](https://argos-ci.com/contact).

docs/learn/integrations/other-git-providers.md

@@ -6,7 +6,7 @@ description: >-
 
 # Other Git providers
 
-Argos integrates natively with [GitHub](github-integration.md) and [GitLab](gitlab-integration.md). Other providers are not supported yet.
+Argos integrates natively with [GitHub](github-integration.md), [GitLab](gitlab-integration.md) and [Cursor Origin](cursor-origin-integration.md). Other providers are not supported yet.
 
 ### Bitbucket
 

docs/learn/review-workflow/pull-request-comments.md

@@ -1,17 +1,17 @@
 ---
 description: >-
   Get the latest Argos build status and a link to the build page posted
-  automatically on your GitHub pull requests.
+  automatically on your GitHub and Cursor Origin pull requests.
 ---
 
 # Pull request comments
 
-Argos posts a comment on your GitHub pull requests with the latest build results, so your team sees visual changes without leaving the PR.
+Argos posts a comment on your GitHub and Cursor Origin pull requests with the latest build results, so your team sees visual changes without leaving the PR.
 
 Every time a build status updates, Argos updates the comment with the latest status and a link to the build page.
 
 {% hint style="info" %}
-Pull request comments are available on GitHub. On GitLab, Argos reports results through [commit statuses](summary-checks.md) instead.
+Pull request comments are available on [GitHub](../integrations/github-integration.md) and [Cursor Origin](../integrations/cursor-origin-integration.md). On GitLab, Argos reports results through [commit statuses](summary-checks.md) instead.
 {% endhint %}
 
 ![Argos GitHub pull request comment](<../../.gitbook/assets/github pr comment 54bebb73962dc705b32c33f577fb9dd0.png>)

docs/learn/review-workflow/summary-checks.md

@@ -8,7 +8,7 @@ description: >-
 
 A **summary check** is a single commit status — `argos/summary` — that combines the result of all Argos builds on a commit. When your CI produces several builds (for example, one per app in a monorepo), the summary check gives you one status to glance at, and one status to require.
 
-By default, Argos adds the summary check **only when a commit has more than one build** — a single build keeps its individual status (`argos`, or `argos/<build-name>` for a named build) with no summary added. See [Commit status names](../integrations/github-integration.md#commit-status-names) for the exact context of each status Argos posts.
+By default, Argos adds the summary check **only when a commit has more than one build** — a single build keeps its individual status (`argos`, or `argos/<build-name>` for a named build) with no summary added. See [Commit status names](../integrations/github-integration.md#commit-status-names) for the exact context of each status Argos posts on GitHub, and [Check run names](../integrations/cursor-origin-integration.md#check-run-names) for Cursor Origin, where the summary is a check run.
 
 ![Summary status check in GitHub](<../../.gitbook/assets/summary check d7953362698c802ff3f81de23bfb83cc.png>)
 

docs/sdks-reference/argos-command-line-interface-cli.md

@@ -186,7 +186,7 @@ argos upload ./screenshots --project my-account/my-project
 
 In a non-Git environment, `ARGOS_COMMIT` and `ARGOS_BRANCH` are required — without them the upload fails with "Argos requires a branch and a commit to be set".
 
-To find the [baseline](../learn/platform-fundamentals/baseline-build.md), Argos resolves ancestor commits. When your project is connected to GitHub or GitLab, this happens server-side. Otherwise the CLI fetches history from the `origin` remote — in a repository without `origin` (for example a local mirror), it falls back to the local history, so make sure enough history is available locally, or pin the baseline explicitly with `--reference-commit` and `--reference-branch`. Parent commits are always computed automatically and cannot be set manually.
+To find the [baseline](../learn/platform-fundamentals/baseline-build.md), Argos resolves ancestor commits. When your project is connected to GitHub, GitLab or Cursor Origin, this happens server-side. Otherwise the CLI fetches history from the `origin` remote — in a repository without `origin` (for example a local mirror), it falls back to the local history, so make sure enough history is available locally, or pin the baseline explicitly with `--reference-commit` and `--reference-branch`. Parent commits are always computed automatically and cannot be set manually.
 
 To see what the CLI detected, run it with debug output: