@mrclrchtr/supi-lsp 7.4.0 → 8.0.1

package/README.md

@@ -46,7 +46,7 @@ SuPi advertises static and dynamic pull support. It advertises server-requested
 
 A server gets pull diagnostics when it declares a valid `diagnosticProvider` during initialization. A server also gets pull diagnostics after it registers `textDocument/diagnostic`. The pull support stays active until the server removes the registration. SuPi validates registration parameters. Invalid parameters do not enable pull support. SuPi ignores other registration methods.
 
-When a server sends `workspace/diagnostic/refresh`, SuPi returns `null` immediately. It then invalidates diagnostic evidence only and refreshes the owning client's tracked documents in the background. Unchanged open documents keep their input synchronization; SuPi sends no no-op `didChange`, `didClose`, or `didOpen`. It uses native pull or the tested TypeScript request adapter when available. Push-only routes keep partial or unconfirmed evidence. Actual disk changes use the normal document synchronization path. Overlapping refresh requests share one active pass and one newer pending demand; an active diagnostic transport stays owned until it settles. The refresh covers open, cached, and failed tracked documents. SuPi does not add workspace-wide `workspace/diagnostic` pulls.
+When a server sends `workspace/diagnostic/refresh`, SuPi returns `null` immediately. It then invalidates diagnostic evidence only and refreshes the owning client's tracked documents in the background. Unchanged open documents keep their input synchronization; SuPi sends no no-op `didChange`, `didClose`, or `didOpen`. It uses native pull or the tested TypeScript request adapter when available. Push-only routes keep partial or unconfirmed evidence. Actual disk changes use the normal document synchronization path, followed by one `didSave` when the server requested saves; repeated observations of the same content send no duplicate save. Overlapping refresh requests share one active pass and one newer pending demand; an active diagnostic transport stays owned until it settles. The refresh covers open, cached, and failed tracked documents. SuPi does not add workspace-wide `workspace/diagnostic` pulls.
 
 Protocol support is separate from the configured mode. A server may support pull diagnostics and still use SuPi's push mode because the built-in configuration does not enable pull mode.
 
@@ -108,25 +108,27 @@ Gopls pull diagnostics stay opt-in while golang/go#70199 is open; without the op
 
 Automatic LSP work uses one path policy that does not change for each workspace runtime. It covers project discovery, route startup, warm-up, sentinel and source-file lists, created-file tracking, runtime guidance, and diagnostic summaries not tied to one request.
 
-The policy excludes these directories by default: `.git`, `.cache`, `.pi`, `.pnpm`, `node_modules`, `dist`, `build`, `out`, `coverage`, `.next`, `.nuxt`, `.turbo`, and `__pycache__`. It also applies `lsp.exclude` patterns and root or nested `.gitignore` rules. Patterns use gitignore syntax, including rules relative to each directory and `!` rules. Built-in exclusions cannot be enabled again. Symbolic-link directories are not visited. Other dot-directories, such as `.github` and `.storybook`, remain allowed.
+The policy excludes these directories by default: `.git`, `.cache`, `.pi`, `.pnpm`, `node_modules`, `dist`, `build`, `out`, `coverage`, `.next`, `.nuxt`, `.turbo`, and `__pycache__`. It also applies `code-intelligence.exclude` patterns and root or nested `.gitignore` rules. Patterns use gitignore syntax, including rules relative to each directory and `!` rules. Built-in exclusions cannot be enabled again. Symbolic-link directories are not visited. Other dot-directories, such as `.github` and `.storybook`, remain allowed.
 
-Set `lsp.exclude` in project or global SuPi configuration:
+Set `code-intelligence.exclude` in project or global SuPi configuration. A project list replaces the global list; `[]` clears configured patterns. Use `/supi-settings` to edit this shared list when the settings extension is installed. Reload or restart Pi after saving:
 
 ```json
 {
-  "lsp": {
+  "code-intelligence": {
     "exclude": ["generated/**", "!generated/keep.ts"]
   }
 }
 ```
 
+An old `lsp.exclude` value is a migration error. Move it to `code-intelligence.exclude`; SuPi does not edit personal configuration for you.
+
 An exact semantic request can still route an excluded file when a compatible server is available. This does not add the file to automatic work. Configured diagnostic suppression still applies to diagnostic output.
 
 Tsconfig and jsconfig filtering applies only to TypeScript and JavaScript-family files (`.ts`, `.tsx`, `.mts`, `.cts`, `.js`, `.jsx`, `.mjs`, and `.cjs`). Other-language diagnostics are not filtered by a nearby TypeScript or JavaScript project config. Automatic path exclusions and configured diagnostic suppression still apply. A single-file health result omits the `Tsconfig` coverage line for other languages.
 
 ### Custom server configuration
 
-A custom server needs a command and at least one file type:
+A custom server needs a command and at least one file type. Advanced server settings are JSON objects. They replace inherited settings as a whole; `initializationOptions` remains a separate initialize value:
 
 ```json
 {
@@ -137,6 +139,7 @@ A custom server needs a command and at least one file type:
         "args": ["--stdio"],
         "fileTypes": ["custom"],
         "env": { "CUSTOM_LSP_LOG": "debug" },
+        "settings": { "custom": { "mode": "project" } },
         "initializationOptions": { "mode": "project" }
       }
     }
@@ -144,6 +147,14 @@ A custom server needs a command and at least one file type:
 }
 ```
 
+Server settings use one snapshot for the active workspace runtime:
+
+- An omitted `settings` field inherits the earlier object. `settings: {}` clears inherited settings.
+- `workspace/configuration` reads that snapshot. A request without a section receives the complete object; an unknown section receives `null`.
+- A configured snapshot is also sent through `workspace/didChangeConfiguration` after initialization.
+- SuPi validates the JSON object shape, not server-specific setting names or values.
+- Saved changes apply after reload or restart. A saved value does not prove that the server accepted it.
+
 File types do not include a leading dot. If `rootMarkers` is omitted, the server uses the session root.
 
 Disable one language with `lsp.servers.<language>.enabled: false`. Use `/supi-ci-status` from `@mrclrchtr/supi-code-intelligence` to see detected, running, and missing servers.
@@ -155,6 +166,18 @@ Disable one language with `lsp.servers.<language>.enabled: false`. Use `/supi-ci
 - explicit ready, pending, inactive, disabled, and unavailable registry states
 - a `SemanticProvider` adapter for `supi-code-runtime`
 - precise rename and code-action edit conversion
+- operation-specific code-action kind filters and standard lazy edit resolution
+- negotiated operation support in project-server status
+
+Operation-specific planners request `source.organizeImports` for import updates and
+`source.removeUnused` for dead-code removal. They match the returned `CodeAction.kind`,
+not its title. Edit-only actions are validated before planning. Command actions,
+resource operations, snippets, annotations, malformed actions, and stale responses
+stay unavailable. Distinct matching plans return an ambiguous result instead of
+selecting the first action. Rename uses `prepareRename` when the server advertises
+it and otherwise uses direct standard rename. Standard LSP does not provide
+a safe exact extraction-name contract, so `extract_function` and `extract_variable`
+plans report a SuPi planning limitation instead of selecting a generated name.
 
 Clients, `LspManager`, and the default runtime implementation remain internal.
 
@@ -164,7 +187,7 @@ Clients, `LspManager`, and the default runtime implementation remain internal.
 
 - language-server detection and startup
 - shutdown
-- settings and missing-server inventory
+- server configuration and missing-server inventory
 - publishing workspace runtime state and aggregate lifecycle transitions
 - projecting concrete client readiness into semantic capability state
 

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

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

package/node_modules/@mrclrchtr/supi-code-runtime/src/api.ts

@@ -14,7 +14,7 @@ export type {
   StructuralProvider,
   StructuralResult,
 } from "./capability/types.ts";
-export type { CodeQueryResult } from "./query-result.ts";
+export type { CodeQueryPartialMetadata, CodeQueryResult } from "./query-result.ts";
 // Shared query-result constructors and contract
 export {
   completedCodeQuery,

package/node_modules/@mrclrchtr/supi-code-runtime/src/query-result.ts

@@ -1,3 +1,12 @@
+/** Structured metadata for a partial query result. */
+export interface CodeQueryPartialMetadata {
+  /** Automatic path-policy evidence removed from a collected result. */
+  readonly automaticPathExclusion?: {
+    readonly excludedCount: number;
+    readonly examples: readonly string[];
+  };
+}
+
 /**
  * Result of a read-only code-provider query.
  *
@@ -8,7 +17,12 @@
  */
 export type CodeQueryResult<T> =
   | { readonly kind: "completed"; readonly data: T }
-  | { readonly kind: "partial"; readonly data: T; readonly reason: string }
+  | {
+      readonly kind: "partial";
+      readonly data: T;
+      readonly reason: string;
+      readonly metadata?: CodeQueryPartialMetadata;
+    }
   | { readonly kind: "unavailable"; readonly reason: string };
 
 /** Construct a successfully completed code-query result, including empty data. */
@@ -17,8 +31,12 @@ export function completedCodeQuery<T>(data: T): CodeQueryResult<T> {
 }
 
 /** Construct a usable but incomplete code-query result. */
-export function partialCodeQuery<T>(data: T, reason: string): CodeQueryResult<T> {
-  return { kind: "partial", data, reason };
+export function partialCodeQuery<T>(
+  data: T,
+  reason: string,
+  metadata?: CodeQueryPartialMetadata,
+): CodeQueryResult<T> {
+  return { kind: "partial", data, reason, ...(metadata ? { metadata } : {}) };
 }
 
 /** Construct a code-query result that could not be established. */
@@ -35,7 +53,7 @@ export function mapCodeQueryResult<T, U>(
     case "completed":
       return completedCodeQuery(map(result.data));
     case "partial":
-      return partialCodeQuery(map(result.data), result.reason);
+      return partialCodeQuery(map(result.data), result.reason, result.metadata);
     case "unavailable":
       return unavailableCodeQuery(result.reason);
   }

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

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

package/node_modules/@mrclrchtr/supi-core/src/config/config.ts

@@ -70,6 +70,116 @@ export interface SupiConfigOptions {
   homeDir?: string;
 }
 
+/** Options for loading automatic code-intelligence exclusions. */
+export interface AutomaticExclusionOptions extends SupiConfigOptions {
+  /** Whether the project config is trusted and can apply. Defaults to true. */
+  projectTrusted?: boolean;
+}
+
+/**
+ * Load the one configured exclusion list shared by automatic LSP work and
+ * broad AST searches.
+ *
+ * Project values replace global values. An explicit empty project list clears
+ * the global list. The old `lsp.exclude` key is rejected in every applicable
+ * scope so automatic work cannot start without its former protection.
+ */
+export function loadAutomaticExclusionPatterns(
+  cwd: string,
+  options: AutomaticExclusionOptions = {},
+): readonly string[] {
+  const projectTrusted = options.projectTrusted !== false;
+  const globalCodeIntelligence = loadSupiConfigSectionForScope("code-intelligence", cwd, {
+    scope: "global",
+    homeDir: options.homeDir,
+  });
+  const projectCodeIntelligence = projectTrusted
+    ? loadSupiConfigSectionForScope("code-intelligence", cwd, { scope: "project" })
+    : null;
+  const globalLsp = loadSupiConfigSectionForScope("lsp", cwd, {
+    scope: "global",
+    homeDir: options.homeDir,
+  });
+  const projectLsp = projectTrusted
+    ? loadSupiConfigSectionForScope("lsp", cwd, { scope: "project" })
+    : null;
+
+  const legacyPath = findLegacyExclusionPath(cwd, options, globalLsp, projectLsp);
+  if (legacyPath) {
+    throw new Error(
+      `Unsupported ${legacyPath.scope} configuration at ${legacyPath.path}: "lsp.exclude" was removed. Move its value to "code-intelligence.exclude". Automatic LSP and broad AST work did not start; reload after migration.`,
+    );
+  }
+
+  const source = findExclusionSource(cwd, options, {
+    projectTrusted,
+    globalCodeIntelligence,
+    projectCodeIntelligence,
+  });
+  return validateExclusionSource(source);
+}
+
+interface ExclusionSource {
+  value: unknown;
+  path: string;
+}
+
+interface LegacyExclusionPath {
+  scope: "global" | "project";
+  path: string;
+}
+
+function findLegacyExclusionPath(
+  cwd: string,
+  options: AutomaticExclusionOptions,
+  globalLsp: Record<string, unknown> | null,
+  projectLsp: Record<string, unknown> | null,
+): LegacyExclusionPath | null {
+  if (globalLsp && Object.hasOwn(globalLsp, "exclude")) {
+    return { scope: "global", path: getSupiConfigPath("global", cwd, options) };
+  }
+  if (projectLsp && Object.hasOwn(projectLsp, "exclude")) {
+    return { scope: "project", path: getSupiConfigPath("project", cwd) };
+  }
+  return null;
+}
+
+function findExclusionSource(
+  cwd: string,
+  options: AutomaticExclusionOptions,
+  sections: {
+    projectTrusted: boolean;
+    globalCodeIntelligence: Record<string, unknown> | null;
+    projectCodeIntelligence: Record<string, unknown> | null;
+  },
+): ExclusionSource | null {
+  const { projectTrusted, globalCodeIntelligence, projectCodeIntelligence } = sections;
+  if (
+    projectTrusted &&
+    projectCodeIntelligence &&
+    Object.hasOwn(projectCodeIntelligence, "exclude")
+  ) {
+    return { value: projectCodeIntelligence.exclude, path: getSupiConfigPath("project", cwd) };
+  }
+  if (globalCodeIntelligence && Object.hasOwn(globalCodeIntelligence, "exclude")) {
+    return {
+      value: globalCodeIntelligence.exclude,
+      path: getSupiConfigPath("global", cwd, options),
+    };
+  }
+  return null;
+}
+
+function validateExclusionSource(source: ExclusionSource | null): readonly string[] {
+  if (!source) return Object.freeze([]);
+  if (!Array.isArray(source.value) || !source.value.every((entry) => typeof entry === "string")) {
+    throw new Error(
+      `Invalid "code-intelligence.exclude" in ${source.path}: expected an array of gitignore-style strings. Automatic LSP and broad AST work did not start.`,
+    );
+  }
+  return Object.freeze([...source.value]);
+}
+
 /**
  * Load and merge config for a given extension section.
  *

package/node_modules/@mrclrchtr/supi-core/src/config.ts

@@ -1,7 +1,12 @@
 // supi-core config domain — config loading.
-export type { SupiConfigLocation, SupiConfigOptions } from "./config/config.ts";
+export type {
+  AutomaticExclusionOptions,
+  SupiConfigLocation,
+  SupiConfigOptions,
+} from "./config/config.ts";
 export {
   getSupiConfigPath,
+  loadAutomaticExclusionPatterns,
   loadSupiConfig,
   loadSupiConfigForScope,
   loadSupiConfigSectionForScope,

package/node_modules/@mrclrchtr/supi-core/src/settings/settings-schema.ts

@@ -151,6 +151,7 @@ export interface CustomField extends BaseField {
     cwd: string,
     action: SettingsAction,
     helpers: ConfigHelpers,
+    ctx?: ExtensionContext,
   ) => void | Promise<void>;
 }
 
@@ -404,7 +405,7 @@ async function applyConfigAction(
   const helpers = createConfigHelpers(options.section, scope, cwd, options.homeDir);
   let storedValue: unknown;
   if (field.kind === "custom") {
-    await field.persist(scope, cwd, action, helpers);
+    await field.persist(scope, cwd, action, helpers, ctx);
     storedValue = action.kind === "set" ? action.value : undefined;
   } else if (action.kind === "set") {
     storedValue = parseTypedValue(action.value, field);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-lsp",
-  "version": "7.4.0",
+  "version": "8.0.1",
   "description": "Language Server Protocol runtime for SuPi code intelligence",
   "license": "MIT",
   "repository": {
@@ -37,8 +37,8 @@
     "vscode-jsonrpc": "^9.0.0",
     "vscode-languageserver-protocol": "^3.18.0",
     "vscode-languageserver-types": "^3.18.0",
-    "@mrclrchtr/supi-core": "7.4.0",
-    "@mrclrchtr/supi-code-runtime": "7.4.0"
+    "@mrclrchtr/supi-code-runtime": "8.0.1",
+    "@mrclrchtr/supi-core": "8.0.1"
   },
   "bundledDependencies": [
     "@mrclrchtr/supi-code-runtime",

package/src/api.ts

@@ -1,9 +1,22 @@
 // Public API surface for the LSP session-scoped service.
 
 export { isMissingFileError } from "./client/client-file-state.ts";
-export { type LoadConfigOptions, loadConfig } from "./config/config.ts";
-export type { LspSettings } from "./config/lsp-settings.ts";
-export { loadLspSettings } from "./config/lsp-settings.ts";
+export {
+  getExplicitlyDisabledLanguages,
+  type LoadConfigOptions,
+  loadConfig,
+} from "./config/config.ts";
+export {
+  codeActionKindsForOperation,
+  getServerOperationSupport,
+  isCodeActionKindInRange,
+  REFACTOR_CODE_ACTION_KINDS,
+  supportsCodeActionResolve,
+  supportsCodeActions,
+  supportsPrepareRename,
+  supportsRename,
+  supportsRequestedCodeActionKinds,
+} from "./config/operation-support.ts";
 export {
   clearTsconfigCache,
   type FileScopeDecision,
@@ -21,6 +34,8 @@ export type {
   DocumentSymbol,
   FileEvent,
   Hover,
+  JsonObject,
+  JsonValue,
   Location,
   LocationLink,
   LspConfig,
@@ -29,6 +44,10 @@ export type {
   ProjectServerInfo,
   ProjectServerStatusReason,
   Range,
+  ServerAdvertisement,
+  ServerOperationName,
+  ServerOperationSupport,
+  ServerOperationSupportMap,
   SymbolInformation,
   WorkspaceEdit,
   WorkspaceSymbol,
@@ -52,6 +71,7 @@ export {
 export { raceReadinessValue, raceRequestControl } from "./session/readiness.ts";
 export type {
   LspControllerState,
+  LspRuntimeControllerOptions,
   LspRuntimeTransition,
   LspRuntimeTransitionKind,
   LspRuntimeTransitionListener,
@@ -77,6 +97,7 @@ export type {
   StartupRetryNextAction,
   StartupRetryOutcome,
   StartupRetryReport,
+  WorkspaceCodeActionRequestOptions,
   WorkspaceDiagnosticReport,
   WorkspaceDiagnosticSnapshot,
   WorkspaceDiagnosticSummaryEntry,
@@ -98,6 +119,7 @@ export { MAX_BULK_TRACK_FILES } from "./session/workspace-lsp-runtime.ts";
 export {
   AUTOMATIC_LSP_EXCLUDED_DIRECTORIES,
   type AutomaticLspPathPolicy,
+  type AutomaticLspPathPolicyOptions,
   createAutomaticLspPathPolicy,
   createDefaultAutomaticLspPathPolicy,
 } from "./workspace-path-policy.ts";

package/src/client/client-diagnostic-host.ts

@@ -1,4 +1,5 @@
 import type { DiagnosticRequestAdapter } from "./client-diagnostic-request.ts";
+import type { NormalizedDocumentSync } from "./client-document-sync.ts";
 
 /** Transport and capability operations required by diagnostic state. */
 export interface ClientDiagnosticsHost {
@@ -9,6 +10,6 @@ export interface ClientDiagnosticsHost {
   isOperational(): boolean;
   /** Native pull and server-specific request evidence share this priority adapter. */
   diagnosticRequestAdapter: DiagnosticRequestAdapter;
-  usesIncrementalDocumentSync(): boolean;
+  documentSync(): NormalizedDocumentSync;
   sendNotification(method: string, params: unknown): void;
 }

package/src/client/client-diagnostic-refresh.ts

@@ -289,7 +289,9 @@ interface ClientDiagnosticRefreshOptions {
   /** Invalidate route evidence before applying a disk content change. */
   readonly noteInputContentChange: () => number;
   /** Keep the shared semantic barrier's verified disk observation current. */
-  readonly observeDiskContent: (uri: string, content: string) => void;
+  readonly observeDiskContent: (uri: string, content: string) => boolean;
+  /** Send one save for an externally observed disk change. */
+  readonly noteExternalDiskChange: (uri: string, content: string) => void;
   readonly clearFile: (uri: string) => void;
   readonly invalidateEvidence: (uri: string) => void;
   readonly markUnversionedSyncMoment: (uri: string) => void;
@@ -343,9 +345,10 @@ function prepareRefreshDocuments(
     nextVersion: (uri) => nextDocumentVersion(options.versionHistory, uri),
     nextSynchronizationId: options.nextSynchronizationId,
     evidenceRevision,
+    documentSync: options.host.documentSync(),
     noteInputContentChange: options.noteInputContentChange,
     observeDiskContent: options.observeDiskContent,
-    incrementalSync: options.host.usesIncrementalDocumentSync(),
+    noteExternalDiskChange: options.noteExternalDiskChange,
     sendNotification: (method, params) => options.host.sendNotification(method, params),
     uriToFile,
     preloadedContent: classification.preloadedContent,

package/src/client/client-diagnostics.ts

@@ -1,4 +1,5 @@
 // biome-ignore-all lint/style/noExcessiveLinesPerFile: one client's document sync, diagnostics, refresh, and sync-file flow stay in one cohesive class.
+import { readFileSync } from "node:fs";
 import * as path from "node:path";
 import {
   type CodeQueryResult,
@@ -116,6 +117,8 @@ export class ClientDiagnostics {
       isOperational: () => this.host.isOperational(),
       getOpenDocuments: () => this.#getSemanticInputDocuments(),
       applyDocumentUpdates: (updates) => this.#applySemanticInputUpdates(updates),
+      noteExternalDiskChange: (filePath, content) =>
+        this.#noteExternalDiskChange(filePath, content),
       closeMissingDocument: (filePath) => this.didClose(filePath),
       markUnreadableDocument: (filePath) => this.markFailedFile(filePath),
     });
@@ -200,7 +203,7 @@ export class ClientDiagnostics {
       nextVersion: () => nextDocumentVersion(this.#versionHistory, uri),
       nextSynchronizationId: () => ++this.#nextSynchronizationId,
       evidenceRevision: this.#evidenceRevision,
-      incrementalSync: this.host.usesIncrementalDocumentSync(),
+      documentSync: this.host.documentSync(),
       waiters: this.#waiters,
       sendNotification: (method, params) => this.host.sendNotification(method, params),
       markUnversionedSyncMoment: () => this.#unversionedPushSyncMoments.set(uri, Date.now()),
@@ -213,10 +216,6 @@ export class ClientDiagnostics {
     this.#inputBarrier.initializeDocumentContent(uri, content);
   }
 
-  #observeDiskContent(uri: string, content: string): void {
-    this.#inputBarrier.observeDiskContent(uri, content);
-  }
-
   #forgetDocumentContent(uri: string): void {
     this.#inputBarrier.forgetDocumentContent(uri);
   }
@@ -333,6 +332,38 @@ export class ClientDiagnostics {
     this.#synchronizeTrackedDocument(uri, filePath, content, doc);
   }
 
+  /** Send a save after a disk change that the input barrier observed. */
+  #noteExternalDiskChange(filePath: string, content: string): void {
+    if (!this.host.isOperational()) return;
+    const documentSync = this.host.documentSync();
+    if (!documentSync.save) return;
+    this.host.sendNotification("textDocument/didSave", {
+      textDocument: { uri: fileToUri(filePath) },
+      ...(documentSync.includeText ? { text: content } : {}),
+    });
+  }
+
+  /** Synchronize and notify one tracked document after an observed disk write. */
+  noteWorkspaceWrite(filePath: string): void {
+    if (!this.host.isOperational()) return;
+
+    const uri = fileToUri(filePath);
+    const document = this.#openDocs.get(uri);
+    if (!document) return;
+
+    let content: string;
+    try {
+      content = readFileSync(filePath, "utf-8");
+    } catch {
+      return;
+    }
+    const diskChanged = this.#inputBarrier.observeDiskContent(uri, content);
+    if (document.contentFingerprint !== fingerprintDocumentContent(content)) {
+      this.didChange(filePath, content);
+    }
+    if (diskChanged) this.#noteExternalDiskChange(filePath, content);
+  }
+
   didClose(filePath: string): void {
     const uri = fileToUri(filePath);
     const wasOpen = this.#openDocs.has(uri);
@@ -527,7 +558,9 @@ export class ClientDiagnostics {
       isRelatedUriTracked: (uri) => this.#openDocs.has(uri) || this.#versionHistory.has(uri),
       nextSynchronizationId: () => ++this.#nextSynchronizationId,
       noteInputContentChange: () => this.#noteInputContentChange(),
-      observeDiskContent: (uri, content) => this.#observeDiskContent(uri, content),
+      observeDiskContent: (uri, content) => this.#inputBarrier.observeDiskContent(uri, content),
+      noteExternalDiskChange: (uri, content) =>
+        this.#noteExternalDiskChange(uriToFile(uri), content),
       invalidateEvidence: (uri) => {
         this.#advanceInputRevision(false, true, "failure");
         this.#cancelDiagnosticRequest(uri);