@mrclrchtr/supi-code-intelligence 6.0.1 → 6.1.0

package/node_modules/@mrclrchtr/supi-lsp/src/provider/lsp-semantic-provider.ts

@@ -92,10 +92,9 @@ export function createLspSemanticProvider(lsp: WorkspaceLspRuntime): SemanticPro
     async workspaceSymbols(
       query: string,
       control?: CodeRequestControl,
+      scopes?: readonly string[],
     ): Promise<CodeQueryResult<CodeSymbol[]>> {
-      const result = control
-        ? await lsp.workspaceSymbol(query, control)
-        : await lsp.workspaceSymbol(query);
+      const result = await lsp.workspaceSymbol(query, control, scopes);
       return mapCodeQueryResult(result, (results) =>
         results.map((symbol) => toCodeSymbol(symbol as SymbolInformation)),
       );

package/node_modules/@mrclrchtr/supi-lsp/src/session/runtime-diagnostic-surface.ts

@@ -8,6 +8,14 @@ import type {
   WorkspaceDiagnosticSummaryEntry,
 } from "./runtime-diagnostics.ts";
 
+/**
+ * Explicit diagnostic demand that can recover previously running crashed
+ * routes. Omitted scopes include every route with retained tracked files.
+ */
+export interface ProcessCrashDiagnosticDemand {
+  readonly scopes?: readonly string[];
+}
+
 /** Diagnostic and recovery operations owned by a workspace LSP runtime. */
 export interface WorkspaceLspDiagnosticSurface {
   fileDiagnostics(
@@ -37,6 +45,8 @@ export interface WorkspaceLspDiagnosticSurface {
     quietMs?: number;
     /** Evidence from a refresh the caller already completed; skips this pass's own refresh when no watched-file changes apply. */
     initialEvidence?: DiagnosticEvidenceSummary;
+    /** Explicit demand to recover crashed routes with tracked files in scope. */
+    processCrashDemand?: ProcessCrashDiagnosticDemand;
     control?: CodeRequestControl;
   }): Promise<RecoverDiagnosticsResult>;
 }

package/node_modules/@mrclrchtr/supi-lsp/src/session/runtime-registry.ts

@@ -38,7 +38,10 @@ import type {
   WorkspaceLspRuntimeState,
 } from "./workspace-lsp-runtime.ts";
 
-export type { WorkspaceLspDiagnosticSurface } from "./runtime-diagnostic-surface.ts";
+export type {
+  ProcessCrashDiagnosticDemand,
+  WorkspaceLspDiagnosticSurface,
+} from "./runtime-diagnostic-surface.ts";
 export type {
   DiagnosticEvidenceDocument,
   DiagnosticEvidenceStatus,
@@ -107,7 +110,10 @@ class DefaultWorkspaceLspRuntime implements WorkspaceLspRuntime {
     control?: CodeRequestControl,
   ): Promise<CodeQueryResult<Hover | null>> {
     const resolvedPath = this.resolveFilePath(filePath);
-    const client = await this.manager.ensureFileOpen(resolvedPath);
+    const client = await this.manager.ensureFileOpen(resolvedPath, {
+      recoverProcessCrash: true,
+      control,
+    });
     if (!client) return unavailableFileQuery("hover", resolvedPath);
     return client.hover(resolvedPath, position, control);
   }
@@ -118,7 +124,10 @@ class DefaultWorkspaceLspRuntime implements WorkspaceLspRuntime {
     control?: CodeRequestControl,
   ): Promise<CodeQueryResult<Location | Location[] | LocationLink[] | null>> {
     const resolvedPath = this.resolveFilePath(filePath);
-    const client = await this.manager.ensureFileOpen(resolvedPath);
+    const client = await this.manager.ensureFileOpen(resolvedPath, {
+      recoverProcessCrash: true,
+      control,
+    });
     if (!client) return unavailableFileQuery("definition", resolvedPath);
     return client.definition(resolvedPath, position, control);
   }
@@ -129,7 +138,10 @@ class DefaultWorkspaceLspRuntime implements WorkspaceLspRuntime {
     control?: CodeRequestControl,
   ): Promise<CodeQueryResult<Location[]>> {
     const resolvedPath = this.resolveFilePath(filePath);
-    const client = await this.manager.ensureFileOpen(resolvedPath);
+    const client = await this.manager.ensureFileOpen(resolvedPath, {
+      recoverProcessCrash: true,
+      control,
+    });
     if (!client) return unavailableFileQuery("references", resolvedPath);
     return mapCodeQueryResult(
       await client.references(resolvedPath, position, control),
@@ -143,7 +155,10 @@ class DefaultWorkspaceLspRuntime implements WorkspaceLspRuntime {
     control?: CodeRequestControl,
   ): Promise<CodeQueryResult<Location | Location[] | LocationLink[] | null>> {
     const resolvedPath = this.resolveFilePath(filePath);
-    const client = await this.manager.ensureFileOpen(resolvedPath);
+    const client = await this.manager.ensureFileOpen(resolvedPath, {
+      recoverProcessCrash: true,
+      control,
+    });
     if (!client) return unavailableFileQuery("implementation", resolvedPath);
     return client.implementation(resolvedPath, position, control);
   }
@@ -153,7 +168,10 @@ class DefaultWorkspaceLspRuntime implements WorkspaceLspRuntime {
     control?: CodeRequestControl,
   ): Promise<CodeQueryResult<DocumentSymbol[] | SymbolInformation[]>> {
     const resolvedPath = this.resolveFilePath(filePath);
-    const client = await this.manager.ensureFileOpen(resolvedPath);
+    const client = await this.manager.ensureFileOpen(resolvedPath, {
+      recoverProcessCrash: true,
+      control,
+    });
     if (!client) return unavailableFileQuery("document symbols", resolvedPath);
     return mapCodeQueryResult(
       await client.documentSymbols(resolvedPath, control),
@@ -164,8 +182,9 @@ class DefaultWorkspaceLspRuntime implements WorkspaceLspRuntime {
   async workspaceSymbol(
     query: string,
     control?: CodeRequestControl,
+    scopes?: readonly string[],
   ): Promise<CodeQueryResult<SymbolInformation[] | WorkspaceSymbol[]>> {
-    return this.manager.workspaceSymbol(query, control);
+    return this.manager.workspaceSymbol(query, control, scopes);
   }
 
   async rename(
@@ -175,7 +194,10 @@ class DefaultWorkspaceLspRuntime implements WorkspaceLspRuntime {
     control?: CodeRequestControl,
   ): Promise<RoutedMutationResponse<WorkspaceEdit | null> | null> {
     const resolvedPath = this.resolveFilePath(filePath);
-    const client = await this.manager.ensureFileOpen(resolvedPath);
+    const client = await this.manager.ensureFileOpen(resolvedPath, {
+      recoverProcessCrash: true,
+      control,
+    });
     if (!client) return null;
     return {
       value: await client.rename(resolvedPath, position, newName, control),
@@ -193,7 +215,10 @@ class DefaultWorkspaceLspRuntime implements WorkspaceLspRuntime {
     control?: CodeRequestControl,
   ): Promise<RoutedMutationResponse<CodeAction[] | null> | null> {
     const resolvedPath = this.resolveFilePath(filePath);
-    const client = await this.manager.ensureFileOpen(resolvedPath);
+    const client = await this.manager.ensureFileOpen(resolvedPath, {
+      recoverProcessCrash: true,
+      control,
+    });
     if (!client) return null;
 
     const range = isRange(positionOrRange)
@@ -345,6 +370,8 @@ class DefaultWorkspaceLspRuntime implements WorkspaceLspRuntime {
     quietMs?: number;
     /** Evidence from a refresh the caller already completed; skips this pass's own refresh when no watched-file changes apply. */
     initialEvidence?: DiagnosticEvidenceSummary;
+    /** Explicit demand to recover crashed routes with tracked files in scope. */
+    processCrashDemand?: import("./runtime-diagnostic-surface.ts").ProcessCrashDiagnosticDemand;
     control?: CodeRequestControl;
   }): Promise<RecoverDiagnosticsResult> {
     const recoveryStartedAt = Date.now();

package/node_modules/@mrclrchtr/supi-lsp/src/session/runtime-transition-debug.ts

@@ -8,6 +8,7 @@ export interface TransitionServerEntry {
   readonly name: string;
   readonly status: ProjectServerInfo["status"];
   readonly ready: boolean;
+  readonly statusReason?: NonNullable<ProjectServerInfo["statusReason"]>;
 }
 
 /** Bound a project-server snapshot to MAX_SERVERS name/status/ready entries. */
@@ -18,6 +19,7 @@ function boundedServerEntries(
     name: truncateIdentity(server.name),
     status: server.status,
     ready: server.ready,
+    ...(server.statusReason ? { statusReason: server.statusReason } : {}),
   }));
 }
 

package/node_modules/@mrclrchtr/supi-lsp/src/session/workspace-lsp-runtime.ts

@@ -40,8 +40,8 @@ export interface RoutedMutationResponse<T> {
  * diagnostics, and recovery without exposing clients or the mutable manager.
  * File paths can be absolute or session-cwd-relative. A leading `@` is removed to
  * match Pi's built-in path-tool convention. Positions use raw 0-based LSP coordinates.
- * Provider request control is accepted
- * as metadata only in this expansion and is not interpreted by the runtime.
+ * Request control is forwarded to the routed client and limits the caller's
+ * wait without cancelling shared route recovery.
  */
 export interface WorkspaceLspRuntime extends WorkspaceLspDiagnosticSurface {
   hover(
@@ -68,9 +68,11 @@ export interface WorkspaceLspRuntime extends WorkspaceLspDiagnosticSurface {
     filePath: string,
     control?: CodeRequestControl,
   ): Promise<CodeQueryResult<DocumentSymbol[] | SymbolInformation[]>>;
+  /** Collect symbols from routes that can contribute within the optional path scopes. */
   workspaceSymbol(
     query: string,
     control?: CodeRequestControl,
+    scopes?: readonly string[],
   ): Promise<CodeQueryResult<SymbolInformation[] | WorkspaceSymbol[]>>;
   rename(
     filePath: string,

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

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-code-runtime",
-  "version": "6.0.1",
+  "version": "6.1.0",
   "description": "Shared workspace context and capability contracts for code intelligence",
   "license": "MIT",
   "repository": {

package/node_modules/@mrclrchtr/supi-tree-sitter/node_modules/@mrclrchtr/supi-code-runtime/src/capability/types.ts

@@ -75,9 +75,14 @@ export interface SemanticProvider {
     filePath: string,
     control?: CodeRequestControl,
   ): Promise<CodeQueryResult<DocumentCodeSymbol[]>>;
+  /**
+   * Collect workspace symbols from routes that can contribute within the
+   * optional canonical path scopes.
+   */
   workspaceSymbols(
     query: string,
     control?: CodeRequestControl,
+    scopes?: readonly string[],
   ): Promise<CodeQueryResult<CodeSymbol[]>>;
 
   /** Optional definition capability with explicit completed-empty semantics. */

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

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-core",
-  "version": "6.0.1",
+  "version": "6.1.0",
   "description": "Shared settings, configuration, reporting, and session infrastructure",
   "license": "MIT",
   "repository": {

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

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-tree-sitter",
-  "version": "6.0.1",
+  "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-code-runtime": "6.0.1",
-    "@mrclrchtr/supi-core": "6.0.1"
+    "@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.1",
+  "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.1",
-    "@mrclrchtr/supi-tree-sitter": "6.0.1",
-    "@mrclrchtr/supi-lsp": "6.0.1",
-    "@mrclrchtr/supi-core": "6.0.1"
+    "@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)
+  );
+}