@herbertgao/pi-extensions 2026.9.9 → 2026.9.11

package/node_modules/pi-multi-account/cursor/session-lifecycle.ts

@@ -0,0 +1,40 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+type SessionContext = { sessionManager: { getSessionId(): string; getLeafId?: () => string } };
+
+export function registerSessionLifecycleHooks(
+  pi: ExtensionAPI,
+  dependencies: {
+    cleanupSessionState: (sessionId: string) => void;
+    /** Start a new Cursor-side conversation, keeping the session alive. */
+    resetConversationForSession?: (sessionId: string) => void;
+    debug?: (event: string, data: Record<string, unknown>) => void;
+  },
+): void {
+  const cleanupCurrentSession = (_event: unknown, ctx: SessionContext) => {
+    dependencies.debug?.("session.cleanup_hook", {
+      sessionId: ctx.sessionManager.getSessionId(),
+      leafId: ctx.sessionManager.getLeafId?.(),
+    });
+    dependencies.cleanupSessionState(ctx.sessionManager.getSessionId());
+  };
+
+  pi.on("session_before_switch", cleanupCurrentSession as any);
+  pi.on("session_before_fork", cleanupCurrentSession as any);
+  pi.on("session_before_tree", cleanupCurrentSession as any);
+  // Compaction is the one event that changes what the conversation IS without ending it.
+  // Cursor never sees Pi's compacted message list while it holds a checkpoint, so unless the
+  // conversation is restarted here, the model keeps the full pre-compaction context and keeps
+  // reporting its size — which sends Pi straight into compacting again on the next turn.
+  pi.on("session_compact", ((_event: unknown, ctx: SessionContext) => {
+    const sessionId = ctx.sessionManager.getSessionId();
+    dependencies.debug?.("session.compact_hook", {
+      sessionId,
+      leafId: ctx.sessionManager.getLeafId?.(),
+    });
+    dependencies.resetConversationForSession?.(sessionId);
+  }) as any);
+  pi.on("session_shutdown", ((event: unknown, ctx: SessionContext) => {
+    cleanupCurrentSession(event, ctx);
+  }) as any);
+}

package/node_modules/pi-multi-account/cursor/sse-keepalive.ts

@@ -0,0 +1,24 @@
+import type { ServerResponse } from "node:http";
+
+/** Flush headers before the first model token, then send SSE comments during pauses. */
+export const SSE_KEEPALIVE_INTERVAL_MS = 15_000;
+
+/** Open a streaming SSE response and keep it warm. Returns the function that stops the keepalive. */
+export function startSSEResponse(res: ServerResponse, keepaliveIntervalMs = SSE_KEEPALIVE_INTERVAL_MS): () => void {
+  res.writeHead(200, {
+    "Content-Type": "text/event-stream",
+    "Cache-Control": "no-cache",
+    "Connection": "keep-alive",
+  });
+  res.flushHeaders();
+
+  const timer = setInterval(() => {
+    if (res.writableEnded || res.destroyed) {
+      clearInterval(timer);
+      return;
+    }
+    res.write(": keepalive\n\n");
+  }, keepaliveIntervalMs);
+
+  return () => clearInterval(timer);
+}

package/node_modules/pi-multi-account/cursor/stream-lifecycle.ts

@@ -0,0 +1,193 @@
+/**
+ * Cursor's gRPC agent is not an OpenAI chat completion. This module is the
+ * contract that makes one Cursor Run look like one Pi provider turn:
+ *
+ * - a turn ends when Cursor says so (`turnEnded`), not when the TCP stream happens
+ *   to close;
+ * - only user-visible tokens (text, thinking, token deltas) and Pi-bound tool
+ *   calls count as forward progress for the stall watchdog;
+ * - heartbeats, checkpoints, blob fetches, rejected native tools and mid-turn
+ *   questions do not keep the spinner alive.
+ */
+
+export const NATIVE_TOOL_UNAVAILABLE =
+	"Tool not available in this environment. Use the MCP tools provided instead.";
+
+/**
+ * Cursor often emits sibling `read`/`shell` execs as separate gRPC frames a few
+ * milliseconds apart. Closing the OpenAI stream on the first one leaves the rest
+ * unanswered and Pi stuck on Working. Wait this long after the last Pi-bound exec
+ * so they share one `tool_calls` pause.
+ */
+export const TOOL_CALL_COALESCE_MS = 75;
+
+/** `PI_CURSOR_TOOL_COALESCE_MS` overrides the window; non-positive or garbage falls back. */
+export function resolveToolCallCoalesceMs(env: NodeJS.ProcessEnv = process.env): number {
+	const raw = env.PI_CURSOR_TOOL_COALESCE_MS?.trim();
+	if (raw === undefined || raw === "") return TOOL_CALL_COALESCE_MS;
+	const parsed = Number(raw);
+	if (!Number.isInteger(parsed) || parsed < 1 || parsed > 2_147_483_647) return TOOL_CALL_COALESCE_MS;
+	return parsed;
+}
+
+export type CursorFrameKind =
+	| "heartbeat"
+	| "visible"
+	| "housekeeping"
+	| "turnEnded"
+	| "mcpExec"
+	| "nativeExec"
+	| "interactionQuery"
+	| "execControl"
+	| "unknown";
+
+export type CursorFrameClass = {
+	kind: CursorFrameKind;
+	/** Reset the stall watchdog. Housekeeping must never do this. */
+	countsAsProgress: boolean;
+	/** Finish the OpenAI stream with stop, matching every other provider. */
+	completesTurn: boolean;
+};
+
+const VISIBLE_UPDATES = new Set(["textDelta", "thinkingDelta", "tokenDelta"]);
+
+export function classifyCursorFrame(input: {
+	messageCase?: string;
+	updateCase?: string;
+	execCase?: string;
+}): CursorFrameClass {
+	const messageCase = input.messageCase;
+	if (!messageCase) return { kind: "unknown", countsAsProgress: false, completesTurn: false };
+
+	if (messageCase === "interactionUpdate") {
+		const updateCase = input.updateCase;
+		if (!updateCase || updateCase === "heartbeat") {
+			return { kind: "heartbeat", countsAsProgress: false, completesTurn: false };
+		}
+		if (updateCase === "turnEnded") {
+			return { kind: "turnEnded", countsAsProgress: false, completesTurn: true };
+		}
+		if (VISIBLE_UPDATES.has(updateCase)) {
+			return { kind: "visible", countsAsProgress: true, completesTurn: false };
+		}
+		return { kind: "housekeeping", countsAsProgress: false, completesTurn: false };
+	}
+
+	if (messageCase === "execServerMessage") {
+		if (input.execCase === "mcpArgs") {
+			return { kind: "mcpExec", countsAsProgress: true, completesTurn: false };
+		}
+		if (input.execCase === "requestContextArgs" || input.execCase === "diagnosticsArgs") {
+			return { kind: "housekeeping", countsAsProgress: false, completesTurn: false };
+		}
+		return { kind: "nativeExec", countsAsProgress: false, completesTurn: false };
+	}
+
+	if (messageCase === "kvServerMessage" || messageCase === "conversationCheckpointUpdate") {
+		return { kind: "housekeeping", countsAsProgress: false, completesTurn: false };
+	}
+	if (messageCase === "interactionQuery") {
+		return { kind: "interactionQuery", countsAsProgress: false, completesTurn: false };
+	}
+	if (messageCase === "execServerControlMessage") {
+		return { kind: "execControl", countsAsProgress: false, completesTurn: false };
+	}
+	return { kind: "unknown", countsAsProgress: false, completesTurn: false };
+}
+
+export type NativeExecForward = {
+	toolName: string;
+	args: Record<string, unknown>;
+	resultCase: string;
+};
+
+function quote(value: string): string {
+	return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+
+function asString(value: unknown): string {
+	return typeof value === "string" ? value : String(value ?? "");
+}
+
+/**
+ * Cursor's own read/shell/write tools are not a Pi sandbox. Map them onto the
+ * MCP tools Pi already exposed for this turn so the model gets real results
+ * instead of an infinite reject loop.
+ */
+export function mapNativeExecToPiTool(
+	execCase: string,
+	args: Record<string, unknown>,
+	availableTools: Iterable<string>,
+): NativeExecForward | undefined {
+	const tools = availableTools instanceof Set ? availableTools : new Set(availableTools);
+	const has = (name: string) => tools.has(name);
+	const bash = (command: string, resultCase: string): NativeExecForward | undefined =>
+		has("bash") ? { toolName: "bash", args: { command }, resultCase } : undefined;
+
+	switch (execCase) {
+		case "readArgs":
+			if (has("read")) return { toolName: "read", args: { path: asString(args.path) }, resultCase: "readResult" };
+			return bash(`cat -- ${quote(asString(args.path))}`, "readResult");
+		case "writeArgs":
+			if (has("write")) {
+				return {
+					toolName: "write",
+					args: { path: asString(args.path), content: asString(args.fileText ?? args.content) },
+					resultCase: "writeResult",
+				};
+			}
+			return undefined;
+		case "grepArgs":
+			if (has("grep")) {
+				const forwarded: Record<string, unknown> = { pattern: asString(args.pattern) };
+				if (args.path) forwarded.path = args.path;
+				if (args.glob) forwarded.glob = args.glob;
+				return { toolName: "grep", args: forwarded, resultCase: "grepResult" };
+			}
+			return bash(
+				`rg --line-number --color never ${quote(asString(args.pattern))}${args.path ? ` -- ${quote(asString(args.path))}` : ""}`,
+				"grepResult",
+			);
+		case "lsArgs":
+			if (has("ls")) return { toolName: "ls", args: { path: asString(args.path) }, resultCase: "lsResult" };
+			return bash(`ls -la -- ${quote(asString(args.path))}`, "lsResult");
+		case "deleteArgs":
+			return bash(`rm -f -- ${quote(asString(args.path))}`, "deleteResult");
+		case "shellArgs":
+		case "shellStreamArgs":
+			if (has("bash")) {
+				return {
+					toolName: "bash",
+					args: {
+						command: asString(args.command),
+						...(args.workingDirectory ? { cwd: asString(args.workingDirectory) } : {}),
+					},
+					resultCase: execCase === "shellStreamArgs" ? "shellStream" : "shellResult",
+				};
+			}
+			return undefined;
+		default:
+			return undefined;
+	}
+}
+
+export function interactionQueryResultCase(queryCase: string | undefined): string | undefined {
+	switch (queryCase) {
+		case "webSearchRequestQuery":
+			return "webSearchRequestResponse";
+		case "askQuestionInteractionQuery":
+			return "askQuestionInteractionResponse";
+		case "switchModeRequestQuery":
+			return "switchModeRequestResponse";
+		case "exaSearchRequestQuery":
+			return "exaSearchRequestResponse";
+		case "exaFetchRequestQuery":
+			return "exaFetchRequestResponse";
+		case "createPlanRequestQuery":
+			return "createPlanRequestResponse";
+		case "setupVmEnvironmentArgs":
+			return "setupVmEnvironmentResult";
+		default:
+			return undefined;
+	}
+}

package/node_modules/pi-multi-account/cursor/upstream-watchdog.ts

@@ -0,0 +1,88 @@
+/**
+ * SSE keepalives preserve Pi's client connection even when Cursor stops making progress.
+ * Two clocks are intentionally separate:
+ *   - every complete decoded Cursor frame proves the HTTP/2 transport is alive;
+ *   - only user-visible tokens and Pi-bound tools prove useful model progress.
+ * A single one-minute semantic clock killed healthy long-reasoning Runs and falsely looked
+ * like exhausted Cursor quota to multi-account.
+ */
+
+/** A Run producing no complete upstream frame is treated as dead after one minute. */
+export const TRANSPORT_STALL_TIMEOUT_MS = 60_000;
+/** A live transport may reason quietly, but housekeeping cannot keep it alive forever. */
+export const UPSTREAM_STALL_TIMEOUT_MS = 5 * 60_000;
+
+function resolveTimeout(raw: string | undefined, fallback: number): number {
+  const value = raw?.trim();
+  if (value === undefined || value === "") return fallback;
+  const parsed = Number(value);
+  // Node reduces delays above its signed 32-bit limit to one millisecond.
+  if (!Number.isInteger(parsed) || parsed < 0 || parsed > 2_147_483_647) return fallback;
+  return parsed;
+}
+
+/** `PI_CURSOR_TRANSPORT_STALL_MS` overrides the no-frame window; `0` disables it. */
+export function resolveTransportStallTimeoutMs(env: NodeJS.ProcessEnv = process.env): number {
+  return resolveTimeout(env.PI_CURSOR_TRANSPORT_STALL_MS, TRANSPORT_STALL_TIMEOUT_MS);
+}
+
+/** `PI_CURSOR_UPSTREAM_STALL_MS` overrides the useful-output window; `0` disables it. */
+export function resolveUpstreamStallTimeoutMs(env: NodeJS.ProcessEnv = process.env): number {
+  return resolveTimeout(env.PI_CURSOR_UPSTREAM_STALL_MS, UPSTREAM_STALL_TIMEOUT_MS);
+}
+
+export function formatStallDuration(ms: number): string {
+  const totalSeconds = Math.floor(ms / 1000);
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  if (minutes === 0) return `${seconds}s`;
+  if (seconds === 0) return `${minutes}m`;
+  return `${minutes}m ${seconds}s`;
+}
+
+export interface UpstreamWatchdog {
+  /** Record decoded upstream progress; the stall deadline moves forward. */
+  touch(): void;
+  /** Retire the watchdog. Idempotent; later touches are ignored. */
+  stop(): void;
+}
+
+/**
+ * Arm a stall watchdog. `onStall` runs at most once, with how long upstream had been silent.
+ * A non-positive `timeoutMs` produces an inert watchdog.
+ */
+export function startUpstreamWatchdog(onStall: (silentForMs: number) => void, timeoutMs: number): UpstreamWatchdog {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  let stopped = timeoutMs <= 0;
+  let lastProgressAt = performance.now();
+
+  const arm = (delayMs = timeoutMs) => {
+    if (stopped) return;
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(() => {
+      if (stopped) return;
+      const silentForMs = performance.now() - lastProgressAt;
+      // Timers may wake early. Recheck a monotonic deadline before ending the stream.
+      if (silentForMs < timeoutMs) { arm(Math.ceil(timeoutMs - silentForMs)); return; }
+      stopped = true;
+      timer = undefined;
+      onStall(silentForMs);
+    }, delayMs);
+    timer.unref?.();
+  };
+
+  arm();
+
+  return {
+    touch() {
+      if (stopped) return;
+      lastProgressAt = performance.now();
+      arm();
+    },
+    stop() {
+      stopped = true;
+      if (timer) clearTimeout(timer);
+      timer = undefined;
+    },
+  };
+}

package/node_modules/pi-multi-account/cursor-bridge.ts

@@ -0,0 +1,240 @@
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+const VENDORED_CURSOR_ROOT = join(dirname(fileURLToPath(import.meta.url)), "cursor");
+
+export const CURSOR_BASE = "cursor";
+
+/**
+ * The one bearer value the vendored proxy treats as "no usable token on this request",
+ * falling back to the base slot's stored credential (see `bearerFromRequest` in
+ * cursor/cursor-shared.ts). It is a marker, not a secret: the proxy listens on
+ * 127.0.0.1 only and supplies the real Cursor token itself.
+ *
+ * It exists so a slot published into pi's static models.json is USABLE by a bare
+ * `pi -p` child, which cannot read the OAuth token this extension holds. Locked to the
+ * vendored provider by a test — if the provider ever stops recognising this exact
+ * string, publishing it would silently send a bogus token instead.
+ */
+export const CURSOR_PROXY_PLACEHOLDER_KEY = "cursor-proxy";
+
+export function isCursorProviderId(id: string): boolean {
+	return id === CURSOR_BASE || /^cursor-account-\d+$/.test(id);
+}
+
+/**
+ * Where Cursor implementation is loaded from.
+ *
+ * Production always uses the copy vendored next to this file (`./cursor`).
+ * `PI_CURSOR_PROVIDER_ROOT` is a test seam only: the suite points it at a stub
+ * or an empty directory so it can exercise load failures without starting the
+ * real proxy.
+ */
+export function getCursorProviderRoot(): string {
+	return process.env.PI_CURSOR_PROVIDER_ROOT || VENDORED_CURSOR_ROOT;
+}
+
+export function isCursorProviderInstalled(): boolean {
+	return existsSync(join(getCursorProviderRoot(), "cursor-shared.ts"));
+}
+
+type CursorShared = {
+	ensureCursorProxy: (
+		resolve: (providerId: string) => Promise<string>,
+	) => Promise<number>;
+	registerCursorProvider: (...args: any[]) => void;
+	FALLBACK_MODELS: unknown[];
+	discoverCursorModels?: (accessToken: string) => Promise<unknown[]>;
+};
+type CursorIndex = {
+	registerSessionLifecycleCleanup?: (pi: ExtensionAPI) => void;
+	cleanupControllerSession?: (sessionId: string) => void;
+};
+
+let sharedModPromise: Promise<CursorShared | undefined> | undefined;
+let indexMod: CursorIndex | undefined;
+let proxyPort: number | undefined;
+let loadAttempt = 0;
+
+function loadSpecifier(entry: string): string {
+	return loadAttempt === 0
+		? entry
+		: `${pathToFileURL(entry).href}?pi-multi-account-retry=${loadAttempt}`;
+}
+
+/**
+ * Cache the in-flight PROMISE, not the settled module.
+ *
+ * Discovery fires this without awaiting while `session_start` awaits its own call, so both
+ * used to reach the import at once. A second concurrent import of the same module observes it
+ * mid-initialization: hoisted functions are already callable while its `let` state is still in
+ * the temporal dead zone, which surfaced as "Cannot access 'tokenResolver' before
+ * initialization" and cost the session every Cursor account. One shared promise means the
+ * module is imported exactly once, no matter how many callers race.
+ */
+async function loadCursorModules(): Promise<CursorShared | undefined> {
+	sharedModPromise ??= (async () => {
+		const entry = join(getCursorProviderRoot(), "cursor-shared.ts");
+		if (!existsSync(entry)) return undefined;
+		try {
+			const shared = (await import(
+				/* @vite-ignore */ loadSpecifier(entry)
+			)) as CursorShared;
+			const indexEntry = join(getCursorProviderRoot(), "index.ts");
+			if (existsSync(indexEntry)) {
+				indexMod = (await import(
+					/* @vite-ignore */ loadSpecifier(indexEntry)
+				)) as CursorIndex;
+			}
+			return shared;
+		} catch (error) {
+			sharedModPromise = undefined;
+			loadAttempt++;
+			throw error;
+		}
+	})();
+	return sharedModPromise;
+}
+
+type AuthEntry = {
+	type?: string;
+	access?: string;
+	refresh?: string;
+	expires?: number;
+	key?: string;
+	accountId?: string;
+};
+
+export async function setupCursorSubscription(
+	pi: ExtensionAPI,
+	options: {
+		readAuth: () => Record<string, AuthEntry>;
+		rejectDuplicateLogin?: (slot: string, creds: AuthEntry) => AuthEntry;
+		slotIds: string[];
+		notify?: (message: string, level: "info" | "warning") => void;
+		log?: (kind: string, data: Record<string, unknown>) => void;
+		/**
+		 * Host hook: provision each Cursor slot into Pi's static models.json so a
+		 * bare `pi -p` child (no extensions) resolves cursor/* through the running
+		 * proxy. Called after the proxy is up and again when the real catalog lands.
+		 * Pass model objects (or ids); the host writes Pi-schema objects, never strings.
+		 */
+		onProvision?: (slotIds: string[], port: number, models: unknown[]) => void;
+	},
+): Promise<number | undefined> {
+	const mod = await loadCursorModules();
+	if (!mod) {
+		options.notify?.(
+			`pi-multi-account: Cursor support is missing from this install (expected ${getCursorProviderRoot()}). Everything else keeps working; set "includeCursor": false in the config to silence this.`,
+			"warning",
+		);
+		return undefined;
+	}
+	if (indexMod?.registerSessionLifecycleCleanup) {
+		indexMod.registerSessionLifecycleCleanup(pi);
+	}
+	const resolveAccessToken = async (providerId: string) => {
+		const entry = options.readAuth()[providerId];
+		if (!entry || entry.type !== "oauth") return "";
+		return typeof entry.access === "string" ? entry.access : "";
+	};
+	proxyPort = await mod.ensureCursorProxy(resolveAccessToken);
+	const ids = [...new Set([CURSOR_BASE, ...options.slotIds])];
+	options.onProvision?.(ids, proxyPort, mod.FALLBACK_MODELS as unknown[]);
+	for (const id of ids) {
+		mod.registerCursorProvider(pi, id, proxyPort, mod.FALLBACK_MODELS, {
+			rejectDuplicateLogin: options.rejectDuplicateLogin,
+			onModelsDiscovered: (models: unknown[]) => {
+				mod.registerCursorProvider(pi, id, proxyPort!, models as any[], {
+					rejectDuplicateLogin: options.rejectDuplicateLogin,
+				});
+				options.onProvision?.(ids, proxyPort!, models);
+			},
+		});
+	}
+	void (async () => {
+		if (typeof mod.discoverCursorModels !== "function") {
+			options.log?.("cursor_catalog", { outcome: "unsupported" });
+			return;
+		}
+		for (const id of ids) {
+			const entry = options.readAuth()[id];
+			if (!entry || entry.type !== "oauth" || !entry.access) continue;
+			try {
+				const models = await mod.discoverCursorModels(entry.access);
+				if (!models?.length) {
+					options.log?.("cursor_catalog", { outcome: "empty", provider: id });
+					continue;
+				}
+				for (const slot of ids) {
+					mod.registerCursorProvider(pi, slot, proxyPort!, models as any[], {
+						rejectDuplicateLogin: options.rejectDuplicateLogin,
+					});
+				}
+				options.onProvision?.(ids, proxyPort!, models as unknown[]);
+				options.log?.("cursor_catalog", {
+					outcome: "discovered",
+					provider: id,
+					models: models.length,
+				});
+				return;
+			} catch (error) {
+				options.log?.("cursor_catalog", {
+					outcome: "error",
+					provider: id,
+					reason: error instanceof Error ? error.message : String(error),
+				});
+			}
+		}
+		options.log?.("cursor_catalog", {
+			outcome: "unavailable",
+			reason: "no slot could read the catalog",
+		});
+	})().catch((error) => {
+		options.log?.("cursor_catalog", {
+			outcome: "crashed",
+			reason: error instanceof Error ? error.message : String(error),
+		});
+	});
+	return proxyPort;
+}
+
+/**
+ * Refresh a Cursor OAuth credential through the VENDORED provider.
+ *
+ * This used to `import()` `~/.pi/agent/git/github.com/ndraiman/pi-cursor-provider/auth.ts`
+ * — a path that no longer exists for anyone (the provider is vendored into this
+ * extension, and upstream's repo never contained the file layout we expected).
+ * Every forced Cursor refresh therefore threw before it could refresh anything.
+ * Resolving through {@link getCursorProviderRoot} keeps the `PI_CURSOR_PROVIDER_ROOT`
+ * test seam working.
+ */
+/**
+ * Controller tasks are not Pi sessions, so the normal session_shutdown hook cannot clean their
+ * Cursor conversation state. The native controller provider calls this after each task request;
+ * the callback is deliberately a no-op when the optional Cursor provider is absent.
+ */
+export function cleanupCursorControllerSession(sessionId: string): void {
+	try {
+		indexMod?.cleanupControllerSession?.(sessionId);
+	} catch {
+		// Cleanup is best effort; it must not turn a settled provider result into a host error.
+	}
+}
+
+export async function refreshCursorCredentials(
+	refreshToken: string,
+): Promise<{ access: string; refresh: string; expires: number }> {
+	const entry = join(getCursorProviderRoot(), "auth.ts");
+	if (!existsSync(entry)) {
+		throw new Error(`Cursor support is missing from this install (${entry})`);
+	}
+	const mod = (await import(/* @vite-ignore */ loadSpecifier(entry))) as {
+		refreshCursorToken: (
+			token: string,
+		) => Promise<{ access: string; refresh: string; expires: number }>;
+	};
+	return mod.refreshCursorToken(refreshToken);
+}

package/node_modules/pi-multi-account/cursor-model-name.ts

@@ -0,0 +1,12 @@
+/**
+ * Cursor catalogs name each effort variant ("Grok 4.6 Medium", "Grok 4.6 High").
+ * After we fold those variants into one model, that adjective must not appear in
+ * the picker or the powerline — thinking level is a separate Pi setting.
+ */
+const TRAILING_EFFORT =
+	/\s+(?:\((?:none|low|medium|high|xhigh|max|extra\s*high)\)|(?:None|Low|Medium|High|Extra High|xHigh|Max))\s*$/i;
+
+export function cursorModelDisplayName(name: string): string {
+	const stripped = name.replace(TRAILING_EFFORT, "").trim();
+	return stripped || name;
+}