@cursor/july 0.1.101 → 0.1.103

package/src/internal/session-engine.ts

@@ -28,12 +28,16 @@ import { resolveDedicatedSlackHostBinding } from "../channels/slack/slack-channe
 import {
   AGENT_SERVE_USER_STORE_FILES_SOURCE_ID,
   agentStoreKeys,
+  DEPLOYMENT_STORE_MOUNT_PATH,
+  type FileSink,
+  USER_STORE_MOUNT_PATH,
 } from "../files.js";
 import {
   cursorHostedFiles,
   isCursorHostedFilesAvailable,
   isCursorUserStoreFilesAvailable,
 } from "../files-backends/cursor-hosted.js";
+import { storageKeysForArchitecture } from "../storage.js";
 import {
   type AgentProject,
   type AgentRuntime,
@@ -69,6 +73,7 @@ import {
   type RunnerTurnRequest,
   type SendMessageFn,
   type SendMessageOptions,
+  type SessionContext,
   type SessionEvent,
   type SessionEventPayload,
   type SessionInfo,
@@ -115,6 +120,7 @@ import {
   resolveV2Key,
   V2EngineError,
 } from "./continuation-identity.js";
+import { describeError } from "./describe-error.js";
 import { isDevMode } from "./dev-mode.js";
 import { type EventLogMemoryStats, EventLogStore } from "./event-log.js";
 import { TurnEventMapper } from "./event-mapper.js";
@@ -151,6 +157,7 @@ import {
   SCHEDULE_CHANNEL_PREFIX,
 } from "./prompt-context.js";
 import { assertCloudCanHonorAccountServersFilters } from "./resolved-connections.js";
+import { applyAuthoredResult } from "./result-output.js";
 import type { AgentRunner, SteerAckOutcome } from "./sdk-runner.js";
 import { sessionExternalLinks } from "./session-links.js";
 import { SessionStore } from "./session-store.js";
@@ -168,19 +175,34 @@ import {
 import { TurnGovernor } from "./turn-governor.js";
 import { TurnLeaseStore } from "./turn-lease-store.js";
 import { TurnOutbox } from "./turn-outbox.js";
+import { resolveAgentV2Hosting } from "./v2-hosting.js";
 import {
   buildAgentsMdContent,
   buildCloudMemorySection,
+  buildCloudWorkspaceSection,
   ensureOwnGitRoot,
   isNestedInGitRepo,
   materializeWorkspace,
   SERVER_TOOLS_MCP_SERVER_NAME,
   writeWorkspaceFiles,
 } from "./workspace.js";
+import { syncWorkspaceToStore } from "./workspace-sync.js";
 
 export const HTTP_CHANNEL_ID = "http";
 export { SCHEDULE_CHANNEL_PREFIX } from "./prompt-context.js";
 
+/** Authored surfaces mirrored onto the Agent Store before a first cloud prompt. */
+type CloudSyncSurface = "skills" | "workspace";
+
+/** The Agent Store cloud turns read authored files from, and where the VM mounts it. */
+interface CloudStoreTarget {
+  sink: FileSink;
+  mountPath: string;
+  skillsPrefix: string;
+  workspacePrefix: string;
+  label: string;
+}
+
 export class SessionBusyError extends Error {
   constructor(sessionId: string) {
     super(
@@ -404,8 +426,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 → Agent Store sync (see ensureCloudSkillsSynced). */
-  private cloudSkillsSync: Promise<boolean> | undefined;
+  /** In-flight authored files → Agent Store syncs (see syncToCloudStore). */
+  private readonly cloudSyncs = new Map<CloudSyncSurface, Promise<boolean>>();
 
   private readonly runner: AgentRunner;
   private readonly logger: (line: string) => void;
@@ -537,20 +559,36 @@ export class SessionEngine {
             agentName: options.project.name,
             projectRoot: options.project.rootDir,
             logger: this.logger,
+            keys: storageKeysForArchitecture(
+              options.project.agent.architecture
+            ),
           });
     this.kvApi = createHostKvApi({
       agentName: options.project.name,
       stateRoot: options.stateRoot,
       ...(this.storage === undefined ? {} : { storage: this.storage }),
     });
+    const v2Hosting = resolveAgentV2Hosting({
+      architecture: options.project.agent.architecture,
+    });
+    const managedV2Files =
+      v2Hosting.kind === "cursor-managed"
+        ? () =>
+            cursorHostedFiles({
+              resolveStoreSourceId: () =>
+                v2Hosting.resolveStoreIds().deploymentStoreSourceId,
+            })
+        : undefined;
     this.filesApi = createHostFilesApi({
       agentName: options.project.name,
       stateRoot: options.stateRoot,
+      sink: managedV2Files?.(),
     });
     this.artifactsStore = new ArtifactsStore({
       stateRoot: options.stateRoot,
       agentName: options.project.name,
       config: options.project.artifacts,
+      sink: managedV2Files?.(),
     });
     this.abCollector = new ABCollector(
       options.project.abs,
@@ -660,9 +698,9 @@ export class SessionEngine {
   }
 
   /**
-   * Host services with `files` bound to one session, so a relative path in a
-   * tool or hook resolves to that session's scope and can never be read as
-   * another session's. Unbound (no session) keeps `host.files` usable for
+   * Host services with `files` and `otel` bound to one session, so a relative
+   * path resolves to that session's scope and can never read another
+   * session's. Unbound (no session) keeps `host.files` usable for
    * `{ scope: "deployment" }` and fails loudly on session-scoped calls.
    */
   private hostForSession(sessionId: string | undefined): HostContext {
@@ -1988,7 +2026,9 @@ export class SessionEngine {
         this.activeToolContexts.set(sessionId, { record, turnId, emit });
         this.stubbedCallIds.set(sessionId, stubbed);
         try {
-          outcome = await this.runner.runTurn(request);
+          outcome = await this.runTurnExecute(record, turnId, () =>
+            this.runner.runTurn(request)
+          );
         } finally {
           this.activeToolContexts.delete(sessionId);
           this.stubbedCallIds.delete(sessionId);
@@ -2031,14 +2071,39 @@ export class SessionEngine {
       outcome = { ...outcome, cost: finalCost };
     }
 
+    const authored = this.project.result;
+    if (outcome.status === "finished" && authored !== undefined) {
+      const settled = await applyAuthoredResult({
+        definition: authored,
+        text: finalResult,
+        dryRun: record.dryRun === true,
+        ctx: {
+          session: this.sessionInfo(record),
+          host: this.hostForSession(sessionId),
+          artifacts: this.artifactsApi({ sessionId, turnId }),
+          stateRoot: this.stateRoot,
+          workspaceDir: harnessCwd,
+        },
+      });
+      if (!settled.ok) {
+        outcome = {
+          status: "error",
+          result: finalResult,
+          errorMessage: `turn output failed: ${settled.message}`,
+          usage: finalUsage,
+          cost: finalCost,
+        };
+      }
+    }
+
     if (outcome.status === "finished") {
       await this.appendEvent(sessionId, {
         type: "turn.completed",
         turnId,
         data: {
-          ...(finalResult === undefined ? {} : { result: finalResult }),
-          ...(finalUsage === undefined ? {} : { usage: finalUsage }),
-          ...(finalCost === undefined ? {} : { cost: finalCost }),
+          result: finalResult,
+          usage: finalUsage,
+          cost: finalCost,
         },
       });
     } else {
@@ -2080,8 +2145,8 @@ export class SessionEngine {
 
     return {
       ...outcome,
-      ...(finalResult === undefined ? {} : { result: finalResult }),
-      ...(finalUsage === undefined ? {} : { usage: finalUsage }),
+      result: finalResult,
+      usage: finalUsage,
     };
   }
 
@@ -2092,48 +2157,75 @@ export class SessionEngine {
    * 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
+   */
+  private ensureCloudSkillsSynced(store: CloudStoreTarget): Promise<boolean> {
+    const skills = this.project.agent.skills;
+    return this.syncToCloudStore("skills", store, skills.length > 0, () =>
+      syncSkillsToStore({
+        sink: store.sink,
+        agentName: this.project.name,
+        skills,
+        skillsPrefix: store.skillsPrefix,
+      })
+    );
+  }
+
+  /**
+   * Sync `agent/sandbox/workspace/**` seeds onto the Agent Store at
+   * `workspace/…` (hosted) or `agent-serve/<agent>/workspace/…`
+   * (personal-key local+cloud) before the first cloud prompt, which names
+   * the mounted directory (see buildCloudWorkspaceSection).
+   */
+  private ensureCloudWorkspaceSynced(
+    store: CloudStoreTarget
+  ): Promise<boolean> {
+    const seedFiles = this.project.agent.seedFiles;
+    return this.syncToCloudStore("workspace", store, seedFiles.length > 0, () =>
+      syncWorkspaceToStore({
+        sink: store.sink,
+        seedFiles,
+        workspacePrefix: store.workspacePrefix,
+      })
+    );
+  }
+
+  /**
+   * With files 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
+   * authored files 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 target = this.cloudSkillsStore();
-    if (target === undefined) {
-      this.cloudSkillsSync = Promise.resolve(false);
-      return this.cloudSkillsSync;
+  private syncToCloudStore(
+    surface: CloudSyncSurface,
+    store: CloudStoreTarget,
+    authored: boolean,
+    run: () => Promise<void>
+  ): Promise<boolean> {
+    const inFlight = this.cloudSyncs.get(surface);
+    if (inFlight !== undefined) {
+      return inFlight;
     }
-    const skills = this.project.agent.skills;
-    let sync = syncSkillsToStore({
-      sink: target.sink,
-      agentName: this.project.name,
-      skills,
-      skillsPrefix: target.skillsPrefix,
-    }).then(
+    let sync = run().then(
       () => true,
       (error) => {
         this.logger(
-          `[skills] ${target.label} sync failed: ${error instanceof Error ? error.message : String(error)}`
+          `[${surface}] ${store.label} sync failed: ${error instanceof Error ? error.message : String(error)}`
         );
         return false;
       }
     );
-    if (skills.length > 0) {
+    if (authored) {
       sync = sync.finally(() => {
-        this.cloudSkillsSync = undefined;
+        this.cloudSyncs.delete(surface);
       });
     }
-    this.cloudSkillsSync = sync;
+    this.cloudSyncs.set(surface, sync);
     return sync;
   }
 
@@ -2141,26 +2233,36 @@ export class SessionEngine {
    * Hosted deployments own the deployment store. Local `serve`/`run` with
    * a personal API key writes into the USER store under `agent-serve/`.
    */
-  private cloudSkillsStore():
-    | {
-        sink: ReturnType<typeof cursorHostedFiles>;
-        skillsPrefix: string;
-        label: string;
-      }
-    | undefined {
-    if (isCursorHostedFilesAvailable()) {
+  private cloudStore(): CloudStoreTarget | undefined {
+    const v2Hosting = resolveAgentV2Hosting({
+      architecture: this.project.agent.architecture,
+    });
+    const deployment = {
+      mountPath: DEPLOYMENT_STORE_MOUNT_PATH,
+      skillsPrefix: agentStoreKeys.skillsPrefix(),
+      workspacePrefix: agentStoreKeys.workspacePrefix(),
+      label: "deployment store",
+    };
+    if (v2Hosting.kind === "cursor-managed") {
       return {
-        sink: cursorHostedFiles(),
-        skillsPrefix: agentStoreKeys.skillsPrefix(),
-        label: "deployment store",
+        sink: cursorHostedFiles({
+          resolveStoreSourceId: () =>
+            v2Hosting.resolveStoreIds().deploymentStoreSourceId,
+        }),
+        ...deployment,
       };
     }
+    if (v2Hosting.kind === "not-v2" && isCursorHostedFilesAvailable()) {
+      return { sink: cursorHostedFiles(), ...deployment };
+    }
     if (isCursorUserStoreFilesAvailable()) {
       return {
         sink: cursorHostedFiles({
           storeSourceId: AGENT_SERVE_USER_STORE_FILES_SOURCE_ID,
         }),
+        mountPath: USER_STORE_MOUNT_PATH,
         skillsPrefix: agentStoreKeys.userSkillsPrefix(this.project.name),
+        workspacePrefix: agentStoreKeys.userWorkspacePrefix(this.project.name),
         label: "user store",
       };
     }
@@ -2232,13 +2334,14 @@ 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 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
-        // told to "use <server tool>" calls MCP instead of inventing a .sh.
+        // including agent tool script bodies. Authored skills and workspace
+        // seeds land on the store mount (skills for native discovery, seeds
+        // for the model's file tools), and on hosted deployments 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 told
+        // to "use <server tool>" calls MCP instead of inventing a .sh.
         const preamble = buildAgentsMdContent(agent, {
           includeScripts: true,
           serverToolsMcpName:
@@ -2247,17 +2350,30 @@ export class SessionEngine {
               : SERVER_TOOLS_MCP_SERVER_NAME,
         });
         const hosted = isCursorHostedFilesAvailable();
-        // Synced whenever a store is reachable, 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 || isCursorUserStoreFilesAvailable()) {
-          await this.ensureCloudSkillsSynced();
+        // Synced whenever a store is reachable, not just when skills or
+        // seeds exist: removing the last one has to delete its store copies
+        // too.
+        const store =
+          hosted || isCursorUserStoreFilesAvailable()
+            ? this.cloudStore()
+            : undefined;
+        let sections = "";
+        if (store !== undefined) {
+          const [, seedsSynced] = await Promise.all([
+            this.ensureCloudSkillsSynced(store),
+            this.ensureCloudWorkspaceSynced(store),
+          ]);
+          // Only name the mount when the bytes landed; a failed sync must
+          // not send the model looking for files that are not there.
+          if (seedsSynced && agent.seedFiles.length > 0) {
+            const dir = `${store.mountPath}/${store.workspacePrefix}`;
+            sections += `\n\n${buildCloudWorkspaceSection(dir)}`;
+          }
+        }
+        if (hosted) {
+          sections += `\n\n${buildCloudMemorySection(this.project.name)}`;
         }
-        const memorySection = hosted
-          ? `\n\n${buildCloudMemorySection(this.project.name)}`
-          : "";
-        turnPrompt = `${preamble}${memorySection}\n\n${turnPrompt}`;
+        turnPrompt = `${preamble}${sections}\n\n${turnPrompt}`;
       } else if (runtime === "local" && instructionsInvisibleToHarness) {
         // Local workspace whose AGENTS.md the harness will not load. With a
         // borrowed harness cwd, agent tool scripts live only in the durable
@@ -2747,6 +2863,7 @@ export class SessionEngine {
         this.getChannelSession(channelId, sessionId),
       emit: args.emit,
       now: sessionClock(args.record.asOf),
+      ...(args.record.asOf === undefined ? {} : { asOf: args.record.asOf }),
     };
     try {
       // Before the approval gate: a dry run is unattended, so parking a write
@@ -2815,15 +2932,24 @@ export class SessionEngine {
       }
       const started = Date.now();
       this.logger(`[session] tool ${args.tool.name} start`);
-      const result = await mcpAuthAls.run(
+      const result = await this.runToolExecute(
         {
-          sessionId: args.record.sessionId,
+          record: args.record,
           turnId: args.turnId,
           callId: toolCallId,
           toolName: args.tool.name,
-          emit: args.emit,
         },
-        () => execute(validation.value as never, toolCtx)
+        () =>
+          mcpAuthAls.run(
+            {
+              sessionId: args.record.sessionId,
+              turnId: args.turnId,
+              callId: toolCallId,
+              toolName: args.tool.name,
+              emit: args.emit,
+            },
+            () => execute(validation.value as never, toolCtx)
+          )
       );
       this.logger(
         `[session] tool ${args.tool.name} done (${Date.now() - started}ms)`
@@ -2839,6 +2965,61 @@ export class SessionEngine {
     }
   }
 
+  /**
+   * Bind outbound inject (Factory / Cursor API `traceparent`) to the
+   * turn span for the whole harness run. Host files / VFS RPCs happen
+   * here, not under `runInCall`. No-op when OTel is off.
+   */
+  private runTurnExecute<T>(
+    record: SessionRecord,
+    turnId: string,
+    fn: () => T | Promise<T>
+  ): Promise<T> {
+    const otel = this.otel;
+    const run = (): Promise<T> => Promise.resolve(fn());
+    if (otel === undefined) {
+      return run();
+    }
+    return otel.runInTurn(
+      {
+        sessionId: record.sessionId,
+        session: this.sessionInfo(record),
+        turnId,
+      },
+      run
+    );
+  }
+
+  /**
+   * Bind outbound inject (Factory / Cursor API `traceparent`) to the
+   * tool span. No-op when OTel is off.
+   */
+  private runToolExecute<T>(
+    args: {
+      record: SessionRecord;
+      turnId: string;
+      callId: string;
+      toolName: string;
+    },
+    fn: () => T | Promise<T>
+  ): Promise<T> {
+    const otel = this.otel;
+    const run = (): Promise<T> => Promise.resolve(fn());
+    if (otel === undefined) {
+      return run();
+    }
+    return otel.runInCall(
+      {
+        sessionId: args.record.sessionId,
+        session: this.sessionInfo(args.record),
+        turnId: args.turnId,
+        callId: args.callId,
+        toolName: args.toolName,
+      },
+      run
+    );
+  }
+
   /**
    * Park a server-tool call until a human approves or denies. Emits
    * `action.approval_requested` / `action.approval_resolved` on the
@@ -3712,20 +3893,34 @@ export class SessionEngine {
               this.getChannelSession(channelId, sessionId),
             emit,
             now: sessionClock(record?.asOf),
+            ...(record?.asOf === undefined ? {} : { asOf: record.asOf }),
           });
-        result = normalizeToolResult(
+        const executeBody =
           record !== undefined && emit !== undefined
-            ? await mcpAuthAls.run(
+            ? () =>
+                mcpAuthAls.run(
+                  {
+                    sessionId: record.sessionId,
+                    turnId: callId,
+                    callId,
+                    toolName,
+                    emit,
+                  },
+                  run
+                )
+            : run;
+        result = normalizeToolResult(
+          record !== undefined
+            ? await this.runToolExecute(
                 {
-                  sessionId: record.sessionId,
+                  record,
                   turnId: callId,
                   callId,
                   toolName,
-                  emit,
                 },
-                run
+                executeBody
               )
-            : await run()
+            : await executeBody()
         );
         isError = isErrorEnvelope(result);
       }
@@ -3926,7 +4121,10 @@ export class SessionEngine {
       return;
     }
 
-    const sessionCtx = { session: this.sessionInfo(record) };
+    const sessionCtx: SessionContext = {
+      session: this.sessionInfo(record),
+      host: this.hostForSession(record.sessionId),
+    };
     const channelEvents = this.channelEventHandlersFor(record.channelId);
     if (channelEvents !== undefined) {
       // Handlers are declared against the narrowed event for their key; the
@@ -3969,14 +4167,13 @@ export class SessionEngine {
         }
         try {
           await handler(event, {
+            ...sessionCtx,
             agent: { name: this.project.name },
             channel: {
               id: record.channelId,
               continuationToken: record.continuationKey,
             },
-            session: this.sessionInfo(record),
             stateRoot: this.stateRoot,
-            host: this.hostForSession(record.sessionId),
             artifacts: this.artifactsApi({
               sessionId: record.sessionId,
               turnId: event.turnId,
@@ -3993,12 +4190,12 @@ export class SessionEngine {
     if (this.abCollector.enabled) {
       await this.abCollector.onEvent(
         event,
-        this.sessionInfo(record),
+        sessionCtx.session,
         this.project.name
       );
     }
 
-    this.otel?.onEvent(event, this.sessionInfo(record));
+    this.otel?.onEvent(event, sessionCtx.session);
   }
 
   private channelEventHandlersFor(
@@ -5106,10 +5303,6 @@ function buildRunnerSubagents(agent: ResolvedAgent): RunnerSubagent[] {
   }));
 }
 
-function describeError(error: unknown): string {
-  return error instanceof Error ? error.message : String(error);
-}
-
 function toolErrorResult(message: string): SDKCustomToolResult {
   return {
     content: [{ type: "text", text: message }],

package/src/internal/session-run-log.ts

@@ -15,21 +15,20 @@
  * persist so a store outage never changes the hosted-execution HTTP reply.
  *
  * Same flush moments as `hosted-execution.json` and the start.log tee —
- * see `hosted-execution-flush.ts`. Keys: {@link storageKeys.sessionRun}.
+ * see `hosted-execution-flush.ts`. Keys:
+ * {@link agentSdkStorageKeys.sessionRun}.
  */
 
 import type { FileSink } from "../files.js";
-import {
-  cursorFrameworkStoreSourceId,
-  cursorHostedFiles,
-} from "../files-backends/cursor-hosted.js";
-import { storageKeys } from "../storage-protocol.js";
+import { cursorHostedFiles } from "../files-backends/cursor-hosted.js";
+import { agentSdkStorageKeys } from "../storage-protocol.js";
 import type { AgentProject } from "../types.js";
 import { resolveApiKeySync } from "./cursor/credentials.js";
-import { AGENT_SERVE_GENERATION_ENV_VAR } from "./cursor-relay-core.js";
 import { describeError } from "./describe-error.js";
 import type { HostedExecutionDiagAbortReason } from "./hosted-execution-diag.js";
+import { isRecord } from "./is-record.js";
 import type { LogRingEntry } from "./log-ring.js";
+import { resolveAgentV2Hosting } from "./v2-hosting.js";
 
 export const SESSION_RUN_LOG_VERSION = 1;
 /** Last N log-ring lines kept on each execution. */
@@ -195,10 +194,6 @@ export function snapshotSessionRunLogs(
   }));
 }
 
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
 function decodeSinkBody(body: Uint8Array | { body: Uint8Array }): Uint8Array {
   return body instanceof Uint8Array ? body : body.body;
 }
@@ -442,7 +437,7 @@ export function createSessionRunLogStore(input: {
   const readDocument = async (
     sessionPublicId: string
   ): Promise<SessionRunLogDocument | undefined> => {
-    const key = storageKeys.sessionRun(agentName, sessionPublicId);
+    const key = agentSdkStorageKeys.sessionRun(agentName, sessionPublicId);
     const body = await sink.get(key);
     if (body === undefined) {
       return undefined;
@@ -479,7 +474,10 @@ export function createSessionRunLogStore(input: {
       updatedAt: fitted.writtenAt,
       executions,
     });
-    const key = storageKeys.sessionRun(agentName, document.sessionPublicId);
+    const key = agentSdkStorageKeys.sessionRun(
+      agentName,
+      document.sessionPublicId
+    );
     try {
       await sink.put(key, new TextEncoder().encode(JSON.stringify(document)));
     } catch (error) {
@@ -558,17 +556,17 @@ export function selectSessionRunLogStore(input: {
   env?: Record<string, string | undefined>;
   snapshotLogs?: () => readonly LogRingEntry[];
 }): SessionRunLogStore | undefined {
-  if (input.project.agent.architecture !== "v2") {
-    return undefined;
-  }
-  const env = input.env ?? process.env;
-  if (env[AGENT_SERVE_GENERATION_ENV_VAR] === undefined) {
+  const hosting = resolveAgentV2Hosting({
+    architecture: input.project.agent.architecture,
+    env: input.env as NodeJS.ProcessEnv | undefined,
+  });
+  if (hosting.kind !== "cursor-managed") {
     return undefined;
   }
-  const envSnapshot = env as NodeJS.ProcessEnv;
   return createSessionRunLogStore({
     sink: cursorHostedFiles({
-      resolveStoreSourceId: () => cursorFrameworkStoreSourceId(envSnapshot),
+      resolveStoreSourceId: () =>
+        hosting.resolveStoreIds().frameworkStoreSourceId,
       resolveApiKey: () => resolveApiKeySync()?.apiKey,
     }),
     agentName: input.project.name,