@mrclrchtr/supi-code-intelligence 6.0.1 → 6.2.0

package/src/analysis/search/ast-scan.ts

@@ -150,7 +150,7 @@ export async function enumerateAstFiles(
 class AstFileEnumerator {
   readonly #operations: AstScanOperations;
   readonly #now: () => number;
-  readonly #grammarExtensions = new Set(getSupportedExtensions());
+  readonly #grammarExtensions: ReadonlySet<string> = new Set(getSupportedExtensions());
   readonly #operationExtensions: ReadonlySet<string>;
   readonly #files = new Set<string>();
   readonly #visitedDirectories = new Set<string>();

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/api.ts

@@ -48,6 +48,7 @@ export type {
 export type {
   HealthDiagnosticObservation,
   HealthDiagnosticScope,
+  HealthFileReadiness,
   HealthRefreshAttempt,
   HealthRefreshState,
   HealthStaleAssessment,

package/src/extension.ts

@@ -6,8 +6,10 @@ import type {
   ExtensionAPI,
   ExtensionContext,
 } from "@earendil-works/pi-coding-agent";
-import { recordDebugEvent } from "@mrclrchtr/supi-core/debug";
-import { truncateIdentity } from "@mrclrchtr/supi-lsp/debug-telemetry";
+import {
+  recordDebugEvent,
+  truncateDebugIdentity as truncateIdentity,
+} from "@mrclrchtr/supi-core/debug";
 import { buildArchitectureModel } from "./analysis/architecture/discovery.ts";
 import { createCodeIntelligenceApp } from "./app/app.ts";
 import { registerCodeIntelligenceSettings, resolveOverviewEnabled } from "./config.ts";

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

@@ -2,11 +2,19 @@ import {
   type CodeRequestControl,
   isCodeRequestInterruption,
 } from "@mrclrchtr/supi-code-runtime/api";
-import type { WorkspaceDiagnosticReport, WorkspaceLspRuntime } from "@mrclrchtr/supi-lsp/api";
+import {
+  emptyProcessCrashRecoverySummary,
+  type WorkspaceDiagnosticReport,
+  type WorkspaceLspRuntime,
+} from "@mrclrchtr/supi-lsp/api";
 import { recoverDiagnosticRuntime } from "../analysis/health/recovery.ts";
 import { mergeDiagnosticEvidence } from "../diagnostics/evidence.ts";
 import { refreshFileLspMaintenance, refreshLspMaintenance } from "../substrate/lsp/maintenance.ts";
-import type { HealthDiagnosticScope, HealthRefreshAttempt } from "./health-types.ts";
+import type {
+  HealthDiagnosticScope,
+  HealthFileReadiness,
+  HealthRefreshAttempt,
+} from "./health-types.ts";
 
 interface HealthRefreshAttemptOptions {
   readonly runtime: WorkspaceLspRuntime;
@@ -51,6 +59,8 @@ async function collectFileRefreshAttempt(
     undefined,
     options.control,
   );
+  const fileReadiness: HealthFileReadiness =
+    readiness.kind === "ready" ? "ready" : readiness.kind === "timeout" ? "pending" : "unavailable";
   return {
     attempt: {
       kind: "completed",
@@ -59,7 +69,9 @@ async function collectFileRefreshAttempt(
       requestedDiagnosticScope: scope,
       operationScope: "file-runtime",
       attemptedActiveClients: readiness.kind === "ready" ? 1 : 0,
+      fileReadiness,
       restartedClients: 0,
+      processCrashRecovery: readiness.processCrashRecovery ?? emptyProcessCrashRecoverySummary(),
       staleAssessment: {
         scope: "file",
         suspected: null,
@@ -105,9 +117,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,
@@ -122,7 +138,16 @@ async function collectWorkspaceRefreshAttempt(
           elapsedMs: Date.now() - options.attemptedAt,
           requestedDiagnosticScope: options.diagnosticsScope,
           operationScope: "workspace-runtime",
+          attemptedActiveClients: recovery.attemptedClients,
+          restartedClients: recovery.restartedClients,
+          staleAssessment: {
+            scope: "workspace",
+            suspected: recovery.staleAssessment.suspected,
+            matchedFileCount: recovery.staleAssessment.matchedFiles.length,
+            warning: recovery.staleAssessment.warning,
+          },
           diagnosticEvidence,
+          processCrashRecovery: recovery.processCrashRecovery,
           reason: recovery.refreshFailureReason,
         },
         diagnosticReport: recovery.diagnosticReport,
@@ -137,6 +162,7 @@ async function collectWorkspaceRefreshAttempt(
         operationScope: "workspace-runtime",
         attemptedActiveClients: recovery.attemptedClients,
         restartedClients: recovery.restartedClients,
+        processCrashRecovery: recovery.processCrashRecovery,
         diagnosticEvidence,
         staleAssessment: {
           scope: "workspace",

package/src/session/health-types.ts

@@ -1,4 +1,10 @@
-import type { DiagnosticEvidenceSummary, FileScopeDecision } from "@mrclrchtr/supi-lsp/api";
+import type {
+  DiagnosticEvidenceSummary,
+  FileScopeDecision,
+  ProcessCrashRecoverySummary,
+  ProjectServerInfo,
+  ProjectServerStatusReason,
+} from "@mrclrchtr/supi-lsp/api";
 import type { CapabilityWarningReport } from "../analysis/capability/capability-warnings.ts";
 
 export type HealthSection = "diagnostics" | "servers";
@@ -22,7 +28,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;
 }
 
@@ -87,6 +94,9 @@ export interface HealthStaleAssessment {
 
 export type HealthRefreshOperationScope = "file-runtime" | "workspace-runtime";
 
+/** Readiness result for a file-scoped maintenance attempt. */
+export type HealthFileReadiness = "ready" | "pending" | "unavailable";
+
 /** Shared facts for one completed refresh or file-maintenance attempt. */
 interface CompletedHealthRefreshAttempt {
   readonly kind: "completed";
@@ -97,7 +107,12 @@ interface CompletedHealthRefreshAttempt {
   readonly requestedDiagnosticScope: HealthDiagnosticScope;
   /** Active clients targeted by the best-effort operation; this is not a confirmed-success count. */
   readonly attemptedActiveClients: number;
+  /** File readiness after the bounded wait, when this is file-scoped. */
+  readonly fileReadiness?: HealthFileReadiness;
+  /** Clients restarted by stale-diagnostic recovery. */
   readonly restartedClients: number;
+  /** Separate outcome for process-crash route recovery. */
+  readonly processCrashRecovery: ProcessCrashRecoverySummary;
   readonly staleAssessment: HealthStaleAssessment;
 }
 
@@ -119,8 +134,18 @@ export type HealthRefreshAttempt =
       readonly elapsedMs: number;
       readonly requestedDiagnosticScope: HealthDiagnosticScope;
       readonly operationScope: HealthRefreshOperationScope;
+      /** Active clients targeted before the operation failed, when available. */
+      readonly attemptedActiveClients?: number;
+      /** Clients restarted by stale-diagnostic recovery, when available. */
+      readonly restartedClients?: number;
+      /** Stale-diagnostic assessment, when the recovery pass returned one. */
+      readonly staleAssessment?: HealthStaleAssessment;
       /** Evidence collected before the operation failed, when available. */
       readonly diagnosticEvidence?: DiagnosticEvidenceSummary;
+      /** Process-crash outcome, when the recovery pass returned one. */
+      readonly processCrashRecovery?: ProcessCrashRecoverySummary;
+      /** File readiness outcome, when a file-scoped attempt failed. */
+      readonly fileReadiness?: HealthFileReadiness;
       readonly reason: string;
     };
 

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/input/health-refactor.ts

@@ -1,11 +1,12 @@
 /** Runtime parsers for health and refactor session workflows. */
 
 import type { HealthSection, HealthWorkflowInput } from "../health-types.ts";
-import type {
-  PublicSourceRange,
-  RefactorApplyWorkflowInput,
-  RefactorOperationInput,
-  RefactorPlanWorkflowInput,
+import {
+  PUBLIC_REFACTOR_OPERATION_NAMES,
+  type PublicSourceRange,
+  type RefactorApplyWorkflowInput,
+  type RefactorOperationInput,
+  type RefactorPlanWorkflowInput,
 } from "../refactor-types.ts";
 import type { RefactorTargetInput } from "../target-input.ts";
 import {
@@ -94,22 +95,23 @@ export function parseRefactorPlanWorkflowInput(
 function parseRefactorOperation(value: unknown): InputValidation<RefactorOperationInput> {
   const record = requireRecord(value, "operation");
   if (record.kind === "invalid-input") return record;
-  const keysError = requireOnlyKeys(
-    record.value,
-    ["rename_symbol", "extract_function", "extract_variable"],
-    "operation",
-  );
+  const keysError = requireOnlyKeys(record.value, PUBLIC_REFACTOR_OPERATION_NAMES, "operation");
   if (keysError) return invalid(keysError);
-  const selected = (["rename_symbol", "extract_function", "extract_variable"] as const).filter(
-    (key) => record.value[key] !== undefined,
-  );
+  const selected = PUBLIC_REFACTOR_OPERATION_NAMES.filter((key) => record.value[key] !== undefined);
   if (selected.length !== 1) return invalid("Select exactly one refactor operation.");
 
   const name = selected[0];
   const payload = requireRecord(record.value[name], `operation.${name}`);
   if (payload.kind === "invalid-input") return payload;
   if (name === "rename_symbol") return parseRenameOperation(payload.value);
-  return parseExtractOperation(name, payload.value);
+  if (name === "extract_function" || name === "extract_variable") {
+    return parseExtractOperation(name, payload.value);
+  }
+  const payloadError = requireOnlyKeys(payload.value, [], `operation.${name}`);
+  if (payloadError) return invalid(payloadError);
+  return name === "update_imports"
+    ? valid({ update_imports: {} })
+    : valid({ delete_dead_code: {} });
 }
 
 function parseRenameOperation(

package/src/session/refactor-types.ts

@@ -3,6 +3,17 @@ import type { ApplyResult } from "../analysis/refactor/apply.ts";
 import type { RefactorPlan } from "./refactor-plans.ts";
 import type { RefactorTargetInput, SourcePointInput } from "./target-input.ts";
 
+/** Public refactor operations exposed by code_refactor_plan. */
+export const PUBLIC_REFACTOR_OPERATION_NAMES = [
+  "rename_symbol",
+  "extract_function",
+  "extract_variable",
+  "update_imports",
+  "delete_dead_code",
+] as const;
+
+export type PublicRefactorOperationName = (typeof PUBLIC_REFACTOR_OPERATION_NAMES)[number];
+
 export interface PublicSourceRange {
   readonly start: Omit<SourcePointInput, "file">;
   readonly end: Omit<SourcePointInput, "file">;
@@ -21,7 +32,9 @@ export type RefactorOperationInput =
         readonly newName: string;
         readonly range: PublicSourceRange;
       };
-    };
+    }
+  | { readonly update_imports: Record<string, never> }
+  | { readonly delete_dead_code: Record<string, never> };
 
 export interface RefactorPlanWorkflowInput {
   readonly target: RefactorTargetInput;

package/src/session/refactor-workflow.ts

@@ -26,13 +26,14 @@ import {
   isPlanFresh,
   type RefactorPlan,
 } from "./refactor-plans.ts";
-import type {
-  PublicSourceRange,
-  RefactorApplyWorkflowInput,
-  RefactorApplyWorkflowOutcome,
-  RefactorOperationInput,
-  RefactorPlanWorkflowInput,
-  RefactorPlanWorkflowOutcome,
+import {
+  PUBLIC_REFACTOR_OPERATION_NAMES,
+  type PublicSourceRange,
+  type RefactorApplyWorkflowInput,
+  type RefactorApplyWorkflowOutcome,
+  type RefactorOperationInput,
+  type RefactorPlanWorkflowInput,
+  type RefactorPlanWorkflowOutcome,
 } from "./refactor-types.ts";
 import { resolveTargetWorkflow, type TargetWorkflowDeps } from "./target-workflow.ts";
 import { reportProgress, throwIfAborted, type WorkflowControl } from "./workflow-control.ts";
@@ -208,13 +209,11 @@ function parseOperation(input: RefactorOperationInput):
   | {
       kind: "ok";
       operation: RefactorOperation;
-      newName: string;
+      newName?: string;
       range?: PublicSourceRange;
     }
   | { kind: "invalid-input"; message: string } {
-  const keys = ["rename_symbol", "extract_function", "extract_variable"].filter(
-    (key) => key in input,
-  );
+  const keys = PUBLIC_REFACTOR_OPERATION_NAMES.filter((key) => key in input);
   if (keys.length !== 1) {
     return { kind: "invalid-input", message: "Select exactly one refactor operation." };
   }
@@ -233,11 +232,17 @@ function parseOperation(input: RefactorOperationInput):
       range: input.extract_function.range,
     };
   }
+  if ("extract_variable" in input) {
+    return {
+      kind: "ok",
+      operation: "extract_variable",
+      newName: input.extract_variable.newName,
+      range: input.extract_variable.range,
+    };
+  }
   return {
     kind: "ok",
-    operation: "extract_variable",
-    newName: input.extract_variable.newName,
-    range: input.extract_variable.range,
+    operation: "update_imports" in input ? "update_imports" : "delete_dead_code",
   };
 }
 
@@ -265,13 +270,13 @@ async function planWithProvider(
     file: string;
     position: { line: number; character: number };
     range?: SourceRange;
-    newName: string;
+    newName?: string;
   },
   control?: WorkflowControl,
 ): Promise<RefactorResult> {
   if (!provider) return { kind: "unavailable", reason: "No semantic provider is active." };
   if (provider.refactor) return provider.refactor(request, control);
-  if (request.operation === "rename_symbol" && provider.rename) {
+  if (request.operation === "rename_symbol" && request.newName !== undefined && provider.rename) {
     return provider.rename(request.file, request.position, request.newName, control);
   }
   return {

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/substrate/lsp/lifecycle.ts

@@ -45,7 +45,6 @@ export function registerLspSessionLifecycle(
     await state.providerLease?.release();
     state.providerLease = null;
     state.controller = null;
-    state.lspActive = false;
     state.sentinelSnapshot = new Map();
 
     const lease = await acquireWorkspaceProviderHost(ctx.cwd, {
@@ -53,7 +52,6 @@ export function registerLspSessionLifecycle(
     });
     state.providerLease = lease;
     state.controller = lease.lspController;
-    state.lspActive = lease.lspController?.kind === "ready";
     state.sentinelSnapshot = lease.sentinelSnapshot;
     await onStarted?.(ctx);
     startLifecycleSubscription();
@@ -64,7 +62,6 @@ export function registerLspSessionLifecycle(
     await state.providerLease?.release();
     state.providerLease = null;
     state.controller = null;
-    state.lspActive = false;
     state.sentinelSnapshot = new Map();
     dispatchStateChange();
   });

package/src/substrate/lsp/maintenance.ts

@@ -24,7 +24,6 @@ import {
   isLikelyStaleDiagnostic,
   isProjectConfigFileName,
   raceRequestControl,
-  syncWorkspaceSentinelSnapshot,
   type WorkspaceLspRuntime,
 } from "@mrclrchtr/supi-lsp/api";
 import { mergeDiagnosticEvidence } from "../../diagnostics/evidence.ts";
@@ -56,7 +55,7 @@ export async function refreshLspMaintenance(
   sentinelSnapshot: Map<string, number>,
   options: LspMaintenanceOptions = {},
 ): Promise<WorkspaceLspMaintenanceResult> {
-  const { snapshot } = await synchronizeSentinels(runtime, cwd, sentinelSnapshot, options);
+  const { snapshot } = await synchronizeSentinels(runtime, sentinelSnapshot, options);
   let diagnosticEvidence = emptyEvidence();
   let failureReason: string | undefined;
 
@@ -115,7 +114,7 @@ export async function refreshFileLspMaintenance(options: {
   const { runtime, cwd, sentinelSnapshot, filePath, control } = options;
   // A cancelled caller stops before any maintenance work starts.
   throwIfCodeRequestInterrupted(control);
-  const { snapshot } = await synchronizeSentinels(runtime, cwd, sentinelSnapshot);
+  const { snapshot } = await synchronizeSentinels(runtime, sentinelSnapshot);
   const target = nodePath.resolve(filePath);
   const stale = confirmedOutstandingDiagnostics(runtime, cwd).some(
     (entry) =>
@@ -149,12 +148,11 @@ export async function refreshFileLspMaintenance(options: {
  */
 async function synchronizeSentinels(
   runtime: WorkspaceLspRuntime,
-  cwd: string,
   sentinelSnapshot: Map<string, number>,
   options: LspMaintenanceOptions = {},
 ) {
   const primed = sentinelSnapshot.size > 0;
-  const state = syncWorkspaceSentinelSnapshot(cwd, sentinelSnapshot, {
+  const state = runtime.syncWorkspaceSentinelSnapshot(sentinelSnapshot, {
     includeSourceFiles: true,
   });
 
@@ -193,6 +191,7 @@ async function trackCreatedSourceFiles(
     if (change.type !== FileChangeType.Created) continue;
     const filePath = uriToFile(change.uri);
     if (scope && !isWithinOrEqual(scope, filePath)) continue;
+    if (!runtime.isSupportedSourceFile(filePath)) continue;
     // Best-effort: a file no client can serve stays untracked and is
     // simply absent from evidence until a later explicit request.
     await runtime.trackFile(filePath);