@mrclrchtr/supi-code-intelligence 6.0.1 → 6.2.0

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

@@ -7,7 +7,10 @@ import {
   type CodeRequestControl,
   CodeRequestDeadlineError,
 } from "@mrclrchtr/supi-code-runtime/api";
-import { startDebugTimer } from "@mrclrchtr/supi-core/debug";
+import {
+  startDebugTimer,
+  truncateDebugIdentity as truncateIdentity,
+} from "@mrclrchtr/supi-core/debug";
 import {
   CancellationTokenSource,
   createMessageConnection,
@@ -18,7 +21,7 @@ import {
   StreamMessageReader,
   StreamMessageWriter,
 } from "vscode-jsonrpc/node";
-import { boundCwd, LSP_REQUEST_TIMEOUT_ERROR_CODE, truncateIdentity } from "../debug-telemetry.ts";
+import { boundCwd, LSP_REQUEST_TIMEOUT_ERROR_CODE } from "../debug-telemetry.ts";
 
 const DEFAULT_TIMEOUT_MS = 30_000;
 
@@ -112,34 +115,40 @@ export class JsonRpcClient {
     const methodClass = classifyRequestMethod(method);
     const boundedMethod = truncateIdentity(method);
     const timer = startDebugTimer();
+    // A request cancelled before dispatch must not produce protocol traffic.
+    if (signal?.aborted) {
+      return rejectUndispatchedRequest(
+        signal.reason ?? new Error(`Request ${method} was cancelled`),
+        {
+          timer,
+          operationId: options?.operationId,
+          observation: { method: boundedMethod, methodClass, outcome: "cancelled" },
+          identity: { server: this.server, cwd: this.cwd },
+        },
+      );
+    }
     // An expired absolute deadline must not even send the request: the caller
     // no longer awaits a result, so no protocol traffic may start.
     if (deadlineMs !== undefined && deadlineMs <= 0) {
-      recordRequestTiming(
+      return rejectUndispatchedRequest(new CodeRequestDeadlineError(), {
         timer,
-        options?.operationId,
-        {
+        operationId: options?.operationId,
+        observation: {
           method: boundedMethod,
           methodClass,
           outcome: "timed-out",
           errorCode: LSP_REQUEST_TIMEOUT_ERROR_CODE,
         },
-        { server: this.server, cwd: this.cwd },
-      );
-      return Promise.reject(new CodeRequestDeadlineError());
+        identity: { server: this.server, cwd: this.cwd },
+      });
     }
     if (this.closed || !this.connection) {
-      recordRequestTiming(
+      return rejectUndispatchedRequest(new Error("JSON-RPC client is closed"), {
         timer,
-        options?.operationId,
-        {
-          method: boundedMethod,
-          methodClass,
-          outcome: "cancelled",
-        },
-        { server: this.server, cwd: this.cwd },
-      );
-      return Promise.reject(new Error("JSON-RPC client is closed"));
+        operationId: options?.operationId,
+        observation: { method: boundedMethod, methodClass, outcome: "cancelled" },
+        identity: { server: this.server, cwd: this.cwd },
+      });
     }
     const tokenSource = new CancellationTokenSource();
     let timeout: ReturnType<typeof setTimeout> | undefined;
@@ -344,6 +353,19 @@ function jsonRpcErrorCode(error: unknown): number | undefined {
   return typeof code === "number" && Number.isInteger(code) ? code : undefined;
 }
 
+function rejectUndispatchedRequest(
+  error: unknown,
+  timing: {
+    timer: ReturnType<typeof startDebugTimer>;
+    operationId: string | undefined;
+    observation: RequestTimingObservation;
+    identity: { server?: string; cwd?: string };
+  },
+): Promise<never> {
+  recordRequestTiming(timing.timer, timing.operationId, timing.observation, timing.identity);
+  return Promise.reject(error);
+}
+
 function recordRequestTiming(
   timer: ReturnType<typeof startDebugTimer>,
   operationId: string | undefined,

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

@@ -4,6 +4,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
 import { loadSupiConfigForScope } from "@mrclrchtr/supi-core/config";
+import { truncateDebugIdentity } from "@mrclrchtr/supi-core/debug";
 import type { LspConfig, ServerConfig } from "./types.ts";
 
 const CONFIG_DIR = path.dirname(fileURLToPath(import.meta.url));
@@ -24,17 +25,16 @@ export const LANGUAGE_ALIASES: Record<string, string> = {
   cpp: "c",
 };
 
-/** Resolve a language name through aliases. */
-export function resolveLanguageAlias(name: string): string {
-  return LANGUAGE_ALIASES[name] ?? name;
-}
-
-function resolveAliasesInOverrides(servers: Record<string, Partial<ServerConfig>>): void {
+function resolveAliasesInOverrides(servers: Record<string, unknown>): void {
   for (const [alias, target] of Object.entries(LANGUAGE_ALIASES)) {
-    if (servers[alias]) {
-      servers[target] = { ...(servers[target] ?? {}), ...servers[alias] };
-      delete servers[alias];
-    }
+    if (!Object.hasOwn(servers, alias)) continue;
+    const aliasOverride = servers[alias];
+    const targetOverride = servers[target];
+    servers[target] =
+      isRecord(aliasOverride) && isRecord(targetOverride)
+        ? { ...targetOverride, ...aliasOverride }
+        : aliasOverride;
+    delete servers[alias];
   }
 }
 
@@ -49,13 +49,13 @@ export function loadConfig(cwd: string, options?: LoadConfigOptions): LspConfig
   const globalLsp = loadSupiConfigForScope(
     "lsp",
     cwd,
-    { enabled: true, active: [], servers: {} as Record<string, ServerConfig> },
+    { servers: {} as Record<string, ServerConfig> },
     { scope: "global", homeDir: options?.homeDir },
   );
   const projectLsp = loadSupiConfigForScope(
     "lsp",
     cwd,
-    { enabled: true, active: [], servers: {} as Record<string, ServerConfig> },
+    { servers: {} as Record<string, ServerConfig> },
     { scope: "project" },
   );
 
@@ -91,6 +91,13 @@ function mergeServerConfigs(
   projectOverrides: unknown,
 ): Record<string, ServerConfig> {
   const merged: Record<string, ServerConfig> = { ...defaults };
+  const warnings = new Map<string, { fields: Set<string>; skipped: boolean }>();
+  const reportWarning: ServerConfigWarningReporter = (name, fields, skipped) => {
+    const warning = warnings.get(name) ?? { fields: new Set<string>(), skipped: false };
+    for (const field of fields) warning.fields.add(field);
+    warning.skipped ||= skipped;
+    warnings.set(name, warning);
+  };
 
   const globalServers = isServerRecord(globalOverrides) ? globalOverrides : {};
   const projectServers = isServerRecord(projectOverrides) ? projectOverrides : {};
@@ -100,14 +107,29 @@ function mergeServerConfigs(
 
   // Apply global per-key overrides against defaults
   for (const [lang, override] of Object.entries(globalServers)) {
-    const result = mergeSingleServer(defaults[lang], override);
+    const builtIn = defaults[lang] !== undefined;
+    const result = mergeSingleServer({
+      name: lang,
+      base: defaults[lang],
+      value: override,
+      builtIn,
+      reportWarning,
+    });
     if (result) merged[lang] = result;
   }
 
   // Apply project per-key overrides against the result so far
   for (const [lang, override] of Object.entries(projectServers)) {
-    const result = mergeSingleServer(merged[lang] ?? defaults[lang], override);
+    const builtIn = defaults[lang] !== undefined;
+    const result = mergeSingleServer({
+      name: lang,
+      base: merged[lang] ?? defaults[lang],
+      value: override,
+      builtIn,
+      reportWarning,
+    });
     if (result) merged[lang] = result;
+    else if (!builtIn) delete merged[lang];
   }
 
   // Remove servers whose final merged config has enabled === false
@@ -117,29 +139,141 @@ function mergeServerConfigs(
     }
   }
 
+  for (const [name, warning] of warnings) {
+    warnInvalidServerConfig(name, [...warning.fields], warning.skipped);
+  }
   return merged;
 }
 
-function mergeSingleServer(
-  base: ServerConfig | undefined,
-  override: Partial<ServerConfig>,
-): ServerConfig | null {
-  if (!base) {
-    // A custom server needs a command and at least one file extension.
-    if (
-      typeof override.command === "string" &&
-      override.command.length > 0 &&
-      Array.isArray(override.fileTypes) &&
-      override.fileTypes.length > 0 &&
-      (override.rootMarkers === undefined || Array.isArray(override.rootMarkers))
-    ) {
-      return { ...override, rootMarkers: override.rootMarkers ?? [] } as ServerConfig;
-    }
+type ServerConfigWarningReporter = (
+  name: string,
+  fields: readonly string[],
+  skipped: boolean,
+) => void;
+
+function mergeSingleServer(options: {
+  name: string;
+  base: ServerConfig | undefined;
+  value: unknown;
+  builtIn: boolean;
+  reportWarning: ServerConfigWarningReporter;
+}): ServerConfig | null {
+  const { name, base, value, builtIn, reportWarning } = options;
+  const { override, invalidFields } = validateServerOverride(value);
+  const missingFields = base
+    ? []
+    : [
+        ...(typeof override.command === "string" ? [] : ["command"]),
+        ...(override.fileTypes && override.fileTypes.length > 0 ? [] : ["fileTypes"]),
+      ];
+  const issues = [...new Set([...invalidFields, ...missingFields])];
+  if ((!builtIn && invalidFields.length > 0) || (!base && issues.length > 0)) {
+    reportWarning(name, issues, true);
     return null;
   }
+  if (!base) {
+    return {
+      ...override,
+      command: override.command as string,
+      fileTypes: override.fileTypes as string[],
+      rootMarkers: override.rootMarkers ?? [],
+    };
+  }
+
+  if (invalidFields.length > 0) reportWarning(name, invalidFields, false);
   return { ...base, ...override };
 }
 
-function isServerRecord(value: unknown): value is Record<string, Partial<ServerConfig>> {
+type ServerOverrideSetter = (override: Partial<ServerConfig>, candidate: unknown) => boolean;
+
+const SERVER_OVERRIDE_SETTERS: Record<string, ServerOverrideSetter> = {
+  command(override, candidate) {
+    if (typeof candidate !== "string" || candidate.trim().length === 0) return false;
+    override.command = candidate;
+    return true;
+  },
+  args(override, candidate) {
+    if (!isStringArray(candidate)) return false;
+    override.args = candidate;
+    return true;
+  },
+  fileTypes(override, candidate) {
+    if (!isNonEmptyStringArray(candidate)) return false;
+    override.fileTypes = candidate;
+    return true;
+  },
+  rootMarkers(override, candidate) {
+    if (!isStringArray(candidate)) return false;
+    override.rootMarkers = candidate;
+    return true;
+  },
+  enabled(override, candidate) {
+    if (typeof candidate !== "boolean") return false;
+    override.enabled = candidate;
+    return true;
+  },
+  env(override, candidate) {
+    if (!isStringRecord(candidate)) return false;
+    override.env = candidate;
+    return true;
+  },
+  initializationOptions(override, candidate) {
+    override.initializationOptions = candidate;
+    return true;
+  },
+  readinessTimeoutMs(override, candidate) {
+    if (typeof candidate !== "number" || !Number.isFinite(candidate) || candidate <= 0) {
+      return false;
+    }
+    override.readinessTimeoutMs = candidate;
+    return true;
+  },
+};
+
+function validateServerOverride(value: unknown): {
+  override: Partial<ServerConfig>;
+  invalidFields: string[];
+} {
+  if (!isRecord(value)) return { override: {}, invalidFields: ["definition"] };
+  const override: Partial<ServerConfig> = {};
+  const invalidFields: string[] = [];
+
+  for (const [field, candidate] of Object.entries(value)) {
+    const setter = SERVER_OVERRIDE_SETTERS[field];
+    if (!setter?.(override, candidate)) invalidFields.push(field);
+  }
+
+  return { override, invalidFields };
+}
+
+function isStringArray(value: unknown): value is string[] {
+  return Array.isArray(value) && value.every((entry) => typeof entry === "string");
+}
+
+function isNonEmptyStringArray(value: unknown): value is string[] {
+  return (
+    Array.isArray(value) &&
+    value.length > 0 &&
+    value.every((entry) => typeof entry === "string" && entry.length > 0)
+  );
+}
+
+function isStringRecord(value: unknown): value is Record<string, string> {
+  return isRecord(value) && Object.values(value).every((entry) => typeof entry === "string");
+}
+
+function warnInvalidServerConfig(name: string, fields: readonly string[], skipped: boolean): void {
+  const boundedName = truncateDebugIdentity(name);
+  const boundedFields = truncateDebugIdentity(fields.join(", "));
+  const action = skipped ? "Skipped invalid" : "Ignored invalid fields in";
+  // biome-ignore lint/suspicious/noConsole: malformed user configuration must be visible.
+  console.warn(`[supi-lsp] ${action} LSP server configuration "${boundedName}": ${boundedFields}`);
+}
+
+function isServerRecord(value: unknown): value is Record<string, unknown> {
+  return isRecord(value);
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }

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

@@ -1,100 +1,22 @@
-// LSP settings helpers — config loading for LSP session lifecycle.
-//
-// These are the non-UI config helpers extracted from settings-registration.ts
-// so they can be consumed by the library-only runtime controller without
-// importing pi-specific UI modules.
+// LSP settings used by workspace lifecycle and automatic path policy.
 
-import { loadSupiConfig, loadSupiConfigForScope } from "@mrclrchtr/supi-core/config";
+import { loadSupiConfig } from "@mrclrchtr/supi-core/config";
 
-// ── Types ────────────────────────────────────────────────────
-
-export interface LspSettings extends Record<string, unknown> {
-  enabled: boolean;
-  active: string[];
+/** Effective non-server LSP settings. */
+export interface LspSettings {
   exclude: string[];
 }
 
 export const LSP_DEFAULTS: LspSettings = {
-  enabled: true,
-  active: [],
   exclude: [],
 };
 
-// ── Config helpers ───────────────────────────────────────────
-
-/**
- * Load LSP settings from supi config for the given cwd.
- *
- * Merges project and global scopes with defaults, returning the
- * effective LspSettings for session startup.
- */
+/** Load effective LSP settings for one workspace. */
 export function loadLspSettings(cwd: string, homeDir?: string): LspSettings {
-  return loadSupiConfig("lsp", cwd, LSP_DEFAULTS, { homeDir });
-}
-
-/**
- * Return a user-facing message explaining why LSP may appear disabled.
- *
- * **Since the always-on policy:** `lsp.enabled: false` is deprecated and
- * ignored. This function is kept for backward compatibility with the
- * settings UI and reports that LSP is always attempted.
- */
-export function getLspDisabledMessage(cwd: string, homeDir?: string): string {
-  const global = loadSupiConfigForScope("lsp", cwd, LSP_DEFAULTS, { scope: "global", homeDir });
-  const project = loadSupiConfigForScope("lsp", cwd, LSP_DEFAULTS, { scope: "project", homeDir });
-
-  if (project.enabled === false) {
-    return "LSP is always attempted; `lsp.enabled: false` in project settings (.pi/supi/config.json) is deprecated and ignored";
-  }
-  if (global.enabled === false) {
-    return "LSP is always attempted; `lsp.enabled: false` in global settings (~/.pi/agent/supi/config.json) is deprecated and ignored";
-  }
-  return "LSP is always attempted";
-}
-
-// ── Deprecated-key detection (always-on policy) ────────────────
-
-/**
- * Result of checking for deprecated LSP configuration keys.
- */
-export interface DeprecatedLspKeys {
-  /** `lsp.enabled` presence in project config. */
-  projectEnabled: boolean;
-  /** `lsp.enabled` presence in global config. */
-  globalEnabled: boolean;
-  /** `lsp.active` presence in project config. */
-  projectActive: boolean;
-  /** `lsp.active` presence in global config. */
-  globalActive: boolean;
-}
-
-/**
- * Check whether deprecated `lsp.enabled` or `lsp.active` keys exist
- * in project or global config. These keys are ignored by the always-on
- * LSP policy but may be present in user config.
- */
-export function getDeprecatedLspKeys(cwd: string, homeDir?: string): DeprecatedLspKeys {
-  const global = loadSupiConfigForScope("lsp", cwd, LSP_DEFAULTS, { scope: "global", homeDir });
-  const project = loadSupiConfigForScope("lsp", cwd, LSP_DEFAULTS, { scope: "project", homeDir });
-
+  const loaded = loadSupiConfig("lsp", cwd, LSP_DEFAULTS, { homeDir });
   return {
-    projectEnabled: hasExplicitEnabledKey(project),
-    globalEnabled: hasExplicitEnabledKey(global),
-    projectActive: hasExplicitActiveKey(project),
-    globalActive: hasExplicitActiveKey(global),
+    exclude: Array.isArray(loaded.exclude)
+      ? loaded.exclude.filter((entry): entry is string => typeof entry === "string")
+      : [],
   };
 }
-
-/** Whether the loaded settings had an explicit `enabled` key (different from default). */
-function hasExplicitEnabledKey(settings: Partial<{ enabled: boolean }>): boolean {
-  return settings.enabled === false;
-}
-
-/** Whether the loaded settings had an explicit `active` key. */
-function hasExplicitActiveKey(settings: Partial<{ active: string[] }>): boolean {
-  return Array.isArray(settings.active) && settings.active.length > 0;
-}
-
-// Alias for backwards compatibility with the RED test name
-/** @deprecated Use {@link getDeprecatedLspKeys} instead. */
-export const hasDeprecatedLspKeys: typeof getDeprecatedLspKeys = getDeprecatedLspKeys;

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

@@ -26,9 +26,16 @@ export interface DetectedProjectServer {
   fileTypes: string[];
 }
 
+/** Structured reason for a route-level process-crash recovery state. */
+export type ProjectServerStatusReason =
+  | "process-crashed"
+  | "process-crash-recovery-pending"
+  | "process-crash-recovery-exhausted";
+
 export interface ProjectServerInfo extends DetectedProjectServer {
   status: "running" | "error" | "unavailable";
-  supportedActions: string[];
+  /** Structured lifecycle reason when process-crash recovery is active. */
+  statusReason?: ProjectServerStatusReason;
   openFiles: string[];
   /** Whether the LSP server is currently not indexing and ready to serve queries. */
   ready: boolean;

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

@@ -379,15 +379,14 @@ export function invalidateTsconfigCacheForConfig(configPath: string): void {
 }
 
 /**
- * Invalidate nearest-config lookups that found nothing under `dir`.
+ * Invalidate nearest-config lookups under a directory that gained a config.
  *
- * Used when a config is created: directories below the new config that
- * previously resolved to no config may now resolve to it.
+ * A new config can replace either a no-config result or a cached lower-priority
+ * config, such as `jsconfig.json` when `tsconfig.json` is created.
  */
 export function invalidateTsconfigCacheForConfigDir(dir: string): void {
   const normalizedDir = normalizePath(dir);
-  for (const [key, value] of nearestConfigCache) {
-    if (value !== null) continue;
+  for (const key of nearestConfigCache.keys()) {
     const keyDir = key.split("::", 1)[0];
     if (keyDir === normalizedDir || keyDir.startsWith(`${normalizedDir}/`)) {
       nearestConfigCache.delete(key);

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

@@ -49,40 +49,12 @@ export {
   WorkspaceSymbol,
 } from "vscode-languageserver-types";
 
-// Alias for backward compatibility — our code uses ClientDiagnosticCapabilities
-import type { DiagnosticClientCapabilities } from "vscode-languageserver-protocol";
-export type ClientDiagnosticCapabilities = DiagnosticClientCapabilities;
-
-// ── JSON-RPC types (local — replaced by vscode-jsonrpc in transport task) ──
-export type JsonRpcId = number | string;
-
-export interface JsonRpcRequest {
-  jsonrpc: "2.0";
-  id: JsonRpcId;
-  method: string;
-  params?: unknown;
-}
-
-export interface JsonRpcResponse {
-  jsonrpc: "2.0";
-  id: JsonRpcId | null;
-  result?: unknown;
-  error?: { code: number; message: string; data?: unknown };
-}
-
-export interface JsonRpcNotification {
-  jsonrpc: "2.0";
-  method: string;
-  params?: unknown;
-}
-
-export type JsonRpcMessage = JsonRpcRequest | JsonRpcResponse | JsonRpcNotification;
-
 // ── SuPi-specific server config ──────────────────────────────────────
 export type {
   DetectedProjectServer,
   LspConfig,
   MissingServer,
   ProjectServerInfo,
+  ProjectServerStatusReason,
   ServerConfig,
 } from "./server-config.ts";

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

@@ -1,19 +1,14 @@
 // 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.
+// LSP debug events can include server, workspace, file, method, and root
+// identity for local protocol diagnosis. Each identity string and list uses
+// the shared bounds.
+
+import { truncateDebugIdentity } from "@mrclrchtr/supi-core/debug";
 
 /** 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.
  *
@@ -24,22 +19,13 @@ export const IDENTITY_TRUNCATION_MARKER = "…";
  */
 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);
+  return truncateDebugIdentity(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);
+  return names.slice(0, MAX_SERVERS).map(truncateDebugIdentity);
 }

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

@@ -0,0 +1,6 @@
+import { type Diagnostic, DiagnosticSeverity } from "../config/types.ts";
+
+/** Return Error when a diagnostic omits the optional LSP severity. */
+export function effectiveDiagnosticSeverity(diagnostic: Diagnostic): DiagnosticSeverity {
+  return diagnostic.severity ?? DiagnosticSeverity.Error;
+}

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

@@ -1,23 +1,23 @@
+import { uriToFile } from "@mrclrchtr/supi-core/path";
 import { type Diagnostic, DiagnosticSeverity } from "../config/types.ts";
 import type { OutstandingDiagnosticSummaryEntry } from "../manager/manager-types.ts";
-import { isGlobMatch } from "../pattern-matcher.ts";
-import { displayRelativeFilePath, shouldIgnoreLspPath } from "../summary.ts";
-import { uriToFile } from "../utils.ts";
+import { displayRelativeFilePath } from "../summary.ts";
+import { effectiveDiagnosticSeverity } from "./diagnostic-severity.ts";
 
 export function collectDiagnosticSummaryCounts(
   fileDiags: Map<string, { errors: number; warnings: number }>,
   entry: { uri: string; diagnostics: Diagnostic[] },
   cwd: string,
-  excludePatterns?: string[],
+  includeFile: (file: string) => boolean,
 ): void {
   const file = relativeFilePathFromUri(entry.uri, cwd);
-  if (shouldIgnoreLspPath(file, cwd)) return;
-  if (excludePatterns?.some((p) => isGlobMatch(file, p))) return;
+  if (!includeFile(file)) return;
 
   const current = fileDiags.get(file) ?? { errors: 0, warnings: 0 };
   for (const diagnostic of entry.diagnostics) {
-    if (diagnostic.severity === DiagnosticSeverity.Error) current.errors++;
-    else if (diagnostic.severity === DiagnosticSeverity.Warning) current.warnings++;
+    const severity = effectiveDiagnosticSeverity(diagnostic);
+    if (severity === DiagnosticSeverity.Error) current.errors++;
+    else if (severity === DiagnosticSeverity.Warning) current.warnings++;
   }
   fileDiags.set(file, current);
 }
@@ -46,7 +46,7 @@ export function accumulateOutstandingDiagnostics(
     if (!isDiagnosticWithinThreshold(diagnostic, maxSeverity)) continue;
 
     next.total++;
-    incrementOutstandingDiagnosticCount(next, diagnostic.severity);
+    incrementOutstandingDiagnosticCount(next, effectiveDiagnosticSeverity(diagnostic));
   }
 
   return next;
@@ -56,11 +56,8 @@ export function relativeFilePathFromUri(uri: string, cwd: string): string {
   return displayRelativeFilePath(uriToFile(uri), cwd);
 }
 
-function isDiagnosticWithinThreshold(
-  diagnostic: Diagnostic,
-  maxSeverity: number,
-): diagnostic is Diagnostic & { severity: number } {
-  return diagnostic.severity !== undefined && diagnostic.severity <= maxSeverity;
+function isDiagnosticWithinThreshold(diagnostic: Diagnostic, maxSeverity: number): boolean {
+  return effectiveDiagnosticSeverity(diagnostic) <= maxSeverity;
 }
 
 function incrementOutstandingDiagnosticCount(

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

@@ -35,8 +35,3 @@ export function summarizeDiagnosticEvidence(
   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([]);
-}