@cursor/july 0.1.68 → 0.1.73

package/src/internal/sanitize-mcp-tool-name.ts

@@ -0,0 +1,33 @@
+/**
+ * MCP tool-name sanitization shared by the Cursor-account bridge
+ * (`account-mcp.ts`) and advertised connections (`advertise-tools.ts`).
+ *
+ * Connector display names — and the aggregate `/v1/agent/mcp` names minted
+ * from them (`<serverIdentifier>-<tool>`) — can contain spaces, dots, and
+ * other characters that are illegal as the tool name a model sees.
+ *
+ * Character class matches `packages/agent` `normalizeMcpToolName`
+ * (`[^a-zA-Z0-9_-]` → `_`). Length cap and the empty fallback match the
+ * account bridge (MCP clients commonly enforce `^[a-zA-Z0-9_-]{1,128}$`).
+ * Callers that talk to the backend keep the original advertised name.
+ */
+
+/** MCP clients commonly enforce `^[a-zA-Z0-9_-]{1,128}$` for tool names. */
+export const MAX_MCP_TOOL_NAME_LENGTH = 128;
+
+/** Connector display names can contain anything (spaces, dots, emoji). */
+export function sanitizeMcpToolName(name: string): string {
+  const cleaned = name
+    .replace(/[^a-zA-Z0-9_-]/g, "_")
+    .slice(0, MAX_MCP_TOOL_NAME_LENGTH);
+  return cleaned === "" ? "tool" : cleaned;
+}
+
+/** `base` for the first claimant, `base_2` / `base_3` … for colliders. */
+export function suffixMcpToolName(base: string, index: number): string {
+  if (index === 0) {
+    return base;
+  }
+  const suffix = `_${index + 1}`;
+  return `${base.slice(0, MAX_MCP_TOOL_NAME_LENGTH - suffix.length)}${suffix}`;
+}

package/src/internal/session-engine.ts

@@ -2327,6 +2327,13 @@ export class SessionEngine {
       tools[tool.name] = {
         description: tool.description,
         inputSchema: tool.inputSchema as SDKCustomTool["inputSchema"],
+        // `SDKCustomTool.outputSchema` ships in the next published
+        // @cursor/sdk; the conditional spread carries the field through the
+        // pinned SDK's type until the dependency bumps, at which point local
+        // runs start advertising it.
+        ...(tool.outputSchema === undefined
+          ? {}
+          : { outputSchema: tool.outputSchema }),
         execute: async (args, context) => {
           return this.executeServerTool({
             tool,

package/src/internal/shallow-clone.ts

@@ -5,7 +5,7 @@ import { promisify } from "node:util";
 const execFileAsync = promisify(execFile);
 
 /**
- * Shallow GitHub PR checkout for SDK agents that review a PR's code.
+ * Shallow SCM PR checkout for SDK agents that review a PR's code.
  *
  * Mirrors Bugbot's `shallow_fetch` prefetch strategy
  * (`backend/crates/napi_bugbot/src/temp_clone.rs`): instead of cloning the
@@ -16,11 +16,19 @@ const execFileAsync = promisify(execFile);
  * clone because its tools stream objects on demand; SDK agents read a real
  * working tree, so we materialize the head checkout instead.
  *
- * Auth also mirrors Bugbot's provider model (`IGitProvider.getAccessToken`
- * → token handed straight to git): the clone takes one explicit repo-scoped
- * bearer token. The default source is the serve host's Cursor-account
- * GitHub lease — the same backend `GithubAccessService` mint Bugbot uses —
- * which `CursorGithubCredentialProvider` installs as `GH_TOKEN` for child
+ * SCM support follows Bugbot's provider seam (`IGitProvider.getCloneTarget`
+ * / the Rust `clone_url` dispatch): everything provider-specific — remote
+ * URL shape, git credential username convention, PR head ref layout — lives
+ * in one {@link ScmCloneTarget} produced by {@link resolveScmCloneTarget}.
+ * Supporting another SCM (GitLab, Bitbucket, …) means adding a resolver
+ * case and a default credential source; the fetch/verify/checkout machinery
+ * is provider-agnostic.
+ *
+ * Auth also mirrors Bugbot (`IGitProvider.getAccessToken` → token handed
+ * straight to git): the clone takes one explicit repo-scoped bearer token.
+ * For GitHub the default source is the serve host's Cursor-account lease —
+ * the same backend `GithubAccessService` mint Bugbot uses — which
+ * `CursorGithubCredentialProvider` installs as `GH_TOKEN` for child
  * processes. Where Bugbot embeds the token in the clone URL, this module
  * serves it through an inline credential helper that reads a child-process
  * env var, so the token never lands in argv or in `.git/config` inside a
@@ -31,23 +39,72 @@ const execFileAsync = promisify(execFile);
  * source imports, following `tenant-mcp/run-mcp-registry.ts`.
  */
 
-export type ShallowPrCheckout = {
-  /** Directory containing the PR head working tree (detached at headSha). */
-  checkoutDir: string;
-  headSha: string;
-  /** True when the merge-base commit was also fetched (enables local diffs). */
-  baseFetched: boolean;
-  /** How the head commit was obtained. */
-  headSource: "sha_fetch" | "pr_ref_fetch";
+/** SCMs with shallow-clone support. */
+export type ScmProvider = "github";
+
+/**
+ * Everything git needs to clone one SCM's PR head. Provider-specific
+ * conventions live here and nowhere else.
+ */
+export type ScmCloneTarget = {
+  provider: ScmProvider;
+  /** `owner/name` — used for logs and error messages. */
+  repo: string;
+  prNumber: number;
+  /** HTTPS remote to fetch from. */
+  remoteUrl: string;
+  /** Username paired with the bearer token for git-over-HTTPS basic auth. */
+  credentialUsername: string;
+  /**
+   * Server-advertised PR head ref (e.g. GitHub `refs/pull/<n>/head`,
+   * GitLab `refs/merge-requests/<n>/head`) — the fallback when the pinned
+   * SHA cannot be fetched directly.
+   */
+  prHeadRef: string;
 };
 
-/** Repo-scoped bearer for git-over-HTTPS (installation token or PAT). */
+/**
+ * Resolve a PR URL to its clone target, or `undefined` when the SCM has no
+ * shallow-clone support (callers then review on their fallback checkout —
+ * e.g. Origin PRs, where the host checkout already is the reviewed repo).
+ */
+export function resolveScmCloneTarget(
+  prUrl: string
+): ScmCloneTarget | undefined {
+  let url: URL;
+  try {
+    url = new URL(prUrl);
+  } catch {
+    return undefined;
+  }
+  const parts = url.pathname.split("/").filter(Boolean);
+  if (
+    url.hostname === "github.com" &&
+    parts.length >= 4 &&
+    parts[2] === "pull" &&
+    Number.isInteger(Number(parts[3]))
+  ) {
+    const repo = `${parts[0]}/${parts[1]}`;
+    const prNumber = Number(parts[3]);
+    return {
+      provider: "github",
+      repo,
+      prNumber,
+      remoteUrl: `https://github.com/${repo}.git`,
+      credentialUsername: "x-access-token",
+      prHeadRef: `refs/pull/${prNumber}/head`,
+    };
+  }
+  return undefined;
+}
+
+/** Repo-scoped bearer for git-over-HTTPS. */
 export type ShallowCloneAuth = {
   token: string;
 };
 
 /**
- * Default clone credential: the serve host's Cursor-account GitHub lease.
+ * Default GitHub clone credential: the serve host's Cursor-account lease.
  * `CursorGithubCredentialProvider` mints it repo-scoped from the backend and
  * keeps `GH_TOKEN` refreshed for child processes; `GITHUB_TOKEN` covers
  * local/CI runs that export the conventional variable instead.
@@ -59,6 +116,154 @@ export function serveHostGithubAuth(
   return token === "" ? undefined : { token };
 }
 
+/** Pair the provider's git-over-HTTPS username with the bearer token. */
+function cloneCredential(
+  target: ScmCloneTarget,
+  auth: ShallowCloneAuth | undefined
+): GitCredential | undefined {
+  return auth === undefined
+    ? undefined
+    : { username: target.credentialUsername, token: auth.token };
+}
+
+/** Default clone credential source per provider. */
+function defaultCloneAuth(
+  target: ScmCloneTarget
+): ShallowCloneAuth | undefined {
+  switch (target.provider) {
+    case "github":
+      return serveHostGithubAuth();
+  }
+}
+
+/** Cap on diff text handed to a model; beyond this it is truncated. */
+const DIFF_MAX_CHARS = 80_000;
+
+export type CommitRangeDiff =
+  | { status: "ok"; diff: string }
+  | { status: "unavailable"; reason: string };
+
+/**
+ * Diff two commits inside an existing shallow PR checkout, fetching either
+ * end on demand when the shallow history does not already contain it.
+ *
+ * Lives here because it needs the same authenticated git the clone uses —
+ * a `--depth=1` checkout usually lacks the older commit, so reading a range
+ * means another credentialed fetch. Never throws: every failure becomes an
+ * `unavailable` reason the caller can act on or surface.
+ */
+export async function tryDiffCommitRange(args: {
+  /** Existing checkout to run git in (see {@link createShallowPrCheckout}). */
+  checkoutDir: string;
+  /** The checkout's clone target; supplies the remote's ref + auth conventions. */
+  target: ScmCloneTarget;
+  from: string;
+  to: string;
+  /** Restrict the diff to one path when set. */
+  file?: string | undefined;
+  /** Fetch credential; defaults to the target provider's credential source. */
+  auth?: ShallowCloneAuth | undefined;
+}): Promise<CommitRangeDiff> {
+  if (!isFullCommitSha(args.from) || !isFullCommitSha(args.to)) {
+    return {
+      status: "unavailable",
+      reason:
+        "Could not compute a reliable diff because a commit SHA was not a full 40-character SHA.",
+    };
+  }
+  const credential = cloneCredential(
+    args.target,
+    args.auth ?? defaultCloneAuth(args.target)
+  );
+  for (const sha of [args.from, args.to]) {
+    if (
+      !(await ensureCommitFetched(
+        args.checkoutDir,
+        sha,
+        args.target,
+        credential
+      ))
+    ) {
+      return {
+        status: "unavailable",
+        reason:
+          "Could not compute a reliable diff because a commit was unavailable in the checkout.",
+      };
+    }
+  }
+  try {
+    const diff = await git(args.checkoutDir, [
+      "diff",
+      "--no-ext-diff",
+      "--unified=80",
+      `${args.from}..${args.to}`,
+      ...(args.file === undefined ? [] : ["--", args.file]),
+    ]);
+    return {
+      status: "ok",
+      diff:
+        diff.length <= DIFF_MAX_CHARS
+          ? diff
+          : `${diff.slice(0, DIFF_MAX_CHARS)}\n\n[diff truncated at ${DIFF_MAX_CHARS} characters]`,
+    };
+  } catch {
+    return {
+      status: "unavailable",
+      reason: "Could not compute a reliable diff because git diff failed.",
+    };
+  }
+}
+
+function isFullCommitSha(value: string): boolean {
+  return /^[0-9a-f]{40}$/i.test(value);
+}
+
+/** Present already, or fetchable by SHA, or reachable from the PR head ref. */
+async function ensureCommitFetched(
+  checkoutDir: string,
+  sha: string,
+  target: ScmCloneTarget,
+  credential: GitCredential | undefined
+): Promise<boolean> {
+  if ((await revParse(checkoutDir, sha)) !== undefined) {
+    return true;
+  }
+  const attempts = [
+    [...FETCH_ARGS, sha],
+    // Deeper history on the PR head ref: the older end of an inter-run range
+    // is usually an ancestor of the tip rather than the tip itself.
+    [
+      "fetch",
+      "--depth=200",
+      "--no-tags",
+      "--quiet",
+      "origin",
+      target.prHeadRef,
+    ],
+  ];
+  for (const attempt of attempts) {
+    try {
+      await git(checkoutDir, attempt, credential);
+      if ((await revParse(checkoutDir, sha)) !== undefined) {
+        return true;
+      }
+    } catch {
+      // Try the next strategy; the caller fails closed if none work.
+    }
+  }
+  return false;
+}
+
+export type ShallowPrCheckout = {
+  /** Directory containing the PR head working tree (detached at headSha). */
+  checkoutDir: string;
+  headSha: string;
+  /** True when the merge-base commit was also fetched (enables local diffs). */
+  baseFetched: boolean;
+  /** How the head commit was obtained. */
+  headSource: "sha_fetch" | "pr_ref_fetch";
+};
+
 function logShallowClone(
   message: string,
   fields: Record<string, string | number | boolean | undefined> = {}
@@ -99,17 +304,22 @@ function gitError(args: string[], error: unknown): Error {
 }
 
 /**
- * The one credential helper git may use: serve the caller-provided token
- * from the child process env at request time. The shell reads
- * `$SHALLOW_CLONE_GIT_TOKEN` when git asks, keeping the token out of argv.
+ * The one credential helper git may use: serve the caller-provided
+ * credential from the child process env at request time. The shell reads
+ * the values when git asks, keeping the token out of argv.
  */
-const TOKEN_CREDENTIAL_HELPER =
-  '!f() { test "$1" = get && printf "username=x-access-token\\npassword=$SHALLOW_CLONE_GIT_TOKEN\\n"; }; f';
+const CREDENTIAL_HELPER =
+  '!f() { test "$1" = get && printf "username=$SHALLOW_CLONE_GIT_USERNAME\\npassword=$SHALLOW_CLONE_GIT_TOKEN\\n"; }; f';
+
+type GitCredential = {
+  username: string;
+  token: string;
+};
 
 async function git(
   cwd: string,
   args: string[],
-  auth?: ShallowCloneAuth
+  credential?: GitCredential
 ): Promise<string> {
   // Async on purpose: fetches/checkouts of large repos take minutes, and the
   // serve host runs the clone in-process. A synchronous git call blocks the
@@ -119,9 +329,9 @@ async function git(
     const { stdout } = await execFileAsync(
       "git",
       [
-        ...(auth === undefined
+        ...(credential === undefined
           ? []
-          : ["-c", `credential.helper=${TOKEN_CREDENTIAL_HELPER}`]),
+          : ["-c", `credential.helper=${CREDENTIAL_HELPER}`]),
         ...args,
       ],
       {
@@ -138,9 +348,12 @@ async function git(
           GIT_CONFIG_GLOBAL: "/dev/null",
           GIT_CONFIG_SYSTEM: "/dev/null",
           GIT_TERMINAL_PROMPT: "0",
-          ...(auth === undefined
+          ...(credential === undefined
             ? {}
-            : { SHALLOW_CLONE_GIT_TOKEN: auth.token }),
+            : {
+                SHALLOW_CLONE_GIT_USERNAME: credential.username,
+                SHALLOW_CLONE_GIT_TOKEN: credential.token,
+              }),
         },
       }
     );
@@ -163,14 +376,17 @@ async function revParse(cwd: string, rev: string): Promise<string | undefined> {
 
 const FETCH_ARGS = ["fetch", "--depth=1", "--no-tags", "--quiet", "origin"];
 
+/** Local tracking ref the PR head ref is fetched into. */
+const LOCAL_PR_HEAD_REF = "refs/remotes/origin/shallow-clone-pr-head";
+
 /**
- * Create a fresh shallow checkout of a GitHub PR head at `checkoutDir`.
+ * Create a fresh shallow checkout of a PR head at `checkoutDir`.
  *
  * Fetch order (both single depth-1 round-trips):
  * 1. Fetch `headSha` (and `baseSha` when known) directly — GitHub advertises
  *    `allow-reachable-sha1-in-want`, and this pins the exact reviewed commit
  *    the way Bugbot's `shallow_fetch` does.
- * 2. Fall back to `refs/pull/<n>/head`, verifying it still resolves to
+ * 2. Fall back to the target's PR head ref, verifying it still resolves to
  *    `headSha` so the working tree cannot silently drift from the pinned
  *    patch in the review bundle.
  *
@@ -178,36 +394,33 @@ const FETCH_ARGS = ["fetch", "--depth=1", "--no-tags", "--quiet", "origin"];
  * patch text in their prompt); a missing head checkout throws.
  */
 export async function createShallowPrCheckout(args: {
-  /** `owner/name`. */
-  repo: string;
-  prNumber?: number | undefined;
+  target: ScmCloneTarget;
   headSha: string;
   /** Merge-base SHA; fetched too so `git diff baseSha headSha` works locally. */
   baseSha?: string | undefined;
   checkoutDir: string;
-  /** Clone credential; required for GitHub remotes, unused for file fixtures. */
+  /** Clone credential; required for HTTPS remotes, unused for file fixtures. */
   auth?: ShallowCloneAuth | undefined;
-  /** Test seam: clone from this URL instead of `https://github.com/<repo>.git`. */
-  remoteUrl?: string | undefined;
 }): Promise<ShallowPrCheckout> {
-  const { repo, prNumber, headSha, baseSha, checkoutDir, auth } = args;
+  const { target, headSha, baseSha, checkoutDir, auth } = args;
+  const { repo, prNumber } = target;
+  const credential = cloneCredential(target, auth);
   const startedAt = Date.now();
   logShallowClone("cloning PR head", { repo, prNumber, headSha, baseSha });
   rmSync(checkoutDir, { recursive: true, force: true });
   mkdirSync(checkoutDir, { recursive: true });
   await git(checkoutDir, ["init", "--quiet"]);
-  await git(checkoutDir, [
-    "remote",
-    "add",
-    "origin",
-    args.remoteUrl ?? `https://github.com/${repo}.git`,
-  ]);
+  await git(checkoutDir, ["remote", "add", "origin", target.remoteUrl]);
 
   const shaFetch = async (): Promise<void> => {
     const extraBase =
       baseSha === undefined || baseSha === headSha ? [] : [baseSha];
     try {
-      await git(checkoutDir, [...FETCH_ARGS, headSha, ...extraBase], auth);
+      await git(
+        checkoutDir,
+        [...FETCH_ARGS, headSha, ...extraBase],
+        credential
+      );
     } catch (error) {
       if (extraBase.length === 0) {
         throw error;
@@ -220,38 +433,28 @@ export async function createShallowPrCheckout(args: {
         baseSha,
         error: errorSummary(error),
       });
-      await git(checkoutDir, [...FETCH_ARGS, headSha], auth);
+      await git(checkoutDir, [...FETCH_ARGS, headSha], credential);
     }
   };
 
   let headSource: ShallowPrCheckout["headSource"];
-  let shaFetchError: string | undefined;
   try {
     await shaFetch();
     headSource = "sha_fetch";
   } catch (error) {
-    shaFetchError = errorSummary(error);
-    if (prNumber === undefined) {
-      throw new Error(
-        `Shallow SHA fetch failed for ${repo}@${headSha} and no PR number is available for a ref fallback: ${shaFetchError}`
-      );
-    }
+    const shaFetchError = errorSummary(error);
     logShallowClone("sha fetch failed; falling back to PR head ref", {
       repo,
       prNumber,
       headSha,
       error: shaFetchError,
     });
-    const prRef = `refs/pull/${prNumber}/head`;
     await git(
       checkoutDir,
-      [...FETCH_ARGS, `+${prRef}:refs/remotes/origin/pr/${prNumber}/head`],
-      auth
-    );
-    const fetchedSha = await revParse(
-      checkoutDir,
-      `refs/remotes/origin/pr/${prNumber}/head`
+      [...FETCH_ARGS, `+${target.prHeadRef}:${LOCAL_PR_HEAD_REF}`],
+      credential
     );
+    const fetchedSha = await revParse(checkoutDir, LOCAL_PR_HEAD_REF);
     if (fetchedSha !== headSha) {
       throw new Error(
         `Shallow PR ref fetch for ${repo}#${prNumber} resolved to ${fetchedSha ?? "nothing"}, expected pinned head ${headSha} (sha fetch error: ${shaFetchError})`
@@ -279,7 +482,7 @@ export async function createShallowPrCheckout(args: {
     // Best-effort: local diffs are nice-to-have, the pinned patch in the
     // prompt is the authoritative delta either way.
     try {
-      await git(checkoutDir, [...FETCH_ARGS, baseSha], auth);
+      await git(checkoutDir, [...FETCH_ARGS, baseSha], credential);
       baseFetched = (await revParse(checkoutDir, baseSha)) !== undefined;
     } catch (error) {
       logShallowClone("merge-base fetch failed; continuing without it", {
@@ -303,37 +506,18 @@ export async function createShallowPrCheckout(args: {
   return { checkoutDir, headSha, baseFetched, headSource };
 }
 
-/** True for `https://github.com/<owner>/<repo>/pull/<n>` URLs. */
-export function isGithubPrUrl(prUrl: string): boolean {
-  try {
-    const url = new URL(prUrl);
-    const parts = url.pathname.split("/").filter(Boolean);
-    return (
-      url.hostname === "github.com" &&
-      parts.length >= 4 &&
-      parts[2] === "pull" &&
-      Number.isInteger(Number(parts[3]))
-    );
-  } catch {
-    return false;
-  }
-}
-
 export type TryShallowPrCheckoutOptions = {
-  /** PR URL; only GitHub PR URLs are cloned (others skip). */
+  /** PR URL; resolved to a clone target (unsupported SCMs skip). */
   prUrl: string;
-  /** `owner/name`. */
-  repo: string;
-  prNumber?: number | undefined;
   /** Pinned head SHA; skipped (undefined result) when unknown. */
   headSha?: string | undefined;
   /** Merge-base SHA; fetched too so `git diff baseSha headSha` works locally. */
   baseSha?: string | undefined;
   checkoutDir: string;
-  /** Clone credential; defaults to {@link serveHostGithubAuth}. */
+  /** Clone credential; defaults to the target provider's credential source. */
   auth?: ShallowCloneAuth | undefined;
-  /** Test seam: clone from this URL instead of `https://github.com/<repo>.git`. */
-  remoteUrl?: string | undefined;
+  /** Test seam: clone this target instead of resolving `prUrl`. */
+  target?: ScmCloneTarget | undefined;
 };
 
 export type TryShallowPrCheckoutResult = {
@@ -352,53 +536,57 @@ export type TryShallowPrCheckoutResult = {
  * reviewed repo instead of the host's own checkout.
  *
  * Returns no checkout — leaving the caller on its fallback working
- * directory — when the PR is not on GitHub (e.g. Origin PRs, where the host
- * checkout is the reviewed repo), when no head SHA is pinned, when no clone
- * credential is available, or when the clone fails; `fallbackReason` says
- * which. Failures are logged, never thrown: agents still have the pinned
- * patch in their prompts, so a missing checkout degrades quality rather
- * than the run.
+ * directory — when the PR's SCM has no clone support (e.g. Origin PRs,
+ * where the host checkout is the reviewed repo), when no head SHA is
+ * pinned, when no clone credential is available, or when the clone fails;
+ * `fallbackReason` says which. Failures are logged, never thrown: agents
+ * still have the pinned patch in their prompts, so a missing checkout
+ * degrades quality rather than the run.
  */
 export async function tryCreateShallowPrCheckout(
   options: TryShallowPrCheckoutOptions
 ): Promise<TryShallowPrCheckoutResult> {
-  const { prUrl, repo, prNumber, headSha, baseSha, checkoutDir, remoteUrl } =
-    options;
-  if (remoteUrl === undefined && !isGithubPrUrl(prUrl)) {
-    logShallowClone("skipped: not a GitHub PR URL", { prUrl });
-    return { fallbackReason: "skipped: not a GitHub PR URL" };
+  const { prUrl, headSha, baseSha, checkoutDir } = options;
+  const target = options.target ?? resolveScmCloneTarget(prUrl);
+  if (target === undefined) {
+    logShallowClone("skipped: unsupported SCM for shallow clone", { prUrl });
+    return { fallbackReason: "skipped: unsupported SCM for shallow clone" };
   }
   if (headSha === undefined) {
-    logShallowClone("skipped: no pinned head SHA", { repo, prUrl });
+    logShallowClone("skipped: no pinned head SHA", {
+      repo: target.repo,
+      prUrl,
+    });
     return { fallbackReason: "skipped: no pinned head SHA" };
   }
-  const auth = options.auth ?? serveHostGithubAuth();
-  if (remoteUrl === undefined && auth === undefined) {
-    // Fail fast instead of letting an unauthenticated fetch 404/hang: real
-    // GitHub clones need the serve host's lease (or an explicit token).
-    logShallowClone("skipped: no GitHub clone credential", { repo, prUrl });
+  const auth = options.auth ?? defaultCloneAuth(target);
+  if (auth === undefined && target.remoteUrl.startsWith("https://")) {
+    // Fail fast instead of letting an unauthenticated fetch 404/hang: HTTPS
+    // clones need the provider's credential (or an explicit token).
+    logShallowClone("skipped: no clone credential", {
+      repo: target.repo,
+      provider: target.provider,
+      prUrl,
+    });
     return {
-      fallbackReason:
-        "skipped: no GitHub clone credential (serve host GH_TOKEN lease not installed)",
+      fallbackReason: `skipped: no ${target.provider} clone credential (serve host token lease not installed)`,
     };
   }
   try {
     return {
       checkout: await createShallowPrCheckout({
-        repo,
-        prNumber,
+        target,
         headSha,
         baseSha,
         checkoutDir,
         auth,
-        remoteUrl,
       }),
     };
   } catch (error) {
     const reason = errorSummary(error);
     logShallowClone("failed; caller falls back to host checkout", {
-      repo,
-      prNumber,
+      repo: target.repo,
+      prNumber: target.prNumber,
       headSha,
       error: reason,
     });