@mrclrchtr/supi-lsp 3.2.0 → 4.0.0

package/src/manager/manager-workspace-symbol.ts

@@ -1,5 +1,11 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
+import {
+  type CodeQueryResult,
+  completedCodeQuery,
+  partialCodeQuery,
+  unavailableCodeQuery,
+} from "@mrclrchtr/supi-code-runtime/api";
 import { walkProject } from "@mrclrchtr/supi-core/project";
 import type { LspClient } from "../client/client.ts";
 import type {
@@ -39,30 +45,62 @@ export function getWorkspaceSymbolWarmPosition(
   return null;
 }
 
+export interface WorkspaceSymbolCollection {
+  results: WorkspaceSymbolLike[];
+  hasSupport: boolean;
+  completedClientCount: number;
+  failures: string[];
+}
+
 export async function collectWorkspaceSymbols(
   clients: Iterable<LspClient>,
   query: string,
-): Promise<{ results: WorkspaceSymbolLike[]; hasSupport: boolean }> {
+): Promise<WorkspaceSymbolCollection> {
   const results: WorkspaceSymbolLike[] = [];
+  const failures: string[] = [];
   let hasSupport = false;
+  let completedClientCount = 0;
 
   for (const client of clients) {
     if (client.status !== "running") continue;
     if (!client.serverCapabilities?.workspaceSymbolProvider) continue;
     hasSupport = true;
     const result = await client.workspaceSymbol(query);
-    if (result) results.push(...result);
+    if (result.kind === "unavailable") {
+      failures.push(result.reason);
+      continue;
+    }
+    completedClientCount++;
+    results.push(...(result.data ?? []));
+    if (result.kind === "partial") failures.push(result.reason);
   }
 
-  return { results, hasSupport };
+  return { results, hasSupport, completedClientCount, failures };
+}
+
+/** Project one multi-client collection into the shared typed query contract. */
+export function workspaceSymbolCollectionResult(
+  collection: WorkspaceSymbolCollection,
+): CodeQueryResult<WorkspaceSymbolLike[]> {
+  if (!collection.hasSupport) {
+    return unavailableCodeQuery("No active LSP client supports workspace-symbol requests.");
+  }
+  if (collection.completedClientCount === 0) {
+    return unavailableCodeQuery(
+      collection.failures.join("; ") || "No workspace-symbol request completed.",
+    );
+  }
+  if (collection.failures.length > 0) {
+    return partialCodeQuery(collection.results, collection.failures.join("; "));
+  }
+  return completedCodeQuery(collection.results);
 }
 
 export async function managerWorkspaceSymbol(
   clients: Iterable<LspClient>,
   query: string,
-): Promise<WorkspaceSymbolLike[] | null> {
-  const { results, hasSupport } = await collectWorkspaceSymbols(clients, query);
-  return hasSupport ? results : null;
+): Promise<CodeQueryResult<WorkspaceSymbolLike[]>> {
+  return workspaceSymbolCollectionResult(await collectWorkspaceSymbols(clients, query));
 }
 
 export function findWorkspaceSymbolWarmTargets(

package/src/manager/manager.ts

@@ -2,6 +2,7 @@
 // biome-ignore-all lint/style/noExcessiveLinesPerFile: LspManager stays cohesive; recovery and sync helpers are split into manager-*.ts modules.
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { type CodeQueryResult, unavailableCodeQuery } from "@mrclrchtr/supi-code-runtime/api";
 import * as projectRoots from "@mrclrchtr/supi-core/project";
 import { LspClient } from "../client/client.ts";
 import { getServerForFile } from "../config/config.ts";
@@ -36,8 +37,7 @@ import {
 } from "./manager-client-state.ts";
 import {
   collectOutstandingDiagnosticsDetailed,
-  mapCascadeDiagnosticsToFiles,
-  syncClientFileAndGetCascadingDiagnostics,
+  syncClientFileAndGetDiagnostics,
 } from "./manager-diagnostics.ts";
 import {
   clientKey,
@@ -56,8 +56,11 @@ import type {
 } from "./manager-types.ts";
 import { recoverWorkspaceDiagnostics as recoverWorkspaceDiagnosticsImpl } from "./manager-workspace-recovery.ts";
 import {
+  collectWorkspaceSymbols,
   findWorkspaceSymbolWarmTargets,
   getWorkspaceSymbolWarmPosition,
+  type WorkspaceSymbolCollection,
+  workspaceSymbolCollectionResult,
 } from "./manager-workspace-symbol.ts";
 
 type UnavailableReason = "missing-command" | "start-failed" | "runtime-error";
@@ -361,8 +364,11 @@ export class LspManager {
     return client;
   }
 
-  /** Wait until all started clients are query-ready, then warm one project file per client/root. */
-  async waitUntilWorkspaceReady(): Promise<void> {
+  /**
+   * Wait until all started clients are query-ready, then warm one project file per client/root.
+   * Returns the number of concrete clients that reached readiness.
+   */
+  async waitUntilWorkspaceReady(): Promise<number> {
     const activeClients = Array.from(this.clients.values()).filter(
       (client) => client.status === "running",
     );
@@ -379,38 +385,26 @@ export class LspManager {
       if (!target) continue;
       await this.warmSemanticProject(client, target.file);
     }
+    return activeClients.length;
   }
   async syncFileAndGetDiagnostics(
     filePath: string,
     maxSeverity: number = 1,
-  ): Promise<Diagnostic[]> {
-    const resolvedPath = resolveSessionPath(this.cwd, filePath);
-    return (
-      (await this.syncFileAndGetCascadingDiagnostics(resolvedPath, maxSeverity)).find(
-        (entry) => entry.file === resolvedPath,
-      )?.diagnostics ?? []
-    );
-  }
-  async syncFileAndGetCascadingDiagnostics(
-    filePath: string,
-    maxSeverity: number = 1,
-  ): Promise<Array<{ file: string; diagnostics: Diagnostic[] }>> {
+  ): Promise<CodeQueryResult<Diagnostic[]>> {
     const resolvedPath = resolveSessionPath(this.cwd, filePath);
     const client = await this.getClientForFile(resolvedPath);
-    if (!client) return [];
+    if (!client) {
+      return unavailableCodeQuery(`No LSP client can collect diagnostics for ${resolvedPath}.`);
+    }
     try {
-      const { primary, cascade } = await syncClientFileAndGetCascadingDiagnostics(
-        client,
-        resolvedPath,
-        maxSeverity,
-      );
-      return [
-        ...(primary.length > 0 ? [{ file: resolvedPath, diagnostics: primary }] : []),
-        ...mapCascadeDiagnosticsToFiles(cascade),
-      ];
-    } catch {
+      return {
+        kind: "completed",
+        data: await syncClientFileAndGetDiagnostics(client, resolvedPath, maxSeverity),
+      };
+    } catch (error) {
       this.closeFile(resolvedPath);
-      return [];
+      const detail = error instanceof Error ? error.message : String(error);
+      return unavailableCodeQuery(`Diagnostic collection failed for ${resolvedPath}: ${detail}`);
     }
   }
   /** Close a file across any active LSP clients and clear its cached diagnostics. */
@@ -447,7 +441,7 @@ export class LspManager {
     maxWaitMs?: number;
     quietMs?: number;
   }): Promise<{
-    refreshedClients: number;
+    attemptedClients: number;
     restartedClients: number;
     staleAssessment: {
       suspected: boolean;
@@ -613,21 +607,21 @@ export class LspManager {
       maxSeverity,
     );
   }
-  async workspaceSymbol(query: string): Promise<(SymbolInformation | WorkspaceSymbol)[] | null> {
-    const helper = await import("./manager-workspace-symbol.ts");
-    const initial = await helper.collectWorkspaceSymbols(this.clients.values(), query);
-    if (!initial.hasSupport) return null;
-    if (initial.results.length > 0) return initial.results;
+  async workspaceSymbol(
+    query: string,
+  ): Promise<CodeQueryResult<(SymbolInformation | WorkspaceSymbol)[]>> {
+    const initial = await collectWorkspaceSymbols(this.clients.values(), query);
+    if (!initial.hasSupport || initial.results.length > 0) {
+      return workspaceSymbolCollectionResult(initial);
+    }
 
     const warmed = await this.warmWorkspaceSymbolProjectsUntilResult(
-      helper.findWorkspaceSymbolWarmTargets,
-      helper.getWorkspaceSymbolWarmPosition,
-      helper.collectWorkspaceSymbols,
+      findWorkspaceSymbolWarmTargets,
+      getWorkspaceSymbolWarmPosition,
+      collectWorkspaceSymbols,
       query,
     );
-    if (warmed.results) return warmed.results;
-
-    return initial.results;
+    return workspaceSymbolCollectionResult(warmed.collection ?? initial);
   }
   async ensureFileOpen(filePath: string): Promise<LspClient | null> {
     const resolvedPath = resolveSessionPath(this.cwd, filePath);
@@ -650,14 +644,11 @@ export class LspManager {
       fileTypes: string[],
     ) => Array<{ projectRoot: string; file: string }>,
     getWarmPosition: (
-      symbols: Awaited<ReturnType<LspClient["documentSymbols"]>>,
+      symbols: import("../config/types.ts").DocumentSymbol[] | SymbolInformation[] | null,
     ) => import("../config/types.ts").Position | null,
-    collect: (
-      clients: Iterable<LspClient>,
-      query: string,
-    ) => Promise<{ results: (SymbolInformation | WorkspaceSymbol)[]; hasSupport: boolean }>,
+    collect: (clients: Iterable<LspClient>, query: string) => Promise<WorkspaceSymbolCollection>,
     query: string,
-  ): Promise<{ warmedAny: boolean; results: (SymbolInformation | WorkspaceSymbol)[] | null }> {
+  ): Promise<{ warmedAny: boolean; collection: WorkspaceSymbolCollection | null }> {
     let warmedAny = false;
 
     for (const client of Array.from(this.clients.values())) {
@@ -687,24 +678,20 @@ export class LspManager {
         this.warmedWorkspaceSymbolProjects.add(projectKey);
         warmedAny = true;
 
-        try {
-          const symbols = await openedClient.documentSymbols(target.file);
-          const hoverPosition = getWarmPosition(symbols);
-          if (hoverPosition) {
-            await openedClient.hover(target.file, hoverPosition);
-          }
-        } catch {
-          // Best-effort warm-up only.
+        const symbols = await openedClient.documentSymbols(target.file);
+        if (symbols.kind !== "unavailable") {
+          const hoverPosition = getWarmPosition(symbols.data);
+          if (hoverPosition) await openedClient.hover(target.file, hoverPosition);
         }
 
         const collected = await collect(this.clients.values(), query);
         if (collected.hasSupport && collected.results.length > 0) {
-          return { warmedAny, results: collected.results };
+          return { warmedAny, collection: collected };
         }
       }
     }
 
-    return { warmedAny, results: null };
+    return { warmedAny, collection: null };
   }
 
   private async warmSemanticProject(
@@ -750,15 +737,10 @@ export class LspManager {
 
     this.warmedSemanticProjects.add(projectKey);
 
-    try {
-      const symbols = await openedClient.documentSymbols(resolvedFile);
-      const hoverPosition = getWorkspaceSymbolWarmPosition(symbols);
-      if (hoverPosition) {
-        await openedClient.hover(resolvedFile, hoverPosition);
-      }
-    } catch {
-      // Best-effort warm-up only.
-    }
+    const symbols = await openedClient.documentSymbols(resolvedFile);
+    if (symbols.kind === "unavailable") return;
+    const hoverPosition = getWorkspaceSymbolWarmPosition(symbols.data);
+    if (hoverPosition) await openedClient.hover(resolvedFile, hoverPosition);
   }
 
   private hasOpenFileInProject(client: LspClient, projectRoot: string): boolean {

package/src/provider/lsp-semantic-provider.ts

@@ -1,16 +1,24 @@
-// LSP semantic provider adapter — wraps SessionLspService into the shared
+// LSP semantic provider adapter — wraps WorkspaceLspRuntime into the shared
 // SemanticProvider contract from supi-code-runtime.
 
+import { readFile } from "node:fs/promises";
 import {
   type CodeLocation,
   type CodePosition,
+  type CodeQueryResult,
   type CodeSymbol,
-  normalizeRefactorOperation,
+  completedCodeQuery,
+  type DeclarationNesting,
+  type DocumentCodeSymbol,
+  mapCodeQueryResult,
+  partialCodeQuery,
   type RefactorRequest,
   type RefactorResult,
   type SemanticProvider,
   type SourceRange,
+  unavailableCodeQuery,
 } from "@mrclrchtr/supi-code-runtime/api";
+import { uriToFile } from "@mrclrchtr/supi-core/path";
 import type {
   CodeAction,
   DocumentSymbol,
@@ -20,7 +28,7 @@ import type {
   MarkupContent,
   SymbolInformation,
 } from "../config/types.ts";
-import type { SessionLspService } from "../session/service-registry.ts";
+import type { WorkspaceLspRuntime } from "../session/runtime-registry.ts";
 import {
   collectCodeActionResults,
   isDeleteDeadCodeCodeAction,
@@ -32,74 +40,62 @@ import {
 } from "./refactor-planning.ts";
 
 /**
- * Create a SemanticProvider backed by a SessionLspService.
+ * Create a SemanticProvider backed by a WorkspaceLspRuntime.
  * Maps LSP types into the shared code-runtime types.
  */
-export function createLspSemanticProvider(lsp: SessionLspService): SemanticProvider {
+export function createLspSemanticProvider(lsp: WorkspaceLspRuntime): SemanticProvider {
   return {
-    async definition(filePath: string, position: CodePosition): Promise<CodeLocation[] | null> {
-      const result = await lsp.definition(filePath, position);
-      if (!result) return null;
-      const normalized = Array.isArray(result) ? result : [result];
-      const mapped: CodeLocation[] = [];
-      for (const item of normalized) {
-        const loc = toCodeLocation(item);
-        if (loc) mapped.push(loc);
-      }
-      return mapped;
+    async definition(
+      filePath: string,
+      position: CodePosition,
+    ): Promise<CodeQueryResult<CodeLocation[]>> {
+      return mapCodeQueryResult(await lsp.definition(filePath, position), mapLocations);
     },
 
     async hover(
       filePath: string,
       position: CodePosition,
-    ): Promise<{ contents: string; range?: SourceRange } | null> {
-      const result = await lsp.hover(filePath, position);
-      if (!result) return null;
-      return convertLspHover(result);
+    ): Promise<CodeQueryResult<{ contents: string; range?: SourceRange } | null>> {
+      return mapCodeQueryResult(await lsp.hover(filePath, position), (hover) =>
+        hover ? convertLspHover(hover) : null,
+      );
     },
 
-    async references(filePath: string, position: CodePosition): Promise<CodeLocation[] | null> {
-      const refResult = await lsp.references(filePath, position);
-      if (!refResult) return null;
-      const mapped: CodeLocation[] = [];
-      for (const item of refResult) {
-        const loc = toCodeLocation(item);
-        if (loc) mapped.push(loc);
-      }
-      return mapped;
+    async references(
+      filePath: string,
+      position: CodePosition,
+    ): Promise<CodeQueryResult<CodeLocation[]>> {
+      return mapCodeQueryResult(await lsp.references(filePath, position), mapLocations);
     },
 
-    async implementation(filePath: string, position: CodePosition): Promise<CodeLocation[] | null> {
-      const implResult = await lsp.implementation(filePath, position);
-      if (!implResult) return null;
-      const normalized = Array.isArray(implResult) ? implResult : [implResult];
-      const mapped: CodeLocation[] = [];
-      for (const item of normalized) {
-        const loc = toCodeLocation(item);
-        if (loc) mapped.push(loc);
-      }
-      return mapped;
+    async implementation(
+      filePath: string,
+      position: CodePosition,
+    ): Promise<CodeQueryResult<CodeLocation[]>> {
+      return mapCodeQueryResult(await lsp.implementation(filePath, position), mapLocations);
     },
 
-    async documentSymbols(filePath: string): Promise<CodeSymbol[] | null> {
-      const symbols = await lsp.documentSymbols(filePath);
-      if (!symbols) return null;
-      return flattenDocumentSymbols(symbols, filePath);
+    async documentSymbols(filePath: string): Promise<CodeQueryResult<DocumentCodeSymbol[]>> {
+      const result = await lsp.documentSymbols(filePath);
+      if (result.kind === "unavailable") return unavailableCodeQuery(result.reason);
+      const sourceLines = await readSourceLines(filePath);
+      const symbols = flattenDocumentSymbols(result.data, filePath, null, {
+        sourceLines,
+        nesting: "top-level",
+      });
+      return result.kind === "partial"
+        ? partialCodeQuery(symbols, result.reason)
+        : completedCodeQuery(symbols);
     },
 
-    async workspaceSymbols(query: string): Promise<CodeSymbol[] | null> {
-      const results = await lsp.workspaceSymbol(query);
-      if (!results) return null;
-      return results.map((sym) => toCodeSymbol(sym as SymbolInformation));
+    async workspaceSymbols(query: string): Promise<CodeQueryResult<CodeSymbol[]>> {
+      return mapCodeQueryResult(await lsp.workspaceSymbol(query), (results) =>
+        results.map((symbol) => toCodeSymbol(symbol as SymbolInformation)),
+      );
     },
 
     async refactor(request: RefactorRequest): Promise<RefactorResult> {
-      // Normalize defensively at the provider boundary as well as in
-      // code-intelligence. RefactorRequest still permits the legacy `rename`
-      // alias, and the provider may be invoked directly outside the public tool.
-      const operation = normalizeRefactorOperation(request.operation);
-
-      switch (operation) {
+      switch (request.operation) {
         case "rename_symbol":
           if (!request.newName) {
             return {
@@ -134,13 +130,13 @@ export function createLspSemanticProvider(lsp: SessionLspService): SemanticProvi
           // shared file/resource edits and rollback semantics exist.
           return {
             kind: "unavailable",
-            reason: `Refactor operation "${operation}" is not supported yet. File/resource operations are deferred.`,
+            reason: `Refactor operation "${request.operation}" is not supported yet. File/resource operations are deferred.`,
           };
       }
 
       return {
         kind: "unavailable",
-        reason: `Refactor operation "${operation}" is not supported by the active semantic provider.`,
+        reason: `Refactor operation "${request.operation}" is not supported by the active semantic provider.`,
       };
     },
 
@@ -153,22 +149,11 @@ export function createLspSemanticProvider(lsp: SessionLspService): SemanticProvi
       if (!actions) return [];
       return collectCodeActionResults(actions);
     },
-
-    async codeActionTitles(
-      file: string,
-      position: CodePosition,
-    ): Promise<Array<{ title: string; kind?: string }> | null> {
-      const actions = await lsp.codeActions(file, position);
-      if (!actions) return null;
-      return actions
-        .filter((a) => a.title)
-        .map((a) => ({ title: a.title, kind: a.kind ?? undefined }));
-    },
   };
 }
 
 function runExtractRefactor(
-  lsp: SessionLspService,
+  lsp: WorkspaceLspRuntime,
   request: RefactorRequest,
   operation: "extract_function" | "extract_variable",
   matches: (action: CodeAction) => boolean,
@@ -192,6 +177,15 @@ function runExtractRefactor(
 
 // ── Type conversion helpers ───────────────────────────────────────────
 
+function mapLocations(value: Location | Location[] | LocationLink[] | null): CodeLocation[] {
+  if (!value) return [];
+  const locations = Array.isArray(value) ? value : [value];
+  return locations.flatMap((item) => {
+    const location = toCodeLocation(item);
+    return location ? [location] : [];
+  });
+}
+
 function toCodeLocation(item: Location | LocationLink): CodeLocation | null {
   const loc = item as Record<string, unknown>;
   const uri = loc.uri ?? loc.targetUri;
@@ -251,26 +245,35 @@ function symbolKindName(kind: number): string {
 function flattenDocumentSymbols(
   symbols: DocumentSymbol[] | SymbolInformation[],
   filePath: string,
-  container: string | null = null,
-): CodeSymbol[] {
-  const result: CodeSymbol[] = [];
+  container: string | null,
+  context: { sourceLines: readonly string[] | null; nesting: DeclarationNesting },
+): DocumentCodeSymbol[] {
+  const result: DocumentCodeSymbol[] = [];
 
   for (const sym of symbols) {
     // DocumentSymbol.range = full defining node (declaration anchor);
     // .selectionRange = identifier token (name anchor). SymbolInformation has
     // only location.range (declaration) and no selectionRange.
-    const ds = sym as DocumentSymbol;
-    const si = sym as SymbolInformation;
-    const declStart = ds.range?.start ?? si.location?.range?.start;
+    let document: DocumentSymbol | null = null;
+    let information: SymbolInformation | null = null;
+    if (isSymbolInformation(sym)) information = sym;
+    else document = sym;
+    const declStart = document?.range.start ?? information?.location.range.start;
     if (!declStart) continue;
-    const nameStart = ds.selectionRange?.start;
-
-    const symbol: CodeSymbol = {
+    const nameStart = document
+      ? resolveDocumentSymbolNameStart(document, context.sourceLines)
+      : null;
+    const reportedContainer = information?.containerName ?? container;
+    // SymbolInformation is flat: containerName remains metadata, not hierarchy evidence.
+    const nesting: DeclarationNesting = information ? "unknown" : context.nesting;
+
+    const symbol: DocumentCodeSymbol = {
       name: sym.name,
       kind: symbolKindName(sym.kind),
       file: filePath,
       declarationAnchor: { line: declStart.line + 1, character: declStart.character + 1 },
-      container,
+      container: reportedContainer,
+      nesting,
     };
     if (nameStart) {
       symbol.nameAnchor = { line: nameStart.line + 1, character: nameStart.character + 1 };
@@ -278,21 +281,71 @@ function flattenDocumentSymbols(
 
     result.push(symbol);
 
-    if (Array.isArray(ds.children) && ds.children.length > 0) {
-      result.push(...flattenDocumentSymbols(ds.children, filePath, sym.name));
+    if (document?.children && document.children.length > 0) {
+      result.push(
+        ...flattenDocumentSymbols(document.children, filePath, sym.name, {
+          sourceLines: context.sourceLines,
+          nesting: "nested",
+        }),
+      );
     }
   }
 
   return result;
 }
 
+function isSymbolInformation(
+  symbol: DocumentSymbol | SymbolInformation,
+): symbol is SymbolInformation {
+  return "location" in symbol;
+}
+
+async function readSourceLines(filePath: string): Promise<readonly string[] | null> {
+  try {
+    return (await readFile(filePath, "utf-8")).split(/\r?\n/);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Validate the LSP selection range against source text. Some servers return
+ * the full overload declaration as selectionRange; recover the exact symbol
+ * token on that line rather than labeling the declaration start as a name.
+ */
+function resolveDocumentSymbolNameStart(
+  symbol: DocumentSymbol,
+  sourceLines: readonly string[] | null,
+): { line: number; character: number } | null {
+  const selectionStart = symbol.selectionRange?.start;
+  if (!selectionStart) return null;
+  if (!sourceLines) return selectionStart;
+
+  const sourceLine = sourceLines[selectionStart.line];
+  if (sourceLine === undefined) return null;
+  if (
+    sourceLine.slice(selectionStart.character, selectionStart.character + symbol.name.length) ===
+    symbol.name
+  ) {
+    return selectionStart;
+  }
+
+  const rangeStart = symbol.range?.start;
+  const rangeEnd = symbol.range?.end;
+  const from = rangeStart?.line === selectionStart.line ? rangeStart.character : 0;
+  const until = rangeEnd?.line === selectionStart.line ? rangeEnd.character : sourceLine.length;
+  const repairedCharacter = sourceLine.indexOf(symbol.name, from);
+  if (repairedCharacter < 0 || repairedCharacter + symbol.name.length > until) return null;
+  return { line: selectionStart.line, character: repairedCharacter };
+}
+
 function toCodeSymbol(sym: SymbolInformation): CodeSymbol {
   const uri = sym.location?.uri ?? "";
   const start = sym.location?.range?.start;
   return {
     name: sym.name,
     kind: symbolKindName(sym.kind),
-    file: uri.startsWith("file://") ? decodeURIComponent(uri.slice(7)) : uri,
+    file: uriToFile(uri),
     // SymbolInformation has no selectionRange — nameAnchor is derived later
     // by the orchestration layer's refine, or left absent.
     declarationAnchor: {

package/src/provider/refactor-planning.ts

@@ -1,9 +1,10 @@
 import type { CodePosition, RefactorResult, SourceRange } from "@mrclrchtr/supi-code-runtime/api";
+import { uriToFile } from "@mrclrchtr/supi-core/path";
 import type { CodeAction, TextDocumentEdit, TextEdit, WorkspaceEdit } from "../config/types.ts";
-import type { SessionLspService } from "../session/service-registry.ts";
+import type { WorkspaceLspRuntime } from "../session/runtime-registry.ts";
 
 export async function runRenameRefactor(
-  lsp: SessionLspService,
+  lsp: WorkspaceLspRuntime,
   file: string,
   position: CodePosition,
   newName: string,
@@ -37,7 +38,7 @@ export function collectCodeActionResults(actions: CodeAction[]): RefactorResult[
 }
 
 export async function runFilteredCodeActionRefactor(options: {
-  lsp: SessionLspService;
+  lsp: WorkspaceLspRuntime;
   file: string;
   position: CodePosition;
   operation: "update_imports" | "delete_dead_code" | "extract_function" | "extract_variable";
@@ -146,15 +147,6 @@ function convertLspWorkspaceEdit(edit: WorkspaceEdit | null): RefactorResult {
   return { kind: "precise", edits: { edits: fileEdits } };
 }
 
-function resolveFileFromUri(uri: string): string {
-  if (!uri.startsWith("file://")) return uri;
-  try {
-    return decodeURIComponent(uri.slice(7));
-  } catch {
-    return uri;
-  }
-}
-
 function collectDocumentChangeEdits(
   docChanges: NonNullable<WorkspaceEdit["documentChanges"]>,
 ): Array<{
@@ -170,7 +162,7 @@ function collectDocumentChangeEdits(
   for (const change of docChanges) {
     const tdEdit = change as TextDocumentEdit;
     if (!tdEdit.textDocument || !tdEdit.edits) continue;
-    const file = resolveFileFromUri(tdEdit.textDocument.uri);
+    const file = uriToFile(tdEdit.textDocument.uri);
     for (const singleEdit of tdEdit.edits) {
       const te = singleEdit as TextEdit;
       out.push({
@@ -198,7 +190,7 @@ function collectChangesEdits(changes: NonNullable<WorkspaceEdit["changes"]>): Ar
   }> = [];
   for (const [uri, textEdits] of Object.entries(changes)) {
     if (!textEdits || textEdits.length === 0) continue;
-    const file = resolveFileFromUri(uri);
+    const file = uriToFile(uri);
     for (const te of textEdits) {
       out.push({
         file,