@mrclrchtr/supi-code-intelligence 6.1.0 → 6.3.0

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 {
+  emptyProcessCrashRecoveryReport,
+  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 ?? emptyProcessCrashRecoveryReport(),
       staleAssessment: {
         scope: "file",
         suspected: null,
@@ -95,6 +107,7 @@ async function collectWorkspaceRefreshAttempt(
         requestedDiagnosticScope: options.diagnosticsScope,
         operationScope: "workspace-runtime",
         diagnosticEvidence: maintenance.diagnosticEvidence,
+        processCrashRecovery: emptyProcessCrashRecoveryReport(),
         reason: maintenance.failureReason,
       },
     };
@@ -126,7 +139,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,
@@ -141,6 +163,7 @@ async function collectWorkspaceRefreshAttempt(
         operationScope: "workspace-runtime",
         attemptedActiveClients: recovery.attemptedClients,
         restartedClients: recovery.restartedClients,
+        processCrashRecovery: recovery.processCrashRecovery,
         diagnosticEvidence,
         staleAssessment: {
           scope: "workspace",
@@ -163,6 +186,7 @@ async function collectWorkspaceRefreshAttempt(
         requestedDiagnosticScope: options.diagnosticsScope,
         operationScope: "workspace-runtime",
         diagnosticEvidence: maintenance.diagnosticEvidence,
+        processCrashRecovery: emptyProcessCrashRecoveryReport(),
         reason: errorMessage(error),
       },
     };

package/src/session/health-types.ts

@@ -1,6 +1,7 @@
 import type {
   DiagnosticEvidenceSummary,
   FileScopeDecision,
+  ProcessCrashRecoveryReport,
   ProjectServerInfo,
   ProjectServerStatusReason,
 } from "@mrclrchtr/supi-lsp/api";
@@ -93,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";
@@ -103,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: ProcessCrashRecoveryReport;
   readonly staleAssessment: HealthStaleAssessment;
 }
 
@@ -125,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?: ProcessCrashRecoveryReport;
+      /** File readiness outcome, when a file-scoped attempt failed. */
+      readonly fileReadiness?: HealthFileReadiness;
       readonly reason: string;
     };
 

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/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);

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,8 @@ 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:
+            "Comma-separated gitignore patterns for automatic LSP workspace work. Exact file requests stay available.",
         },
         {
           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;
+}