@cursor/july 0.1.96 → 0.1.97

package/docs/templates/agents-md.md

@@ -0,0 +1,110 @@
+---
+title: "Keep AGENTS.md current from last week's work"
+description: "Scaffold the agent, pick a repo and Slack channels, dispatch the weekly job, and deploy."
+---
+
+# Keep AGENTS.md current from last week's work
+
+This agent runs every Monday at 09:00 UTC. It reads last week's merged
+pull requests and the Slack channels you list. When a durable rule
+showed up, `apply_agents` parks the write until a person approves it,
+then opens a draft follow-up pull request against the default branch.
+Chores and rules the file already states stay quiet.
+
+This template is one model turn: read the week, then call
+`apply_agents`.
+
+Init once per app. Pass a different repo and channel list each time.
+
+## Scaffold
+
+```bash
+npx @cursor/july init ./agents-md --template agents-md
+```
+
+`init` asks which GitHub repo to watch and which Slack channels to
+read. Pass `--var repos=acme/api --var slack=#eng-api,#api-private`
+to skip the prompt. Use `--var slack=none` when Slack is out of
+scope.
+
+The answers land in `agent/lib/config.ts`. Edit that file when the
+set changes.
+
+## Connect GitHub and Slack
+
+Connect GitHub in Cursor for that repository (Settings or
+[cursor.com/dashboard](https://cursor.com/dashboard)). Sign the host
+in:
+
+```bash
+cd agents-md
+agent-sdk login
+```
+
+`cursorAccount` mints a short-lived, repo-scoped credential with
+`contents-write` so the agent can open the follow-up PR. See the
+[GitHub guide](../guides/github.md).
+
+Create the Slack app and invite the bot to each listed channel,
+including private ones:
+
+```bash
+agent-sdk slack create --dir .
+```
+
+See the [Slack guide](../guides/slack.md).
+
+## First weekly run
+
+```bash
+agent-sdk dev
+```
+
+Schedules never fire under `dev`. Dispatch the same path production
+uses:
+
+```bash
+curl -X POST http://127.0.0.1:3000/v1/dev/schedules/weekly
+```
+
+The playground can run `/queue/run` too.
+
+The host writes `week/prs.md`, `week/slack.md`, `week/window.txt`,
+and `week/tree/**.txt` snapshots of the current `AGENTS.md` files,
+then starts a model turn. The
+model calls `apply_agents` once. A skip finishes. An update parks in
+the playground until someone approves; then a draft PR opens against
+the repository default branch. Later updates to the same base stack
+on `agents-md/<base>`. Pull requests from those branches are ignored
+so the follow-up cannot feed the next week.
+
+Chat replies stay in the playground. `apply_agents` records a skip,
+or parks the write. Approve there or with
+`POST /v1/session/:id/approvals/:callId`.
+
+## What to edit
+
+- `agent/lib/config.ts`: repo and Slack channels
+- `agent/instructions.md`: what counts as an update
+- `evals/agents.eval.ts`: smoke cases
+
+## Evals
+
+Four smoke cases: a lint-only week, a billing rule that parks the
+write, the same rule already in `AGENTS.md`, and an empty week.
+
+```bash
+agent-sdk eval
+```
+
+Eval sessions skip the GitHub write.
+
+## Deploy
+
+```bash
+agent-sdk deploy
+```
+
+Run it from the agent's git checkout. The command infers repository,
+ref, path, and slug. Production fires the Monday cron. The deployment
+uses the team's Cursor GitHub connection for the watched repo.

package/docs/troubleshooting.md

@@ -42,7 +42,7 @@ not on `PATH`, use `npx @cursor/july`.
 | What you see | What to do |
 | --- | --- |
 | `409` on a follow-up message | Refresh the `continuationToken` or confirm the session is a chat session. Task sessions do not accept follow-ups. |
-| `409 session_busy` on `call --session` | Wait for the model turn to finish, or omit `--session` for a one-off call. |
+| `409 session_busy` on `call --session` | The tool is a write (or declares no effect) and a model turn is running. Wait for the turn to finish, omit `--session` for a one-off call, or declare `effect: "read"` on a tool that only reads so it runs alongside turns. |
 | `403` on stream or follow-up | Use the same auth identity that created the session. Off localhost, pass `--bearer-token` and send it on every request. |
 | Works on localhost; blocked through a tunnel or LAN | Default auth allows only direct loopback callers. Share the host with `--bearer-token <secret>` (or authored `bearerAuth`). Use `--allow-anonymous` only on a trusted private network. |
 | A channel route fails to compile with a schema type error | `GET` routes need a Zod `querySchema`. `POST` / `PUT` / `PATCH` need a Zod `bodySchema`. Use `z.object({})` or `z.unknown()` for open shapes. |
@@ -70,7 +70,7 @@ not on `PATH`, use `npx @cursor/july`.
 | What you see | What to do |
 | --- | --- |
 | `must be defineConnection({ url, oauth: true })` | The connection file needs `oauth: true`, or you passed the wrong connection name to `agent-sdk mcp oauth`. |
-| Local auth works; hosted calls unauthorized | Run `agent-sdk mcp oauth <name> --store`, confirm names with `agent-sdk secrets list <slug>`, then redeploy. |
+| Local auth works; hosted calls unauthorized | Finish Connect on the hosted engine, or run `agent-sdk mcp oauth <name> --store`. Confirm names with `agent-sdk secrets list <slug>`, then redeploy. |
 | Model asks for `mcp_auth` or IDE MCP for a connector it already has | Attached MCP is behind meta-tools. Set `advertiseTools: true` for named tools on local turns, or call it from a host tool via `ctx.host.mcp`. |
 
 See [Host MCP OAuth](./guides/mcp-oauth.md) and

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cursor/july",
-  "version": "0.1.96",
+  "version": "0.1.97",
   "description": "(early alpha) Filesystem-first framework for defining Cursor agents as markdown and TypeScript and serving them over channels with the Cursor SDK.",
   "license": "SEE LICENSE IN LICENSE.md",
   "repository": {

package/skills/create-agent/SKILL.md

@@ -111,7 +111,8 @@ agent-sdk init ./<slug>
    `subagents/<id>/` (needs `description`), `schedules/`, `hooks/`.
    Slack: `agent-sdk slack create --dir ./<slug> --name "<Name>"`,
    not a hand-written channel. Manual Slack app:
-   `agent-sdk slack init --manual`.
+   `agent-sdk slack init --manual` (Slack CLI, or paste at
+   api.slack.com).
 4. `evals/evals.config.ts` with `maxConcurrency: 20` (required;
    cap 200) plus `evals/**/*.eval.ts`. Assert `t.succeeded()` +
    `t.calledTool(...)`. API: `skills/evals/SKILL.md`.

package/skills/mcp-auth/SKILL.md

@@ -30,8 +30,11 @@ can still call `ctx.host.mcp`.
 3. **Allow egress** on hosted non-bootstrap hosts:
    `hosting.egressDomains`.
 4. **Authorize.** Local: `agent-sdk mcp oauth <name>`. Hosted:
-   `agent-sdk mcp oauth <name> --store` then `agent-sdk deploy`.
-   `secrets list` shows the names.
+   finish Connect so the current process can retry, then
+   `agent-sdk mcp oauth <name> --store` and `agent-sdk deploy` so
+   the next pod gets `MCP_OAUTH_*`. `secrets list` shows the names.
+   Secrets are deployment-wide, not per caller. `cursorAccount: true`
+   stays on the Cursor backend.
 
 ```ts
 // agent/mcp-connections/inventory.ts
@@ -75,7 +78,7 @@ the CLI config directory (`mcp-auth.json` or
 | `must be defineConnection({ url, oauth: true })` | Wrong name or missing `oauth: true` |
 | `Unknown MCP connection` | Filename must match the CLI arg |
 | Callback hang | Free port 8787; finish the browser flow here |
-| Hosted 401 | `secrets list`; `--store`; redeploy |
+| Hosted 401 | `secrets list`; Connect or `--store`; redeploy |
 | Model invents `mcp_auth` / IDE MCP | `advertiseTools: true` on local turns |
 
 No raw tokens in git.

package/skills/setup-slack/SKILL.md

@@ -64,28 +64,38 @@ Local serve does not need a hosted engine. Next
 
 ## 2. Manual (`slack init --manual`)
 
-Only when they own the app at api.slack.com.
+Only when they own the app. Preferred: Slack CLI
+(`~/.slack/bin/slack`). Paste at api.slack.com if the CLI is
+missing. Never `slack deploy`; Agent SDK serve owns Socket Mode.
 
 ```bash
 agent-sdk slack init --manual --dir . --name "My Agent"
+# --slack-team T0123ABCD when several workspaces are logged in
+# --no-install to scaffold only
 ```
 
 Writes `agent/channels/slack.ts` (`envPrefix` from the directory),
-manifests under the project state directory, and `env.example`.
-`--channel-posts` subscribes `message.channels` /
-`message.groups`.
+manifests, a `.slack/` project (`get-manifest` → those JSON files),
+and `env.example`. `--channel-posts` subscribes `message.channels`
+/ `message.groups`. If Slack CLI is logged in, this installs the
+app. `--install` fails when that cannot run.
 
 Human gates, one at a time. Stop after each.
 
-1. **Create the app.** Create New App → From a manifest. Start
-   with `manifest.dev.json`.
-2. **Install.** Install to Workspace. Copy the bot token
-   (`xoxb-...`).
-3. **App token.** Create an app-level token with
-   `connections:write` (`xapp-...`).
-4. **Write env.** Put both in `.env.local`. Then doctor.
-
-Repeat for prod with the prod manifest.
+1. **Install the app.** If `next` starts with "Ask the user to
+   install this Slack app", stop and prompt them. Slack CLI: they
+   run `slack login --no-prompt`, send `/slackauthticket <ticket>`,
+   then `slack login --ticket <ticket> --challenge <code>`, then
+   `slack app install --environment local --team <T> --force`.
+   Prod: `SLACK_ENV=deployed slack app install --environment
+   deployed --team <T> --force`. Fallback: Create New App → From a
+   manifest, start with `.slack/manifest.dev.json`.
+2. **Tokens.** Slack CLI leaves xoxb / xapp in that process only.
+   Copy the bot token from the app's OAuth page. Mint an app-level
+   token with `connections:write`. Put both in `.env.local` using
+   `env.example` names. If Slack CLI wrote `SLACK_*` to `.env`,
+   copy those values to the prefixed keys.
+3. **Doctor.**
 
 ## 3. Doctor and smoke
 

package/src/bin/agent-serve.ts

@@ -140,7 +140,7 @@ Usage:
   ${CLI} deploy      [--dir <path>] [--slug <slug> | --all] [--team <id>] [--json]
                           [--no-wait] [--repo <url>] [--ref <ref>]
                           [--path <agentPath>] [--cursor-events-repo <owner/name>]...
-                          [--allow-domain <domain>]...
+                          [--allow-domain <domain>]... [--multi-tenant]
   ${CLI} manifest    [--dir <path>] [--json]
   ${CLI} deployments [--team <id>] [--json]
   ${CLI} deployment  <slug> [--team <id>] [--json]
@@ -268,6 +268,8 @@ Commands:
               (flags always win). When --dir is a multi-agent parent,
               pick one interactively, or pass --slug / --all. First deploy
               of a slug prints the alias token exactly once — save it.
+              --multi-tenant adds a release to an existing Cursor-managed
+              product (v2 only); it cannot create a new multi-tenant app.
   deployments List the team's deployments (slug, status, generation, kind).
   deployment  Show one deployment in full (status, lastError, engine info).
   stop        Stop a deployment and wait until it reports stopped.
@@ -430,6 +432,9 @@ Options:
   --allow-domain     deploy: egress domain the engine pod may reach
                      (repeatable; unioned with hosting.egressDomains from the
                      agent manifest). Repo-backed deploys only.
+  --multi-tenant     deploy: add a release to an existing Cursor-managed
+                     (multi-tenant) product. architecture v2 only. Cannot
+                     create a new multi-tenant application.
   --from-argv        secrets set: allow NAME=VALUE on argv (leaks into shell
                      history and agent-captured terminals). Default is names
                      only with a hidden prompt or piped stdin.
@@ -439,6 +444,8 @@ Options:
                      GITHUB_WEBHOOK_SECRET). github: --events overrides the
                      derived webhook event list.
   --install          github: install the cli/gh-webhook extension if missing.
+                     slack init --manual: require Slack CLI app install.
+  --no-install       slack init --manual: skip Slack CLI app install.
   --action           github replay: event action (e.g. opened, synchronize).
   --conclusion       github replay: CI conclusion (check_run/suite/status).
   --comment          github replay: comment body for comment events.
@@ -557,6 +564,7 @@ async function main(argv: string[]): Promise<number> {
       secret: { type: "string" },
       channel: { type: "string", multiple: true },
       install: { type: "boolean", default: false },
+      "no-install": { type: "boolean", default: false },
       action: { type: "string" },
       conclusion: { type: "string" },
       context: { type: "string" },
@@ -570,6 +578,7 @@ async function main(argv: string[]): Promise<number> {
       all: { type: "boolean", default: false },
       "cursor-events-repo": { type: "string", multiple: true },
       "allow-domain": { type: "string", multiple: true },
+      "multi-tenant": { type: "boolean", default: false },
       "from-argv": { type: "boolean", default: false },
       strict: { type: "boolean", default: false },
       junit: { type: "string" },
@@ -622,6 +631,8 @@ async function main(argv: string[]): Promise<number> {
         icon: values.icon,
         force: values.force,
         manual: values.manual,
+        install: values.install,
+        noInstall: values["no-install"],
         iconSource: positionals[0] === "icon" ? positionals[1] : undefined,
       });
     }
@@ -757,6 +768,7 @@ async function main(argv: string[]): Promise<number> {
         ...(values["allow-domain"] === undefined
           ? {}
           : { allowDomains: values["allow-domain"] }),
+        multiTenant: values["multi-tenant"] === true,
       });
     }
 

package/src/channels/origin/api.ts

@@ -9,8 +9,8 @@
  * from options first, then the environment: `ORIGIN_APP_ID` (or
  * `AGENT_SERVE_ORIGIN_APP_ID`), `ORIGIN_APP_INSTALLATION_ID`,
  * `ORIGIN_APP_PRIVATE_KEY` (PKCS8 PEM for the app's Ed25519 key; literal
- * `\n` sequences are normalized), and `ORIGIN_API_BASE_URL` for the public
- * REST base.
+ * `\n` sequences are normalized), `ORIGIN_API_BASE_URL` for the public REST
+ * base, and `ORIGIN_RPC_BASE_URL` for the first-party ConnectRPC base.
  *
  * Hosted v2 forks configure none of that: their only credential is the
  * deployment service account's `CURSOR_API_KEY`, exchanged for a Cursor
@@ -40,6 +40,15 @@ import {
  */
 export const DEFAULT_ORIGIN_PUBLIC_API_BASE_URL = "https://api.cursor.com";
 
+/**
+ * Origin's first-party ConnectRPC host (`origin.v1.OriginService`). Separate
+ * deployment from {@link DEFAULT_ORIGIN_PUBLIC_API_BASE_URL}: a handful of
+ * workflow operations — comment reactions among them — have no
+ * `/v1/origin/...` REST binding yet and are only reachable as Connect unary
+ * JSON here.
+ */
+export const DEFAULT_ORIGIN_RPC_BASE_URL = "https://api.origin.cursor.com";
+
 /** Fixed audience for Origin app JWTs (`APP_TOKEN_AUDIENCE` backend-side). */
 const ORIGIN_APP_TOKEN_AUDIENCE = "origin-apps";
 const APP_JWT_TTL_SECONDS = 5 * 60;
@@ -139,6 +148,12 @@ export function originPublicApiBaseUrl(
   return fromEnv ?? DEFAULT_ORIGIN_PUBLIC_API_BASE_URL;
 }
 
+/** Origin ConnectRPC base. Trailing slashes are stripped for path joins. */
+export function originRpcBaseUrl(env: NodeJS.ProcessEnv = process.env): string {
+  const fromEnv = envValue(env.ORIGIN_RPC_BASE_URL)?.replace(/\/+$/, "");
+  return fromEnv ?? DEFAULT_ORIGIN_RPC_BASE_URL;
+}
+
 function base64UrlJson(value: unknown): string {
   return Buffer.from(JSON.stringify(value)).toString("base64url");
 }
@@ -376,9 +391,10 @@ export interface OriginClientOptions {
   token?: string | OriginTokenProvider;
   /**
    * App credentials to mint installation tokens from. Defaults to the
-   * environment ({@link resolveOriginAppCredentials}).
+   * environment ({@link resolveOriginAppCredentials}). Pass `false` to
+   * disable app credential lookup and force the Cursor-account exchange.
    */
-  credentials?: OriginAppCredentials;
+  credentials?: OriginAppCredentials | false;
   /** Public Origin REST base. Defaults to `ORIGIN_API_BASE_URL` / prod. */
   apiBaseUrl?: string;
   /** Injectable fetch for tests. */
@@ -441,7 +457,10 @@ export function createOriginClient(
       return await options.token();
     }
     if (tokenProvider === undefined) {
-      const credentials = options.credentials ?? resolveOriginAppCredentials();
+      const credentials =
+        options.credentials === false
+          ? undefined
+          : (options.credentials ?? resolveOriginAppCredentials());
       const exchange = options.cursorAccountExchange ?? true;
       const exchangeOptions =
         exchange === false ? undefined : exchange === true ? {} : exchange;

package/src/channels/origin/binding.ts

@@ -13,6 +13,7 @@ import {
   createOriginClient,
   type OriginApiMethod,
   type OriginClient,
+  originRpcBaseUrl,
   resolveOriginAppCredentialParts,
 } from "./api.js";
 import {
@@ -20,6 +21,10 @@ import {
   type OriginCheck,
   type OriginCheckCreateInput,
 } from "./checks.js";
+import {
+  type OriginCommentReactionInput,
+  setOriginCommentReaction,
+} from "./reactions.js";
 import type { OriginAppOptions, OriginRepositoryRef } from "./types.js";
 
 /** Origin operations exposed to hooks (`ctx.origin`). */
@@ -44,53 +49,77 @@ export interface OriginHandle {
   createCheck(
     input: Omit<OriginCheckCreateInput, "origin" | "owner" | "repo">
   ): Promise<OriginCheck>;
+  /**
+   * Add or remove one reaction on a PR comment — the Origin analogue of
+   * GitHub's `thread.react("eyes")`. Needs
+   * `repository:pull_requests:reviews:write`. Reactions have no REST
+   * binding, so this call goes to Origin's ConnectRPC host rather than the
+   * public API base {@link request} uses.
+   */
+  reactToComment(input: OriginCommentReactionInput): Promise<void>;
 }
 
 export function buildOriginBinding(input: {
   repository: OriginRepositoryRef;
   /** Installation id from the delivery envelope, when present. */
   installationId?: string;
+  /** Force the signed-in Cursor account / deployment SA credential path. */
+  cursorAccount?: boolean;
   /** Channel-authored outbound app credentials / API base. */
   app?: OriginAppOptions;
   /** Injectable fetch for tests. */
   fetch?: typeof fetch;
 }): OriginHandle {
-  let client: OriginClient | undefined;
-  const getClient = (): OriginClient => {
-    if (client === undefined) {
-      const fromEnv = resolveOriginAppCredentialParts();
-      const appId = input.app?.appId ?? fromEnv.appId;
-      const installationId =
-        input.app?.installationId ??
-        input.installationId ??
-        fromEnv.installationId;
-      const privateKey = input.app?.privateKey ?? fromEnv.privateKey;
-      const credentials =
-        appId !== undefined &&
-        installationId !== undefined &&
-        privateKey !== undefined
-          ? { appId, installationId, privateKey }
-          : undefined;
-      client = createOriginClient({
-        token: input.app?.token,
-        credentials,
-        apiBaseUrl: input.app?.apiBaseUrl,
-        fetch: input.fetch,
-      });
-    }
-    return client;
+  const buildClient = (apiBaseUrl: string | undefined): OriginClient => {
+    const fromEnv = input.cursorAccount
+      ? {}
+      : resolveOriginAppCredentialParts();
+    const appId = input.app?.appId ?? fromEnv.appId;
+    const installationId =
+      input.app?.installationId ??
+      input.installationId ??
+      fromEnv.installationId;
+    const privateKey = input.app?.privateKey ?? fromEnv.privateKey;
+    const credentials =
+      appId !== undefined &&
+      installationId !== undefined &&
+      privateKey !== undefined
+        ? { appId, installationId, privateKey }
+        : undefined;
+    return createOriginClient({
+      token: input.cursorAccount ? undefined : input.app?.token,
+      credentials: input.cursorAccount ? false : credentials,
+      apiBaseUrl,
+      fetch: input.fetch,
+    });
+  };
+
+  // Public REST and ConnectRPC are separate Origin deployments, so the
+  // handle keeps a client per host. Both stay lazy: a hook that touches
+  // neither needs no credential.
+  let restClient: OriginClient | undefined;
+  const getRestClient = (): OriginClient => {
+    restClient ??= buildClient(input.app?.apiBaseUrl);
+    return restClient;
+  };
+  let rpcClient: OriginClient | undefined;
+  const getRpcClient = (): OriginClient => {
+    rpcClient ??= buildClient(input.app?.rpcBaseUrl ?? originRpcBaseUrl());
+    return rpcClient;
   };
 
   return {
     installationId: input.app?.installationId ?? input.installationId,
     repository: input.repository,
-    request: (request) => getClient().request(request),
+    request: (request) => getRestClient().request(request),
     createCheck: (check) =>
       createOriginCheck({
         ...check,
-        origin: getClient(),
+        origin: getRestClient(),
         owner: input.repository.owner,
         repo: input.repository.name,
       }),
+    reactToComment: (reaction) =>
+      setOriginCommentReaction({ ...reaction, origin: getRpcClient() }),
   };
 }

package/src/channels/origin/index.ts

@@ -29,4 +29,5 @@ export * from "./cursor-account.js";
 export * from "./events.js";
 export * from "./origin-channel.js";
 export * from "./origin-webhook.js";
+export * from "./reactions.js";
 export * from "./types.js";

package/src/channels/origin/origin-channel.ts

@@ -306,6 +306,7 @@ export function parseOriginPullRequestEvent(input: {
       repository,
       pullRequestNumber: number,
       pullRequestUrl: url,
+      pullRequestAuthor: author,
       payload,
       sender: originSender(input.envelope, payload),
     },
@@ -432,6 +433,9 @@ function enrichEventContext(input: {
     origin: buildOriginBinding({
       repository: input.ctx.repository,
       installationId: input.ctx.installationId,
+      cursorAccount:
+        input.options.cursorAccount !== undefined &&
+        input.options.cursorAccount !== false,
       app: input.options.app,
     }),
   };

package/src/channels/origin/reactions.ts

@@ -0,0 +1,82 @@
+/**
+ * Origin PR comment reactions — the Origin analogue of the GitHub channel's
+ * `thread.react("eyes")`.
+ *
+ * Unlike checks and comments, reactions have no `/v1/origin/...` REST
+ * binding. The only write is Connect unary JSON against Origin's first-party
+ * service (`origin.v1.OriginService/SetCommentReaction`), which lives on a
+ * different host than the public REST API — {@link originRpcBaseUrl}, not
+ * {@link originPublicApiBaseUrl}. `ctx.origin.reactToComment` already points
+ * at the right one; a hand-built client must too.
+ *
+ * Writing needs `repository:pull_requests:reviews:write`: an `oit_…`
+ * installation token for app channels, or a deployment service-account
+ * session (hosted v2 forks). Origin rejects reactions on comments that
+ * belong to an unsubmitted review. API failures throw `OriginApiError`.
+ */
+
+import type { OriginApiMethod } from "./api.js";
+
+/** Any client that can call Origin's ConnectRPC host. */
+export interface OriginReactionClient {
+  request<T = unknown>(input: {
+    method: OriginApiMethod;
+    path: string;
+    body?: unknown;
+  }): Promise<T>;
+}
+
+/** Connect unary route backing {@link setOriginCommentReaction}. */
+export const SET_ORIGIN_COMMENT_REACTION_PATH =
+  "/origin.v1.OriginService/SetCommentReaction";
+
+/**
+ * The eight reactions Origin accepts. Anything else is rejected with
+ * `invalid_argument`, so channels get a compile error instead of a 400.
+ */
+export const ORIGIN_COMMENT_REACTIONS = [
+  "👍",
+  "👎",
+  "😄",
+  "🎉",
+  "😕",
+  "❤️",
+  "🚀",
+  "👀",
+] as const;
+
+export type OriginCommentReaction = (typeof ORIGIN_COMMENT_REACTIONS)[number];
+
+export interface OriginCommentReactionInput {
+  /** Origin comment TypeID (`cmt_…`), i.e. `comment.id` on a comment hook. */
+  commentId: string;
+  emoji: OriginCommentReaction;
+  /** `false` removes the reaction. Removing one that is absent is a no-op. */
+  active?: boolean;
+}
+
+/**
+ * Add (or, with `active: false`, remove) one reaction on an Origin PR
+ * comment as the client's own principal.
+ *
+ * ```ts
+ * await setOriginCommentReaction({
+ *   origin: createOriginClient({ apiBaseUrl: originRpcBaseUrl() }),
+ *   commentId: comment.id,
+ *   emoji: "👀",
+ * });
+ * ```
+ */
+export async function setOriginCommentReaction(
+  input: OriginCommentReactionInput & { origin: OriginReactionClient }
+): Promise<void> {
+  await input.origin.request({
+    method: "POST",
+    path: SET_ORIGIN_COMMENT_REACTION_PATH,
+    body: {
+      commentId: input.commentId,
+      emoji: input.emoji,
+      active: input.active ?? true,
+    },
+  });
+}

package/src/channels/origin/types.ts

@@ -58,6 +58,11 @@ export interface OriginEventContext {
   repository: OriginRepositoryRef;
   pullRequestNumber: number;
   pullRequestUrl: string;
+  /**
+   * Who opened the pull request, when the payload carries it. Distinct from
+   * {@link sender} — on a comment event the sender is the commenter.
+   */
+  pullRequestAuthor?: OriginActor;
   /**
    * Raw parsed `event.payload` record (`{}` when absent), for consumers
    * whose normalization needs more than the typed event — the GitHub
@@ -152,6 +157,12 @@ export interface OriginAppOptions {
   token?: string | OriginTokenProvider;
   /** Public Origin REST base, e.g. `https://api.cursor.com`. */
   apiBaseUrl?: string;
+  /**
+   * Origin ConnectRPC base for operations without a REST binding (comment
+   * reactions), e.g. `https://api.origin.cursor.com`. Falls back to
+   * `ORIGIN_RPC_BASE_URL`.
+   */
+  rpcBaseUrl?: string;
 }
 
 export interface OriginChannelOptions {