@mrclrchtr/supi-lsp 3.2.0 → 4.0.0

package/src/session/{service-registry.ts → runtime-registry.ts}

@@ -1,12 +1,16 @@
-// Shared session-scoped LSP service registry.
-// Peer extensions can import `getSessionLspService` from the package root
-// to reuse the active LSP runtime without starting duplicate servers.
+// Shared session-scoped LSP service registry reused by peer extensions.
 
+import {
+  type CodeQueryResult,
+  mapCodeQueryResult,
+  unavailableCodeQuery,
+} from "@mrclrchtr/supi-code-runtime/api";
 import { createSessionStateRegistry } from "@mrclrchtr/supi-core/session";
 import type {
   CodeAction,
   Diagnostic,
   DocumentSymbol,
+  FileEvent,
   Hover,
   Location,
   LocationLink,
@@ -19,11 +23,16 @@ import type {
 } from "../config/types.ts";
 import type { LspManager } from "../manager/manager.ts";
 import { resolveSessionPath } from "../utils.ts";
+import { raceReadinessValue } from "./readiness.ts";
 
 function isRange(value: Position | Range): value is Range {
   return "start" in value && "end" in value;
 }
 
+function unavailableFileQuery<T>(operation: string, file: string): CodeQueryResult<T> {
+  return unavailableCodeQuery(`No routed LSP client could complete ${operation} for ${file}.`);
+}
+
 /** Workspace diagnostic summary grouped by file. */
 export interface WorkspaceDiagnosticSummaryEntry {
   file: string;
@@ -43,7 +52,8 @@ export interface OutstandingDiagnosticSummaryEntry {
 
 /** Result from a workspace diagnostic recovery pass. */
 export interface RecoverDiagnosticsResult {
-  refreshedClients: number;
+  /** Active clients targeted by the best-effort refresh, not confirmed successful refreshes. */
+  attemptedClients: number;
   restartedClients: number;
   staleAssessment: {
     suspected: boolean;
@@ -52,9 +62,9 @@ export interface RecoverDiagnosticsResult {
   };
 }
 
-export type SessionLspServiceState =
-  | { kind: "ready"; service: SessionLspService }
-  | { kind: "inactive"; service: SessionLspService }
+export type WorkspaceLspRuntimeState =
+  | { kind: "ready"; runtime: WorkspaceLspRuntime }
+  | { kind: "inactive"; runtime: WorkspaceLspRuntime }
   | { kind: "pending" }
   | { kind: "disabled" }
   | { kind: "unavailable"; reason: string };
@@ -65,59 +75,116 @@ export type SemanticReadinessResult =
   | { kind: "unavailable"; reason: string };
 
 /**
- * Public wrapper around {@link LspManager} that exposes stable semantic operations.
+ * Workspace-scoped LSP interface that owns routing, readiness, semantic operations,
+ * diagnostics, and recovery without exposing clients or the mutable manager.
  * File path inputs may be absolute or session-cwd-relative; a leading `@` is stripped
  * to match pi's built-in path-tool convention. Position arguments use raw 0-based LSP
  * coordinates; use `toLspPosition()` from `@mrclrchtr/supi-lsp/api` when starting from
  * user-facing 1-based line and character values.
  */
-export class SessionLspService {
+export interface WorkspaceLspRuntime {
+  hover(filePath: string, position: Position): Promise<CodeQueryResult<Hover | null>>;
+  definition(
+    filePath: string,
+    position: Position,
+  ): Promise<CodeQueryResult<Location | Location[] | LocationLink[] | null>>;
+  references(filePath: string, position: Position): Promise<CodeQueryResult<Location[]>>;
+  implementation(
+    filePath: string,
+    position: Position,
+  ): Promise<CodeQueryResult<Location | Location[] | LocationLink[] | null>>;
+  documentSymbols(
+    filePath: string,
+  ): Promise<CodeQueryResult<DocumentSymbol[] | SymbolInformation[]>>;
+  workspaceSymbol(query: string): Promise<CodeQueryResult<SymbolInformation[] | WorkspaceSymbol[]>>;
+  rename(filePath: string, position: Position, newName: string): Promise<WorkspaceEdit | null>;
+  codeActions(filePath: string, positionOrRange: Position | Range): Promise<CodeAction[] | null>;
+  /** Succeeds only when the concrete routed client exists and is query-ready. */
+  waitUntilReadyForFile(
+    filePath: string,
+    options?: { timeoutMs?: number },
+  ): Promise<SemanticReadinessResult>;
+  /** Succeeds only when at least one concrete workspace client is active and query-ready. */
+  waitUntilReadyForWorkspace(options?: { timeoutMs?: number }): Promise<SemanticReadinessResult>;
+  getProjectServers(): ProjectServerInfo[];
+  isSupportedSourceFile(filePath: string): boolean;
+  trackFile(filePath: string): Promise<boolean>;
+  closeFile(filePath: string): void;
+  pruneMissingFiles(): readonly string[];
+  noteWorkspaceChanges(changes: FileEvent[]): void;
+  fileDiagnostics(filePath: string, maxSeverity?: number): Promise<CodeQueryResult<Diagnostic[]>>;
+  refreshOpenDiagnostics(options?: { maxWaitMs?: number; quietMs?: number }): Promise<void>;
+  getWorkspaceDiagnosticSummary(): WorkspaceDiagnosticSummaryEntry[];
+  getOutstandingDiagnostics(
+    maxSeverity?: number,
+  ): Array<{ file: string; diagnostics: Diagnostic[] }>;
+  getOutstandingDiagnosticSummary(maxSeverity?: number): OutstandingDiagnosticSummaryEntry[];
+  recoverDiagnostics(options?: {
+    restartIfStillStale?: boolean;
+    maxWaitMs?: number;
+    quietMs?: number;
+  }): Promise<RecoverDiagnosticsResult>;
+}
+
+class DefaultWorkspaceLspRuntime implements WorkspaceLspRuntime {
   constructor(private readonly manager: LspManager) {}
 
+  static createOwner(manager: LspManager) {
+    const runtime = new DefaultWorkspaceLspRuntime(manager);
+    return { runtime: runtime as WorkspaceLspRuntime, shutdown: () => runtime.#shutdown() };
+  }
+
   // ── Semantic lookups ────────────────────────────────────────────────
 
-  async hover(filePath: string, position: Position): Promise<Hover | null> {
+  async hover(filePath: string, position: Position): Promise<CodeQueryResult<Hover | null>> {
     const resolvedPath = this.resolveFilePath(filePath);
     const client = await this.manager.ensureFileOpen(resolvedPath);
-    if (!client) return null;
+    if (!client) return unavailableFileQuery("hover", resolvedPath);
     return client.hover(resolvedPath, position);
   }
 
   async definition(
     filePath: string,
     position: Position,
-  ): Promise<Location | Location[] | LocationLink[] | null> {
+  ): Promise<CodeQueryResult<Location | Location[] | LocationLink[] | null>> {
     const resolvedPath = this.resolveFilePath(filePath);
     const client = await this.manager.ensureFileOpen(resolvedPath);
-    if (!client) return null;
+    if (!client) return unavailableFileQuery("definition", resolvedPath);
     return client.definition(resolvedPath, position);
   }
 
-  async references(filePath: string, position: Position): Promise<Location[] | null> {
+  async references(filePath: string, position: Position): Promise<CodeQueryResult<Location[]>> {
     const resolvedPath = this.resolveFilePath(filePath);
     const client = await this.manager.ensureFileOpen(resolvedPath);
-    if (!client) return null;
-    return client.references(resolvedPath, position);
+    if (!client) return unavailableFileQuery("references", resolvedPath);
+    return mapCodeQueryResult(
+      await client.references(resolvedPath, position),
+      (data) => data ?? [],
+    );
   }
 
   async implementation(
     filePath: string,
     position: Position,
-  ): Promise<Location | Location[] | LocationLink[] | null> {
+  ): Promise<CodeQueryResult<Location | Location[] | LocationLink[] | null>> {
     const resolvedPath = this.resolveFilePath(filePath);
     const client = await this.manager.ensureFileOpen(resolvedPath);
-    if (!client) return null;
+    if (!client) return unavailableFileQuery("implementation", resolvedPath);
     return client.implementation(resolvedPath, position);
   }
 
-  async documentSymbols(filePath: string): Promise<DocumentSymbol[] | SymbolInformation[] | null> {
+  async documentSymbols(
+    filePath: string,
+  ): Promise<CodeQueryResult<DocumentSymbol[] | SymbolInformation[]>> {
     const resolvedPath = this.resolveFilePath(filePath);
     const client = await this.manager.ensureFileOpen(resolvedPath);
-    if (!client) return null;
-    return client.documentSymbols(resolvedPath);
+    if (!client) return unavailableFileQuery("document symbols", resolvedPath);
+    return mapCodeQueryResult(await client.documentSymbols(resolvedPath), (data) => data ?? []);
   }
 
-  async workspaceSymbol(query: string): Promise<SymbolInformation[] | WorkspaceSymbol[] | null> {
+  async workspaceSymbol(
+    query: string,
+  ): Promise<CodeQueryResult<SymbolInformation[] | WorkspaceSymbol[]>> {
     return this.manager.workspaceSymbol(query);
   }
 
@@ -167,7 +234,18 @@ export class SessionLspService {
       };
     }
 
-    return raceReadiness(this.manager.waitUntilFileReady(resolvedPath), options.timeoutMs);
+    const readiness = await raceReadinessValue(
+      this.manager.waitUntilFileReady(resolvedPath),
+      options.timeoutMs,
+    );
+    if (readiness.kind !== "resolved") return readiness;
+    if (readiness.value === null) {
+      return {
+        kind: "unavailable",
+        reason: "The routed LSP client could not be started for this file",
+      };
+    }
+    return { kind: "ready" };
   }
 
   /**
@@ -177,11 +255,20 @@ export class SessionLspService {
   async waitUntilReadyForWorkspace(
     options: { timeoutMs?: number } = {},
   ): Promise<SemanticReadinessResult> {
-    return raceReadiness(this.manager.waitUntilWorkspaceReady(), options.timeoutMs);
+    const readiness = await raceReadinessValue(
+      this.manager.waitUntilWorkspaceReady(),
+      options.timeoutMs,
+    );
+    if (readiness.kind !== "resolved") return readiness;
+    if (readiness.value === 0) {
+      return {
+        kind: "unavailable",
+        reason: "No active LSP clients are ready for this workspace",
+      };
+    }
+    return { kind: "ready" };
   }
 
-  // ── Project / runtime awareness ─────────────────────────────────────
-
   getProjectServers(): ProjectServerInfo[] {
     return this.manager.getKnownProjectServers([]);
   }
@@ -191,15 +278,51 @@ export class SessionLspService {
     return this.manager.canServeFile(this.resolveFilePath(filePath));
   }
 
-  // ── Diagnostics ─────────────────────────────────────────────────────
+  /** Track a file in its routed client without exposing that client. */
+  async trackFile(filePath: string): Promise<boolean> {
+    const resolvedPath = this.resolveFilePath(filePath);
+    return (await this.manager.ensureFileOpen(resolvedPath)) !== null;
+  }
+
+  /** Stop tracking a file and clear its cached diagnostics. */
+  closeFile(filePath: string): void {
+    this.manager.closeFile(this.resolveFilePath(filePath));
+  }
+
+  /** Remove missing files from runtime tracking. */
+  pruneMissingFiles(): readonly string[] {
+    return this.manager.pruneMissingFiles();
+  }
+
+  /** Notify routed clients of workspace file changes and reset pull state. */
+  noteWorkspaceChanges(changes: FileEvent[]): void {
+    this.manager.clearAllPullResultIds();
+    this.manager.notifyWorkspaceFileChanges(changes);
+  }
+
+  async #shutdown(): Promise<void> {
+    await this.manager.shutdownAll();
+  }
+
+  // ── Diagnostics and recovery ────────────────────────────────────────
 
   /** Sync a file through LSP and return diagnostics up to the supplied severity threshold. */
-  async fileDiagnostics(filePath: string, maxSeverity: number = 4): Promise<Diagnostic[] | null> {
+  async fileDiagnostics(
+    filePath: string,
+    maxSeverity: number = 4,
+  ): Promise<CodeQueryResult<Diagnostic[]>> {
     const resolvedPath = this.resolveFilePath(filePath);
-    if (!this.manager.canServeFile(resolvedPath)) return null;
+    if (!this.manager.canServeFile(resolvedPath)) {
+      return unavailableFileQuery("diagnostics", resolvedPath);
+    }
     return this.manager.syncFileAndGetDiagnostics(resolvedPath, maxSeverity);
   }
 
+  /** Re-sync every open document and wait for diagnostics to settle. */
+  async refreshOpenDiagnostics(options?: { maxWaitMs?: number; quietMs?: number }): Promise<void> {
+    await this.manager.refreshOpenDiagnostics(options);
+  }
+
   /** Get a lightweight workspace diagnostic summary for all tracked files. */
   getWorkspaceDiagnosticSummary(): WorkspaceDiagnosticSummaryEntry[] {
     return this.manager.getDiagnosticSummary();
@@ -231,51 +354,20 @@ export class SessionLspService {
   }
 }
 
-// ── Registry ──────────────────────────────────────────────────────────
+export function createWorkspaceLspRuntimeOwner(manager: LspManager) {
+  return DefaultWorkspaceLspRuntime.createOwner(manager);
+}
 
 const WAIT_INTERVAL_MS = 25;
-const DEFAULT_SEMANTIC_READY_TIMEOUT_MS = 15_000;
-const registry = createSessionStateRegistry<SessionLspServiceState>("supi-lsp/session-registry");
-
-async function raceReadiness(
-  readiness: Promise<unknown>,
-  timeoutMs: number | undefined,
-): Promise<SemanticReadinessResult> {
-  const effectiveTimeoutMs = timeoutMs ?? DEFAULT_SEMANTIC_READY_TIMEOUT_MS;
-  let timer: ReturnType<typeof setTimeout> | null = null;
-
-  try {
-    await Promise.race([
-      readiness,
-      new Promise<never>((_, reject) => {
-        timer = setTimeout(
-          () => reject(new Error("semantic-readiness-timeout")),
-          effectiveTimeoutMs,
-        );
-      }),
-    ]);
-    return { kind: "ready" };
-  } catch (error) {
-    if (timer) clearTimeout(timer);
-    if (error instanceof Error && error.message === "semantic-readiness-timeout") {
-      return { kind: "timeout" };
-    }
-    return {
-      kind: "unavailable",
-      reason: error instanceof Error ? error.message : String(error),
-    };
-  } finally {
-    if (timer) clearTimeout(timer);
-  }
-}
+const registry = createSessionStateRegistry<WorkspaceLspRuntimeState>("supi-lsp/session-registry");
 
 /** Publish the LSP service state for a session cwd. */
-export function setSessionLspServiceState(cwd: string, state: SessionLspServiceState): void {
+export function setWorkspaceLspRuntimeState(cwd: string, state: WorkspaceLspRuntimeState): void {
   registry.set(cwd, state);
 }
 
 /** Acquire the LSP service state for a session cwd. */
-export function getSessionLspService(cwd: string): SessionLspServiceState {
+export function getWorkspaceLspRuntime(cwd: string): WorkspaceLspRuntimeState {
   return (
     registry.get(cwd) ?? {
       kind: "unavailable",
@@ -285,22 +377,22 @@ export function getSessionLspService(cwd: string): SessionLspServiceState {
 }
 
 /** Wait briefly for a pending session-scoped LSP service to become ready. */
-export async function waitForSessionLspService(
+export async function waitForWorkspaceLspRuntime(
   cwd: string,
   timeoutMs: number = 250,
-): Promise<SessionLspServiceState> {
+): Promise<WorkspaceLspRuntimeState> {
   const deadline = Date.now() + Math.max(0, timeoutMs);
-  let state = getSessionLspService(cwd);
+  let state = getWorkspaceLspRuntime(cwd);
 
   while (state.kind === "pending" && Date.now() < deadline) {
     await new Promise((resolve) => setTimeout(resolve, WAIT_INTERVAL_MS));
-    state = getSessionLspService(cwd);
+    state = getWorkspaceLspRuntime(cwd);
   }
 
   return state;
 }
 
 /** Remove the LSP service state for a session cwd. */
-export function clearSessionLspService(cwd: string): void {
+export function clearWorkspaceLspRuntime(cwd: string): void {
   registry.clear(cwd);
 }

package/node_modules/@mrclrchtr/supi-code-runtime/node_modules/@mrclrchtr/supi-core/src/abort-utils.ts

@@ -1,31 +0,0 @@
-/**
- * Abort controller/signal utility helpers.
- *
- * @module
- */
-
-/**
- * Combine a caller-provided abort controller with a generation timeout signal.
- *
- * Returns the combined signal and a cleanup function that removes both
- * event listeners. Callers must invoke cleanup in a `finally` block
- * to avoid listener leaks.
- */
-export function combineAbortSignals(
-  abort: AbortController,
-  timeoutMs: number,
-): { signal: AbortSignal; cleanup: () => void } {
-  const timeoutSignal = AbortSignal.timeout(timeoutMs);
-  const combinedController = new AbortController();
-  const onAbort = () => combinedController.abort();
-  abort.signal.addEventListener("abort", onAbort, { once: true });
-  timeoutSignal.addEventListener("abort", onAbort, { once: true });
-
-  return {
-    signal: combinedController.signal,
-    cleanup: () => {
-      abort.signal.removeEventListener("abort", onAbort);
-      timeoutSignal.removeEventListener("abort", onAbort);
-    },
-  };
-}

package/node_modules/@mrclrchtr/supi-code-runtime/node_modules/@mrclrchtr/supi-core/src/substrate-types.ts

@@ -1,11 +0,0 @@
-/** 0-based position used by LSP and code-intelligence internally. */
-export interface CodePosition {
-  line: number;
-  character: number;
-}
-
-/** Normalized location — flat replacement for LSP's nested Location/range shape. */
-export interface CodeLocation {
-  uri: string;
-  range: { start: CodePosition; end: CodePosition };
-}

package/node_modules/@mrclrchtr/supi-code-runtime/node_modules/@mrclrchtr/supi-core/src/types.ts

@@ -1,2 +0,0 @@
-// supi-core types domain — shared substrate types (zero dependencies, pure types).
-export type { CodeLocation, CodePosition } from "./substrate-types.ts";

package/node_modules/@mrclrchtr/supi-core/src/abort-utils.ts

@@ -1,31 +0,0 @@
-/**
- * Abort controller/signal utility helpers.
- *
- * @module
- */
-
-/**
- * Combine a caller-provided abort controller with a generation timeout signal.
- *
- * Returns the combined signal and a cleanup function that removes both
- * event listeners. Callers must invoke cleanup in a `finally` block
- * to avoid listener leaks.
- */
-export function combineAbortSignals(
-  abort: AbortController,
-  timeoutMs: number,
-): { signal: AbortSignal; cleanup: () => void } {
-  const timeoutSignal = AbortSignal.timeout(timeoutMs);
-  const combinedController = new AbortController();
-  const onAbort = () => combinedController.abort();
-  abort.signal.addEventListener("abort", onAbort, { once: true });
-  timeoutSignal.addEventListener("abort", onAbort, { once: true });
-
-  return {
-    signal: combinedController.signal,
-    cleanup: () => {
-      abort.signal.removeEventListener("abort", onAbort);
-      timeoutSignal.removeEventListener("abort", onAbort);
-    },
-  };
-}

package/node_modules/@mrclrchtr/supi-core/src/substrate-types.ts

@@ -1,11 +0,0 @@
-/** 0-based position used by LSP and code-intelligence internally. */
-export interface CodePosition {
-  line: number;
-  character: number;
-}
-
-/** Normalized location — flat replacement for LSP's nested Location/range shape. */
-export interface CodeLocation {
-  uri: string;
-  range: { start: CodePosition; end: CodePosition };
-}

package/node_modules/@mrclrchtr/supi-core/src/types.ts

@@ -1,2 +0,0 @@
-// supi-core types domain — shared substrate types (zero dependencies, pure types).
-export type { CodeLocation, CodePosition } from "./substrate-types.ts";

package/src/diagnostics/diagnostic-augmentation.ts

@@ -1,82 +0,0 @@
-import type { Diagnostic, Hover, MarkedString, MarkupContent } from "../config/types.ts";
-import type { LspManager } from "../manager/manager.ts";
-import { resolveSessionPath } from "../utils.ts";
-
-const AUGMENT_TIMEOUT_MS = 500;
-
-/**
- * Augment diagnostics with LSP hover and code_actions at the first severity-1 error.
- * Silently returns null if LSP is unavailable, times out, or there are no errors.
- */
-export async function augmentDiagnostics(
-  filePath: string,
-  diags: Diagnostic[],
-  manager: LspManager,
-  cwd: string,
-): Promise<string | null> {
-  const firstError = diags.find((d) => d.severity === 1);
-  if (!firstError) return null;
-
-  const resolvedPath = resolveSessionPath(cwd, filePath);
-  const client = await manager.getClientForFile(resolvedPath);
-  if (!client) return null;
-
-  const pos = firstError.range.start;
-
-  const [hoverResult, codeActionsResult] = await Promise.all([
-    withTimeout(client.hover(resolvedPath, pos), AUGMENT_TIMEOUT_MS),
-    withTimeout(
-      client.codeActions(resolvedPath, { start: pos, end: pos }, { diagnostics: [firstError] }),
-      AUGMENT_TIMEOUT_MS,
-    ),
-  ]);
-
-  const parts: string[] = [];
-
-  if (hoverResult) {
-    const hoverText = formatHoverForDiagnostics(hoverResult);
-    if (hoverText) parts.push(`💡 Hover info:\n${hoverText}`);
-  }
-
-  if (codeActionsResult && codeActionsResult.length > 0) {
-    const titles = codeActionsResult.map((a) => a.title).join(", ");
-    parts.push(`💡 Available fix: ${titles}`);
-  }
-
-  return parts.length > 0 ? parts.join("\n") : null;
-}
-
-/**
- * Extract raw hover text for inline diagnostic augmentation.
- * Intentionally strips markdown code-block framing (unlike formatHover)
- * to keep augmentation concise and readable inside diagnostic output.
- */
-function formatHoverForDiagnostics(hover: Hover): string {
-  const contents = hover.contents;
-  let text = "";
-
-  if (typeof contents === "string") {
-    text = contents;
-  } else if ("value" in contents) {
-    const mc = contents as MarkupContent | { language: string; value: string };
-    if ("kind" in mc) text = mc.value;
-    else text = mc.value;
-  } else if (Array.isArray(contents)) {
-    text = (contents as MarkedString[])
-      .map((c) => (typeof c === "string" ? c : c.value))
-      .join("\n");
-  }
-
-  const lines = text.split("\n").slice(0, 3);
-  return lines.join("\n");
-}
-
-async function withTimeout<T>(promise: Promise<T | null>, ms: number): Promise<T | null> {
-  let timer: ReturnType<typeof setTimeout> | null = null;
-  const timeoutPromise = new Promise<null>((resolve) => {
-    timer = setTimeout(() => resolve(null), ms);
-  });
-  const result = await Promise.race([promise, timeoutPromise]);
-  if (timer) clearTimeout(timer);
-  return result;
-}

package/src/diagnostics/diagnostic-context.ts

@@ -1,116 +0,0 @@
-// Diagnostic context formatting for the LSP extension.
-// Extracted from guidance.ts to keep prompt surfaces separate from formatting logic.
-
-import type { Diagnostic } from "../config/types.ts";
-import type { OutstandingDiagnosticSummaryEntry } from "../manager/manager-types.ts";
-import { splitSuppressionDiagnostics } from "./suppression-diagnostics.ts";
-
-export const MAX_DETAILED_DIAGNOSTICS = 5;
-const MAX_DETAIL_LINES_PER_FILE = 3;
-
-interface DetailedDiagnostics {
-  file: string;
-  diagnostics: Diagnostic[];
-}
-
-export function formatDiagnosticsContext(
-  diagnostics: OutstandingDiagnosticSummaryEntry[],
-  maxFiles: number = 3,
-  detailed?: DetailedDiagnostics[],
-  staleWarning?: string | null,
-): string | null {
-  if (diagnostics.length === 0) return null;
-
-  const totalDiags = diagnostics.reduce((sum, d) => sum + d.total, 0);
-  const detailMap = buildDetailMap(totalDiags, detailed);
-
-  const lines: string[] = [];
-  if (staleWarning) lines.push(staleWarning);
-  const visible = diagnostics.slice(0, maxFiles);
-
-  for (const entry of visible) {
-    lines.push(`- ${entry.file}: ${formatCounts(entry)}`);
-    appendDetailLines(lines, detailMap?.get(entry.file));
-  }
-
-  const remaining = diagnostics.length - visible.length;
-  if (remaining > 0) {
-    lines.push(`- +${remaining} more file${remaining === 1 ? "" : "s"}`);
-  }
-
-  appendSuppressionCleanup(
-    lines,
-    visible.map((entry) => entry.file),
-    detailMap,
-  );
-
-  return [
-    '<extension-context source="supi-lsp">',
-    "Outstanding diagnostics — fix these before proceeding:",
-    ...lines,
-    "</extension-context>",
-  ].join("\n");
-}
-
-function buildDetailMap(
-  totalDiags: number,
-  detailed?: DetailedDiagnostics[],
-): Map<string, Diagnostic[]> | null {
-  if (totalDiags > MAX_DETAILED_DIAGNOSTICS || !detailed || detailed.length === 0) return null;
-  return new Map(detailed.map((d) => [d.file, d.diagnostics]));
-}
-
-function appendDetailLines(lines: string[], details?: Diagnostic[]): void {
-  if (!details) return;
-  for (const d of details.slice(0, MAX_DETAIL_LINES_PER_FILE)) {
-    const line = d.range.start.line + 1;
-    const char = d.range.start.character + 1;
-    const source = d.source ? ` ${d.source}` : "";
-    const msg = typeof d.message === "string" ? d.message : d.message.value;
-    lines.push(`  L${line} C${char}${source}: ${msg}`);
-  }
-  if (details.length > MAX_DETAIL_LINES_PER_FILE) {
-    const extra = details.length - MAX_DETAIL_LINES_PER_FILE;
-    lines.push(`  +${extra} more`);
-  }
-}
-
-function appendSuppressionCleanup(
-  lines: string[],
-  visibleFiles: string[],
-  detailMap: Map<string, Diagnostic[]> | null,
-): void {
-  if (!detailMap) return;
-
-  const suppressionLines: string[] = [];
-  for (const file of visibleFiles) {
-    const diagnostics = detailMap.get(file);
-    if (!diagnostics) continue;
-
-    const { suppressions } = splitSuppressionDiagnostics(diagnostics, 1);
-    if (suppressions.length === 0) continue;
-
-    suppressionLines.push(`- ${file}`);
-    appendDetailLines(suppressionLines, suppressions);
-  }
-
-  if (suppressionLines.length === 0) return;
-  lines.push("", "Stale suppression comments — clean these up:", ...suppressionLines);
-}
-
-export function diagnosticsContextFingerprint(content: string | null): string | null {
-  return content;
-}
-
-function formatCounts(entry: OutstandingDiagnosticSummaryEntry): string {
-  const counts: string[] = [];
-  if (entry.errors > 0) counts.push(pluralize(entry.errors, "error"));
-  if (entry.warnings > 0) counts.push(pluralize(entry.warnings, "warning"));
-  if (entry.information > 0) counts.push(pluralize(entry.information, "info"));
-  if (entry.hints > 0) counts.push(pluralize(entry.hints, "hint"));
-  return counts.join(", ");
-}
-
-function pluralize(count: number, word: string): string {
-  return `${count} ${word}${count === 1 ? "" : "s"}`;
-}