pi-cursor-sdk 0.4.0 → 0.5.0

package/dist/cursor-runtime-state.js

@@ -2,7 +2,8 @@ import { registerCursorCloudLifecycleLedger, runCursorCloudLifecycleCommand, } f
 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 { getResolvedSessionCursorHttp1Enabled } from "./cursor-http1.js";
-import { getCursorSessionCwd, getCursorSessionProjectTrusted } from "./cursor-session-scope.js";
+import { getCursorSessionScopeSnapshot } from "./cursor-session-scope.js";
+import { cursorSettingsScopeForContext, getCursorSessionSettings } from "./cursor-session-settings.js";
 export const CURSOR_RUNTIME_ENTRY_TYPE = "cursor-runtime-state";
 export const CURSOR_CLOUD_ACK_DISCLOSURE = [
     "Cursor Cloud executes this work remotely.",
@@ -12,11 +13,7 @@ export const CURSOR_CLOUD_ACK_DISCLOSURE = [
     "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)
@@ -27,15 +24,17 @@ function isCursorRuntimeEntryData(value) {
 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");
+export function getCursorCliConfig(scopeKey) {
+    const cli = getCursorSessionSettings(scopeKey).cli;
+    const config = structuredClone(cli.config);
+    const envNames = parseExplicitCursorCloudEnvNames(cli.cloudEnvNames, "--cursor-cloud-env");
     if (envNames)
         config.cloud = { ...config.cloud, envNames };
     return config;
 }
-export function getCursorSessionConfig() {
-    const useHttp1ForAgent = getResolvedSessionCursorHttp1Enabled();
+export function getCursorSessionConfig(scopeKey) {
+    const { runtime: sessionCursorRuntime, cloudAcknowledged: sessionCursorCloudAcknowledged } = getCursorSessionSettings(scopeKey);
+    const useHttp1ForAgent = getResolvedSessionCursorHttp1Enabled(scopeKey);
     return {
         ...(sessionCursorRuntime
             ? {
@@ -49,8 +48,8 @@ export function getCursorSessionConfig() {
 export function resolveEffectiveCursorConfig(options) {
     const loadedConfig = loadCursorSdkConfig({ cwd: options.cwd, projectTrusted: options.projectTrusted === true });
     return resolveCursorSdkConfig({
-        cli: getCursorCliConfig(),
-        session: getCursorSessionConfig(),
+        cli: getCursorCliConfig(options.scopeKey),
+        session: getCursorSessionConfig(options.scopeKey),
         user: loadedConfig.user,
         project: loadedConfig.project,
     });
@@ -58,7 +57,10 @@ export function resolveEffectiveCursorConfig(options) {
 export function resolveEffectiveCursorConfigForContext(ctx) {
     return resolveEffectiveCursorConfig({
         cwd: ctx.cwd,
-        projectTrusted: getCursorSessionCwd() === ctx.cwd && getCursorSessionProjectTrusted(),
+        projectTrusted: cursorSettingsScopeForContext(ctx) === undefined
+            ? getCursorSessionScopeSnapshot().cwd === ctx.cwd && getCursorSessionScopeSnapshot().projectTrusted
+            : getCursorSessionSettings(cursorSettingsScopeForContext(ctx)).projectTrusted,
+        scopeKey: cursorSettingsScopeForContext(ctx),
     });
 }
 export function resolveCursorStatusRuntime(ctx) {
@@ -90,15 +92,16 @@ export function formatCursorStatus(runtime, fast, mode, useHttp1ForAgent = false
         parts.push("plan");
     return parts.join(" · ");
 }
-export function consumeCursorLocalForceOverride(resolved) {
+export function consumeCursorLocalForceOverride(resolved, scopeKey) {
     if (!resolved.value)
         return false;
-    if (resolved.source === "cli" && !cliLocalForceConsumed) {
-        if (cliCursorSnapshot.config.local) {
-            const { force: _, ...local } = cliCursorSnapshot.config.local;
-            cliCursorSnapshot.config.local = local;
+    const cli = getCursorSessionSettings(scopeKey).cli;
+    if (resolved.source === "cli" && !cli.localForceConsumed) {
+        if (cli.config.local) {
+            const { force: _, ...local } = cli.config.local;
+            cli.config.local = local;
         }
-        cliLocalForceConsumed = true;
+        cli.localForceConsumed = true;
         return true;
     }
     if (resolved.source === "environment" && !envLocalForceConsumed) {
@@ -107,19 +110,21 @@ export function consumeCursorLocalForceOverride(resolved) {
     }
     return false;
 }
-export function restoreSessionCursorRuntimeState(branch) {
-    sessionCursorRuntime = undefined;
-    sessionCursorCloudAcknowledged = false;
+export function restoreSessionCursorRuntimeState(branch, scopeKey) {
+    const state = getCursorSessionSettings(scopeKey);
+    state.runtime = undefined;
+    state.cloudAcknowledged = 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;
+            state.runtime = entry.data.runtime;
+            state.cloudAcknowledged ||= entry.data.cloudAcknowledged === true;
         }
     }
 }
-export function restoreCursorCliState(pi) {
+export function restoreCursorCliState(pi, scopeKey) {
+    const cli = getCursorSessionSettings(scopeKey).cli;
     const runtime = stringFlagValue(pi.getFlag("cursor-runtime"));
     const repo = stringFlagValue(pi.getFlag("cursor-cloud-repo"));
     const branch = stringFlagValue(pi.getFlag("cursor-cloud-branch"));
@@ -144,30 +149,29 @@ export function restoreCursorCliState(pi) {
     const local = {
         ...(pi.getFlag("cursor-auto-review") === true ? { autoReview: true } : {}),
         ...(pi.getFlag("cursor-sandbox") === true ? { sandboxOptions: { enabled: true } } : {}),
-        ...(!cliLocalForceConsumed && pi.getFlag("cursor-local-force") === true ? { force: true } : {}),
+        ...(!cli.localForceConsumed && pi.getFlag("cursor-local-force") === true ? { force: true } : {}),
         ...(pi.getFlag("cursor-no-local-resume") === true
             ? { resume: false }
             : pi.getFlag("cursor-local-resume") === true
                 ? { resume: true }
                 : {}),
     };
-    cliCursorSnapshot = {
-        config: {
-            ...(runtime ? { runtime } : {}),
-            ...(Object.keys(cloud).length ? { cloud } : {}),
-            ...(Object.keys(local).length ? { local } : {}),
-        },
-        ...(cloudEnvNames ? { cloudEnvNames } : {}),
+    cli.config = {
+        ...(runtime ? { runtime } : {}),
+        ...(Object.keys(cloud).length ? { cloud } : {}),
+        ...(Object.keys(local).length ? { local } : {}),
     };
+    cli.cloudEnvNames = cloudEnvNames;
 }
-function persistCursorRuntimePreference(pi, runtime, cloudAcknowledged = false) {
-    const acknowledged = sessionCursorCloudAcknowledged || cloudAcknowledged;
+function persistCursorRuntimePreference(pi, runtime, cloudAcknowledged, scopeKey) {
+    const state = getCursorSessionSettings(scopeKey);
+    const acknowledged = state.cloudAcknowledged || cloudAcknowledged;
     pi.appendEntry(CURSOR_RUNTIME_ENTRY_TYPE, {
         runtime,
         ...(acknowledged ? { cloudAcknowledged: true } : {}),
     });
-    sessionCursorRuntime = runtime;
-    sessionCursorCloudAcknowledged = acknowledged;
+    state.runtime = runtime;
+    state.cloudAcknowledged = acknowledged;
 }
 function registerCursorRuntimeFlags(pi) {
     pi.registerFlag("cursor-runtime", {
@@ -277,6 +281,7 @@ function registerCursorRuntimeCommand(pi, refreshStatus) {
     pi.registerCommand("cursor-runtime", {
         description: "Set Cursor runtime for this session: local or cloud",
         handler: async (args, ctx) => {
+            const scopeKey = cursorSettingsScopeForContext(ctx);
             const usage = "Usage: /cursor-runtime local|cloud [--save-user|--save-project]";
             const tokens = args.trim().split(/\s+/).filter(Boolean);
             const raw = tokens[0];
@@ -298,7 +303,7 @@ function registerCursorRuntimeCommand(pi, refreshStatus) {
                 ctx.ui.notify(`${currentResolution.message} Fix the explicit override before changing the session runtime.`, "error");
                 return;
             }
-            if (saveProject && (getCursorSessionCwd() !== ctx.cwd || !getCursorSessionProjectTrusted())) {
+            if (saveProject && (getCursorSessionScopeSnapshot(pi).cwd !== ctx.cwd || !getCursorSessionScopeSnapshot(pi).projectTrusted)) {
                 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;
             }
@@ -328,7 +333,7 @@ function registerCursorRuntimeCommand(pi, refreshStatus) {
                 }
             }
             try {
-                persistCursorRuntimePreference(pi, raw, cloudAcknowledged);
+                persistCursorRuntimePreference(pi, raw, cloudAcknowledged, scopeKey);
             }
             catch (error) {
                 const effectiveResolution = resolveCursorStatusRuntime(ctx);
@@ -372,9 +377,11 @@ export function registerCursorCloudRuntimeControls(pi, options) {
     });
 }
 export function resetCursorRuntimeStateForTests() {
-    cliCursorSnapshot = { config: {} };
-    cliLocalForceConsumed = false;
+    const cli = getCursorSessionSettings().cli;
+    cli.config = {};
+    cli.cloudEnvNames = undefined;
+    cli.localForceConsumed = false;
     envLocalForceConsumed = false;
-    sessionCursorRuntime = undefined;
-    sessionCursorCloudAcknowledged = false;
+    getCursorSessionSettings().runtime = undefined;
+    getCursorSessionSettings().cloudAcknowledged = false;
 }

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

@@ -1,86 +1,65 @@
-import { asRecord, getArray, getString } from "./cursor-record-utils.js";
-import { readCursorSdkTurnUsage } from "./cursor-usage-accounting.js";
-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-");
+import { asRecord } from "./cursor-record-utils.js";
+const fields = ["inputTokens", "outputTokens", "cacheReadTokens", "cacheWriteTokens", "totalTokens"];
+export function readCursorUsageTokens(value) {
+    const record = asRecord(value);
+    if (!record || fields.some(key => !Number.isSafeInteger(record[key]) || record[key] < 0))
+        return undefined;
+    if (record.reasoningTokens !== undefined && (!Number.isSafeInteger(record.reasoningTokens) || record.reasoningTokens < 0 || record.reasoningTokens > record.outputTokens))
+        return undefined;
+    return { inputTokens: record.inputTokens, outputTokens: record.outputTokens, cacheReadTokens: record.cacheReadTokens, cacheWriteTokens: record.cacheWriteTokens, totalTokens: record.totalTokens, ...(record.reasoningTokens === undefined ? {} : { reasoningTokens: record.reasoningTokens }) };
 }
-export function sumCursorSdkTurnUsage(usages) {
-    if (usages.length === 0)
+function readCost(value) {
+    const record = asRecord(value);
+    if (!record || ["rawCostCents", "chargedCents"].some(key => typeof record[key] !== "number" || !Number.isFinite(record[key]) || record[key] < 0))
         return undefined;
-    return usages.reduce((total, usage) => ({
-        inputTokens: total.inputTokens + usage.inputTokens,
-        outputTokens: total.outputTokens + usage.outputTokens,
-        cacheReadTokens: total.cacheReadTokens + usage.cacheReadTokens,
-        cacheWriteTokens: total.cacheWriteTokens + usage.cacheWriteTokens,
-    }));
+    return { rawCostCents: record.rawCostCents, chargedCents: record.chargedCents };
 }
-export function peekCursorBilledUsageRunIds(agentId) {
-    return seenBilledRunIdsByAgent.get(agentId) ?? new Set();
+function billedTokens(value) {
+    const usage = readCursorUsageTokens(value);
+    if (!usage || usage.totalTokens !== usage.inputTokens + usage.outputTokens + usage.cacheReadTokens + usage.cacheWriteTokens)
+        return undefined;
+    return usage;
 }
-export function rememberCursorBilledUsageRunIds(agentId, runIds) {
-    if (runIds.length === 0)
-        return;
-    let seen = seenBilledRunIdsByAgent.get(agentId);
-    if (!seen) {
-        seen = new Set();
-        seenBilledRunIdsByAgent.set(agentId, seen);
+export function readCursorBilledSnapshot(value) {
+    const record = asRecord(value);
+    const usage = billedTokens(record?.usage);
+    if (!record || !usage || !Array.isArray(record.runs))
+        return undefined;
+    const cost = record.cost === undefined ? undefined : readCost(record.cost);
+    if (record.cost !== undefined && !cost)
+        return undefined;
+    const runs = [];
+    const ids = new Set();
+    for (const item of record.runs) {
+        const row = asRecord(item);
+        const tokens = billedTokens(row?.usage);
+        const rowCost = row?.cost === undefined ? undefined : readCost(row.cost);
+        if (!row || typeof row.runId !== "string" || !row.runId || row.runId.length > 256 || ids.has(row.runId) || !tokens || (row.cost !== undefined && !rowCost))
+            return undefined;
+        ids.add(row.runId);
+        runs.push({ runId: row.runId, usage: tokens, ...(rowCost ? { cost: rowCost } : {}) });
     }
-    for (const runId of runIds)
-        seen.add(runId);
+    if (fields.some(key => runs.reduce((sum, row) => sum + row.usage[key], 0) > usage[key]))
+        return undefined;
+    return { usage, runs, ...(cost ? { cost } : {}) };
 }
-function withTimeout(promise, timeoutMs = BILLED_USAGE_TIMEOUT_MS) {
+/** Fetch is only observation; the origin journal owns recognition. No run-ID guesses or private fallback. */
+export async function fetchCursorSdkAgentUsage(agent) {
+    if (typeof agent.getUsage !== "function")
+        return { status: "unavailable", reason: "unsupported" };
     let timer;
-    const timeout = new Promise((resolve) => {
-        timer = setTimeout(() => resolve(undefined), timeoutMs);
-        timer.unref?.();
-    });
-    return Promise.race([promise.catch(() => undefined), timeout]).finally(() => {
+    try {
+        const timeout = new Promise(resolve => {
+            timer = setTimeout(() => resolve({ status: "unavailable", reason: "timeout" }), 5000);
+            timer.unref?.();
+        });
+        return await Promise.race([Promise.resolve().then(() => agent.getUsage()).then(value => {
+                const snapshot = readCursorBilledSnapshot(value);
+                return snapshot ? { status: "observed-pending-settlement", snapshot } : { status: "unavailable", reason: "invalid-response" };
+            }, () => ({ status: "unavailable", reason: "request-failed" })), timeout]);
+    }
+    finally {
         if (timer)
             clearTimeout(timer);
-    });
-}
-export function selectCursorBilledTurnUsage(agentUsage, options) {
-    const runs = (getArray(asRecord(agentUsage), "runs") ?? []).flatMap((item) => {
-        const record = asRecord(item);
-        const runId = getString(record, "runId");
-        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) {
-    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)));
-}
-export async function attachCursorSdkBilledTurnUsage(options) {
-    const agentUsage = await fetchCursorSdkAgentUsage(options.agent, {
-        runtime: options.runtime,
-        runId: options.runId,
-    });
-    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);
-    return { agentUsage, turn: selected.turn };
 }
-export const __testUtils = {
-    reset() {
-        seenBilledRunIdsByAgent.clear();
-    },
-};

package/dist/cursor-sdk-event-debug-session.js

@@ -2,7 +2,7 @@ import { createHash } from "node:crypto";
 import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { basename, join, resolve } from "node:path";
 import { CURSOR_SDK_EVENT_DEBUG_RUN_DIR_ENV, CURSOR_SDK_EVENT_DEBUG_SESSION_DIR_ENV, SESSION_MANIFEST, resolveCursorSdkEventDebugBaseDir, } from "./cursor-sdk-event-debug-constants.js";
-import { getCursorSessionFile, getCursorSessionScopeKey } from "./cursor-session-scope.js";
+import { getCursorSessionScopeSnapshot } from "./cursor-session-scope.js";
 const ANONYMOUS_SESSION_SCOPE_KEY = "__anonymous__";
 const sessionDebugStates = new Map();
 function sanitizePathSegment(value) {
@@ -46,12 +46,12 @@ function resolveSessionDebugDir(cwd, env, scopeKey) {
         return resolve(pinned);
     return join(resolveCursorSdkEventDebugBaseDir(cwd, env), "sessions", slugSessionKey(scopeKey));
 }
-export function allocateCursorSdkEventDebugTurn(cwd, env) {
+export function allocateCursorSdkEventDebugTurn(cwd, env, scope = getCursorSessionScopeSnapshot()) {
     const pinnedRunDir = resolvePinnedRunArtifactDir(env[CURSOR_SDK_EVENT_DEBUG_RUN_DIR_ENV]);
     if (pinnedRunDir) {
         return { artifactDir: pinnedRunDir, pinnedRun: true };
     }
-    const scopeKey = getCursorSessionScopeKey();
+    const scopeKey = scope.scopeKey;
     const sessionDir = resolveSessionDebugDir(cwd, env, scopeKey);
     mkdirSync(sessionDir, { recursive: true });
     let state = sessionDebugStates.get(scopeKey);
@@ -67,13 +67,13 @@ export function allocateCursorSdkEventDebugTurn(cwd, env) {
     const existing = readSessionManifest(sessionDir);
     const manifest = existing ?? {
         sessionKey: scopeKey,
-        sessionFile: getCursorSessionFile(),
+        sessionFile: scope.sessionFile,
         sessionDir,
         createdAt: new Date().toISOString(),
         updatedAt: new Date().toISOString(),
         turns: [],
     };
-    manifest.sessionFile = getCursorSessionFile();
+    manifest.sessionFile = scope.sessionFile;
     manifest.updatedAt = new Date().toISOString();
     manifest.turns.push({
         turn: state.turnCounter,
@@ -99,7 +99,6 @@ export function updateCursorSdkEventDebugSessionManifest(sessionDir, artifactDir
     turnEntry.finalizedAt = new Date().toISOString();
     turnEntry.summary = summary;
     manifest.updatedAt = new Date().toISOString();
-    manifest.sessionFile = getCursorSessionFile();
     writeSessionManifest(sessionDir, manifest);
 }
 export function resetCursorSdkEventDebugSessionStateForTests() {

package/dist/cursor-sdk-event-debug.js

@@ -3,7 +3,7 @@ import { copyFileSync, existsSync, unlinkSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { serializeCursorPiToolBridgeDiagnostic } from "./cursor-pi-tool-bridge-diagnostics.js";
 import { asRecord } from "./cursor-record-utils.js";
-import { getCursorSessionFile } from "./cursor-session-scope.js";
+import { getCursorSessionScopeSnapshot } from "./cursor-session-scope.js";
 import { parseEnvBoolean } from "./cursor-env-boolean.js";
 import { ARTIFACTS, CURSOR_SDK_EVENT_DEBUG_ENV, CURSOR_SDK_EVENT_DEBUG_LOG_PREFIX, CURSOR_SDK_EVENT_DEBUG_STDERR_ENV, SESSION_MANIFEST, SESSION_PI_SESSION_SNAPSHOT, } from "./cursor-sdk-event-debug-constants.js";
 import { allocateCursorSdkEventDebugTurn, resetCursorSdkEventDebugSessionStateForTests, slugSessionKey, updateCursorSdkEventDebugSessionManifest, } from "./cursor-sdk-event-debug-session.js";
@@ -122,6 +122,7 @@ export class CursorSdkEventDebugSink {
         timeline: {},
         errors: 0,
     };
+    sessionFile;
     metadata;
     jsonlBuffers = new Map();
     jsonlBufferBytes = new Map();
@@ -135,8 +136,9 @@ export class CursorSdkEventDebugSink {
         const env = options.env ?? process.env;
         if (!resolveCursorSdkEventDebugEnabled(env))
             return undefined;
-        const allocation = allocateCursorSdkEventDebugTurn(options.cwd, env);
-        return new CursorSdkEventDebugSink(allocation, options, env);
+        const scope = options.scope ?? getCursorSessionScopeSnapshot();
+        const allocation = allocateCursorSdkEventDebugTurn(options.cwd, env, scope);
+        return new CursorSdkEventDebugSink(allocation, { ...options, scope }, env);
     }
     constructor(allocation, options, env) {
         this.artifactDir = allocation.artifactDir;
@@ -145,6 +147,7 @@ export class CursorSdkEventDebugSink {
         this.sessionKey = allocation.sessionKey;
         this.pinnedRun = allocation.pinnedRun;
         this.env = env;
+        this.sessionFile = options.scope?.sessionFile;
         this.metadata = {
             capturedAt: new Date().toISOString(),
             modelId: options.modelId,
@@ -152,7 +155,7 @@ export class CursorSdkEventDebugSink {
             cwd: options.cwd,
             sessionDir: allocation.sessionDir,
             sessionKey: allocation.sessionKey,
-            sessionFile: getCursorSessionFile(),
+            sessionFile: this.sessionFile,
             turn: allocation.turn,
             pinnedRun: allocation.pinnedRun,
             artifacts: ARTIFACTS,
@@ -285,7 +288,7 @@ export class CursorSdkEventDebugSink {
         writeFileSync(join(this.artifactDir, ARTIFACTS.waitResult), `${JSON.stringify(result, null, 2)}\n`);
     }
     capturePiSessionSnapshot() {
-        const sessionFile = getCursorSessionFile();
+        const sessionFile = this.sessionFile;
         if (!sessionFile) {
             return { copied: false, reason: "session file unknown" };
         }
@@ -342,7 +345,7 @@ export class CursorSdkEventDebugSink {
             artifactDir: this.artifactDir,
             sessionDir: this.sessionDir,
             sessionKey: this.sessionKey,
-            sessionFile: getCursorSessionFile(),
+            sessionFile: this.sessionFile,
             turn: this.turn,
             elapsedMs: Date.now() - this.startedAt,
             counts: {

package/dist/cursor-sdk-process-error-guard.js

@@ -4,7 +4,7 @@ import { classifyCursorConnectError, isCursorSdkAbortConnectError, isCursorSdkCo
 // ConnectRPC suppression remains scoped to active provider turns.
 const activeProviderTurns = new Set();
 const activeSessions = new Set();
-let activeLifecycleSessionGuard;
+const lifecycleSessionGuards = new Map();
 let originalProcessEmit;
 let cursorProcessEmit;
 let bunUnhandledRejectionListenerInstalled = false;
@@ -125,8 +125,9 @@ export const __testUtils = {
     activeProviderTurnCount: () => activeProviderTurns.size,
     activeSessionCount: () => activeSessions.size,
     resetLifecycleSessionGuard() {
-        activeLifecycleSessionGuard?.dispose();
-        activeLifecycleSessionGuard = undefined;
+        for (const guard of lifecycleSessionGuards.values())
+            guard.dispose();
+        lifecycleSessionGuards.clear();
     },
 };
 export { isCursorSdkAbortConnectError };
@@ -167,11 +168,11 @@ export function installCursorSdkSessionProcessErrorGuard() {
 }
 export function registerCursorSdkSessionProcessErrorGuard(pi) {
     pi.on("session_start", () => {
-        activeLifecycleSessionGuard?.dispose();
-        activeLifecycleSessionGuard = installCursorSdkSessionProcessErrorGuard();
+        lifecycleSessionGuards.get(pi)?.dispose();
+        lifecycleSessionGuards.set(pi, installCursorSdkSessionProcessErrorGuard());
     });
     pi.on("session_shutdown", () => {
-        activeLifecycleSessionGuard?.dispose();
-        activeLifecycleSessionGuard = undefined;
+        lifecycleSessionGuards.get(pi)?.dispose();
+        lifecycleSessionGuards.delete(pi);
     });
 }

package/dist/cursor-sdk-runtime.js

@@ -1,3 +1,16 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { resolveCursorSdkPlatformPackageDirectory } from "./cursor-ripgrep-path.js";
 export async function loadCursorSdk() {
+    // The SDK searches launcher ancestors, which miss Pi's separately installed extension packages.
+    if (process.env.CURSOR_TREE_SITTER_VENDOR_DIR === undefined) {
+        const packageDirectory = resolveCursorSdkPlatformPackageDirectory();
+        if (packageDirectory) {
+            const vendor = join(packageDirectory, "vendor");
+            if (existsSync(join(vendor, "tree-sitter", "index.js")) && existsSync(join(vendor, "tree-sitter-bash", "index.js"))) {
+                process.env.CURSOR_TREE_SITTER_VENDOR_DIR = vendor;
+            }
+        }
+    }
     return import("@cursor/sdk");
 }

package/dist/cursor-session-agent-cleanup.js

@@ -2,7 +2,7 @@ import { asRecord, getString } from "./cursor-record-utils.js";
 import { fsyncExistingRegularFile } from "./cursor-durable-fs.js";
 import { scrubSensitiveText } from "./cursor-sensitive-text.js";
 import { loadCursorSdk } from "./cursor-sdk-runtime.js";
-import { getCursorSessionScopeKey } from "./cursor-session-scope.js";
+import { cursorSessionScopeKeyForManager } from "./cursor-session-scope.js";
 import { CURSOR_SESSION_AGENT_RESUME_ENTRY_TYPE, isCursorLocalAgentId, parseCursorSessionAgentResumeEntryData, readResumableCursorSessionAgentIds, resolveCursorSessionRepoRoot, } from "./cursor-session-agent-resume.js";
 import { cursorSessionStoreIdentitiesEqual, getCursorSessionStoreIdentities, openCursorSessionStore, } from "./cursor-session-store.js";
 export const CURSOR_SESSION_AGENT_CLEANUP_ENTRY_TYPE = "cursor-sdk-agent-cleanup";
@@ -41,7 +41,7 @@ function getCurrentCleanupScope(ctx) {
     const sessionId = ctx.sessionManager.getSessionId();
     const repoRoot = resolveCursorSessionRepoRoot(ctx.cwd);
     return {
-        scopeKey: getCursorSessionScopeKey(),
+        scopeKey: cursorSessionScopeKeyForManager(ctx.sessionManager),
         ...(sessionFile ? { sessionFile } : {}),
         ...(sessionId ? { sessionId } : {}),
         cwd: ctx.cwd,

package/dist/cursor-session-agent-lifecycle.js

@@ -1,32 +1,41 @@
 import { clearCursorSdkHttp1 } from "./cursor-http1.js";
-import { onCursorSessionScopeKeyChange } from "./cursor-session-scope.js";
+import { cursorSessionScopeKeyForManager, hasLiveCursorSessions, onCursorSessionScopeKeyChange } from "./cursor-session-scope.js";
 import { disposeSessionCursorAgent, invalidateSessionAgent, resetSessionCursorAgent, } from "./cursor-session-agent.js";
 export function registerCursorSessionAgentLifecycle(pi) {
-    onCursorSessionScopeKeyChange(async (previousScopeKey) => {
+    let scopeKey;
+    pi.on("session_start", (_event, ctx) => { scopeKey = cursorSessionScopeKeyForManager(ctx.sessionManager); });
+    onCursorSessionScopeKeyChange(pi, async (previousScopeKey) => {
         await disposeSessionCursorAgent(previousScopeKey);
     });
     pi.on("session_shutdown", async (event) => {
         try {
+            if (scopeKey === undefined)
+                return;
             if (event.reason === "reload") {
-                await resetSessionCursorAgent();
+                await resetSessionCursorAgent(scopeKey);
                 return;
             }
-            await disposeSessionCursorAgent();
+            await disposeSessionCursorAgent(scopeKey);
         }
         finally {
-            clearCursorSdkHttp1();
+            if (!hasLiveCursorSessions())
+                clearCursorSdkHttp1();
         }
     });
     pi.on("session_compact", () => {
-        invalidateSessionAgent();
+        if (scopeKey !== undefined)
+            invalidateSessionAgent(scopeKey);
     });
     pi.on("session_before_tree", () => {
-        invalidateSessionAgent();
+        if (scopeKey !== undefined)
+            invalidateSessionAgent(scopeKey);
     });
     pi.on("session_tree", async () => {
-        await resetSessionCursorAgent();
+        if (scopeKey !== undefined)
+            await resetSessionCursorAgent(scopeKey);
     });
     pi.on("model_select", () => {
-        invalidateSessionAgent();
+        if (scopeKey !== undefined)
+            invalidateSessionAgent(scopeKey);
     });
 }