@mrclrchtr/supi-code-intelligence 6.1.0 → 6.3.0

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

@@ -36,7 +36,6 @@ export interface ProjectServerInfo extends DetectedProjectServer {
   status: "running" | "error" | "unavailable";
   /** Structured lifecycle reason when process-crash recovery is active. */
   statusReason?: ProjectServerStatusReason;
-  supportedActions: string[];
   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,35 +49,6 @@ 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,

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([]);
-}

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

@@ -32,7 +32,6 @@ export function assessStaleDiagnostics(
 }
 
 export function isLikelyStaleDiagnostic(diagnostic: Diagnostic): boolean {
-  if (diagnostic.severity === undefined) return false;
   if (diagnostic.code !== undefined) {
     if (typeof diagnostic.code === "number" && MODULE_RESOLUTION_CODES.has(diagnostic.code)) {
       return true;

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

@@ -1,9 +1,13 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { fileToUri, uriToFile } from "@mrclrchtr/supi-core/path";
 import { FileChangeType, type FileEvent } from "../config/types.ts";
-import { fileToUri, uriToFile } from "../utils.ts";
+import {
+  type AutomaticLspPathPolicy,
+  createDefaultAutomaticLspPathPolicy,
+  walkAutomaticLspTree,
+} from "../workspace-path-policy.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 {
@@ -13,6 +17,8 @@ export interface WorkspaceSentinelScanOptions {
    * the diff then reports them as `sourceChanges` so the caller can pull them.
    */
   includeSourceFiles?: boolean;
+  /** Runtime-owned automatic path policy. */
+  policy?: AutomaticLspPathPolicy;
 }
 
 /** Build a fresh snapshot of workspace sentinel files and their mtimes. */
@@ -25,11 +31,19 @@ export function scanWorkspaceSentinels(
 
   if (!fs.existsSync(resolvedCwd)) return snapshot;
 
-  try {
-    walkWorkspace(resolvedCwd, resolvedCwd, snapshot, options.includeSourceFiles ?? false);
-  } catch {
-    return snapshot;
-  }
+  const policy = options.policy ?? createDefaultAutomaticLspPathPolicy(resolvedCwd);
+  walkAutomaticLspTree(policy, resolvedCwd, Number.MAX_SAFE_INTEGER, (directory, entries) => {
+    for (const entry of entries) {
+      if (!entry.isFile() && !entry.isSymbolicLink()) continue;
+      const filePath = path.join(directory, entry.name);
+      if (!options.includeSourceFiles && !isWorkspaceSentinelPath(filePath, resolvedCwd)) continue;
+      try {
+        snapshot.set(filePath, fs.statSync(filePath).mtimeMs);
+      } catch {
+        // File deleted between readdir and stat — skip.
+      }
+    }
+  });
 
   return snapshot;
 }
@@ -60,6 +74,13 @@ export function diffWorkspaceSentinelSnapshot(
   return changes.sort((a, b) => a.uri.localeCompare(b.uri));
 }
 
+/** One policy-filtered workspace inventory refresh. */
+export interface WorkspaceSentinelSyncResult {
+  snapshot: Map<string, number>;
+  changes: FileEvent[];
+  sourceChanges: FileEvent[];
+}
+
 /**
  * Refresh a previous snapshot and return the new snapshot plus change events.
  *
@@ -72,7 +93,7 @@ export function syncWorkspaceSentinelSnapshot(
   cwd: string,
   previous: Map<string, number>,
   options: WorkspaceSentinelScanOptions = {},
-): { snapshot: Map<string, number>; changes: FileEvent[]; sourceChanges: FileEvent[] } {
+): WorkspaceSentinelSyncResult {
   const snapshot = scanWorkspaceSentinels(cwd, options);
   const changes = diffWorkspaceSentinelSnapshot(previous, snapshot);
   if (!options.includeSourceFiles) return { snapshot, changes, sourceChanges: [] };
@@ -91,47 +112,6 @@ export function syncWorkspaceSentinelSnapshot(
   };
 }
 
-/** Determine whether a file path should trigger workspace recovery. */
-export function isWorkspaceRecoveryTrigger(filePath: string, cwd: string): boolean {
-  const root = path.resolve(cwd);
-  return isWorkspaceSentinelPath(path.resolve(root, filePath), root);
-}
-
-function walkWorkspace(
-  root: string,
-  directory: string,
-  snapshot: Map<string, number>,
-  includeSourceFiles: boolean,
-): void {
-  let entries: fs.Dirent[];
-  try {
-    entries = fs.readdirSync(directory, { withFileTypes: true });
-  } catch {
-    // Permission error or deleted directory — skip it rather than
-    // failing the entire scan. A partial snapshot still detects
-    // changes in accessible subtrees.
-    return;
-  }
-
-  for (const entry of entries) {
-    if (entry.isDirectory()) {
-      if (IGNORED_DIRECTORIES.has(entry.name)) continue;
-      walkWorkspace(root, path.join(directory, entry.name), snapshot, includeSourceFiles);
-      continue;
-    }
-
-    if (!entry.isFile()) continue;
-
-    const filePath = path.join(directory, entry.name);
-    if (!includeSourceFiles && !isWorkspaceSentinelPath(filePath, root)) continue;
-    try {
-      snapshot.set(filePath, fs.statSync(filePath).mtimeMs);
-    } catch {
-      // File deleted between readdir and stat — skip.
-    }
-  }
-}
-
 function isWorkspaceSentinelPath(filePath: string, root: string): boolean {
   const name = path.basename(filePath);
 

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

@@ -3,6 +3,7 @@ import {
   type CodeRequestControl,
   isCodeRequestInterruption,
 } from "@mrclrchtr/supi-code-runtime/api";
+import { uriToFile } from "@mrclrchtr/supi-core/path";
 import type { LspClient } from "../client/client.ts";
 import { getDiagnosticFileState } from "../client/client-file-state.ts";
 import {
@@ -10,7 +11,6 @@ import {
   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);

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

@@ -7,9 +7,8 @@ import {
 import type { LspClient } from "../client/client.ts";
 import type { DiagnosticEntry } from "../client/client-document-state.ts";
 import type { Diagnostic } from "../config/types.ts";
+import { effectiveDiagnosticSeverity } from "../diagnostics/diagnostic-severity.ts";
 import { relativeFilePathFromUri } from "../diagnostics/diagnostic-summary.ts";
-import { shouldIgnoreLspPath } from "../summary.ts";
-import { isExcludedByPattern } from "./manager-helpers.ts";
 
 /** Sync one file and return diagnostics up to the supplied severity threshold. */
 export async function syncClientFileAndGetDiagnostics(
@@ -30,7 +29,7 @@ export async function syncClientFileAndGetDiagnostics(
 export function collectOutstandingDiagnosticsDetailed(
   clientEntries: Iterable<ReadonlyArray<DiagnosticEntry>>,
   cwd: string,
-  excludePatterns: string[],
+  includeFile: (file: string) => boolean,
   maxSeverity: number,
 ): Array<{ file: string; diagnostics: Diagnostic[] }> {
   const fileDiags = new Map<string, Diagnostic[]>();
@@ -38,8 +37,7 @@ export function collectOutstandingDiagnosticsDetailed(
   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;
+      if (!includeFile(file)) continue;
       const filtered = filterDiagnosticsBySeverity(entry.diagnostics, maxSeverity);
       if (filtered.length === 0) continue;
       const existing = fileDiags.get(file) ?? [];
@@ -53,7 +51,5 @@ export function collectOutstandingDiagnosticsDetailed(
 }
 
 function filterDiagnosticsBySeverity(diagnostics: Diagnostic[], maxSeverity: number): Diagnostic[] {
-  return diagnostics.filter(
-    (diagnostic) => diagnostic.severity !== undefined && diagnostic.severity <= maxSeverity,
-  );
+  return diagnostics.filter((diagnostic) => effectiveDiagnosticSeverity(diagnostic) <= maxSeverity);
 }

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

@@ -1,7 +1,6 @@
 import * as path from "node:path";
+import { resolveToolPath as resolveSessionPath } from "@mrclrchtr/supi-core/path";
 import * as projectRoots from "@mrclrchtr/supi-core/project";
-import { isGlobMatch } from "../pattern-matcher.ts";
-import { resolveSessionPath } from "../utils.ts";
 
 /** Unique key for a client identified by server name and root. */
 export function clientKey(serverName: string, root: string): string {
@@ -32,10 +31,3 @@ export function rememberKnownRoot(
   const roots = knownRoots.get(serverName) ?? [];
   knownRoots.set(serverName, projectRoots.mergeKnownRoots(roots, root));
 }
-
-/** Check if a file path matches any user-configured exclude pattern. */
-export function isExcludedByPattern(file: string, excludePatterns: string[]): boolean {
-  return (
-    excludePatterns.length > 0 && excludePatterns.some((pattern) => isGlobMatch(file, pattern))
-  );
-}

package/node_modules/@mrclrchtr/supi-lsp/src/manager/manager-process-crash-report.ts

@@ -0,0 +1,106 @@
+import * as path from "node:path";
+import {
+  MAX_PROCESS_CRASH_RECOVERY_ENTRIES,
+  type ProcessCrashRecoveryEntry,
+  type ProcessCrashRecoveryNextAction,
+  type ProcessCrashRecoveryOutcome,
+  type ProcessCrashRecoveryReport,
+} from "../session/runtime-diagnostics.ts";
+
+/** One route result before its root is projected to a workspace-relative path. */
+export interface ProcessCrashRecoveryRouteResult {
+  readonly name: string;
+  readonly root: string;
+  readonly outcome: ProcessCrashRecoveryOutcome;
+  /** The caught Error.message from a failed replacement, when available. */
+  readonly failureMessage?: string;
+}
+
+/** Maximum failure detail retained in a process-crash report. */
+export const MAX_PROCESS_CRASH_FAILURE_MESSAGE_LENGTH = 512;
+
+const OUTCOME_ORDER: Record<ProcessCrashRecoveryOutcome, number> = {
+  "recovery-failed": 0,
+  "recovery-exhausted": 1,
+  "skipped-no-retained-file": 2,
+  recovered: 3,
+};
+
+/** Build the bounded, deterministic report for one process-crash demand. */
+export function buildProcessCrashRecoveryReport(
+  routes: readonly ProcessCrashRecoveryRouteResult[],
+  cwd: string,
+): ProcessCrashRecoveryReport {
+  const entries = routes.map((route) => toReportEntry(route, cwd)).sort(compareEntries);
+  const visibleEntries = entries.slice(0, MAX_PROCESS_CRASH_RECOVERY_ENTRIES);
+
+  return {
+    recoveredRoutes: countRoutes(routes, "recovered"),
+    skippedRoutes: countRoutes(routes, "skipped-no-retained-file"),
+    failedRoutes: countRoutes(routes, "recovery-failed"),
+    exhaustedRoutes: countRoutes(routes, "recovery-exhausted"),
+    entries: visibleEntries,
+    omittedEntries: Math.max(0, entries.length - visibleEntries.length),
+  };
+}
+
+/** Limit one caught Error.message without retaining other error fields. */
+export function boundProcessCrashFailureMessage(message: string): string {
+  if (message.length <= MAX_PROCESS_CRASH_FAILURE_MESSAGE_LENGTH) return message;
+  return `${message.slice(0, MAX_PROCESS_CRASH_FAILURE_MESSAGE_LENGTH - 1)}…`;
+}
+
+function toReportEntry(
+  route: ProcessCrashRecoveryRouteResult,
+  cwd: string,
+): ProcessCrashRecoveryEntry {
+  const action = nextAction(route.outcome);
+  const entry: ProcessCrashRecoveryEntry = {
+    name: route.name,
+    root: relativeRoot(cwd, route.root),
+    outcome: route.outcome,
+    ...(action ? { nextAction: action } : {}),
+    ...(route.outcome === "recovery-failed" && route.failureMessage
+      ? { failureMessage: boundProcessCrashFailureMessage(route.failureMessage) }
+      : {}),
+  };
+  return entry;
+}
+
+function relativeRoot(cwd: string, root: string): string {
+  return (path.relative(path.resolve(cwd), path.resolve(cwd, root)) || ".").replaceAll("\\", "/");
+}
+
+function nextAction(outcome: ProcessCrashRecoveryOutcome): ProcessCrashRecoveryNextAction | null {
+  switch (outcome) {
+    case "skipped-no-retained-file":
+      return "use-exact-file";
+    case "recovery-failed":
+    case "recovery-exhausted":
+      return "reload-workspace";
+    case "recovered":
+      return null;
+  }
+}
+
+function compareEntries(
+  first: ProcessCrashRecoveryEntry,
+  second: ProcessCrashRecoveryEntry,
+): number {
+  return (
+    OUTCOME_ORDER[first.outcome] - OUTCOME_ORDER[second.outcome] ||
+    compareStrings(first.root, second.root) ||
+    compareStrings(first.name, second.name)
+  );
+}
+
+function compareStrings(first: string, second: string): number {
+  return first < second ? -1 : first > second ? 1 : 0;
+}
+
+function countRoutes(
+  routes: readonly ProcessCrashRecoveryRouteResult[],
+  outcome: ProcessCrashRecoveryOutcome,
+): number {
+  return routes.filter((route) => route.outcome === outcome).length;
+}

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

@@ -1,5 +1,4 @@
 import type { LspClient } from "../client/client.ts";
-import { getSupportedLspServerActions } from "../config/server-actions.ts";
 import type { ProjectServerInfo, ProjectServerStatusReason } from "../config/server-config.ts";
 import { displayRelativeFilePath } from "../summary.ts";
 
@@ -10,6 +9,8 @@ interface ProjectServerInfoInput {
   client: LspClient | undefined;
   unavailableReason?: "missing-command" | "start-failed" | "runtime-error";
   statusReason?: ProjectServerStatusReason;
+  /** Filter files from ambient project status without changing explicit routing. */
+  includeOpenFile?: (file: string) => boolean;
 }
 
 export function buildProjectServerInfo(
@@ -32,8 +33,10 @@ export function buildProjectServerInfo(
     fileTypes: input.fileTypes,
     status,
     ...(input.statusReason ? { statusReason: input.statusReason } : {}),
-    supportedActions: getSupportedLspServerActions(input.client?.serverCapabilities),
-    openFiles: input.client?.openFiles.map((file) => displayRelativeFilePath(file, cwd)) ?? [],
+    openFiles:
+      input.client?.openFiles
+        .filter((file) => input.includeOpenFile?.(file) ?? true)
+        .map((file) => displayRelativeFilePath(file, cwd)) ?? [],
     ready: input.client?.ready ?? false,
   };
 }

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

@@ -16,12 +16,19 @@ import {
   assessStaleDiagnostics,
   type StaleDiagnosticAssessment,
 } from "../diagnostics/stale-diagnostics.ts";
-import type { WorkspaceDiagnosticReport } from "../session/runtime-diagnostics.ts";
+import {
+  emptyProcessCrashRecoveryReport,
+  type ProcessCrashRecoveryReport,
+  type WorkspaceDiagnosticReport,
+} from "../session/runtime-diagnostics.ts";
 
 export interface WorkspaceRecoveryResult {
   /** Active clients targeted by the best-effort refresh, not confirmed successful refreshes. */
   attemptedClients: number;
+  /** Clients restarted by stale-diagnostic recovery, not process-crash recovery. */
   restartedClients: number;
+  /** No process-crash demand is handled by this generic recovery pass. */
+  processCrashRecovery: ProcessCrashRecoveryReport;
   /** Server names of the active clients targeted by this pass, for telemetry identity. */
   attemptedServers: string[];
   /** Server names of the clients restarted during this pass, for telemetry identity. */
@@ -157,6 +164,7 @@ export async function recoverWorkspaceDiagnostics(
     return {
       attemptedClients,
       restartedClients,
+      processCrashRecovery: emptyProcessCrashRecoveryReport(),
       attemptedServers,
       restartedServers: restartServerNames,
       ...(restartReason ? { restartReason } : {}),