@stigmer/runner 3.15.2 → 3.15.3-dev.20260914121148

package/src/activities/execute-cursor/__tests__/session-store.test.ts

@@ -0,0 +1,220 @@
+/**
+ * Unit tests for `session-store.ts`: where a session's Cursor SDK store lives,
+ * and the lifetime the runner owns for it (stigmer/stigmer#1053).
+ *
+ * The location rules are correctness-critical: the state root is keyed by
+ * sessionId and rooted at the durable workspace volume so native
+ * Agent.resume() survives restart/snapshot-restore and so sessions that share
+ * one volume (a workflow sandbox's child agent executions) never collide.
+ *
+ * The lifetime rules are what a revert of the adapter's release hooks would
+ * break: one open per session however many activities ask, the SAME instance
+ * on every ask, a release that disposes and forgets so the next ask reopens, a
+ * failed open that is not remembered, and a re-acquire under a different root
+ * that releases the store it held. `SessionStores` takes the opener, so these
+ * run against a recording fake and no SQLite file.
+ */
+
+import { describe, it, expect, afterEach } from "vitest";
+import { mkdtempSync, rmSync, existsSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { SessionStores, resolveSessionStoreLocation, type ReleasableStore, type SessionStoreLocation } from "../session-store.js";
+
+const tempRoots: string[] = [];
+
+function freshWorkspaceRoot(): string {
+  const dir = mkdtempSync(join(tmpdir(), "stigmer-session-store-test-"));
+  tempRoots.push(dir);
+  return dir;
+}
+
+afterEach(() => {
+  for (const dir of tempRoots.splice(0)) {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+describe("resolveSessionStoreLocation", () => {
+  it("derives the state root under the workspace volume (not $HOME), created eagerly", () => {
+    const workspaceRootDir = freshWorkspaceRoot();
+    const location = resolveSessionStoreLocation("ses-123", workspaceRootDir);
+
+    expect(location.stateRoot).toBe(join(workspaceRootDir, ".stigmer", "cursor-sdk-state", "ses-123"));
+    expect(location.stateRoot.startsWith(workspaceRootDir)).toBe(true);
+    // Created eagerly to prevent ENOENT on the SDK's first write.
+    expect(existsSync(location.stateRoot)).toBe(true);
+    expect(location.workspaceRef).toBe("stigmer-session:ses-123");
+  });
+
+  it("isolates two sessions sharing one workspace volume into distinct stores", () => {
+    const workspaceRootDir = freshWorkspaceRoot();
+    const a = resolveSessionStoreLocation("ses-aaa", workspaceRootDir);
+    const b = resolveSessionStoreLocation("ses-bbb", workspaceRootDir);
+
+    expect(a.stateRoot).not.toBe(b.stateRoot);
+    expect(a.workspaceRef).not.toBe(b.workspaceRef);
+    expect(a.stateRoot.startsWith(join(workspaceRootDir, ".stigmer"))).toBe(true);
+    expect(b.stateRoot.startsWith(join(workspaceRootDir, ".stigmer"))).toBe(true);
+  });
+
+  it("throws on an empty sessionId (would collide across sessions on a shared volume)", () => {
+    const workspaceRootDir = freshWorkspaceRoot();
+    expect(() => resolveSessionStoreLocation("", workspaceRootDir)).toThrow(/sessionId is required/);
+  });
+
+  it("throws on an empty workspaceRootDir (state must live on the durable volume)", () => {
+    expect(() => resolveSessionStoreLocation("ses-123", "")).toThrow(/workspaceRootDir is required/);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// The lifetime
+// ---------------------------------------------------------------------------
+
+class FakeStore implements ReleasableStore {
+  disposeCalls = 0;
+  constructor(readonly location: SessionStoreLocation) {}
+  get stateRoot(): string {
+    return this.location.stateRoot;
+  }
+  async dispose(): Promise<void> {
+    this.disposeCalls++;
+  }
+}
+
+/** A recording opener; `failNext` makes the next open reject once. */
+function recordingOpener() {
+  const opened: FakeStore[] = [];
+  let failNext: Error | undefined;
+  const open = async (location: SessionStoreLocation): Promise<FakeStore> => {
+    if (failNext) {
+      const err = failNext;
+      failNext = undefined;
+      throw err;
+    }
+    const store = new FakeStore(location);
+    opened.push(store);
+    return store;
+  };
+  return { open, opened, fail: (err: Error) => (failNext = err) };
+}
+
+describe("SessionStores", () => {
+  it("opens once per session and hands the same instance to every later acquire, concurrent ones included", async () => {
+    const workspaceRootDir = freshWorkspaceRoot();
+    const { open, opened } = recordingOpener();
+    const stores = new SessionStores(open);
+
+    // Two activities racing on one session (the agent cache's documented race).
+    const [a, b] = await Promise.all([
+      stores.acquire("ses-1", workspaceRootDir),
+      stores.acquire("ses-1", workspaceRootDir),
+    ]);
+    const c = await stores.acquire("ses-1", workspaceRootDir);
+
+    expect(opened).toHaveLength(1);
+    expect(a).toBe(b);
+    expect(b).toBe(c);
+    expect(a.location.workspaceRef).toBe("stigmer-session:ses-1");
+    expect(stores.size).toBe(1);
+  });
+
+  it("keeps one store per session, not one per process", async () => {
+    const workspaceRootDir = freshWorkspaceRoot();
+    const { open, opened } = recordingOpener();
+    const stores = new SessionStores(open);
+
+    const a = await stores.acquire("ses-a", workspaceRootDir);
+    const b = await stores.acquire("ses-b", workspaceRootDir);
+
+    expect(opened).toHaveLength(2);
+    expect(a).not.toBe(b);
+    expect(stores.size).toBe(2);
+  });
+
+  it("release disposes the session's store and forgets it, so a later acquire reopens", async () => {
+    const workspaceRootDir = freshWorkspaceRoot();
+    const { open, opened } = recordingOpener();
+    const stores = new SessionStores(open);
+
+    const first = await stores.acquire("ses-1", workspaceRootDir);
+    await stores.release("ses-1");
+
+    expect(first.disposeCalls).toBe(1);
+    expect(stores.size).toBe(0);
+
+    const second = await stores.acquire("ses-1", workspaceRootDir);
+    expect(second).not.toBe(first);
+    expect(opened).toHaveLength(2);
+  });
+
+  it("release of a session with no store is a no-op", async () => {
+    const { open, opened } = recordingOpener();
+    const stores = new SessionStores(open);
+
+    await expect(stores.release("ses-unknown")).resolves.toBeUndefined();
+    expect(opened).toHaveLength(0);
+  });
+
+  it("releaseAll disposes every held store and empties the map (worker shutdown)", async () => {
+    const workspaceRootDir = freshWorkspaceRoot();
+    const { open, opened } = recordingOpener();
+    const stores = new SessionStores(open);
+
+    await stores.acquire("ses-a", workspaceRootDir);
+    await stores.acquire("ses-b", workspaceRootDir);
+    await stores.releaseAll();
+
+    expect(opened.map((s) => s.disposeCalls)).toEqual([1, 1]);
+    expect(stores.size).toBe(0);
+  });
+
+  it("does not remember a failed open: the next acquire retries", async () => {
+    const workspaceRootDir = freshWorkspaceRoot();
+    const { open, opened, fail } = recordingOpener();
+    const stores = new SessionStores(open);
+
+    fail(new Error("disk full"));
+    await expect(stores.acquire("ses-1", workspaceRootDir)).rejects.toThrow("disk full");
+    expect(stores.size).toBe(0);
+
+    const store = await stores.acquire("ses-1", workspaceRootDir);
+    expect(opened).toEqual([store]);
+    expect(stores.size).toBe(1);
+  });
+
+  it("a re-acquire under a different workspace volume releases the held store and opens the new one", async () => {
+    const rootA = freshWorkspaceRoot();
+    const rootB = freshWorkspaceRoot();
+    const { open, opened } = recordingOpener();
+    const stores = new SessionStores(open);
+
+    const onA = await stores.acquire("ses-1", rootA);
+    const onB = await stores.acquire("ses-1", rootB);
+
+    // The handle for the old binding can never serve the new one (the same
+    // rule the agent cache applies to a fingerprint mismatch).
+    expect(onB).not.toBe(onA);
+    expect(onA.disposeCalls).toBe(1);
+    expect(onB.stateRoot.startsWith(rootB)).toBe(true);
+    expect(opened).toHaveLength(2);
+    expect(stores.size).toBe(1);
+  });
+
+  it("a dispose that throws is swallowed: the store is forgotten either way", async () => {
+    const workspaceRootDir = freshWorkspaceRoot();
+    const stores = new SessionStores(async (location) => {
+      const store = new FakeStore(location);
+      store.dispose = async () => {
+        throw new Error("handle already closed");
+      };
+      return store;
+    });
+
+    await stores.acquire("ses-1", workspaceRootDir);
+    await expect(stores.release("ses-1")).resolves.toBeUndefined();
+    expect(stores.size).toBe(0);
+  });
+});

package/src/activities/execute-cursor/adapter.ts

@@ -5,9 +5,10 @@
  * module boots, releases, and delegates.
  *
  * What this adapter owns: the proxy interceptors and the parked-agent cache
- * (worker lifetime), the parked agent per session (session lifetime), and one
- * engine turn (`runTurn`, through `turn.ts`). Everything else about a turn is
- * the runtime's (`harness/run-turn.ts`).
+ * (worker lifetime), the parked agent and the SDK store per session (session
+ * lifetime; `agent-session-cache.ts`, `session-store.ts`), and one engine turn
+ * (`runTurn`, through `turn.ts`). Everything else about a turn is the
+ * runtime's (`harness/run-turn.ts`).
  *
  * THIS MODULE'S STATIC GRAPH IS SDK-FREE, ON PURPOSE. The composition roots
  * import it (through `src/harness-adapters.ts`) BEFORE they boot it, and
@@ -57,6 +58,7 @@ import { closeAllCachedAgents, evictSessionAgent } from "./agent-session-cache.j
 import { CURSOR_CAPABILITIES } from "./cursor-capabilities.js";
 import { installFetchInterceptor } from "./fetch-interceptor.js";
 import { assertHttp2ConnectPatched, installHttp2Interceptor } from "./http2-interceptor.js";
+import { releaseAllSessionStores, releaseSessionStore } from "./session-store.js";
 import type { CursorAdapterConfig } from "./turn-setup.js";
 
 /** The config slice this adapter reads per turn, taken at `boot`; a whole `Config` satisfies it. */
@@ -120,14 +122,16 @@ export function createCursorAdapter(): HarnessAdapter {
       booted = { config: resolveCursorConfig(bootConfig), runCursorTurn };
     },
 
-    /** Close every parked agent (their executor leases and MCP subprocesses). */
+    /** Close every parked agent (their executor leases and MCP subprocesses), then every session's SDK store. */
     async shutdown(): Promise<void> {
       closeAllCachedAgents();
+      await releaseAllSessionStores();
     },
 
-    /** The session is done on this host: close the agent parked for it, if any (#215). */
+    /** The session is done on this host: close the agent parked for it, if any (#215), then its SDK store (#1053). */
     async releaseSession(sessionId: string): Promise<void> {
       evictSessionAgent(sessionId);
+      await releaseSessionStore(sessionId);
     },
 
     async runTurn(input: TurnInput, sink: TurnSink): Promise<TurnOutcome> {

package/src/activities/execute-cursor/sdk-warmup.ts

@@ -3,10 +3,19 @@
  *
  * The first `Agent.create` in a pod pays the SDK's platform construction:
  * four SQLite-backed stores (run/checkpoint/event stores + notifier) whose
- * first use loads the sqlite native binding and compiles the schema
- * migrations. The 2026-07-30 instrumented baseline (issue #209) measured
- * this at ~1.2s of the ~2.4s `resolve_agent` segment, with a 624ms floor —
- * roughly half the cost is per-process warm-up, not per-session work.
+ * first use compiles the schema migrations. The 2026-07-30 instrumented
+ * baseline (issue #209, @cursor/sdk 1.0.13) measured this at ~1.2s of the
+ * ~2.4s `resolve_agent` segment, with a 624ms floor — roughly half the cost
+ * was per-process warm-up, not per-session work. Part of that floor was the
+ * `sqlite3` native binding's load; since 1.0.31 (stigmer/stigmer#1053) the
+ * SDK's stores run on `node:sqlite`, which is inside the Node binary, and the
+ * session's store is opened by the runner itself (`session-store.ts`,
+ * `SqliteLocalAgentStore.open`) rather than through the platform this
+ * warm-up constructs. What this warm-up still saves at 1.0.31 is therefore a
+ * measurement, not a known quantity: its `durationMs` and the cold-start
+ * timeline answer it, and the harness program carries the question of
+ * whether to warm through the store the runner actually opens, or through
+ * the SDK's own `prewarmLocalWorkspace`, or not at all.
  *
  * Pool members idle between boot and claim, so constructing one throwaway
  * platform there moves that per-process cost off the user-visible path.
@@ -32,8 +41,8 @@ export interface SdkWarmupResult {
 
 /**
  * Construct (and abandon) one SDK agent platform on a throwaway temp-dir
- * state root, forcing the sqlite native binding + store schema work to
- * happen now instead of inside the first user-facing `Agent.create`.
+ * state root, forcing the store schema work to happen now instead of inside
+ * the first user-facing `Agent.create`.
  *
  * Total by construction — warm-up is an optimization and must never affect
  * the member's ability to serve. The throwaway state root is a few KB on

package/src/activities/execute-cursor/session-lifecycle.ts

@@ -3,59 +3,63 @@
  *
  * SessionSpec.harness_state_id stores the Cursor agentId. This module handles
  * creating new agents (first execution), resuming existing agents
- * (subsequent executions), graceful fallback on resume failure, and
- * cleaning up agents (session deletion).
+ * (subsequent executions) and graceful fallback on resume failure.
  *
  * Two execution modes:
  *
- * - Local mode: Agent.create({ local: { cwd } }) with explicit
- *   platform.workspaceRef/stateRoot for deterministic store keying.
- *   Produces agent- prefixed IDs.
+ * - Local mode: Agent.create({ local: { cwd, dirs, store, ... } }) over the
+ *   session's own SQLite store (`session-store.ts`). Produces agent- prefixed
+ *   IDs.
  *
  * - Cloud mode (feature-flagged): Agent.create({ cloud: { repos } })
- *   for git-backed workspaces. Produces bc- prefixed IDs. No platform
- *   options — cloud state lives on Cursor's servers, not local SQLite.
+ *   for git-backed workspaces. Produces bc- prefixed IDs. No store — cloud
+ *   state lives on Cursor's servers, not local SQLite.
  *
- * Key SDK limitation: mcpServers are NOT persisted across Agent.resume().
- * They must be passed again on every resume call.
+ * Nothing under `local` survives Agent.resume(): `cwd`, `dirs`,
+ * `settingSources`, `store` and `enableAgentRetries` are re-supplied on every
+ * resume, exactly like `mcpServers`, `agents` and the model params. Omitting
+ * `cwd` re-roots the resumed agent at process.cwd() and loads the "project"
+ * setting source (the .cursor/hooks.json carrying the HITL approval hook) from
+ * the wrong directory, silently disabling the gate on every resumed turn;
+ * omitting `store` would make the SDK look the agent up in a default store
+ * derived from `cwd`, not the one the session's records are in.
  *
- * Platform store keying (local only): The Cursor SDK defaults to
- * process.cwd() for its internal state root lookup. In cloud sandboxes,
- * process.cwd() is the runner's app directory, not the workspace — causing
- * Agent.resume() to fail with "Agent not found". We pass explicit
- * platform.workspaceRef and platform.stateRoot derived from the Stigmer
- * sessionId to ensure deterministic store lookup regardless of process.cwd().
+ * Durability model: the session's SQLite store (agent records, runs,
+ * checkpoints) is the source of truth for conversation continuation. It lives
+ * under the durable workspace volume (`session-store.ts`) so Agent.resume()
+ * survives pod restart, reschedule, and snapshot restore. When resume
+ * nonetheless fails (store lost, corrupted, or agent unknown), this module
+ * creates a fresh agent and the caller starts a new turn from the user message
+ * plus re-injected instructions — there is no separate continuation store.
  *
- * Durability model: the SDK's local SQLite store (agent records, runs,
- * checkpoints) is the source of truth for conversation continuation. It is
- * persisted under the durable workspace volume (see resolvePlatformOptions)
- * so Agent.resume() survives pod restart, reschedule, and snapshot restore.
- * When resume nonetheless fails (store lost, corrupted, or agent unknown),
- * this module creates a fresh agent and the caller starts a new turn from
- * the user message plus re-injected instructions — there is no separate
- * continuation store.
+ * Retries are the runner's, not the SDK's. `@cursor/sdk` 1.0.31 defaults
+ * `enableAgentRetries` to true for headless embedders (1.0.13 defaulted it to
+ * false); the runner already owns recovery from a dead or stalled transport —
+ * `withTimeout` around agent resolution, `resolveAgentWithTransportRecovery`
+ * (reset the transport, retry once), the two recovery spines in
+ * `turn-settle.ts`, and the stall detector — so the SDK's layer is pinned OFF
+ * to keep one retry authority and the 1.0.13 timing of every provider fault.
+ * Whether to adopt the SDK's retries and delete ours is an open design
+ * question for the harness program, recorded there; it is not decided here.
  */
 
-import { mkdirSync } from "node:fs";
-import { join } from "node:path";
-
 import { Agent } from "@cursor/sdk";
 import type {
   SDKAgent,
-  CursorAgentPlatformOptions,
   AgentDefinition,
+  LocalAgentOptions,
   ModelParameterValue,
 } from "@cursor/sdk";
+import type { SqliteLocalAgentStore } from "@cursor/sdk/sqlite";
 import { withTimeout, TimeoutError } from "../../shared/with-timeout.js";
 import type { CloudRepo } from "../../shared/blueprint-resolver.js";
 import type { CursorMcpServerConfig } from "./cursor-mcp-config.js";
+import { sessionStore } from "./session-store.js";
 
 // ---------------------------------------------------------------------------
 // Constants
 // ---------------------------------------------------------------------------
 
-const CURSOR_SDK_STATE_DIR = ".stigmer/cursor-sdk-state";
-
 /**
  * Cursor SDK setting sources loaded for LOCAL agents.
  *
@@ -199,64 +203,41 @@ export interface AgentResolution {
 // ---------------------------------------------------------------------------
 
 /**
- * Compute deterministic platform options for a Stigmer session.
- *
- * workspaceRef is a synthetic identifier (not a filesystem path) that
- * ensures the SDK's platform cache key is stable across activity
- * invocations regardless of process.cwd().
+ * The `local` options a session's agent is created AND resumed with — one
+ * builder so the two calls cannot drift (see the module header for why every
+ * field is re-supplied on resume).
  *
- * stateRoot is a session-isolated directory under the durable workspace
- * volume ({workspaceRootDir}/.stigmer/cursor-sdk-state/{sessionId}) where
- * the SDK persists its SQLite stores (agent records, runs, checkpoints).
- * Placing it on the workspace volume (rather than $HOME) makes native
- * Agent.resume() survive pod restart/reschedule and snapshot restore, and
- * keys it by sessionId so sessions sharing one volume (e.g. the child agent
- * executions of a workflow sandbox) never collide. Created eagerly to
- * prevent ENOENT on first SDK write.
- *
- * Both inputs are required and must be non-empty: the stateRoot is keyed by
- * sessionId, so an empty sessionId would collapse every session sharing the
- * volume onto the same store and corrupt their conversation state.
+ * Workspaces: the SDK takes ONE primary `cwd` (the default shell's directory
+ * and the agent's store scoping) plus `dirs` for the other roots of a
+ * multi-root workspace, merged cwd-first with duplicates dropped, so rules,
+ * skills and hooks load from every root. The session's first workspace
+ * directory is the primary, as it was when the SDK took the whole array.
  */
-export function resolvePlatformOptions(
+async function localAgentOptions(
   sessionId: string,
   workspaceRootDir: string,
-): CursorAgentPlatformOptions {
-  if (!sessionId) {
-    throw new Error(
-      "resolvePlatformOptions: sessionId is required but was empty. The Cursor SDK " +
-      "state store is keyed by sessionId; an empty value would collide across sessions " +
-      "sharing a workspace volume (e.g. a workflow sandbox's child agent executions).",
-    );
-  }
-  if (!workspaceRootDir) {
-    throw new Error(
-      "resolvePlatformOptions: workspaceRootDir is required but was empty. The Cursor " +
-      "SDK state store must live on the durable workspace volume to survive restarts.",
-    );
-  }
-  const stateRoot = join(workspaceRootDir, CURSOR_SDK_STATE_DIR, sessionId);
-  mkdirSync(stateRoot, { recursive: true });
+  workspaceDirs: readonly string[],
+): Promise<LocalAgentOptions & { readonly store: SqliteLocalAgentStore }> {
+  const [cwd, ...dirs] = workspaceDirs;
+  const store = await sessionStore(sessionId, workspaceRootDir);
   return {
-    workspaceRef: `stigmer-session:${sessionId}`,
-    stateRoot,
+    cwd,
+    ...(dirs.length > 0 ? { dirs } : {}),
+    settingSources: [...LOCAL_SETTING_SOURCES],
+    store,
+    // The runner is the one retry authority (module header).
+    enableAgentRetries: false,
   };
 }
 
 /**
  * Create a new local Cursor Agent for the first execution in a session.
- *
- * Supports multi-workspace: passes string[] when multiple dirs, string when single.
  */
 export async function createAgent(options: CreateAgentOptions): Promise<SDKAgent> {
-  const cwd = options.workspaceDirs.length === 1
-    ? options.workspaceDirs[0]
-    : options.workspaceDirs;
-
-  const platform = resolvePlatformOptions(options.sessionId, options.workspaceRootDir);
+  const local = await localAgentOptions(options.sessionId, options.workspaceRootDir, options.workspaceDirs);
   console.log(
-    `createAgent: sessionId=${options.sessionId}, workspaceRef=${platform.workspaceRef}, ` +
-    `stateRoot=${platform.stateRoot}, process.cwd=${process.cwd()}`,
+    `createAgent: sessionId=${options.sessionId}, workspaceRef=${local.store.workspaceRef}, ` +
+    `stateRoot=${local.store.stateRoot}, process.cwd=${process.cwd()}`,
   );
 
   return Agent.create({
@@ -264,10 +245,9 @@ export async function createAgent(options: CreateAgentOptions): Promise<SDKAgent
     // Always a full selection — id AND params. A bare { id } would let the
     // catalog's default variant (account-influenced) pick the price (#357).
     model: { id: options.model, params: options.modelParams },
-    local: { cwd, settingSources: [...LOCAL_SETTING_SOURCES] },
+    local,
     mcpServers: options.mcpServers as Record<string, any>,
     agents: options.agents,
-    platform,
   });
 }
 
@@ -278,14 +258,10 @@ export async function createAgent(options: CreateAgentOptions): Promise<SDKAgent
  * propagate or fall back to a fresh agent with continuation context.
  */
 export async function resumeAgent(options: ResumeAgentOptions): Promise<SDKAgent> {
-  const cwd = options.workspaceDirs.length === 1
-    ? options.workspaceDirs[0]
-    : options.workspaceDirs;
-
-  const platform = resolvePlatformOptions(options.sessionId, options.workspaceRootDir);
+  const local = await localAgentOptions(options.sessionId, options.workspaceRootDir, options.workspaceDirs);
   console.log(
     `resumeAgent: agentId=${options.agentId}, sessionId=${options.sessionId}, ` +
-    `workspaceRef=${platform.workspaceRef}, stateRoot=${platform.stateRoot}, ` +
+    `workspaceRef=${local.store.workspaceRef}, stateRoot=${local.store.stateRoot}, ` +
     `process.cwd=${process.cwd()}`,
   );
 
@@ -296,16 +272,9 @@ export async function resumeAgent(options: ResumeAgentOptions): Promise<SDKAgent
     // ledger, #357), but an id-only resume would fall back to the catalog
     // default variant for the new turns.
     model: options.model ? { id: options.model, params: options.modelParams } : undefined,
-    // Neither cwd nor settingSources survive Agent.resume(); both must be
-    // re-supplied every turn. Omitting cwd makes the SDK fall back to
-    // process.cwd(), which re-roots the agent in the runner's own working
-    // directory and loads the "project" setting source — the .cursor/hooks.json
-    // carrying the HITL approval hook — from that wrong directory, silently
-    // disabling the approval gate on every resumed turn.
-    local: { cwd, settingSources: [...LOCAL_SETTING_SOURCES] },
+    local,
     mcpServers: options.mcpServers as Record<string, any>,
     agents: options.agents,
-    platform,
   });
 }
 
@@ -317,7 +286,7 @@ export async function resumeAgent(options: ResumeAgentOptions): Promise<SDKAgent
  * Create a new cloud Cursor Agent for git-backed sessions.
  *
  * Cloud agents (bc- prefix) run on Cursor's servers with cloned repos.
- * No platform options — cloud state lives server-side, not in local SQLite.
+ * No store — cloud state lives server-side, not in local SQLite.
  * Model is optional — Cursor resolves the caller's configured default
  * when omitted.
  */
@@ -341,7 +310,7 @@ export async function createCloudAgent(options: CreateCloudAgentOptions): Promis
  *
  * Throws on failure — the caller (resolveAgent) decides whether to
  * propagate or fall back to a fresh cloud agent with continuation context.
- * No platform options — cloud state lives server-side.
+ * No store — cloud state lives server-side.
  */
 export async function resumeCloudAgent(options: ResumeCloudAgentOptions): Promise<SDKAgent> {
   console.log(
@@ -365,8 +334,8 @@ export async function resumeCloudAgent(options: ResumeCloudAgentOptions): Promis
  * graceful fallback if resume fails.
  *
  * The mode parameter determines which create/resume functions are used:
- * - "local": createAgent / resumeAgent (with platform options)
- * - "cloud": createCloudAgent / resumeCloudAgent (no platform options)
+ * - "local": createAgent / resumeAgent (over the session's store)
+ * - "cloud": createCloudAgent / resumeCloudAgent (no store)
  *
  * When harnessStateId is non-empty (subsequent execution):
  *   1. Attempt Agent.resume with mode-appropriate options.
@@ -536,18 +505,3 @@ export async function resolveAgentWithTransportRecovery(
     return attempt(true);
   }
 }
-
-/**
- * Dispose a Cursor Agent when a session is deleted.
- * Best-effort: logs and swallows errors.
- */
-export async function disposeAgent(agentId: string, apiKey: string): Promise<void> {
-  try {
-    await Agent.archive(agentId, { apiKey });
-  } catch (err) {
-    console.warn(
-      `Failed to archive Cursor agent ${agentId}:`,
-      err instanceof Error ? err.message : err,
-    );
-  }
-}