@cursor/july 0.1.54 → 0.1.61

package/src/internal/init-project.ts

@@ -3,7 +3,7 @@
  */
 
 import { spawn } from "node:child_process";
-import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { mkdir, readdir, readFile, writeFile } from "node:fs/promises";
 import { basename, dirname, join, relative, resolve } from "node:path";
 import type { ModelSetting } from "../types.js";
@@ -13,6 +13,14 @@ import {
   packageRootDir,
   packageVersion,
 } from "./distribution.js";
+import {
+  applyInitReplacements,
+  isTemplateMetaPath,
+  loadTemplateInitSpec,
+  posixRel,
+  type TemplateInitSpec,
+  templateFileHasReplacements,
+} from "./init-interview.js";
 import {
   makePalette,
   stdoutPalette,
@@ -27,6 +35,11 @@ export interface InitProjectOptions {
   /** Model id override written into agent.ts. */
   model?: string;
   templateDir?: string;
+  overlayDir?: string;
+  templateName?: string;
+  /** Answers collected from `init.json` / `--var`. */
+  answers?: Record<string, string>;
+  initSpec?: TemplateInitSpec;
 }
 
 export type InitFileAction = "create" | "exist";
@@ -46,23 +59,30 @@ export interface InitProjectResult {
   skipped: string[];
 }
 
+type TemplateEntry = {
+  dir: string;
+  overlay?: string;
+};
+
+const TEMPLATES: Readonly<Record<string, TemplateEntry>> = {
+  "agentic-owners": { dir: "agentic-owners" },
+  demo: { dir: "demo" },
+  "pr-autofixer": { dir: "pr-autofixer" },
+  "security-reviewer": { dir: "security-reviewer" },
+  "triage-linear": { dir: "triage", overlay: "linear" },
+  "triage-jira": { dir: "triage", overlay: "jira" },
+};
+
+function canonicalTemplateName(name: string): string {
+  return name === "triage" ? "triage-linear" : name;
+}
+
 export function availableTemplates(): string[] {
-  const templatesDir = join(packageRootDir(), "templates");
-  try {
-    return readdirSync(templatesDir, { withFileTypes: true })
-      .filter((entry) => entry.isDirectory())
-      .map((entry) => entry.name)
-      .sort();
-  } catch (error) {
-    if (hasErrorCode(error, "ENOENT")) {
-      return [];
-    }
-    throw error;
-  }
+  return Object.keys(TEMPLATES).sort();
 }
 
 export type TemplateResolution =
-  | { ok: true; name: string; dir: string }
+  | { ok: true; name: string; dir: string; overlayDir?: string }
   | { ok: false; message: string };
 
 export function resolveTemplate(name: string): TemplateResolution {
@@ -72,21 +92,23 @@ export function resolveTemplate(name: string): TemplateResolution {
       message: "template name must match /^[a-z][a-z0-9-]*$/",
     };
   }
-  const available = availableTemplates();
-  if (!available.includes(name)) {
-    const detail =
-      available.length === 0
-        ? "no templates ship with this build"
-        : `available: ${available.join(", ")}`;
+  const resolved = canonicalTemplateName(name);
+  const entry = TEMPLATES[resolved];
+  if (entry === undefined) {
     return {
       ok: false,
-      message: `unknown template "${name}" (${detail})`,
+      message: `unknown template "${name}" (available: ${availableTemplates().join(", ")})`,
     };
   }
+  const dir = join(packageRootDir(), "templates", entry.dir);
   return {
     ok: true,
-    name,
-    dir: join(packageRootDir(), "templates", name),
+    name: resolved,
+    dir,
+    overlayDir:
+      entry.overlay === undefined
+        ? undefined
+        : join(dir, "overlays", entry.overlay),
   };
 }
 
@@ -121,6 +143,13 @@ export function checkInitTarget(
   if (marker === template) {
     return { ok: true };
   }
+  if (
+    marker !== undefined &&
+    template !== undefined &&
+    canonicalTemplateName(marker) === canonicalTemplateName(template)
+  ) {
+    return { ok: true };
+  }
   if (template === undefined) {
     return {
       ok: false,
@@ -194,28 +223,38 @@ export async function initProject(
 
   if (options.templateDir !== undefined) {
     const templateDir = options.templateDir;
-    const entries = await readdir(templateDir, {
-      recursive: true,
-      withFileTypes: true,
-    });
-    const relativePaths = entries
-      .filter((entry) => entry.isFile())
-      .map((entry) => relative(templateDir, join(entry.parentPath, entry.name)))
-      .sort();
-    for (const rel of relativePaths) {
-      const source = join(templateDir, rel);
-      if (rel === "package.json") {
-        const packageJson: {
-          name: string;
-          dependencies: Record<string, string>;
-          [key: string]: unknown;
-        } = JSON.parse(await readFile(source, "utf8"));
-        packageJson.name = projectName;
-        packageJson.dependencies[PACKAGE_NAME] = `^${packageVersion()}`;
-        packageJson.cursorAgentTemplate = basename(templateDir);
-        await write(rel, `${JSON.stringify(packageJson, null, 2)}\n`);
-      } else {
-        await write(rel, await readFile(source));
+    const overlayDir = options.overlayDir;
+    const overlayPaths = overlayDir ? await listTemplateFiles(overlayDir) : [];
+    const overlaySet = new Set(overlayPaths);
+    const corePaths = (await listTemplateFiles(templateDir)).filter(
+      (rel) => !overlaySet.has(rel)
+    );
+    const templateName = options.templateName ?? basename(templateDir);
+    const initSpec =
+      options.initSpec ?? (await loadTemplateInitSpec(templateDir));
+    const answers = options.answers ?? {};
+    for (const rel of corePaths) {
+      await writeTemplateFile({
+        write,
+        sourceDir: templateDir,
+        rel,
+        projectName,
+        templateName,
+        initSpec,
+        answers,
+      });
+    }
+    if (overlayDir !== undefined) {
+      for (const rel of overlayPaths) {
+        await writeTemplateFile({
+          write,
+          sourceDir: overlayDir,
+          rel,
+          projectName,
+          templateName,
+          initSpec,
+          answers,
+        });
       }
     }
     return {
@@ -346,6 +385,60 @@ export default memoryHook();
   };
 }
 
+async function listTemplateFiles(root: string): Promise<string[]> {
+  const entries = await readdir(root, {
+    recursive: true,
+    withFileTypes: true,
+  });
+  return entries
+    .filter((entry) => entry.isFile())
+    .map((entry) =>
+      posixRel(relative(root, join(entry.parentPath, entry.name)))
+    )
+    .filter((rel) => !isTemplateMetaPath(rel))
+    .sort();
+}
+
+async function writeTemplateFile(input: {
+  write: (rel: string, contents: string | Uint8Array) => Promise<void>;
+  sourceDir: string;
+  rel: string;
+  projectName: string;
+  templateName: string;
+  initSpec?: TemplateInitSpec;
+  answers: Record<string, string>;
+}): Promise<void> {
+  const source = join(input.sourceDir, input.rel);
+  if (input.rel === "package.json") {
+    const packageJson: {
+      name: string;
+      dependencies: Record<string, string>;
+      [key: string]: unknown;
+    } = JSON.parse(await readFile(source, "utf8"));
+    packageJson.name = input.projectName;
+    packageJson.dependencies[PACKAGE_NAME] = `^${packageVersion()}`;
+    packageJson.cursorAgentTemplate = input.templateName;
+    await input.write(input.rel, `${JSON.stringify(packageJson, null, 2)}\n`);
+    return;
+  }
+  if (
+    input.initSpec !== undefined &&
+    templateFileHasReplacements(input.initSpec, input.rel)
+  ) {
+    await input.write(
+      input.rel,
+      applyInitReplacements(
+        await readFile(source, "utf8"),
+        input.rel,
+        input.initSpec,
+        input.answers
+      )
+    );
+    return;
+  }
+  await input.write(input.rel, await readFile(source));
+}
+
 export function isEexist(error: unknown): boolean {
   return hasErrorCode(error, "EEXIST");
 }
@@ -740,7 +833,14 @@ export function printInitGuide(): void {
 
 Scaffold a project, then open the playground:
   npx ${PACKAGE_NAME} init ./my-agent   # installs deps + links agent-sdk onto PATH
-  npx ${PACKAGE_NAME} init ./my-triage --template triage   # start from a template (agent-sdk templates: triage)
+  npx ${PACKAGE_NAME} init ./my-demo --template demo              # record a PR walkthrough
+  npx ${PACKAGE_NAME} init ./my-reviewer --template security-reviewer   # review PRs for security bugs
+  npx ${PACKAGE_NAME} init ./my-triage --template triage-linear   # comment on Linear issues
+  npx ${PACKAGE_NAME} init ./my-triage --template triage-jira     # comment on Jira issues
+  npx ${PACKAGE_NAME} init ./my-owners --template agentic-owners  # review PRs via owners policies
+  npx ${PACKAGE_NAME} init ./pr-autofixer --template pr-autofixer # fix PRs on a cloud VM
+  # TTY asks for GitHub repos. Scripts pass --var:
+  #   --var repos=acme/widgets,acme/api
   cd ./my-agent && agent-sdk dev        # or: npx ${PACKAGE_NAME} dev
 
 Recommended loop once the project exists (from the project directory):

package/src/internal/mcp-endpoint.ts

@@ -82,6 +82,13 @@ interface ConnectableMcpServer {
  * transport per POST, JSON response mode, spec-compliant 405 on other
  * methods. Shared by the per-agent MCP endpoint and the Cursor account
  * bridge so the subtle transport/error plumbing exists once.
+ *
+ * Origin MCP in `backend/server/src/origin/mcp/originMcpHttpHandler.ts`
+ * is not a 1:1 copy: it races `request.signal` so a tool that ignores abort
+ * cannot hang, while this helper has no such backstop and still leaks an
+ * unsettled promise. backend/server cannot import `@cursor/july` internals,
+ * so Origin diverges on purpose. Do not extract a shared package, and do
+ * not port the abort race here, in that stack.
  */
 export async function handleStatelessMcpRequest(args: {
   request: Request;

package/src/internal/server.ts

@@ -17,7 +17,6 @@ import { join } from "node:path";
 import {
   type CursorGithubRepoScope,
   createCursorAccountGithubTokenResolver,
-  cursorGithubPermissionsForChannel,
   type GithubCursorAccountRuntime,
   getGithubCursorAccountRuntime,
   parseCursorGithubRepoScope,
@@ -25,6 +24,12 @@ import {
   resolveCursorGithubProxyUrl,
 } from "../channels/github/cursor-account.js";
 import { findGitHubChannelTargets } from "../channels/github/forward.js";
+import {
+  getOriginCursorAccountRuntime,
+  type OriginCursorAccountRuntime,
+  parseCursorOriginRepoScope,
+} from "../channels/origin/cursor-account.js";
+import { findOriginChannelTargets } from "../channels/origin/origin-channel.js";
 import {
   dispatchCursorSlackEnvelope,
   getSlackCursorAccountRuntime,
@@ -59,9 +64,11 @@ import {
 import { CursorGithubCredentialProvider } from "./cursor/github-credentials.js";
 import {
   CursorEventRelay,
+  type CursorScmSubscription,
   formatCursorScmDispatchOutcome,
   formatCursorScmEventLog,
   scmMetadataToGitHubPayload,
+  scmMetadataToOriginPayload,
 } from "./cursor-event-relay.js";
 import {
   type CursorSlackAgentRegistration,
@@ -89,6 +96,7 @@ import {
 } from "./eval-run-store.js";
 import {
   collectGitHubTriggerTargets,
+  collectOriginTriggerTargets,
   handleAgentServeTrigger,
 } from "./handleAgentServeTrigger.js";
 import { createHostPlatforms, warmupHostGitHubAuth } from "./host-platforms.js";
@@ -151,11 +159,7 @@ import {
 } from "./resolved-connections.js";
 import { Router } from "./router.js";
 import { ScheduleRunner, UnknownScheduleError } from "./schedule-runner.js";
-import {
-  type AgentRunner,
-  CursorSdkRunner,
-  resolveServeWorkspaceScanCacheTtlMs,
-} from "./sdk-runner.js";
+import { type AgentRunner, CursorSdkRunner } from "./sdk-runner.js";
 import {
   SessionAuthError,
   SessionBusyError,
@@ -267,11 +271,20 @@ export async function startServer(
   }
 
   const cursorGithubTargets = collectCursorGithubTargets(mounts);
+  const cursorOriginTargets = collectCursorOriginTargets(mounts);
   const cursorGithubConfig = resolveCursorGithubEventConfig({
     configured: options.cursorEvents,
     targets: cursorGithubTargets,
   });
-  const effectiveCursorEvents = cursorGithubConfig.cursorEvents;
+  const cursorOriginScope = resolveCursorOriginRepoScope({
+    explicitRepos: options.cursorEvents?.repos ?? [],
+    targets: cursorOriginTargets,
+  });
+  const effectiveCursorEvents =
+    cursorGithubConfig.cursorEvents ??
+    (cursorOriginScope === undefined
+      ? undefined
+      : { repos: [...cursorOriginScope.repos] });
 
   // One resolution for every Cursor credential consumer (SDK runner, account
   // MCP bridge, SCM event relay, GitHub credentials): explicit option →
@@ -379,17 +392,11 @@ export async function startServer(
       "[agent-sdk] warning: --allow-anonymous admits every HTTP caller as the same principal; use only on a trusted network (e.g. Tailscale) and prefer --bearer-token for shared hosts"
     );
   }
-  const workspaceScanCacheTtlMs = resolveServeWorkspaceScanCacheTtlMs({
-    dev,
-  });
   const runner =
     options.runner ??
     new CursorSdkRunner({
       ...(accountKey === undefined ? {} : { apiKey: accountKey.apiKey }),
       logger,
-      ...(workspaceScanCacheTtlMs === undefined
-        ? {}
-        : { workspaceScanCacheTtlMs }),
     });
 
   const router = new Router();
@@ -684,7 +691,7 @@ export async function startServer(
   // job (backend `/github_webhook` already verified); we only admit loopback
   // so this route is not a public unsigned endpoint. Agents decide whether
   // to run via their onPullRequest / onComment / … hooks.
-  const collectTriggerTargets = () =>
+  const collectGitHubTargets = () =>
     collectGitHubTriggerTargets({
       mounts: runtimes.map((runtime) => ({
         slug: runtime.slug,
@@ -693,6 +700,15 @@ export async function startServer(
           buildChannelHandlerArgs({ runtime, channelId }),
       })),
     });
+  const collectOriginTargets = () =>
+    collectOriginTriggerTargets({
+      mounts: runtimes.map((runtime) => ({
+        slug: runtime.slug,
+        channels: runtime.project.channels,
+        buildHandlerArgs: (channelId) =>
+          buildChannelHandlerArgs({ runtime, channelId }),
+      })),
+    });
   router.add({
     method: "POST",
     pattern: "/v1/webhooks/github",
@@ -704,7 +720,7 @@ export async function startServer(
         bodyText,
         eventName: request.headers.get("x-github-event"),
         deliveryId: request.headers.get("x-github-delivery") ?? undefined,
-        targets: collectTriggerTargets(),
+        targets: collectGitHubTargets(),
       });
       const status = result.ok ? 202 : (result.targets[0]?.status ?? 500);
       return jsonResponse(result, { status });
@@ -743,13 +759,17 @@ export async function startServer(
   // Cursor SCM events relay (opt-in: serve({ cursorEvents }) / --cursor-events).
   const cursorEventRelay = startCursorEventRelay({
     config: effectiveCursorEvents,
+    githubRepos: cursorGithubConfig.cursorEvents?.repos ?? [],
+    originRepos: cursorOriginScope?.repos ?? [],
     stateRoot: options.stateRoot,
     mounts,
     auth: cursorEventsAuth,
     logger,
-    collectTriggerTargets,
+    collectGitHubTargets,
+    collectOriginTargets,
     cursorAccountOnly:
-      options.cursorEvents === undefined && cursorGithubTargets.length > 0,
+      options.cursorEvents === undefined &&
+      (cursorGithubTargets.length > 0 || cursorOriginTargets.length > 0),
   });
 
   const server = createServer((req, res) => {
@@ -1759,37 +1779,73 @@ function requireCursorEventsAuth(
 /**
  * Opt-in Cursor SCM events relay. Credentials are already required by
  * {@link requireCursorEventsAuth}; the remaining unusable configs (no repos,
- * no github channel) warn and leave the relay off — serve still starts.
+ * no github/origin channel) warn and leave the relay off — serve still starts.
+ *
+ * GitHub and Origin subscriptions are registered independently so mirrored
+ * `owner/name` slugs do not mix. `--cursor-events --repo` feeds GitHub
+ * channels; Origin is subscribed only when an `originChannel({ cursorAccount })`
+ * opted in.
  */
 function startCursorEventRelay(input: {
   config: ServeOptions["cursorEvents"];
+  githubRepos: readonly string[];
+  originRepos: readonly string[];
   stateRoot: string | undefined;
   mounts: AgentMount[];
   auth: CursorEventsAuth | undefined;
   logger: (line: string) => void;
-  collectTriggerTargets: () => ReturnType<typeof collectGitHubTriggerTargets>;
+  collectGitHubTargets: () => ReturnType<typeof collectGitHubTriggerTargets>;
+  collectOriginTargets: () => ReturnType<typeof collectOriginTriggerTargets>;
   cursorAccountOnly: boolean;
 }): CursorEventRelay | undefined {
-  const { config, stateRoot, mounts, auth, logger, collectTriggerTargets } =
-    input;
+  const { config, stateRoot, mounts, auth, logger } = input;
   if (config === undefined || auth === undefined) {
     return undefined;
   }
-  const repos = [...new Set(config.repos.map((repo) => repo.trim()))].filter(
-    (repo) => repo.length > 0
-  );
-  if (repos.length === 0) {
-    logger(
-      "[agent-sdk] cursor-events: no repos configured (pass --repo owner/name); relay disabled"
-    );
-    return undefined;
-  }
   const githubTargets = findGitHubChannelTargets(mounts);
-  const events = [...new Set(githubTargets.flatMap((target) => target.events))];
-  if (events.length === 0) {
-    logger(
-      "[agent-sdk] cursor-events: no mounted agent declares a github channel; relay disabled"
-    );
+  const originTargets = findOriginChannelTargets(mounts);
+  const githubEvents = [
+    ...new Set(githubTargets.flatMap((target) => target.events)),
+  ];
+  const originEvents = [
+    ...new Set(originTargets.flatMap((target) => target.events)),
+  ];
+  const githubRepos = [
+    ...new Set(input.githubRepos.map((repo) => repo.trim().toLowerCase())),
+  ].filter((repo) => repo.length > 0);
+  const originRepos = [
+    ...new Set(input.originRepos.map((repo) => repo.trim().toLowerCase())),
+  ].filter((repo) => repo.length > 0);
+
+  const subscriptions: CursorScmSubscription[] = [];
+  if (githubEvents.length > 0 && githubRepos.length > 0) {
+    for (const repo of githubRepos) {
+      subscriptions.push({
+        provider: "github",
+        repo,
+        events: githubEvents,
+      });
+    }
+  }
+  if (originEvents.length > 0 && originRepos.length > 0) {
+    for (const repo of originRepos) {
+      subscriptions.push({
+        provider: "origin",
+        repo,
+        events: originEvents,
+      });
+    }
+  }
+  if (subscriptions.length === 0) {
+    if (githubRepos.length === 0 && originRepos.length === 0) {
+      logger(
+        "[agent-sdk] cursor-events: no repos configured (pass --repo owner/name); relay disabled"
+      );
+    } else {
+      logger(
+        "[agent-sdk] cursor-events: no mounted agent declares a github or origin channel; relay disabled"
+      );
+    }
     return undefined;
   }
   const baseStateRoot =
@@ -1798,15 +1854,36 @@ function startCursorEventRelay(input: {
   const relay = new CursorEventRelay({
     baseUrl: auth.baseUrl,
     apiKey: auth.apiKey,
-    repos,
-    events,
+    subscriptions,
     stateDir: join(baseStateRoot, "cursor-events"),
     logger,
-    // Stream is compact metadata (Sand-style); stub a GitHub body from the
-    // envelope — rich pullRequest meta when present for onPullRequest Zod.
     dispatch: async (event) => {
+      if (event.provider === "origin") {
+        const targets = input.collectOriginTargets().filter((target) => {
+          const cursorAccount = target.options.cursorAccount;
+          if (
+            input.cursorAccountOnly &&
+            cursorAccount !== true &&
+            typeof cursorAccount !== "object"
+          ) {
+            return false;
+          }
+          return typeof cursorAccount !== "object"
+            ? true
+            : cursorAccount.repos.some(
+                (repo) => repo.toLowerCase() === event.repo.toLowerCase()
+              );
+        });
+        const result = await handleAgentServeTrigger({
+          type: "origin",
+          bodyText: JSON.stringify(scmMetadataToOriginPayload(event)),
+          targets,
+        });
+        logCursorScmDispatch(logger, event, result);
+        return;
+      }
       if (event.provider !== "github") return;
-      const targets = collectTriggerTargets().filter((target) => {
+      const targets = input.collectGitHubTargets().filter((target) => {
         const cursorAccount = target.options.cursorAccount;
         if (
           input.cursorAccountOnly &&
@@ -1828,27 +1905,35 @@ function startCursorEventRelay(input: {
         deliveryId: event.deliveryId,
         targets,
       });
-      const outcomes = result.targets
-        .map((target) => formatCursorScmDispatchOutcome(target))
-        .join(", ");
-      const rejected = result.targets.filter((target) => target.status >= 400);
-      if (rejected.length > 0) {
-        logger(
-          `[agent-sdk] cursor-events: dropped ${formatCursorScmEventLog(event)} before hook: ${rejected.map(formatCursorScmDispatchOutcome).join(", ")}`
-        );
-      }
-      logger(
-        `[agent-sdk] cursor-events: dispatched ${formatCursorScmEventLog(event)}${outcomes === "" ? "" : ` → ${outcomes}`}`
-      );
+      logCursorScmDispatch(logger, event, result);
     },
   });
   relay.start();
   logger(
-    `[agent-sdk] cursor-events: relaying ${events.length} event kind(s) for ${repos.join(", ")} from ${auth.baseUrl}`
+    `[agent-sdk] cursor-events: relaying ${subscriptions.length} subscription(s) from ${auth.baseUrl}`
   );
   return relay;
 }
 
+function logCursorScmDispatch(
+  logger: (line: string) => void,
+  event: Parameters<typeof formatCursorScmEventLog>[0],
+  result: Awaited<ReturnType<typeof handleAgentServeTrigger>>
+): void {
+  const outcomes = result.targets
+    .map((target) => formatCursorScmDispatchOutcome(target))
+    .join(", ");
+  const rejected = result.targets.filter((target) => target.status >= 400);
+  if (rejected.length > 0) {
+    logger(
+      `[agent-sdk] cursor-events: dropped ${formatCursorScmEventLog(event)} before hook: ${rejected.map(formatCursorScmDispatchOutcome).join(", ")}`
+    );
+  }
+  logger(
+    `[agent-sdk] cursor-events: dispatched ${formatCursorScmEventLog(event)}${outcomes === "" ? "" : ` → ${outcomes}`}`
+  );
+}
+
 interface CursorGithubTarget {
   slug: string;
   channelId: string;
@@ -1893,11 +1978,8 @@ function resolveCursorGithubEventConfig(input: {
     ]),
   ];
   const permissions = resolveCursorGithubPermissions(
-    input.targets.map((target) =>
-      cursorGithubPermissionsForChannel(
-        target.accountRuntime.options,
-        target.accountRuntime.scope?.permissions
-      )
+    input.targets.map(
+      (target) => target.accountRuntime.scope?.permissions ?? "pr-write"
     )
   );
   const scope = parseCursorGithubRepoScope(repos, permissions);
@@ -1910,6 +1992,54 @@ function resolveCursorGithubEventConfig(input: {
   };
 }
 
+interface CursorOriginTarget {
+  slug: string;
+  channelId: string;
+  accountRuntime: OriginCursorAccountRuntime;
+}
+
+function collectCursorOriginTargets(
+  mounts: AgentMount[]
+): CursorOriginTarget[] {
+  const targets: CursorOriginTarget[] = [];
+  for (const mount of mounts) {
+    for (const channel of mount.project.channels) {
+      const accountRuntime = getOriginCursorAccountRuntime(channel.definition);
+      if (accountRuntime !== undefined) {
+        targets.push({
+          slug: mount.slug,
+          channelId: channel.id,
+          accountRuntime,
+        });
+      }
+    }
+  }
+  return targets;
+}
+
+/**
+ * Origin cursorAccount repos. `true` takes the host's explicit `--repo`
+ * list (not GitHub channel-declared repos). `{ repos }` is self-contained.
+ */
+function resolveCursorOriginRepoScope(input: {
+  explicitRepos: readonly string[];
+  targets: CursorOriginTarget[];
+}): ReturnType<typeof parseCursorOriginRepoScope> | undefined {
+  if (input.targets.length === 0) {
+    return undefined;
+  }
+  const wantsHostRepos = input.targets.some(
+    (target) => target.accountRuntime.options.cursorAccount === true
+  );
+  const repos = [
+    ...(wantsHostRepos ? input.explicitRepos : []),
+    ...input.targets.flatMap(
+      (target) => target.accountRuntime.scope?.repos ?? []
+    ),
+  ];
+  return parseCursorOriginRepoScope(repos);
+}
+
 interface CursorSlackTarget {
   runtime: MountedRuntime;
   channelId: string;