@trim21/personal-pi-extensions 0.1.460 → 0.1.465

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trim21/personal-pi-extensions",
-  "version": "0.1.460",
+  "version": "0.1.465",
   "type": "module",
   "description": "Custom pi coding-agent extensions: bwrap sandbox, workspace guard, opencode edit, and more",
   "keywords": [

package/src/aft/index.ts

@@ -1,13 +1,12 @@
 /**
- * AFT 扩展入口：感知工具（aft_outline / aft_zoom / aft_callgraph / aft_search）
- * + aft_refactor / aft_import（workspace-wide 重构与 import 管理，路径级写保护）。
+ * AFT 扩展入口：感知工具（aft_outline / aft_zoom / aft_callgraph / aft_search），
+ * 全部只读。
  *
- * 感知工具只读，不触碰本仓库自己的 read/write/edit/bash 工具及其安全机制
+ * 感知工具不触碰本仓库自己的 read/write/edit/bash 工具及其安全机制
  * （bwrap 沙箱、write-guard、reads 记账）。aft_search 仅当用户级 aft.jsonc 开启
  * semantic_search 且配好外部 embedding 后端（semantic.backend 为
  * openai_compatible / ollama 且有 base_url）时注册；aft 默认的本地 ONNX
- * fastembed 后端不使用。aft_refactor / aft_import 的 Rust 命令不支持 preview，
- * 写保护退化为路径级审批。
+ * fastembed 后端不使用。
  *
  * bridge 状态（日志 + 常驻 aft 子进程）的生命周期跟 session 走：session_start
  * 时用当次 session id 创建（日志落在 tmp/{sessionId}/aft-plugin.log），
@@ -23,8 +22,6 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 
 import { createAftState, resolveSessionId, shutdownAftPool } from "./bridge.js";
 import { loadAftConfig } from "./config.js";
-import { registerImportTool } from "./imports.js";
-import { registerRefactorTool } from "./refactor.js";
 import {
   registerCallgraphTool,
   registerOutlineTool,
@@ -59,8 +56,6 @@ export default function aftReadTools(pi: ExtensionAPI): void {
   registerOutlineTool(pi, toolCtx);
   registerZoomTool(pi, toolCtx);
   registerCallgraphTool(pi, toolCtx);
-  registerRefactorTool(pi, toolCtx);
-  registerImportTool(pi, toolCtx);
   if (cfg.semanticSearch) {
     if (cfg.semanticRemote) {
       registerSearchTool(pi, toolCtx);

package/src/aft/tools.ts

@@ -7,8 +7,6 @@
 
 import { readFileSync } from "node:fs";
 import { stat } from "node:fs/promises";
-import { homedir } from "node:os";
-import { isAbsolute, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 
 import {
@@ -22,7 +20,7 @@ import {
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 
-import { formatDisplayPath, formatSubtitlePath } from "../lib/path.js";
+import { formatDisplayPath, formatSubtitlePath, resolvePathArg } from "../lib/path.js";
 import { type ToolPendant } from "../lib/pendant.js";
 import { type AftState, callAftTool, SEMANTIC_INDEX_WAIT_TIMEOUT_MS } from "./bridge.js";
 
@@ -41,15 +39,6 @@ const SEARCH_PROMPT = readFileSync(
   "utf8",
 ).trim();
 
-/** 解析 `~` 前缀与相对路径（相对 session cwd）。URL 与绝对路径原样返回。 */
-export function resolvePathArg(cwd: string, input: string): string {
-  if (input === "~" || input.startsWith("~/")) {
-    return join(homedir(), input.slice(1));
-  }
-  if (input.startsWith("http://") || input.startsWith("https://")) return input;
-  return isAbsolute(input) ? input : resolve(cwd, input);
-}
-
 export interface AftToolContext {
   cwd: string;
   /** 当前 session 的 bridge 状态；session 未初始化时抛错。 */

package/src/claude-code/files.ts

@@ -14,9 +14,11 @@ import {
 } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 
+import { RenameNotPossibleError } from "../lib/lsp/client.js";
 import { appendLspDiagnosticText } from "../lib/lsp/diagnostic.js";
 import { type LspService, registerLsp } from "../lib/lsp/lsp.js";
-import { formatSubtitlePath } from "../lib/path.js";
+import { canonicalizeEdit, expandWorkspaceEdit, symbolCandidates } from "../lib/lsp/rename.js";
+import { formatSubtitlePath, resolvePathArg } from "../lib/path.js";
 import type { ToolPendant } from "../lib/pendant.ts";
 import { guardWriteAccess } from "../lib/write-guard.js";
 import {
@@ -58,6 +60,10 @@ const WRITE_PROMPT = readFileSync(
   fileURLToPath(new URL("write.md", import.meta.url)),
   "utf8",
 ).trim();
+const LSP_RENAME_PROMPT = readFileSync(
+  fileURLToPath(new URL("lsp-rename.md", import.meta.url)),
+  "utf8",
+).trim();
 const IMAGE_MIMES = new Map<string, string>([
   [".gif", "image/gif"],
   [".jpeg", "image/jpeg"],
@@ -672,10 +678,202 @@ export function registerFileTools(
       };
     },
   });
+
+  pi.registerTool({
+    name: "lsp-rename",
+    label: "Lsp Rename",
+    description: "Rename a code symbol and update all references across the workspace via LSP",
+    promptSnippet: "Workspace-wide symbol rename via LSP",
+    promptGuidelines: [LSP_RENAME_PROMPT],
+    parameters: Type.Object(
+      {
+        file_path: Type.String({
+          description:
+            "A file containing the symbol (absolute path, or relative / ~/ path resolved against the session cwd)",
+        }),
+        line: Type.Integer({
+          minimum: 1,
+          description:
+            "1-based line number where the symbol appears (any occurrence works, not only the definition)",
+        }),
+        symbol: Type.String({
+          minLength: 1,
+          description: "The symbol's name exactly as it appears on that line",
+        }),
+        new_name: Type.String({ minLength: 1, description: "The new name for the symbol" }),
+        character: Type.Optional(
+          Type.Integer({
+            minimum: 1,
+            description:
+              "1-based character offset of the symbol on that line. Only needed when the tool reports an ambiguity error on this line",
+          }),
+        ),
+      },
+      { additionalProperties: false },
+    ),
+    async execute(_id, params, signal, _onUpdate, ctx) {
+      signal?.throwIfAborted();
+
+      const filePath = resolvePathArg(ctx.cwd, params.file_path);
+      let content: string;
+      try {
+        await stat(filePath);
+        content = await readFile(filePath, "utf8");
+      } catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+          throw new Error(`File does not exist: ${filePath}`, { cause: error });
+        }
+        throw error;
+      }
+
+      const notify = (message: string, level: "info" | "warning" | "error") =>
+        ctx.ui.notify(message, level);
+      const options = { notify, signal };
+
+      // ── 按 symbol 名枚举行内候选，逐候选探测与消歧 ────────────────────────
+      const candidates = symbolCandidates(
+        content,
+        params.line - 1,
+        params.symbol,
+        params.character === undefined ? undefined : params.character - 1,
+      );
+      if (candidates.length === 0) {
+        throw new Error(
+          `Symbol "${params.symbol}" not found on line ${params.line} of ${filePath}. Read the file again and locate the symbol.`,
+        );
+      }
+      const successes: { result: Awaited<ReturnType<typeof service.rename>> }[] = [];
+      const notPossibleErrors: string[] = [];
+      for (const candidate of candidates) {
+        signal?.throwIfAborted();
+        try {
+          const result = await service.rename({
+            file: filePath,
+            cwd: ctx.cwd,
+            line: candidate.line,
+            character: candidate.character,
+            newName: params.new_name,
+            options,
+          });
+          successes.push({ result });
+        } catch (error) {
+          if (error instanceof RenameNotPossibleError) {
+            notPossibleErrors.push(error.message);
+            continue;
+          }
+          throw error;
+        }
+      }
+      if (successes.length === 0) {
+        throw new RenameNotPossibleError(
+          notPossibleErrors.length > 0
+            ? notPossibleErrors.join("; ")
+            : `no renameable symbol "${params.symbol}" on line ${params.line} of ${filePath}`,
+        );
+      }
+
+      // 同一符号的多次出现编辑集合一致；不一致即为不同符号 → 要求补 character
+      const groups = new Map<
+        string,
+        { result: (typeof successes)[number]["result"]; candidates: typeof candidates }
+      >();
+      for (const [index, candidate] of candidates.entries()) {
+        const entry = successes[index];
+        if (!entry) continue;
+        const key = canonicalizeEdit(entry.result.edit);
+        const group = groups.get(key);
+        if (group) group.candidates.push(candidate);
+        else groups.set(key, { result: entry.result, candidates: [candidate] });
+      }
+      if (groups.size > 1) {
+        const listing = [...groups.values()]
+          .map((group) =>
+            group.candidates
+              .map(
+                (candidate) =>
+                  `- line ${candidate.line + 1}, column ${candidate.character + 1} (rename target: ${group.result.placeholder ?? "unknown"})`,
+              )
+              .join("\n"),
+          )
+          .join("\n");
+        throw new Error(
+          `Ambiguous rename target on line ${params.line} of ${filePath}: several distinct symbols share the name "${params.symbol}". Retry with 'character' (1-based) to pick one:\n${listing}`,
+        );
+      }
+      const firstGroup = [...groups.values()][0];
+      if (!firstGroup) throw new Error("LSP rename returned no target");
+      const { result } = firstGroup;
+
+      // ── 内存展开 → 审批 → 写盘 → 诊断 ────────────────────────────────────
+      signal?.throwIfAborted();
+      const applied = await expandWorkspaceEdit(result.edit, (path) => readFile(path, "utf8"));
+      if (applied.length === 0) {
+        throw new Error("LSP rename returned no edits");
+      }
+      for (const fileEdit of applied) {
+        await guardWriteAccess(ctx, {
+          toolName: "lsp-rename",
+          absolutePath: fileEdit.path,
+          change: { oldText: fileEdit.oldText, newText: fileEdit.newText },
+        });
+      }
+
+      const diffs: string[] = [];
+      const pendingReads: { key: string; snapshot: FileSnapshot }[] = [];
+      for (const fileEdit of applied) {
+        await withFileMutationQueue(fileEdit.path, async () => {
+          await writeFile(fileEdit.path, fileEdit.newText, "utf8");
+          const key = await readStateKey(fileEdit.path);
+          pendingReads.push({ key, snapshot: snapshotOf(fileEdit.newText) });
+        });
+        diffs.push(
+          `### ${fileEdit.path} (${fileEdit.changeCount} edit(s))\n\n\`\`\`diff\n${generateDiffString(fileEdit.oldText, fileEdit.newText).diff}\n\`\`\``,
+        );
+      }
+
+      let diagnosticText = "";
+      for (const fileEdit of applied) {
+        signal?.throwIfAborted();
+        const diagnostics = await service.lspDiagnosticsForFile(fileEdit.path, ctx.cwd, {
+          notify,
+          signal,
+        });
+        if (diagnostics.text !== "") diagnosticText += `${diagnostics.text}\n`;
+      }
+
+      const reads: Record<string, FileSnapshot> = {};
+      for (const { key, snapshot } of pendingReads) {
+        reads[key] = snapshot;
+        state.reads.set(key, snapshot);
+      }
+
+      const renamed =
+        result.placeholder !== undefined && result.placeholder !== params.new_name
+          ? `'${result.placeholder}' -> '${params.new_name}'`
+          : `to '${params.new_name}'`;
+      const summary = `Renamed ${renamed} across ${applied.length} file(s).`;
+      const text =
+        diagnosticText === ""
+          ? summary
+          : `${summary}\n\nLSP diagnostics detected in renamed files:\n${diagnosticText.trimEnd()}`;
+
+      return {
+        content: [{ type: "text" as const, text }],
+        details: {
+          reads,
+          pendant: {
+            title: "lsp-rename",
+            subtitle: `${renamed} · ${applied.length} file(s)`,
+            markdown: diffs.join("\n\n"),
+          } satisfies ToolPendant,
+        },
+      };
+    },
+  });
 }
 
 /** 会更新 reads state 并随 details 持久化快照的工具名。 */
-const FILE_TOOL_NAMES = new Set(["Read", "Edit", "Write"]);
+const FILE_TOOL_NAMES = new Set(["Read", "Edit", "Write", "lsp-rename"]);
 
 /**
  * 从当前分支的历史工具结果重建已读记账。先清空再重放，保证 state 只反映

package/src/claude-code/lsp-rename.md

@@ -0,0 +1,9 @@
+## LSP Rename
+
+Rename a code symbol (function, class, variable, ...) and update every reference across the workspace via LSP.
+
+- Locate the symbol with `file_path` + `line` (1-based) + `symbol` (the symbol's name exactly as it appears on that line). Any occurrence works — it does not have to be the definition.
+- The tool computes the column itself; do not pass `character` unless asked to disambiguate.
+- When several distinct symbols share the same name on that line, the tool refuses to guess: it reports an ambiguity error listing the candidate columns. Re-run with `character` (1-based) to pick one.
+- Requires an LSP server of kind `language` (per lsp.json) for the file; linter-only servers cannot rename.
+- After the rename, affected files are reported with their edit counts and LSP diagnostics. Renamed files are marked as read — no re-Read needed before further edits.

package/src/lib/lsp/adapter.ts

@@ -20,8 +20,13 @@ export interface LspServerHandle {
   languageIds?: Record<string, string>;
 }
 
+/** 服务器类型：真语言服务器（language，可承载符号级请求）或 LSP 协议 linter。 */
+export type ServerKind = "language" | "linter";
+
 export interface LspServerAdapter {
   readonly id: string;
+  /** 服务器类型；缺省视为 "language"（诊断之外的符号级功能只面向 language）。 */
+  readonly kind?: ServerKind;
   /** 关联的文件扩展名（含点，小写）；空数组表示匹配所有文件。 */
   readonly extensions: readonly string[];
   /** per-server initialize 握手超时（ms）；缺省用全局配置 / client 默认。 */

package/src/lib/lsp/client.ts

@@ -16,13 +16,15 @@ import { fileURLToPath, pathToFileURL } from "node:url";
 import {
   createMessageConnection,
   type MessageConnection,
+  ResponseError,
   StreamMessageReader,
   StreamMessageWriter,
 } from "vscode-jsonrpc/node";
-import type { Diagnostic as VSCodeDiagnostic } from "vscode-languageserver-types";
+import type { Diagnostic as VSCodeDiagnostic, WorkspaceEdit } from "vscode-languageserver-types";
 
 import type { LspServerHandle } from "./adapter.js";
 import { LANGUAGE_EXTENSIONS } from "./language.js";
+import { editFilePaths } from "./rename.js";
 import type { FileChange, FileChangeType } from "./watcher.js";
 
 // LSP spec 常量
@@ -51,6 +53,65 @@ const FILE_CHANGE_TYPE: Record<FileChangeType, number> = {
 
 export type Diagnostic = VSCodeDiagnostic;
 
+/** 两个路径集合是否一致（用于判断 references 结果是否收敛）。 */
+function samePaths(a: Set<string>, b: Set<string>): boolean {
+  if (a.size !== b.size) return false;
+  for (const path of a) if (!b.has(path)) return false;
+  return true;
+}
+
+/** LSP MethodNotFound（-32601）：服务器未实现 prepareRename / rename 请求。 */
+const LSP_METHOD_NOT_FOUND = -32601;
+
+/**
+ * 位置不可 rename 或服务器不具备 rename 能力；与传输失败等意外错误区分，
+ * 供调用方在多候选探测时跳过该 client 而不是中断整个操作。
+ */
+export class RenameNotPossibleError extends Error {}
+
+/**
+ * rename edit 未覆盖 references 看到的全部文件：服务器索引可能仍在后台加载。
+ * 抛出时发生在写盘之前，整个 rename 无副作用，可稍后重试。
+ */
+export class RenameIncompleteError extends Error {
+  readonly missing: readonly string[];
+  constructor(missing: readonly string[]) {
+    super(
+      `LSP rename incomplete: textDocument/references found the symbol in ` +
+        `${missing.length} file(s) that the rename edit does not cover ` +
+        `(${missing.join(", ")}). The server index may still be loading; ` +
+        `nothing was modified, retry shortly.`,
+    );
+    this.missing = missing;
+  }
+}
+
+/**
+ * rename 覆盖校验的轮询节奏。budgetMs 是 references 收敛 + 重试的总预算；
+ * 测试可临时缩小以缩短等待。
+ */
+export const renameVerificationTiming = { pollMs: 400, budgetMs: 10_000 };
+
+interface PrepareRenameResponse {
+  range?: unknown;
+  placeholder?: string;
+  defaultBehavior?: boolean;
+}
+
+/** renameSymbol 的请求与结果（line / character 为 0-based LSP position）。 */
+export interface RenameSymbolRequest {
+  path: string;
+  line: number;
+  character: number;
+  newName: string;
+}
+
+export interface RenameSymbolResult {
+  edit: WorkspaceEdit;
+  /** prepareRename 返回的符号当前名；服务器未提供 prepare 时缺省。 */
+  placeholder?: string;
+}
+
 export class InitializeError extends Error {
   readonly serverID: string;
   constructor(serverID: string, cause: unknown) {
@@ -100,6 +161,7 @@ interface ServerCapabilities {
         change?: number;
       };
   diagnosticProvider?: unknown;
+  renameProvider?: boolean | { prepareProvider?: boolean };
   [key: string]: unknown;
 }
 
@@ -137,6 +199,12 @@ export interface LspClient {
     after?: number;
     signal?: AbortSignal;
   }): Promise<void>;
+  /**
+   * 符号重命名：先把磁盘内容同步给服务器（didOpen/didChange），再按能力决定
+   * 是否先发 prepareRename 校验位置，最后发 textDocument/rename 返回 WorkspaceEdit。
+   * 位置不在符号上 / 服务器不支持 rename 时抛 RenameNotPossibleError。
+   */
+  renameSymbol(request: RenameSymbolRequest): Promise<RenameSymbolResult>;
   shutdown(): Promise<void>;
 }
 
@@ -387,6 +455,11 @@ export async function create(input: CreateInput): Promise<LspClient> {
 
   const syncKind = getSyncKind(initialized.capabilities);
   const hasStaticPullDiagnostics = Boolean(initialized.capabilities?.diagnosticProvider);
+  // prepareProvider 只在静态声明为对象且显式开启时使用；其余情况跳过 prepare
+  // 直接 rename（能力可能经动态注册，静态声明缺失不代表服务器不支持）。
+  const renameProvider = initialized.capabilities?.renameProvider;
+  const hasPrepareProvider =
+    typeof renameProvider === "object" && renameProvider.prepareProvider === true;
 
   await connection.sendNotification("initialized", {});
 
@@ -764,6 +837,55 @@ export async function create(input: CreateInput): Promise<LspClient> {
 
   // ── 公开 API ────────────────────────────────────────────────────────────────
 
+  const openDocument = async (request: { path: string }): Promise<number> => {
+    const resolvedPath = normalize(
+      isAbsolute(request.path) ? request.path : resolve(input.directory, request.path),
+    );
+    const text = await readFile(resolvedPath, "utf8");
+    const extension = extname(resolvedPath);
+    const languageId =
+      input.server.languageIds?.[extension] ?? LANGUAGE_EXTENSIONS[extension] ?? "plaintext";
+    const uri = pathToFileURL(resolvedPath).href;
+
+    const document = files[resolvedPath];
+    if (document !== undefined) {
+      // didChange：内容已变，旧诊断立即失效。清空缓存避免等待窗口内服务器
+      // 重算未完成时（大项目可远超窗口）聚合到过期诊断；新 push 到达即填充。
+      pushDiagnostics.delete(resolvedPath);
+      pullDiagnostics.delete(resolvedPath);
+
+      const next = document.version + 1;
+      files[resolvedPath] = { version: next, text };
+      documentVersions.set(resolvedPath, next);
+      await connection.sendNotification("textDocument/didChange", {
+        textDocument: { uri, version: next },
+        contentChanges:
+          syncKind === TEXT_DOCUMENT_SYNC_INCREMENTAL
+            ? [
+                {
+                  range: { start: { line: 0, character: 0 }, end: endPosition(document.text) },
+                  text,
+                },
+              ]
+            : [{ text }],
+      });
+      touch(resolvedPath);
+      await evictExcess();
+      return next;
+    }
+
+    pushDiagnostics.delete(resolvedPath);
+    pullDiagnostics.delete(resolvedPath);
+    await connection.sendNotification("textDocument/didOpen", {
+      textDocument: { uri, languageId, version: 0, text },
+    });
+    files[resolvedPath] = { version: 0, text };
+    documentVersions.set(resolvedPath, 0);
+    touch(resolvedPath);
+    await evictExcess();
+    return 0;
+  };
+
   return {
     root: input.root,
     get serverID() {
@@ -783,54 +905,7 @@ export async function create(input: CreateInput): Promise<LspClient> {
       return connection;
     },
     notify: {
-      async open(request: { path: string }): Promise<number> {
-        const resolvedPath = normalize(
-          isAbsolute(request.path) ? request.path : resolve(input.directory, request.path),
-        );
-        const text = await readFile(resolvedPath, "utf8");
-        const extension = extname(resolvedPath);
-        const languageId =
-          input.server.languageIds?.[extension] ?? LANGUAGE_EXTENSIONS[extension] ?? "plaintext";
-        const uri = pathToFileURL(resolvedPath).href;
-
-        const document = files[resolvedPath];
-        if (document !== undefined) {
-          // didChange：内容已变，旧诊断立即失效。清空缓存避免等待窗口内服务器
-          // 重算未完成时（大项目可远超窗口）聚合到过期诊断；新 push 到达即填充。
-          pushDiagnostics.delete(resolvedPath);
-          pullDiagnostics.delete(resolvedPath);
-
-          const next = document.version + 1;
-          files[resolvedPath] = { version: next, text };
-          documentVersions.set(resolvedPath, next);
-          await connection.sendNotification("textDocument/didChange", {
-            textDocument: { uri, version: next },
-            contentChanges:
-              syncKind === TEXT_DOCUMENT_SYNC_INCREMENTAL
-                ? [
-                    {
-                      range: { start: { line: 0, character: 0 }, end: endPosition(document.text) },
-                      text,
-                    },
-                  ]
-                : [{ text }],
-          });
-          touch(resolvedPath);
-          await evictExcess();
-          return next;
-        }
-
-        pushDiagnostics.delete(resolvedPath);
-        pullDiagnostics.delete(resolvedPath);
-        await connection.sendNotification("textDocument/didOpen", {
-          textDocument: { uri, languageId, version: 0, text },
-        });
-        files[resolvedPath] = { version: 0, text };
-        documentVersions.set(resolvedPath, 0);
-        touch(resolvedPath);
-        await evictExcess();
-        return 0;
-      },
+      open: openDocument,
       async watchedFiles(changes: FileChange[]): Promise<void> {
         const notified: { uri: string; type: number }[] = [];
         for (const change of changes) {
@@ -869,6 +944,104 @@ export async function create(input: CreateInput): Promise<LspClient> {
         });
       },
     },
+    async renameSymbol(request: RenameSymbolRequest): Promise<RenameSymbolResult> {
+      const resolvedPath = normalize(
+        isAbsolute(request.path) ? request.path : resolve(input.directory, request.path),
+      );
+      const uri = pathToFileURL(resolvedPath).href;
+      // rename 前强制同步磁盘内容，保证服务器基于最新文本计算编辑
+      await openDocument({ path: resolvedPath });
+      const position = { line: request.line, character: request.character };
+      const at = `${resolvedPath}:${request.line + 1}:${request.character + 1}`;
+      const notRenameable = () =>
+        new RenameNotPossibleError(`LSP server "${input.serverID}" cannot rename at ${at}`);
+
+      // references 前置 + rename 覆盖校验：LSP 没有标准化的"索引完成"信号，
+      // 服务器（如 tsserver）可能在项目加载完成前回答，导致 rename 漏掉
+      // 尚未入索引的文件。对策分两层：
+      // 1. 收敛检测：references 连续两次文件集合一致才认为索引稳定，防止
+      //    "服务器根本还没发现某文件"时校验形同虚设；
+      // 2. 覆盖校验：references 报告的文件必须都被 rename edit 覆盖，
+      //    不完整时等待重试，预算耗尽仍不完整抛 RenameIncompleteError——
+      //    调用方尚未写盘，整个操作无副作用，可稍后重试。
+      // 服务器不支持 references（MethodNotFound）时跳过校验，信任服务器，
+      // 与编辑器行为一致。
+      const referencesRequest = () =>
+        connection.sendRequest<{ uri: string }[] | null>("textDocument/references", {
+          textDocument: { uri },
+          position,
+          context: { includeDeclaration: true },
+        });
+
+      const toPaths = (locations: { uri: string }[] | null): Set<string> =>
+        new Set(
+          (locations ?? []).flatMap((location) =>
+            location.uri.startsWith("file:") ? [normalize(fileURLToPath(location.uri))] : [],
+          ),
+        );
+
+      const sendRename = async (): Promise<WorkspaceEdit | null> => {
+        try {
+          return await connection.sendRequest<WorkspaceEdit | null>("textDocument/rename", {
+            textDocument: { uri },
+            position,
+            newName: request.newName,
+          });
+        } catch (error) {
+          if (error instanceof ResponseError && error.code === LSP_METHOD_NOT_FOUND) {
+            throw notRenameable();
+          }
+          throw error;
+        }
+      };
+
+      let placeholder: string | undefined;
+      if (hasPrepareProvider) {
+        let prepared: PrepareRenameResponse | null;
+        try {
+          prepared = await connection.sendRequest<PrepareRenameResponse | null>(
+            "textDocument/prepareRename",
+            { textDocument: { uri }, position },
+          );
+        } catch (error) {
+          if (error instanceof ResponseError && error.code === LSP_METHOD_NOT_FOUND) {
+            throw notRenameable();
+          }
+          throw error;
+        }
+        if (!prepared) throw notRenameable();
+        if (typeof prepared.placeholder === "string") placeholder = prepared.placeholder;
+      }
+
+      let locations: { uri: string }[] | null;
+      try {
+        locations = await referencesRequest();
+      } catch (error) {
+        if (!(error instanceof ResponseError && error.code === LSP_METHOD_NOT_FOUND)) throw error;
+        const edit = await sendRename();
+        if (!edit) throw notRenameable();
+        return placeholder === undefined ? { edit } : { edit, placeholder };
+      }
+
+      const deadline = Date.now() + renameVerificationTiming.budgetMs;
+      let previous: Set<string> | undefined;
+      let current = toPaths(locations);
+      for (;;) {
+        const settled = previous !== undefined && samePaths(previous, current);
+        if (settled || Date.now() >= deadline) {
+          const edit = await sendRename();
+          if (!edit) throw notRenameable();
+          const missing = [...current].filter((path) => !editFilePaths(edit).has(path));
+          if (missing.length === 0) {
+            return placeholder === undefined ? { edit } : { edit, placeholder };
+          }
+          throw new RenameIncompleteError(missing);
+        }
+        previous = current;
+        await sleep(renameVerificationTiming.pollMs);
+        current = toPaths(await referencesRequest());
+      }
+    },
     get diagnostics() {
       const result = new Map<string, Diagnostic[]>();
       for (const key of new Set([...pushDiagnostics.keys(), ...pullDiagnostics.keys()])) {