pi-cursor-sdk 0.1.19 → 0.1.21

package/src/cursor-transcript-tool-formatters.ts

@@ -505,18 +505,6 @@ export function getTodoTotalCount(args: Record<string, unknown>, result: Normali
 	return getNumber(asRecord(result.value), "totalCount") ?? getNumber(args, "totalCount") ?? todos.length;
 }
 
-export function summarizeTodos(args: Record<string, unknown>, result: NormalizedResult): string {
-	const todos = getTodoItems(args, result);
-	const total = getTodoTotalCount(args, result, todos);
-	const completed = todos.filter((todo) => todo.status === "completed").length;
-	const inProgress = todos.filter((todo) => todo.status === "inProgress").length;
-	const pending = todos.filter((todo) => todo.status === "pending").length;
-	const parts = [`${completed}/${total} completed`];
-	if (inProgress > 0) parts.push(`${inProgress} in progress`);
-	if (pending > 0) parts.push(`${pending} pending`);
-	return parts.join(", ");
-}
-
 function formatTodoStatus(status: string | undefined): string {
 	if (status === "completed") return "✓";
 	if (status === "inProgress") return "…";
@@ -532,12 +520,6 @@ export function formatTodos(args: Record<string, unknown>, result: NormalizedRes
 	return joinSections(header, limitText(lines.join("\n"), options));
 }
 
-export function summarizePlan(args: Record<string, unknown>, result: NormalizedResult): string {
-	const planText = getString(args, "plan") ?? getString(asRecord(result.value), "plan");
-	const firstLine = planText ? firstNonEmptyLine(planText) : undefined;
-	return firstLine ? truncateArg(firstLine, 160) : summarizeTodos(args, result);
-}
-
 export function formatPlan(args: Record<string, unknown>, result: NormalizedResult, options: TranscriptOptions): string {
 	if (result.status === "error") return joinSections("createPlan", formatError(result.error));
 	const planText = getString(args, "plan") ?? getString(asRecord(result.value), "plan");
@@ -578,13 +560,6 @@ export function formatTask(args: Record<string, unknown>, result: NormalizedResu
 	return joinSections(`task ${description}`, limitText(taskText || stringifyUnknown(result.value), options));
 }
 
-export function summarizeTask(description: string, taskText: string): string {
-	const firstLine = firstNonEmptyLine(taskText);
-	if (!firstLine) return truncateArg(description);
-	if (description === "task" || description === firstLine) return truncateArg(firstLine);
-	return truncateArg(`${description}: ${firstLine}`, 160);
-}
-
 function getGenerateImageValue(result: NormalizedResult): Record<string, unknown> | undefined {
 	return asRecord(result.value);
 }
@@ -642,16 +617,6 @@ function describeNonTextMcpContent(entry: unknown): string {
 	return `[${type} omitted]`;
 }
 
-export function summarizeSemSearch(args: Record<string, unknown>): string {
-	const query = getString(args, "query") ?? "semantic search";
-	const targetDirectories = getArray(args, "targetDirectories");
-	const dirHint =
-		targetDirectories && targetDirectories.length > 0
-			? ` (${targetDirectories.length} dir${targetDirectories.length === 1 ? "" : "s"})`
-			: "";
-	return truncateArg(`${query}${dirHint}`);
-}
-
 export function formatSemSearch(args: Record<string, unknown>, result: NormalizedResult, options: TranscriptOptions): string {
 	const query = getString(args, "query") ?? "semantic search";
 	const header = `semSearch ${truncateArg(query)}`;
@@ -694,24 +659,6 @@ function formatRecordingDurationMs(ms: number | undefined): string | undefined {
 	return seconds < 60 ? `${seconds.toFixed(1)}s` : `${Math.floor(seconds / 60)}m ${Math.round(seconds % 60)}s`;
 }
 
-export function summarizeRecordScreen(
-	args: Record<string, unknown>,
-	result: NormalizedResult,
-	options: TranscriptOptions,
-): string {
-	const mode = getString(args, "mode");
-	if (result.status === "error") return formatRecordScreenMode(mode);
-	const value = asRecord(result.value);
-	const path = getString(value, "path");
-	const displayPath = path ? formatDisplayPath(path, options.cwd) : undefined;
-	const duration = formatRecordingDurationMs(getNumber(value, "recordingDurationMs"));
-	const modeLabel = formatRecordScreenMode(mode);
-	if (displayPath && duration) return `${displayPath} · ${duration}`;
-	if (displayPath) return displayPath;
-	if (duration) return `${modeLabel} · ${duration}`;
-	return modeLabel;
-}
-
 export function formatRecordScreen(args: Record<string, unknown>, result: NormalizedResult, options: TranscriptOptions): string {
 	const mode = getString(args, "mode");
 	const header = `recordScreen ${formatRecordScreenMode(mode)}`;
@@ -750,12 +697,6 @@ export function getMcpResultPreview(result: NormalizedResult): string | undefine
 	return undefined;
 }
 
-export function summarizeMcp(args: Record<string, unknown>, result: NormalizedResult): string {
-	const toolName = truncateArg(getString(args, "toolName") ?? "mcp");
-	const preview = getMcpResultPreview(result);
-	return preview && preview !== toolName ? `${toolName} · ${preview}` : toolName;
-}
-
 function formatWebToolBody(
 	toolLabel: string,
 	args: Record<string, unknown>,

package/src/cursor-transcript-tool-specs.ts

@@ -1,5 +1,25 @@
-import { CURSOR_REPLAY_ACTIVITY_TOOL_NAME, getCursorReplayDisplayLabel, type CursorReplayLegacyToolName } from "./cursor-tool-names.js";
+import {
+	CURSOR_KNOWN_NORMALIZED_TOOL_NAMES,
+	CURSOR_REPLAY_ACTIVITY_TOOL_NAME,
+	getCursorReplayActivityLabelKey,
+	getCursorReplayActivityTitle,
+	getCursorReplayCallSummary,
+	getCursorReplayDisplayLabel,
+	getCursorToolActivityReplaySpec,
+	getCursorToolGenerateImageReplaySpec,
+	type CursorNormalizedToolName,
+	type CursorReplayActivityToolName,
+	type CursorReplayLegacyToolName,
+} from "./cursor-tool-presentation-registry.js";
 import { resolveCursorEditDiff } from "./cursor-edit-diff.js";
+import {
+	assembleCursorReplayActivityDetails,
+	assembleCursorReplayGenerateImageDetails,
+	buildCursorReplayNativeEditDetails,
+	buildCursorReplayNativeWriteDetails,
+	CURSOR_REPLAY_UNREGISTERED_ACTIVITY_TOOL_NAME,
+	type CursorReplayToolDetails,
+} from "./cursor-replay-tool-details.js";
 import {
 	asRecord,
 	firstNonEmptyLine,
@@ -24,7 +44,6 @@ import {
 	buildReadDisplayArgs,
 	buildShellDisplayArgs,
 	buildWriteDisplayArgs,
-	collectTaskText,
 	formatDelete,
 	formatEdit,
 	formatFallback,
@@ -46,27 +65,13 @@ import {
 	formatWrite,
 	formatNativeReadDisplayContent,
 	getCursorWriteArgContent,
-	getGenerateImageDisplayPath,
-	getGenerateImagePath,
 	getGlobBody,
 	getGrepBody,
 	getLsBody,
-	getReadLintDiagnostics,
-	getReadLintPaths,
 	getShellOutput,
-	getTaskDescription,
-	getTodoItems,
-	getTodoTotalCount,
-	inferImageMimeType,
-	summarizePlan,
-	summarizeMcp,
-	summarizeRecordScreen,
-	summarizeSemSearch,
-	summarizeTask,
-	summarizeTodos,
 	usesLocalReadPreview,
 } from "./cursor-transcript-tool-formatters.js";
-import { extractWebFetchTarget, extractWebSearchQuery } from "./cursor-web-tool-activity.js";
+import type { CursorReplaySummaryArgs } from "./cursor-replay-summary-args.js";
 
 export interface ToolDisplayContext {
 	rawName: string;
@@ -76,17 +81,17 @@ export interface ToolDisplayContext {
 	options: TranscriptOptions;
 }
 
-interface ActivityReplaySpec {
-	labelKey: CursorReplayLegacyToolName;
-	buildActivityArgs: (context: ToolDisplayContext) => Record<string, unknown>;
-	buildActivitySummary: (context: ToolDisplayContext) => string | undefined;
-	buildDetails: (context: ToolDisplayContext, contentText: string) => Record<string, unknown>;
-}
+type NeutralActivityReplayToolName = Exclude<CursorReplayActivityToolName, "edit" | "write" | "generateImage">;
 
 interface ToolDisplaySpec {
 	formatTranscript: (context: ToolDisplayContext) => string;
 	buildPiToolDisplay: (context: ToolDisplayContext) => CursorPiToolDisplay;
-	activityReplay?: ActivityReplaySpec;
+}
+
+function requireReplayActivityLabelKey(normalizedName: CursorReplayActivityToolName): CursorReplayLegacyToolName {
+	const labelKey = getCursorReplayActivityLabelKey(normalizedName);
+	if (!labelKey) throw new Error(`Missing replay activity label for ${normalizedName}`);
+	return labelKey;
 }
 
 function textToolResult(text: string, details?: unknown): PiToolDisplayResult {
@@ -106,51 +111,81 @@ function buildCursorActivityDisplayArgs(
 	};
 }
 
+function buildRegistryReplaySummary(
+	labelKey: CursorReplayLegacyToolName,
+	args: CursorReplaySummaryArgs,
+): string | undefined {
+	return getCursorReplayCallSummary(labelKey, args);
+}
+
 function buildReplaySummaryDisplay(
 	toolName: string,
 	args: Record<string, unknown>,
 	result: NormalizedResult,
 	contentText: string,
-	details: Record<string, unknown>,
+	details: CursorReplayToolDetails,
 ): CursorPiToolDisplay {
 	const isError = result.status === "error";
-	const summary = isError ? details.summary : (details.summary ?? firstNonEmptyLine(contentText));
+	const expandedText = details.expandedText ?? contentText;
+	const summary = details.summary;
 	return {
 		toolName,
 		args,
 		result: textToolResult(contentText, {
 			...details,
 			summary,
-			expandedText: details.expandedText ?? contentText,
+			expandedText,
 		}),
 		isError,
 	};
 }
 
-function buildActivityReplayDisplay(cursorToolName: string, spec: ToolDisplaySpec, context: ToolDisplayContext): CursorPiToolDisplay {
-	const activity = spec.activityReplay;
-	if (!activity) throw new Error(`Missing activity replay spec for ${cursorToolName}`);
-	const activityTitle = getCursorReplayDisplayLabel(activity.labelKey);
-	const activitySummary = activity.buildActivitySummary(context);
-	const activityArgs = buildCursorActivityDisplayArgs(
-		activity.buildActivityArgs(context),
+function getCursorToolActivityTitle(toolName: string): string {
+	return getCursorReplayActivityTitle(toolName) ?? buildGenericUnknownToolActivityTitle(toolName);
+}
+
+function buildActivityReplayDisplay(
+	sourceToolName: NeutralActivityReplayToolName,
+	context: ToolDisplayContext,
+): CursorPiToolDisplay {
+	const spec = TOOL_DISPLAY_SPECS[sourceToolName];
+	const activity = getCursorToolActivityReplaySpec(sourceToolName);
+	if (!activity) throw new Error(`Missing activity replay spec for ${sourceToolName}`);
+	const labelKey = requireReplayActivityLabelKey(sourceToolName);
+	const activityTitle = getCursorReplayDisplayLabel(labelKey);
+	const replayArgs = activity.buildActivityArgs(context);
+	const activitySummary = buildRegistryReplaySummary(labelKey, replayArgs);
+	const activityArgs = buildCursorActivityDisplayArgs({ ...replayArgs }, activityTitle, activitySummary);
+	const contentText = spec.formatTranscript(context).trimEnd();
+	const activityFields = activity.buildDetails(context, contentText);
+	const details = assembleCursorReplayActivityDetails(
+		sourceToolName,
 		activityTitle,
+		activityFields,
+		contentText,
+		context.result.status === "error",
 		activitySummary,
 	);
+	return buildReplaySummaryDisplay(CURSOR_REPLAY_ACTIVITY_TOOL_NAME, activityArgs, context.result, contentText, details);
+}
+
+function buildGenerateImageReplayDisplay(context: ToolDisplayContext): CursorPiToolDisplay {
+	const spec = TOOL_DISPLAY_SPECS.generateImage;
+	const replay = getCursorToolGenerateImageReplaySpec("generateImage");
+	if (!replay) throw new Error("Missing generate image replay spec");
+	const labelKey = requireReplayActivityLabelKey("generateImage");
+	const activityTitle = getCursorReplayDisplayLabel(labelKey);
+	const replayArgs = replay.buildActivityArgs(context);
+	const activitySummary = buildRegistryReplaySummary(labelKey, replayArgs);
+	const activityArgs = buildCursorActivityDisplayArgs({ ...replayArgs }, activityTitle, activitySummary);
 	const contentText = spec.formatTranscript(context).trimEnd();
-	const details = activity.buildDetails(context, contentText);
-	return buildReplaySummaryDisplay(
-		CURSOR_REPLAY_ACTIVITY_TOOL_NAME,
-		activityArgs,
-		context.result,
+	const details = assembleCursorReplayGenerateImageDetails(
+		replay.buildDetails(context, contentText),
 		contentText,
-		{
-			cursorToolName,
-			title: activityTitle,
-			summary: context.result.status === "error" ? undefined : details.summary ?? activitySummary,
-			...details,
-		},
+		context.result.status === "error",
+		activitySummary,
 	);
+	return buildReplaySummaryDisplay(CURSOR_REPLAY_ACTIVITY_TOOL_NAME, activityArgs, context.result, contentText, details);
 }
 
 function buildGenericUnknownToolActivityTitle(displayName: string): string {
@@ -175,12 +210,35 @@ function buildGenericPiToolDisplay(context: ToolDisplayContext): CursorPiToolDis
 		result.status === "error"
 			? undefined
 			: activitySummary ?? truncateArg(displayName === "unknown" ? "tool" : displayName);
-	return buildReplaySummaryDisplay(CURSOR_REPLAY_ACTIVITY_TOOL_NAME, activityArgs, result, contentText, {
-		cursorToolName: name,
-		title: activityTitle,
-		summary,
-		expandedText: contentText,
-	});
+	return buildReplaySummaryDisplay(
+		CURSOR_REPLAY_ACTIVITY_TOOL_NAME,
+		activityArgs,
+		result,
+		contentText,
+		assembleCursorReplayActivityDetails(
+			CURSOR_REPLAY_UNREGISTERED_ACTIVITY_TOOL_NAME,
+			activityTitle,
+			{ summary, expandedText: contentText },
+			contentText,
+			result.status === "error",
+			activitySummary,
+		),
+	);
+}
+
+function buildEditActivitySummary(
+	displayPath: string | undefined,
+	value: Record<string, unknown>,
+): string | undefined {
+	const path = displayPath ?? "replayed";
+	const linesAdded = getNumber(value, "linesAdded");
+	const linesRemoved = getNumber(value, "linesRemoved");
+	const parts = [
+		linesAdded ? `added ${linesAdded} line${linesAdded === 1 ? "" : "s"}` : undefined,
+		linesRemoved ? `removed ${linesRemoved} line${linesRemoved === 1 ? "" : "s"}` : undefined,
+	].filter((part): part is string => Boolean(part));
+	if (parts.length > 0) return `${path} ${parts.join(", ")}`;
+	return path;
 }
 
 function buildEditPiToolDisplay(context: ToolDisplayContext): CursorPiToolDisplay {
@@ -191,18 +249,17 @@ function buildEditPiToolDisplay(context: ToolDisplayContext): CursorPiToolDispla
 	const nativeEditArgs = buildNativeEditDisplayArgs(rawName, args, options);
 	const baseActivityArgs = buildCursorEditActivityDisplayArgs(args, options);
 	const displayPath = typeof baseActivityArgs.path === "string" ? baseActivityArgs.path : undefined;
-	const activityTitle = getCursorReplayDisplayLabel("cursor_edit");
+	const activityTitle = getCursorToolActivityTitle("edit");
 	const activityArgs = buildCursorActivityDisplayArgs(baseActivityArgs, activityTitle, displayPath);
 	const contentText = formatEdit(activityArgs, result, options);
-	const details = {
-		cursorToolName: "edit",
+	const details = buildCursorReplayNativeEditDetails({
 		path: displayPath,
 		linesAdded: getNumber(value, "linesAdded"),
 		linesRemoved: getNumber(value, "linesRemoved"),
 		diffString: normalizedDiff,
 		diff: normalizedDiff,
 		firstChangedLine: getNumber(value, "firstChangedLine"),
-	};
+	});
 	if (nativeEditArgs) {
 		return {
 			toolName: "edit",
@@ -216,11 +273,22 @@ function buildEditPiToolDisplay(context: ToolDisplayContext): CursorPiToolDispla
 		activityArgs,
 		result,
 		contentText.trimEnd(),
-		{
-			...details,
-			title: activityTitle,
-			summary: result.status === "error" ? undefined : displayPath ?? "replayed",
-		},
+		assembleCursorReplayActivityDetails(
+			"edit",
+			activityTitle,
+			{
+				path: displayPath,
+				summary: result.status === "error" ? undefined : buildEditActivitySummary(displayPath, value ?? {}),
+				expandedText: contentText.trimEnd(),
+				diffString: normalizedDiff,
+				diff: normalizedDiff,
+				linesAdded: getNumber(value, "linesAdded"),
+				linesRemoved: getNumber(value, "linesRemoved"),
+			},
+			contentText.trimEnd(),
+			result.status === "error",
+			displayPath,
+		),
 	);
 }
 
@@ -231,26 +299,33 @@ function buildWritePiToolDisplay(context: ToolDisplayContext): CursorPiToolDispl
 	const displayArgs = buildWriteDisplayArgs(args, options);
 	const displayPath = typeof args.path === "string" ? formatDisplayPath(args.path, options.cwd) : undefined;
 	const contentText = formatWrite(args, result, options).trimEnd();
-	const details = {
-		cursorToolName: "write",
+	const details = buildCursorReplayNativeWriteDetails({
 		path: displayPath,
 		linesCreated: getNumber(value, "linesCreated"),
 		fileSize: getNumber(value, "fileSize"),
 		fileContentAfterWrite: getString(value, "fileContentAfterWrite"),
 		expandedText: contentText,
-	};
+	});
 	if (content === undefined) {
-		const activityTitle = getCursorReplayDisplayLabel("cursor_write");
+		const activityTitle = getCursorToolActivityTitle("write");
 		return buildReplaySummaryDisplay(
 			CURSOR_REPLAY_ACTIVITY_TOOL_NAME,
 			buildCursorActivityDisplayArgs(displayArgs, activityTitle, displayPath ?? "file"),
 			result,
 			contentText,
-			{
-				...details,
-				title: activityTitle,
-				summary: result.status === "error" ? undefined : displayPath ?? "wrote file",
-			},
+			assembleCursorReplayActivityDetails(
+				"write",
+				activityTitle,
+				{
+					path: displayPath,
+					summary: result.status === "error" ? undefined : displayPath ?? "wrote file",
+					expandedText: contentText,
+					fileContentAfterWrite: getString(value, "fileContentAfterWrite"),
+				},
+				contentText,
+				result.status === "error",
+				displayPath ?? "file",
+			),
 		);
 	}
 	return {
@@ -261,7 +336,7 @@ function buildWritePiToolDisplay(context: ToolDisplayContext): CursorPiToolDispl
 	};
 }
 
-const TOOL_DISPLAY_SPECS: Record<string, ToolDisplaySpec> = {
+const TOOL_DISPLAY_IMPLEMENTATIONS: Record<CursorNormalizedToolName, ToolDisplaySpec> = {
 	read: {
 		formatTranscript: ({ args, result, options }) => formatRead(args, result, options),
 		buildPiToolDisplay: ({ args, result, options }) => {
@@ -334,207 +409,69 @@ const TOOL_DISPLAY_SPECS: Record<string, ToolDisplaySpec> = {
 	},
 	delete: {
 		formatTranscript: ({ args, result, options }) => formatDelete(args, result, options),
-		buildPiToolDisplay: (context) => buildActivityReplayDisplay("delete", TOOL_DISPLAY_SPECS.delete, context),
-		activityReplay: {
-			labelKey: "cursor_delete",
-			buildActivityArgs: ({ args, options }) => {
-				const displayPath = typeof args.path === "string" ? formatDisplayPath(args.path, options.cwd) : undefined;
-				return displayPath ? { path: displayPath } : {};
-			},
-			buildActivitySummary: ({ args, options }) => {
-				const displayPath = typeof args.path === "string" ? formatDisplayPath(args.path, options.cwd) : undefined;
-				return displayPath ?? "file";
-			},
-			buildDetails: ({ args, result, options }) => {
-				const displayPath = typeof args.path === "string" ? formatDisplayPath(args.path, options.cwd) : undefined;
-				const value = asRecord(result.value);
-				return {
-					path: displayPath,
-					fileSize: getNumber(value, "fileSize"),
-					summary: result.status === "error" ? undefined : displayPath ? `deleted ${displayPath}` : "deleted file",
-				};
-			},
-		},
+		buildPiToolDisplay: (context) => buildActivityReplayDisplay("delete", context),
 	},
 	readLints: {
 		formatTranscript: ({ args, result, options }) => formatReadLints(args, result, options),
-		buildPiToolDisplay: (context) => buildActivityReplayDisplay("readLints", TOOL_DISPLAY_SPECS.readLints, context),
-		activityReplay: {
-			labelKey: "cursor_read_lints",
-			buildActivityArgs: ({ args, result, options }) => {
-				const paths = getReadLintPaths(args, result, options);
-				const diagnosticCount = getReadLintDiagnostics(result, options).length;
-				return { paths, diagnosticCount };
-			},
-			buildActivitySummary: ({ args, result, options }) => {
-				const paths = getReadLintPaths(args, result, options);
-				const diagnosticCount = getReadLintDiagnostics(result, options).length;
-				return `${diagnosticCount} diagnostic${diagnosticCount === 1 ? "" : "s"}${paths.length > 0 ? ` in ${paths.join(", ")}` : ""}`;
-			},
-			buildDetails: () => ({}),
-		},
+		buildPiToolDisplay: (context) => buildActivityReplayDisplay("readLints", context),
 	},
 	updateTodos: {
 		formatTranscript: ({ args, result, options }) => formatTodos(args, result, options, "updateTodos"),
-		buildPiToolDisplay: (context) => buildActivityReplayDisplay("updateTodos", TOOL_DISPLAY_SPECS.updateTodos, context),
-		activityReplay: {
-			labelKey: "cursor_update_todos",
-			buildActivityArgs: ({ args, result }) => {
-				const todos = getTodoItems(args, result);
-				return { totalCount: getTodoTotalCount(args, result, todos) };
-			},
-			buildActivitySummary: ({ args, result }) => summarizeTodos(args, result),
-			buildDetails: () => ({}),
-		},
+		buildPiToolDisplay: (context) => buildActivityReplayDisplay("updateTodos", context),
 	},
 	createPlan: {
 		formatTranscript: ({ args, result, options }) => formatPlan(args, result, options),
-		buildPiToolDisplay: (context) => buildActivityReplayDisplay("createPlan", TOOL_DISPLAY_SPECS.createPlan, context),
-		activityReplay: {
-			labelKey: "cursor_create_plan",
-			buildActivityArgs: ({ args, result }) => {
-				const todos = getTodoItems(args, result);
-				return { totalCount: getTodoTotalCount(args, result, todos) };
-			},
-			buildActivitySummary: ({ args, result }) => summarizePlan(args, result),
-			buildDetails: () => ({}),
-		},
+		buildPiToolDisplay: (context) => buildActivityReplayDisplay("createPlan", context),
 	},
 	task: {
 		formatTranscript: ({ args, result, options }) => formatTask(args, result, options),
-		buildPiToolDisplay: (context) => buildActivityReplayDisplay("task", TOOL_DISPLAY_SPECS.task, context),
-		activityReplay: {
-			labelKey: "cursor_task",
-			buildActivityArgs: ({ args, result }) => {
-				const description = getTaskDescription(args, result);
-				return { description: truncateArg(description) };
-			},
-			buildActivitySummary: ({ args, result }) => {
-				const description = getTaskDescription(args, result);
-				return summarizeTask(description, collectTaskText(result));
-			},
-			buildDetails: () => ({}),
-		},
+		buildPiToolDisplay: (context) => buildActivityReplayDisplay("task", context),
 	},
 	generateImage: {
 		formatTranscript: ({ args, result, options }) => formatGenerateImage(args, result, options),
-		buildPiToolDisplay: (context) => buildActivityReplayDisplay("generateImage", TOOL_DISPLAY_SPECS.generateImage, context),
-		activityReplay: {
-			labelKey: "cursor_generate_image",
-			buildActivityArgs: ({ args }) => {
-				const prompt = getString(args, "prompt") ?? getString(args, "description") ?? "image";
-				return { prompt: truncateArg(prompt) };
-			},
-			buildActivitySummary: ({ args, result, options }) => {
-				const prompt = getString(args, "prompt") ?? getString(args, "description") ?? "image";
-				const imageDisplayPath = getGenerateImageDisplayPath(args, result, options);
-				return imageDisplayPath ?? truncateArg(prompt);
-			},
-			buildDetails: ({ args, result, options }, contentText) => {
-				const imagePath = getGenerateImagePath(args, result);
-				const imageDisplayPath = getGenerateImageDisplayPath(args, result, options);
-				return {
-					imagePath,
-					imageDisplayPath,
-					imageMimeType: inferImageMimeType(imagePath),
-					summary: result.status === "error" ? undefined : imageDisplayPath ? `saved ${imageDisplayPath}` : "image generated",
-					expandedText: contentText,
-				};
-			},
-		},
+		buildPiToolDisplay: (context) => buildGenerateImageReplayDisplay(context),
 	},
 	mcp: {
 		formatTranscript: ({ args, result, options }) => formatMcp(args, result, options),
-		buildPiToolDisplay: (context) => buildActivityReplayDisplay("mcp", TOOL_DISPLAY_SPECS.mcp, context),
-		activityReplay: {
-			labelKey: "cursor_mcp",
-			buildActivityArgs: ({ args }) => {
-				const toolName = getString(args, "toolName") ?? "mcp";
-				return { toolName: truncateArg(toolName) };
-			},
-			buildActivitySummary: ({ args, result }) => summarizeMcp(args, result),
-			buildDetails: ({ args, result }) => ({
-				summary: result.status === "error" ? undefined : summarizeMcp(args, result),
-			}),
-		},
+		buildPiToolDisplay: (context) => buildActivityReplayDisplay("mcp", context),
 	},
 	semSearch: {
 		formatTranscript: ({ args, result, options }) => formatSemSearch(args, result, options),
-		buildPiToolDisplay: (context) => buildActivityReplayDisplay("semSearch", TOOL_DISPLAY_SPECS.semSearch, context),
-		activityReplay: {
-			labelKey: "cursor_sem_search",
-			buildActivityArgs: ({ args }) => {
-				const query = getString(args, "query") ?? "semantic search";
-				return { query: truncateArg(query) };
-			},
-			buildActivitySummary: ({ args }) => summarizeSemSearch(args),
-			buildDetails: ({ result }, contentText) => ({
-				summary: result.status === "error" ? undefined : firstNonEmptyLine(contentText) ?? "semantic search results captured",
-			}),
-		},
+		buildPiToolDisplay: (context) => buildActivityReplayDisplay("semSearch", context),
 	},
 	recordScreen: {
 		formatTranscript: ({ args, result, options }) => formatRecordScreen(args, result, options),
-		buildPiToolDisplay: (context) => buildActivityReplayDisplay("recordScreen", TOOL_DISPLAY_SPECS.recordScreen, context),
-		activityReplay: {
-			labelKey: "cursor_record_screen",
-			buildActivityArgs: ({ args, result, options }) => {
-				const mode = getString(args, "mode");
-				const path = getString(asRecord(result.value), "path");
-				return {
-					...(mode ? { mode } : {}),
-					...(path ? { path: formatDisplayPath(path, options.cwd) } : {}),
-				};
-			},
-			buildActivitySummary: ({ args, result, options }) => summarizeRecordScreen(args, result, options),
-			buildDetails: ({ args, result, options }, contentText) => ({
-				summary:
-					result.status === "error"
-						? undefined
-						: summarizeRecordScreen(args, result, options) ?? firstNonEmptyLine(contentText) ?? "screen recording updated",
-			}),
-		},
+		buildPiToolDisplay: (context) => buildActivityReplayDisplay("recordScreen", context),
 	},
 	webSearch: {
 		formatTranscript: ({ args, result, options }) => formatWebSearch(args, result, options),
-		buildPiToolDisplay: (context) => buildActivityReplayDisplay("webSearch", TOOL_DISPLAY_SPECS.webSearch, context),
-		activityReplay: {
-			labelKey: "cursor_web_search",
-			buildActivityArgs: ({ args }) => {
-				const query = extractWebSearchQuery(args);
-				return query ? { query: truncateArg(query) } : {};
-			},
-			buildActivitySummary: ({ args }) => truncateArg(extractWebSearchQuery(args) ?? "web search"),
-			buildDetails: ({ result }, contentText) => ({
-				summary: result.status === "error" ? undefined : firstNonEmptyLine(contentText) ?? "web search result captured",
-			}),
-		},
+		buildPiToolDisplay: (context) => buildActivityReplayDisplay("webSearch", context),
 	},
 	webFetch: {
 		formatTranscript: ({ args, result, options }) => formatWebFetch(args, result, options),
-		buildPiToolDisplay: (context) => buildActivityReplayDisplay("webFetch", TOOL_DISPLAY_SPECS.webFetch, context),
-		activityReplay: {
-			labelKey: "cursor_web_fetch",
-			buildActivityArgs: ({ args }) => {
-				const target = extractWebFetchTarget(args);
-				return target ? { url: truncateArg(target) } : {};
-			},
-			buildActivitySummary: ({ args }) => truncateArg(extractWebFetchTarget(args) ?? "web fetch"),
-			buildDetails: ({ result }, contentText) => ({
-				summary: result.status === "error" ? undefined : firstNonEmptyLine(contentText) ?? "web fetch result captured",
-			}),
-		},
+		buildPiToolDisplay: (context) => buildActivityReplayDisplay("webFetch", context),
 	},
 };
 
+export const CURSOR_TOOL_DISPLAY_SPEC_KEYS = CURSOR_KNOWN_NORMALIZED_TOOL_NAMES;
+
+const TOOL_DISPLAY_SPECS = Object.fromEntries(
+	CURSOR_KNOWN_NORMALIZED_TOOL_NAMES.map((name) => [name, TOOL_DISPLAY_IMPLEMENTATIONS[name]]),
+) as Record<CursorNormalizedToolName, ToolDisplaySpec>;
+
+function getToolDisplaySpec(name: string): ToolDisplaySpec | undefined {
+	if (Object.hasOwn(TOOL_DISPLAY_SPECS, name)) return TOOL_DISPLAY_SPECS[name as CursorNormalizedToolName];
+	return undefined;
+}
+
 export function formatCursorToolTranscriptFromSpec(context: ToolDisplayContext): string {
-	const spec = TOOL_DISPLAY_SPECS[context.name];
+	const spec = getToolDisplaySpec(context.name);
 	if (spec) return spec.formatTranscript(context);
 	return formatFallback(context.name, context.args, context.result, context.options);
 }
 
 export function buildCursorPiToolDisplayFromSpec(context: ToolDisplayContext): CursorPiToolDisplay {
-	const spec = TOOL_DISPLAY_SPECS[context.name];
+	const spec = getToolDisplaySpec(context.name);
 	if (spec) return spec.buildPiToolDisplay(context);
 	return buildGenericPiToolDisplay(context);
 }