@mrclrchtr/supi-code-intelligence 6.0.1 → 6.2.0

package/src/substrate/lsp/settings.ts

@@ -1,8 +1,7 @@
 // LSP settings registration for the code-intelligence umbrella extension.
 //
-// Always-on LSP policy: the global `lsp.enabled` and `lsp.active` keys
-// are deprecated and ignored. Per-language disable via
-// `lsp.servers.<language>.enabled: false` is the only supported opt-out.
+// Per-language disable via `lsp.servers.<language>.enabled: false` is the
+// supported opt-out.
 //
 // Registered fields:
 // - exclude: stringList
@@ -21,11 +20,9 @@ import {
 } from "@mrclrchtr/supi-core/settings";
 import { type LspSettings, loadConfig } from "@mrclrchtr/supi-lsp/api";
 
-const LSP_DEFAULTS: LspSettings = {
-  enabled: true,
-  active: [],
-  exclude: [],
-};
+const LSP_DEFAULTS = {
+  exclude: [] as string[],
+} satisfies LspSettings;
 
 /** Discover configured servers from the defaults + effective LSP config. */
 function getConfiguredServers(cwd: string): string[] {
@@ -153,7 +150,7 @@ export function registerLspSettings(pi: ExtensionAPI): void {
           kind: "stringList" as const,
           key: "exclude",
           label: "Exclude Patterns",
-          description: "Gitignore patterns to suppress LSP diagnostics (comma-separated)",
+          description: "Gitignore patterns for automatic LSP workspace work (comma-separated)",
         },
         {
           kind: "custom" as const,

package/src/substrate/lsp/state.ts

@@ -22,7 +22,6 @@ export interface LspAdapterState {
   controller: LspRuntimeController | null;
   providerLease: WorkspaceProviderHostLease | null;
   inspector: LspInspectorState;
-  lspActive: boolean;
   /** Snapshot of workspace sentinel files (package.json, tsconfig, lockfiles) for change detection. */
   sentinelSnapshot: Map<string, number>;
   /** Fired for runtime lifecycle changes that require a footer render. */
@@ -34,7 +33,6 @@ export function createLspAdapterState(): LspAdapterState {
     controller: null,
     providerLease: null,
     inspector: { handle: null, close: null },
-    lspActive: false,
     sentinelSnapshot: new Map(),
     stateChanges: new EventTarget(),
   };

package/src/substrate/workspace-provider-host.ts

@@ -1,7 +1,7 @@
 import { realpathSync } from "node:fs";
 import { resolve } from "node:path";
 import { getDefaultWorkspaceRuntime } from "@mrclrchtr/supi-code-runtime/api";
-import { LspRuntimeController, scanWorkspaceSentinels } from "@mrclrchtr/supi-lsp/api";
+import { LspRuntimeController } from "@mrclrchtr/supi-lsp/api";
 import { TreeSitterRuntimeController } from "@mrclrchtr/supi-tree-sitter/api";
 
 const HOSTS = Symbol.for("supi-code-intelligence/workspace-provider-hosts");
@@ -77,7 +77,7 @@ class WorkspaceProviderHost {
       lspController: projectTrusted ? this.#lsp : null,
       sentinelSnapshot:
         projectTrusted && this.#lsp?.kind === "ready"
-          ? scanWorkspaceSentinels(this.cwd)
+          ? (this.#lsp.workspaceRuntime?.scanWorkspaceSentinels() ?? new Map())
           : new Map(),
       release: async () => {
         if (released) return;

package/src/tool/code_health/file-scope-markdown.ts

@@ -0,0 +1,43 @@
+import type { HealthDiagnosticObservation } from "../../session/health-types.ts";
+
+/** Render the tsconfig coverage result for a single-file health request. */
+export function renderFileScopeStatus(
+  lines: string[],
+  observation: Extract<
+    HealthDiagnosticObservation,
+    { kind: "completed" | "partial" | "unavailable" }
+  >,
+  cwd: string,
+): void {
+  if (observation.scope.kind !== "file" || !observation.scopeStatus) return;
+
+  const decision = observation.scopeStatus;
+  switch (decision.status) {
+    case "included":
+      lines.push(
+        `**Tsconfig**: covered by ${formatConfigPath(decision.configPath, cwd)} — part of workspace diagnostics.`,
+      );
+      return;
+    case "excluded":
+      lines.push(
+        `**Tsconfig**: NOT covered by ${formatConfigPath(decision.configPath, cwd)} — not part of workspace diagnostics.`,
+      );
+      return;
+    case "no-config":
+      lines.push("**Tsconfig**: no tsconfig.json or jsconfig.json found — nothing filtered.");
+      return;
+    case "out-of-tree":
+      lines.push("**Tsconfig**: outside the project root — not part of workspace diagnostics.");
+  }
+}
+
+/** Format a config path relative to the current workspace. */
+function formatConfigPath(configPath: string | null, cwd: string): string {
+  if (!configPath) return "no config";
+  return `\`${makeRelative(cwd, configPath)}\``;
+}
+
+/** Format a workspace path without exposing an absolute root. */
+export function makeRelative(cwd: string, file: string): string {
+  return file.startsWith(cwd) ? file.slice(cwd.length + 1) : file;
+}

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,9 +6,20 @@
  */
 
 import type { CapabilityWarningReport } from "../../analysis/capability/capability-warnings.ts";
+import {
+  formatProjectServerRoot,
+  formatProjectServerRouteSummary,
+  formatProjectServerStatusReason,
+} from "../../analysis/health/server-status.ts";
+import { makeRelative, renderFileScopeStatus } from "./file-scope-markdown.ts";
+import {
+  formatProcessCrashRecovery,
+  formatRefreshElapsed,
+  formatStaleDiagnosticRestarts as formatStaleDiagnosticRestartsText,
+  isFileReadinessPending,
+} from "./refresh-outcome.ts";
 import type {
   HealthData,
-  HealthDiagnosticObservation,
   HealthDiagnosticScope,
   HealthRefreshAttempt,
   HealthResultAssembly,
@@ -28,7 +39,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");
 }
 
@@ -41,19 +54,25 @@ function renderRefreshStatus(
   if (!hasDiagnostics) return;
 
   switch (data.refresh.kind) {
-    case "completed":
+    case "completed": {
+      const fileReadinessPending = isFileReadinessPending(data.refresh, data.semanticState);
       lines.push(
-        `**${refreshAttemptLabel(data.refresh)}**: ${asSentence(completedRefreshText(data.refresh))}`,
+        `**${refreshAttemptLabel(data.refresh)}**: ${asSentence(completedRefreshText(data.refresh, fileReadinessPending))}`,
       );
       lines.push(`**Stale assessment**: ${asSentence(staleAssessmentText(data.refresh))}`);
       lines.push("");
       return;
+    }
     case "failed": {
       const evidence = data.refresh.diagnosticEvidence
         ? `; ${formatDiagnosticEvidence(data.refresh.diagnosticEvidence)}`
         : "";
+      const processCrashRecovery = data.refresh.processCrashRecovery
+        ? formatProcessCrashRecovery(data.refresh.processCrashRecovery)
+        : null;
+      const staleRestart = formatStaleDiagnosticRestarts(data.refresh);
       lines.push(
-        `**${refreshAttemptLabel(data.refresh)}**: failed — ${data.refresh.reason}${evidence}`,
+        `**${refreshAttemptLabel(data.refresh)}**: failed — ${data.refresh.reason}${staleRestart ? `; ${staleRestart}` : ""}${processCrashRecovery ? `; ${processCrashRecovery}` : ""}${evidence}`,
       );
       lines.push("");
       return;
@@ -77,14 +96,27 @@ function renderRefreshStatus(
 
 function completedRefreshText(
   attempt: Extract<HealthRefreshAttempt, { kind: "completed" }>,
+  fileReadinessPending = attempt.fileReadiness === "pending",
 ): string {
-  const base =
-    attempt.attemptedActiveClients === 0 && attempt.restartedClients === 0
+  const processCrashRecovery = formatProcessCrashRecovery(attempt.processCrashRecovery);
+  const noOp =
+    !fileReadinessPending &&
+    attempt.attemptedActiveClients === 0 &&
+    attempt.restartedClients === 0 &&
+    processCrashRecovery === null;
+  const base = fileReadinessPending
+    ? "readiness pending — LSP may still be warming; retry shortly"
+    : noOp
       ? "completed no-op — no active clients were targeted"
-      : `completed — ${attempt.attemptedActiveClients} active client${plural(attempt.attemptedActiveClients)} targeted, ${attempt.restartedClients} restarted`;
+      : `completed — ${attempt.attemptedActiveClients} active client${plural(attempt.attemptedActiveClients)} targeted`;
+  const staleRestart = noOp ? null : formatStaleDiagnosticRestarts(attempt);
+  const outcome = [staleRestart, processCrashRecovery].filter(
+    (value): value is string => value !== null,
+  );
+  const withOutcome = outcome.length > 0 ? `${base}; ${outcome.join("; ")}` : base;
   return attempt.operationScope === "workspace-runtime"
-    ? `${base}; ${formatDiagnosticEvidence(attempt.diagnosticEvidence)}`
-    : base;
+    ? `${withOutcome}; ${formatDiagnosticEvidence(attempt.diagnosticEvidence)}`
+    : withOutcome;
 }
 
 function refreshAttemptLabel(attempt: Pick<HealthRefreshAttempt, "operationScope">): string {
@@ -110,7 +142,7 @@ function renderLastAttempt(lines: string[], attempt: HealthRefreshAttempt, cwd:
   const outcome = refreshAttemptOutcome(attempt);
   const label = refreshAttemptLabel(attempt);
   lines.push(
-    `**Previous ${label.toLowerCase()}**: ${asSentence(outcome)} Started ${formatElapsed(Date.now() - attempt.attemptedAt)}; requested ${formatDiagnosticScope(attempt.requestedDiagnosticScope, cwd)}; operation scope: ${refreshOperationScopeText(attempt)}.`,
+    `**Previous ${label.toLowerCase()}**: ${asSentence(outcome)} Started ${formatRefreshElapsed(Date.now() - attempt.attemptedAt)}; requested ${formatDiagnosticScope(attempt.requestedDiagnosticScope, cwd)}; operation scope: ${refreshOperationScopeText(attempt)}.`,
   );
 }
 
@@ -118,24 +150,35 @@ function renderRetainedAttempt(lines: string[], attempt: HealthRefreshAttempt, c
   const label =
     attempt.operationScope === "file-runtime" ? "File LSP maintenance" : "Diagnostic refresh";
   lines.push(
-    `**${label}**: not requested for this call. Previous attempt ${asSentence(refreshAttemptOutcome(attempt))} Started ${formatElapsed(Date.now() - attempt.attemptedAt)}; requested ${formatDiagnosticScope(attempt.requestedDiagnosticScope, cwd)}; operation scope: ${refreshOperationScopeText(attempt)}.`,
+    `**${label}**: not requested for this call. Previous attempt ${asSentence(refreshAttemptOutcome(attempt))} Started ${formatRefreshElapsed(Date.now() - attempt.attemptedAt)}; requested ${formatDiagnosticScope(attempt.requestedDiagnosticScope, cwd)}; operation scope: ${refreshOperationScopeText(attempt)}.`,
   );
 }
 
 function refreshAttemptOutcome(attempt: HealthRefreshAttempt): string {
-  return attempt.kind === "completed"
-    ? completedRefreshText(attempt)
-    : `failed — ${attempt.reason}${attempt.diagnosticEvidence ? `; ${formatDiagnosticEvidence(attempt.diagnosticEvidence)}` : ""}`;
+  if (attempt.kind === "completed") return completedRefreshText(attempt);
+  const processCrashRecovery = attempt.processCrashRecovery
+    ? formatProcessCrashRecovery(attempt.processCrashRecovery)
+    : null;
+  const staleRestart = formatStaleDiagnosticRestarts(attempt);
+  const evidence = attempt.diagnosticEvidence
+    ? `; ${formatDiagnosticEvidence(attempt.diagnosticEvidence)}`
+    : "";
+  return `failed — ${attempt.reason}${staleRestart ? `; ${staleRestart}` : ""}${processCrashRecovery ? `; ${processCrashRecovery}` : ""}${evidence}`;
 }
 
 function refreshOperationScopeText(attempt: HealthRefreshAttempt): string {
   return attempt.operationScope === "file-runtime" ? "file runtime" : "workspace runtime";
 }
 
-function formatElapsed(milliseconds: number): string {
-  const seconds = Math.max(0, Math.round(milliseconds / 1_000));
-  if (seconds < 60) return `${seconds}s ago`;
-  return `${Math.round(seconds / 60)}m ago`;
+function formatStaleDiagnosticRestarts(attempt: {
+  kind?: HealthRefreshAttempt["kind"];
+  operationScope: HealthRefreshAttempt["operationScope"];
+  restartedClients?: number;
+}): string | null {
+  if (attempt.operationScope !== "workspace-runtime" || attempt.restartedClients === undefined) {
+    return null;
+  }
+  return formatStaleDiagnosticRestartsText(attempt.restartedClients);
 }
 
 function renderCapabilityWarningsSection(
@@ -158,7 +201,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("");
 }
@@ -185,49 +229,6 @@ function renderDiagnosticsSection(lines: string[], data: HealthData, cwd: string
   lines.push("");
 }
 
-/**
- * Render the tsconfig coverage verdict for a single-file health request.
- *
- * Written in plain vocabulary (no basis terms) so a reader without tsconfig
- * background can act on it: the sentence names the deciding config and states
- * whether the file's errors are part of workspace diagnostics. The structured
- * decision basis stays in the diagnostics.scope debug event.
- */
-function renderFileScopeStatus(
-  lines: string[],
-  observation: Extract<
-    HealthDiagnosticObservation,
-    { kind: "completed" | "partial" | "unavailable" }
-  >,
-  cwd: string,
-): void {
-  if (observation.scope.kind !== "file" || !observation.scopeStatus) return;
-
-  const decision = observation.scopeStatus;
-  switch (decision.status) {
-    case "included":
-      lines.push(
-        `**Tsconfig**: covered by ${formatConfigPath(decision.configPath, cwd)} — part of workspace diagnostics.`,
-      );
-      return;
-    case "excluded":
-      lines.push(
-        `**Tsconfig**: NOT covered by ${formatConfigPath(decision.configPath, cwd)} — not part of workspace diagnostics.`,
-      );
-      return;
-    case "no-config":
-      lines.push("**Tsconfig**: no tsconfig.json or jsconfig.json found — nothing filtered.");
-      return;
-    case "out-of-tree":
-      lines.push("**Tsconfig**: outside the project root — not part of workspace diagnostics.");
-  }
-}
-
-function formatConfigPath(configPath: string | null, cwd: string): string {
-  if (!configPath) return "no config";
-  return `\`${makeRelative(cwd, configPath)}\``;
-}
-
 function formatDiagnosticEvidence(evidence: {
   requested: number;
   confirmed: number;
@@ -242,7 +243,14 @@ function renderDiagnosticObservation(lines: string[], data: HealthData, cwd: str
   const observation = data.diagnostics;
   if (observation.kind === "not-requested") return;
   if (observation.kind === "unavailable") {
-    lines.push(`Diagnostics unavailable — ${asSentence(observation.reason)}`);
+    if (
+      observation.scope.kind === "file" &&
+      isFileReadinessPending(currentRefreshAttempt(data), data.semanticState)
+    ) {
+      lines.push("Diagnostics pending — LSP may still be warming; retry shortly.");
+    } else {
+      lines.push(`Diagnostics unavailable — ${asSentence(observation.reason)}`);
+    }
     return;
   }
   if (observation.kind === "partial") {
@@ -261,6 +269,10 @@ function renderDiagnosticObservation(lines: string[], data: HealthData, cwd: str
   renderDiagnosticEntries(lines, data, cwd);
 }
 
+function currentRefreshAttempt(data: HealthData): HealthRefreshAttempt | null {
+  return data.refresh.kind === "completed" || data.refresh.kind === "failed" ? data.refresh : null;
+}
+
 function asSentence(text: string): string {
   return /[.!?]$/.test(text) ? text : `${text}.`;
 }
@@ -316,6 +328,7 @@ function renderServersSection(
   lines: string[],
   data: HealthData,
   status: "complete" | "partial" | "unavailable" | undefined,
+  cwd: string,
 ): void {
   lines.push("### Servers");
   lines.push("");
@@ -329,8 +342,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}`,
       );
     }
   }
@@ -359,7 +375,3 @@ function formatDiagnosticScope(scope: HealthDiagnosticScope, cwd: string): strin
 function plural(count: number): string {
   return count === 1 ? "" : "s";
 }
-
-function makeRelative(cwd: string, file: string): string {
-  return file.startsWith(cwd) ? file.slice(cwd.length + 1) : file;
-}

package/src/tool/code_health/refresh-outcome.ts

@@ -0,0 +1,46 @@
+import type { ProcessCrashRecoverySummary } from "@mrclrchtr/supi-lsp/api";
+import type { SemanticHealthState } from "../../session/health-types.ts";
+
+/** Report whether a file health result is waiting for semantic readiness. */
+export function isFileReadinessPending(
+  attempt: { operationScope?: string; fileReadiness?: string } | null | undefined,
+  semanticState: SemanticHealthState | null | undefined,
+): boolean {
+  if (attempt?.operationScope !== undefined) {
+    return (
+      attempt.operationScope === "file-runtime" &&
+      (attempt.fileReadiness === "pending" ||
+        (attempt.fileReadiness === undefined && semanticState?.kind === "pending"))
+    );
+  }
+  return semanticState?.kind === "pending";
+}
+
+/** Format the outcome of stale-diagnostic client restarts. */
+export function formatStaleDiagnosticRestarts(restartedClients: number): string {
+  return `stale diagnostic restarts: ${restartedClients} client${plural(restartedClients)} restarted`;
+}
+
+/** Format a non-empty process-crash route recovery outcome. */
+export function formatProcessCrashRecovery(
+  summary: ProcessCrashRecoverySummary | null | undefined,
+): string | null {
+  if (
+    !summary ||
+    (summary.attemptedRoutes === 0 && summary.recoveredRoutes === 0 && summary.failedRoutes === 0)
+  ) {
+    return null;
+  }
+  return `process-crash recovery: ${summary.recoveredRoutes} route${plural(summary.recoveredRoutes)} recovered (${summary.attemptedRoutes} attempted, ${summary.failedRoutes} failed)`;
+}
+
+/** Format the age of a retained refresh attempt for a status line. */
+export function formatRefreshElapsed(milliseconds: number): string {
+  const seconds = Math.max(0, Math.round(milliseconds / 1_000));
+  if (seconds < 60) return `${seconds}s ago`;
+  return `${Math.round(seconds / 60)}m ago`;
+}
+
+function plural(count: number): string {
+  return count === 1 ? "" : "s";
+}

package/src/tool/code_health/refresh-status.ts

@@ -1,3 +1,11 @@
+import type { ProcessCrashRecoverySummary } from "@mrclrchtr/supi-lsp/api";
+import {
+  formatProcessCrashRecovery,
+  formatStaleDiagnosticRestarts,
+  isFileReadinessPending,
+} from "./refresh-outcome.ts";
+import { readSemanticHealthState } from "./semantic-state.ts";
+
 /** Render current and retained health refresh status for the TUI. */
 
 export function readRefreshStatus(data: Record<string, unknown> | null): string | null {
@@ -5,25 +13,10 @@ export function readRefreshStatus(data: Record<string, unknown> | null): string
   if (!refresh) return null;
 
   switch (refresh.kind) {
-    case "completed": {
-      const attempted = readNumber(refresh.attemptedActiveClients);
-      const restarted = readNumber(refresh.restartedClients);
-      const stale = readRecord(refresh.staleAssessment);
-      const noOp = attempted === 0 && restarted === 0;
-      const label = refreshAttemptLabel(refresh);
-      const base = noOp
-        ? `${label} completed no-op`
-        : `${label} completed: ${attempted} clients targeted, ${restarted} restarted`;
-      const evidence = formatDiagnosticEvidence(readRecord(refresh.diagnosticEvidence));
-      const withEvidence = evidence ? `${base}; ${evidence}` : base;
-      return stale?.suspected === true
-        ? `${withEvidence}; stale pattern suspected in ${readNumber(stale.matchedFileCount)} files`
-        : withEvidence;
-    }
-    case "failed": {
-      const evidence = formatDiagnosticEvidence(readRecord(refresh.diagnosticEvidence));
-      return `${refreshAttemptLabel(refresh)} failed${typeof refresh.reason === "string" ? `: ${refresh.reason}` : ""}${evidence ? `; ${evidence}` : ""}`;
-    }
+    case "completed":
+      return formatCompletedRefreshStatus(refresh, isPendingFileReadiness(data));
+    case "failed":
+      return formatFailedRefreshStatus(refresh);
     case "not-attempted":
       return `refresh attempt not started${formatLastRefreshSuffix(refresh)}`;
     case "not-requested":
@@ -33,6 +26,89 @@ export function readRefreshStatus(data: Record<string, unknown> | null): string
   }
 }
 
+function formatCompletedRefreshStatus(
+  refresh: Record<string, unknown>,
+  fileReadinessPending: boolean,
+): string {
+  const attempted = readNumber(refresh.attemptedActiveClients);
+  const restarted = readNumber(refresh.restartedClients);
+  const processCrashRecovery = formatProcessCrashRecovery(
+    readProcessCrashRecovery(refresh.processCrashRecovery),
+  );
+  const noOp =
+    !fileReadinessPending && attempted === 0 && restarted === 0 && processCrashRecovery === null;
+  const label = refreshAttemptLabel(refresh);
+  const base = fileReadinessPending
+    ? `${label} waiting — LSP may still be warming; retry shortly`
+    : noOp
+      ? `${label} completed no-op`
+      : `${label} completed: ${attempted} clients targeted`;
+  const outcomes = formatRefreshOutcomes(refresh, restarted, processCrashRecovery, noOp);
+  const withOutcome = outcomes.length > 0 ? `${base}; ${outcomes.join("; ")}` : base;
+  const evidence = formatDiagnosticEvidence(readRecord(refresh.diagnosticEvidence));
+  const withEvidence = evidence ? `${withOutcome}; ${evidence}` : withOutcome;
+  const stale = readRecord(refresh.staleAssessment);
+  return stale?.suspected === true
+    ? `${withEvidence}; stale pattern suspected in ${readNumber(stale.matchedFileCount)} files`
+    : withEvidence;
+}
+
+function formatFailedRefreshStatus(refresh: Record<string, unknown>): string {
+  const processCrashRecovery = formatProcessCrashRecovery(
+    readProcessCrashRecovery(refresh.processCrashRecovery),
+  );
+  const staleRestart = formatStaleDiagnosticRestartsForRecord(refresh);
+  const evidence = formatDiagnosticEvidence(readRecord(refresh.diagnosticEvidence));
+  const reason = typeof refresh.reason === "string" ? `: ${refresh.reason}` : "";
+  return `${refreshAttemptLabel(refresh)} failed${reason}${staleRestart ? `; ${staleRestart}` : ""}${processCrashRecovery ? `; ${processCrashRecovery}` : ""}${evidence ? `; ${evidence}` : ""}`;
+}
+
+function formatRefreshOutcomes(
+  refresh: Record<string, unknown>,
+  restarted: number,
+  processCrashRecovery: string | null,
+  noOp: boolean,
+): string[] {
+  const outcomes: string[] = [];
+  if (refresh.operationScope === "workspace-runtime" && !noOp) {
+    outcomes.push(formatStaleDiagnosticRestarts(restarted));
+  }
+  if (processCrashRecovery) outcomes.push(processCrashRecovery);
+  return outcomes;
+}
+
+/** Render only the material current recovery outcome for compact TUI chrome. */
+export function readCompactRefreshStatus(data: Record<string, unknown> | null): string | null {
+  const refresh = readRecord(data?.refresh);
+  if (!refresh || (refresh.kind !== "completed" && refresh.kind !== "failed")) return null;
+
+  const processCrashRecovery = formatProcessCrashRecovery(
+    readProcessCrashRecovery(refresh.processCrashRecovery),
+  );
+  if (refresh.kind === "failed") {
+    const staleRestart = formatStaleDiagnosticRestartsForRecord(refresh);
+    return (
+      [staleRestart, processCrashRecovery]
+        .filter((value): value is string => value !== null)
+        .join("; ") || null
+    );
+  }
+  const fileReadinessPending = isPendingFileReadiness(data);
+  if (
+    !processCrashRecovery &&
+    readNumber(refresh.restartedClients) === 0 &&
+    !fileReadinessPending
+  ) {
+    return null;
+  }
+
+  const staleRestart = formatStaleDiagnosticRestartsForRecord(refresh);
+  const readiness = fileReadinessPending ? "LSP may still be warming; retry shortly" : null;
+  return [staleRestart, processCrashRecovery, readiness]
+    .filter((value): value is string => value !== null)
+    .join("; ");
+}
+
 export function readPreviousRefreshStatus(data: Record<string, unknown> | null): string | null {
   const refresh = readRecord(data?.refresh);
   if (!refresh || (refresh.kind !== "not-requested" && refresh.kind !== "not-attempted")) {
@@ -41,11 +117,23 @@ export function readPreviousRefreshStatus(data: Record<string, unknown> | null):
   const attempt = readRecord(refresh.lastAttempt);
   if (!attempt) return null;
   const evidence = formatCompactDiagnosticEvidence(readRecord(attempt.diagnosticEvidence));
+  const processCrashRecovery = formatProcessCrashRecovery(
+    readProcessCrashRecovery(attempt.processCrashRecovery),
+  );
+  const staleRestart = formatStaleDiagnosticRestartsForRecord(attempt);
+  const fileReadinessPending =
+    attempt.kind === "completed" &&
+    isFileReadinessPending(attempt, readSemanticHealthState(data?.semanticState));
+  const readiness = fileReadinessPending ? "LSP may still be warming; retry shortly" : null;
+  const outcome = [readiness, staleRestart, processCrashRecovery, evidence]
+    .filter((value): value is string => value !== null)
+    .join("; ");
   if (attempt.kind === "failed") {
-    return `last ${refreshAttemptLabel(attempt)} failed${evidence ? ` (${evidence})` : ""}`;
+    return `last ${refreshAttemptLabel(attempt)} failed${outcome ? ` (${outcome})` : ""}`;
   }
   if (attempt.kind === "completed") {
-    return `last ${refreshAttemptLabel(attempt)} completed${evidence ? ` (${evidence})` : ""}`;
+    const status = fileReadinessPending ? "waiting" : "completed";
+    return `last ${refreshAttemptLabel(attempt)} ${status}${outcome ? ` (${outcome})` : ""}`;
   }
   return null;
 }
@@ -54,16 +142,45 @@ function refreshAttemptLabel(attempt: Record<string, unknown>): string {
   return attempt.operationScope === "file-runtime" ? "file maintenance attempt" : "refresh attempt";
 }
 
+function formatStaleDiagnosticRestartsForRecord(attempt: Record<string, unknown>): string | null {
+  if (
+    attempt.operationScope !== "workspace-runtime" ||
+    typeof attempt.restartedClients !== "number"
+  ) {
+    return null;
+  }
+  const processCrashRecovery = formatProcessCrashRecovery(
+    readProcessCrashRecovery(attempt.processCrashRecovery),
+  );
+  const noOp =
+    attempt.kind === "completed" &&
+    readNumber(attempt.attemptedActiveClients) === 0 &&
+    attempt.restartedClients === 0 &&
+    processCrashRecovery === null;
+  return noOp ? null : formatStaleDiagnosticRestarts(attempt.restartedClients);
+}
+
 function formatLastRefreshSuffix(refresh: Record<string, unknown>): string {
   const attempt = readRecord(refresh.lastAttempt);
   if (!attempt) return "";
   const evidence = formatDiagnosticEvidence(readRecord(attempt.diagnosticEvidence));
+  const staleRestart = formatStaleDiagnosticRestartsForRecord(attempt);
+  const processCrashRecovery = formatProcessCrashRecovery(
+    readProcessCrashRecovery(attempt.processCrashRecovery),
+  );
+  const fileReadinessPending =
+    attempt.kind === "completed" && isFileReadinessPending(attempt, null);
+  const readiness = fileReadinessPending ? "LSP may still be warming; retry shortly" : null;
+  const outcome = [readiness, staleRestart, processCrashRecovery, evidence]
+    .filter((value): value is string => value !== null)
+    .join("; ");
   if (attempt.kind === "failed") {
     const reason = typeof attempt.reason === "string" ? `: ${attempt.reason}` : "";
-    return `; last ${refreshAttemptLabel(attempt)} failed${reason}${evidence ? `; ${evidence}` : ""}`;
+    return `; last ${refreshAttemptLabel(attempt)} failed${reason}${outcome ? `; ${outcome}` : ""}`;
   }
   if (attempt.kind === "completed") {
-    return `; last ${refreshAttemptLabel(attempt)} completed${evidence ? `; ${evidence}` : ""}`;
+    const status = fileReadinessPending ? "waiting" : "completed";
+    return `; last ${refreshAttemptLabel(attempt)} ${status}${outcome ? `; ${outcome}` : ""}`;
   }
   return "";
 }
@@ -80,6 +197,32 @@ function formatDiagnosticEvidence(evidence: Record<string, unknown> | null): str
   return `${counts[0]} requested, ${counts[1]} confirmed, ${counts[2]} unconfirmed, ${counts[3]} failed, ${counts[4]} removed`;
 }
 
+export function isPendingFileReadiness(data: Record<string, unknown> | null): boolean {
+  const observation = readRecord(data?.diagnosticObservation);
+  const scope = readRecord(observation?.scope);
+  if (scope?.kind !== "file") return false;
+
+  const refresh = readRecord(data?.refresh);
+  const attempt = refresh && typeof refresh.operationScope === "string" ? refresh : null;
+  return isFileReadinessPending(attempt, readSemanticHealthState(data?.semanticState));
+}
+
+function readProcessCrashRecovery(value: unknown): ProcessCrashRecoverySummary | null {
+  const summary = readRecord(value);
+  if (!summary) return null;
+  const attemptedRoutes = summary.attemptedRoutes;
+  const recoveredRoutes = summary.recoveredRoutes;
+  const failedRoutes = summary.failedRoutes;
+  if (
+    !isEvidenceCount(attemptedRoutes) ||
+    !isEvidenceCount(recoveredRoutes) ||
+    !isEvidenceCount(failedRoutes)
+  ) {
+    return null;
+  }
+  return { attemptedRoutes, recoveredRoutes, failedRoutes };
+}
+
 function readEvidenceCounts(evidence: Record<string, unknown> | null): number[] | null {
   if (!evidence) return null;
   const counts = [