pi-cursor-sdk 0.1.20 → 0.1.22

package/src/cursor-setting-sources.ts

@@ -1,17 +1,14 @@
 import type { SettingSource } from "@cursor/sdk";
+/** Provider-facing wrapper; canonical parsing lives in shared/cursor-setting-sources.mjs. */
+import {
+	CURSOR_SETTING_SOURCES_ENV as CURSOR_SETTING_SOURCES_ENV_JS,
+	resolveCursorSettingSources as resolveCursorSettingSourcesJs,
+} from "../shared/cursor-setting-sources.mjs";
 
-export const CURSOR_SETTING_SOURCES_ENV = "PI_CURSOR_SETTING_SOURCES";
+export const CURSOR_SETTING_SOURCES_ENV = CURSOR_SETTING_SOURCES_ENV_JS;
 
 export function resolveCursorSettingSources(raw?: string): SettingSource[] | undefined {
-	const trimmed = raw?.trim();
-	if (!trimmed) return ["all"];
-	const normalized = trimmed.toLowerCase();
-	if (["0", "false", "off", "none", "omit", "disabled"].includes(normalized)) return undefined;
-	if (["1", "true", "on", "all"].includes(normalized)) return ["all"];
-	return trimmed
-		.split(",")
-		.map((entry) => entry.trim())
-		.filter((entry): entry is SettingSource => Boolean(entry));
+	return resolveCursorSettingSourcesJs(raw) as SettingSource[] | undefined;
 }
 
 export function getEffectiveCursorSettingSources(raw: string | undefined = process.env[CURSOR_SETTING_SOURCES_ENV]): SettingSource[] | undefined {

package/src/cursor-state.ts

@@ -1,46 +1,72 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
-import type { ExtensionAPI, ExtensionContext, SessionStartEvent } from "@earendil-works/pi-coding-agent";
+import type { AgentModeOption } from "@cursor/sdk";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import {
+	buildCursorToolManifestText,
+	CURSOR_TOOL_MANIFEST_ENV,
+	resolveCursorToolManifestEnabled,
+} from "./cursor-tool-manifest.js";
+import {
+	buildCursorPiToolBridgeSnapshot,
+	CURSOR_PI_TOOL_BRIDGE_ENV,
+	resolveCursorPiToolBridgeEnabled,
+} from "./cursor-pi-tool-bridge-snapshot.js";
+import {
+	CURSOR_SETTING_SOURCES_ENV,
+	getEffectiveCursorSettingSources,
+} from "./cursor-setting-sources.js";
 import { isCursorModel } from "./cursor-model.js";
 import { getCursorModelMetadata } from "./model-discovery.js";
 
 const FAST_ENTRY_TYPE = "cursor-fast-state";
+const MODE_ENTRY_TYPE = "cursor-mode-state";
 const GLOBAL_CONFIG_FILE = "cursor-sdk.json";
 
+export type CursorAgentMode = AgentModeOption;
+
+const DEFAULT_CURSOR_AGENT_MODE: AgentModeOption = "agent";
+
 interface CursorFastEntryData {
 	baseModelId: string;
 	fast: boolean;
 }
 
+interface CursorModeEntryData {
+	mode: AgentModeOption;
+}
+
 interface CursorGlobalConfig {
 	fastDefaults?: Record<string, boolean>;
 }
 
-type CursorFastControlsModel =
-	| Pick<NonNullable<ExtensionContext["model"]>, "id" | "provider" | "api">
-	| undefined;
-
-type CursorFastControlsContext = {
-	model: CursorFastControlsModel;
-	ui: Pick<ExtensionContext["ui"], "notify" | "setStatus">;
-	sessionManager: Pick<ExtensionContext["sessionManager"], "getBranch">;
-};
+type CursorRuntimeControlsExtensionApi = Pick<
+	ExtensionAPI,
+	"appendEntry" | "getFlag" | "registerFlag" | "registerCommand" | "on" | "getActiveTools" | "getAllTools"
+>;
 
-interface CursorFastControlsExtensionApi extends Pick<ExtensionAPI, "appendEntry" | "getFlag" | "registerFlag"> {
-	registerCommand(name: string, options: {
-		description?: string;
-		handler: (args: string, ctx: CursorFastControlsContext) => Promise<void> | void;
-	}): void;
-	on(event: "session_start", handler: (event: SessionStartEvent, ctx: CursorFastControlsContext) => Promise<void> | void): void;
-	on(event: "model_select", handler: (event: { model: ExtensionContext["model"] }, ctx: CursorFastControlsContext) => Promise<void> | void): void;
-	on(event: "turn_start", handler: (event: unknown, ctx: CursorFastControlsContext) => Promise<void> | void): void;
-}
+type CursorCliModeState =
+	| { kind: "unset" }
+	| { kind: "valid"; mode: AgentModeOption }
+	| { kind: "invalid"; raw: string; message: string };
 
 const sessionFastPreferences = new Map<string, boolean>();
 let globalFastPreferences = new Map<string, boolean>();
 let cliForceFast = false;
 let cliForceNoFast = false;
+let sessionCursorAgentMode: AgentModeOption | undefined;
+let cliCursorModeState: CursorCliModeState = { kind: "unset" };
+
+export function isCursorAgentMode(value: unknown): value is AgentModeOption {
+	return value === "agent" || value === "plan";
+}
+
+export function parseCursorAgentMode(raw: unknown): AgentModeOption | undefined {
+	if (typeof raw !== "string") return undefined;
+	const mode = raw.trim();
+	return isCursorAgentMode(mode) ? mode : undefined;
+}
 
 function isCursorFastEntryData(value: unknown): value is CursorFastEntryData {
 	if (!value || typeof value !== "object") return false;
@@ -48,6 +74,12 @@ function isCursorFastEntryData(value: unknown): value is CursorFastEntryData {
 	return typeof data.baseModelId === "string" && typeof data.fast === "boolean";
 }
 
+function isCursorModeEntryData(value: unknown): value is CursorModeEntryData {
+	if (!value || typeof value !== "object") return false;
+	const data = value as Record<string, unknown>;
+	return isCursorAgentMode(data.mode);
+}
+
 function getConfigPath(): string {
 	return join(getAgentDir(), GLOBAL_CONFIG_FILE);
 }
@@ -86,6 +118,16 @@ function restoreSessionFastPreferences(ctx: { sessionManager: Pick<ExtensionCont
 	}
 }
 
+function restoreSessionCursorMode(ctx: { sessionManager: Pick<ExtensionContext["sessionManager"], "getBranch"> }): void {
+	sessionCursorAgentMode = undefined;
+	for (const entry of ctx.sessionManager.getBranch()) {
+		if (entry.type !== "custom" || entry.customType !== MODE_ENTRY_TYPE) continue;
+		if (isCursorModeEntryData(entry.data)) {
+			sessionCursorAgentMode = entry.data.mode;
+		}
+	}
+}
+
 function getEffectiveFast(baseModelId: string, modelId: string): boolean | undefined {
 	const metadata = getCursorModelMetadata(modelId);
 	if (!metadata?.supportsFast) return undefined;
@@ -94,21 +136,43 @@ function getEffectiveFast(baseModelId: string, modelId: string): boolean | undef
 	return sessionFastPreferences.get(baseModelId) ?? globalFastPreferences.get(baseModelId) ?? metadata.defaultFast;
 }
 
-function updateCursorStatus(ctx: { model: CursorFastControlsModel; ui: Pick<ExtensionContext["ui"], "setStatus"> }, model = ctx.model): void {
+function formatInvalidCursorMode(raw: string): string {
+	return `Invalid --cursor-mode "${raw}". Use "agent" or "plan".`;
+}
+
+export function getEffectiveCursorAgentMode(): AgentModeOption {
+	switch (cliCursorModeState.kind) {
+		case "valid":
+			return cliCursorModeState.mode;
+		case "invalid":
+			throw new Error(cliCursorModeState.message);
+		case "unset":
+			return sessionCursorAgentMode ?? DEFAULT_CURSOR_AGENT_MODE;
+	}
+}
+
+function formatCursorStatus(fast: boolean | undefined): string | undefined {
+	const parts: string[] = [];
+	if (fast === true) parts.push("fast");
+	if (cliCursorModeState.kind === "invalid") {
+		parts.push("mode invalid");
+	} else if (getEffectiveCursorAgentMode() === "plan") {
+		parts.push("plan");
+	}
+	return parts.length > 0 ? `cursor ${parts.join(" · ")}` : undefined;
+}
+
+function updateCursorStatus(ctx: Pick<ExtensionContext, "model" | "ui">, model = ctx.model): void {
 	if (!model || !isCursorModel(model)) {
 		ctx.ui.setStatus("cursor", undefined);
 		return;
 	}
 	const metadata = getCursorModelMetadata(model.id);
-	if (!metadata?.supportsFast) {
-		ctx.ui.setStatus("cursor", undefined);
-		return;
-	}
-	const fast = getEffectiveFast(metadata.baseModelId, model.id);
-	ctx.ui.setStatus("cursor", fast === true ? "cursor fast" : undefined);
+	const fast = metadata?.supportsFast ? getEffectiveFast(metadata.baseModelId, model.id) : undefined;
+	ctx.ui.setStatus("cursor", formatCursorStatus(fast));
 }
 
-function getCurrentCursorMetadata(ctx: { model: CursorFastControlsModel }) {
+function getCurrentCursorMetadata(ctx: Pick<ExtensionContext, "model">) {
 	const model = ctx.model;
 	if (!model || !isCursorModel(model)) return undefined;
 	return getCursorModelMetadata(model.id);
@@ -146,13 +210,87 @@ function persistFastPreference(pi: Pick<ExtensionAPI, "appendEntry">, baseModelI
 	}
 }
 
+function persistCursorModePreference(pi: Pick<ExtensionAPI, "appendEntry">, mode: AgentModeOption): void {
+	const previousMode = sessionCursorAgentMode;
+	sessionCursorAgentMode = mode;
+	try {
+		pi.appendEntry<CursorModeEntryData>(MODE_ENTRY_TYPE, { mode });
+	} catch (error) {
+		sessionCursorAgentMode = previousMode;
+		throw error;
+	}
+}
+
+function restoreCliCursorMode(raw: boolean | string | undefined, hasUI: boolean, notify: ExtensionContext["ui"]["notify"]): void {
+	cliCursorModeState = { kind: "unset" };
+	if (raw === undefined || raw === "" || raw === false) return;
+	const parsed = parseCursorAgentMode(raw);
+	if (parsed) {
+		cliCursorModeState = { kind: "valid", mode: parsed };
+		return;
+	}
+	const rawText = String(raw);
+	const message = formatInvalidCursorMode(rawText);
+	cliCursorModeState = { kind: "invalid", raw: rawText, message };
+	if (hasUI) {
+		notify(message, "error");
+		return;
+	}
+	throw new Error(message);
+}
+
+function formatEffectiveCursorSettingSourcesLabel(raw: string | undefined = process.env[CURSOR_SETTING_SOURCES_ENV]): string {
+	const effective = getEffectiveCursorSettingSources(raw);
+	const effectiveLabel = effective === undefined ? "none" : effective.join(",");
+	const rawLabel = raw?.trim() ? raw.trim() : "(unset → all)";
+	return `${rawLabel} (effective: ${effectiveLabel})`;
+}
+
+export function formatCursorToolsDebugReport(
+	pi: Pick<ExtensionAPI, "getActiveTools" | "getAllTools">,
+	env: Record<string, string | undefined> = process.env,
+): string {
+	const bridgeEnabled = resolveCursorPiToolBridgeEnabled(env);
+	const manifestEnabled = resolveCursorToolManifestEnabled(env);
+	const lines = [
+		"Cursor tool surfaces (current session):",
+		`${CURSOR_PI_TOOL_BRIDGE_ENV}: ${bridgeEnabled ? "enabled" : "disabled"}`,
+		`${CURSOR_TOOL_MANIFEST_ENV}: ${manifestEnabled ? "enabled" : "disabled"}`,
+		`${CURSOR_SETTING_SOURCES_ENV}: ${formatEffectiveCursorSettingSourcesLabel(env[CURSOR_SETTING_SOURCES_ENV])}`,
+	];
+
+	let bridgeSnapshot;
+	if (bridgeEnabled) {
+		try {
+			bridgeSnapshot = buildCursorPiToolBridgeSnapshot(pi);
+		} catch {
+			lines.push("Pi bridge snapshot: unavailable (extension tool APIs required).");
+		}
+	}
+
+	lines.push(buildCursorToolManifestText({ bridgeSnapshot, piBridgeEnabled: bridgeEnabled }));
+	return lines.join("\n");
+}
+
+function emitCursorToolsDebugReport(
+	pi: Pick<ExtensionAPI, "getActiveTools" | "getAllTools">,
+	ctx: Pick<ExtensionContext, "hasUI" | "ui">,
+): void {
+	const report = formatCursorToolsDebugReport(pi);
+	if (ctx.hasUI) {
+		ctx.ui.notify(report, "info");
+		return;
+	}
+	console.log(report);
+}
+
 export function getEffectiveFastForModelId(modelId: string): boolean | undefined {
 	const metadata = getCursorModelMetadata(modelId);
 	if (!metadata) return undefined;
 	return getEffectiveFast(metadata.baseModelId, modelId);
 }
 
-export function registerCursorFastControls(pi: CursorFastControlsExtensionApi): void {
+export function registerCursorRuntimeControls(pi: CursorRuntimeControlsExtensionApi): void {
 	pi.registerFlag("cursor-fast", {
 		description: "Force Cursor fast mode for this run when the selected Cursor model supports it",
 		type: "boolean",
@@ -165,6 +303,12 @@ export function registerCursorFastControls(pi: CursorFastControlsExtensionApi):
 		default: false,
 	});
 
+	pi.registerFlag("cursor-mode", {
+		description: "Set Cursor SDK conversation mode for this run: agent or plan",
+		type: "string",
+		default: "",
+	});
+
 	pi.registerCommand("cursor-fast", {
 		description: "Toggle Cursor fast mode for the selected Cursor model",
 		handler: async (_args, ctx) => {
@@ -197,11 +341,60 @@ export function registerCursorFastControls(pi: CursorFastControlsExtensionApi):
 		},
 	});
 
+	pi.registerCommand("cursor-tools", {
+		description: "Show live Cursor tool surfaces for this session (maintainer debug)",
+		handler: async (_args, ctx) => {
+			emitCursorToolsDebugReport(pi, ctx);
+		},
+	});
+
+	pi.registerCommand("cursor-mode", {
+		description: "Set Cursor SDK conversation mode: agent or plan",
+		handler: async (args, ctx) => {
+			const usage = "Usage: /cursor-mode agent|plan";
+			const mode = parseCursorAgentMode(args);
+			if (!args.trim()) {
+				try {
+					ctx.ui.notify(`Cursor mode is ${getEffectiveCursorAgentMode()}. ${usage}`, "info");
+				} catch (error) {
+					ctx.ui.notify(`${error instanceof Error ? error.message : String(error)} ${usage}`, "error");
+				}
+				return;
+			}
+			if (!mode) {
+				ctx.ui.notify(`Invalid Cursor mode "${args.trim()}". ${usage}`, "error");
+				return;
+			}
+			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);
+				if (clearedInvalidCliMode) cliCursorModeState = { kind: "unset" };
+			} catch (error) {
+				updateCursorStatus(ctx);
+				ctx.ui.notify(`Failed to save Cursor mode preference: ${error instanceof Error ? error.message : String(error)}`, "error");
+				return;
+			}
+			updateCursorStatus(ctx);
+			ctx.ui.notify(
+				clearedInvalidCliMode
+					? `Cursor mode set to ${mode}; cleared invalid --cursor-mode override`
+					: `Cursor mode set to ${mode}`,
+				"info",
+			);
+		},
+	});
+
 	pi.on("session_start", async (_event, ctx) => {
 		globalFastPreferences = loadGlobalFastPreferences();
 		cliForceFast = pi.getFlag("cursor-fast") === true;
 		cliForceNoFast = pi.getFlag("cursor-no-fast") === true;
 		restoreSessionFastPreferences(ctx);
+		restoreSessionCursorMode(ctx);
+		restoreCliCursorMode(pi.getFlag("cursor-mode"), ctx.hasUI, ctx.ui.notify.bind(ctx.ui));
 		updateCursorStatus(ctx);
 	});
 
@@ -214,9 +407,20 @@ export function registerCursorFastControls(pi: CursorFastControlsExtensionApi):
 	});
 }
 
+function resetCursorModeStateForTests(): void {
+	sessionCursorAgentMode = undefined;
+	cliCursorModeState = { kind: "unset" };
+}
+
 export const __testUtils = {
 	FAST_ENTRY_TYPE,
+	MODE_ENTRY_TYPE,
+	DEFAULT_CURSOR_AGENT_MODE,
 	getConfigPath,
 	loadGlobalFastPreferences,
 	sessionFastPreferences,
+	getSessionCursorAgentMode: () => sessionCursorAgentMode,
+	getCliCursorAgentMode: () => (cliCursorModeState.kind === "valid" ? cliCursorModeState.mode : undefined),
+	getCliCursorModeState: () => cliCursorModeState,
+	resetCursorModeStateForTests,
 };

package/src/cursor-tool-lifecycle.ts

@@ -1,5 +1,6 @@
 import { truncateCursorDisplayLine } from "./cursor-display-text.js";
 import { scrubSensitiveText } from "./cursor-sensitive-text.js";
+import { getCursorToolLifecycleLabelKind } from "./cursor-tool-presentation-registry.js";
 import { extractWebSearchQuery } from "./cursor-web-tool-activity.js";
 import { firstNonEmptyLine, getArray, getString, truncateArg } from "./cursor-transcript-utils.js";
 import { classifyCursorToolVisibility } from "./cursor-tool-visibility.js";
@@ -39,7 +40,7 @@ export function buildCursorToolLifecycleLabel(toolCall: unknown, apiKey?: string
 	const visibility = classifyCursorToolVisibility(toolCall);
 	const args = visibility.args;
 
-	switch (visibility.normalizedKey) {
+	switch (getCursorToolLifecycleLabelKind(visibility.normalizedKey)) {
 		case "task": {
 			return scrubLifecycleDetail(getString(args, "description"), apiKey) ?? "task";
 		}
@@ -49,26 +50,26 @@ export function buildCursorToolLifecycleLabel(toolCall: unknown, apiKey?: string
 		case "mcp": {
 			return scrubLifecycleDetail(getString(args, "toolName"), apiKey) ?? "mcp";
 		}
-		case "generateimage": {
+		case "generateImage": {
 			return scrubLifecycleDetail(getString(args, "prompt") ?? getString(args, "description"), apiKey) ?? "image generation";
 		}
-		case "recordscreen": {
+		case "recordScreen": {
 			return scrubLifecycleDetail(getString(args, "mode"), apiKey) ?? "screen recording";
 		}
-		case "semsearch": {
+		case "semSearch": {
 			return scrubLifecycleDetail(getString(args, "query"), apiKey) ?? "semantic search";
 		}
-		case "websearch": {
+		case "webSearch": {
 			return scrubLifecycleDetail(extractWebSearchQuery(args), apiKey) ?? "web search";
 		}
-		case "webfetch": {
+		case "webFetch": {
 			return "web fetch";
 		}
-		case "createplan": {
+		case "createPlan": {
 			const plan = getString(args, "plan");
 			return scrubLifecycleDetail(plan ? firstNonEmptyLine(plan) ?? plan : undefined, apiKey) ?? "plan";
 		}
-		case "updatetodos": {
+		case "updateTodos": {
 			const todos = getArray(args, "todos") ?? getArray(args, "items");
 			if (todos && todos.length > 0) return truncateArg(`${todos.length} item${todos.length === 1 ? "" : "s"}`);
 			return "todos";

package/src/cursor-tool-manifest.ts

@@ -0,0 +1,41 @@
+import { parseEnvBoolean } from "./cursor-env-boolean.js";
+import type { CursorPiToolBridgeSnapshot } from "./cursor-pi-tool-bridge-types.js";
+
+export const CURSOR_TOOL_MANIFEST_ENV = "PI_CURSOR_TOOL_MANIFEST";
+
+/**
+ * Representative @cursor/sdk@1.0.14 local-agent ToolType values; actual exposure can vary by run.
+ * See docs/cursor-native-tool-replay.md#sdk-tooltype-replay-matrix.
+ */
+export const CURSOR_HOST_TOOL_MANIFEST_SUMMARY =
+	"read, shell, grep, glob, ls, edit, write, delete, readLints, updateTodos, createPlan, task, generateImage, mcp, semSearch, recordScreen, and web search/fetch when exposed";
+
+export function resolveCursorToolManifestEnabled(
+	env: Record<string, string | undefined> = process.env,
+): boolean {
+	return parseEnvBoolean(env[CURSOR_TOOL_MANIFEST_ENV], true);
+}
+
+export function buildCursorToolManifestText(options: {
+	bridgeSnapshot?: CursorPiToolBridgeSnapshot;
+	/** When false, bridge is off via PI_CURSOR_PI_TOOL_BRIDGE=0 (not merely empty). */
+	piBridgeEnabled?: boolean;
+} = {}): string {
+	const piBridgeEnabled = options.piBridgeEnabled ?? true;
+	const lines = [
+		"Callable tool surfaces this run:",
+		`- Cursor SDK host tools (callable; not listed in MCP listTools): ${CURSOR_HOST_TOOL_MANIFEST_SUMMARY}.`,
+		"- Configured Cursor MCP servers: discovered at runtime via MCP listTools (depends on Cursor settings and PI_CURSOR_SETTING_SOURCES).",
+	];
+	const bridgeTools = options.bridgeSnapshot?.tools ?? [];
+	if (!piBridgeEnabled) {
+		lines.push("- Pi bridge: disabled (PI_CURSOR_PI_TOOL_BRIDGE=0).");
+	} else if (bridgeTools.length === 0) {
+		lines.push("- Pi bridge: no pi__* tools exposed this run.");
+	} else {
+		const names = [...bridgeTools.map((tool) => tool.mcpToolName)].sort().join(", ");
+		lines.push(`- Pi bridge (call pi__* MCP names; pi shows real pi tool names): ${names}.`);
+	}
+	lines.push("- Not callable: cursor-replay-* IDs, pi history tool names, and transcript labels.");
+	return lines.join("\n");
+}

package/src/cursor-tool-names.ts

@@ -1,106 +1,18 @@
-export const CURSOR_REPLAY_ACTIVITY_TOOL_NAME = "cursor";
-
-export const CURSOR_REPLAY_LEGACY_TOOL_NAMES = [
-	"cursor_edit",
-	"cursor_write",
-	"cursor_read_lints",
-	"cursor_delete",
-	"cursor_update_todos",
-	"cursor_task",
-	"cursor_create_plan",
-	"cursor_generate_image",
-	"cursor_mcp",
-	"cursor_sem_search",
-	"cursor_record_screen",
-	"cursor_web_search",
-	"cursor_web_fetch",
-] as const;
-
-export type CursorReplayLegacyToolName = (typeof CURSOR_REPLAY_LEGACY_TOOL_NAMES)[number];
-export type CursorReplayToolName = typeof CURSOR_REPLAY_ACTIVITY_TOOL_NAME | CursorReplayLegacyToolName;
-
-const CURSOR_REPLAY_SOURCE_TOOL_NAMES = {
-	cursor_edit: "edit",
-	cursor_write: "write",
-	cursor_read_lints: "readLints",
-	cursor_delete: "delete",
-	cursor_update_todos: "updateTodos",
-	cursor_task: "task",
-	cursor_create_plan: "createPlan",
-	cursor_generate_image: "generateImage",
-	cursor_mcp: "MCP",
-	cursor_sem_search: "semSearch",
-	cursor_record_screen: "recordScreen",
-	cursor_web_search: "web search",
-	cursor_web_fetch: "web fetch",
-} as const satisfies Record<CursorReplayLegacyToolName, string>;
-
-const CURSOR_REPLAY_PROMPT_LABELS = {
-	cursor_edit: "Cursor edit",
-	cursor_write: "Cursor write",
-	cursor_read_lints: "Cursor diagnostics",
-	cursor_delete: "Cursor delete",
-	cursor_update_todos: "Cursor todos",
-	cursor_task: "Cursor task",
-	cursor_create_plan: "Cursor plan",
-	cursor_generate_image: "Cursor image generation",
-	cursor_mcp: "Cursor MCP",
-	cursor_sem_search: "Cursor semantic search",
-	cursor_record_screen: "Cursor screen recording",
-	cursor_web_search: "Cursor web search",
-	cursor_web_fetch: "Cursor web fetch",
-} as const satisfies Record<CursorReplayLegacyToolName, string>;
-
-export const CURSOR_REPLAY_ACTIVITY_LABEL_KEYS_BY_TOOL_NAME = {
-	edit: "cursor_edit",
-	write: "cursor_write",
-	readLints: "cursor_read_lints",
-	delete: "cursor_delete",
-	updateTodos: "cursor_update_todos",
-	task: "cursor_task",
-	createPlan: "cursor_create_plan",
-	generateImage: "cursor_generate_image",
-	mcp: "cursor_mcp",
-	semSearch: "cursor_sem_search",
-	recordScreen: "cursor_record_screen",
-	webSearch: "cursor_web_search",
-	webFetch: "cursor_web_fetch",
-} as const satisfies Record<string, CursorReplayLegacyToolName>;
-
-export type CursorReplayActivityToolName = keyof typeof CURSOR_REPLAY_ACTIVITY_LABEL_KEYS_BY_TOOL_NAME;
-
-export function isCursorReplayLegacyToolName(toolName: string): toolName is CursorReplayLegacyToolName {
-	return CURSOR_REPLAY_LEGACY_TOOL_NAMES.some((legacyToolName) => legacyToolName === toolName);
-}
-
-export function isCursorReplayToolName(toolName: string): toolName is CursorReplayToolName {
-	return toolName === CURSOR_REPLAY_ACTIVITY_TOOL_NAME || isCursorReplayLegacyToolName(toolName);
-}
-
-export function isExcludedFromCursorBridgeExposure(toolName: string): boolean {
-	return isCursorReplayLegacyToolName(toolName) || toolName === CURSOR_REPLAY_ACTIVITY_TOOL_NAME;
-}
-
-export function getCursorReplaySourceToolName(toolName: CursorReplayLegacyToolName): string {
-	return CURSOR_REPLAY_SOURCE_TOOL_NAMES[toolName];
-}
-
-export function getCursorReplayPromptLabel(toolName: string): string {
-	if (toolName === CURSOR_REPLAY_ACTIVITY_TOOL_NAME) return "Cursor activity";
-	if (isCursorReplayLegacyToolName(toolName)) return CURSOR_REPLAY_PROMPT_LABELS[toolName];
-	return toolName;
-}
-
-export function getCursorReplayDisplayLabel(toolName: CursorReplayToolName): string {
-	if (toolName === CURSOR_REPLAY_ACTIVITY_TOOL_NAME) return "Cursor activity";
-	return CURSOR_REPLAY_PROMPT_LABELS[toolName];
-}
-
-export function getCursorReplayActivityLabelKey(toolName: string): CursorReplayLegacyToolName | undefined {
-	return CURSOR_REPLAY_ACTIVITY_LABEL_KEYS_BY_TOOL_NAME[toolName as CursorReplayActivityToolName];
-}
-
-export function getCursorReplayActivityTitle(toolName: string): string | undefined {
-	const labelKey = getCursorReplayActivityLabelKey(toolName);
-	return labelKey ? getCursorReplayDisplayLabel(labelKey) : undefined;
-}
+export {
+	CURSOR_REPLAY_ACTIVITY_LABEL_KEYS_BY_TOOL_NAME,
+	CURSOR_REPLAY_ACTIVITY_TOOL_NAME,
+	CURSOR_REPLAY_LEGACY_TOOL_NAMES,
+	getCursorReplayActivityLabelKey,
+	getCursorReplayActivityTitle,
+	getCursorReplayDisplayLabel,
+	getCursorReplayPromptLabel,
+	getCursorReplaySideEffectDescription,
+	getCursorReplayOperationLabel,
+	getCursorReplayWrapperLabel,
+	isCursorReplayLegacyToolName,
+	isCursorReplayToolName,
+	isExcludedFromCursorBridgeExposure,
+	type CursorReplayActivityToolName,
+	type CursorReplayLegacyToolName,
+	type CursorReplayToolName,
+} from "./cursor-tool-presentation-registry.js";