@cursor/july 0.1.100 → 0.1.102

package/src/extensions/cursor-cloud-agents/lib/fleet.ts

@@ -0,0 +1,109 @@
+/**
+ * Who launched which cloud agent. The tools authenticate with the serve
+ * host's one Cursor API key, so the host itself must keep every session's
+ * cloud agents bound to the principal that launched them: status and
+ * follow-ups only reach agents recorded here for the same principal, and
+ * the fleet listing is that principal's records, by default narrowed to the
+ * session that launched them.
+ */
+
+import { z } from "zod";
+import type { ToolContext } from "../../../types.js";
+
+const PREFIX = "cloud-agents";
+
+// Type alias, not an interface: fleet entries flow into tool results.
+export type FleetEntry = {
+  agentId: string;
+  name?: string;
+  launchedAt: string;
+  /** The session whose turn launched the agent; absent on records older than this field. */
+  sessionId?: string;
+};
+
+export type FleetScope = "session" | "all";
+
+const fleetSchema: z.ZodType<FleetEntry[]> = z.array(
+  z.object({
+    agentId: z.string(),
+    name: z.string().optional(),
+    launchedAt: z.string(),
+    sessionId: z.string().optional(),
+  })
+);
+const ownerSchema = z.object({ principal: z.string() });
+
+// `host.kv` has no compare-and-swap, and a model that launches two agents in
+// one turn calls this tool in parallel. Chain the index read-modify-write per
+// principal so neither launch overwrites the other's entry.
+const indexWrites = new Map<string, Promise<void>>();
+
+function withIndexLock(key: string, task: () => Promise<void>): Promise<void> {
+  const run = (indexWrites.get(key) ?? Promise.resolve()).then(task, task);
+  indexWrites.set(key, run);
+  return run.finally(() => {
+    if (indexWrites.get(key) === run) {
+      indexWrites.delete(key);
+    }
+  });
+}
+
+/** Unauthenticated sessions (local dev, direct calls) share one principal. */
+export function principalOf(ctx: ToolContext): string {
+  const auth = ctx.session.auth;
+  return auth === null
+    ? "anonymous"
+    : `${auth.principalType}:${auth.principalId}`;
+}
+
+export async function recordLaunch(
+  ctx: ToolContext,
+  agentId: string,
+  name: string | undefined
+): Promise<void> {
+  const principal = principalOf(ctx);
+  const entry: FleetEntry = {
+    agentId,
+    name,
+    launchedAt: new Date().toISOString(),
+    sessionId: ctx.session.id,
+  };
+  await ctx.host.kv.put(`${PREFIX}/agents/${agentId}`, { principal });
+  await withIndexLock(fleetKey(principal), async () => {
+    const fleet = await listFleet(ctx);
+    await ctx.host.kv.put(fleetKey(principal), [entry, ...fleet]);
+  });
+}
+
+/** Refuse agents launched by another principal, or not through the extension. */
+export async function assertOwned(
+  ctx: ToolContext,
+  agentId: string
+): Promise<void> {
+  const owner = ownerSchema.safeParse(
+    await ctx.host.kv.get(`${PREFIX}/agents/${agentId}`)
+  );
+  if (!owner.success || owner.data.principal !== principalOf(ctx)) {
+    throw new Error(
+      `Agent ${agentId} was not launched through this extension by this principal; only your own launches can be read or steered.`
+    );
+  }
+}
+
+/** The caller's launches, newest first: this session's, or every session's. */
+export async function listFleet(
+  ctx: ToolContext,
+  scope: FleetScope = "all"
+): Promise<FleetEntry[]> {
+  const fleet = fleetSchema.safeParse(
+    await ctx.host.kv.get(fleetKey(principalOf(ctx)))
+  );
+  const entries = fleet.success ? fleet.data : [];
+  return scope === "all"
+    ? entries
+    : entries.filter((entry) => entry.sessionId === ctx.session.id);
+}
+
+function fleetKey(principal: string): string {
+  return `${PREFIX}/principals/${encodeURIComponent(principal)}`;
+}

package/src/extensions/cursor-cloud-agents/lib/inputs.ts

@@ -0,0 +1,5 @@
+import { z } from "zod";
+
+export const agentRef: z.ZodObject<{ agent_id: z.ZodString }> = z.object({
+  agent_id: z.string().describe("Agent id (`bc-...`) returned by launch."),
+});

package/src/extensions/cursor-cloud-agents/lib/repos.ts

@@ -0,0 +1,81 @@
+/**
+ * Which repositories a launch may target. The model picks `repo` / `ref` /
+ * `prUrl` per call, but the author's `cloud.repos` are the allowlist.
+ * Model-chosen targets always require that allowlist: an unbound mount
+ * (no `cloud.repos`) must not accept an arbitrary URL under the host API
+ * key, with or without `envVars`.
+ */
+
+import { parsePrUrl } from "../../../internal/scm/pr-url.js";
+import type { AgentCloudOptions } from "../../../types.js";
+
+export interface LaunchTarget {
+  repo?: string;
+  ref?: string;
+  prUrl?: string;
+}
+
+export function launchRepos(
+  target: LaunchTarget,
+  cloud: AgentCloudOptions
+): AgentCloudOptions["repos"] {
+  if (
+    target.repo === undefined &&
+    target.ref === undefined &&
+    target.prUrl === undefined
+  ) {
+    return cloud.repos;
+  }
+  const pr = target.prUrl === undefined ? undefined : parsePrUrl(target.prUrl);
+  if (target.prUrl !== undefined && pr?.provider !== "github") {
+    throw new Error(`prUrl must be a GitHub pull request URL: ${target.prUrl}`);
+  }
+  const prRepo =
+    pr === undefined ? undefined : `https://github.com/${pr.owner}/${pr.repo}`;
+  // A lone `ref` needs exactly one configured repository to apply to.
+  const configured = cloud.repos ?? [];
+  const url =
+    target.repo ??
+    prRepo ??
+    (configured.length === 1 ? configured[0]?.url : undefined);
+  if (url === undefined) {
+    throw new Error(
+      configured.length > 1
+        ? "`repo` is required: this extension configures several repositories."
+        : "`repo` is required: this extension has no configured default repository."
+    );
+  }
+  if (prRepo !== undefined && repoKey(prRepo) !== repoKey(url)) {
+    throw new Error(`prUrl ${target.prUrl} is not a pull request of ${url}.`);
+  }
+  const allowlisted = cloud.repos?.some(
+    (configured) => repoKey(configured.url) === repoKey(url)
+  );
+  if (allowlisted !== true) {
+    throw new Error(
+      cloud.repos === undefined
+        ? `Configure cloud.repos before launching against a model-chosen repository (${url}).`
+        : `${url} is not one of this extension's configured repositories.`
+    );
+  }
+  // Keep the matching allowlist entry's branch / PR defaults when the model
+  // only names the repository (handoff always passes `repo`). An explicit
+  // `ref` clears an inherited `prUrl` so branch and PR targets do not mix.
+  const match = configured.find(
+    (configuredRepo) => repoKey(configuredRepo.url) === repoKey(url)
+  );
+  return [
+    {
+      url,
+      startingRef: target.ref ?? match?.startingRef,
+      prUrl:
+        target.prUrl ?? (target.ref !== undefined ? undefined : match?.prUrl),
+    },
+  ];
+}
+
+function repoKey(url: string): string {
+  const parsed = new URL(url);
+  const path = parsed.pathname.replace(/\.git$/, "").replace(/\/+$/, "");
+  return `${parsed.hostname}${path}`.toLowerCase();
+}

package/src/extensions/cursor-cloud-agents/lib/transcript.ts

@@ -0,0 +1,23 @@
+/** A cloud agent's conversation as JSONL lines, one message per line. */
+
+import type { CloudAgentMessage } from "./backend.js";
+
+/** Workspace-relative path of a dumped transcript; the directory Sand uses too. */
+export function transcriptPath(agentId: string): string {
+  return `cloud-agent-transcripts/${agentId}.jsonl`;
+}
+
+export function transcriptLines(messages: CloudAgentMessage[]): string[] {
+  return messages.map((message) => JSON.stringify(message));
+}
+
+/** The text of the last assistant message, the agent's report. */
+export function lastAssistantText(
+  messages: CloudAgentMessage[]
+): string | undefined {
+  return messages
+    .toReversed()
+    .find(
+      (message) => message.role === "assistant" && message.text !== undefined
+    )?.text;
+}

package/src/extensions/cursor-cloud-agents/skills/handoff.md

@@ -0,0 +1,41 @@
+---
+description: "Delegate coding work to Cursor cloud agents: when to hand off, how to write the prompt, and how to look an agent up by id, read what it did, reply, and cancel."
+---
+
+# Cloud agent handoff
+
+Hand work to a Cursor cloud agent when it needs a repository checkout, a long run, or an isolated machine: implementing a change, running a test suite, opening a pull request. Answer questions and small reads yourself.
+
+The tools below are this extension's; they appear under its mount namespace, as `<namespace>__launch` and so on. Every agent is addressed by its `agent_id` (`bc-...`).
+
+## Launch
+
+Call `launch` with a self-contained prompt: the goal, the repository or pull request, constraints (branch, files to leave alone), and what done looks like (tests pass, PR opened). Pass `starting_ref` or `pr_url` to pick a branch or pull request; `repo` must be one of the configured repositories.
+
+The result carries `agentId` (`bc-...`) and a `url`. Report both in full. Never truncate the id.
+
+## Look an agent up by id
+
+Call `get` with the `agent_id`. It returns the agent's `status` (`creating`, `running`, `finished`, `error`, or `expired`), its `branch` and pull request `prUrl` once pushed, the `changes` it made so far (files and lines), a `summary` when one exists, and an `error` when it failed. A run takes minutes: check when asked or when you need the result, not in a tight loop. The final report itself comes from `dump`.
+
+## Read what it did
+
+To read the report or understand what was done, call `dump` with the `agent_id`. It writes the agent's whole conversation, every run, to `cloud-agent-transcripts/<agent_id>.jsonl` in your workspace and returns the absolute `path` plus the `finalMessage`. Each line is one JSON message with `role` (`user` or `assistant`) and, for assistant lines, `text`, `thinking`, and `toolCalls` (tool `name`, `args`, `content`, `error`). Read it with your file and shell tools, using the returned path:
+
+- `tail -n 1 <path>` gives the final report.
+- `grep '"toolCalls"' <path>` shows the commands and edits it made.
+- `grep '"role":"user"' <path>` shows every prompt it received, including replies.
+
+Use `dump` before summarizing an agent's work for a person, and to understand a failure before replying with a fix.
+
+## Reply
+
+Call `reply` with the `agent_id` and a prompt to steer an agent or ask for changes on its branch. The follow-up queues behind the current run and starts when it finishes; pass `interrupt: true` to stop the current step and deliver it now. Do not launch a second agent for follow-up work on the same branch.
+
+## Cancel
+
+Call `cancel` with the `agent_id` to stop the active run. The agent keeps its branch and conversation, so a `reply` can continue from where it stopped.
+
+## Fleet
+
+`list` returns the agents launched in this session, newest first; pass `scope: "all"` to include your launches from other sessions. Launch one agent per independent task and give each a descriptive `name`. Agents launched by others are out of reach.

package/src/extensions/cursor-cloud-agents/tools/cancel.ts

@@ -0,0 +1,19 @@
+import { defineTool } from "../../../tools.js";
+import type { ToolDefinition } from "../../../types.js";
+import { cloudAgentsBackend } from "../lib/backend.js";
+import { assertOwned } from "../lib/fleet.js";
+import { agentRef } from "../lib/inputs.js";
+
+const cancel: ToolDefinition = defineTool({
+  description:
+    "Stop a cloud agent's active run. The agent keeps its branch and conversation; reply to it to continue.",
+  effect: "write",
+  inputSchema: agentRef,
+  async execute(input, ctx) {
+    await assertOwned(ctx, input.agent_id);
+    await cloudAgentsBackend().pause(input.agent_id);
+    return { agentId: input.agent_id, cancelled: true };
+  },
+});
+
+export default cancel;

package/src/extensions/cursor-cloud-agents/tools/dump.ts

@@ -0,0 +1,51 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { defineTool } from "../../../tools.js";
+import type { ToolDefinition } from "../../../types.js";
+import { cloudAgentsBackend } from "../lib/backend.js";
+import { assertOwned } from "../lib/fleet.js";
+import { agentRef } from "../lib/inputs.js";
+import {
+  lastAssistantText,
+  transcriptLines,
+  transcriptPath,
+} from "../lib/transcript.js";
+
+const dump: ToolDefinition = defineTool({
+  description:
+    "Write a cloud agent's full conversation to a JSONL file in your workspace so you can read what it did: one JSON message per line (prompts, assistant text, thinking, tool calls). Read the last line for the final report.",
+  effect: "read",
+  inputSchema: agentRef,
+  async execute(input, ctx) {
+    await assertOwned(ctx, input.agent_id);
+    const backend = cloudAgentsBackend();
+    const [messages, info] = await Promise.all([
+      backend.conversation(input.agent_id),
+      backend.info(input.agent_id),
+    ]);
+    if (messages.length === 0) {
+      return {
+        agentId: input.agent_id,
+        lineCount: 0,
+        status: info.status,
+        note: "The agent has not produced any transcript yet.",
+      };
+    }
+    // Absolute: the harness's shell does not run in the workspace directory.
+    const path = join(ctx.workspaceDir, transcriptPath(input.agent_id));
+    const jsonl = `${transcriptLines(messages).join("\n")}\n`;
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, jsonl, "utf8");
+    return {
+      agentId: input.agent_id,
+      path,
+      sizeBytes: Buffer.byteLength(jsonl),
+      lineCount: messages.length,
+      status: info.status,
+      finalMessage: lastAssistantText(messages),
+      note: `One JSON message per line. Grep it, or read the final report with \`tail -n 1 ${path}\`.`,
+    };
+  },
+});
+
+export default dump;

package/src/extensions/cursor-cloud-agents/tools/get.ts

@@ -0,0 +1,18 @@
+import { defineTool } from "../../../tools.js";
+import type { ToolDefinition } from "../../../types.js";
+import { cloudAgentsBackend } from "../lib/backend.js";
+import { assertOwned } from "../lib/fleet.js";
+import { agentRef } from "../lib/inputs.js";
+
+const get: ToolDefinition = defineTool({
+  description:
+    "Look up a cloud agent you launched by id: its status, branch, pull request, changed-file counts, summary, and any error. Use dump to read everything it did.",
+  effect: "read",
+  inputSchema: agentRef,
+  async execute(input, ctx) {
+    await assertOwned(ctx, input.agent_id);
+    return cloudAgentsBackend().info(input.agent_id);
+  },
+});
+
+export default get;

package/src/extensions/cursor-cloud-agents/tools/launch.ts

@@ -0,0 +1,64 @@
+import { z } from "zod";
+import { defineTool } from "../../../tools.js";
+import type { ToolDefinition } from "../../../types.js";
+import extension from "../extension.js";
+import { cloudAgentsBackend } from "../lib/backend.js";
+import { recordLaunch } from "../lib/fleet.js";
+import { launchRepos } from "../lib/repos.js";
+
+const launch: ToolDefinition = defineTool({
+  description:
+    "Launch a Cursor cloud agent on a repository with a self-contained task. Returns the agent id and URL; check on it with get, read what it did with dump.",
+  effect: "write",
+  needsApproval: () => extension.config.needsApproval,
+  inputSchema: z.object({
+    prompt: z
+      .string()
+      .min(1)
+      .describe(
+        "Self-contained task: goal, constraints, and what done looks like."
+      ),
+    repo: z
+      .string()
+      .url()
+      .optional()
+      .describe(
+        "GitHub repository URL, one of the configured repositories. Defaults to the configured repository."
+      ),
+    starting_ref: z
+      .string()
+      .optional()
+      .describe(
+        "Branch or commit to start from; defaults to the configured or default branch."
+      ),
+    pr_url: z
+      .string()
+      .url()
+      .optional()
+      .describe("Work on this pull request's branch instead of a new one."),
+    name: z
+      .string()
+      .max(100)
+      .optional()
+      .describe("Display name; derived from the prompt when omitted."),
+  }),
+  async execute(input, ctx) {
+    const { cloud, model } = extension.config;
+    const launched = await cloudAgentsBackend().launch({
+      prompt: input.prompt,
+      name: input.name,
+      model,
+      cloud: {
+        ...cloud,
+        repos: launchRepos(
+          { repo: input.repo, ref: input.starting_ref, prUrl: input.pr_url },
+          cloud
+        ),
+      },
+    });
+    await recordLaunch(ctx, launched.agentId, input.name);
+    return launched;
+  },
+});
+
+export default launch;

package/src/extensions/cursor-cloud-agents/tools/list.ts

@@ -0,0 +1,31 @@
+import { z } from "zod";
+import { defineTool } from "../../../tools.js";
+import type { ToolDefinition } from "../../../types.js";
+import { agentUrl } from "../lib/backend.js";
+import { listFleet } from "../lib/fleet.js";
+
+const list: ToolDefinition = defineTool({
+  description:
+    'List the cloud agents launched in this session, newest first. Pass scope "all" for every agent you launched, in any session.',
+  effect: "read",
+  inputSchema: z.object({
+    scope: z
+      .enum(["session", "all"])
+      .default("session")
+      .describe(
+        "session: agents this session launched; all: every agent launched by you, in any session."
+      ),
+    limit: z.number().int().min(1).max(100).default(20),
+  }),
+  async execute(input, ctx) {
+    const fleet = await listFleet(ctx, input.scope);
+    return {
+      sessionId: ctx.session.id,
+      agents: fleet
+        .slice(0, input.limit)
+        .map((entry) => ({ ...entry, url: agentUrl(entry.agentId) })),
+    };
+  },
+});
+
+export default list;

package/src/extensions/cursor-cloud-agents/tools/reply.ts

@@ -0,0 +1,34 @@
+import { z } from "zod";
+import { defineTool } from "../../../tools.js";
+import type { ToolDefinition } from "../../../types.js";
+import extension from "../extension.js";
+import { cloudAgentsBackend } from "../lib/backend.js";
+import { assertOwned } from "../lib/fleet.js";
+import { agentRef } from "../lib/inputs.js";
+
+const reply: ToolDefinition = defineTool({
+  description:
+    "Send a follow-up prompt to a cloud agent you launched. It queues behind the current run; pass interrupt to stop that run's current step and deliver it now.",
+  effect: "write",
+  needsApproval: () => extension.config.needsApproval,
+  inputSchema: agentRef.extend({
+    prompt: z.string().min(1).describe("The follow-up instruction."),
+    interrupt: z
+      .boolean()
+      .default(false)
+      .describe(
+        "Deliver now, cancelling the in-flight step, instead of waiting for the current run to finish."
+      ),
+  }),
+  async execute(input, ctx) {
+    await assertOwned(ctx, input.agent_id);
+    const { runId } = await cloudAgentsBackend().followUp(
+      input.agent_id,
+      input.prompt,
+      input.interrupt
+    );
+    return { agentId: input.agent_id, runId, queued: !input.interrupt };
+  },
+});
+
+export default reply;

package/src/extensions.ts

@@ -0,0 +1,141 @@
+/**
+ * Extensions — agent-shaped trees an agent mounts under a namespace.
+ *
+ * An extension is a directory laid out like `agent/`: `extension.ts`
+ * declares it, `tools/<name>.ts` and `skills/<name>.md|ts` are its
+ * contributions, `lib/` holds shared code.
+ *
+ * ```ts
+ * // extension.ts
+ * import { defineExtension } from "@cursor/july/extensions";
+ * import { z } from "zod";
+ *
+ * export default defineExtension({
+ *   root: import.meta.dirname,
+ *   description: "Investigate failing CI builds.",
+ *   config: z.object({ org: z.string(), token: z.string() }),
+ * });
+ *
+ * // tools/failed_jobs.ts
+ * import extension from "../extension.js";
+ *
+ * export default defineTool({
+ *   description: "List the failed jobs of a build.",
+ *   execute: (input) => failedJobs(extension.config, input),
+ * });
+ * ```
+ *
+ * A consumer mounts it from `agent/extensions/<ns>.ts`; the filename is the
+ * namespace, and every contribution is exposed as `<ns>__<name>`
+ * (`ci__failed_jobs`). `__` is reserved for that: an authored `agent/tools/`
+ * or `agent/skills/` name may not contain it.
+ *
+ * ```ts
+ * // agent/extensions/ci.ts
+ * import ci from "@acme/ci-triage";
+ *
+ * export default ci({ org: "acme", token: process.env.BUILDKITE_TOKEN! });
+ * ```
+ *
+ * To adjust a contribution, mount as a directory instead and overlay the
+ * slot: `agent/extensions/ci/extension.ts` holds the mount, and
+ * `agent/extensions/ci/tools/job_log.ts` replaces `ci__job_log` — or removes
+ * it with `export default disableTool()`.
+ *
+ * A Cursor plugin (the marketplace format: `.cursor-plugin/plugin.json`,
+ * `skills/`, `commands/`, `agents/`, `mcp.json`) mounts the same way with
+ * `cursorPlugin`. Its skills and commands become `<ns>__<name>` skills, its
+ * agents `<ns>__<name>` subagents, and its MCP servers `<ns>__<server>`
+ * connections. Rules and hooks are not mounted yet.
+ *
+ * ```ts
+ * // agent/extensions/notion.ts
+ * import { cursorPlugin } from "@cursor/july/extensions";
+ *
+ * export default cursorPlugin({
+ *   path: "plugins/notion-workspace",
+ *   variables: { NOTION_TOKEN: process.env.NOTION_TOKEN! },
+ * });
+ * ```
+ *
+ * A directory mount overlays its MCP servers too:
+ * `agent/extensions/notion/mcp-connections/notion.ts` replaces
+ * `notion__notion` with your own `defineConnection` (headers, `oauth`,
+ * `advertiseTools`), and `export default disableConnection()` drops a server
+ * the agent should not carry.
+ */
+
+import { brandDefinition } from "./internal/brand.js";
+import type {
+  CursorPluginOptions,
+  DisabledConnectionDefinition,
+  DisabledToolDefinition,
+  Extension,
+  ExtensionMount,
+  ExtensionOptions,
+} from "./types.js";
+
+export type {
+  CursorPluginDeclaration,
+  CursorPluginOptions,
+  DisabledConnectionDefinition,
+  DisabledToolDefinition,
+  DiscoveredExtension,
+  Extension,
+  ExtensionDeclaration,
+  ExtensionMount,
+  ExtensionOptions,
+} from "./types.js";
+
+export function defineExtension<TConfig = undefined, TInput = TConfig>(
+  options: ExtensionOptions<TConfig, TInput>
+): Extension<TConfig, TInput> {
+  let mounted: { config: TConfig } | undefined;
+  const mount = (config?: TInput): ExtensionMount => {
+    const parsed =
+      options.config === undefined
+        ? (config as unknown as TConfig)
+        : options.config.parse(config);
+    mounted = { config: parsed };
+    return brandDefinition("extension", {
+      extension: handle,
+      config: parsed,
+    });
+  };
+  const handle = Object.defineProperties(mount, {
+    root: { value: options.root, enumerable: true },
+    description: { value: options.description, enumerable: true },
+    config: {
+      enumerable: true,
+      get(): TConfig {
+        if (mounted === undefined) {
+          throw new Error(
+            `Extension at ${options.root} read its config before an agent mounted it. Mount it from agent/extensions/<ns>.ts; the mount runs before the tree loads.`
+          );
+        }
+        return mounted.config;
+      },
+    },
+  }) as unknown as Extension<TConfig, TInput>;
+  return handle;
+}
+
+export function disableTool(): DisabledToolDefinition {
+  return brandDefinition("disabled-tool", {});
+}
+
+export function disableConnection(): DisabledConnectionDefinition {
+  return brandDefinition("disabled-connection", {});
+}
+
+export function cursorPlugin(options: CursorPluginOptions): ExtensionMount {
+  return brandDefinition("extension", {
+    extension: {
+      root: options.path,
+      description: undefined,
+      layout: "cursor-plugin",
+      variables: options.variables ?? {},
+    },
+    config: undefined,
+  });
+}

package/src/files-backends/cursor-hosted.ts

@@ -51,10 +51,7 @@ import {
   type FileSinkEntry,
   type FileSinkPutResult,
 } from "../files.js";
-import {
-  resolveDeploymentStoreSourceIdSync,
-  resolveFrameworkStoreSourceIdSync,
-} from "../internal/cursor/hosted-store-secrets.js";
+import { resolveDeploymentStoreSourceIdSync } from "../internal/cursor/hosted-store-secrets.js";
 import { createAgentStorePresignedUrlValidatorForBackend } from "./agent-store-presigned-url.js";
 
 /**
@@ -118,19 +115,6 @@ export function isCursorHostedFilesAvailable(
   return resolveDeploymentStoreSourceIdSync(env) !== undefined;
 }
 
-/**
- * The framework-level store's source id, or `undefined` when the deployment
- * has none (v1, self-hosted, or a v2 deploy predating framework-store
- * provisioning). Same detection posture as
- * {@link isCursorHostedFilesAvailable}: keyed on the id alone — a missing
- * credential must fail loudly at use, not silently deselect the store.
- */
-export function cursorFrameworkStoreSourceId(
-  env: NodeJS.ProcessEnv = process.env
-): string | undefined {
-  return resolveFrameworkStoreSourceIdSync(env);
-}
-
 /**
  * Local `serve`/`run` with a personal `CURSOR_API_KEY` can address
  * `/v0/agent-serve-files/user`. Hosted deployments have a store source id