@mrclrchtr/supi-code-intelligence 6.0.0 → 6.1.0

package/node_modules/@mrclrchtr/supi-tree-sitter/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-tree-sitter",
-  "version": "6.0.0",
+  "version": "6.1.0",
   "description": "Structural AST analysis for SuPi code intelligence",
   "license": "MIT",
   "repository": {
@@ -36,8 +36,8 @@
   "dependencies": {
     "jiti": "^2.7.0",
     "web-tree-sitter": "^0.26.8",
-    "@mrclrchtr/supi-core": "6.0.0",
-    "@mrclrchtr/supi-code-runtime": "6.0.0"
+    "@mrclrchtr/supi-code-runtime": "6.1.0",
+    "@mrclrchtr/supi-core": "6.1.0"
   },
   "bundledDependencies": [
     "@mrclrchtr/supi-code-runtime",

package/node_modules/@mrclrchtr/supi-tree-sitter/resources/grammars/kotlin/tree-sitter-kotlin.wasm.json

@@ -6,7 +6,7 @@
     "releaseAsset": "https://github.com/fwcd/tree-sitter-kotlin/releases/download/0.3.8/tree-sitter-kotlin.wasm"
   },
   "generatedWith": {
-    "treeSitterCli": "0.26.12"
+    "treeSitterCli": "0.26.13"
   },
   "sha256": "e08447e36ad5d86f39f91f13defce0636aea1490b8d65dafde6fa72649422061"
 }

package/node_modules/@mrclrchtr/supi-tree-sitter/resources/grammars/sql/tree-sitter-sql.wasm.json

@@ -5,7 +5,7 @@
     "repository": "https://github.com/derekstride/tree-sitter-sql"
   },
   "generatedWith": {
-    "treeSitterCli": "0.26.12"
+    "treeSitterCli": "0.26.13"
   },
   "sha256": "9b93a15dc3eade66df4347731f2687b939daf987c8382660d6118e863604ab09",
   "trust": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-code-intelligence",
-  "version": "6.0.0",
+  "version": "6.1.0",
   "description": "LSP and AST navigation, search, diagnostics, and refactoring",
   "license": "MIT",
   "repository": {
@@ -35,10 +35,10 @@
   ],
   "dependencies": {
     "yaml": "^2.9.0",
-    "@mrclrchtr/supi-code-runtime": "6.0.0",
-    "@mrclrchtr/supi-lsp": "6.0.0",
-    "@mrclrchtr/supi-tree-sitter": "6.0.0",
-    "@mrclrchtr/supi-core": "6.0.0"
+    "@mrclrchtr/supi-lsp": "6.1.0",
+    "@mrclrchtr/supi-core": "6.1.0",
+    "@mrclrchtr/supi-code-runtime": "6.1.0",
+    "@mrclrchtr/supi-tree-sitter": "6.1.0"
   },
   "bundledDependencies": [
     "@mrclrchtr/supi-code-runtime",

package/src/analysis/health/recovery.ts

@@ -4,6 +4,7 @@
 import type { CapabilityState, CodeRequestControl } from "@mrclrchtr/supi-code-runtime/api";
 import type {
   DiagnosticEvidenceSummary,
+  ProcessCrashDiagnosticDemand,
   RecoverDiagnosticsResult,
   WorkspaceLspRuntime,
 } from "@mrclrchtr/supi-lsp/api";
@@ -16,6 +17,8 @@ interface RecoverOptions {
   control?: CodeRequestControl;
   /** Evidence from the maintenance refresh, so the recovery pass skips its own refresh. */
   initialEvidence?: DiagnosticEvidenceSummary;
+  /** Explicit demand for crashed diagnostic routes before diagnostic recovery. */
+  processCrashDemand?: ProcessCrashDiagnosticDemand;
 }
 
 /** Run the runtime's best-effort recovery and preserve its established outcome. */
@@ -26,6 +29,7 @@ export async function recoverDiagnosticRuntime(
   return opts.service.recoverDiagnostics({
     restartIfStillStale: true,
     ...(opts.initialEvidence !== undefined ? { initialEvidence: opts.initialEvidence } : {}),
+    ...(opts.processCrashDemand ? { processCrashDemand: opts.processCrashDemand } : {}),
     control: opts.control,
   });
 }

package/src/analysis/health/server-status.ts

@@ -0,0 +1,64 @@
+import * as path from "node:path";
+import type { ProjectServerInfo, ProjectServerStatusReason } from "@mrclrchtr/supi-lsp/api";
+
+/** Workspace-wide counts for non-running LSP routes. */
+export interface ProjectServerRouteStatusCounts {
+  recovering: number;
+  error: number;
+  unavailable: number;
+}
+
+/** Count typed route states without changing semantic readiness. */
+export function countProjectServerRouteStatuses(
+  servers: readonly Pick<ProjectServerInfo, "status" | "statusReason">[],
+): ProjectServerRouteStatusCounts {
+  return {
+    recovering: servers.filter((server) => server.statusReason === "process-crash-recovery-pending")
+      .length,
+    error: servers.filter(
+      (server) =>
+        server.status === "error" && server.statusReason !== "process-crash-recovery-pending",
+    ).length,
+    unavailable: servers.filter((server) => server.status === "unavailable").length,
+  };
+}
+
+/** Render nonzero workspace route counts for an aggregate status surface. */
+export function formatProjectServerRouteSummary(
+  servers: readonly Pick<ProjectServerInfo, "status" | "statusReason">[],
+): string | null {
+  return formatProjectServerRouteStatusCounts(countProjectServerRouteStatuses(servers));
+}
+
+/** Render one structured workspace route-count value. */
+export function formatProjectServerRouteStatusCounts(
+  counts: ProjectServerRouteStatusCounts,
+): string | null {
+  const parts: string[] = [];
+  if (counts.recovering > 0) parts.push(`${counts.recovering} recovering`);
+  if (counts.error > 0) parts.push(`${counts.error} error${counts.error === 1 ? "" : "s"}`);
+  if (counts.unavailable > 0) parts.push(`${counts.unavailable} unavailable`);
+  return parts.length > 0 ? `workspace routes: ${parts.join(", ")}` : null;
+}
+
+/** Render an LSP route root relative to its workspace. */
+export function formatProjectServerRoot(cwd: string, root: string): string {
+  const relative = path.relative(cwd, root);
+  return (relative || ".").replaceAll("\\", "/");
+}
+
+/** Render a concise explanation for a process-crash recovery state. */
+export function formatProjectServerStatusReason(
+  reason: ProjectServerStatusReason | undefined,
+): string | null {
+  switch (reason) {
+    case "process-crashed":
+      return "process crashed; next evidence operation will recover";
+    case "process-crash-recovery-pending":
+      return "process recovery in progress";
+    case "process-crash-recovery-exhausted":
+      return "process recovery exhausted; reload required";
+    default:
+      return null;
+  }
+}

package/src/analysis/health/signals.ts

@@ -15,6 +15,7 @@ export function collectServers(
     root: server.root,
     fileTypes: server.fileTypes,
     status: server.status,
+    ...(server.statusReason ? { statusReason: server.statusReason } : {}),
     ready: server.ready,
   }));
 }

package/src/analysis/provider.ts

@@ -97,7 +97,8 @@ export function withSemanticRequestControl<T extends SemanticProvider>(
     references: (file, position) => provider.references(file, position, control),
     implementation: (file, position) => provider.implementation(file, position, control),
     documentSymbols: (file) => provider.documentSymbols(file, control),
-    workspaceSymbols: (query) => provider.workspaceSymbols(query, control),
+    workspaceSymbols: (query, _requestControl, scopes) =>
+      provider.workspaceSymbols(query, control, scopes),
     hover: provider.hover
       ? (file, position) => provider.hover?.(file, position, control)
       : undefined,

package/src/analysis/target/symbol.ts

@@ -8,6 +8,7 @@
 
 import * as path from "node:path";
 import {
+  type CodeQueryResult,
   type CodeRequestControl,
   type CodeSymbol,
   isCodeRequestInterruption,
@@ -114,33 +115,27 @@ export async function resolveSymbolTarget(
     control?: CodeRequestControl;
   },
 ): Promise<TargetOutcome> {
-  const result = await semantic.workspaceSymbols(symbol);
+  const scopePath = options?.path ? normalizePath(options.path, cwd) : null;
+  const result = await semantic.workspaceSymbols(
+    symbol,
+    options?.control,
+    scopePath ? [scopePath] : undefined,
+  );
   if (result.kind === "unavailable") {
     return {
-      kind: "error",
-      message: `Symbol discovery for \`${symbol}\` is unavailable: ${result.reason}`,
-    };
-  }
-  if (result.data.length === 0) {
-    return {
-      kind: "error",
-      message: `Symbol not found: \`${symbol}\`. Try \`code_resolve\` to search for it, or use an anchor target (file/line/character) if you know the location.`,
+      kind: "unavailable",
+      reason: `Symbol discovery for \`${symbol}\` is unavailable: ${result.reason}`,
     };
   }
+  if (result.data.length === 0) return emptySymbolOutcome(symbol, result, options?.path);
 
-  const scopePath = options?.path ? normalizePath(options.path, cwd) : null;
   const scoped = result.data.filter((candidate) =>
     scopePath ? isWithinOrEqual(scopePath, candidate.file) : true,
   );
   const eligible = options?.exportedOnly
     ? scoped.filter((candidate) => !NON_EXPORTED_KINDS.has(candidate.kind))
     : scoped;
-  if (eligible.length === 0) {
-    return {
-      kind: "error",
-      message: `Symbol not found: \`${symbol}\`${scopePath ? ` in path \`${options?.path}\`` : ""}. Try \`code_resolve\` to search for it, or use an anchor target (file/line/character) if you know the location.`,
-    };
-  }
+  if (eligible.length === 0) return emptySymbolOutcome(symbol, result, options?.path);
 
   const requestedKind = options?.kind;
   if (requestedKind) {
@@ -248,6 +243,23 @@ type CandidateOutcomeOptions = CandidateOutcomeBase &
  * exact provider result count for omission disclosure. No candidate is
  * promoted when the requested provider kind did not match.
  */
+function emptySymbolOutcome(
+  symbol: string,
+  result: Exclude<CodeQueryResult<CodeSymbol[]>, { kind: "unavailable" }>,
+  scope?: string,
+): TargetOutcome {
+  if (result.kind === "partial") {
+    return {
+      kind: "unavailable",
+      reason: `Symbol discovery for \`${symbol}\` is incomplete: ${result.reason}`,
+    };
+  }
+  return {
+    kind: "error",
+    message: `Symbol not found: \`${symbol}\`${scope ? ` in path \`${scope}\`` : ""}. Try \`code_resolve\` to search for it, or use an anchor target (file/line/character) if you know the location.`,
+  };
+}
+
 async function buildCandidateOutcome(
   options: CandidateOutcomeOptions,
 ): Promise<Extract<TargetOutcome, { kind: "disambiguation" | "kind-mismatch" }>> {

package/src/analysis/target/types.ts

@@ -156,4 +156,5 @@ export type TargetOutcome =
       candidates: DisambiguationCandidateData[];
       omittedCount: number;
     }
+  | { kind: "unavailable"; reason: string }
   | { kind: "error"; message: string };

package/src/session/find-workflow.ts

@@ -9,6 +9,7 @@ import { isCodeFindAstKind } from "../tool/code_find/ast-kinds.ts";
 import type { CapabilityAdapter } from "./capability-adapter.ts";
 import type { FindWorkflowInput, FindWorkflowOutcome } from "./find-types.ts";
 import { parseFindWorkflowInput } from "./input/workflows.ts";
+import { resolveWorkspaceSemanticDemand } from "./semantic-demand.ts";
 import { reportProgress, throwIfAborted, type WorkflowControl } from "./workflow-control.ts";
 
 export interface FindWorkflowDeps {
@@ -71,22 +72,14 @@ async function runSemanticSearch(options: {
   control?: WorkflowControl;
 }): Promise<FindWorkflowOutcome> {
   const { query, scopePaths, scopeLabel, maxResults, deps, control } = options;
-  const readiness = await deps.capability.ensureSemanticReadiness(
-    deps.cwd,
-    { kind: "workspace" },
-    control,
-  );
-  if (readiness.kind === "timeout") {
+  const semanticDemand = await resolveWorkspaceSemanticDemand(deps.capability, deps.cwd, control);
+  if (semanticDemand.kind === "timeout") {
     return { kind: "unavailable", reason: SEMANTIC_READINESS_TIMEOUT_REASON };
   }
-  if (readiness.kind === "unavailable") return readiness;
+  if (semanticDemand.kind === "unavailable") return semanticDemand;
   throwIfAborted(control);
 
-  const provider = deps.capability.getSemanticProvider(deps.cwd);
-  if (!provider?.workspaceSymbols) {
-    return { kind: "unavailable", reason: "No semantic workspace-symbol provider is active." };
-  }
-  const result = await provider.workspaceSymbols(query, control);
+  const result = await semanticDemand.provider.workspaceSymbols(query, control, scopePaths);
   // A cancellation that landed during the request must not publish symbols
   // the caller no longer awaits.
   throwIfAborted(control);

package/src/session/health-refresh.ts

@@ -105,9 +105,13 @@ async function collectWorkspaceRefreshAttempt(
       service: options.runtime,
       control: options.control,
       progress: options.reportRecoveryProgress,
-      // The maintenance pass already refreshed every open document; reuse its
-      // evidence so the recovery pass skips a redundant second refresh.
+      // The maintenance pass already refreshed every running route. Reuse its
+      // evidence unless process-crash demand restores a required route; the
+      // runtime then performs a fresh pass that includes the replacement.
       initialEvidence: maintenance.diagnosticEvidence,
+      processCrashDemand: {
+        ...(workspaceScope?.filter ? { scopes: [workspaceScope.filter] } : {}),
+      },
     });
     const diagnosticEvidence = mergeDiagnosticEvidence(
       maintenance.diagnosticEvidence,

package/src/session/health-types.ts

@@ -1,4 +1,9 @@
-import type { DiagnosticEvidenceSummary, FileScopeDecision } from "@mrclrchtr/supi-lsp/api";
+import type {
+  DiagnosticEvidenceSummary,
+  FileScopeDecision,
+  ProjectServerInfo,
+  ProjectServerStatusReason,
+} from "@mrclrchtr/supi-lsp/api";
 import type { CapabilityWarningReport } from "../analysis/capability/capability-warnings.ts";
 
 export type HealthSection = "diagnostics" | "servers";
@@ -22,7 +27,8 @@ export interface HealthServerInfo {
   readonly name: string;
   readonly root: string;
   readonly fileTypes: readonly string[];
-  readonly status: string;
+  readonly status: ProjectServerInfo["status"];
+  readonly statusReason?: ProjectServerStatusReason;
   readonly ready: boolean;
 }
 

package/src/session/health-workflow.ts

@@ -59,6 +59,7 @@ export async function runHealthWorkflow(
   if (prepared.kind === "invalid-input") return prepared;
   const { request, scopeFilter, included, level } = prepared.value;
   const semanticRequested = healthNeedsSemantic(included);
+  const fileReadinessRequested = included.includes("diagnostics");
   throwIfAborted(control);
 
   reportProgress(control, {
@@ -85,6 +86,7 @@ export async function runHealthWorkflow(
   });
   const semanticState = await establishSemanticHealthState({
     requested: semanticRequested,
+    fileReadinessRequested,
     runtime,
     scopeFilter,
     lspState,
@@ -139,6 +141,8 @@ function healthNeedsSemantic(included: readonly HealthSection[]): boolean {
 
 interface SemanticHealthStateOptions {
   requested: boolean;
+  /** Whether this call requests file-routed evidence rather than passive inventory. */
+  fileReadinessRequested: boolean;
   runtime: WorkspaceLspRuntime | null;
   scopeFilter: string | null;
   lspState: WorkspaceLspRuntimeState;
@@ -150,7 +154,7 @@ async function establishSemanticHealthState(
   options: SemanticHealthStateOptions,
 ): Promise<SemanticHealthState | null> {
   if (!options.requested) return null;
-  if (options.runtime && isScopedFile(options.scopeFilter)) {
+  if (options.fileReadinessRequested && options.runtime && isScopedFile(options.scopeFilter)) {
     const readiness = await options.runtime.waitUntilReadyForFile(
       options.scopeFilter,
       undefined,

package/src/session/semantic-demand.ts

@@ -0,0 +1,36 @@
+import type { CodeRequestControl, SemanticProvider } from "@mrclrchtr/supi-code-runtime/api";
+import type { CapabilityAdapter, ReadinessOutcome } from "./capability-adapter.ts";
+
+export type WorkspaceSemanticDemandState =
+  | { kind: "ready"; provider: SemanticProvider }
+  | Exclude<ReadinessOutcome, { kind: "ready" }>;
+
+/**
+ * Wait for normal workspace startup, but let a registered provider proceed
+ * when known crashed routes make readiness recoverable only through demand.
+ */
+export async function resolveWorkspaceSemanticDemand(
+  capability: CapabilityAdapter,
+  cwd: string,
+  control?: CodeRequestControl,
+): Promise<WorkspaceSemanticDemandState> {
+  let provider = capability.getSemanticProvider(cwd);
+  const readiness = await capability.ensureSemanticReadiness(cwd, { kind: "workspace" }, control);
+  if (readiness.kind === "timeout") return readiness;
+  if (readiness.kind === "unavailable" && !hasProcessCrashRoute(capability, cwd)) {
+    return readiness;
+  }
+
+  provider ??= capability.getSemanticProvider(cwd);
+  return provider
+    ? { kind: "ready", provider }
+    : { kind: "unavailable", reason: "No semantic workspace-symbol provider is active." };
+}
+
+function hasProcessCrashRoute(capability: CapabilityAdapter, cwd: string): boolean {
+  const lspState = capability.getLspRuntimeState(cwd);
+  return (
+    lspState.kind === "ready" &&
+    lspState.runtime.getProjectServers().some((server) => server.statusReason !== undefined)
+  );
+}

package/src/session/target-workflow.ts

@@ -23,6 +23,7 @@ import type {
 } from "../analysis/target/types.ts";
 import type { CapabilityAdapter } from "./capability-adapter.ts";
 import { parseTargetInput } from "./input/common.ts";
+import { resolveWorkspaceSemanticDemand } from "./semantic-demand.ts";
 import { registerTargetCandidates, type TargetWorkflowCandidate } from "./target-candidates.ts";
 import type { TargetInput, TargetSymbolKind } from "./target-input.ts";
 import {
@@ -201,22 +202,15 @@ async function resolveSymbolWorkflow(
     scope = resolved.path;
   }
 
-  const readiness = await deps.capability.ensureSemanticReadiness(
-    deps.cwd,
-    { kind: "workspace" },
-    control,
-  );
-  if (readiness.kind === "timeout") {
+  const semanticDemand = await resolveWorkspaceSemanticDemand(deps.capability, deps.cwd, control);
+  if (semanticDemand.kind === "timeout") {
     return { kind: "unavailable", reason: "LSP readiness timed out. Retry shortly." };
   }
-  if (readiness.kind === "unavailable") {
-    return { kind: "unavailable", reason: readiness.reason };
+  if (semanticDemand.kind === "unavailable") {
+    return { kind: "unavailable", reason: semanticDemand.reason };
   }
 
-  const provider = withSemanticRequestControl(
-    deps.capability.getSemanticProvider(deps.cwd),
-    control,
-  );
+  const provider = withSemanticRequestControl(semanticDemand.provider, control);
   if (!provider) {
     return {
       kind: "unavailable",
@@ -291,6 +285,9 @@ function toWorkflowOutcome(
   policy: TargetWorkflowPolicy,
   deps: TargetWorkflowDeps,
 ): TargetWorkflowOutcome {
+  if (outcome.kind === "unavailable") {
+    return { kind: "unavailable", reason: outcome.reason };
+  }
   if (outcome.kind === "error") {
     return { kind: "invalid-input", message: outcome.message };
   }

package/src/tool/code_health/guidance.ts

@@ -1,8 +1,8 @@
 export const toolDescription =
-  "Report live diagnostics as observations, language-server status, and final semantic health state. Tracked-file snapshots do not prove workspace completeness; server inventory is workspace-wide.";
+  "Report live diagnostics as observations, language-server route status, and final semantic health state. Tracked-file snapshots do not prove workspace completeness; server inventory and route issue counts are workspace-wide. Server-only calls are passive.";
 
 export const promptSnippet = "live workspace health observations";
 
 export const promptGuidelines = [
-  "Use code_health with refresh:true before relying on potentially stale diagnostics.",
+  "Use code_health with refresh:true before relying on potentially stale diagnostics; explicit refresh can recover crashed routes with tracked files in scope.",
 ];

package/src/tool/code_health/markdown.ts

@@ -6,6 +6,11 @@
  */
 
 import type { CapabilityWarningReport } from "../../analysis/capability/capability-warnings.ts";
+import {
+  formatProjectServerRoot,
+  formatProjectServerRouteSummary,
+  formatProjectServerStatusReason,
+} from "../../analysis/health/server-status.ts";
 import type {
   HealthData,
   HealthDiagnosticObservation,
@@ -28,7 +33,9 @@ export function renderHealthResult(result: HealthResultAssembly, cwd: string): s
   renderRefreshStatus(lines, data, hasDiagnostics, cwd);
   if (hasDiagnostics) renderDiagnosticsSection(lines, data, cwd);
   if (semanticRequested) renderCapabilityWarningsSection(lines, result.details.capabilityWarnings);
-  if (hasSection("servers")) renderServersSection(lines, data, sectionStatus(result, "servers"));
+  if (hasSection("servers")) {
+    renderServersSection(lines, data, sectionStatus(result, "servers"), cwd);
+  }
   return lines.join("\n");
 }
 
@@ -158,7 +165,8 @@ function renderCapabilityWarningsSection(
 function renderStatusLine(lines: string[], data: HealthData, semanticRequested: boolean): void {
   if (!semanticRequested) return;
 
-  lines.push(`**LSP**: ${displaySemanticStatus(data)}`);
+  const routeSummary = formatProjectServerRouteSummary(data.servers);
+  lines.push(`**LSP**: ${displaySemanticStatus(data)}${routeSummary ? ` — ${routeSummary}` : ""}`);
   if (data.structuralStatus) lines.push(`**Structural**: ${data.structuralStatus}`);
   lines.push("");
 }
@@ -316,6 +324,7 @@ function renderServersSection(
   lines: string[],
   data: HealthData,
   status: "complete" | "partial" | "unavailable" | undefined,
+  cwd: string,
 ): void {
   lines.push("### Servers");
   lines.push("");
@@ -329,8 +338,11 @@ function renderServersSection(
   } else {
     for (const server of data.servers) {
       const statusIcon = server.status === "running" ? "✓" : "✗";
+      const reason = server.statusReason
+        ? ` — ${formatProjectServerStatusReason(server.statusReason)}`
+        : "";
       lines.push(
-        `- ${statusIcon} **${server.name}** (${server.fileTypes.join(", ")}) — ${server.status}`,
+        `- ${statusIcon} **${server.name}** @ \`${formatProjectServerRoot(cwd, server.root)}\` (${server.fileTypes.join(", ")}) — ${server.status}${reason}`,
       );
     }
   }

package/src/tool/code_health/result.ts

@@ -1,4 +1,9 @@
 import type { ConfidenceMode } from "@mrclrchtr/supi-code-runtime/api";
+import {
+  countProjectServerRouteStatuses,
+  formatProjectServerRoot,
+  formatProjectServerStatusReason,
+} from "../../analysis/health/server-status.ts";
 import type { HealthData, HealthSection } from "../../session/health-types.ts";
 import {
   assembleToolResult,
@@ -36,7 +41,7 @@ const SECTION_TITLES: Record<HealthSection, string> = {
 };
 
 /** Assemble public code_health evidence and details before presentation adapters render it. */
-export function assembleHealthResult(data: HealthData): HealthResultAssembly {
+export function assembleHealthResult(data: HealthData, cwd?: string): HealthResultAssembly {
   const projections = data.includedSections.map((section) => projectSection(section, data));
   const sections = projections.map((projection) => projection.section);
   const sectionDetails = projections.map((projection) => projection.details);
@@ -55,7 +60,7 @@ export function assembleHealthResult(data: HealthData): HealthResultAssembly {
     provenance,
   });
 
-  const displaySections = buildHealthDisplaySections(data);
+  const displaySections = buildHealthDisplaySections(data, cwd);
 
   return {
     data,
@@ -78,12 +83,13 @@ export function assembleHealthResult(data: HealthData): HealthResultAssembly {
       capabilityWarnings: data.capabilityWarnings ?? null,
       diagnosticFileCount: data.diagnostics.entries.length,
       serverCount: data.servers.length,
+      serverRouteStatusCounts: countProjectServerRouteStatuses(data.servers),
       evidenceLists: [...assembled.evidenceLists],
     },
   };
 }
 
-function buildHealthDisplaySections(data: HealthData): ToolDisplaySection[] {
+function buildHealthDisplaySections(data: HealthData, cwd?: string): ToolDisplaySection[] {
   const sections: ToolDisplaySection[] = [];
 
   if (data.includedSections.includes("diagnostics") && data.diagnostics.entries.length > 0) {
@@ -107,7 +113,10 @@ function buildHealthDisplaySections(data: HealthData): ToolDisplaySection[] {
         title: "Servers",
         items: data.servers,
         totalCount: data.servers.length,
-        format: (server) => `${server.name} (${server.fileTypes.join(", ")}) — ${server.status}`,
+        format: (server) => {
+          const root = cwd ? formatProjectServerRoot(cwd, server.root) : server.root;
+          return `${server.name} @ ${root} (${server.fileTypes.join(", ")}) — ${server.status}${server.statusReason ? ` — ${formatProjectServerStatusReason(server.statusReason)}` : ""}`;
+        },
       }),
     );
   }
@@ -255,7 +264,7 @@ export function finishHealthResult(outcome: HealthOutcome, cwd: string): CodeInt
     return healthErrorResult(`**Error:** ${outcome.message}`, outcome.message);
   }
 
-  const assembly = assembleHealthResult(outcome.data);
+  const assembly = assembleHealthResult(outcome.data, cwd);
   return {
     content: renderHealthResult(assembly, cwd),
     details: {

package/src/tool/code_health/spec.ts

@@ -17,7 +17,8 @@ export const codeHealthSpec = {
       scope: Type.Optional(ScopeParam),
       refresh: Type.Optional(
         Type.Boolean({
-          description: "Attempt diagnostic recovery before collecting; result reports the outcome.",
+          description:
+            "Attempt diagnostic and required process-crash recovery before collecting; result reports the outcome.",
         }),
       ),
       include: Type.Optional(

package/src/tool/code_health/tui.ts

@@ -4,6 +4,10 @@
 
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import { Container, Spacer, Text } from "@earendil-works/pi-tui";
+import {
+  formatProjectServerRouteStatusCounts,
+  type ProjectServerRouteStatusCounts,
+} from "../../analysis/health/server-status.ts";
 import {
   type EvidenceEntry,
   formatCallValue,
@@ -132,8 +136,11 @@ function buildCompactSummary(data: Record<string, unknown> | null, theme: Theme)
   );
   if (semanticRequested) {
     const semanticStatus = readSemanticStatus(data);
+    const routeSummary = readServerRouteStatusSummary(data);
     const statusColor = semanticStatus.startsWith("ready") ? "success" : "warning";
-    segments.push(`${theme.fg("dim", "lsp")} ${theme.fg(statusColor, semanticStatus)}`);
+    segments.push(
+      `${theme.fg("dim", "lsp")} ${theme.fg(statusColor, semanticStatus)}${routeSummary ? ` ${theme.fg("warning", routeSummary)}` : ""}`,
+    );
   }
   const previousRefresh = readPreviousRefreshStatus(data);
   if (previousRefresh) segments.push(theme.fg("dim", previousRefresh));
@@ -179,7 +186,10 @@ function buildStatusBar(data: Record<string, unknown> | null, theme: Theme): Tex
   const lspColor = semanticStatus.startsWith("ready") ? "success" : "warning";
   const structuralColor = structuralStatus === "ready" ? "success" : "muted";
 
-  const lines: string[] = [`LSP: ${theme.fg(lspColor, semanticStatus)}`];
+  const routeSummary = readServerRouteStatusSummary(data);
+  const lines: string[] = [
+    `LSP: ${theme.fg(lspColor, semanticStatus)}${routeSummary ? ` — ${theme.fg("warning", routeSummary)}` : ""}`,
+  ];
   if (structuralStatus) {
     lines.push(`Tree-sitter: ${theme.fg(structuralColor, structuralStatus)}`);
   }
@@ -287,7 +297,8 @@ function buildHealthSectionSummary(data: Record<string, unknown> | null, theme:
     if (section.status === "unavailable" || !section.available) {
       return `${label} unavailable`;
     }
-    return `${label} ${section.itemCount}`;
+    const routeSummary = section.key === "servers" ? readServerRouteStatusSummary(data) : null;
+    return `${label} ${section.itemCount}${routeSummary ? ` — ${routeSummary}` : ""}`;
   });
   return new Text(theme.fg("muted", lines.join("  ")), 0, 0);
 }
@@ -345,6 +356,16 @@ function readSemanticStatus(data: Record<string, unknown> | null): string {
   return formatSemanticHealthState(readSemanticHealthState(data?.semanticState));
 }
 
+function readServerRouteStatusSummary(data: Record<string, unknown> | null): string | null {
+  const counts = readRecord(data?.serverRouteStatusCounts);
+  if (!counts) return null;
+  return formatProjectServerRouteStatusCounts({
+    recovering: typeof counts.recovering === "number" ? counts.recovering : 0,
+    error: typeof counts.error === "number" ? counts.error : 0,
+    unavailable: typeof counts.unavailable === "number" ? counts.unavailable : 0,
+  } satisfies ProjectServerRouteStatusCounts);
+}
+
 function readString(data: Record<string, unknown> | null, key: string): string | null {
   const value = data?.[key];
   return typeof value === "string" ? value : null;

package/src/tool/result/errors.ts

@@ -100,6 +100,7 @@ export function healthErrorResult(content: string, reason?: string): CodeIntelRe
         capabilityWarnings: null,
         diagnosticFileCount: 0,
         serverCount: 0,
+        serverRouteStatusCounts: { recovering: 0, error: 0, unavailable: 0 },
       },
       status: "invalid-input",
       message: reason ?? content,