@stigmer/runner 3.15.2 → 3.15.3-dev.20260914121148

package/src/activities/execute-cursor/__test-utils__/__tests__/scripted-double.test.ts

@@ -9,17 +9,20 @@
  *  - `nextRunId` names the run the next send will be given, so a script can be
  *    built with matching event ids before the send happens.
  *  - `agentForWorkspaceRef` hands `Agent.create` the agent declared for the
- *    session the create names (via `platform.workspaceRef`), consulted before
- *    the ordered list and registered for `Agent.resume` by id; a create with no
- *    session, or a session the resolver does not know, falls through to the
- *    list as before.
+ *    session the create names (via the `workspaceRef` of the scripted store it
+ *    passes as `local.store`), consulted before the ordered list and
+ *    registered for `Agent.resume` by id; a create with no store, or a session
+ *    the resolver does not know, falls through to the list as before.
+ *  - `ScriptedLocalAgentStore.open` (the `@cursor/sdk/sqlite` double) records
+ *    every open and dispose on the bound SDK, so a scenario can assert the
+ *    adapter's session-store lifetime.
  */
 
 import { describe, it, expect } from "vitest";
 import type { AgentOptions, SDKMessage } from "@cursor/sdk";
 
 import { ScriptedCursorAgent, defaultRunId, sdkEvents, step } from "../scripted-agent.js";
-import { ScriptedCursorSdk } from "../scripted-sdk.js";
+import { ScriptedCursorSdk, ScriptedLocalAgentStore, bindScriptedSdk } from "../scripted-sdk.js";
 
 /** An agent whose declared turns each play the given events and finish. */
 function agent(id: string, turns: SDKMessage[][] = []): ScriptedCursorAgent {
@@ -76,8 +79,14 @@ describe("ScriptedCursorAgent.nextRunId", () => {
 });
 
 describe("ScriptedCursorSdk.agentForWorkspaceRef", () => {
+  // The scripted store carries only the members the runner touches, not the
+  // SDK's whole `LocalAgentStore`, hence the cast — the same one the mocked
+  // module makes when it stands in for `@cursor/sdk/sqlite`.
   const createFor = (workspaceRef: string | undefined): AgentOptions =>
-    ({ apiKey: "k", ...(workspaceRef !== undefined ? { platform: { workspaceRef, stateRoot: "/tmp/x" } } : {}) }) as unknown as AgentOptions;
+    ({
+      apiKey: "k",
+      local: workspaceRef !== undefined ? { store: new ScriptedLocalAgentStore(workspaceRef, "/tmp/x") } : undefined,
+    }) as unknown as AgentOptions;
 
   it("hands out the session's agent before the ordered list and registers it for resume", () => {
     const forSession = agent("session-agent");
@@ -94,9 +103,24 @@ describe("ScriptedCursorSdk.agentForWorkspaceRef", () => {
     expect(sdk.resolutions.map((r) => `${r.kind}:${r.agentId}`)).toEqual(["create:session-agent", "resume:session-agent", "create:listed-agent"]);
   });
 
-  it("a create without a platform ref falls through to the ordered list", () => {
+  it("a create without a store falls through to the ordered list", () => {
     const listed = agent("listed-only");
     const sdk = new ScriptedCursorSdk({ agents: [listed], catalog: [], agentForWorkspaceRef: () => agent("never") });
     expect(sdk.create(createFor(undefined))).toBe(listed);
   });
 });
+
+describe("ScriptedLocalAgentStore (the @cursor/sdk/sqlite double)", () => {
+  it("open hands out a store carrying the ref and root asked for, and records opens and disposes on the bound SDK", async () => {
+    const sdk = new ScriptedCursorSdk({ agents: [], catalog: [] });
+    bindScriptedSdk(sdk);
+
+    const store = await ScriptedLocalAgentStore.open({ workspaceRef: "stigmer-session:ses-9", stateRoot: "/tmp/ses-9" });
+    expect(store.workspaceRef).toBe("stigmer-session:ses-9");
+    expect(store.stateRoot).toBe("/tmp/ses-9");
+    expect(sdk.stores).toEqual([store]);
+
+    await store.dispose();
+    expect(store.disposeCalls).toBe(1);
+  });
+});

package/src/activities/execute-cursor/__test-utils__/contract-subject.ts

@@ -95,7 +95,7 @@ import type {
 } from "../../../__test-utils__/harness-contract/types.js";
 import type { HermeticEnvironment } from "../../../__test-utils__/hermetic-activity.js";
 import { createCursorAdapter } from "../adapter.js";
-import { resolvePlatformOptions } from "../session-lifecycle.js";
+import { resolveSessionStoreLocation } from "../session-store.js";
 import { hookInputFor, streamArgsFor, STREAM_NAME, type GatedActionKind } from "./cursor-hook-harness.js";
 import { FIXTURE, SDK_CATALOG, hermeticCursorConfig, runWorkspaceHook } from "./hermetic-cursor.js";
 import { ScriptedCursorAgent, sdkEvents, step, type ScriptStep, type ScriptedRun } from "./scripted-agent.js";
@@ -216,9 +216,9 @@ class CursorSubject implements CursorContractSubject {
   private mintAgent(sessionId: string): ScriptedCursorAgent {
     const agent = new ScriptedCursorAgent({ agentId: `agent-kit-${++this.mintCounter}`, turns: [] });
     this.agents.set(sessionId, agent);
-    // The adapter asks the SDK to create an agent for the session under this
-    // ref; the double answers with this agent.
-    const { workspaceRef } = resolvePlatformOptions(sessionId, this.config.workspaceRootDir);
+    // The adapter asks the SDK to create an agent for the session over a store
+    // opened under this ref; the double answers with this agent.
+    const { workspaceRef } = resolveSessionStoreLocation(sessionId, this.config.workspaceRootDir);
     this.agentsByWorkspaceRef.set(workspaceRef, agent);
     return agent;
   }
@@ -248,11 +248,13 @@ class CursorSubject implements CursorContractSubject {
           break;
         case "usage":
           script.push(
+            // The kit's delta leaves a count optional; the SDK's `turn-ended`
+            // states all four, and an absent count is zero, as the pricer reads it.
             step.turnEnded({
-              inputTokens: s.delta.inputTokens,
-              outputTokens: s.delta.outputTokens,
-              cacheReadTokens: s.delta.cacheReadTokens,
-              cacheWriteTokens: s.delta.cacheWriteTokens,
+              inputTokens: s.delta.inputTokens ?? 0,
+              outputTokens: s.delta.outputTokens ?? 0,
+              cacheReadTokens: s.delta.cacheReadTokens ?? 0,
+              cacheWriteTokens: s.delta.cacheWriteTokens ?? 0,
             }),
           );
           break;

package/src/activities/execute-cursor/__test-utils__/hermetic-cursor.ts

@@ -11,12 +11,15 @@
  * registry the harness reads at setup, the Cursor `Config` slice, and the
  * per-scenario reset of the harness's module-level caches.
  *
- * What the two `vi.mock` calls a scenario file must carry look like — they are
- * hoisted by vitest and so cannot live here:
+ * What the three `vi.mock` calls a scenario file must carry look like — they
+ * are hoisted by vitest and so cannot live here (the SDK's sqlite entry is a
+ * separate module id, so it is doubled separately; `scripted-sdk.ts`):
  *
  * ```ts
  * vi.mock("@cursor/sdk", async () =>
  *   (await import("../../__test-utils__/scripted-sdk.js")).scriptedCursorSdkModule());
+ * vi.mock("@cursor/sdk/sqlite", async () =>
+ *   (await import("../../__test-utils__/scripted-sdk.js")).scriptedCursorSqliteModule());
  * vi.mock("../../../../client/stigmer-client.js", async () =>
  *   (await import("../../../../__test-utils__/hermetic-activity.js")).hermeticStigmerClientModule());
  * ```

package/src/activities/execute-cursor/__test-utils__/scripted-agent.ts

@@ -24,16 +24,12 @@
  * The same shape as the native harness's `__test-utils__/scripted-model.ts`
  * (`ScriptStep`, driven in order), applied to the SDK's event surface.
  *
- * Typing: `SDKMessage`, `Run`, `RunResult` and `SDKAgent` are the SDK's own
- * types (`@cursor/sdk` 1.0.13, concrete in `messages.d.ts` / `run.d.ts` /
- * `agent.d.ts`), so a script that drifts from the real event shape fails
- * `tsc`. The delta channel is the exception: `InteractionUpdate` re-exports
- * from `@anysphere/cursor-sdk-shared`, a workspace package the published SDK
- * does not ship, so under `skipLibCheck` it resolves to `any` — in production
- * code too (`turn-stream.ts`, `delta-enricher.ts` read it untyped). The one
- * delta this double emits, the `turn-ended` usage, is therefore typed HERE
- * ({@link TurnEndedUsageDelta}) against what `turn-stream.ts` reads from it,
- * and that gap is recorded in the entry's findings rather than papered over.
+ * Typing: `SDKMessage`, `Run`, `RunResult`, `SDKAgent` and the delta channel's
+ * `TurnEndedUpdate` are the SDK's own types (`@cursor/sdk` 1.0.31, concrete in
+ * `messages.d.ts` / `run.d.ts` / `agent.d.ts` / the vendored `delta-types`),
+ * so a script that drifts from the real event shape fails `tsc`. (At 1.0.13
+ * the delta types resolved to `any` and the one delta this double emits was
+ * typed locally; stigmer/stigmer#1053 closed that gap.)
  *
  * Cancellation: `run.cancel()` is how the harness stops a turn (first denial,
  * cost cap, stall). The double honours it the way the SDK does — the stream
@@ -50,6 +46,8 @@
  */
 
 import type {
+  AgentUsage,
+  GetUsageOptions,
   ModelSelection,
   Run,
   RunOperation,
@@ -59,6 +57,7 @@ import type {
   SDKMessage,
   SDKUserMessage,
   SendOptions,
+  TurnEndedUpdate,
 } from "@cursor/sdk";
 import type { ConversationTurn } from "@cursor/sdk";
 
@@ -66,21 +65,6 @@ import type { ConversationTurn } from "@cursor/sdk";
 // Script steps
 // ---------------------------------------------------------------------------
 
-/**
- * The `turn-ended` delta as `turn-stream.ts` reads it (`update.type ===
- * "turn-ended" && update.usage` -> `usageAccumulator.addTurn(update.usage)`).
- * See the module header for why this is typed locally.
- */
-export interface TurnEndedUsageDelta {
-  readonly type: "turn-ended";
-  readonly usage: {
-    readonly inputTokens?: number;
-    readonly outputTokens?: number;
-    readonly cacheWriteTokens?: number;
-    readonly cacheReadTokens?: number;
-  };
-}
-
 /** What an `effect` step can reach: the run it is part of. */
 export interface EffectContext {
   readonly run: ScriptedRun;
@@ -89,7 +73,7 @@ export interface EffectContext {
 
 export type ScriptStep =
   | { readonly kind: "event"; readonly event: SDKMessage }
-  | { readonly kind: "delta"; readonly update: TurnEndedUsageDelta }
+  | { readonly kind: "delta"; readonly update: TurnEndedUpdate }
   | { readonly kind: "effect"; readonly label: string; readonly run: (ctx: EffectContext) => void | Promise<void> }
   | { readonly kind: "result"; readonly result: Omit<RunResult, "id"> };
 
@@ -101,7 +85,8 @@ export const step = {
   event(event: SDKMessage): ScriptStep {
     return { kind: "event", event };
   },
-  turnEnded(usage: TurnEndedUsageDelta["usage"]): ScriptStep {
+  /** The `turn-ended` delta `turn-stream.ts` prices; the SDK's shape, all four counts stated. */
+  turnEnded(usage: NonNullable<TurnEndedUpdate["usage"]>): ScriptStep {
     return { kind: "delta", update: { type: "turn-ended", usage } };
   },
   effect(label: string, run: (ctx: EffectContext) => void | Promise<void>): ScriptStep {
@@ -224,7 +209,7 @@ export class ScriptedRun implements Run {
           yield s.event;
           break;
         case "delta":
-          await this.onDelta?.({ update: s.update as never });
+          await this.onDelta?.({ update: s.update });
           break;
         case "effect":
           await s.run({ run: this, agent: this.agent });
@@ -365,4 +350,11 @@ export class ScriptedCursorAgent implements SDKAgent {
   async downloadArtifact(_path: string): Promise<Buffer> {
     throw new Error("ScriptedCursorAgent: artifacts are not part of the scripted surface");
   }
+
+  async getUsage(_options?: GetUsageOptions): Promise<AgentUsage> {
+    // The harness prices the `turn-ended` delta itself (`usage-pricing.ts`) and
+    // never asks the SDK for billed usage; a call here is a test bug, like a
+    // `send()` with no script.
+    throw new Error("ScriptedCursorAgent: getUsage() is not part of the scripted surface");
+  }
 }

package/src/activities/execute-cursor/__test-utils__/scripted-sdk.ts

@@ -1,11 +1,16 @@
 /**
  * The `@cursor/sdk` module a hermetic `ExecuteCursor` run imports — every
- * runtime surface the activity path touches, backed by scripted agents.
+ * runtime surface the activity path touches, backed by scripted agents — and
+ * the `@cursor/sdk/sqlite` module beside it, backed by a store that holds
+ * nothing.
  *
- * The activity reaches the SDK at three runtime sites and nowhere else:
+ * The activity reaches the SDK at four runtime sites and nowhere else:
  *
- *  - `session-lifecycle.ts`: `Agent.create(options)`, `Agent.resume(id, options)`,
- *    `Agent.archive(id, ...)` — the agent handle.
+ *  - `session-lifecycle.ts`: `Agent.create(options)`, `Agent.resume(id, options)`
+ *    — the agent handle.
+ *  - `session-store.ts`: `SqliteLocalAgentStore.open({ workspaceRef, stateRoot })`
+ *    from `@cursor/sdk/sqlite` — the session's store the handle is created and
+ *    resumed over (`local.store`).
  *  - `service-tier.ts`: `Cursor.models.list({ apiKey })` — the catalog the
  *    variant params (`fast`, `thinking`) are pinned from.
  *  - `index.ts` outer catch: `import("@cursor/sdk")` for `CursorSdkError`, the
@@ -13,35 +18,42 @@
  *
  * Neither the SDK nor the client is injectable into the activity (the real
  * seam arrives with the harness contract; parent Q1/Q2), so — exactly as the
- * native activity tests already do for their boundary modules — the module is
- * substituted with `vi.mock`. Three existing tests each mock ONE of these
+ * native activity tests already do for their boundary modules — the modules
+ * are substituted with `vi.mock`. Three existing tests each mock ONE of these
  * surfaces (`session-lifecycle.test.ts`, `service-tier.test.ts`,
- * `sdk-warmup.test.ts`); a whole-activity run needs all three at once, which is
- * what this module is.
+ * `sdk-warmup.test.ts`); a whole-activity run needs all of them at once, which
+ * is what this module is.
  *
- * `vi.mock` is hoisted and must appear in the test file; the factory can
- * `await import()` this module and return {@link scriptedCursorSdkModule}. The
- * module's statics read the {@link ScriptedCursorSdk} bound for the current
+ * `vi.mock` is hoisted and must appear in the test file, once per module id
+ * (a subpath is its own module id, so `@cursor/sdk/sqlite` needs its own
+ * `vi.mock`); the factories `await import()` this module and return
+ * {@link scriptedCursorSdkModule} and {@link scriptedCursorSqliteModule}. The
+ * modules' statics read the {@link ScriptedCursorSdk} bound for the current
  * scenario ({@link bindScriptedSdk}), so one test file can run several
- * scenarios with different agents against the same mocked module.
+ * scenarios with different agents against the same mocked modules.
  *
  * Resolution rules a scenario declares, mirroring what the real SDK does:
  *  - `Agent.create` hands out the agent declared for the session it is asked
- *    for (`agentForSession`, when the scenario resolves agents per session —
- *    the harness contract kit runs several sessions concurrently on one
- *    adapter, and the order their creates arrive in is real I/O timing), else
- *    the NEXT unclaimed agent in `agents` (turn 1 of a fresh session; the fresh
- *    agent of a poisoned-handle recovery) — unless the scenario declared a
- *    `createFailure`, which the FIRST create throws instead (the SDK refusing
+ *    for (`agentForWorkspaceRef`, when the scenario resolves agents per
+ *    session — the harness contract kit runs several sessions concurrently on
+ *    one adapter, and the order their creates arrive in is real I/O timing),
+ *    else the NEXT unclaimed agent in `agents` (turn 1 of a fresh session; the
+ *    fresh agent of a poisoned-handle recovery) — unless the scenario declared
+ *    a `createFailure`, which the FIRST create throws instead (the SDK refusing
  *    to mint an agent: a 401 on the key, a validation error).
  *  - `Agent.resume(id)` hands back the agent with that id if the scenario
  *    declared it (in `agents` or `resumableAgents`, or handed out for a
  *    session), else throws — `resolveAgent` then falls back to `create`, which
  *    is the production shape of a lost handle.
  *  - `Cursor.models.list` answers the scenario's catalog.
+ *  - `SqliteLocalAgentStore.open` hands out a {@link ScriptedLocalAgentStore}
+ *    carrying the ref and root it was asked for, and records the open; its
+ *    `dispose()` is recorded too, so a scenario can assert the adapter's
+ *    session-store lifetime (`releaseSession`, `shutdown`).
  */
 
 import type { AgentOptions, ModelListItem, SDKAgent } from "@cursor/sdk";
+import type { SqliteLocalAgentStore, SqliteLocalAgentStoreOptions } from "@cursor/sdk/sqlite";
 import type { ScriptedCursorAgent } from "./scripted-agent.js";
 
 export interface ScriptedSdkOptions {
@@ -50,12 +62,12 @@ export interface ScriptedSdkOptions {
   /**
    * The agent `Agent.create` hands out for the session the create names,
    * consulted before the ordered list. The SDK's create options carry the
-   * session as `platform.workspaceRef` (`session-lifecycle.ts`
-   * `resolvePlatformOptions`: `stigmer-session:<sessionId>`), so the resolver
-   * is keyed by that ref — a scenario computes the ref the same way the
-   * adapter does. `undefined` falls through to the list. Consulted live on
-   * every create, so a scenario may mint the session's agent only when it
-   * learns of the session.
+   * session as the store's `workspaceRef` (`local.store`, opened by
+   * `session-store.ts`: `stigmer-session:<sessionId>`), so the resolver is
+   * keyed by that ref — a scenario computes the ref the same way the adapter
+   * does (`resolveSessionStoreLocation`). `undefined` falls through to the
+   * list. Consulted live on every create, so a scenario may mint the session's
+   * agent only when it learns of the session.
    */
   readonly agentForWorkspaceRef?: (workspaceRef: string) => ScriptedCursorAgent | undefined;
   /**
@@ -82,21 +94,46 @@ export interface RecordedResolution {
 }
 
 /**
- * The `platform.workspaceRef` a create names, read defensively: the platform
- * option's type re-exports from the unshipped `@anysphere/cursor-sdk-local-runtime`
- * and resolves to `any` under `skipLibCheck` (the same gap `scripted-agent.ts`
- * records for the delta channel), so the shape is checked here, not assumed.
+ * The session a create names: the `workspaceRef` of the store it passes as
+ * `local.store`. In a hermetic run that store is the one this module's sqlite
+ * double opened; anything else (a test that mocks `@cursor/sdk` with its own
+ * stub and passes no store) names no session and falls through to the list.
  */
 function workspaceRefOf(options: AgentOptions): string | undefined {
-  const platform: unknown = (options as { platform?: unknown }).platform;
-  if (typeof platform !== "object" || platform === null) return undefined;
-  const ref = (platform as { workspaceRef?: unknown }).workspaceRef;
-  return typeof ref === "string" ? ref : undefined;
+  const store = options.local?.store;
+  return store instanceof ScriptedLocalAgentStore ? store.workspaceRef : undefined;
+}
+
+/**
+ * The `@cursor/sdk/sqlite` store the adapter opens per session, holding
+ * nothing: the scripted agents carry their own state, so the store only has
+ * to be the thing `Agent.create` / `Agent.resume` are handed and the thing
+ * `releaseSession` / `shutdown` dispose. `open` and `dispose` are recorded on
+ * the bound {@link ScriptedCursorSdk} for lifetime assertions.
+ */
+export class ScriptedLocalAgentStore {
+  disposeCalls = 0;
+
+  constructor(
+    readonly workspaceRef: string,
+    readonly stateRoot: string,
+  ) {}
+
+  static async open(options: SqliteLocalAgentStoreOptions): Promise<ScriptedLocalAgentStore> {
+    const store = new ScriptedLocalAgentStore(options.workspaceRef, options.stateRoot ?? "");
+    current().stores.push(store);
+    return store;
+  }
+
+  async dispose(): Promise<void> {
+    this.disposeCalls++;
+  }
 }
 
 export class ScriptedCursorSdk {
   readonly resolutions: RecordedResolution[] = [];
-  readonly archived: string[] = [];
+  /** Every store `SqliteLocalAgentStore.open` handed out, in order. */
+  readonly stores: ScriptedLocalAgentStore[] = [];
   private nextCreate = 0;
   private createFailurePending: boolean;
   private readonly byId = new Map<string, ScriptedCursorAgent>();
@@ -145,10 +182,6 @@ export class ScriptedCursorSdk {
     return agent;
   }
 
-  archive(agentId: string): void {
-    this.archived.push(agentId);
-  }
-
   listModels(): readonly ModelListItem[] {
     return this.options.catalog;
   }
@@ -242,7 +275,6 @@ export function scriptedCursorSdkModule(): Record<string, unknown> {
       create: async (options: AgentOptions): Promise<SDKAgent> => current().create(options),
       resume: async (agentId: string, options?: Partial<AgentOptions>): Promise<SDKAgent> =>
         current().resume(agentId, options),
-      archive: async (agentId: string): Promise<void> => current().archive(agentId),
     },
     Cursor: {
       models: {
@@ -252,3 +284,27 @@ export function scriptedCursorSdkModule(): Record<string, unknown> {
     CursorSdkError: ScriptedCursorSdkError,
   };
 }
+
+/**
+ * The factory a test passes to `vi.mock("@cursor/sdk/sqlite", ...)`, beside
+ * the one above:
+ *
+ * ```ts
+ * vi.mock("@cursor/sdk/sqlite", async () =>
+ *   (await import("../../__test-utils__/scripted-sdk.js")).scriptedCursorSqliteModule(),
+ * );
+ * ```
+ *
+ * The one export the runner reads from that entry (`session-store.ts`). The
+ * class is exported under the SDK's name so `session-store.ts`'s dynamic
+ * import destructures it unchanged; its type is the SDK's, which is why
+ * {@link ScriptedLocalAgentStore} carries `workspaceRef`, `stateRoot` and
+ * `dispose()` — the members the runner touches — and nothing else.
+ */
+export function scriptedCursorSqliteModule(): Record<string, unknown> {
+  return {
+    SqliteLocalAgentStore: ScriptedLocalAgentStore satisfies {
+      open(options: SqliteLocalAgentStoreOptions): Promise<Pick<SqliteLocalAgentStore, "workspaceRef" | "stateRoot" | "dispose">>;
+    },
+  };
+}

package/src/activities/execute-cursor/__tests__/cursor-baseurl-routing.test.ts

@@ -41,14 +41,15 @@ describeWithCursorKey("SDK routing with CURSOR_BACKEND_URL unset", () => {
     mkdirSync(stateRoot, { recursive: true });
 
     const { Agent } = await import("@cursor/sdk");
+    const { SqliteLocalAgentStore } = await import("@cursor/sdk/sqlite");
 
     const agent = await Agent.create({
       apiKey: CURSOR_API_KEY,
       model: { id: "claude-sonnet-4" },
-      local: { cwd: stateRoot },
-      platform: {
-        workspaceRef: `routing-test-${Date.now()}`,
-        stateRoot,
+      local: {
+        cwd: stateRoot,
+        // 1.0.31: the store is caller-owned (`session-store.ts` in production).
+        store: await SqliteLocalAgentStore.open({ workspaceRef: `routing-test-${Date.now()}`, stateRoot }),
       },
     });
 
@@ -62,14 +63,15 @@ describeWithCursorKey("SDK routing with CURSOR_BACKEND_URL unset", () => {
     mkdirSync(stateRoot, { recursive: true });
 
     const { Agent } = await import("@cursor/sdk");
+    const { SqliteLocalAgentStore } = await import("@cursor/sdk/sqlite");
 
     const agent = await Agent.create({
       apiKey: CURSOR_API_KEY,
       model: { id: "claude-sonnet-4" },
-      local: { cwd: stateRoot },
-      platform: {
-        workspaceRef: `routing-send-test-${Date.now()}`,
-        stateRoot,
+      local: {
+        cwd: stateRoot,
+        // 1.0.31: the store is caller-owned (`session-store.ts` in production).
+        store: await SqliteLocalAgentStore.open({ workspaceRef: `routing-send-test-${Date.now()}`, stateRoot }),
       },
     });
 

package/src/activities/execute-cursor/__tests__/cursor-fetch-interceptor-bypass.test.ts

@@ -41,16 +41,17 @@ describeWithCursorKey("Fetch Interceptor vs Connect-Node Transport", () => {
 
   it("Agent.create() does NOT go through globalThis.fetch (proving interceptor is useless)", async () => {
     const { Agent } = await import("@cursor/sdk");
+    const { SqliteLocalAgentStore } = await import("@cursor/sdk/sqlite");
 
     const stateRoot = join(tmpdir(), `cursor-intercept-test-${Date.now()}`);
     mkdirSync(stateRoot, { recursive: true });
 
     const agent = await Agent.create({
       apiKey: CURSOR_API_KEY,
-      local: { cwd: stateRoot },
-      platform: {
-        workspaceRef: `intercept-test-${Date.now()}`,
-        stateRoot,
+      local: {
+        cwd: stateRoot,
+        // 1.0.31: the store is caller-owned (`session-store.ts` in production).
+        store: await SqliteLocalAgentStore.open({ workspaceRef: `intercept-test-${Date.now()}`, stateRoot }),
       },
     });
 

package/src/activities/execute-cursor/__tests__/cursor-generate-image-live.test.ts

@@ -35,6 +35,7 @@
  */
 
 import { describe, it, expect } from "vitest";
+import { SqliteLocalAgentStore } from "@cursor/sdk/sqlite";
 import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, existsSync, chmodSync, readdirSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -87,8 +88,12 @@ describeWithCursorKey("generateImage live ground truth (issue #965)", () => {
     const agent = await Agent.create({
       apiKey: CURSOR_API_KEY,
       model: { id: "composer-2.5" },
-      local: { cwd: workspaceRoot, settingSources: ["project"] },
-      platform: { workspaceRef: `genimage-spike-${Date.now()}`, stateRoot },
+      local: {
+        cwd: workspaceRoot,
+        settingSources: ["project"],
+        // 1.0.31: the store is caller-owned (`session-store.ts` in production).
+        store: await SqliteLocalAgentStore.open({ workspaceRef: `genimage-spike-${Date.now()}`, stateRoot }),
+      },
     });
 
     // The runner's exact consumption shape (index.ts / turn-stream.ts):