pi-cursor-sdk 0.4.0 → 0.5.0

package/dist/cursor-skill-tool.js

@@ -11,7 +11,6 @@ export const CURSOR_ACTIVATE_SKILL_MCP_NAME = "pi__cursor_activate_skill";
 const AVAILABLE_SKILLS_SECTION_PATTERN = /<skills>\nThe following skills provide specialized instructions for specific tasks\.[\s\S]*?<\/available_skills>\n<\/skills>|\n\nThe following skills provide specialized instructions for specific tasks\.[\s\S]*?<\/available_skills>/;
 const MAX_SKILL_RESOURCES = 80;
 const RESOURCE_DIR_NAMES = ["scripts", "references", "assets"];
-let currentSkillsByName = new Map();
 function escapeXml(value) {
     return value
         .replace(/&/g, "&amp;")
@@ -23,32 +22,9 @@ function escapeXml(value) {
 function getVisibleSkills(skills) {
     return (skills ?? []).filter((skill) => !skill.disableModelInvocation);
 }
-function setCurrentSkills(skills) {
-    currentSkillsByName = new Map(getVisibleSkills(skills).map((skill) => [skill.name, skill]));
-}
-function getAvailableSkillNames() {
-    return [...currentSkillsByName.keys()].sort();
-}
 function resolveEffectiveRuntimeForSkillLifecycle(cursorModel, ctx) {
     return cursorModel ? resolveEffectiveCursorConfigForContext(ctx).runtime.value : "local";
 }
-function shouldExposeSkillTool(model, runtime) {
-    return runtime === "local" && isCursorModel(model) && resolveCursorPiToolBridgeEnabled() && currentSkillsByName.size > 0;
-}
-function syncCursorSkillToolForModel(pi, model, runtime) {
-    const activeToolNames = new Set(pi.getActiveTools());
-    const shouldBeActive = !arePiToolsDisabled(pi) && shouldExposeSkillTool(model, runtime);
-    const alreadyActive = activeToolNames.has(CURSOR_ACTIVATE_SKILL_TOOL_NAME);
-    if (shouldBeActive === alreadyActive)
-        return;
-    if (shouldBeActive) {
-        activeToolNames.add(CURSOR_ACTIVATE_SKILL_TOOL_NAME);
-    }
-    else {
-        activeToolNames.delete(CURSOR_ACTIVATE_SKILL_TOOL_NAME);
-    }
-    pi.setActiveTools([...activeToolNames]);
-}
 export function formatCursorSkillsForPrompt(skills) {
     const visibleSkills = getVisibleSkills(skills);
     if (visibleSkills.length === 0)
@@ -119,15 +95,6 @@ async function listSkillResourcePaths(baseDir) {
     }
     return resources;
 }
-function buildActivationDetails(skill, resources = []) {
-    return {
-        name: skill?.name,
-        filePath: skill?.filePath,
-        baseDir: skill ? dirname(skill.filePath) : undefined,
-        resources,
-        availableSkillNames: getAvailableSkillNames(),
-    };
-}
 function formatSkillResources(resources) {
     if (resources.length === 0)
         return "<skill_resources />";
@@ -150,18 +117,35 @@ function wrapSkillContent(skill, content, resources) {
     ].join("\n");
 }
 export function registerCursorSkillTool(pi) {
+    let currentSkillsByName = new Map();
+    function setCurrentSkills(skills) {
+        currentSkillsByName = new Map(getVisibleSkills(skills).map((skill) => [skill.name, skill]));
+    }
+    function getAvailableSkillNames() {
+        return [...currentSkillsByName.keys()].sort();
+    }
+    function syncCursorSkillToolForModel(model, runtime) {
+        const activeToolNames = new Set(pi.getActiveTools());
+        const shouldBeActive = !arePiToolsDisabled(pi) && runtime === "local" && isCursorModel(model)
+            && resolveCursorPiToolBridgeEnabled() && currentSkillsByName.size > 0;
+        const alreadyActive = activeToolNames.has(CURSOR_ACTIVATE_SKILL_TOOL_NAME);
+        if (shouldBeActive === alreadyActive)
+            return;
+        if (shouldBeActive) {
+            activeToolNames.add(CURSOR_ACTIVATE_SKILL_TOOL_NAME);
+        }
+        else {
+            activeToolNames.delete(CURSOR_ACTIVATE_SKILL_TOOL_NAME);
+        }
+        pi.setActiveTools([...activeToolNames]);
+    }
     pi.registerTool({
         name: CURSOR_ACTIVATE_SKILL_TOOL_NAME,
         label: "Cursor skill",
         description: "Load full pi Agent Skill instructions for Cursor. Use with a skill name from the current <available_skills> catalog before applying that skill.",
-        promptSnippet: "Load full pi Agent Skill instructions for a listed skill before Cursor applies that skill",
         parameters: Type.Object({
             name: Type.String({ description: "Skill name from the current <available_skills> catalog" }),
         }),
-        promptGuidelines: [
-            `Use ${CURSOR_ACTIVATE_SKILL_TOOL_NAME} only for skill names listed in the current <available_skills> catalog.`,
-            "After loading a skill, follow its instructions and resolve relative skill paths against the returned skill directory.",
-        ],
         async execute(_toolCallId, params) {
             const requestedName = params.name?.trim();
             if (!requestedName) {
@@ -178,7 +162,13 @@ export function registerCursorSkillTool(pi) {
                 ]);
                 return {
                     content: [{ type: "text", text: wrapSkillContent(skill, content, resources) }],
-                    details: buildActivationDetails(skill, resources),
+                    details: {
+                        name: skill.name,
+                        filePath: skill.filePath,
+                        baseDir: dirname(skill.filePath),
+                        resources,
+                        availableSkillNames: getAvailableSkillNames(),
+                    },
                 };
             }
             catch (error) {
@@ -188,7 +178,7 @@ export function registerCursorSkillTool(pi) {
     });
     const clearSkillsAndSync = (model, runtime = "local") => {
         setCurrentSkills([]);
-        syncCursorSkillToolForModel(pi, model, runtime);
+        syncCursorSkillToolForModel(model, runtime);
     };
     registerCursorModelLifecycle(pi, {
         sessionStart: (_event, ctx) => {
@@ -202,7 +192,7 @@ export function registerCursorSkillTool(pi) {
             const runtime = resolveEffectiveRuntimeForSkillLifecycle(cursorModel, ctx);
             if (!cursorModel || runtime === "cloud")
                 setCurrentSkills([]);
-            syncCursorSkillToolForModel(pi, ctx.model, runtime);
+            syncCursorSkillToolForModel(ctx.model, runtime);
         },
         beforeAgentStart: (event, ctx) => {
             const cursorModel = isCursorModel(ctx.model);
@@ -213,7 +203,7 @@ export function registerCursorSkillTool(pi) {
             else {
                 setCurrentSkills([]);
             }
-            syncCursorSkillToolForModel(pi, ctx.model, runtime);
+            syncCursorSkillToolForModel(ctx.model, runtime);
             const resolved = resolveCursorSkillSystemPrompt(event.systemPrompt, ctx.model, event.systemPromptOptions, runtime);
             if (resolved === event.systemPrompt)
                 return undefined;
@@ -221,10 +211,3 @@ export function registerCursorSkillTool(pi) {
         },
     });
 }
-export const __testUtils = {
-    AVAILABLE_SKILLS_SECTION_PATTERN,
-    buildActivationDetails,
-    setCurrentSkills,
-    listSkillResourcePaths,
-    wrapSkillContent,
-};

package/dist/cursor-state.js

@@ -6,7 +6,8 @@ import { CURSOR_SETTING_SOURCES_ENV, DEFAULT_CURSOR_SETTING_SOURCES, resolveCurs
 import { isCursorModel } from "./cursor-model.js";
 import { registerCursorModelLifecycle } from "./cursor-model-lifecycle.js";
 import { asRecord } from "./cursor-record-utils.js";
-import { getCursorSessionScopeKey } from "./cursor-session-scope.js";
+import { getCursorSessionScopeSnapshot, getCursorSessionScopeKey } from "./cursor-session-scope.js";
+import { cursorSettingsScopeForContext, getCursorSessionSettings, registerCursorSessionSettings, resetCursorSessionSettingsForTests } from "./cursor-session-settings.js";
 import { refreshSessionCursorAgentConfig } from "./cursor-session-agent.js";
 import { getCursorModelMetadata } from "./model-discovery.js";
 import { cursorFastDefaultsFromConfig, getCursorSdkUserConfigPath, loadCursorSdkUserConfig, mergeCursorSdkConfigForUpdate, resolveCursorFastDefault, updateCursorSdkConfig, } from "./cursor-config.js";
@@ -15,13 +16,8 @@ export { consumeCursorLocalForceOverride, getCursorCliConfig, getCursorSessionCo
 const FAST_ENTRY_TYPE = "cursor-fast-state";
 const MODE_ENTRY_TYPE = "cursor-mode-state";
 const DEFAULT_CURSOR_AGENT_MODE = "agent";
-const sessionFastPreferences = new Map();
 const authoritativeGlobalFastPreferenceIds = new Set();
 let globalFastPreferences = new Map();
-let cliForceFast = false;
-let cliForceNoFast = false;
-let sessionCursorAgentMode;
-let cliCursorModeState = { kind: "unset" };
 const invalidCursorModeNotifiedSessionScopeKeys = new Set();
 export function isCursorAgentMode(value) {
     return value === "agent" || value === "plan";
@@ -64,7 +60,8 @@ function saveGlobalCursorHttp1Enabled(enabled) {
         local: { useHttp1ForAgent: enabled },
     }), { newFileMode: 0o600 });
 }
-function restoreSessionFastPreferences(branch) {
+function restoreSessionFastPreferences(branch, scopeKey) {
+    const sessionFastPreferences = getCursorSessionSettings(scopeKey).fast;
     sessionFastPreferences.clear();
     for (const entry of branch) {
         if (entry.type !== "custom" || entry.customType !== FAST_ENTRY_TYPE)
@@ -76,30 +73,32 @@ function restoreSessionFastPreferences(branch) {
         }
     }
 }
-function restoreSessionCursorMode(branch) {
-    sessionCursorAgentMode = undefined;
+function restoreSessionCursorMode(branch, scopeKey) {
+    const state = getCursorSessionSettings(scopeKey);
+    state.mode = undefined;
     for (const entry of branch) {
         if (entry.type !== "custom" || entry.customType !== MODE_ENTRY_TYPE)
             continue;
         if (isCursorModeEntryData(entry.data)) {
-            sessionCursorAgentMode = entry.data.mode;
+            state.mode = entry.data.mode;
         }
     }
 }
 function restoreSessionCursorPreferences(ctx) {
     const branch = ctx.sessionManager.getBranch();
-    restoreSessionCursorRuntimeState(branch);
-    restoreSessionFastPreferences(branch);
-    restoreSessionCursorMode(branch);
-    restoreSessionCursorHttp1(branch);
-}
-function restoreSessionCursorHttp1(branch) {
-    setStoredCursorHttp1Enabled(undefined);
+    const scopeKey = cursorSettingsScopeForContext(ctx);
+    restoreSessionCursorRuntimeState(branch, scopeKey);
+    restoreSessionFastPreferences(branch, scopeKey);
+    restoreSessionCursorMode(branch, scopeKey);
+    restoreSessionCursorHttp1(branch, scopeKey);
+}
+function restoreSessionCursorHttp1(branch, scopeKey) {
+    setStoredCursorHttp1Enabled(undefined, scopeKey);
     for (const entry of branch) {
         if (entry.type !== "custom" || entry.customType !== CURSOR_HTTP1_ENTRY_TYPE)
             continue;
         if (isCursorHttp1EntryData(entry.data)) {
-            setStoredCursorHttp1Enabled(entry.data.enabled);
+            setStoredCursorHttp1Enabled(entry.data.enabled, scopeKey);
         }
     }
 }
@@ -113,7 +112,8 @@ function getMapFastPreference(map, metadata) {
     const preferenceModelId = getFastPreferenceModelId(metadata);
     return map.get(preferenceModelId) ?? (preferenceModelId !== metadata.baseModelId ? map.get(metadata.baseModelId) : undefined);
 }
-function getEffectiveFast(modelId) {
+function getEffectiveFast(modelId, scopeKey) {
+    const { forceNoFast: cliForceNoFast, forceFast: cliForceFast } = getCursorSessionSettings(scopeKey).cli;
     const metadata = getCursorModelMetadata(modelId);
     if (!metadata?.supportsFast)
         return undefined;
@@ -123,7 +123,7 @@ function getEffectiveFast(modelId) {
         aliasOverride: metadata.fastOverride,
         sessionValue: authoritativeGlobalFastPreferenceIds.has(getFastPreferenceModelId(metadata))
             ? undefined
-            : getMapFastPreference(sessionFastPreferences, metadata),
+            : getMapFastPreference(getCursorSessionSettings(scopeKey).fast, metadata),
         userValue: getMapFastPreference(globalFastPreferences, metadata),
         modelDefault: metadata.defaultFast,
     }).value;
@@ -131,21 +131,22 @@ function getEffectiveFast(modelId) {
 function formatInvalidCursorMode(raw) {
     return `Invalid --cursor-mode "${raw}". Use "agent" or "plan".`;
 }
-export function getStoredCursorAgentMode() {
-    return sessionCursorAgentMode ?? DEFAULT_CURSOR_AGENT_MODE;
+export function getStoredCursorAgentMode(scopeKey) {
+    return getCursorSessionSettings(scopeKey).mode ?? DEFAULT_CURSOR_AGENT_MODE;
 }
-export function resolveCursorAgentMode() {
+export function resolveCursorAgentMode(scopeKey) {
+    const cliCursorModeState = getCursorSessionSettings(scopeKey).cli.mode;
     switch (cliCursorModeState.kind) {
         case "valid":
             return { kind: "valid", mode: cliCursorModeState.mode };
         case "invalid":
             return { kind: "invalid", raw: cliCursorModeState.raw, message: cliCursorModeState.message };
         case "unset":
-            return { kind: "valid", mode: getStoredCursorAgentMode() };
+            return { kind: "valid", mode: getStoredCursorAgentMode(scopeKey) };
     }
 }
-export function getCursorProviderAgentModeOrThrow() {
-    const resolution = resolveCursorAgentMode();
+export function getCursorProviderAgentModeOrThrow(scopeKey) {
+    const resolution = resolveCursorAgentMode(scopeKey);
     if (resolution.kind === "invalid")
         throw new Error(resolution.message);
     return resolution.mode;
@@ -157,14 +158,14 @@ function updateCursorStatus(ctx, model = ctx.model) {
     }
     const metadata = getCursorModelMetadata(model.id);
     const resolution = resolveCursorStatusRuntime(ctx);
-    const modeResolution = resolveCursorAgentMode();
+    const modeResolution = resolveCursorAgentMode(cursorSettingsScopeForContext(ctx));
     const mode = modeResolution.kind === "invalid" ? "invalid" : modeResolution.mode;
     if (resolution.kind === "invalid") {
         ctx.ui.setStatus("cursor", formatCursorStatus("invalid", undefined, mode));
         return;
     }
     const runtime = resolution.runtime.value;
-    const fast = runtime === "cloud" ? undefined : metadata?.supportsFast ? getEffectiveFast(model.id) : undefined;
+    const fast = runtime === "cloud" ? undefined : metadata?.supportsFast ? getEffectiveFast(model.id, cursorSettingsScopeForContext(ctx)) : undefined;
     ctx.ui.setStatus("cursor", formatCursorStatus(runtime, fast, mode, resolution.useHttp1ForAgent.value));
 }
 function getCurrentCursorMetadata(ctx) {
@@ -181,7 +182,8 @@ function restoreMapValue(map, key, previous) {
         map.set(key, previous);
     }
 }
-function persistFastPreference(pi, modelId, fast) {
+function persistFastPreference(pi, modelId, fast, scopeKey) {
+    const sessionFastPreferences = getCursorSessionSettings(scopeKey).fast;
     const previousSession = sessionFastPreferences.get(modelId);
     const previousGlobal = globalFastPreferences.get(modelId);
     sessionFastPreferences.set(modelId, fast);
@@ -204,25 +206,26 @@ function persistFastPreference(pi, modelId, fast) {
         return error;
     }
 }
-function persistCursorModePreference(pi, mode) {
-    const previousMode = sessionCursorAgentMode;
-    sessionCursorAgentMode = mode;
+function persistCursorModePreference(pi, mode, scopeKey) {
+    const state = getCursorSessionSettings(scopeKey);
+    const previousMode = state.mode;
+    state.mode = mode;
     try {
         pi.appendEntry(MODE_ENTRY_TYPE, { mode });
     }
     catch (error) {
-        sessionCursorAgentMode = previousMode;
+        state.mode = previousMode;
         throw error;
     }
 }
-function persistCursorHttp1Preference(pi, enabled) {
-    const previousSession = getStoredCursorHttp1Enabled();
-    setStoredCursorHttp1Enabled(enabled);
+function persistCursorHttp1Preference(pi, enabled, scopeKey) {
+    const previousSession = getStoredCursorHttp1Enabled(scopeKey);
+    setStoredCursorHttp1Enabled(enabled, scopeKey);
     try {
         saveGlobalCursorHttp1Enabled(enabled);
     }
     catch (error) {
-        setStoredCursorHttp1Enabled(previousSession);
+        setStoredCursorHttp1Enabled(previousSession, scopeKey);
         throw error;
     }
     try {
@@ -235,24 +238,25 @@ function persistCursorHttp1Preference(pi, enabled) {
         return error;
     }
 }
-function restoreCliCursorMode(raw) {
-    cliCursorModeState = { kind: "unset" };
+function restoreCliCursorMode(raw, scopeKey) {
+    const cli = getCursorSessionSettings(scopeKey).cli;
+    cli.mode = { kind: "unset" };
     if (raw === undefined || raw === "" || raw === false)
         return;
     const parsed = parseCursorAgentMode(raw);
     if (parsed) {
-        cliCursorModeState = { kind: "valid", mode: parsed };
+        cli.mode = { kind: "valid", mode: parsed };
         return;
     }
     const rawText = String(raw);
     const message = formatInvalidCursorMode(rawText);
-    cliCursorModeState = { kind: "invalid", raw: rawText, message };
+    cli.mode = { kind: "invalid", raw: rawText, message };
 }
 function notifyInvalidCursorModeIfCursorActive(ctx) {
-    const modeResolution = resolveCursorAgentMode();
+    const modeResolution = resolveCursorAgentMode(cursorSettingsScopeForContext(ctx));
     if (modeResolution.kind !== "invalid" || !ctx.hasUI || ctx.mode !== "tui")
         return;
-    const scopeKey = getCursorSessionScopeKey();
+    const scopeKey = cursorSettingsScopeForContext(ctx) ?? getCursorSessionScopeKey();
     if (invalidCursorModeNotifiedSessionScopeKeys.has(scopeKey))
         return;
     invalidCursorModeNotifiedSessionScopeKeys.add(scopeKey);
@@ -293,10 +297,11 @@ function emitCursorToolsDebugReport(pi, ctx) {
     }
     console.log(report);
 }
-export function getEffectiveFastForModelId(modelId) {
-    return getEffectiveFast(modelId);
+export function getEffectiveFastForModelId(modelId, scopeKey) {
+    return getEffectiveFast(modelId, scopeKey);
 }
 export function registerCursorRuntimeControls(pi) {
+    registerCursorSessionSettings(pi);
     registerCursorCloudRuntimeControls(pi, { refreshStatus: updateCursorStatus });
     pi.registerFlag("cursor-fast", {
         description: "Force Cursor fast mode for this run when the selected Cursor model supports it",
@@ -322,6 +327,7 @@ export function registerCursorRuntimeControls(pi) {
                 ctx.ui.notify(`Fast mode not supported by ${modelName}`, "info");
                 return;
             }
+            const { forceNoFast: cliForceNoFast, forceFast: cliForceFast } = getCursorSessionSettings(cursorSettingsScopeForContext(ctx)).cli;
             if (cliForceNoFast) {
                 ctx.ui.notify("Cursor fast is forced off by --cursor-no-fast", "info");
                 return;
@@ -336,11 +342,11 @@ export function registerCursorRuntimeControls(pi) {
                 return;
             }
             const preferenceModelId = getFastPreferenceModelId(metadata);
-            const current = getEffectiveFast(metadata.piModelId) ?? false;
+            const current = getEffectiveFast(metadata.piModelId, cursorSettingsScopeForContext(ctx)) ?? false;
             const next = !current;
             let appendError;
             try {
-                appendError = persistFastPreference(pi, preferenceModelId, next);
+                appendError = persistFastPreference(pi, preferenceModelId, next, cursorSettingsScopeForContext(ctx));
             }
             catch (error) {
                 updateCursorStatus(ctx);
@@ -389,7 +395,7 @@ export function registerCursorRuntimeControls(pi) {
             }
             let appendError;
             try {
-                appendError = persistCursorHttp1Preference(pi, next);
+                appendError = persistCursorHttp1Preference(pi, next, cursorSettingsScopeForContext(ctx));
             }
             catch (error) {
                 updateCursorStatus(ctx);
@@ -418,7 +424,7 @@ export function registerCursorRuntimeControls(pi) {
                 return;
             }
             try {
-                const result = await refreshSessionCursorAgentConfig();
+                const result = await refreshSessionCursorAgentConfig(getCursorSessionScopeSnapshot(pi).scopeKey);
                 const messages = {
                     reloaded: "Cursor SDK agent config refreshed.",
                     "no-agent": "No Cursor SDK agent exists yet; config will load on the next Cursor run.",
@@ -438,7 +444,7 @@ export function registerCursorRuntimeControls(pi) {
             const usage = "Usage: /cursor-mode agent|plan";
             const mode = parseCursorAgentMode(args);
             if (!args.trim()) {
-                const modeResolution = resolveCursorAgentMode();
+                const modeResolution = resolveCursorAgentMode(cursorSettingsScopeForContext(ctx));
                 if (modeResolution.kind === "invalid") {
                     ctx.ui.notify(`${modeResolution.message} ${usage}`, "error");
                 }
@@ -451,15 +457,17 @@ export function registerCursorRuntimeControls(pi) {
                 ctx.ui.notify(`Invalid Cursor mode "${args.trim()}". ${usage}`, "error");
                 return;
             }
+            const cli = getCursorSessionSettings(cursorSettingsScopeForContext(ctx)).cli;
+            const cliCursorModeState = cli.mode;
             if (cliCursorModeState.kind === "valid") {
                 ctx.ui.notify(`Cursor mode is forced to ${cliCursorModeState.mode} by --cursor-mode`, "info");
                 return;
             }
             const clearedInvalidCliMode = cliCursorModeState.kind === "invalid";
             try {
-                persistCursorModePreference(pi, mode);
+                persistCursorModePreference(pi, mode, cursorSettingsScopeForContext(ctx));
                 if (clearedInvalidCliMode)
-                    cliCursorModeState = { kind: "unset" };
+                    cli.mode = { kind: "unset" };
             }
             catch (error) {
                 updateCursorStatus(ctx);
@@ -481,11 +489,13 @@ export function registerCursorRuntimeControls(pi) {
             authoritativeGlobalFastPreferenceIds.clear();
             setCursorHttp1GlobalPreferenceAuthoritative(false);
             globalFastPreferences = loadGlobalFastPreferences();
-            cliForceFast = pi.getFlag("cursor-fast") === true;
-            cliForceNoFast = pi.getFlag("cursor-no-fast") === true;
-            restoreCursorCliState(pi);
+            const scopeKey = cursorSettingsScopeForContext(ctx);
+            const cli = getCursorSessionSettings(scopeKey).cli;
+            cli.forceFast = pi.getFlag("cursor-fast") === true;
+            cli.forceNoFast = pi.getFlag("cursor-no-fast") === true;
+            restoreCursorCliState(pi, scopeKey);
             restoreSessionCursorPreferences(ctx);
-            restoreCliCursorMode(pi.getFlag("cursor-mode"));
+            restoreCliCursorMode(pi.getFlag("cursor-mode"), scopeKey);
         },
         sync: (ctx) => {
             if (isCursorModel(ctx.model))
@@ -495,10 +505,10 @@ export function registerCursorRuntimeControls(pi) {
     });
 }
 function resetCursorModeStateForTests() {
-    sessionCursorAgentMode = undefined;
+    resetCursorSessionSettingsForTests();
     setCursorHttp1GlobalPreferenceAuthoritative(false);
     setStoredCursorHttp1Enabled(undefined);
-    cliCursorModeState = { kind: "unset" };
+    getCursorSessionSettings().cli.mode = { kind: "unset" };
     resetCursorRuntimeStateForTests();
     invalidCursorModeNotifiedSessionScopeKeys.clear();
     authoritativeGlobalFastPreferenceIds.clear();
@@ -511,9 +521,9 @@ export const __testUtils = {
     DEFAULT_CURSOR_AGENT_MODE,
     getConfigPath,
     loadGlobalFastPreferences,
-    sessionFastPreferences,
-    getSessionCursorAgentMode: () => sessionCursorAgentMode,
-    getCliCursorAgentMode: () => (cliCursorModeState.kind === "valid" ? cliCursorModeState.mode : undefined),
-    getCliCursorModeState: () => cliCursorModeState,
+    get sessionFastPreferences() { return getCursorSessionSettings().fast; },
+    getSessionCursorAgentMode: () => getCursorSessionSettings().mode,
+    getCliCursorAgentMode: () => { const mode = getCursorSessionSettings().cli.mode; return mode.kind === "valid" ? mode.mode : undefined; },
+    getCliCursorModeState: () => getCursorSessionSettings().cli.mode,
     resetCursorModeStateForTests,
 };

package/dist/cursor-usage-accounting.js

@@ -1,3 +1,4 @@
+import { calculateCost } from "@earendil-works/pi-ai";
 import { CURSOR_APPROX_CHARS_PER_TOKEN, CURSOR_IMAGE_TOKEN_ESTIMATE, estimateCursorContextTokens, estimateCursorTextTokens, } from "./context.js";
 import { asRecord, getNumber } from "./cursor-record-utils.js";
 function getPromptInputTokenBudget(model) {
@@ -81,86 +82,28 @@ export function applyCursorSdkUsage(partial, turnUsage) {
     partial.usage.output = turnUsage.outputTokens;
     partial.usage.cacheRead = turnUsage.cacheReadTokens;
     partial.usage.cacheWrite = turnUsage.cacheWriteTokens;
-    // totalTokens is context occupancy (full prompt + output), not the sum of spend components alone.
+    // Full prompt + output equals the sum of Pi's disjoint components.
     partial.usage.totalTokens = turnUsage.inputTokens + turnUsage.outputTokens;
 }
-function isCompatibleCursorAssistantMeasurement(assistant, model) {
-    return assistant.api === model.api && assistant.provider === model.provider && assistant.model === model.id;
-}
-function getLatestCompactionBoundary(context) {
-    for (let index = context.messages.length - 1; index >= 0; index -= 1) {
-        const message = context.messages[index];
-        if (message.role !== "compactionSummary")
-            continue;
-        const tokensBefore = message.tokensBefore;
-        return {
-            index,
-            tokensBefore: Number.isFinite(tokensBefore) && tokensBefore !== undefined && tokensBefore > 0 ? Math.floor(tokensBefore) : undefined,
-        };
-    }
-    return undefined;
-}
-function getLastAcceptedContextOccupancy(context, model) {
-    const boundary = getLatestCompactionBoundary(context);
-    for (let index = context.messages.length - 1; index >= 0; index -= 1) {
-        if (boundary && index < boundary.index)
-            break;
-        const message = context.messages[index];
-        if (message.role !== "assistant" || !("usage" in message))
-            continue;
-        const assistant = message;
-        if (assistant.stopReason === "aborted" || assistant.stopReason === "error" || !assistant.usage)
-            continue;
-        if (!isCompatibleCursorAssistantMeasurement(assistant, model))
-            continue;
-        const { usage } = assistant;
-        const total = usage.totalTokens || usage.input + usage.output + usage.cacheRead + usage.cacheWrite;
-        if (!Number.isFinite(total) || total <= 0 || total > model.contextWindow)
-            continue;
-        if (boundary?.tokensBefore !== undefined && total >= boundary.tokensBefore)
-            continue;
-        return total;
-    }
-    return 0;
-}
-export function applyCursorApproximateUsage(partial, model, context, sessionInputTokens) {
+export function applyCursorApproximateUsage(partial, model, context, sessionInputTokens, occupancyFloor) {
     const outputTokens = estimateCursorAssistantSessionOutputTokens(partial);
-    partial.usage.input = Math.max(0, sessionInputTokens);
+    const floor = occupancyFloor !== undefined && Number.isFinite(occupancyFloor) && occupancyFloor > 0 && occupancyFloor <= model.contextWindow ? occupancyFloor : 0;
+    const totalTokens = Math.max(Math.max(0, sessionInputTokens) + outputTokens, estimateCursorContextTotalTokens(partial, model, context), floor);
+    // Estimated prompt components describe the same occupancy as totalTokens.
+    partial.usage.input = totalTokens - outputTokens;
     partial.usage.output = outputTokens;
     partial.usage.cacheRead = 0;
     partial.usage.cacheWrite = 0;
-    // Never report less occupancy than the last compatible same-model in-window assistant measurement.
-    partial.usage.totalTokens = Math.max(partial.usage.input + partial.usage.output, estimateCursorContextTotalTokens(partial, model, context), getLastAcceptedContextOccupancy(context, model));
-}
-function applyCursorOccupancyEstimate(partial, model, context) {
-    partial.usage.totalTokens = Math.max(estimateCursorContextTotalTokens(partial, model, context), getLastAcceptedContextOccupancy(context, model));
-}
-function isCurrentLocalOccupancy(turn, model, context) {
-    if (!isCursorSdkUsageSafeForPiMessage(turn, model))
-        return false;
-    const tokensBefore = getLatestCompactionBoundary(context)?.tokensBefore;
-    return tokensBefore === undefined || turn.inputTokens + turn.outputTokens < tokensBefore;
-}
-function applyResolvedCursorOccupancy(partial, model, context, localTurn) {
-    if (localTurn && isCurrentLocalOccupancy(localTurn, model, context)) {
-        partial.usage.totalTokens = localTurn.inputTokens + localTurn.outputTokens;
-        return;
-    }
-    applyCursorOccupancyEstimate(partial, model, context);
+    partial.usage.totalTokens = totalTokens;
 }
 export function applyCursorUsage(partial, model, context, sessionInputTokens, sdkUsage) {
-    const billed = sdkUsage?.billed;
     const localTurn = sdkUsage?.runtime === "local" ? sdkUsage.turn : undefined;
-    if (billed && isCursorSdkUsagePartitionSafe(billed, model)) {
-        applyCursorSdkUsage(partial, billed);
-        applyResolvedCursorOccupancy(partial, model, context, localTurn);
-        return;
-    }
-    // Only local raw turn-ended usage has a captured full-prompt/cache-partition occupancy contract.
     if (localTurn && isCursorSdkUsageSafeForPiMessage(localTurn, model)) {
+        // Fresh LOCAL occupancy supersedes any previous request-provenance floor.
         applyCursorSdkUsage(partial, localTurn);
-        applyResolvedCursorOccupancy(partial, model, context, localTurn);
-        return;
     }
-    applyCursorApproximateUsage(partial, model, context, sessionInputTokens);
+    else {
+        applyCursorApproximateUsage(partial, model, context, sessionInputTokens, sdkUsage?.occupancyFloor);
+    }
+    calculateCost(model, partial.usage);
 }