@mrclrchtr/supi-code-intelligence 4.10.0 → 6.0.0

package/node_modules/@mrclrchtr/supi-lsp/src/config/tsconfig-scope.ts

@@ -7,6 +7,10 @@
 
 import * as path from "node:path";
 import ts from "typescript";
+import { collectExtendedProjectConfigs } from "./tsconfig-extends.ts";
+import { normalizeTsconfigPath as normalizePath } from "./tsconfig-path.ts";
+
+export { isProjectConfigFileName } from "./tsconfig-extends.ts";
 
 interface ParsedProjectConfig {
   configPath: string;
@@ -19,8 +23,39 @@ interface ParsedProjectConfig {
   usesDefaultInclude: boolean;
 }
 
+interface ParsedProjectConfigCacheEntry {
+  parsed: ParsedProjectConfig | null;
+  dependencies: Set<string>;
+}
+
+/** Whether a file is inside the compilation scope of its nearest project config. */
+export type FileScopeStatus = "included" | "excluded" | "no-config" | "out-of-tree";
+
+/**
+ * The mechanism that produced a file scope decision.
+ *
+ * `extension` covers unsupported file extensions (checked before any pattern).
+ */
+export type ScopeDecisionBasis =
+  | "fileNames"
+  | "explicit"
+  | "include-pattern"
+  | "default-include"
+  | "exclude-pattern"
+  | "extension";
+
+/** An explainable tsconfig scope decision for one file. */
+export interface FileScopeDecision {
+  status: FileScopeStatus;
+  /** Decision mechanism; null when no decision applies (no-config, out-of-tree). */
+  basis: ScopeDecisionBasis | null;
+  /** Absolute path of the config that decided the file, when one exists. */
+  configPath: string | null;
+  caseSensitiveFileNames: boolean;
+}
+
 const nearestConfigCache = new Map<string, string | null>();
-const parsedConfigCache = new Map<string, ParsedProjectConfig | null>();
+const parsedConfigCache = new Map<string, ParsedProjectConfigCacheEntry>();
 
 const tsInternal = ts as typeof ts & {
   getFileMatcherPatterns?: (
@@ -47,14 +82,63 @@ const tsInternal = ts as typeof ts & {
  * @returns `true` if the file is excluded from compilation scope
  */
 export function isFileExcludedByTsconfig(filePath: string, cwd: string): boolean {
+  // Legacy filter semantics: only a resolved "excluded" decision filters a
+  // file. Out-of-tree and no-config files stay unfiltered; the decision API
+  // still reports those statuses honestly for consumers that want them.
+  return getFileScopeDecision(filePath, cwd).status === "excluded";
+}
+
+/**
+ * Compute the explainable tsconfig scope decision for one file.
+ *
+ * The decision carries the mechanism that produced it (the scope decision
+ * basis) so consumers can report why a file is inside or outside the nearest
+ * project config without re-deriving the scope logic.
+ */
+export function getFileScopeDecision(filePath: string, cwd: string): FileScopeDecision {
+  const caseSensitiveFileNames = ts.sys.useCaseSensitiveFileNames;
   const absolutePath = path.resolve(cwd, filePath);
+  if (isOutOfTree(cwd, absolutePath)) {
+    return {
+      status: "out-of-tree",
+      basis: null,
+      configPath: null,
+      caseSensitiveFileNames,
+    };
+  }
+
   const configPath = findNearestProjectConfig(path.dirname(absolutePath), cwd);
-  if (!configPath) return false;
+  if (!configPath) {
+    return {
+      status: "no-config",
+      basis: null,
+      configPath: null,
+      caseSensitiveFileNames,
+    };
+  }
 
   const parsed = parseProjectConfig(configPath);
-  if (!parsed) return false;
+  if (!parsed) {
+    return {
+      status: "no-config",
+      basis: null,
+      configPath,
+      caseSensitiveFileNames,
+    };
+  }
 
-  return !isFileInProjectScope(parsed, absolutePath);
+  const decision = decideFileScope(parsed, absolutePath);
+  return {
+    status: decision.included ? "included" : "excluded",
+    basis: decision.basis,
+    configPath: parsed.configPath,
+    caseSensitiveFileNames,
+  };
+}
+
+function isOutOfTree(cwd: string, absolutePath: string): boolean {
+  const relative = path.relative(path.resolve(cwd), absolutePath);
+  return relative.startsWith(`..${path.sep}`) || relative === "..";
 }
 
 /**
@@ -104,11 +188,15 @@ function getLocalProjectConfig(directory: string): string | null {
 function parseProjectConfig(configPath: string): ParsedProjectConfig | null {
   const normalizedConfigPath = normalizePath(configPath);
   const cached = parsedConfigCache.get(normalizedConfigPath);
-  if (cached !== undefined) return cached;
+  if (cached !== undefined) return cached.parsed;
 
+  const cacheEntry: ParsedProjectConfigCacheEntry = {
+    parsed: null,
+    dependencies: collectExtendedProjectConfigs(configPath),
+  };
   const parsed = ts.getParsedCommandLineOfConfigFile(configPath, {}, createParseConfigHost());
   if (!parsed) {
-    parsedConfigCache.set(normalizedConfigPath, null);
+    parsedConfigCache.set(normalizedConfigPath, cacheEntry);
     return null;
   }
 
@@ -119,7 +207,10 @@ function parseProjectConfig(configPath: string): ParsedProjectConfig | null {
     configDir,
     parsed.raw.include,
     parsed.raw.exclude,
-    usesDefaultInclude,
+    {
+      useDefaultInclude: usesDefaultInclude,
+      useCaseSensitiveFileNames: ts.sys.useCaseSensitiveFileNames,
+    },
   );
   const supportedExtensions = new Set(getSupportedExtensions(parsed.options));
   if (parsed.options.resolveJsonModule) supportedExtensions.add(".json");
@@ -134,7 +225,8 @@ function parseProjectConfig(configPath: string): ParsedProjectConfig | null {
     supportedExtensions,
     usesDefaultInclude,
   } satisfies ParsedProjectConfig;
-  parsedConfigCache.set(normalizedConfigPath, result);
+  cacheEntry.parsed = result;
+  parsedConfigCache.set(normalizedConfigPath, cacheEntry);
   return result;
 }
 
@@ -147,15 +239,21 @@ function extractExplicitFiles(rawFiles: unknown, configDir: string): Set<string>
   );
 }
 
+interface FileMatcherOptions {
+  useDefaultInclude: boolean;
+  useCaseSensitiveFileNames: boolean;
+}
+
 function createFileMatchers(
   configDir: string,
   rawInclude: unknown,
   rawExclude: unknown,
-  useDefaultInclude: boolean,
+  options: FileMatcherOptions,
 ): {
   includeFilePattern: RegExp | null;
   excludePattern: RegExp | null;
 } {
+  const { useDefaultInclude, useCaseSensitiveFileNames } = options;
   const includeSpecs = Array.isArray(rawInclude)
     ? rawInclude.filter((entry): entry is string => typeof entry === "string")
     : undefined;
@@ -167,29 +265,45 @@ function createFileMatchers(
     excludeSpecs,
     useDefaultInclude ? ["**/*"] : includeSpecs,
   );
+  // normalizePath() lowercases paths when the filesystem is case-insensitive,
+  // so the include/exclude regexes must match case-insensitively too. Otherwise
+  // files created after the parse (absent from fileNames, tested against the
+  // include pattern) are wrongly declared excluded.
+  const regexFlags = useCaseSensitiveFileNames ? undefined : "i";
 
   return {
     includeFilePattern: matcherPatterns.includeFilePattern
-      ? new RegExp(matcherPatterns.includeFilePattern)
+      ? new RegExp(matcherPatterns.includeFilePattern, regexFlags)
       : null,
     excludePattern: matcherPatterns.excludePattern
-      ? new RegExp(matcherPatterns.excludePattern)
+      ? new RegExp(matcherPatterns.excludePattern, regexFlags)
       : null,
   };
 }
 
-function isFileInProjectScope(parsed: ParsedProjectConfig, absolutePath: string): boolean {
+function decideFileScope(
+  parsed: ParsedProjectConfig,
+  absolutePath: string,
+): { included: boolean; basis: ScopeDecisionBasis } {
   const normalizedPath = normalizePath(absolutePath);
-  if (parsed.fileNames.has(normalizedPath)) return true;
+  if (parsed.fileNames.has(normalizedPath)) return { included: true, basis: "fileNames" };
 
   const extension = path.extname(absolutePath).toLowerCase();
-  if (!parsed.supportedExtensions.has(extension)) return false;
+  if (!parsed.supportedExtensions.has(extension)) return { included: false, basis: "extension" };
 
-  if (parsed.explicitFiles) return parsed.explicitFiles.has(normalizedPath);
-  if (!isWithinOrEqual(parsed.configDir, absolutePath)) return false;
-  if (parsed.excludePattern?.test(normalizedPath)) return false;
-  if (parsed.usesDefaultInclude) return true;
-  return parsed.includeFilePattern ? parsed.includeFilePattern.test(normalizedPath) : false;
+  if (parsed.explicitFiles) {
+    return { included: parsed.explicitFiles.has(normalizedPath), basis: "explicit" };
+  }
+  // Include patterns are rooted at the config directory; a file outside it can
+  // only be in scope through the parse-time file set or an explicit files list.
+  if (!isWithinOrEqual(parsed.configDir, absolutePath)) {
+    return { included: false, basis: "include-pattern" };
+  }
+  if (parsed.excludePattern?.test(normalizedPath))
+    return { included: false, basis: "exclude-pattern" };
+  if (parsed.usesDefaultInclude) return { included: true, basis: "default-include" };
+  if (!parsed.includeFilePattern) return { included: false, basis: "include-pattern" };
+  return { included: parsed.includeFilePattern.test(normalizedPath), basis: "include-pattern" };
 }
 
 function getSupportedExtensions(options: ts.CompilerOptions): string[] {
@@ -229,11 +343,6 @@ function isWithinOrEqual(root: string, target: string): boolean {
   return relative === "" || (!relative.startsWith(`..${path.sep}`) && relative !== "..");
 }
 
-function normalizePath(target: string): string {
-  const resolved = path.resolve(target).replaceAll("\\", "/");
-  return ts.sys.useCaseSensitiveFileNames ? resolved : resolved.toLowerCase();
-}
-
 /**
  * Clear cached nearest-config lookups and parsed project config state.
  * Useful for testing and after workspace file changes.
@@ -242,3 +351,46 @@ export function clearTsconfigCache(): void {
   nearestConfigCache.clear();
   parsedConfigCache.clear();
 }
+
+/**
+ * Invalidate cached state for one config file that changed, was created, or
+ * was deleted.
+ *
+ * Removes the changed config and every cached root config that depends on it,
+ * so the next decision re-reads current config data. The wholesale
+ * {@link clearTsconfigCache} stays for lifecycle events; change signals use
+ * this targeted invalidation instead.
+ */
+export function invalidateTsconfigCacheForConfig(configPath: string): void {
+  const normalizedConfigPath = normalizePath(configPath);
+  const invalidated = new Set([normalizedConfigPath]);
+
+  for (const [cachedConfigPath, cacheEntry] of parsedConfigCache) {
+    if (cacheEntry.dependencies.has(normalizedConfigPath)) invalidated.add(cachedConfigPath);
+  }
+
+  for (const cachedConfigPath of invalidated) {
+    parsedConfigCache.delete(cachedConfigPath);
+  }
+
+  for (const [key, value] of nearestConfigCache) {
+    if (value !== null && invalidated.has(normalizePath(value))) nearestConfigCache.delete(key);
+  }
+}
+
+/**
+ * Invalidate nearest-config lookups that found nothing under `dir`.
+ *
+ * Used when a config is created: directories below the new config that
+ * previously resolved to no config may now resolve to it.
+ */
+export function invalidateTsconfigCacheForConfigDir(dir: string): void {
+  const normalizedDir = normalizePath(dir);
+  for (const [key, value] of nearestConfigCache) {
+    if (value !== null) continue;
+    const keyDir = key.split("::", 1)[0];
+    if (keyDir === normalizedDir || keyDir.startsWith(`${normalizedDir}/`)) {
+      nearestConfigCache.delete(key);
+    }
+  }
+}

package/node_modules/@mrclrchtr/supi-lsp/src/debug-telemetry.ts

@@ -0,0 +1,45 @@
+// Bounded identity vocabulary for LSP debug telemetry.
+//
+// LSP debug events may carry server, workspace, file, method, and root
+// identity for local protocol diagnosis. Every emitted identity string is
+// bounded to MAX_IDENTITY_STRING UTF-16 code units (truncation marker
+// included) and every identity list is bounded to MAX_SERVERS entries.
+
+/** Maximum number of server entries in one bounded LSP debug payload. */
+export const MAX_SERVERS = 16;
+
+/** Maximum UTF-16 code-unit length of one emitted identity string in an LSP debug payload. */
+export const MAX_IDENTITY_STRING = 512;
+
+/** Marker appended to an identity string truncated to MAX_IDENTITY_STRING. */
+export const IDENTITY_TRUNCATION_MARKER = "…";
+
+/**
+ * JSON-RPC error code recorded for client-local request timeouts.
+ *
+ * The JSON-RPC and LSP vocabularies define no timeout code. This constant
+ * uses the JSON-RPC implementation-defined error range (-32099..-32000) at a
+ * value that vscode-jsonrpc transport codes (-32099, -32098, -32097, -32096,
+ * -32002, -32001) and LSP error codes never use.
+ */
+export const LSP_REQUEST_TIMEOUT_ERROR_CODE = -32_095;
+
+/**
+ * Truncate one identity string so the emitted value (marker included) never
+ * exceeds MAX_IDENTITY_STRING UTF-16 code units.
+ */
+export function truncateIdentity(value: string): string {
+  if (value.length <= MAX_IDENTITY_STRING) return value;
+  return `${value.slice(0, MAX_IDENTITY_STRING - 1)}${IDENTITY_TRUNCATION_MARKER}`;
+}
+
+/** Bound an optional workspace root for event-level identity; undefined stays absent. */
+export function boundCwd(cwd: string | undefined): string | undefined {
+  if (cwd === undefined) return undefined;
+  return truncateIdentity(cwd);
+}
+
+/** Bound a server-name list to MAX_SERVERS entries, truncating each name. */
+export function boundServerNames(names: readonly string[]): string[] {
+  return names.slice(0, MAX_SERVERS).map(truncateIdentity);
+}

package/node_modules/@mrclrchtr/supi-lsp/src/diagnostics/evidence.ts

@@ -0,0 +1,42 @@
+/** Reason for a partial or unavailable single-file result when the push stays tentative. */
+export const TENTATIVE_PUSH_UNAVAILABLE_REASON =
+  "The current push publication is tentative: a later diagnostic republish for the same document synchronization is required.";
+
+/** A final evidence state for one tracked document. */
+export type DiagnosticEvidenceStatus = "confirmed" | "unconfirmed" | "failed" | "removed";
+
+/** Freshness evidence for one tracked document. */
+export interface DiagnosticEvidenceDocument {
+  readonly file: string;
+  readonly status: DiagnosticEvidenceStatus;
+}
+
+/** Exact document coverage from a diagnostic snapshot or refresh attempt. */
+export interface DiagnosticEvidenceSummary {
+  readonly requested: number;
+  readonly confirmed: number;
+  readonly unconfirmed: number;
+  readonly failed: number;
+  readonly removed: number;
+  readonly documents: readonly DiagnosticEvidenceDocument[];
+}
+
+/** Build exact coverage counts from one document outcome per requested document. */
+export function summarizeDiagnosticEvidence(
+  documents: readonly DiagnosticEvidenceDocument[],
+): DiagnosticEvidenceSummary {
+  const counts = {
+    requested: documents.length,
+    confirmed: 0,
+    unconfirmed: 0,
+    failed: 0,
+    removed: 0,
+  };
+  for (const document of documents) counts[document.status]++;
+  return { ...counts, documents: [...documents] };
+}
+
+/** Return an empty evidence summary for a refresh with no tracked documents. */
+export function emptyDiagnosticEvidence(): DiagnosticEvidenceSummary {
+  return summarizeDiagnosticEvidence([]);
+}

package/node_modules/@mrclrchtr/supi-lsp/src/diagnostics/workspace-sentinels.ts

@@ -1,20 +1,32 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { FileChangeType, type FileEvent } from "../config/types.ts";
-import { fileToUri } from "../utils.ts";
+import { fileToUri, uriToFile } from "../utils.ts";
 
 const IGNORED_DIRECTORIES = new Set(["node_modules", ".pnpm", ".git", "dist", "coverage"]);
 const ROOT_LOCKFILES = ["pnpm-lock.yaml", "package-lock.json", "yarn.lock", "bun.lockb"];
 
+export interface WorkspaceSentinelScanOptions {
+  /**
+   * Also track every regular source file (not just sentinels). The workspace
+   * refresh path uses this to discover files created since the last refresh;
+   * the diff then reports them as `sourceChanges` so the caller can pull them.
+   */
+  includeSourceFiles?: boolean;
+}
+
 /** Build a fresh snapshot of workspace sentinel files and their mtimes. */
-export function scanWorkspaceSentinels(cwd: string): Map<string, number> {
+export function scanWorkspaceSentinels(
+  cwd: string,
+  options: WorkspaceSentinelScanOptions = {},
+): Map<string, number> {
   const resolvedCwd = path.resolve(cwd);
   const snapshot = new Map<string, number>();
 
   if (!fs.existsSync(resolvedCwd)) return snapshot;
 
   try {
-    walkWorkspace(resolvedCwd, resolvedCwd, snapshot);
+    walkWorkspace(resolvedCwd, resolvedCwd, snapshot, options.includeSourceFiles ?? false);
   } catch {
     return snapshot;
   }
@@ -48,15 +60,34 @@ export function diffWorkspaceSentinelSnapshot(
   return changes.sort((a, b) => a.uri.localeCompare(b.uri));
 }
 
-/** Refresh a previous snapshot and return the new snapshot plus change events. */
+/**
+ * Refresh a previous snapshot and return the new snapshot plus change events.
+ *
+ * When `includeSourceFiles` is set, the returned `changes` list keeps
+ * sentinel-file events only; source-file events are returned separately in
+ * `sourceChanges` so the caller can act on them without interpreting every
+ * regular file edit as a config-level workspace change.
+ */
 export function syncWorkspaceSentinelSnapshot(
   cwd: string,
   previous: Map<string, number>,
-): { snapshot: Map<string, number>; changes: FileEvent[] } {
-  const snapshot = scanWorkspaceSentinels(cwd);
+  options: WorkspaceSentinelScanOptions = {},
+): { snapshot: Map<string, number>; changes: FileEvent[]; sourceChanges: FileEvent[] } {
+  const snapshot = scanWorkspaceSentinels(cwd, options);
+  const changes = diffWorkspaceSentinelSnapshot(previous, snapshot);
+  if (!options.includeSourceFiles) return { snapshot, changes, sourceChanges: [] };
+
+  const sourceChanges = changes.filter((change) => {
+    const filePath = uriToFile(change.uri);
+    return !isWorkspaceSentinelPath(filePath, cwd);
+  });
   return {
     snapshot,
-    changes: diffWorkspaceSentinelSnapshot(previous, snapshot),
+    changes: changes.filter((change) => {
+      const filePath = uriToFile(change.uri);
+      return isWorkspaceSentinelPath(filePath, cwd);
+    }),
+    sourceChanges,
   };
 }
 
@@ -66,7 +97,12 @@ export function isWorkspaceRecoveryTrigger(filePath: string, cwd: string): boole
   return isWorkspaceSentinelPath(path.resolve(root, filePath), root);
 }
 
-function walkWorkspace(root: string, directory: string, snapshot: Map<string, number>): void {
+function walkWorkspace(
+  root: string,
+  directory: string,
+  snapshot: Map<string, number>,
+  includeSourceFiles: boolean,
+): void {
   let entries: fs.Dirent[];
   try {
     entries = fs.readdirSync(directory, { withFileTypes: true });
@@ -80,14 +116,14 @@ function walkWorkspace(root: string, directory: string, snapshot: Map<string, nu
   for (const entry of entries) {
     if (entry.isDirectory()) {
       if (IGNORED_DIRECTORIES.has(entry.name)) continue;
-      walkWorkspace(root, path.join(directory, entry.name), snapshot);
+      walkWorkspace(root, path.join(directory, entry.name), snapshot, includeSourceFiles);
       continue;
     }
 
     if (!entry.isFile()) continue;
 
     const filePath = path.join(directory, entry.name);
-    if (!isWorkspaceSentinelPath(filePath, root)) continue;
+    if (!includeSourceFiles && !isWorkspaceSentinelPath(filePath, root)) continue;
     try {
       snapshot.set(filePath, fs.statSync(filePath).mtimeMs);
     } catch {

package/node_modules/@mrclrchtr/supi-lsp/src/manager/manager-client-state.ts

@@ -1,5 +1,16 @@
 import * as path from "node:path";
+import {
+  type CodeRequestControl,
+  isCodeRequestInterruption,
+} from "@mrclrchtr/supi-code-runtime/api";
 import type { LspClient } from "../client/client.ts";
+import { getDiagnosticFileState } from "../client/client-file-state.ts";
+import {
+  type DiagnosticEvidenceDocument,
+  type DiagnosticEvidenceSummary,
+  summarizeDiagnosticEvidence,
+} from "../diagnostics/evidence.ts";
+import { uriToFile } from "../utils.ts";
 
 export function closeFileAcrossClients(clients: Iterable<LspClient>, filePath: string): void {
   const resolvedPath = path.resolve(filePath);
@@ -21,14 +32,73 @@ export function pruneMissingFilesFromClients(clients: Iterable<LspClient>): stri
 
 export async function refreshOpenDiagnosticsForClients(
   clients: Iterable<LspClient>,
-  options?: { maxWaitMs?: number; quietMs?: number },
-): Promise<void> {
-  const refreshes = Array.from(clients)
-    .filter((client) => client.status === "running")
-    .map((client) =>
-      client.refreshOpenDiagnostics(options).catch(() => {
-        // Soft-fail: LSP errors must not prevent agent startup
-      }),
-    );
+  options?: { maxWaitMs?: number; quietMs?: number } & CodeRequestControl,
+): Promise<DiagnosticEvidenceSummary> {
+  const documents: DiagnosticEvidenceDocument[] = [];
+  const refreshes = Array.from(clients).map(async (client) => {
+    const trackedFiles = [...client.openFiles];
+    if (client.status !== "running") {
+      documents.push(...failedCoverageForClient(client, trackedFiles));
+      return;
+    }
+
+    try {
+      const result = await client.refreshOpenDiagnostics(options);
+      const reportedFiles = new Set(result.documents.map((document) => document.file));
+      documents.push(...result.documents);
+      documents.push(
+        ...trackedFiles
+          .filter((file) => !reportedFiles.has(file))
+          .map((file) => ({ file, status: "failed" as const })),
+      );
+    } catch (error) {
+      // A cancelled refresh must not degrade into failed coverage evidence.
+      if (isCodeRequestInterruption(error, options)) throw error;
+      // Keep failed coverage for every document requested by the client.
+      documents.push(...failedCoverageForClient(client, trackedFiles));
+    }
+  });
   await Promise.all(refreshes);
+  return summarizeDiagnosticEvidence(deduplicateEvidenceDocuments(documents));
+}
+
+function failedCoverageForClient(
+  client: LspClient,
+  trackedFiles: readonly string[],
+): DiagnosticEvidenceDocument[] {
+  const snapshot = client.getDiagnosticSnapshot();
+  const files = new Set([
+    ...trackedFiles,
+    ...snapshot.documents.map((document) => uriToFile(document.uri)),
+  ]);
+  return Array.from(files).map((file) => ({
+    file,
+    status: getDiagnosticFileState(file) === "removed" ? ("removed" as const) : ("failed" as const),
+  }));
+}
+
+function deduplicateEvidenceDocuments(
+  documents: readonly DiagnosticEvidenceDocument[],
+): DiagnosticEvidenceDocument[] {
+  const byFile = new Map<string, DiagnosticEvidenceDocument>();
+  for (const document of documents) {
+    const existing = byFile.get(document.file);
+    if (!existing || evidenceStatusRank(document.status) > evidenceStatusRank(existing.status)) {
+      byFile.set(document.file, document);
+    }
+  }
+  return Array.from(byFile.values()).sort((a, b) => a.file.localeCompare(b.file));
+}
+
+function evidenceStatusRank(status: DiagnosticEvidenceDocument["status"]): number {
+  switch (status) {
+    case "confirmed":
+      return 1;
+    case "unconfirmed":
+      return 2;
+    case "failed":
+      return 3;
+    case "removed":
+      return 4;
+  }
 }

package/node_modules/@mrclrchtr/supi-lsp/src/manager/manager-diagnostics.ts

@@ -1,5 +1,11 @@
 import { readFileSync } from "node:fs";
+import {
+  type CodeQueryResult,
+  type CodeRequestControl,
+  mapCodeQueryResult,
+} from "@mrclrchtr/supi-code-runtime/api";
 import type { LspClient } from "../client/client.ts";
+import type { DiagnosticEntry } from "../client/client-document-state.ts";
 import type { Diagnostic } from "../config/types.ts";
 import { relativeFilePathFromUri } from "../diagnostics/diagnostic-summary.ts";
 import { shouldIgnoreLspPath } from "../summary.ts";
@@ -10,23 +16,27 @@ export async function syncClientFileAndGetDiagnostics(
   client: Pick<LspClient, "syncAndWaitForDiagnostics">,
   filePath: string,
   maxSeverity: number,
-): Promise<Diagnostic[]> {
-  return filterDiagnosticsBySeverity(
-    await client.syncAndWaitForDiagnostics(filePath, readFileSync(filePath, "utf-8")),
-    maxSeverity,
+  control?: CodeRequestControl,
+): Promise<CodeQueryResult<Diagnostic[]>> {
+  const content = readFileSync(filePath, "utf-8");
+  const result = control
+    ? await client.syncAndWaitForDiagnostics(filePath, content, control)
+    : await client.syncAndWaitForDiagnostics(filePath, content);
+  return mapCodeQueryResult(result, (diagnostics) =>
+    filterDiagnosticsBySeverity(diagnostics, maxSeverity),
   );
 }
 
 export function collectOutstandingDiagnosticsDetailed(
-  clients: Iterable<Pick<LspClient, "getAllDiagnostics">>,
+  clientEntries: Iterable<ReadonlyArray<DiagnosticEntry>>,
   cwd: string,
   excludePatterns: string[],
   maxSeverity: number,
 ): Array<{ file: string; diagnostics: Diagnostic[] }> {
   const fileDiags = new Map<string, Diagnostic[]>();
 
-  for (const client of clients) {
-    for (const entry of client.getAllDiagnostics()) {
+  for (const entries of clientEntries) {
+    for (const entry of entries) {
       const file = relativeFilePathFromUri(entry.uri, cwd);
       if (shouldIgnoreLspPath(file, cwd)) continue;
       if (isExcludedByPattern(file, excludePatterns)) continue;