@cursor/july 0.1.113 → 0.2.0

package/src/internal/server.ts

@@ -919,6 +919,14 @@ export async function startServer(
       }),
       architecture,
       controlPlane: reminderControlPlane,
+      // Hosted admissions build their channel args with no request
+      // principal (`buildChannelHandlerArgs` → `auth: null`), so a fire that
+      // opens a session on a fresh pod uses the same one and a session
+      // restored from durable storage still matches.
+      hostedGuest:
+        hostedReminderControlPlane === undefined
+          ? undefined
+          : { fireAuth: () => null },
     });
     const evalRuns = new EvalRunStore(
       project.rootDir,

package/src/memory.ts

@@ -117,6 +117,30 @@ export interface AgentStoreMemoryBackendOptions {
   sink?: FileSink;
   /** Rotation threshold, same meaning as {@link FileMemoryBackendOptions}. */
   maxJournalBytes?: number;
+  /** Backoff sleep override (tests). */
+  sleep?: (ms: number) => Promise<void>;
+  /** Jitter source override (tests). Returns [0, 1). */
+  random?: () => number;
+}
+
+/**
+ * CAS attempts per append. The journal is one deployment-wide key written by
+ * every engine pod, so under concurrent turn traffic the etag precondition
+ * loses races routinely; each retry needs headroom to land.
+ */
+const MEMORY_CAS_MAX_ATTEMPTS = 5;
+
+/**
+ * Jittered exponential backoff between CAS attempts. Retrying immediately is
+ * a fleet-wide stampede: every losing pod re-GETs the full journal and
+ * re-PUTs in lockstep, which multiplied reads ~65x on one deployment during
+ * the 2026-09-18 Agent Store read storm and tripped the store's
+ * per-service-account read limit (every pod shares the deployment
+ * credential). Jitter desynchronizes the writers so most retries land on the
+ * first or second attempt.
+ */
+function memoryCasBackoffMs(attempt: number, random: () => number): number {
+  return 100 * 2 ** attempt * (0.5 + random());
 }
 
 /**
@@ -130,8 +154,14 @@ export function agentStoreMemoryBackend(
 ): MemoryBackend {
   const sink = options.sink ?? cursorHostedFiles();
   const maxJournalBytes = options.maxJournalBytes ?? 5 * 1024 * 1024;
+  const sleep =
+    options.sleep ??
+    ((ms: number) => new Promise<void>(resolve => setTimeout(resolve, ms)));
+  const random = options.random ?? Math.random;
   // Appends are chained per journal key (same shape as fileMemoryBackend);
-  // a failed append must not poison the chain for later turns.
+  // a failed append must not poison the chain for later turns. The chain
+  // serializes appends within this pod only — pods race each other on the
+  // shared key, which is what the CAS retry (with backoff) absorbs.
   const appendChains = new Map<string, Promise<void>>();
 
   const append = async (
@@ -140,7 +170,7 @@ export function agentStoreMemoryBackend(
   ): Promise<void> => {
     const key = agentStoreKeys.memoryJournal(ctx.agentName);
     const line = Buffer.from(`${JSON.stringify(record)}\n`, "utf8");
-    for (let attempt = 0; attempt < 3; attempt += 1) {
+    for (let attempt = 0; attempt < MEMORY_CAS_MAX_ATTEMPTS; attempt += 1) {
       const current = await sink.get(key);
       const currentBody =
         current === undefined
@@ -170,7 +200,11 @@ export function agentStoreMemoryBackend(
           ifMatch: current === undefined ? null : etag,
         });
       } catch (error) {
-        if (error instanceof FileConflictError && attempt < 2) {
+        if (
+          error instanceof FileConflictError &&
+          attempt < MEMORY_CAS_MAX_ATTEMPTS - 1
+        ) {
+          await sleep(memoryCasBackoffMs(attempt, random));
           continue;
         }
         throw error;

package/src/types.ts

@@ -279,8 +279,8 @@ export interface AgentConfig {
    */
   tools?: ToolName[];
   /**
-   * Hosted architecture override. Leave this unset unless Cursor instructs
-   * you to select a specific architecture.
+   * Hosted architecture. Defaults to `"v2"`. Set `"v1"` to stay on the
+   * resident-engine architecture.
    */
   architecture?: AgentArchitecture;
   /**
@@ -2475,10 +2475,11 @@ export type ChannelEventHandlers<TState = JsonValue> = {
 export interface ChannelStartArgs {
   send: SendMessageFn;
   /**
-   * Hosted architecture from {@link AgentConfig.architecture}. Omitted
-   * means v1. Host pipelines that call `send()` themselves (instead of
-   * letting the channel adapter stamp continuation) branch on this so
-   * v1 `continuationToken` and v2 `claim` stay mutually exclusive.
+   * Hosted architecture from {@link AgentConfig.architecture}. Discovery
+   * fills `"v2"` when the author omits it. Host pipelines that call
+   * `send()` themselves (instead of letting the channel adapter stamp
+   * continuation) branch on this so v1 `continuationToken` and v2 `claim`
+   * stay mutually exclusive.
    */
   architecture?: AgentArchitecture;
   getSession(sessionId: string): Promise<ChannelSession | null>;
@@ -3006,7 +3007,12 @@ export interface ReminderFireContext extends ReminderUntilContext {
    * uses a named {@link ReminderCreateInput.handler}. Empty object otherwise.
    */
   args: JsonObject;
-  /** Wake the reminder's already-bound session (target is implicit). */
+  /**
+   * Wake the reminder's already-bound session (target is implicit). On a
+   * hosted architecture v2 deployment this resolves after the woken turn
+   * completes, because the pod may stop once the fire's outcome is applied;
+   * locally and on v1 it resolves as soon as the turn is admitted.
+   */
   followup(args: { message: string }): Promise<ChannelSession>;
   cancel(reason?: string): Promise<void>;
   /**
@@ -3344,8 +3350,9 @@ export interface ResolvedAgent {
   concurrency?: AgentConcurrencyOptions;
   /**
    * Validated architecture from {@link AgentConfig.architecture}.
-   * `"v2"` deploys onto the v2 control plane and stamps kind `/v2`
-   * continuation defaults onto channels that omitted a selector.
+   * Omitted authors resolve to `"v2"`. `"v2"` deploys onto the v2
+   * control plane and stamps kind `/v2` continuation defaults onto
+   * channels that omitted a selector.
    */
   architecture?: AgentArchitecture;
   persistent?: boolean;