pi-cursor-sdk 0.4.0 → 0.5.0

package/src/cursor-fallback-models.generated.ts

@@ -1,6 +1,6 @@
 import type { ModelListItem } from "@cursor/sdk";
 
-// Generated with @cursor/sdk@1.0.32 from 42 Cursor models.
+// Generated with @cursor/sdk@1.0.32 from 45 Cursor models.
 // Refresh with: npm run refresh:cursor-snapshots -- --write
 // Do not add secrets; this file stores public model metadata only.
 export const FALLBACK_MODEL_ITEMS = [
@@ -5599,6 +5599,185 @@ export const FALLBACK_MODEL_ITEMS = [
 			}
 		]
 	},
+	{
+		id: "claude-sonnet-5-5",
+		displayName: "Claude Sonnet 5.5",
+		parameters: [
+			{
+				id: "context",
+				displayName: "Context",
+				values: [
+					{
+						value: "300k",
+						displayName: "300K"
+					},
+					{
+						value: "1m",
+						displayName: "1M"
+					}
+				]
+			},
+			{
+				id: "reasoning_effort",
+				displayName: "Effort",
+				values: [
+					{
+						value: "low",
+						displayName: "Low"
+					},
+					{
+						value: "medium",
+						displayName: "Medium"
+					},
+					{
+						value: "high",
+						displayName: "High"
+					},
+					{
+						value: "xhigh",
+						displayName: "Extra High"
+					},
+					{
+						value: "max",
+						displayName: "Max"
+					}
+				]
+			}
+		],
+		variants: [
+			{
+				params: [
+					{
+						id: "context",
+						value: "300k"
+					},
+					{
+						id: "reasoning_effort",
+						value: "low"
+					}
+				],
+				displayName: "Claude Sonnet 5.5  Low"
+			},
+			{
+				params: [
+					{
+						id: "context",
+						value: "300k"
+					},
+					{
+						id: "reasoning_effort",
+						value: "medium"
+					}
+				],
+				displayName: "Claude Sonnet 5.5  Medium"
+			},
+			{
+				params: [
+					{
+						id: "context",
+						value: "300k"
+					},
+					{
+						id: "reasoning_effort",
+						value: "high"
+					}
+				],
+				displayName: "Claude Sonnet 5.5  High"
+			},
+			{
+				params: [
+					{
+						id: "context",
+						value: "300k"
+					},
+					{
+						id: "reasoning_effort",
+						value: "xhigh"
+					}
+				],
+				displayName: "Claude Sonnet 5.5  Extra High"
+			},
+			{
+				params: [
+					{
+						id: "context",
+						value: "300k"
+					},
+					{
+						id: "reasoning_effort",
+						value: "max"
+					}
+				],
+				displayName: "Claude Sonnet 5.5  Max"
+			},
+			{
+				params: [
+					{
+						id: "context",
+						value: "1m"
+					},
+					{
+						id: "reasoning_effort",
+						value: "low"
+					}
+				],
+				displayName: "Claude Sonnet 5.5 1M Low"
+			},
+			{
+				params: [
+					{
+						id: "context",
+						value: "1m"
+					},
+					{
+						id: "reasoning_effort",
+						value: "medium"
+					}
+				],
+				displayName: "Claude Sonnet 5.5 1M Medium"
+			},
+			{
+				params: [
+					{
+						id: "context",
+						value: "1m"
+					},
+					{
+						id: "reasoning_effort",
+						value: "high"
+					}
+				],
+				displayName: "Claude Sonnet 5.5 1M High",
+				isDefault: true
+			},
+			{
+				params: [
+					{
+						id: "context",
+						value: "1m"
+					},
+					{
+						id: "reasoning_effort",
+						value: "xhigh"
+					}
+				],
+				displayName: "Claude Sonnet 5.5 1M Extra High"
+			},
+			{
+				params: [
+					{
+						id: "context",
+						value: "1m"
+					},
+					{
+						id: "reasoning_effort",
+						value: "max"
+					}
+				],
+				displayName: "Claude Sonnet 5.5 1M Max"
+			}
+		]
+	},
 	{
 		id: "composer-2",
 		displayName: "Composer 2",
@@ -5979,6 +6158,114 @@ export const FALLBACK_MODEL_ITEMS = [
 			}
 		]
 	},
+	{
+		id: "glm-5p3",
+		displayName: "GLM 5.3",
+		parameters: [
+			{
+				id: "reasoning",
+				displayName: "Reasoning",
+				values: [
+					{
+						value: "low",
+						displayName: "Low"
+					},
+					{
+						value: "high",
+						displayName: "High"
+					},
+					{
+						value: "max",
+						displayName: "Max"
+					}
+				]
+			}
+		],
+		variants: [
+			{
+				params: [
+					{
+						id: "reasoning",
+						value: "low"
+					}
+				],
+				displayName: "GLM 5.3 Low"
+			},
+			{
+				params: [
+					{
+						id: "reasoning",
+						value: "high"
+					}
+				],
+				displayName: "GLM 5.3 High"
+			},
+			{
+				params: [
+					{
+						id: "reasoning",
+						value: "max"
+					}
+				],
+				displayName: "GLM 5.3 Max",
+				isDefault: true
+			}
+		]
+	},
+	{
+		id: "glm-5p3-flash",
+		displayName: "GLM 5.3 Flash",
+		parameters: [
+			{
+				id: "reasoning",
+				displayName: "Reasoning",
+				values: [
+					{
+						value: "low",
+						displayName: "Low"
+					},
+					{
+						value: "high",
+						displayName: "High"
+					},
+					{
+						value: "max",
+						displayName: "Max"
+					}
+				]
+			}
+		],
+		variants: [
+			{
+				params: [
+					{
+						id: "reasoning",
+						value: "low"
+					}
+				],
+				displayName: "GLM 5.3 Flash Low"
+			},
+			{
+				params: [
+					{
+						id: "reasoning",
+						value: "high"
+					}
+				],
+				displayName: "GLM 5.3 Flash High"
+			},
+			{
+				params: [
+					{
+						id: "reasoning",
+						value: "max"
+					}
+				],
+				displayName: "GLM 5.3 Flash Max",
+				isDefault: true
+			}
+		]
+	},
 	{
 		id: "gpt-5-mini",
 		displayName: "GPT-5 Mini",

package/src/cursor-fallback-warning.ts

@@ -1,7 +1,7 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { isCursorModel } from "./cursor-model.js";
 import { registerCursorModelLifecycle, type CursorModelLifecycleExtensionApi } from "./cursor-model-lifecycle.js";
-import { getCursorSessionScopeKey } from "./cursor-session-scope.js";
+import { cursorSessionScopeKeyForManager } from "./cursor-session-scope.js";
 import type { CursorModelFallbackIssue } from "./model-discovery.js";
 
 export type CursorFallbackWarningExtensionApi = CursorModelLifecycleExtensionApi;
@@ -14,7 +14,7 @@ export function registerCursorFallbackIssueWarning(
 
 	registerCursorModelLifecycle(pi, (ctx: ExtensionContext) => {
 		if (!isCursorModel(ctx.model) || !ctx.hasUI) return;
-		const scopeKey = getCursorSessionScopeKey();
+		const scopeKey = cursorSessionScopeKeyForManager(ctx.sessionManager);
 		if (warnedSessionScopeKeys.has(scopeKey)) return;
 		warnedSessionScopeKeys.add(scopeKey);
 		ctx.ui.notify(issue.message, "warning");

package/src/cursor-http1.ts

@@ -1,6 +1,7 @@
 import type { CursorSdkModule } from "./cursor-sdk-runtime.js";
 import type { CursorResolvedSetting } from "./cursor-config.js";
 import { asRecord } from "./cursor-record-utils.js";
+import { getCursorSessionSettings } from "./cursor-session-settings.js";
 
 export const CURSOR_HTTP1_ENTRY_TYPE = "cursor-http1-state";
 
@@ -12,7 +13,6 @@ type CursorHttp1Sdk = {
 	Cursor: Pick<CursorSdkModule["Cursor"], "configure">;
 };
 
-let sessionCursorHttp1Enabled: boolean | undefined;
 let globalPreferenceAuthoritative = false;
 let configuredCursor: CursorHttp1Sdk["Cursor"] | undefined;
 
@@ -20,16 +20,16 @@ export function isCursorHttp1EntryData(value: unknown): value is CursorHttp1Entr
 	return typeof asRecord(value)?.enabled === "boolean";
 }
 
-export function getStoredCursorHttp1Enabled(): boolean | undefined {
-	return sessionCursorHttp1Enabled;
+export function getStoredCursorHttp1Enabled(scopeKey?: string): boolean | undefined {
+	return getCursorSessionSettings(scopeKey).http1;
 }
 
-export function setStoredCursorHttp1Enabled(enabled: boolean | undefined): void {
-	sessionCursorHttp1Enabled = enabled;
+export function setStoredCursorHttp1Enabled(enabled: boolean | undefined, scopeKey?: string): void {
+	getCursorSessionSettings(scopeKey).http1 = enabled;
 }
 
-export function getResolvedSessionCursorHttp1Enabled(): boolean | undefined {
-	return globalPreferenceAuthoritative ? undefined : sessionCursorHttp1Enabled;
+export function getResolvedSessionCursorHttp1Enabled(scopeKey?: string): boolean | undefined {
+	return globalPreferenceAuthoritative ? undefined : getStoredCursorHttp1Enabled(scopeKey);
 }
 
 export function setCursorHttp1GlobalPreferenceAuthoritative(authoritative: boolean): void {
@@ -58,7 +58,7 @@ export function configureCursorSdkHttp1(
 
 export const __testUtils = {
 	reset(): void {
-		sessionCursorHttp1Enabled = undefined;
+		setStoredCursorHttp1Enabled(undefined);
 		globalPreferenceAuthoritative = false;
 		configuredCursor = undefined;
 	},

package/src/cursor-live-run-coordinator.ts

@@ -11,7 +11,7 @@ import {
 	type CursorLiveToolResultConsumption,
 } from "./cursor-live-run-accounting.js";
 import type { CursorSdkTurnUsage } from "./cursor-usage-accounting.js";
-import type { CursorNativeToolDisplayItem } from "./cursor-native-tool-display-state.js";
+import type { CursorNativeToolDisplayItem, CursorNativeToolDisplayState } from "./cursor-native-tool-display-state.js";
 import type { CursorPiBridgeToolRequest, CursorPiToolBridgeRun } from "./cursor-pi-tool-bridge.js";
 import { getCursorSessionScopeKey } from "./cursor-session-scope.js";
 import type { CursorSdkEventDebugRecorder } from "./cursor-sdk-event-debug.js";
@@ -45,7 +45,7 @@ export interface CursorLiveRun {
 	sdkRun?: CursorLiveSdkRun;
 	ignoreFutureSdkTurnUsage?: boolean;
 	accounting: CursorLiveRunAccountingState;
-	billedTurnUsage?: CursorSdkTurnUsage;
+	onAbandon?: () => Promise<void>;
 	pendingEvents: CursorLiveQueuedEvent[];
 	textDeltas: string[];
 	emittedText: string;
@@ -59,6 +59,7 @@ export interface CursorLiveRun {
 	abortMessage?: string;
 	chainUserInputAfterCompletion: boolean;
 	debugRecorder?: CursorSdkEventDebugRecorder;
+	nativeDisplay?: CursorNativeToolDisplayState;
 }
 
 export interface CursorLiveRunCreateParams {
@@ -70,6 +71,7 @@ export interface CursorLiveRunCreateParams {
 	promptInputTokens: number;
 	textDeltas?: string[];
 	debugRecorder?: CursorSdkEventDebugRecorder;
+	nativeDisplay?: CursorNativeToolDisplayState;
 }
 
 export interface CursorLiveRunCoordinatorDeps {
@@ -96,7 +98,7 @@ export interface CursorLiveRunCoordinator {
 	consumeToolResults(run: CursorLiveRun, context: Context, getReplayId: CursorReplayIdResolver): CursorLiveToolResultConsumption;
 	takeTurnInputTokens(run: CursorLiveRun, toolResultInputTokens: number): number;
 	takeSdkTurnUsage(run: CursorLiveRun): CursorSdkTurnUsage | undefined;
-	getPendingFromContext(context: Context, getReplayId: CursorReplayIdResolver): CursorLiveRun | undefined;
+	getPendingFromContext(context: Context, getReplayId: CursorReplayIdResolver, scopeKey: string): CursorLiveRun | undefined;
 	getActiveForScope(scopeKey?: string): CursorLiveRun | undefined;
 	isReady(run: CursorLiveRun): boolean;
 	waitForProgress(run: CursorLiveRun, signal?: AbortSignal): Promise<void>;
@@ -293,6 +295,7 @@ export function createCursorLiveRunCoordinator(deps: CursorLiveRunCoordinatorDep
 				bridgeRun: params.bridgeRun,
 				sessionBridgeRun: params.sessionBridgeRun,
 				sessionAgentScopeKey,
+				nativeDisplay: params.nativeDisplay,
 				accounting: createCursorLiveRunAccountingState(params.promptInputTokens),
 				pendingEvents: [],
 				textDeltas: params.textDeltas ?? [],
@@ -420,7 +423,9 @@ export function createCursorLiveRunCoordinator(deps: CursorLiveRunCoordinatorDep
 			return taken.sdkTurnUsage;
 		},
 
-		getPendingFromContext(context, getReplayId): CursorLiveRun | undefined {
+		getPendingFromContext(context, getReplayId, scopeKey): CursorLiveRun | undefined {
+			const run = getUndisposed(pendingRunIdsByScopeKey.get(scopeKey));
+			if (!run) return undefined;
 			const messages = getCursorConversationMessages(context);
 			let index = messages.length - 1;
 			while (index >= 0 && messages[index]?.role === "user") {
@@ -430,15 +435,7 @@ export function createCursorLiveRunCoordinator(deps: CursorLiveRunCoordinatorDep
 			for (; index >= 0; index -= 1) {
 				const message = messages[index];
 				if (message.role !== "toolResult") break;
-				const replayId = getReplayId(message.toolCallId);
-				if (replayId) {
-					const replayRun = getUndisposed(replayId);
-					if (replayRun) return replayRun;
-				}
-				for (const run of pendingRuns.values()) {
-					if (run.disposed) continue;
-					if (run.bridgeRun?.hasPendingPiToolCallId(message.toolCallId)) return run;
-				}
+				if (matchesCursorLiveRunToolResult(run, message, getReplayId)) return run;
 			}
 			return undefined;
 		},
@@ -531,11 +528,13 @@ export function createCursorLiveRunCoordinator(deps: CursorLiveRunCoordinatorDep
 				}
 				if (abandoned) {
 					if (!run.done) {
+						const usageCompletion = run.onAbandon?.();
 						try {
 							await cancelCursorLiveSdkRun(run);
 						} catch {
 							// cancellation failure should not block session-agent abandonment
 						}
+						await usageCompletion;
 					}
 					await deps.abandonSessionAgent(run.sessionAgentScopeKey);
 				}

package/src/cursor-native-replay-routing.ts

@@ -8,6 +8,7 @@ export interface NativeReplayRoutingInput {
 	toolName: string;
 	useNativeToolReplay: boolean;
 	activeToolNames?: ReadonlySet<string>;
+	registeredToolNames?: ReadonlySet<string>;
 	hasLiveRun: boolean;
 }
 
@@ -20,7 +21,7 @@ export function isNativeToolActiveInContext(toolName: string, activeToolNames?:
  * Extension resync (pi active tools) is separate; this uses context.tools snapshot only.
  */
 export function resolveNativeReplayDisposition(input: NativeReplayRoutingInput): NativeReplayDisposition {
-	if (!input.useNativeToolReplay || !canRenderCursorToolNatively(input.toolName)) {
+	if (!input.useNativeToolReplay || !(input.registeredToolNames?.has(input.toolName) ?? canRenderCursorToolNatively(input.toolName))) {
 		return "transcript_trace";
 	}
 	if (isNativeToolActiveInContext(input.toolName, input.activeToolNames) && input.hasLiveRun) {

package/src/cursor-native-tool-display-registration.ts

@@ -13,9 +13,9 @@ import {
 	isCursorNativeToolRegistrationRequested,
 	NATIVE_CURSOR_TOOL_DISPLAY_ENV,
 	readBooleanEnv,
-	registeredNativeToolNames,
+	getCursorNativeToolDisplayState,
+	registerCursorNativeToolDisplayState,
 	setCursorNativeToolDisplayRuntimeRequested,
-	skippedNativeToolNames,
 } from "./cursor-native-tool-display-state.js";
 import { isCursorReplayToolName } from "./cursor-tool-presentation-registry.js";
 import { registerNativeCursorTool } from "./cursor-native-tool-display-tools.js";
@@ -30,7 +30,11 @@ function isCursorCorePiReplayToolName(toolName: string): toolName is (typeof CUR
 type CursorNativeToolActivationApi = Pick<ExtensionAPI, "getActiveTools" | "setActiveTools">;
 type CursorNativeToolRegistryApi = CursorNativeToolActivationApi & Pick<ExtensionAPI, "getAllTools" | "registerTool">;
 
-export interface CursorNativeToolDisplayExtensionApi extends CursorNativeToolRegistryApi, CursorModelLifecycleExtensionApi {}
+export type CursorNativeToolDisplayExtensionApi = CursorNativeToolRegistryApi
+	& CursorModelLifecycleExtensionApi & Parameters<typeof registerCursorNativeToolDisplayState>[0];
+
+// Pi filters getAllTools even after registration; new/reloaded extensions receive a new API.
+const filteredRegistrations = new WeakMap<CursorNativeToolRegistryApi, Set<NativeCursorToolName>>();
 
 function hasNonBuiltinTool(pi: Pick<ExtensionAPI, "getAllTools">, toolName: NativeCursorToolName): boolean {
 	const existingTool = pi.getAllTools().find((tool) => tool.name === toolName);
@@ -44,17 +48,29 @@ type NativeRegistrationContext = Pick<ExtensionContext, "mode" | "model"> & {
 function registerNativeCursorToolsFromSet(
 	pi: CursorNativeToolRegistryApi,
 	toolNames: readonly NativeCursorToolName[],
+	getCwd: () => string,
 ): NativeCursorToolName[] {
+	const state = getCursorNativeToolDisplayState(pi);
+	const { registeredNativeToolSources, skippedNativeToolNames } = state;
+	let filteredToolNames = filteredRegistrations.get(pi);
+	if (!filteredToolNames) {
+		filteredToolNames = new Set();
+		filteredRegistrations.set(pi, filteredToolNames);
+	}
 	const newlySkippedToolNames: NativeCursorToolName[] = [];
 	for (const toolName of toolNames) {
-		if (registeredNativeToolNames.has(toolName) || skippedNativeToolNames.has(toolName)) continue;
+		if (registeredNativeToolSources.has(toolName) || filteredToolNames.has(toolName)) continue;
 		if (hasNonBuiltinTool(pi, toolName)) {
-			skippedNativeToolNames.add(toolName);
-			newlySkippedToolNames.push(toolName);
+			if (!skippedNativeToolNames.has(toolName)) {
+				skippedNativeToolNames.add(toolName);
+				newlySkippedToolNames.push(toolName);
+			}
 			continue;
 		}
-		registerNativeCursorTool(pi, toolName);
-		registeredNativeToolNames.add(toolName);
+		registerNativeCursorTool(pi, toolName, getCwd, state);
+		const registeredTool = pi.getAllTools().find((tool) => tool.name === toolName);
+		if (registeredTool) registeredNativeToolSources.set(toolName, registeredTool.sourceInfo);
+		else filteredToolNames.add(toolName);
 	}
 	return newlySkippedToolNames;
 }
@@ -67,15 +83,12 @@ function notifySkippedNativeCursorToolsIfNeeded(ctx: NativeRegistrationContext,
 	);
 }
 
-function hasAttemptedNativeCursorToolRegistration(): boolean {
-	return registeredNativeToolNames.size > 0 || skippedNativeToolNames.size > 0;
-}
-
 function removeRegisteredNonCoreNativeCursorTools(pi: CursorNativeToolActivationApi): void {
-	if (registeredNativeToolNames.size === 0) return;
+	const { registeredNativeToolSources } = getCursorNativeToolDisplayState(pi);
+	if (registeredNativeToolSources.size === 0) return;
 	const activeToolNames = new Set(pi.getActiveTools());
 	let changed = false;
-	for (const toolName of registeredNativeToolNames) {
+	for (const toolName of registeredNativeToolSources.keys()) {
 		if (isCursorCorePiReplayToolName(toolName)) continue;
 		if (!activeToolNames.delete(toolName)) continue;
 		changed = true;
@@ -87,7 +100,8 @@ export function syncRegisteredNativeCursorToolsForModel(
 	pi: CursorNativeToolActivationApi,
 	model: ExtensionContext["model"],
 ): void {
-	if (registeredNativeToolNames.size === 0) return;
+	const { registeredNativeToolSources } = getCursorNativeToolDisplayState(pi);
+	if (registeredNativeToolSources.size === 0) return;
 	if (!isCursorModel(model)) {
 		removeRegisteredNonCoreNativeCursorTools(pi);
 		return;
@@ -95,7 +109,7 @@ export function syncRegisteredNativeCursorToolsForModel(
 	if (arePiToolsDisabled(pi)) return;
 	const activeToolNames = new Set(pi.getActiveTools());
 	let changed = false;
-	for (const toolName of registeredNativeToolNames) {
+	for (const toolName of registeredNativeToolSources.keys()) {
 		if (isCursorReplayToolName(toolName) && !CURSOR_MODEL_ACTIVE_REPLAY_TOOL_NAMES.some((activeReplayToolName) => activeReplayToolName === toolName)) continue;
 		if (activeToolNames.has(toolName)) continue;
 		activeToolNames.add(toolName);
@@ -104,31 +118,41 @@ export function syncRegisteredNativeCursorToolsForModel(
 	if (changed) pi.setActiveTools([...activeToolNames]);
 }
 
-function ensureNativeCursorToolsRegisteredForModel(pi: CursorNativeToolRegistryApi, ctx: NativeRegistrationContext): void {
-	if (!isCursorModel(ctx.model) || hasAttemptedNativeCursorToolRegistration()) return;
+function ensureNativeCursorToolsRegisteredForModel(pi: CursorNativeToolRegistryApi, ctx: NativeRegistrationContext, getCwd: () => string): void {
+	if (!isCursorModel(ctx.model)) return;
 
 	const nonCoreToolNames = NATIVE_CURSOR_TOOL_NAMES.filter((toolName) => !isCursorCorePiReplayToolName(toolName));
 	const skippedToolNames = [
-		...registerNativeCursorToolsFromSet(pi, nonCoreToolNames),
-		...registerNativeCursorToolsFromSet(pi, CURSOR_CORE_PI_REPLAY_TOOL_NAMES),
+		...registerNativeCursorToolsFromSet(pi, nonCoreToolNames, getCwd),
+		...registerNativeCursorToolsFromSet(pi, CURSOR_CORE_PI_REPLAY_TOOL_NAMES, getCwd),
 	];
 	notifySkippedNativeCursorToolsIfNeeded(ctx, skippedToolNames);
 }
 
-function ensureThenSyncNativeCursorToolsForModel(pi: CursorNativeToolRegistryApi, ctx: NativeRegistrationContext): void {
+function ensureThenSyncNativeCursorToolsForModel(pi: CursorNativeToolRegistryApi, ctx: NativeRegistrationContext, getCwd: () => string): void {
+	const { registeredNativeToolSources } = getCursorNativeToolDisplayState(pi);
+	const currentTools = pi.getAllTools();
+	for (const [toolName, sourceInfo] of registeredNativeToolSources) {
+		if (!currentTools.some((tool) => tool.name === toolName && tool.sourceInfo === sourceInfo)) {
+			registeredNativeToolSources.delete(toolName);
+		}
+	}
 	const requested = isCursorNativeToolRegistrationRequested(ctx.mode);
-	setCursorNativeToolDisplayRuntimeRequested(requested);
+	setCursorNativeToolDisplayRuntimeRequested(requested, pi);
 	if (!requested) {
 		removeRegisteredNonCoreNativeCursorTools(pi);
 		return;
 	}
-	ensureNativeCursorToolsRegisteredForModel(pi, ctx);
+	ensureNativeCursorToolsRegisteredForModel(pi, ctx, getCwd);
 	syncRegisteredNativeCursorToolsForModel(pi, ctx.model);
 }
 
 export function registerCursorNativeToolDisplay(pi: CursorNativeToolDisplayExtensionApi): void {
+	registerCursorNativeToolDisplayState(pi);
+	let cwd = process.cwd();
 	registerCursorModelLifecycle(pi, (ctx) => {
-		ensureThenSyncNativeCursorToolsForModel(pi, ctx);
+		cwd = ctx.cwd;
+		ensureThenSyncNativeCursorToolsForModel(pi, ctx, () => cwd);
 	});
 }