@mrclrchtr/supi-lsp 11.2.0 → 11.3.0

package/README.md

@@ -64,6 +64,8 @@ A configured route is not a ready server. Features depend on the active server,
 
 The [operation-support model](src/config/operation-support.ts) separates server advertisement from SuPi planning limits. A server can advertise an action that SuPi cannot safely turn into a plan.
 
+Workspace-symbol scopes select contributing routes and bound query completeness; returned data can still contain out-of-scope rows, which consumers must filter. An automatic-policy exclusion does not make a scoped query partial when both its observed path and physical identity are proven outside every requested scope. In-scope exclusions, aliases that may overlap, unresolved paths, and contributing route failures remain partial. Unscoped queries retain all exclusion evidence. Partial metadata sets `exclusionOnly` when policy exclusions are the only gap, with no route failure or inferred-project coverage gap. Explicitly selected excluded files and directories remain inspectable; when a scoped query returns no row inside any scope, warm-up may open files inside those selected scopes so a server that only indexes opened documents can report them. Automatic path rules and target-uniqueness checks are unchanged.
+
 ### Reference-server acceptance
 
 The [Code Intelligence acceptance suite](../supi-code-intelligence/__tests__/acceptance/language-baseline-harness.ts) exercises public tools against real servers for TypeScript, JavaScript, Python, Java, Go, Rust, C, and C++. Its [pinned Linux/macOS configuration](../../scripts/language-baseline/pins.json) is separate from the built-in route matrix. Qualification remains pending until both pinned CI jobs pass. Missing test prerequisites are failures, not skipped passes.
@@ -161,6 +163,22 @@ Protocol support is separate from the configured mode. A server may support pull
 
 The LSP 3.18 specification adds `Diagnostic.message` markup content, guarded by the client capability `textDocument.diagnostic.markupMessageSupport`; SuPi's validator already accepts plaintext and markdown messages but does not advertise the capability. Other 3.18 features (snippet text edits, inline completion, folding-range refresh, multi-range formatting) are outside the diagnostic surface and are not implemented.
 
+### Texlab diagnostic verification
+
+Verified binary: **Texlab 5.26.0**. This separate verification does not revise the historical audit above or qualify other Texlab versions. The probe advertised pull support, opened a document with a syntax error, and then corrected and saved it.
+
+| Protocol check | Observed result |
+|---|---|
+| Static `diagnosticProvider` | Not advertised |
+| Dynamic `textDocument/diagnostic` registration | None observed |
+| Explicit `textDocument/diagnostic` request | JSON-RPC `-32601` (`method not found`) |
+| `publishDiagnostics` | Publications without a document version |
+| Syntax error → corrected document | Error publication followed by empty publications |
+
+Texlab supplies useful diagnostics through ambient push. SuPi shows observed errors as partial evidence and removes them after a correcting publication, but an empty publication does not confirm a completed clean check. `code_health` therefore keeps the file unconfirmed. A `push-settle` timeout ends the bounded observation window; it is not a failed diagnostic request or proof that Texlab is unresponsive. Longer waits, repeated publications, and restarts do not establish completion.
+
+The [installed Texlab integration test](__tests__/integration/client.integration.texlab.test.ts) covers routing, the absence of a diagnostic provider/request adapter, and unconfirmed coverage. It runs when `texlab` is installed. See [ADR 0022](../../docs/adr/0022-request-confirmed-lsp-agnostic-diagnostics.md) for the unchanged evidence policy.
+
 ### Diagnostic evidence policy
 
 See [`ADR 0022`](../../docs/adr/0022-request-confirmed-lsp-agnostic-diagnostics.md) for the decision record. SuPi uses one shared diagnostic engine with optional internal request adapters. It selects one source for each file:
@@ -185,11 +203,13 @@ Refresh and file collection share synchronization, evidence-revision, deadline,
 
 Caller cancellation or deadline stops only that caller's wait. Explicit diagnostic requests use an owned transport lifetime: supersession drops queued jobs and stops future adapter phases but does not cancel an active protocol request. The route stays occupied until actual settlement or connection disposal. The owner timeout attempts protocol cancellation but does not prove that the backend stopped. The owner bound is at least 30 seconds (or a larger collection budget). A result from an obsolete document generation is discarded. Ordinary semantic requests still pass caller cancellation to the protocol transport.
 
+First document enrollment is admitted between semantic query and refactor-planning attempts on the same current client. Each attempt covers input synchronization, its RPCs, and final acceptance; reads can still run concurrently. A refactor attempt retains admission through `prepareRename`/`rename` or `codeAction`/`resolve` and verified snapshot capture, but releases it before retries and the rename workflow's own cross-file enrollment. FIFO admission prevents later reads from overtaking a waiting first open. At most 32 operations may wait; excess demand fails rather than growing an unbounded queue. Waiting preserves the caller's original signal and absolute deadline, and interrupted operations are removed before they can open a document. Disk content is read after admission. First opens for semantic or refactor demand also discard the caller's original parameters after a known input change; ordinary tracking can still adopt fresh content. Tracked-document updates, closes, workspace changes, and lifecycle invalidation do not wait: they still invalidate active evidence and discard queued request parameters. Closing a file cancels its queued opens, and stopping a client discards its queued work. Admission does not span retries, project warm-up, or whole tool/refactor workflows. Diagnostic transport ownership and confirmation remain separate and unchanged.
+
 If another request first opens a document during an active semantic or diagnostic request, the client can synchronize and repeat the request once. The retry retains the caller's original signal and deadline. Content, workspace, close, and lifecycle changes still reject stale results. A diagnostic retry collects new request evidence; it does not promote an old cache. This retry is not route recovery. A second enrollment during the retry still rejects the result. Semantic failure reasons state whether the retry failed or was exhausted. The bounded `request.retry` debug event records the retry reason and outcome with the public call's opaque operation ID, when supplied. A completed RPC alone does not establish accepted semantic evidence.
 
 A read-only semantic request can also retry once after an LSP `ContentModified` error (`-32801`). This retry shares the same one-retry budget as enrollment; it does not add another try. Before this protocol retry, the client waits 100 ms so an immediate retry does not race the same server analysis. The wait is cancellable, respects the original absolute deadline, and does not delay enrollment-only retries. The client keeps the original request parameters and checks changes from the first failed input revision. It runs the full input sync before retry and checks current inputs before it accepts a result. An enrollment is still the only input change that can permit a retry. A content, workspace, close, lifecycle, or retirement change blocks it. Client replacement, caller cancellation, and a deadline also block retry. The post-request check rejects a result if inputs change while that attempt runs. This error-code retry applies only to read-only semantic requests. Diagnostics, rename, code actions, and refactors keep the default policy and do not retry `ContentModified`. See the [LSP 3.17 message-ordering rule](https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#messageOrdering), the [retry guard](src/client/client-request-enrollment.ts), and the [client query path](src/client/client.ts).
 
-Diagnostic collection does not close and reopen a document to obtain confirmation. It does not send a no-op `didChange` for that purpose. Refresh retains unchanged documents and their current server state, and resynchronizes changed or invalidated documents. A client restart may reopen tracked documents to restore client state; that is recovery, not diagnostic confirmation.
+Diagnostic collection does not close and reopen a document to obtain confirmation. It does not send a no-op `didChange` for that purpose. Refresh retains unchanged documents and their current server state, and resynchronizes changed or invalidated documents. A client restart may reopen tracked documents to restore client state; that is recovery, not diagnostic confirmation. Recovery skips documents closed or already reopened on the replacement and checks client ownership before reading or restoring failed state.
 
 Server readiness follows LSP work-done progress: a created progress token is pending and never blocks readiness; an observed `begin` marks active work and makes the client not ready until its `end` or the bounded per-token timeout.
 
@@ -233,7 +253,7 @@ Set `code-intelligence.exclude` in project or global SuPi configuration. A proje
 
 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.
+An exact semantic request or exact-file health refresh can still route an excluded or external file when a compatible server is available. Explicit refresh can retry that file's failed route without applying automatic-discovery exclusions. Original route and document identities are preserved; display-path canonicalization does not merge alias routes. 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.
 
@@ -272,6 +292,23 @@ Server settings use one snapshot for the active workspace runtime:
 - 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.
 
+TypeScript and JavaScript servers format code-action edits, such as organize imports, with their own defaults (4-space indentation) unless settings say otherwise. SuPi does not infer formatting from Biome, Prettier, or EditorConfig. Both the `typescript-language-server` and native TS 7 backends read `typescript.format` / `javascript.format`:
+
+```json
+{
+  "lsp": {
+    "servers": {
+      "typescript": {
+        "settings": {
+          "typescript": { "format": { "indentSize": 2, "tabSize": 2, "convertTabsToSpaces": true } },
+          "javascript": { "format": { "indentSize": 2, "tabSize": 2, "convertTabsToSpaces": true } }
+        }
+      }
+    }
+  }
+}
+```
+
 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.

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

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

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

@@ -77,7 +77,9 @@ export interface SemanticProvider {
   ): Promise<CodeQueryResult<DocumentCodeSymbol[]>>;
   /**
    * Collect workspace symbols from routes that can contribute within the
-   * optional canonical path scopes.
+   * optional path scopes. Completeness is relative to those scopes, but data
+   * may include out-of-scope rows; consumers must filter rows themselves.
+   * Policy exclusions proven outside every scope do not make the query partial.
    */
   workspaceSymbols(
     query: string,

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

@@ -3,8 +3,17 @@ export interface CodeQueryPartialMetadata {
   /** Automatic path-policy evidence removed from a collected result. */
   readonly automaticPathExclusion?: {
     readonly excludedCount: number;
+    /** Observed policy paths, not canonical navigation paths; retain aliases when presenting exclusions. */
     readonly examples: readonly string[];
   };
+  /**
+   * True when automatic path-policy exclusions are the only reason the result
+   * is partial: every contributing provider branch completed and no coverage
+   * gap was observed. Excluded rows matched paths the workspace policy treats
+   * as out of automatic scope, so the retained rows are the complete in-policy
+   * answer.
+   */
+  readonly exclusionOnly?: boolean;
 }
 
 /**

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

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

package/node_modules/@mrclrchtr/supi-core/src/child-web-tools.ts

@@ -0,0 +1,110 @@
+// Session-provided Web tools for SuPi child sessions (Agent Runs and Reviewer Sessions).
+//
+// The loaded supi-web extension answers a synchronous request on the parent event bus.
+// Consumers never depend on supi-web; when it is absent or provides no tools, the
+// request returns undefined and the child simply lacks Web tools.
+
+import type { ExtensionAPI, ExtensionFactory } from "@earendil-works/pi-coding-agent";
+
+/** Web tools that child sessions may receive when the containing session provides them. */
+export const CHILD_WEB_TOOL_NAMES = [
+  "web_fetch_md",
+  "web_search",
+  "web_docs_search",
+  "web_docs_fetch",
+] as const;
+
+/** One session-provided Web tool name. */
+export type ChildWebToolName = (typeof CHILD_WEB_TOOL_NAMES)[number];
+
+/**
+ * Web tools currently callable in the containing session plus a child-only extension
+ * factory that registers them. The factory must not capture the parent session; it may
+ * capture plain data such as the containing session's configuration directory.
+ */
+export interface ChildWebToolProvision {
+  readonly toolNames: readonly ChildWebToolName[];
+  /** Register the requested subset of `toolNames` in a child session. */
+  readonly createFactory: (toolNames: readonly ChildWebToolName[]) => ExtensionFactory;
+}
+
+/** Plain containing-session data supplied with a child Web tool request. */
+export interface ChildWebToolsRequestContext {
+  /**
+   * Working directory whose SuPi configuration governs Web settings such as Firecrawl.
+   * Children with a different cwd (for example a frozen Review Workspace) keep this policy.
+   */
+  readonly configCwd: string;
+}
+
+type EventBusLike = Pick<ExtensionAPI["events"], "on" | "emit">;
+
+const REQUEST_CHANNEL = "supi:child-web-tools:request";
+const RESPONSE_CHANNEL = "supi:child-web-tools:response";
+
+interface ChildWebToolsRequest extends ChildWebToolsRequestContext {
+  readonly requestId: string;
+}
+
+interface ChildWebToolsResponse {
+  readonly requestId: string;
+  readonly provision: ChildWebToolProvision;
+}
+
+let nextRequestId = 0;
+
+/**
+ * Answer child Web tool requests on the parent event bus. The callback must be synchronous
+ * because Pi's event bus does not await listeners. Returns an unsubscribe function.
+ */
+export function provideChildWebTools(
+  events: EventBusLike,
+  resolve: (context: ChildWebToolsRequestContext) => ChildWebToolProvision | undefined,
+): () => void {
+  return events.on(REQUEST_CHANNEL, (data) => {
+    const request = data as Partial<ChildWebToolsRequest> | undefined;
+    if (typeof request?.requestId !== "string" || typeof request.configCwd !== "string") return;
+    const { requestId, configCwd } = request;
+    const provision = resolve({ configCwd });
+    if (!provision || provision.toolNames.length === 0) return;
+    events.emit(RESPONSE_CHANNEL, { requestId, provision } satisfies ChildWebToolsResponse);
+  });
+}
+
+/** Capture the Web tools the containing session currently provides, if any. */
+export function requestChildWebTools(
+  events: EventBusLike,
+  context: ChildWebToolsRequestContext,
+): ChildWebToolProvision | undefined {
+  const requestId = `child-web-${process.pid}-${++nextRequestId}`;
+  let provision: ChildWebToolProvision | undefined;
+  const unsubscribe = events.on(RESPONSE_CHANNEL, (data) => {
+    const response = data as Partial<ChildWebToolsResponse> | undefined;
+    if (response?.requestId === requestId && response.provision) provision = response.provision;
+  });
+  try {
+    events.emit(REQUEST_CHANNEL, { requestId, ...context } satisfies ChildWebToolsRequest);
+  } finally {
+    unsubscribe();
+  }
+  return provision;
+}
+
+/**
+ * Return the Web tools callable in a session under Pi's exposure rules: active `direct`
+ * tools, plus registered `codemode` and `deferred` tools. `model-only` and `hidden`
+ * tools are not callable.
+ */
+export function callableChildWebToolNames(
+  pi: Pick<ExtensionAPI, "getAllTools" | "getActiveTools">,
+): ChildWebToolName[] {
+  const active = new Set(pi.getActiveTools());
+  const exposures = new Map(
+    pi.getAllTools().map((tool) => [tool.name, tool.exposure ?? "direct"] as const),
+  );
+  return CHILD_WEB_TOOL_NAMES.filter((name) => {
+    const exposure = exposures.get(name);
+    if (exposure === "direct") return active.has(name);
+    return exposure === "codemode" || exposure === "deferred";
+  });
+}

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

@@ -1,5 +1,16 @@
 // supi-core session domain — session utilities and registries.
 
+export type {
+  ChildWebToolName,
+  ChildWebToolProvision,
+  ChildWebToolsRequestContext,
+} from "./child-web-tools.ts";
+export {
+  CHILD_WEB_TOOL_NAMES,
+  callableChildWebToolNames,
+  provideChildWebTools,
+  requestChildWebTools,
+} from "./child-web-tools.ts";
 export { createRegistry, createSessionStateRegistry } from "./registry-utils.ts";
 export type {
   SessionCapabilitySkill,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-lsp",
-  "version": "11.2.0",
+  "version": "11.3.0",
   "description": "Language Server Protocol runtime for SuPi code intelligence",
   "license": "MIT",
   "repository": {
@@ -38,8 +38,8 @@
     "vscode-jsonrpc": "^10.0.0",
     "vscode-languageserver-protocol": "^3.18.5",
     "vscode-languageserver-types": "^3.18.5",
-    "@mrclrchtr/supi-core": "11.2.0",
-    "@mrclrchtr/supi-code-runtime": "11.2.0"
+    "@mrclrchtr/supi-code-runtime": "11.3.0",
+    "@mrclrchtr/supi-core": "11.3.0"
   },
   "bundledDependencies": [
     "@mrclrchtr/supi-code-runtime",

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

@@ -95,10 +95,17 @@ async function collectPushOnlyEvidence(
       ? partialCodeQuery(diagnostics, TENTATIVE_PUSH_UNAVAILABLE_REASON)
       : unavailableCodeQuery(TENTATIVE_PUSH_UNAVAILABLE_REASON);
   }
-  return incompleteDiagnosticResult(
-    options.cachedDiagnostics,
-    push === "released" ? "released" : "timed-out",
-  );
+  if (push === "released") {
+    return incompleteDiagnosticResult(options.cachedDiagnostics, "released");
+  }
+  return options.cachedDiagnostics
+    ? partialCodeQuery(
+        options.cachedDiagnostics,
+        `${TENTATIVE_PUSH_UNAVAILABLE_REASON} Retained cached diagnostics are partial evidence.`,
+      )
+    : unavailableCodeQuery(
+        `${TENTATIVE_PUSH_UNAVAILABLE_REASON} No current publication was observed.`,
+      );
 }
 
 /** Collect one request report without using an ambient push as confirmation. */

package/src/client/client-diagnostics.ts

@@ -47,6 +47,7 @@ import {
 } from "./client-document-state.ts";
 import { clearTrackedDocumentState, synchronizeTrackedDocument } from "./client-document-sync.ts";
 import { getDiagnosticFileState } from "./client-file-state.ts";
+import { SemanticInputAdmission } from "./client-input-admission.ts";
 import { SemanticInputRequestRetryGuard } from "./client-request-enrollment.ts";
 import {
   SemanticInputBarrier,
@@ -103,6 +104,7 @@ export class ClientDiagnostics {
   /** URIs closed by a lifecycle operation: versioned pushes stay fail-closed. */
   readonly #closedVersionedBarrier = new Set<string>();
   readonly #inputBarrier: SemanticInputBarrier;
+  #inputAdmission = new SemanticInputAdmission();
   #evidenceRevision = 0;
   #nextSynchronizationId = 0;
   /** One active server refresh plus one coalesced newer demand generation. */
@@ -125,6 +127,60 @@ export class ClientDiagnostics {
     });
   }
 
+  /** Keep first enrollment outside a semantic query or refactor-planning attempt. */
+  withSemanticRequest<T>(
+    run: () => Promise<T>,
+    control?: CodeRequestControl,
+    uri?: string,
+  ): Promise<T> {
+    return this.#inputAdmission.request(run, control, uri);
+  }
+
+  /** Read content only after admission; tracked-document changes never wait. */
+  async openDocument(
+    filePath: string,
+    readContent: () => string,
+    control?: CodeRequestControl,
+    protectInputs = false,
+  ): Promise<void> {
+    throwIfCodeRequestInterrupted(control);
+    const open = () => {
+      throwIfCodeRequestInterrupted(control);
+      if (!this.host.isOperational()) throw new Error("LSP client is not running.");
+      this.didOpen(filePath, readContent());
+    };
+    if (this.#openDocs.has(fileToUri(filePath))) {
+      open();
+      return;
+    }
+    await this.#inputAdmission.enroll(fileToUri(filePath), open, control, protectInputs);
+  }
+
+  /** Restore only still-retained documents; a close or replacement wins over recovery. */
+  async restoreDocument(
+    filePath: string,
+    readContent: () => string,
+    isCurrent: () => boolean,
+  ): Promise<void> {
+    const uri = fileToUri(filePath);
+    const admission = this.#inputAdmission;
+    const canRestore = () =>
+      isCurrent() &&
+      this.host.isOperational() &&
+      admission === this.#inputAdmission &&
+      !this.#closedVersionedBarrier.has(uri) &&
+      !this.#openDocs.has(uri);
+    if (!canRestore()) return;
+    try {
+      await this.openDocument(filePath, () => {
+        if (!canRestore()) throw new Error("Document restoration was superseded.");
+        return readContent();
+      });
+    } catch {
+      if (canRestore()) this.markFailedFile(filePath);
+    }
+  }
+
   /** Synchronize all open document inputs, rejoining once after a new enrollment. */
   async synchronizeSemanticInputs(
     control?: CodeRequestControl,
@@ -222,17 +278,22 @@ export class ClientDiagnostics {
     this.#inputBarrier.forgetDocumentContent(uri);
   }
 
-  #ensureExplicitDocumentContent(
+  async #ensureExplicitDocumentContent(
     filePath: string,
     content: string,
     contentIsAuthoritative: boolean,
-  ): void {
+    control?: CodeRequestControl,
+  ): Promise<void> {
     const uri = fileToUri(filePath);
     const document = this.#openDocs.get(uri);
     if (!document) {
-      // An untracked file needs an initial protocol document before its barrier
-      // read can verify the manager's content.
-      this.didOpen(filePath, content);
+      // A manager read can predate admission. Re-read disk after the wait;
+      // explicit authoritative content retains its existing override semantics.
+      await this.openDocument(
+        filePath,
+        () => (contentIsAuthoritative ? content : readFileSync(filePath, "utf-8")),
+        control,
+      );
       return;
     }
     // Manager reads are not authoritative: an already tracked document can
@@ -260,6 +321,8 @@ export class ClientDiagnostics {
   }
 
   clear(options: { preserveFailedDocuments?: boolean } = {}): void {
+    this.#inputAdmission.dispose();
+    this.#inputAdmission = new SemanticInputAdmission();
     if (options.preserveFailedDocuments) {
       for (const uri of [...this.#openDocs.keys(), ...this.#diagnosticStore.keys()]) {
         this.#failedUris.add(uri);
@@ -336,6 +399,7 @@ export class ClientDiagnostics {
 
   /** Send a save after a disk change that the input barrier observed. */
   #noteExternalDiskChange(filePath: string, content: string): void {
+    this.#inputAdmission.invalidateRequests();
     if (!this.host.isOperational()) return;
     const documentSync = this.host.documentSync();
     if (!documentSync.save) return;
@@ -368,6 +432,7 @@ export class ClientDiagnostics {
 
   didClose(filePath: string): void {
     const uri = fileToUri(filePath);
+    this.#inputAdmission.close(uri);
     const wasOpen = this.#openDocs.has(uri);
     const hadState =
       wasOpen ||
@@ -627,7 +692,12 @@ export class ClientDiagnostics {
     throwIfCodeRequestInterrupted(control);
     const uri = fileToUri(filePath);
     const contentIsAuthoritative = options.contentIsAuthoritative !== false;
-    this.#ensureExplicitDocumentContent(filePath, content, contentIsAuthoritative);
+    try {
+      await this.#ensureExplicitDocumentContent(filePath, content, contentIsAuthoritative, control);
+    } catch (error) {
+      throwIfCodeRequestInterrupted(control);
+      return unavailableAfterEnrollmentRetry(error);
+    }
     const contentOverrides = this.#getDiagnosticContentOverrides(
       uri,
       content,
@@ -1044,6 +1114,7 @@ export class ClientDiagnostics {
     changeKind: SemanticInputChangeKind = "content",
   ): void {
     this.#inputBarrier.noteInputChange(changeKind);
+    if (changeKind !== "enrollment") this.#inputAdmission.invalidateRequests();
     if (invalidateEvidence) this.#advanceEvidenceRevision(false);
     if (cancelRequests) this.#cancelAllDiagnosticRequests();
   }

package/src/client/client-input-admission.ts

@@ -0,0 +1,149 @@
+import {
+  type CodeRequestControl,
+  CodeRequestDeadlineError,
+  throwIfCodeRequestInterrupted,
+} from "@mrclrchtr/supi-code-runtime/api";
+
+const MAX_PENDING_INPUT_OPERATIONS = 32;
+
+type InputOperationKind = "request" | "enrollment" | "request-enrollment";
+
+interface PendingInputOperation {
+  readonly uri: string | undefined;
+  readonly kind: InputOperationKind;
+  start(): void;
+  cancel(reason: unknown): void;
+}
+
+/**
+ * Admit first opens between semantic query and refactor-planning attempts on one client.
+ * Consecutive readers run concurrently; FIFO admission prevents either new
+ * readers or enrollments from overtaking a waiting operation. This is not
+ * diagnostic transport ownership: an interrupted semantic attempt can release
+ * its admission even when the server has not yet acknowledged cancellation.
+ */
+export class SemanticInputAdmission {
+  readonly #pending: PendingInputOperation[] = [];
+  #readers = 0;
+  #enrolling = false;
+  #disposed = false;
+
+  /** Cover one attempt's synchronization, RPCs and acceptance, never its retry. */
+  request<T>(run: () => Promise<T>, control?: CodeRequestControl, uri?: string): Promise<T> {
+    return this.#run("request", uri, run, control);
+  }
+
+  /**
+   * Commit a first open after earlier attempts leave. Demand with original
+   * semantic/refactor parameters opts into input invalidation while waiting.
+   */
+  enroll(
+    uri: string,
+    run: () => void,
+    control?: CodeRequestControl,
+    protectInputs = false,
+  ): Promise<void> {
+    return this.#run(protectInputs ? "request-enrollment" : "enrollment", uri, run, control);
+  }
+
+  /** A close cancels queued opens and queries for that document, before dispatch. */
+  close(uri: string): void {
+    const cancelled = this.#pending.filter((pending) => pending.uri === uri);
+    for (const pending of cancelled) this.#pending.splice(this.#pending.indexOf(pending), 1);
+    for (const pending of cancelled)
+      pending.cancel(new Error("Document closed before input admission."));
+  }
+
+  /** Discard queued request parameters after a known non-enrollment input change. */
+  invalidateRequests(): void {
+    const cancelled = this.#pending.filter((pending) => pending.kind !== "enrollment");
+    for (const pending of cancelled) this.#pending.splice(this.#pending.indexOf(pending), 1);
+    for (const pending of cancelled)
+      pending.cancel(new Error("Semantic inputs changed before request admission."));
+  }
+
+  /** Reject queued work without confusing caller completion with transport settlement. */
+  dispose(): void {
+    this.#disposed = true;
+    for (const pending of [...this.#pending]) {
+      pending.cancel(new Error("LSP client stopped before input admission."));
+    }
+  }
+
+  #run<T>(
+    kind: InputOperationKind,
+    uri: string | undefined,
+    run: () => T | Promise<T>,
+    control: CodeRequestControl | undefined,
+  ): Promise<T> {
+    throwIfCodeRequestInterrupted(control);
+    if (this.#disposed) return Promise.reject(new Error("LSP input admission is disposed."));
+    if (this.#pending.length >= MAX_PENDING_INPUT_OPERATIONS) {
+      return Promise.reject(new Error("LSP input admission queue is full."));
+    }
+    return new Promise<T>((resolve, reject) => {
+      let timer: ReturnType<typeof setTimeout> | undefined;
+      let waiting = true;
+      const cleanup = () => {
+        if (timer !== undefined) clearTimeout(timer);
+        control?.signal?.removeEventListener("abort", abort);
+      };
+      const operation: PendingInputOperation = {
+        uri,
+        kind,
+        cancel: (reason) => {
+          if (!waiting) return;
+          waiting = false;
+          cleanup();
+          const index = this.#pending.indexOf(operation);
+          if (index !== -1) this.#pending.splice(index, 1);
+          reject(reason);
+          this.#drain();
+        },
+        start: () => {
+          waiting = false;
+          cleanup();
+          if (kind !== "request") this.#enrolling = true;
+          else this.#readers++;
+          const finish = () => {
+            if (kind !== "request") this.#enrolling = false;
+            else this.#readers--;
+            this.#drain();
+          };
+          try {
+            throwIfCodeRequestInterrupted(control);
+            Promise.resolve(run()).then(resolve, reject).finally(finish);
+          } catch (error) {
+            reject(error);
+            finish();
+          }
+        },
+      };
+      const abort = () => {
+        try {
+          throwIfCodeRequestInterrupted(control);
+        } catch (error) {
+          operation.cancel(error);
+        }
+      };
+      this.#pending.push(operation);
+      control?.signal?.addEventListener("abort", abort, { once: true });
+      if (control?.deadline !== undefined) {
+        timer = setTimeout(
+          () => operation.cancel(new CodeRequestDeadlineError()),
+          Math.max(0, control.deadline - Date.now()),
+        );
+      }
+      this.#drain();
+    });
+  }
+
+  #drain(): void {
+    while (!this.#disposed && !this.#enrolling && this.#pending.length > 0) {
+      const next = this.#pending[0];
+      if (next.kind !== "request" && this.#readers > 0) return;
+      this.#pending.shift();
+      next.start();
+    }
+  }
+}

package/src/client/client-typescript-project.ts

@@ -0,0 +1,40 @@
+/**
+ * Whether tsserver placed an open file in a configured project.
+ *
+ * - `configured`: a `tsconfig.json` / `jsconfig.json` program owns the file.
+ * - `inferred`: tsserver created an inferred project for the file alone, so
+ *   project-wide requests such as `workspace/symbol` do not cover the
+ *   configured program.
+ * - `unknown`: the route is not TypeScript or tsserver could not answer.
+ */
+export type ProjectMembership = "configured" | "inferred" | "unknown";
+
+/** Build `workspace/executeCommand` params for tsserver `projectInfo`. */
+export function typeScriptProjectInfoParams(uri: string): unknown {
+  return {
+    command: "typescript.tsserverRequest",
+    arguments: [
+      "projectInfo",
+      { file: uri, needFileNameList: false },
+      // Semantic execution target; the project must be loaded to answer.
+      { executionTarget: 0, expectsResult: true, isAsync: false },
+    ],
+  };
+}
+
+/**
+ * Read project membership from a tsserver `projectInfo` response.
+ * tsserver names projects without a config file `/dev/null/<kind>Project<N>*`.
+ */
+export function readTypeScriptProjectMembership(response: unknown): ProjectMembership {
+  if (!isRecord(response) || response.type !== "response" || response.success !== true) {
+    return "unknown";
+  }
+  const body = response.body;
+  if (!isRecord(body) || typeof body.configFileName !== "string") return "unknown";
+  return body.configFileName.startsWith("/dev/null/") ? "inferred" : "configured";
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}