@cursor/july 0.1.105 → 0.1.107

package/docs/reference/cli.md

@@ -674,14 +674,17 @@ The command polls for up to ten minutes until the status reaches
 
 ## delete
 
-`delete` removes a deployment.
+`delete` removes a hosted deployment. You can delete a deployment that
+still runs. The command frees the slug. A later deploy can use the same
+name. Spend stays on the archived service account.
 
 ```bash
 agent-sdk delete <slug> [--team <id>] [--no-wait] [--json]
 ```
 
 The command waits until the deployment is gone. `--no-wait` returns after
-the delete request is accepted.
+the delete request is accepted. Architecture v2 slugs use the Agent SDK
+control plane. Architecture v1 slugs use the Agent Serve control plane.
 
 ## rotate-token
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cursor/july",
-  "version": "0.1.105",
+  "version": "0.1.107",
   "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": {
@@ -24,7 +24,7 @@
     "!dist/internal/tenant-mcp/**",
     "!dist/internal/grokbot/**",
     "!dist/extensions/cursor-grokbot-agents/**",
-    "!dist/internal/review-comments.*",
+    "!dist/internal/review-comments*",
     "!dist/internal/shallow-clone.*",
     "!dist/internal/managed-delivery.*",
     "src/**/*",
@@ -32,7 +32,7 @@
     "!src/internal/tenant-mcp/**",
     "!src/internal/grokbot/**",
     "!src/extensions/cursor-grokbot-agents/**",
-    "!src/internal/review-comments.ts",
+    "!src/internal/review-comments*",
     "!src/internal/shallow-clone.ts",
     "!src/internal/managed-delivery.ts",
     "skills/**/*",

package/skills/otel/SKILL.md

@@ -33,9 +33,9 @@ export default defineOtel({
 3. `serve(dir, { otel: { … } })`. `otel: false` disables env and
    authored config.
 
-Hosted v2 secrets arrive after bake. Use `defineOtel(() => …)` so flush
-re-resolves exporters. Authored `agent/otel.ts` records from process
-start even when the factory returns no exporters yet.
+Hosted secrets can arrive after startup. Use `defineOtel(() => …)` so
+flush re-resolves exporters. Authored `agent/otel.ts` records from
+process start even when the factory returns no exporters yet.
 
 | Signal | Default |
 | --- | --- |

package/src/bin/agent-serve.ts

@@ -341,9 +341,6 @@ Options:
                      the Cursor backend's per-forge forwarder instead of
                      minting raw tokens into this process
                      (AGENT_SERVE_<FORGE>_PROXY_URL overrides a base URL).
-  --cursor-github-proxy
-                     serve: deprecated alias for --cursor-scm-proxy; removed
-                     one release after --cursor-scm-proxy ships.
   --public-url       serve: base URL where this host is reachable from outside
                      (e.g. https://agent-serve.example.com). Required for peer
                      connections (defineConnection({ agent })) on cloud-runtime
@@ -519,7 +516,6 @@ async function main(argv: string[]): Promise<number> {
       "allow-anonymous-cursor-account-mcp": { type: "boolean", default: false },
       "allow-anonymous-grokbot": { type: "boolean", default: false },
       "cursor-scm-proxy": { type: "boolean", default: false },
-      "cursor-github-proxy": { type: "boolean", default: false },
       "no-schedules": { type: "boolean", default: false },
       "no-control-plane": { type: "boolean", default: false },
       "no-playground": { type: "boolean", default: false },
@@ -1353,11 +1349,7 @@ async function main(argv: string[]): Promise<number> {
             : undefined,
         allowAnonymousGrokbot:
           values["allow-anonymous-grokbot"] === true ? true : undefined,
-        cursorScmProxy:
-          values["cursor-scm-proxy"] === true ||
-          values["cursor-github-proxy"] === true
-            ? true
-            : undefined,
+        cursorScmProxy: values["cursor-scm-proxy"] === true ? true : undefined,
         schedules: values["no-schedules"] === true ? false : undefined,
         noControlPlane: values["no-control-plane"] === true ? true : undefined,
         playground: values["no-playground"] === true ? false : undefined,

package/src/channels/bitbucket/types.ts

@@ -229,10 +229,8 @@ export interface BitbucketChannelOptions {
    */
   webhookEvents?: readonly string[];
   /**
-   * Continuation selector. Omitted inherits {@link AgentConfig.architecture}:
-   * engine-minted per-PR continuation unless the agent set
-   * `architecture: "v2"` (then `bitbucket.pr/v2`, or `bitbucket.none/v2`
-   * when a non-PR event is declared).
+   * Continuation selector. Omit this to inherit the agent architecture's
+   * default. Set it explicitly only when migrating persisted identities.
    */
   continuation?: ContinuationIdentity;
   /**

package/src/channels/deployments/types.ts

@@ -56,10 +56,9 @@ export interface DeploymentsChannelOptions {
    * and then receives nothing. A bare string takes the default environment and
    * event filters.
    *
-   * Omit on hosted v2. The control plane then binds `deploy_source` edges
-   * from the deploy's watched `repositories` and the channel admits what it
-   * is sent. That is the multi-tenant shape: an agent cannot enumerate
-   * sources for a tenant it has never seen.
+   * Omit on Cursor-managed hosting. The control plane binds sources from the
+   * deployment's watched repositories, and the channel admits only what it
+   * receives. An agent cannot enumerate sources for an unseen tenant.
    *
    * Name sources to narrow below that scope, or to drive the self-hosted
    * relay, which has no deploy scope to inherit. On that wire `[]` means
@@ -89,10 +88,8 @@ export interface DeploymentsChannelOptions {
   onStart?: ChannelDefinition["onStart"];
   onStop?: ChannelDefinition["onStop"];
   /**
-   * Continuation selector. Omitted inherits {@link AgentConfig.architecture}:
-   * `"deployments.none/v1"` unless the agent set `architecture: "v2"` (then
-   * `"deployments.deployment/v2"`). Override with `"deployments.none/v2"`
-   * for one-shot events.
+   * Continuation selector. Omit this to inherit the agent architecture's
+   * default. Set it explicitly only when migrating persisted identities.
    */
   continuation?: ContinuationIdentity;
 }

package/src/channels/github/types.ts

@@ -480,10 +480,8 @@ export interface GitHubChannelOptions {
    */
   botName?: string;
   /**
-   * Continuation selector. Omitted inherits {@link AgentConfig.architecture}:
-   * `"github.pr/v1"` unless the agent set `architecture: "v2"` (then
-   * `"github.pr/v2"`). Override type with `"github.issue/v2"` or
-   * `"github.none/v2"` for events outside PR membership.
+   * Continuation selector. Omit this to inherit the agent architecture's
+   * default. Set it explicitly only when migrating persisted identities.
    */
   continuation?: ContinuationIdentity;
   /**

package/src/channels/gitlab/types.ts

@@ -219,11 +219,8 @@ export interface GitLabChannelOptions {
    */
   webhookEvents?: readonly string[];
   /**
-   * Continuation selector. Omitted inherits {@link AgentConfig.architecture}:
-   * engine-minted per-MR continuation unless the agent set
-   * `architecture: "v2"` (then `gitlab.mr/v2`, or `gitlab.none/v2` when a
-   * non-MR event is declared). Override with `"gitlab.none/v2"` for one-shot
-   * events.
+   * Continuation selector. Omit this to inherit the agent architecture's
+   * default. Set it explicitly only when migrating persisted identities.
    */
   continuation?: ContinuationIdentity;
   /**

package/src/channels/origin/types.ts

@@ -246,9 +246,8 @@ export interface OriginChannelOptions {
    */
   webhookEvents?: readonly string[];
   /**
-   * Continuation selector. Omitted inherits {@link AgentConfig.architecture}:
-   * `"origin.pr/v1"` unless the agent set `architecture: "v2"` (then
-   * `"origin.pr/v2"`). Override with `"origin.none/v2"` for one-shot events.
+   * Continuation selector. Omit this to inherit the agent architecture's
+   * default. Set it explicitly only when migrating persisted identities.
    */
   continuation?: ContinuationIdentity;
   /**

package/src/channels/slack/defaults.ts

@@ -362,6 +362,9 @@ export function buildDefaultEvents(
       channel.state.streamTs = null;
       channel.state.streamChannelId = null;
       channel.state.streamFull = false;
+      // A stream failure downgrades the rest of its own turn, not the thread.
+      channel.state.streamingUnavailable = false;
+      channel.state.streamAppendedChunks = 0;
       channel.state.lastPostedText = null;
       channel.state.streamBlockText = null;
       channel.state.reasoningCard = undefined;

package/src/channels/slack/dispatch.ts

@@ -132,6 +132,7 @@ export function emptySlackChannelState(
     lastBotMessageTs: null,
     streamingUnavailable: false,
     streamFull: false,
+    streamAppendedChunks: 0,
     progressTs: null,
     approvalMessageByCallId: {},
     reasoningCard: undefined,

package/src/channels/slack/live-delivery.ts

@@ -147,6 +147,7 @@ export function createStreamDeliveryStrategy(
     channel.state.streamTs = started.ts;
     channel.state.streamChannelId = started.channel;
     channel.state.streamFull = false;
+    channel.state.streamAppendedChunks = 0;
     channel.state.lastPostedText = openingText;
     channel.state.streamBlockText = openingText;
     log.info("chat.startStream ok", {
@@ -193,6 +194,21 @@ export function createStreamDeliveryStrategy(
       highlightCodeFences(text)
     );
 
+  /**
+   * The reply does not extend what the stream already holds, so there is no
+   * delta to append and the text on Slack is not the reply.
+   */
+  const rewound = (channel: SlackChannel, text: string): boolean =>
+    streamDelta(channel, text) === "" &&
+    !highlightCodeFences(text).startsWith(
+      highlightCodeFences(channel.state.streamBlockText ?? "")
+    );
+
+  const countAppended = (channel: SlackChannel, chunks: number): void => {
+    channel.state.streamAppendedChunks =
+      (channel.state.streamAppendedChunks ?? 0) + chunks;
+  };
+
   const stopWithSuffix = async (args: {
     channel: SlackChannel;
     channelId: string;
@@ -246,25 +262,25 @@ export function createStreamDeliveryStrategy(
   };
 
   /**
-   * The streamed message is full. Close it as it stands so it stops spinning
-   * and post the rest as a new thread message. Most of the answer is on Slack
-   * either way, so the reply counts as delivered even if that post fails: a
-   * duplicate would be worse than a lost tail.
+   * The open stream cannot carry the rest of the reply — it is full, or the
+   * reply no longer extends what it holds. Close it as it stands so it stops
+   * spinning and post the remainder as a new thread message.
    */
-  const continueOverflow = async (args: {
+  const continueInNewMessage = async (args: {
     channel: SlackChannel;
     channelId: string;
     ts: string;
     remainder: string;
+    reason: string;
     sessionId: string;
-  }): Promise<void> => {
-    const { channel, channelId, ts, remainder, sessionId } = args;
+  }): Promise<boolean> => {
+    const { channel, channelId, ts, remainder, reason, sessionId } = args;
     const log = getLog();
     await stopChatStream({ botToken, channel: channelId, ts });
     channel.state.streamTs = null;
     const threadTs = channel.state.threadTs;
     if (remainder === "" || threadTs === null || threadTs === "") {
-      return;
+      return true;
     }
     try {
       const posted = await postMessage({
@@ -275,19 +291,23 @@ export function createStreamDeliveryStrategy(
         plainText: remainder.length >= SLACK_MARKDOWN_TEXT_MAX_LEN,
       });
       channel.state.lastBotMessageTs = posted.ts;
-      log.info("reply overflowed the stream; continued in a new message", {
+      log.info("reply continued in a new message", {
+        reason,
         channel: channelId,
         stream_ts: ts,
         session: sessionId,
         continued_chars: remainder.length,
       });
+      return true;
     } catch (error) {
-      log.warn("stream overflow continuation failed", {
+      log.warn("stream continuation failed", {
+        reason,
         error: error instanceof Error ? error.message : String(error),
         channel: channelId,
         stream_ts: ts,
         session: sessionId,
       });
+      return false;
     }
   };
 
@@ -328,6 +348,7 @@ export function createStreamDeliveryStrategy(
         noteAppendFailure(channel, result);
         return;
       }
+      countAppended(channel, 1);
       channel.state.lastPostedText = text;
       channel.state.streamBlockText = text;
     },
@@ -364,8 +385,10 @@ export function createStreamDeliveryStrategy(
           chunks: chunks.length,
         });
         noteAppendFailure(channel, result);
+        return false;
       }
-      return result.ok;
+      countAppended(channel, chunks.length);
+      return true;
     },
 
     async finalize({ channel, channelId, text, sessionId }) {
@@ -381,6 +404,22 @@ export function createStreamDeliveryStrategy(
       }
       // Measured before the stop attempt mutates stream state.
       const remainder = streamDelta(channel, text);
+      // Nothing to append and the stream does not hold the reply: closing it
+      // here would leave the answer nowhere and report it as delivered.
+      if (rewound(channel, text)) {
+        const posted = await continueInNewMessage({
+          channel,
+          channelId,
+          ts,
+          remainder: text,
+          reason: "rewound",
+          sessionId,
+        });
+        if (posted) {
+          channel.state.lastPostedText = text;
+        }
+        return { delivered: posted };
+      }
       const stopped =
         channel.state.streamFull === true
           ? { ok: false, error: "msg_too_long" }
@@ -391,15 +430,17 @@ export function createStreamDeliveryStrategy(
           stream_ts: ts,
           session: sessionId,
           chars: text.length,
+          appends: channel.state.streamAppendedChunks ?? 0,
         });
         return { delivered: true };
       }
       if (stopped.error === "msg_too_long") {
-        await continueOverflow({
+        await continueInNewMessage({
           channel,
           channelId,
           ts,
           remainder,
+          reason: "msg_too_long",
           sessionId,
         });
         channel.state.lastPostedText = text;

package/src/channels/slack/types.ts

@@ -81,6 +81,8 @@ export interface SlackChannelState {
   streamingUnavailable?: boolean;
   /** The open stream hit Slack's size cap; appends stop until it closes. */
   streamFull?: boolean;
+  /** Chunks Slack accepted on the open stream, reported when it closes. */
+  streamAppendedChunks?: number;
   /** Editable progress message ts when `chat.startStream` is unavailable. */
   progressTs: string | null;
   /**
@@ -597,9 +599,8 @@ export interface SlackAccessPolicy {
 export interface SlackChannelOptions {
   credentials?: SlackCredentials;
   /**
-   * Continuation selector. Omitted inherits {@link AgentConfig.architecture}:
-   * `"slack.thread/v1"` unless the agent set `architecture: "v2"` (then
-   * `"slack.thread/v2"`). Override with `"slack.none/v2"` for one-shot events.
+   * Continuation selector. Omit this to inherit the agent architecture's
+   * default. Set it explicitly only when migrating persisted identities.
    */
   continuation?: ContinuationIdentity;
   /** Defaults to `{ respondTo: "thread", blockExternals: true }`. */

package/src/index.ts

@@ -139,7 +139,9 @@ export {
   TOOL_MCP_ENDPOINT_PATH,
 } from "./internal/mcp-endpoint.js";
 export {
+  REMINDER_ARGS_MAX_BYTES,
   ReminderValidationError,
+  rejectAnonymousReminderHandlers,
   UnknownReminderError,
 } from "./internal/reminder-runner.js";
 export type { AgentMount } from "./internal/server.js";
@@ -169,8 +171,10 @@ export { prompt } from "./prompt.js";
 export type {
   ReminderBusyPolicy,
   ReminderCreateInput,
+  ReminderDefinition,
   ReminderFireContext,
   ReminderFireResult,
+  ReminderHandlerConfig,
   ReminderHostApi,
   ReminderInfo,
   ReminderReschedule,
@@ -179,6 +183,7 @@ export type {
   ReminderTarget,
   ReminderUntilContext,
 } from "./reminders.js";
+export { defineReminder } from "./reminders.js";
 export { defineResult } from "./result.js";
 export { defineSchedule } from "./schedules.js";
 export { defineSkill } from "./skills.js";
@@ -226,9 +231,7 @@ export {
 
 /**
  * Runtime config for an agent — authored at `agent/agent.ts` (the root
- * agent) or `agent/subagents/<id>/agent.ts` (a subagent). Set
- * `architecture: "v2"` to deploy onto the v2 control plane; omitted
- * channel continuation then inherits kind `/v2` defaults.
+ * agent) or `agent/subagents/<id>/agent.ts` (a subagent).
  */
 export function defineAgent(config: AgentConfig): AgentConfigDefinition {
   return brandDefinition("agent", config);

package/src/internal/cli-deploy.ts

@@ -1570,14 +1570,26 @@ export async function cmdDelete(
   if (typeof ctx === "number") {
     return ctx;
   }
-  let accepted: DeleteAccepted;
+  // Same dispatch as `stop`: v1 409s architecture-v2 slugs, so the v2
+  // DELETE goes first. A v2 404 (missing slug, or an older backend)
+  // falls through to the v1 agent-serve delete.
+  let architecture: "v1" | "v2" = "v2";
+  let accepted: DeleteAccepted | AgentkitStopAccepted;
   try {
-    accepted = await ctx.client.deleteDeployment({
-      teamId: ctx.teamId,
-      slug,
-    });
+    accepted = await ctx.client.deleteAgentkit({ teamId: ctx.teamId, slug });
   } catch (error) {
-    return renderApiError(error, ctx.err);
+    if (!(error instanceof DeployApiError) || error.status !== 404) {
+      return renderApiError(error, ctx.err);
+    }
+    try {
+      accepted = await ctx.client.deleteDeployment({
+        teamId: ctx.teamId,
+        slug,
+      });
+      architecture = "v1";
+    } catch (v1Error) {
+      return renderApiError(v1Error, ctx.err);
+    }
   }
   if (ctx.noWait) {
     if (ctx.json) {
@@ -1588,7 +1600,11 @@ export async function cmdDelete(
     return 0;
   }
   try {
-    await pollUntilGone(ctx, slug);
+    await pollUntilGone(ctx, slug, () =>
+      architecture === "v2"
+        ? ctx.client.getAgentkitDeploy({ teamId: ctx.teamId, slug })
+        : ctx.client.getDeployment({ teamId: ctx.teamId, slug })
+    );
   } catch (error) {
     return renderApiError(error, ctx.err);
   }
@@ -2103,7 +2119,12 @@ function transientDeployStatusWaitMs(
  */
 async function pollUntilGone(
   ctx: DeployCliContext,
-  slug: string
+  slug: string,
+  getDetail: () => Promise<{
+    status: string;
+    progress?: DeploymentProgress;
+    statusMessage?: string | null;
+  }>
 ): Promise<void> {
   const startedAt = Date.now();
   const tty = process.stderr.isTTY === true;
@@ -2126,10 +2147,7 @@ async function pollUntilGone(
 
   for (;;) {
     try {
-      const detail = await ctx.client.getDeployment({
-        teamId: ctx.teamId,
-        slug,
-      });
+      const detail = await getDetail();
       report(deployProgressLabel(detail));
     } catch (error: unknown) {
       if (error instanceof DeployApiError && error.status === 404) {

package/src/internal/cursor/backend-client.ts

@@ -82,6 +82,37 @@ const githubTokenResponseSchema: z.ZodType<CursorGithubToken> = z.object({
   expiresAt: z.string().datetime(),
 });
 
+/** SCMs whose git fetches ride the backend's `/v0/scm-events/<provider>-git-proxy` routes. */
+export type CursorScmCloneProvider = "gitlab" | "bitbucket";
+
+/**
+ * Proxied clone target for a GitLab / Bitbucket repository. The backend
+ * never hands out the provider credential: git fetches go to `remoteUrl`
+ * on the backend with the caller's own Cursor API key as a bearer token,
+ * and the backend adds the tenant credential per request.
+ */
+export interface CursorScmCloneTarget {
+  /** Absolute `<backend>/v0/scm-events/<provider>-git-proxy/<repo>.git`. */
+  remoteUrl: string;
+  /** Bearer credential git presents to the backend (the caller's API key). */
+  token: string;
+  /** ISO timestamp after which the caller re-resolves the target. */
+  expiresAt: string;
+  username: string;
+  authMode: "bearer";
+}
+
+const scmCloneTargetResponseSchema = z.object({
+  expiresAt: z.string().datetime(),
+  clone: z.object({
+    remotePath: z
+      .string()
+      .regex(/^\/v0\/scm-events\/[a-z]+-git-proxy\/.+\.git$/),
+    username: z.string().min(1),
+    authMode: z.literal("bearer"),
+  }),
+});
+
 const mcpToolSchema = z.object({
   name: z.string(),
   providerIdentifier: z.string().optional(),
@@ -490,6 +521,62 @@ export class CursorBackendClient {
     return githubTokenResponseSchema.parse(parsed);
   }
 
+  /**
+   * Resolve the proxied clone target for a GitLab / Bitbucket repository
+   * (`owner/name`; GitLab `path_with_namespace`). Same authorization as the
+   * provider proxy this host already calls; the returned remote lives on
+   * the backend and takes this client's API key, never a provider token.
+   */
+  async getScmCloneTarget(
+    provider: CursorScmCloneProvider,
+    repo: string
+  ): Promise<CursorScmCloneTarget> {
+    const label = provider === "gitlab" ? "GitLab" : "Bitbucket";
+    let response: Response;
+    try {
+      response = await this.fetchImpl(
+        `${this.backendUrl}/v0/scm-events/${provider}-clone-target`,
+        {
+          method: "POST",
+          headers: {
+            "content-type": "application/json",
+            authorization: `Bearer ${this.currentApiKey()}`,
+          },
+          body: JSON.stringify({ repo }),
+          signal: AbortSignal.timeout(30_000),
+        }
+      );
+    } catch (error) {
+      throw new CursorBackendError(
+        `Cursor ${label} clone target request failed: ${describeError(error)}`
+      );
+    }
+    const text = await response.text();
+    if (!response.ok) {
+      throw new CursorBackendError(
+        describeGithubTokenHttpFailure(response.status, text, label),
+        response.status,
+        retryAfterMsFromResponse(response)
+      );
+    }
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(text) as unknown;
+    } catch {
+      throw new CursorBackendError(
+        `Cursor backend returned a non-JSON ${label} clone target response.`
+      );
+    }
+    const body = scmCloneTargetResponseSchema.parse(parsed);
+    return {
+      remoteUrl: `${this.backendUrl}${body.clone.remotePath}`,
+      token: this.currentApiKey(),
+      expiresAt: body.expiresAt,
+      username: body.clone.username,
+      authMode: body.clone.authMode,
+    };
+  }
+
   /**
    * One unary Connect-JSON call on `aiserver.v1.<service>` with the same
    * token exchange and 401 retry as the dashboard RPCs. Callers parse the
@@ -864,7 +951,8 @@ const MAX_GITHUB_TOKEN_RETRY_AFTER_MS = 60 * 60_000;
  */
 function describeGithubTokenHttpFailure(
   status: number,
-  bodyText: string
+  bodyText: string,
+  label = "GitHub"
 ): string {
   const detail = githubTokenErrorFromBody(bodyText);
   if (status === 401) {
@@ -875,7 +963,7 @@ function describeGithubTokenHttpFailure(
   if (detail !== undefined) {
     return detail;
   }
-  return `Cursor GitHub credential request failed (${status}).`;
+  return `Cursor ${label} credential request failed (${status}).`;
 }
 
 function githubTokenErrorFromBody(bodyText: string): string | undefined {

package/src/internal/deploy-client.ts

@@ -675,6 +675,22 @@ export class AgentServeDeployClient {
     return agentkitStopAcceptedSchema.parse(raw);
   }
 
+  /**
+   * Delete a v2 deployment (`DELETE /internal/agentsdk/deployments/:slug`).
+   * 202 means accepted; poll {@link getAgentkitDeploy} until 404.
+   */
+  async deleteAgentkit(args: {
+    teamId: number;
+    slug: string;
+  }): Promise<AgentkitStopAccepted> {
+    const raw = await this.request({
+      method: "DELETE",
+      path: `/internal/agentsdk/deployments/${encodeURIComponent(args.slug)}?teamId=${args.teamId}`,
+      context: { verb: "delete", slug: args.slug },
+    });
+    return agentkitStopAcceptedSchema.parse(raw);
+  }
+
   async listDeployments(args: { teamId: number }): Promise<Deployment[]> {
     const raw = await this.request({
       method: "GET",