@emmaneugene/pi-cursor-sdk 0.3.7 → 0.4.0

package/dist/cursor-runtime-state.js

@@ -1,48 +1,15 @@
-import { registerCursorCloudLifecycleLedger, runCursorCloudLifecycleCommand, } from "./cursor-cloud-lifecycle.js";
-import { CURSOR_AUTO_REVIEW_ENV, CURSOR_CLOUD_ACK_ENV, CURSOR_CLOUD_ALLOW_LOCAL_STATE_ENV, CURSOR_CLOUD_AUTO_CREATE_PR_ENV, CURSOR_CLOUD_BRANCH_ENV, CURSOR_CLOUD_CONTEXT_ENV, CURSOR_CLOUD_DIRECT_PUSH_ENV, CURSOR_CLOUD_ENV_ENV, CURSOR_CLOUD_ENV_FROM_FILES_ENV, CURSOR_CLOUD_ENV_NAME_ENV, CURSOR_CLOUD_ENV_TYPE_ENV, CURSOR_CLOUD_REPO_ENV, CURSOR_CLOUD_SKIP_REVIEWER_REQUEST_ENV, CURSOR_LOCAL_FORCE_ENV, CURSOR_LOCAL_RESUME_ENV, CURSOR_RUNTIME_ENV, CURSOR_SANDBOX_ENV, getCursorSdkProjectConfigPath, getCursorSdkUserConfigPath, loadCursorSdkConfig, mergeCursorSdkConfigForUpdate, parseExplicitCursorCloudEnvNames, resolveCursorSdkConfig, updateCursorSdkConfig, } from "./cursor-config.js";
-import { asRecord } from "./cursor-record-utils.js";
+import { CURSOR_AUTO_REVIEW_ENV, CURSOR_LOCAL_FORCE_ENV, CURSOR_LOCAL_RESUME_ENV, CURSOR_SANDBOX_ENV, loadCursorSdkConfig, resolveCursorSdkConfig, } from "./cursor-config.js";
 import { getResolvedSessionCursorHttp1Enabled } from "./cursor-http1.js";
 import { getCursorSessionCwd, getCursorSessionProjectTrusted } from "./cursor-session-scope.js";
-export const CURSOR_RUNTIME_ENTRY_TYPE = "cursor-runtime-state";
-export const CURSOR_CLOUD_ACK_DISCLOSURE = [
-    "Cursor Cloud executes this work remotely.",
-    "Fresh context is used by default; prior Pi context is included only with explicit bootstrap opt-in.",
-    "Pi-local tools and the Pi bridge are unavailable, and Pi environment variables are not forwarded.",
-    "Cursor may create branches, commit, push, and open pull requests.",
-    "Cloud agents remain until you archive or delete them.",
-    "Cloud Agents run in Max Mode, are billed at Cursor API pricing, and may require spend-limit setup.",
-].join("\n\n");
 let cliCursorSnapshot = { config: {} };
 let cliLocalForceConsumed = false;
 let envLocalForceConsumed = false;
-let sessionCursorRuntime;
-let sessionCursorCloudAcknowledged = false;
-function isCursorRuntimeEntryData(value) {
-    const record = asRecord(value);
-    if (!record)
-        return false;
-    return (record.runtime === "local" || record.runtime === "cloud")
-        && (record.cloudAcknowledged === undefined || typeof record.cloudAcknowledged === "boolean");
-}
-function stringFlagValue(value) {
-    return typeof value === "string" && value.trim() ? value.trim() : undefined;
-}
 export function getCursorCliConfig() {
-    const config = structuredClone(cliCursorSnapshot.config);
-    const envNames = parseExplicitCursorCloudEnvNames(cliCursorSnapshot.cloudEnvNames, "--cursor-cloud-env");
-    if (envNames)
-        config.cloud = { ...config.cloud, envNames };
-    return config;
+    return structuredClone(cliCursorSnapshot.config);
 }
 export function getCursorSessionConfig() {
     const useHttp1ForAgent = getResolvedSessionCursorHttp1Enabled();
     return {
-        ...(sessionCursorRuntime
-            ? {
-                runtime: sessionCursorRuntime,
-                ...(sessionCursorCloudAcknowledged ? { cloud: { acknowledged: true } } : {}),
-            }
-            : {}),
         ...(useHttp1ForAgent === undefined ? {} : { local: { useHttp1ForAgent } }),
     };
 }
@@ -66,7 +33,6 @@ export function resolveCursorStatusRuntime(ctx) {
         const config = resolveEffectiveCursorConfigForContext(ctx);
         return {
             kind: "valid",
-            runtime: config.runtime,
             useHttp1ForAgent: config.local.useHttp1ForAgent,
         };
     }
@@ -74,15 +40,9 @@ export function resolveCursorStatusRuntime(ctx) {
         return { kind: "invalid", message: error instanceof Error ? error.message : String(error) };
     }
 }
-export function formatResolvedCursorRuntime(runtime) {
-    const cap = runtime.cappedBy;
-    return cap
-        ? `${runtime.value} (source: ${runtime.source} safety cap over ${cap.cappedSource} ${cap.cappedValue})`
-        : `${runtime.value} (source: ${runtime.source})`;
-}
-export function formatCursorStatus(runtime, fast, mode, useHttp1ForAgent = false) {
-    const parts = [`cursor:${runtime}`, fast === true ? "fast:on" : fast === false ? "fast:off" : "fast:n/a"];
-    if (runtime === "local" && useHttp1ForAgent)
+export function formatCursorStatus(fast, mode, useHttp1ForAgent = false) {
+    const parts = ["cursor", fast === true ? "fast:on" : fast === false ? "fast:off" : "fast:n/a"];
+    if (useHttp1ForAgent)
         parts.push("http1");
     if (mode === "invalid")
         parts.push("mode invalid");
@@ -107,40 +67,7 @@ export function consumeCursorLocalForceOverride(resolved) {
     }
     return false;
 }
-export function restoreSessionCursorRuntimeState(branch) {
-    sessionCursorRuntime = undefined;
-    sessionCursorCloudAcknowledged = false;
-    for (const entry of branch) {
-        if (entry.type !== "custom" || entry.customType !== CURSOR_RUNTIME_ENTRY_TYPE)
-            continue;
-        if (isCursorRuntimeEntryData(entry.data)) {
-            sessionCursorRuntime = entry.data.runtime;
-            sessionCursorCloudAcknowledged ||= entry.data.cloudAcknowledged === true;
-        }
-    }
-}
 export function restoreCursorCliState(pi) {
-    const runtime = stringFlagValue(pi.getFlag("cursor-runtime"));
-    const repo = stringFlagValue(pi.getFlag("cursor-cloud-repo"));
-    const branch = stringFlagValue(pi.getFlag("cursor-cloud-branch"));
-    const contextHandoff = stringFlagValue(pi.getFlag("cursor-cloud-context"));
-    const environmentType = stringFlagValue(pi.getFlag("cursor-cloud-env-type"));
-    const environmentName = stringFlagValue(pi.getFlag("cursor-cloud-env-name"));
-    const cloudEnvNames = stringFlagValue(pi.getFlag("cursor-cloud-env"));
-    const cloud = {
-        ...(repo ? { repo } : {}),
-        ...(branch ? { branch } : {}),
-        ...(contextHandoff ? { contextHandoff } : {}),
-        ...(pi.getFlag("cursor-cloud-direct-push") === true ? { directPush: true } : {}),
-        ...(pi.getFlag("cursor-cloud-auto-create-pr") === true ? { autoCreatePR: true } : {}),
-        ...(pi.getFlag("cursor-cloud-skip-reviewer-request") === true ? { skipReviewerRequest: true } : {}),
-        ...(pi.getFlag("cursor-cloud-allow-local-state") === true ? { allowLocalState: true } : {}),
-        ...(pi.getFlag("cursor-cloud-env-from-files") === true ? { envFromFiles: true } : {}),
-        ...(environmentType || environmentName
-            ? { environment: { ...(environmentType ? { type: environmentType } : {}), ...(environmentName ? { name: environmentName } : {}) } }
-            : {}),
-        ...(pi.getFlag("cursor-cloud-ack") === true ? { acknowledged: true } : {}),
-    };
     const local = {
         ...(pi.getFlag("cursor-auto-review") === true ? { autoReview: true } : {}),
         ...(pi.getFlag("cursor-sandbox") === true ? { sandboxOptions: { enabled: true } } : {}),
@@ -153,88 +80,11 @@ export function restoreCursorCliState(pi) {
     };
     cliCursorSnapshot = {
         config: {
-            ...(runtime ? { runtime } : {}),
-            ...(Object.keys(cloud).length ? { cloud } : {}),
             ...(Object.keys(local).length ? { local } : {}),
         },
-        ...(cloudEnvNames ? { cloudEnvNames } : {}),
     };
 }
-function persistCursorRuntimePreference(pi, runtime, cloudAcknowledged = false) {
-    const acknowledged = sessionCursorCloudAcknowledged || cloudAcknowledged;
-    pi.appendEntry(CURSOR_RUNTIME_ENTRY_TYPE, {
-        runtime,
-        ...(acknowledged ? { cloudAcknowledged: true } : {}),
-    });
-    sessionCursorRuntime = runtime;
-    sessionCursorCloudAcknowledged = acknowledged;
-}
-function registerCursorRuntimeFlags(pi) {
-    pi.registerFlag("cursor-runtime", {
-        description: `Select Cursor runtime for this run: local or cloud (or set ${CURSOR_RUNTIME_ENV})`,
-        type: "string",
-        default: "",
-    });
-    pi.registerFlag("cursor-cloud-repo", {
-        description: `Set Cursor cloud repository URL for this run (or set ${CURSOR_CLOUD_REPO_ENV})`,
-        type: "string",
-        default: "",
-    });
-    pi.registerFlag("cursor-cloud-branch", {
-        description: `Set Cursor cloud branch/ref for this run (or set ${CURSOR_CLOUD_BRANCH_ENV})`,
-        type: "string",
-        default: "",
-    });
-    pi.registerFlag("cursor-cloud-context", {
-        description: `Set Cursor cloud context handoff: never, fresh, or bootstrap (or set ${CURSOR_CLOUD_CONTEXT_ENV})`,
-        type: "string",
-        default: "",
-    });
-    pi.registerFlag("cursor-cloud-direct-push", {
-        description: `Allow Cursor cloud direct push for this run (or set ${CURSOR_CLOUD_DIRECT_PUSH_ENV}=1)`,
-        type: "boolean",
-        default: false,
-    });
-    pi.registerFlag("cursor-cloud-auto-create-pr", {
-        description: `Ask Cursor cloud to create a pull request for this run (or set ${CURSOR_CLOUD_AUTO_CREATE_PR_ENV}=1)`,
-        type: "boolean",
-        default: false,
-    });
-    pi.registerFlag("cursor-cloud-skip-reviewer-request", {
-        description: `Ask Cursor cloud not to request you as a reviewer for this run (or set ${CURSOR_CLOUD_SKIP_REVIEWER_REQUEST_ENV}=1)`,
-        type: "boolean",
-        default: false,
-    });
-    pi.registerFlag("cursor-cloud-allow-local-state", {
-        description: `Allow Cursor cloud to proceed with local-only state for this run (or set ${CURSOR_CLOUD_ALLOW_LOCAL_STATE_ENV}=1)`,
-        type: "boolean",
-        default: false,
-    });
-    pi.registerFlag("cursor-cloud-env", {
-        description: `Reserved Cursor cloud env var names; env forwarding is not implemented yet (or set ${CURSOR_CLOUD_ENV_ENV})`,
-        type: "string",
-        default: "",
-    });
-    pi.registerFlag("cursor-cloud-env-from-files", {
-        description: `Reserved Cursor cloud env-file forwarding flag; not implemented yet (or set ${CURSOR_CLOUD_ENV_FROM_FILES_ENV}=1)`,
-        type: "boolean",
-        default: false,
-    });
-    pi.registerFlag("cursor-cloud-env-type", {
-        description: `Select Cursor-managed cloud environment type: cloud, pool, or machine (or set ${CURSOR_CLOUD_ENV_TYPE_ENV})`,
-        type: "string",
-        default: "",
-    });
-    pi.registerFlag("cursor-cloud-env-name", {
-        description: `Select Cursor-managed cloud environment name (or set ${CURSOR_CLOUD_ENV_NAME_ENV})`,
-        type: "string",
-        default: "",
-    });
-    pi.registerFlag("cursor-cloud-ack", {
-        description: `Acknowledge first-use Cursor cloud runtime risks for this run (or set ${CURSOR_CLOUD_ACK_ENV}=1)`,
-        type: "boolean",
-        default: false,
-    });
+export function registerCursorLocalRuntimeFlags(pi) {
     pi.registerFlag("cursor-auto-review", {
         description: `Enable Cursor SDK local Auto-review for this run (or set ${CURSOR_AUTO_REVIEW_ENV}=1)`,
         type: "boolean",
@@ -261,120 +111,8 @@ function registerCursorRuntimeFlags(pi) {
         default: false,
     });
 }
-async function confirmCloudAcknowledgement(ctx, alreadyAcknowledged) {
-    if (alreadyAcknowledged)
-        return true;
-    if (!ctx.hasUI) {
-        ctx.ui.notify(`Cursor cloud runtime requires first-use acknowledgement. Pass --cursor-cloud-ack or set ${CURSOR_CLOUD_ACK_ENV}=1, then retry.`, "error");
-        return false;
-    }
-    const confirmed = await ctx.ui.confirm("Enable Cursor Cloud runtime?", CURSOR_CLOUD_ACK_DISCLOSURE);
-    if (!confirmed)
-        ctx.ui.notify("Cursor cloud runtime change cancelled; no settings were written.", "info");
-    return confirmed;
-}
-function registerCursorRuntimeCommand(pi, refreshStatus) {
-    pi.registerCommand("cursor-runtime", {
-        description: "Set Cursor runtime for this session: local or cloud",
-        handler: async (args, ctx) => {
-            const usage = "Usage: /cursor-runtime local|cloud [--save-user|--save-project]";
-            const tokens = args.trim().split(/\s+/).filter(Boolean);
-            const raw = tokens[0];
-            const saveUser = tokens.includes("--save-user");
-            const saveProject = tokens.includes("--save-project");
-            const extra = tokens.slice(1).filter((token) => token !== "--save-user" && token !== "--save-project");
-            const currentResolution = resolveCursorStatusRuntime(ctx);
-            if (!raw) {
-                ctx.ui.notify(currentResolution.kind === "invalid"
-                    ? `${currentResolution.message} ${usage}`
-                    : `Cursor runtime is ${formatResolvedCursorRuntime(currentResolution.runtime)}. ${usage}`, currentResolution.kind === "invalid" ? "error" : "info");
-                return;
-            }
-            if ((raw !== "local" && raw !== "cloud") || extra.length > 0 || (saveUser && saveProject)) {
-                ctx.ui.notify(`Invalid Cursor runtime arguments. ${usage}`, "error");
-                return;
-            }
-            if (currentResolution.kind === "invalid") {
-                ctx.ui.notify(`${currentResolution.message} Fix the explicit override before changing the session runtime.`, "error");
-                return;
-            }
-            if (saveProject && (getCursorSessionCwd() !== ctx.cwd || !getCursorSessionProjectTrusted())) {
-                ctx.ui.notify("Cannot save Cursor project config without explicit project-trust provenance. Ensure .pi/settings.json or another Pi project resource exists, trust the project, then restart pi; or restart with --approve. Project-local package installs must use --approve on every run that reads or writes .pi/cursor-sdk.json.", "error");
-                return;
-            }
-            const cloudAcknowledged = raw === "cloud" && await confirmCloudAcknowledgement(ctx, resolveEffectiveCursorConfigForContext(ctx).cloud.acknowledged.value);
-            if (raw === "cloud" && !cloudAcknowledged)
-                return;
-            if (saveUser || saveProject) {
-                try {
-                    if (saveUser) {
-                        updateCursorSdkConfig(getCursorSdkUserConfigPath(), (current) => mergeCursorSdkConfigForUpdate(current, {
-                            runtime: raw,
-                            ...(cloudAcknowledged ? { cloud: { acknowledged: true } } : {}),
-                        }), { newFileMode: 0o600 });
-                    }
-                    else {
-                        updateCursorSdkConfig(getCursorSdkProjectConfigPath(ctx.cwd), (current) => mergeCursorSdkConfigForUpdate(current, { runtime: raw }));
-                    }
-                }
-                catch (error) {
-                    const effectiveResolution = resolveCursorStatusRuntime(ctx);
-                    refreshStatus(ctx);
-                    const effective = effectiveResolution.kind === "valid"
-                        ? ` Effective runtime remains ${formatResolvedCursorRuntime(effectiveResolution.runtime)}.`
-                        : ` ${effectiveResolution.message}`;
-                    ctx.ui.notify(`Failed to save Cursor runtime preference to ${saveUser ? "user" : "project"} config: ${error instanceof Error ? error.message : String(error)}.${effective}`, "error");
-                    return;
-                }
-            }
-            try {
-                persistCursorRuntimePreference(pi, raw, cloudAcknowledged);
-            }
-            catch (error) {
-                const effectiveResolution = resolveCursorStatusRuntime(ctx);
-                refreshStatus(ctx);
-                const effective = effectiveResolution.kind === "valid"
-                    ? ` Effective runtime is ${formatResolvedCursorRuntime(effectiveResolution.runtime)}.`
-                    : ` ${effectiveResolution.message}`;
-                const persisted = saveUser
-                    ? "User config was saved, but persisting the session runtime entry failed."
-                    : saveProject
-                        ? "Project config was saved, but persisting the session runtime entry failed."
-                        : "Persisting the session runtime entry failed.";
-                ctx.ui.notify(`${persisted} ${error instanceof Error ? error.message : String(error)}.${effective}`, "error");
-                return;
-            }
-            const effectiveResolution = resolveCursorStatusRuntime(ctx);
-            refreshStatus(ctx);
-            const saved = saveUser
-                ? " Saved to user config."
-                : saveProject
-                    ? " Saved to project config; cloud acknowledgement remains session/user-scoped."
-                    : "";
-            const effective = effectiveResolution.kind === "valid"
-                ? ` Effective runtime is ${formatResolvedCursorRuntime(effectiveResolution.runtime)}.`
-                : ` ${effectiveResolution.message}`;
-            ctx.ui.notify(raw === "cloud"
-                ? `Cursor runtime request saved for this session and cloud risk acknowledged.${effective}${saved}`
-                : `Cursor runtime request saved for this session.${effective}${saved}`, "info");
-        },
-    });
-}
-export function registerCursorCloudRuntimeControls(pi, options) {
-    registerCursorCloudLifecycleLedger(pi);
-    registerCursorRuntimeFlags(pi);
-    registerCursorRuntimeCommand(pi, options.refreshStatus);
-    pi.registerCommand("cursor-cloud", {
-        description: "List, archive, or delete recorded Cursor cloud agents for this session branch",
-        handler: async (args, ctx) => {
-            await runCursorCloudLifecycleCommand(pi, args, ctx);
-        },
-    });
-}
 export function resetCursorRuntimeStateForTests() {
     cliCursorSnapshot = { config: {} };
     cliLocalForceConsumed = false;
     envLocalForceConsumed = false;
-    sessionCursorRuntime = undefined;
-    sessionCursorCloudAcknowledged = false;
 }

package/dist/cursor-sdk-billed-usage.js

@@ -4,9 +4,6 @@ const BILLED_USAGE_TIMEOUT_MS = 5000;
 // ponytail: process-lifetime watermark of billed usage UUIDs per agentId; reset on process exit.
 // Upgrade to session-scoped storage if multi-day processes retain enough agent IDs to matter.
 const seenBilledRunIdsByAgent = new Map();
-export function isCursorSdkClientMintedRunId(runId) {
-    return runId.startsWith("run-");
-}
 export function sumCursorSdkTurnUsage(usages) {
     if (usages.length === 0)
         return undefined;
@@ -49,31 +46,19 @@ export function selectCursorBilledTurnUsage(agentUsage, options) {
         const usage = readCursorSdkTurnUsage(record?.usage);
         return runId && usage ? [{ runId, usage }] : [];
     });
-    if (options.runtime === "cloud" && options.runId) {
-        const match = runs.find((run) => run.runId === options.runId);
-        return match ? { turn: match.usage, runIds: [match.runId] } : { runIds: [] };
-    }
     const unseen = runs.filter((run) => !options.seenRunIds?.has(run.runId));
     return { turn: sumCursorSdkTurnUsage(unseen.map((run) => run.usage)), runIds: unseen.map((run) => run.runId) };
 }
-export async function fetchCursorSdkAgentUsage(agent, options) {
+export async function fetchCursorSdkAgentUsage(agent) {
     if (typeof agent.getUsage !== "function")
         return undefined;
-    const query = options.runtime === "cloud" && options.runId && isCursorSdkClientMintedRunId(options.runId)
-        ? { runId: options.runId }
-        : undefined;
-    return withTimeout(Promise.resolve(agent.getUsage(query)));
+    return withTimeout(Promise.resolve(agent.getUsage()));
 }
 export async function attachCursorSdkBilledTurnUsage(options) {
-    const agentUsage = await fetchCursorSdkAgentUsage(options.agent, {
-        runtime: options.runtime,
-        runId: options.runId,
-    });
+    const agentUsage = await fetchCursorSdkAgentUsage(options.agent);
     if (!agentUsage)
         return {};
     const selected = selectCursorBilledTurnUsage(agentUsage, {
-        runtime: options.runtime,
-        runId: options.runtime === "cloud" ? options.runId : undefined,
         seenRunIds: peekCursorBilledUsageRunIds(options.agentId),
     });
     rememberCursorBilledUsageRunIds(options.agentId, selected.runIds);

package/dist/cursor-sdk-platform-package.js

@@ -0,0 +1,88 @@
+import { accessSync, constants, existsSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, isAbsolute, join } from "node:path";
+const RIPGREP_ENV = "CURSOR_RIPGREP_PATH";
+const TREE_SITTER_VENDOR_ENV = "CURSOR_TREE_SITTER_VENDOR_DIR";
+function cursorSdkPlatformPackageName() {
+    return `@cursor/sdk-${process.platform}-${process.arch}`;
+}
+function resolveCursorSdkPlatformPackageDir(fromModuleUrl = import.meta.url) {
+    try {
+        const require = createRequire(fromModuleUrl);
+        const sdkEntry = require.resolve("@cursor/sdk");
+        return dirname(require.resolve(`${cursorSdkPlatformPackageName()}/package.json`, {
+            paths: [dirname(sdkEntry)],
+        }));
+    }
+    catch {
+        return undefined;
+    }
+}
+function resolveCursorSdkPlatformBinary(binaryName, fromModuleUrl = import.meta.url) {
+    try {
+        const packageDirectory = resolveCursorSdkPlatformPackageDir(fromModuleUrl);
+        if (!packageDirectory)
+            return undefined;
+        const binaryPath = join(packageDirectory, "bin", binaryName);
+        accessSync(binaryPath, constants.X_OK);
+        return binaryPath;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function resolveBundledCursorRipgrepPath(fromModuleUrl = import.meta.url) {
+    return resolveCursorSdkPlatformBinary(process.platform === "win32" ? "rg.exe" : "rg", fromModuleUrl);
+}
+export function ensureCursorRipgrepPath() {
+    const configuredPath = process.env[RIPGREP_ENV];
+    if (configuredPath && isAbsolute(configuredPath))
+        return configuredPath;
+    const bundledPath = resolveBundledCursorRipgrepPath();
+    if (bundledPath)
+        process.env[RIPGREP_ENV] = bundledPath;
+    return bundledPath;
+}
+export function resolveBundledCursorTreeSitterVendorDir(fromModuleUrl = import.meta.url) {
+    const packageDirectory = resolveCursorSdkPlatformPackageDir(fromModuleUrl);
+    if (!packageDirectory)
+        return undefined;
+    const vendorDir = join(packageDirectory, "vendor");
+    if (!existsSync(join(vendorDir, "tree-sitter", "index.js")))
+        return undefined;
+    return vendorDir;
+}
+export function ensureCursorTreeSitterVendorDir() {
+    const configuredPath = process.env[TREE_SITTER_VENDOR_ENV];
+    if (configuredPath && isAbsolute(configuredPath))
+        return configuredPath;
+    const bundledPath = resolveBundledCursorTreeSitterVendorDir();
+    if (bundledPath)
+        process.env[TREE_SITTER_VENDOR_ENV] = bundledPath;
+    return bundledPath;
+}
+export function resolveBundledCursorSandboxPath(fromModuleUrl = import.meta.url) {
+    return resolveCursorSdkPlatformBinary(process.platform === "win32" ? "cursorsandbox.exe" : "cursorsandbox", fromModuleUrl);
+}
+/**
+ * The SDK finds `cursorsandbox` by walking from `process.argv[1]`, not from
+ * `require.resolve`. Point that walk at the installed platform package for the
+ * duration of local `Agent.create` / `Agent.resume`.
+ */
+export async function runWithCursorSdkPlatformPackageVisible(run, fromModuleUrl = import.meta.url) {
+    const packageDirectory = resolveCursorSdkPlatformPackageDir(fromModuleUrl);
+    if (!packageDirectory)
+        return run();
+    const hostEntry = join(packageDirectory, "package.json");
+    if (!existsSync(hostEntry))
+        return run();
+    const previousArgv1 = process.argv[1];
+    process.argv[1] = hostEntry;
+    try {
+        return await run();
+    }
+    finally {
+        if (process.argv[1] === hostEntry)
+            process.argv[1] = previousArgv1;
+    }
+}

package/dist/cursor-session-agent.js

@@ -4,6 +4,7 @@ import { computeCursorContextFingerprint } from "./context.js";
 import { getCursorSessionFile, getCursorSessionScopeGeneration, getCursorSessionScopeKey } from "./cursor-session-scope.js";
 import { getMatchingCursorSessionAgentResumeHandle, persistCursorSessionAgentResumeHandle, } from "./cursor-session-agent-resume.js";
 import { loadCursorSdk } from "./cursor-sdk-runtime.js";
+import { runWithCursorSdkPlatformPackageVisible } from "./cursor-sdk-platform-package.js";
 import { cursorSessionStoreIdentitiesEqual, openCursorSessionStore, openCursorSessionStoreForScope, } from "./cursor-session-store.js";
 export const CURSOR_LOCAL_AGENT_IDLE_MS = 5 * 60 * 1000;
 class SessionCursorAgentCreationSupersededError extends Error {
@@ -330,22 +331,25 @@ async function createSessionAgentEntry(scopeKey, persistentStore, instanceId, se
         let agent;
         let effectiveSendState = sendState;
         let resumed = false;
-        if (resumeHandle && resumeAttemptAllowed && resumeAgent) {
-            try {
-                agent = await resumeAgent(resumeHandle.agentId, buildAgentOptions());
-                effectiveSendState = { ...resumeHandle.sendState };
-                resumed = true;
-            }
-            catch {
-                if (persistentStore)
-                    resumeNotice = LOCAL_RESUME_FALLBACK_NOTICE;
-                if (!cursorSessionStoreIdentitiesEqual(sessionStore.identity, identities.sessionStore)) {
-                    await sessionStore.dispose().catch(() => undefined);
-                    sessionStore = await openCursorSessionStore(params.cwd, identities.sessionStore);
+        await runWithCursorSdkPlatformPackageVisible(async () => {
+            if (resumeHandle && resumeAttemptAllowed && resumeAgent) {
+                try {
+                    agent = await resumeAgent(resumeHandle.agentId, buildAgentOptions());
+                    effectiveSendState = { ...resumeHandle.sendState };
+                    resumed = true;
+                }
+                catch {
+                    if (persistentStore)
+                        resumeNotice = LOCAL_RESUME_FALLBACK_NOTICE;
+                    const currentStore = sessionStore;
+                    if (currentStore && !cursorSessionStoreIdentitiesEqual(currentStore.identity, identities.sessionStore)) {
+                        await currentStore.dispose().catch(() => undefined);
+                        sessionStore = await openCursorSessionStore(params.cwd, identities.sessionStore);
+                    }
                 }
             }
-        }
-        agent ??= await createAgent(buildAgentOptions());
+            agent ??= await createAgent(buildAgentOptions());
+        });
         if (!agent)
             throw new Error("Cursor SDK agent creation returned no agent");
         if (!sessionStore)

package/dist/cursor-skill-tool.js

@@ -5,7 +5,6 @@ import { arePiToolsDisabled } from "./cursor-active-tools.js";
 import { isCursorModel } from "./cursor-model.js";
 import { registerCursorModelLifecycle } from "./cursor-model-lifecycle.js";
 import { resolveCursorPiToolBridgeEnabled } from "./cursor-pi-tool-bridge-env.js";
-import { resolveEffectiveCursorConfigForContext } from "./cursor-runtime-state.js";
 export const CURSOR_ACTIVATE_SKILL_TOOL_NAME = "cursor_activate_skill";
 export const CURSOR_ACTIVATE_SKILL_MCP_NAME = "pi__cursor_activate_skill";
 const AVAILABLE_SKILLS_SECTION_PATTERN = /\n\nThe following skills provide specialized instructions for specific tasks\.[\s\S]*?<\/available_skills>/;
@@ -29,15 +28,12 @@ function setCurrentSkills(skills) {
 function getAvailableSkillNames() {
     return [...currentSkillsByName.keys()].sort();
 }
-function resolveEffectiveRuntimeForSkillLifecycle(cursorModel, ctx) {
-    return cursorModel ? resolveEffectiveCursorConfigForContext(ctx).runtime.value : "local";
+function shouldExposeSkillTool(model) {
+    return isCursorModel(model) && resolveCursorPiToolBridgeEnabled() && currentSkillsByName.size > 0;
 }
-function shouldExposeSkillTool(model, runtime) {
-    return runtime === "local" && isCursorModel(model) && resolveCursorPiToolBridgeEnabled() && currentSkillsByName.size > 0;
-}
-function syncCursorSkillToolForModel(pi, model, runtime) {
+function syncCursorSkillToolForModel(pi, model) {
     const activeToolNames = new Set(pi.getActiveTools());
-    const shouldBeActive = !arePiToolsDisabled(pi) && shouldExposeSkillTool(model, runtime);
+    const shouldBeActive = !arePiToolsDisabled(pi) && shouldExposeSkillTool(model);
     const alreadyActive = activeToolNames.has(CURSOR_ACTIVATE_SKILL_TOOL_NAME);
     if (shouldBeActive === alreadyActive)
         return;
@@ -71,11 +67,9 @@ export function formatCursorSkillsForPrompt(skills) {
     lines.push("</available_skills>");
     return lines.join("\n");
 }
-export function resolveCursorSkillSystemPrompt(systemPrompt, model, systemPromptOptions, runtime = "local") {
+export function resolveCursorSkillSystemPrompt(systemPrompt, model, systemPromptOptions) {
     if (!isCursorModel(model))
         return systemPrompt;
-    if (runtime === "cloud")
-        return systemPrompt.replace(AVAILABLE_SKILLS_SECTION_PATTERN, "");
     const skills = getVisibleSkills(systemPromptOptions?.skills);
     if (skills.length === 0)
         return systemPrompt;
@@ -186,9 +180,9 @@ export function registerCursorSkillTool(pi) {
             }
         },
     });
-    const clearSkillsAndSync = (model, runtime = "local") => {
+    const clearSkillsAndSync = (model) => {
         setCurrentSkills([]);
-        syncCursorSkillToolForModel(pi, model, runtime);
+        syncCursorSkillToolForModel(pi, model);
     };
     registerCursorModelLifecycle(pi, {
         sessionStart: (_event, ctx) => {
@@ -198,23 +192,19 @@ export function registerCursorSkillTool(pi) {
             clearSkillsAndSync(event.model);
         },
         turnStart: (_event, ctx) => {
-            const cursorModel = isCursorModel(ctx.model);
-            const runtime = resolveEffectiveRuntimeForSkillLifecycle(cursorModel, ctx);
-            if (!cursorModel || runtime === "cloud")
+            if (!isCursorModel(ctx.model))
                 setCurrentSkills([]);
-            syncCursorSkillToolForModel(pi, ctx.model, runtime);
+            syncCursorSkillToolForModel(pi, ctx.model);
         },
         beforeAgentStart: (event, ctx) => {
-            const cursorModel = isCursorModel(ctx.model);
-            const runtime = resolveEffectiveRuntimeForSkillLifecycle(cursorModel, ctx);
-            if (cursorModel && runtime === "local") {
+            if (isCursorModel(ctx.model)) {
                 setCurrentSkills(event.systemPromptOptions?.skills);
             }
             else {
                 setCurrentSkills([]);
             }
-            syncCursorSkillToolForModel(pi, ctx.model, runtime);
-            const resolved = resolveCursorSkillSystemPrompt(event.systemPrompt, ctx.model, event.systemPromptOptions, runtime);
+            syncCursorSkillToolForModel(pi, ctx.model);
+            const resolved = resolveCursorSkillSystemPrompt(event.systemPrompt, ctx.model, event.systemPromptOptions);
             if (resolved === event.systemPrompt)
                 return undefined;
             return { systemPrompt: resolved };

package/dist/cursor-state.js

@@ -10,7 +10,7 @@ import { getCursorSessionScopeKey } from "./cursor-session-scope.js";
 import { refreshSessionCursorAgentConfig } from "./cursor-session-agent.js";
 import { getCursorModelMetadata } from "./model-discovery.js";
 import { buildCursorBridgeExcludeToolNames, cursorFastDefaultsFromConfig, getCursorSdkUserConfigPath, loadCursorSdkUserConfig, mergeCursorSdkConfigForUpdate, resolveCursorFastDefault, updateCursorSdkConfig, } from "./cursor-config.js";
-import { CURSOR_RUNTIME_ENTRY_TYPE, formatCursorStatus, registerCursorCloudRuntimeControls, resetCursorRuntimeStateForTests, resolveCursorStatusRuntime, resolveEffectiveCursorConfigForContext, restoreCursorCliState, restoreSessionCursorRuntimeState, } from "./cursor-runtime-state.js";
+import { formatCursorStatus, registerCursorLocalRuntimeFlags, resetCursorRuntimeStateForTests, resolveCursorStatusRuntime, resolveEffectiveCursorConfigForContext, restoreCursorCliState, } from "./cursor-runtime-state.js";
 export { consumeCursorLocalForceOverride, getCursorCliConfig, getCursorSessionConfig, } from "./cursor-runtime-state.js";
 const FAST_ENTRY_TYPE = "cursor-fast-state";
 const MODE_ENTRY_TYPE = "cursor-mode-state";
@@ -88,7 +88,6 @@ function restoreSessionCursorMode(branch) {
 }
 function restoreSessionCursorPreferences(ctx) {
     const branch = ctx.sessionManager.getBranch();
-    restoreSessionCursorRuntimeState(branch);
     restoreSessionFastPreferences(branch);
     restoreSessionCursorMode(branch);
     restoreSessionCursorHttp1(branch);
@@ -160,12 +159,11 @@ function updateCursorStatus(ctx, model = ctx.model) {
     const modeResolution = resolveCursorAgentMode();
     const mode = modeResolution.kind === "invalid" ? "invalid" : modeResolution.mode;
     if (resolution.kind === "invalid") {
-        ctx.ui.setStatus("cursor", formatCursorStatus("invalid", undefined, mode));
+        ctx.ui.setStatus("cursor", formatCursorStatus(undefined, "invalid"));
         return;
     }
-    const runtime = resolution.runtime.value;
-    const fast = runtime === "cloud" ? undefined : metadata?.supportsFast ? getEffectiveFast(model.id) : undefined;
-    ctx.ui.setStatus("cursor", formatCursorStatus(runtime, fast, mode, resolution.useHttp1ForAgent.value));
+    const fast = metadata?.supportsFast ? getEffectiveFast(model.id) : undefined;
+    ctx.ui.setStatus("cursor", formatCursorStatus(fast, mode, resolution.useHttp1ForAgent.value));
 }
 function getCurrentCursorMetadata(ctx) {
     const model = ctx.model;
@@ -307,7 +305,7 @@ export function getEffectiveFastForModelId(modelId) {
     return getEffectiveFast(modelId);
 }
 export function registerCursorRuntimeControls(pi) {
-    registerCursorCloudRuntimeControls(pi, { refreshStatus: updateCursorStatus });
+    registerCursorLocalRuntimeFlags(pi);
     pi.registerFlag("cursor-fast", {
         description: "Force Cursor fast mode for this run when the selected Cursor model supports it",
         type: "boolean",
@@ -517,7 +515,6 @@ export const __testUtils = {
     FAST_ENTRY_TYPE,
     MODE_ENTRY_TYPE,
     CURSOR_HTTP1_ENTRY_TYPE,
-    RUNTIME_ENTRY_TYPE: CURSOR_RUNTIME_ENTRY_TYPE,
     DEFAULT_CURSOR_AGENT_MODE,
     getConfigPath,
     loadGlobalFastPreferences,

package/dist/cursor-usage-accounting.js

@@ -150,7 +150,7 @@ function applyResolvedCursorOccupancy(partial, model, context, localTurn) {
 }
 export function applyCursorUsage(partial, model, context, sessionInputTokens, sdkUsage) {
     const billed = sdkUsage?.billed;
-    const localTurn = sdkUsage?.runtime === "local" ? sdkUsage.turn : undefined;
+    const localTurn = sdkUsage?.turn;
     if (billed && isCursorSdkUsagePartitionSafe(billed, model)) {
         applyCursorSdkUsage(partial, billed);
         applyResolvedCursorOccupancy(partial, model, context, localTurn);