@cursor/july 0.1.79 → 0.1.82

package/src/internal/server.ts

@@ -20,11 +20,14 @@ import {
 } from "../channels/deployments/deployments-channel.js";
 import type { DeploymentsChannelOptions } from "../channels/deployments/types.js";
 import {
+  type CursorAccountGithubTokenResolver,
   type CursorGithubRepoScope,
   createCursorAccountGithubTokenResolver,
+  createCursorGithubProxyHostResolver,
+  cursorGithubPermissionsForChannel,
   type GithubCursorAccountRuntime,
   getGithubCursorAccountRuntime,
-  parseCursorGithubRepoScope,
+  resolveCursorGithubCredentialScope,
   resolveCursorGithubPermissions,
   resolveCursorGithubProxyUrl,
 } from "../channels/github/cursor-account.js";
@@ -315,79 +318,127 @@ export async function startServer(
       : requireCursorEventsAuth(effectiveCursorEvents, accountKey);
 
   let cursorGithubCredentials: CursorGithubCredentialProvider | undefined;
-  if (cursorGithubConfig.scope !== undefined) {
-    if (cursorEventsAuth === undefined) {
-      throw new Error(
-        "githubChannel({ cursorAccount: true }) could not resolve Cursor event authentication."
-      );
-    }
-    if (options.allowAnonymous === true) {
-      if (options.allowAnonymousCursorGithub !== true) {
+  // Proxy-wired GitHub token resolver for `ctx.host.github` when no startup
+  // token mint runs (empty repo scope): host Octokit calls must route
+  // through github-proxy exactly like channel Octokit calls.
+  let hostGithubProxyResolver: CursorAccountGithubTokenResolver | undefined;
+  if (cursorGithubTargets.length > 0) {
+    const githubProxyRequested = options.cursorGithubProxy === true;
+    const needsGithubAuth =
+      cursorGithubConfig.scope !== undefined || githubProxyRequested;
+    if (needsGithubAuth) {
+      const cursorGithubAuth =
+        cursorEventsAuth ??
+        (accountKey?.apiKey !== undefined && accountKey.apiKey.trim() !== ""
+          ? {
+              apiKey: accountKey.apiKey.trim(),
+              baseUrl: cursorExternalApiUrl(),
+            }
+          : undefined);
+      if (cursorGithubAuth === undefined) {
         throw new Error(
-          "githubChannel({ cursorAccount: true }) cannot be served with --allow-anonymous because admitted callers could use the signed-in account's GitHub access. If every admitted caller is trusted (e.g. behind an SSO proxy), opt in with --allow-anonymous-cursor-github."
+          "githubChannel({ cursorAccount: true }) could not resolve Cursor event authentication."
         );
       }
-      logger(
-        "[agent-sdk] warning: --allow-anonymous-cursor-github — every admitted HTTP caller can drive sessions holding the signed-in account's repo-scoped GitHub credential; serve this only behind a trusted boundary (e.g. an SSO proxy)"
-      );
-    }
-    if (cursorGithubConfig.scope.permissions === "contents-write") {
-      logger(
-        '[agent-sdk] warning: Cursor GitHub credentials include contents:write — the host holds a push-capable token shared with model-driven tools and untrusted webhook content; prefer permissions: "pr-write" unless this agent must push code'
-      );
-    }
-    const provider = new CursorGithubCredentialProvider({
-      client: new CursorBackendClient({
-        backendUrl: cursorEventsAuth.baseUrl,
-        apiKey: cursorEventsAuth.apiKey,
-        logger,
-      }),
-      scope: cursorGithubConfig.scope,
-      logger,
-    });
-    cursorGithubCredentials = provider;
-    const githubProxyUrl =
-      options.cursorGithubProxy === true
-        ? resolveCursorGithubProxyUrl(cursorEventsAuth.baseUrl)
-        : undefined;
-    if (githubProxyUrl !== undefined) {
-      // Proxy mode: channel Octokit calls carry the Cursor API key to the
-      // backend forwarder, which swaps in the installation token server-side
-      // and logs every call with per-deployment attribution. The provider
-      // still runs so child `gh` processes get a `GH_TOKEN` lease (v1).
-      const proxyTransport = {
-        apiBaseUrl: githubProxyUrl,
-        headers: {
-          "x-cursor-github-repos": cursorGithubConfig.scope.repos.join(","),
-          "x-cursor-github-permissions": cursorGithubConfig.scope.permissions,
-        },
-      };
-      for (const target of cursorGithubTargets) {
-        target.accountRuntime.credentials.bind(
-          async () => cursorEventsAuth.apiKey
+      if (options.allowAnonymous === true) {
+        if (options.allowAnonymousCursorGithub !== true) {
+          throw new Error(
+            "githubChannel({ cursorAccount: true }) cannot be served with --allow-anonymous because admitted callers could use the signed-in account's GitHub access. If every admitted caller is trusted (e.g. behind an SSO proxy), opt in with --allow-anonymous-cursor-github."
+          );
+        }
+        logger(
+          "[agent-sdk] warning: --allow-anonymous-cursor-github — every admitted HTTP caller can drive sessions holding the signed-in account's repo-scoped GitHub credential; serve this only behind a trusted boundary (e.g. an SSO proxy)"
         );
-        target.accountRuntime.credentials.bindProxyTransport(proxyTransport);
       }
-      logger(
-        `[agent-sdk] GitHub auth: channel API calls route through ${githubProxyUrl}`
-      );
-    } else {
-      for (const target of cursorGithubTargets) {
-        target.accountRuntime.credentials.bind(() => provider.getToken());
+      if (cursorGithubConfig.permissions === "contents-write") {
+        logger(
+          '[agent-sdk] warning: Cursor GitHub credentials include contents:write — the host holds a push-capable token shared with model-driven tools and untrusted webhook content; prefer permissions: "pr-write" unless this agent must push code'
+        );
+      }
+      const githubProxyUrl = githubProxyRequested
+        ? resolveCursorGithubProxyUrl(cursorGithubAuth.baseUrl)
+        : undefined;
+      if (cursorGithubConfig.scope !== undefined) {
+        const provider = new CursorGithubCredentialProvider({
+          client: new CursorBackendClient({
+            backendUrl: cursorGithubAuth.baseUrl,
+            apiKey: cursorGithubAuth.apiKey,
+            logger,
+          }),
+          scope: cursorGithubConfig.scope,
+          logger,
+        });
+        cursorGithubCredentials = provider;
+        if (githubProxyUrl !== undefined) {
+          // Proxy mode: channel Octokit calls carry the Cursor API key to the
+          // backend forwarder, which swaps in the installation token server-side
+          // and logs every call with per-deployment attribution. The provider
+          // still runs so child `gh` processes get a `GH_TOKEN` lease (v1).
+          const proxyTransport = {
+            apiBaseUrl: githubProxyUrl,
+            headers: {
+              "x-cursor-github-repos": cursorGithubConfig.scope.repos.join(","),
+              "x-cursor-github-permissions": cursorGithubConfig.permissions,
+            },
+          };
+          for (const target of cursorGithubTargets) {
+            target.accountRuntime.credentials.bind(
+              async () => cursorGithubAuth.apiKey
+            );
+            target.accountRuntime.credentials.bindProxyTransport(
+              proxyTransport
+            );
+          }
+          logger(
+            `[agent-sdk] GitHub auth: channel API calls route through ${githubProxyUrl}`
+          );
+        } else {
+          for (const target of cursorGithubTargets) {
+            target.accountRuntime.credentials.bind(() => provider.getToken());
+          }
+        }
+      } else if (githubProxyUrl !== undefined) {
+        // `cursorAccount: true` with no `--repo`: skip the startup token mint
+        // (it requires a repo list) and let github-proxy take the repo from
+        // each Octokit call. Hosted multi-tenant uses this with the
+        // deployment event stream.
+        const proxyTransport = {
+          apiBaseUrl: githubProxyUrl,
+          headers: {
+            "x-cursor-github-permissions": cursorGithubConfig.permissions,
+          },
+        };
+        for (const target of cursorGithubTargets) {
+          target.accountRuntime.credentials.bind(
+            async () => cursorGithubAuth.apiKey
+          );
+          target.accountRuntime.credentials.bindProxyTransport(proxyTransport);
+        }
+        // `ctx.host.github` gets the same proxy transport; without this it
+        // would fall back to ambient auth (env token / `gh`) or an
+        // unauthenticated Octokit, and every host GitHub call would 404.
+        hostGithubProxyResolver = createCursorGithubProxyHostResolver({
+          getApiKey: async () => cursorGithubAuth.apiKey,
+          transport: proxyTransport,
+        });
+        logger(
+          `[agent-sdk] GitHub auth: channel and host API calls route through ${githubProxyUrl} (repo scope per request)`
+        );
       }
     }
   }
   const resolvedCursorGithubCredentials = cursorGithubCredentials;
+  const hostGithubToken =
+    hostGithubProxyResolver ??
+    (resolvedCursorGithubCredentials === undefined
+      ? undefined
+      : createCursorAccountGithubTokenResolver(() =>
+          resolvedCursorGithubCredentials.getToken()
+        ));
   const hostPlatforms = createHostPlatforms(
-    resolvedCursorGithubCredentials === undefined
+    hostGithubToken === undefined
       ? {}
-      : {
-          githubCredentials: {
-            token: createCursorAccountGithubTokenResolver(() =>
-              resolvedCursorGithubCredentials.getToken()
-            ),
-          },
-        }
+      : { githubCredentials: { token: hostGithubToken } }
   );
 
   if (playground) {
@@ -2003,6 +2054,20 @@ function collectCursorGithubTargets(
 interface CursorGithubConfigResolution {
   cursorEvents: ServeOptions["cursorEvents"];
   scope: CursorGithubRepoScope | undefined;
+  permissions: CursorGithubRepoScope["permissions"];
+}
+
+function cursorGithubPermissionsForTarget(
+  target: CursorGithubTarget
+): CursorGithubRepoScope["permissions"] {
+  const authored =
+    typeof target.accountRuntime.options.cursorAccount === "object"
+      ? target.accountRuntime.options.cursorAccount.permissions
+      : undefined;
+  return (
+    target.accountRuntime.scope?.permissions ??
+    cursorGithubPermissionsForChannel(target.accountRuntime.options, authored)
+  );
 }
 
 function resolveCursorGithubEventConfig(input: {
@@ -2010,7 +2075,11 @@ function resolveCursorGithubEventConfig(input: {
   targets: CursorGithubTarget[];
 }): CursorGithubConfigResolution {
   if (input.targets.length === 0) {
-    return { cursorEvents: input.configured, scope: undefined };
+    return {
+      cursorEvents: input.configured,
+      scope: undefined,
+      permissions: "pr-write",
+    };
   }
   const repos = [
     ...(input.configured?.repos ?? []),
@@ -2019,17 +2088,23 @@ function resolveCursorGithubEventConfig(input: {
     ]),
   ];
   const permissions = resolveCursorGithubPermissions(
-    input.targets.map(
-      (target) => target.accountRuntime.scope?.permissions ?? "pr-write"
-    )
+    input.targets.map(cursorGithubPermissionsForTarget)
   );
-  const scope = parseCursorGithubRepoScope(repos, permissions);
+  const scope = resolveCursorGithubCredentialScope(repos, permissions);
+  if (scope === undefined) {
+    return {
+      cursorEvents: input.configured,
+      scope: undefined,
+      permissions,
+    };
+  }
   return {
     cursorEvents: {
       ...input.configured,
       repos: [...scope.repos],
     },
     scope,
+    permissions,
   };
 }
 
@@ -2078,6 +2153,9 @@ function resolveCursorOriginRepoScope(input: {
       (target) => target.accountRuntime.scope?.repos ?? []
     ),
   ];
+  if (repos.length === 0) {
+    return undefined;
+  }
   return parseCursorOriginRepoScope(repos);
 }
 

package/src/internal/session-engine.ts

@@ -24,7 +24,10 @@ import {
   SlackNudgeStore,
 } from "../channels/slack/nudge-store.js";
 import { resolveDedicatedSlackHostBinding } from "../channels/slack/slack-channel.js";
-import { isCursorHostedFilesAvailable } from "../files-backends/cursor-hosted.js";
+import {
+  cursorHostedFiles,
+  isCursorHostedFilesAvailable,
+} from "../files-backends/cursor-hosted.js";
 import {
   type AgentProject,
   type ApprovalDecision,
@@ -80,6 +83,16 @@ import {
   isUnpricedCompletedTurn,
   mapSdkTokenUsage,
 } from "./cloud-turn-cost.js";
+import {
+  applyAgentContinuationDefaults,
+  channelContinuationIdentity,
+  httpContinuationIdentity,
+} from "./continuation-channel.js";
+import {
+  continuationSource,
+  resolveV2Key,
+  V2EngineError,
+} from "./continuation-identity.js";
 import { isDevMode } from "./dev-mode.js";
 import { type EventLogMemoryStats, EventLogStore } from "./event-log.js";
 import { TurnEventMapper } from "./event-mapper.js";
@@ -113,6 +126,7 @@ import { assertCloudCanHonorAccountServersFilters } from "./resolved-connections
 import type { AgentRunner } from "./sdk-runner.js";
 import { sessionExternalLinks } from "./session-links.js";
 import { SessionStore } from "./session-store.js";
+import { syncSkillsToStore } from "./skills-sync.js";
 import { StorageCoordinator } from "./storage-coordinator.js";
 import type { FrameworkSessionStore } from "./storage-roles.js";
 import { normalizeToolResult, toolCallErrorMessage } from "./tool-result.js";
@@ -302,6 +316,8 @@ export class SessionEngine {
   >();
   /** Once-per-process cache for the A/B snapshot backfill (see abSnapshot). */
   private restoredAbSnapshot: Promise<ABSnapshot | undefined> | undefined;
+  /** In-flight skills → deployment store sync (see ensureCloudSkillsSynced). */
+  private cloudSkillsSync: Promise<boolean> | undefined;
 
   private readonly runner: AgentRunner;
   private readonly logger: (line: string) => void;
@@ -366,6 +382,7 @@ export class SessionEngine {
 
   constructor(options: SessionEngineOptions) {
     this.project = options.project;
+    applyAgentContinuationDefaults(this.project);
     this.stateRoot = options.stateRoot;
     this.runner = options.runner;
     this.logger = options.logger ?? (() => {});
@@ -734,26 +751,50 @@ export class SessionEngine {
    * Start or resume a session on a channel. When `continuationToken`
    * addresses an existing session this is a follow-up turn; otherwise a new
    * session is created (keyed by the provided token, or a fresh one).
+   *
+   * v2 (`/v2` selectors) refuses `continuationToken` and looks
+   * up `(agentId, cKey)` from a mailbox stamp or structured claim.
    */
   async send(
     channelId: string,
     message: string,
     options: EngineSendOptions = {}
   ): Promise<ChannelSession> {
-    const auth = options.auth ?? null;
+    const identity =
+      channelId === HTTP_CHANNEL_ID
+        ? httpContinuationIdentity(this.project.httpChannel)
+        : channelContinuationIdentity(this.channelsById.get(channelId));
+    let sendOptions = options;
+    let skipContinuationLookup = false;
+    if (continuationSource(identity) === "control-plane") {
+      if (options.continuationToken !== undefined) {
+        throw new V2EngineError(
+          "v2: do not pass continuationToken; use mailboxContinuation or claim"
+        );
+      }
+      const cKey = resolveV2Key(identity, options);
+      sendOptions = { ...options, continuationToken: cKey };
+      skipContinuationLookup = cKey.startsWith("evt:");
+    }
+
+    const auth = sendOptions.auth ?? null;
     let existing =
-      options.continuationToken === undefined
+      skipContinuationLookup || sendOptions.continuationToken === undefined
         ? undefined
         : await this.sessions.findByContinuation(
             channelId,
-            options.continuationToken
+            sendOptions.continuationToken
           );
-    if (existing === undefined && options.continuationToken !== undefined) {
+    if (
+      existing === undefined &&
+      !skipContinuationLookup &&
+      sendOptions.continuationToken !== undefined
+    ) {
       // Local miss: the session may live only in the storage sink (it
       // fell outside the startup restore window, or restore is lazy-only).
       existing = await this.restoreSessionByContinuation(
         channelId,
-        options.continuationToken
+        sendOptions.continuationToken
       );
     }
 
@@ -765,25 +806,25 @@ export class SessionEngine {
       // synchronize). Leave the durable continuation key unchanged.
       let record = existing;
       const refreshWorkspace =
-        options.workspaceDir !== undefined &&
-        options.workspaceDir !== existing.workspaceOverride;
+        sendOptions.workspaceDir !== undefined &&
+        sendOptions.workspaceDir !== existing.workspaceOverride;
       if (
         refreshWorkspace ||
-        options.workspaceFiles !== undefined ||
-        options.images !== undefined
+        sendOptions.workspaceFiles !== undefined ||
+        sendOptions.images !== undefined
       ) {
         record = await this.updateRecord(existing.sessionId, (current) => ({
           ...current,
           workspaceOverride: refreshWorkspace
-            ? options.workspaceDir
+            ? sendOptions.workspaceDir
             : current.workspaceOverride,
           pendingWorkspaceFiles: mergePendingWorkspaceFiles(
             current.pendingWorkspaceFiles,
-            options.workspaceFiles
+            sendOptions.workspaceFiles
           ),
           pendingImages: mergePendingImages(
             current.pendingImages,
-            options.images
+            sendOptions.images
           ),
         }));
       }
@@ -792,31 +833,32 @@ export class SessionEngine {
       // and the first send's snapshot must not pin this session's turns to a
       // stale repo/prUrl for the session's lifetime.
       if (
-        options.cloud !== undefined &&
-        JSON.stringify(options.cloud) !== JSON.stringify(record.cloudOverride)
+        sendOptions.cloud !== undefined &&
+        JSON.stringify(sendOptions.cloud) !==
+          JSON.stringify(record.cloudOverride)
       ) {
         record = await this.updateRecord(record.sessionId, (current) => ({
           ...current,
-          cloudOverride: options.cloud,
+          cloudOverride: sendOptions.cloud,
         }));
       }
       // Refresh wake-derived channel state (GitHub headSha / refs) without
       // wiping sticky fields. Null patch values are skipped.
-      if (options.refreshState !== undefined) {
+      if (sendOptions.refreshState !== undefined) {
         record = await this.updateRecord(record.sessionId, (current) => ({
           ...current,
           channelState: mergeChannelStateSkipNull(
             current.channelState,
-            options.refreshState
+            sendOptions.refreshState
           ),
         }));
       }
       const since = (await this.logs.get(record.sessionId)).count;
       const coalesced = await this.startTurn(record.sessionId, message, {
-        admission: options.admission ?? "preempt",
-        ...(options.coalesceSourceTs === undefined
+        admission: sendOptions.admission ?? "preempt",
+        ...(sendOptions.coalesceSourceTs === undefined
           ? {}
-          : { sourceTs: options.coalesceSourceTs }),
+          : { sourceTs: sendOptions.coalesceSourceTs }),
       });
       return this.channelSession(
         record.sessionId,
@@ -828,22 +870,22 @@ export class SessionEngine {
     }
 
     const now = new Date().toISOString();
-    const channelState = this.initialChannelState(channelId, options.state);
-    const purpose = options.purpose === "eval" ? "eval" : "live";
+    const channelState = this.initialChannelState(channelId, sendOptions.state);
+    const purpose = sendOptions.purpose === "eval" ? "eval" : "live";
     let record: SessionRecord = {
       sessionId: newSessionId(),
       channelId,
-      mode: options.mode ?? "chat",
+      mode: sendOptions.mode ?? "chat",
       purpose,
-      continuationKey: options.continuationToken ?? newContinuationKey(),
+      continuationKey: sendOptions.continuationToken ?? newContinuationKey(),
       auth,
-      title: options.title,
+      title: sendOptions.title,
       channelState,
-      workspaceOverride: options.workspaceDir,
-      pendingWorkspaceFiles: options.workspaceFiles,
-      pendingImages: options.images,
-      cloudOverride: options.cloud,
-      sdkAgentId: options.sdkAgentId,
+      workspaceOverride: sendOptions.workspaceDir,
+      pendingWorkspaceFiles: sendOptions.workspaceFiles,
+      pendingImages: sendOptions.images,
+      cloudOverride: sendOptions.cloud,
+      sdkAgentId: sendOptions.sdkAgentId,
       turnCount: 0,
       createdAt: now,
       updatedAt: now,
@@ -857,10 +899,10 @@ export class SessionEngine {
     record = await this.enrollABs(record);
     const since = (await this.logs.get(record.sessionId)).count;
     await this.startTurn(record.sessionId, message, {
-      admission: options.admission ?? "preempt",
-      ...(options.coalesceSourceTs === undefined
+      admission: sendOptions.admission ?? "preempt",
+      ...(sendOptions.coalesceSourceTs === undefined
         ? {}
-        : { sourceTs: options.coalesceSourceTs }),
+        : { sourceTs: sendOptions.coalesceSourceTs }),
     });
     return this.channelSession(record.sessionId, record, true, false, since);
   }
@@ -1753,6 +1795,51 @@ export class SessionEngine {
     };
   }
 
+  /**
+   * Sync authored skills onto the deployment store at `skills/<name>/…`
+   * before the first cloud prompt, so `--agent-store-skills-dir` and the
+   * first-turn S3 scan can discover them. False when the sync fails: the
+   * turn then runs without store skills rather than pointing discovery at
+   * paths that do not exist.
+   *
+   * With skills authored, every first cloud turn re-copies the authored
+   * bytes and the memo only dedupes concurrent first turns. The mount is
+   * writable from cloud sessions, so a once-per-process copy would let one
+   * session's edits masquerade as agent definition for every later session
+   * until the engine restarts; re-syncing keeps the store true to discovery
+   * the same way local materialization always rewrites skills. Without
+   * skills the sync is best-effort stale cleanup and one attempt per
+   * process is enough, success or not — a deployment without the files
+   * surface must not fail and log on every new session for a feature it
+   * does not use.
+   */
+  private ensureCloudSkillsSynced(): Promise<boolean> {
+    if (this.cloudSkillsSync !== undefined) {
+      return this.cloudSkillsSync;
+    }
+    const skills = this.project.agent.skills;
+    let sync = syncSkillsToStore({
+      sink: cursorHostedFiles(),
+      agentName: this.project.name,
+      skills,
+    }).then(
+      () => true,
+      (error) => {
+        this.logger(
+          `[skills] deployment store sync failed: ${error instanceof Error ? error.message : String(error)}`
+        );
+        return false;
+      }
+    );
+    if (skills.length > 0) {
+      sync = sync.finally(() => {
+        this.cloudSkillsSync = undefined;
+      });
+    }
+    this.cloudSkillsSync = sync;
+    return sync;
+  }
+
   private async buildTurnRequest(
     record: SessionRecord,
     agent: ResolvedAgent,
@@ -1815,8 +1902,9 @@ export class SessionEngine {
     if (isFirstTurn) {
       if (runtime === "cloud") {
         // Cloud VMs have no materialized workspace: ship the full context,
-        // including agent tool script bodies. On hosted deployments the
-        // shared memory journal is on the store mount — say where. When the
+        // including agent tool script bodies. On hosted deployments authored
+        // skills land on the store mount for native discovery, and the
+        // shared memory journal is on that mount too — say where. When the
         // turn carries the session-bound server-tool MCP endpoint, the
         // preamble catalogs server tools under that MCP server name *before*
         // the agent-tool "write the script if missing" recipe, so a model
@@ -1828,7 +1916,14 @@ export class SessionEngine {
               ? undefined
               : SERVER_TOOLS_MCP_SERVER_NAME,
         });
-        const memorySection = isCursorHostedFilesAvailable()
+        const hosted = isCursorHostedFilesAvailable();
+        // Synced whenever hosted, not just when skills exist: removing the
+        // last skill has to delete its store copies too. Discovery is native
+        // (`--agent-store-skills-dir`); this only has to land the bytes.
+        if (hosted) {
+          await this.ensureCloudSkillsSynced();
+        }
+        const memorySection = hosted
           ? `\n\n${buildCloudMemorySection(this.project.name)}`
           : "";
         turnPrompt = `${preamble}${memorySection}\n\n${turnPrompt}`;

package/src/internal/session-store.ts

@@ -11,6 +11,7 @@ import { mkdir, readdir, readFile, rename, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import type { SessionRecord } from "../types.js";
 import { isSafeSessionId } from "./auth.js";
+import { isV2DurableContinuationKey } from "./continuation-identity.js";
 
 export class SessionStore {
   private readonly cache = new Map<string, SessionRecord>();
@@ -39,6 +40,11 @@ export class SessionStore {
   }
 
   private continuationKeyOf(channelId: string, key: string): string {
+    // v2 index is (agentId, cKey). This store is already per-agent, so drop
+    // channelId for `cont:` / `evt:` keys. v1 stays `{channelId}\n{token}`.
+    if (isV2DurableContinuationKey(key)) {
+      return `\0v2\n${key}`;
+    }
     return `${channelId}\n${key}`;
   }