@mrclrchtr/supi-code-intelligence 6.3.0 → 6.4.0

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

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

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

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

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

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

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

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

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

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-lsp",
-  "version": "6.3.0",
+  "version": "6.4.0",
   "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-code-runtime": "6.3.0",
-    "@mrclrchtr/supi-core": "6.3.0"
+    "@mrclrchtr/supi-code-runtime": "6.4.0",
+    "@mrclrchtr/supi-core": "6.4.0"
   },
   "bundledDependencies": [
     "@mrclrchtr/supi-code-runtime",

package/node_modules/@mrclrchtr/supi-lsp/src/api.ts

@@ -1,5 +1,6 @@
 // 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";
@@ -41,6 +42,12 @@ export {
   type WorkspaceSentinelScanOptions,
   type WorkspaceSentinelSyncResult,
 } from "./diagnostics/workspace-sentinels.ts";
+export {
+  scanWorkspaceSources,
+  type WorkspaceSourceInventory,
+  type WorkspaceSourceInventoryReason,
+  type WorkspaceSourceScanOptions,
+} from "./diagnostics/workspace-sources.ts";
 export { raceReadinessValue, raceRequestControl } from "./session/readiness.ts";
 export type {
   LspControllerState,
@@ -51,6 +58,8 @@ export type {
 } from "./session/runtime-controller.ts";
 export { LspRuntimeController } from "./session/runtime-controller.ts";
 export type {
+  BulkTrackFileOutcome,
+  BulkTrackFilesResult,
   DiagnosticEvidenceDocument,
   DiagnosticEvidenceStatus,
   DiagnosticEvidenceSummary,
@@ -79,6 +88,7 @@ export {
   waitForWorkspaceLspRuntime,
 } from "./session/runtime-registry.ts";
 export { scanMissingServers } from "./session/scanner.ts";
+export { MAX_BULK_TRACK_FILES } from "./session/workspace-lsp-runtime.ts";
 export {
   AUTOMATIC_LSP_EXCLUDED_DIRECTORIES,
   type AutomaticLspPathPolicy,

package/node_modules/@mrclrchtr/supi-lsp/src/diagnostics/workspace-sentinels.ts

@@ -1,6 +1,6 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { fileToUri, uriToFile } from "@mrclrchtr/supi-core/path";
+import { fileToUri } from "@mrclrchtr/supi-core/path";
 import { FileChangeType, type FileEvent } from "../config/types.ts";
 import {
   type AutomaticLspPathPolicy,
@@ -11,12 +11,6 @@ import {
 const ROOT_LOCKFILES = ["pnpm-lock.yaml", "package-lock.json", "yarn.lock", "bun.lockb"];
 
 export interface WorkspaceSentinelScanOptions {
-  /**
-   * Also track every regular source file (not just sentinels). The workspace
-   * refresh path uses this to discover files created since the last refresh;
-   * the diff then reports them as `sourceChanges` so the caller can pull them.
-   */
-  includeSourceFiles?: boolean;
   /** Runtime-owned automatic path policy. */
   policy?: AutomaticLspPathPolicy;
 }
@@ -36,7 +30,7 @@ export function scanWorkspaceSentinels(
     for (const entry of entries) {
       if (!entry.isFile() && !entry.isSymbolicLink()) continue;
       const filePath = path.join(directory, entry.name);
-      if (!options.includeSourceFiles && !isWorkspaceSentinelPath(filePath, resolvedCwd)) continue;
+      if (!isWorkspaceSentinelPath(filePath, resolvedCwd)) continue;
       try {
         snapshot.set(filePath, fs.statSync(filePath).mtimeMs);
       } catch {
@@ -78,38 +72,16 @@ export function diffWorkspaceSentinelSnapshot(
 export interface WorkspaceSentinelSyncResult {
   snapshot: Map<string, number>;
   changes: FileEvent[];
-  sourceChanges: FileEvent[];
 }
 
-/**
- * Refresh a previous snapshot and return the new snapshot plus change events.
- *
- * When `includeSourceFiles` is set, the returned `changes` list keeps
- * sentinel-file events only; source-file events are returned separately in
- * `sourceChanges` so the caller can act on them without interpreting every
- * regular file edit as a config-level workspace change.
- */
+/** Refresh a previous sentinel snapshot and return its change events. */
 export function syncWorkspaceSentinelSnapshot(
   cwd: string,
   previous: Map<string, number>,
   options: WorkspaceSentinelScanOptions = {},
 ): WorkspaceSentinelSyncResult {
   const snapshot = scanWorkspaceSentinels(cwd, options);
-  const changes = diffWorkspaceSentinelSnapshot(previous, snapshot);
-  if (!options.includeSourceFiles) return { snapshot, changes, sourceChanges: [] };
-
-  const sourceChanges = changes.filter((change) => {
-    const filePath = uriToFile(change.uri);
-    return !isWorkspaceSentinelPath(filePath, cwd);
-  });
-  return {
-    snapshot,
-    changes: changes.filter((change) => {
-      const filePath = uriToFile(change.uri);
-      return isWorkspaceSentinelPath(filePath, cwd);
-    }),
-    sourceChanges,
-  };
+  return { snapshot, changes: diffWorkspaceSentinelSnapshot(previous, snapshot) };
 }
 
 function isWorkspaceSentinelPath(filePath: string, root: string): boolean {

package/node_modules/@mrclrchtr/supi-lsp/src/diagnostics/workspace-sources.ts

@@ -0,0 +1,108 @@
+import { type Dirent, promises as fs } from "node:fs";
+import * as path from "node:path";
+import {
+  type CodeRequestControl,
+  isCodeRequestInterruption,
+  throwIfCodeRequestInterrupted,
+} from "@mrclrchtr/supi-code-runtime/api";
+import { raceRequestControl } from "../session/readiness.ts";
+import type { AutomaticLspPathPolicy } from "../workspace-path-policy.ts";
+
+const MAX_SOURCE_INVENTORY_FILES = 50_000;
+
+export type WorkspaceSourceInventoryReason = "file-limit" | "filesystem-error";
+
+/** Complete or safety-limited automatic source inventory. */
+export interface WorkspaceSourceInventory {
+  readonly status: "complete" | "limited";
+  /** The reason is null only when the inventory is complete. */
+  readonly reason: WorkspaceSourceInventoryReason | null;
+  /** Number of configured-extension files observed before the scan stopped. */
+  readonly observedFileCount: number;
+  /** Paths are present only as a usable complete inventory. */
+  readonly files: readonly string[];
+}
+
+/** Inputs for one automatic source inventory. */
+export interface WorkspaceSourceScanOptions {
+  readonly fileTypes: readonly string[];
+  readonly policy: AutomaticLspPathPolicy;
+  readonly control?: CodeRequestControl;
+}
+
+/**
+ * Scan one workspace for automatic source paths.
+ *
+ * The scan uses the runtime path policy and configured LSP extensions. A
+ * limited result is not a source baseline and must not be diffed. Caller
+ * interruption is rethrown so a health call does not retain partial state.
+ */
+export async function scanWorkspaceSources(
+  cwd: string,
+  options: WorkspaceSourceScanOptions,
+): Promise<WorkspaceSourceInventory> {
+  const extensionSet = new Set(
+    options.fileTypes.map((fileType) => fileType.replace(/^\./, "").toLowerCase()),
+  );
+  const files: string[] = [];
+  let observedFileCount = 0;
+  let reason: WorkspaceSourceInventoryReason | null = null;
+
+  const readEntries = async (directory: string): Promise<Dirent[] | null> => {
+    try {
+      return await raceRequestControl(
+        fs.readdir(directory, { withFileTypes: true }) as Promise<Dirent[]>,
+        options.control,
+      );
+    } catch (error) {
+      if (isCodeRequestInterruption(error, options.control)) throw error;
+      reason = "filesystem-error";
+      return null;
+    }
+  };
+
+  const visitEntry = async (directory: string, entry: Dirent): Promise<void> => {
+    const filePath = path.join(directory, entry.name);
+    const kind = entry.isDirectory() ? "directory" : "file";
+    if (!options.policy.isEligible(filePath, kind)) return;
+
+    if (entry.isDirectory()) {
+      await walk(filePath);
+      return;
+    }
+    if (!entry.isFile() && !entry.isSymbolicLink()) return;
+    if (!extensionSet.has(path.extname(entry.name).slice(1).toLowerCase())) return;
+
+    observedFileCount++;
+    if (observedFileCount > MAX_SOURCE_INVENTORY_FILES) {
+      reason = "file-limit";
+      return;
+    }
+    files.push(filePath);
+  };
+
+  const walk = async (directory: string): Promise<void> => {
+    if (reason !== null) return;
+    throwIfCodeRequestInterrupted(options.control);
+    if (!options.policy.isEligible(directory, "directory")) return;
+
+    const entries = await readEntries(directory);
+    if (!entries) return;
+    entries.sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
+      throwIfCodeRequestInterrupted(options.control);
+      await visitEntry(directory, entry);
+      if (reason !== null) return;
+    }
+  };
+
+  await walk(path.resolve(cwd));
+  throwIfCodeRequestInterrupted(options.control);
+
+  return {
+    status: reason === null ? "complete" : "limited",
+    reason,
+    observedFileCount,
+    files: reason === null ? files.sort((a, b) => a.localeCompare(b)) : [],
+  };
+}

package/node_modules/@mrclrchtr/supi-lsp/src/manager/manager.ts

@@ -26,6 +26,7 @@ import {
   truncateDebugIdentity as truncateIdentity,
 } from "@mrclrchtr/supi-core/debug";
 import { resolveToolPath as resolveSessionPath, uriToFile } from "@mrclrchtr/supi-core/path";
+import { isMissingFileError } from "../client/client-file-state.ts";
 import { getServerForFile } from "../config/config.ts";
 import {
   getFileScopeDecision,
@@ -63,6 +64,10 @@ import {
   type WorkspaceSentinelScanOptions,
   type WorkspaceSentinelSyncResult,
 } from "../diagnostics/workspace-sentinels.ts";
+import {
+  scanWorkspaceSources as scanAutomaticWorkspaceSources,
+  type WorkspaceSourceInventory,
+} from "../diagnostics/workspace-sources.ts";
 import { raceRequestControl } from "../session/readiness.ts";
 import {
   emptyProcessCrashRecoveryReport,
@@ -71,6 +76,11 @@ import {
   type ScopeDecisionSummary,
   type WorkspaceDiagnosticReport,
 } from "../session/runtime-diagnostics.ts";
+import {
+  type BulkTrackFileOutcome,
+  type BulkTrackFilesResult,
+  MAX_BULK_TRACK_FILES,
+} from "../session/workspace-lsp-runtime.ts";
 import {
   displayRelativeFilePath,
   formatCoverageSummaryText,
@@ -124,6 +134,7 @@ type UnavailableReason = "missing-command" | "start-failed" | "runtime-error";
 
 /** Maximum tracked-file entries retained in one scope-decision telemetry summary. */
 const SCOPE_DECISION_MAX_ENTRIES = 24;
+const MAX_CONCURRENT_BULK_TRACKS = 4;
 
 interface ScopeDecisionAccumulator {
   entries: ScopeDecisionEntry[];
@@ -286,6 +297,9 @@ export class LspManager {
   private handledCrashGenerations = new Map<string, number>();
   /** Prevent late startup and lifecycle callbacks from republishing after shutdown. */
   private shuttingDown = false;
+  /** Coalesce per-file tracking transitions into one bulk transition. */
+  private trackedFilesBatchDepth = 0;
+  private trackedFilesBatchChanged = false;
   constructor(
     private readonly config: LspConfig,
     private readonly cwd: string,
@@ -343,7 +357,7 @@ export class LspManager {
     return this.canServeFile(filePath);
   }
 
-  /** Inventory automatic workspace sentinel and source paths with the runtime policy. */
+  /** Inventory automatic workspace sentinels with the runtime policy. */
   scanWorkspaceSentinels(options: WorkspaceSentinelScanOptions = {}): Map<string, number> {
     return scanAutomaticWorkspaceSentinels(this.cwd, {
       ...options,
@@ -351,7 +365,16 @@ export class LspManager {
     });
   }
 
-  /** Refresh the automatic workspace inventory with the runtime policy. */
+  /** Scan configured LSP source extensions with the runtime path policy. */
+  scanWorkspaceSources(control?: CodeRequestControl): Promise<WorkspaceSourceInventory> {
+    return scanAutomaticWorkspaceSources(this.cwd, {
+      fileTypes: Object.values(this.config.servers).flatMap((server) => server.fileTypes),
+      policy: this.automaticPathPolicy,
+      control,
+    });
+  }
+
+  /** Refresh the automatic workspace sentinel with the runtime policy. */
   syncWorkspaceSentinelSnapshot(
     previous: Map<string, number>,
     options: WorkspaceSentinelScanOptions = {},
@@ -417,9 +440,14 @@ export class LspManager {
     // A recovered route keeps its consumed budget but has no active reason.
     // Passive callers can use its running client normally.
 
-    return this.startServerForRoot(route.serverName, route.root);
+    return this.startServerForRoot(route.serverName, route.root, options.control);
   }
-  async startServerForRoot(serverName: string, root: string): Promise<LspClient | null> {
+  async startServerForRoot(
+    serverName: string,
+    root: string,
+    control?: CodeRequestControl,
+  ): Promise<LspClient | null> {
+    throwIfCodeRequestInterrupted(control);
     if (this.shuttingDown) return null;
     const serverConfig = this.config.servers[serverName];
     if (!serverConfig) return null;
@@ -450,17 +478,18 @@ export class LspManager {
     // This prevents spawning duplicate server processes when two
     // callers race through getClientForFile before either await yields.
     const pending = this.pendingStarts.get(key);
-    if (pending) return pending;
+    if (pending) return raceRequestControl(pending, control);
 
     const startPromise = this.performStart(serverName, serverConfig, root, key);
     this.pendingStarts.set(key, startPromise);
-    try {
-      return await startPromise;
-    } finally {
-      if (this.pendingStarts.get(key) === startPromise) {
-        this.pendingStarts.delete(key);
-      }
-    }
+    // Keep the shared startup registered until it settles. A cancelled
+    // caller only stops waiting; it must not allow a duplicate route start.
+    void startPromise
+      .finally(() => {
+        if (this.pendingStarts.get(key) === startPromise) this.pendingStarts.delete(key);
+      })
+      .catch(() => {});
+    return raceRequestControl(startPromise, control);
   }
 
   private createClient(
@@ -505,6 +534,11 @@ export class LspManager {
       }
     }
 
+    if (kind === "tracked-files" && this.trackedFilesBatchDepth > 0) {
+      this.trackedFilesBatchChanged = true;
+      return;
+    }
+
     const aggregateKind =
       kind === "readiness" && generation > 1 && client.ready ? "recovery" : kind;
     this.publishLifecycle(aggregateKind);
@@ -1387,6 +1421,118 @@ export class LspManager {
       return unavailableCodeQuery(`Diagnostic collection failed for ${resolvedPath}: ${detail}`);
     }
   }
+  /**
+   * Track a bounded set of automatic source files with shared route starts.
+   * Inputs after the first 256 unique paths are ignored.
+   */
+  async bulkTrackFiles(
+    filePaths: readonly string[],
+    control?: CodeRequestControl,
+  ): Promise<BulkTrackFilesResult> {
+    throwIfCodeRequestInterrupted(control);
+    const selected = Array.from(
+      new Set(filePaths.map((filePath) => resolveSessionPath(this.cwd, filePath))),
+    ).slice(0, MAX_BULK_TRACK_FILES);
+    if (selected.length === 0) return { outcomes: [] };
+
+    this.trackedFilesBatchDepth++;
+    const outcomes = new Array<BulkTrackFileOutcome>(selected.length);
+    const workerCount = Math.min(MAX_CONCURRENT_BULK_TRACKS, selected.length);
+    let nextIndex = 0;
+    const worker = async (): Promise<void> => {
+      for (;;) {
+        throwIfCodeRequestInterrupted(control);
+        const index = nextIndex++;
+        if (index >= selected.length) return;
+        outcomes[index] = await this.trackBulkFile(selected[index], control);
+      }
+    };
+    const workers = Array.from({ length: workerCount }, () => worker());
+    try {
+      await Promise.all(workers);
+      return { outcomes };
+    } catch (error) {
+      // Let every worker observe cancellation before the batch transition is
+      // published. Shared route startup may continue, but no worker may open
+      // another document after this caller stops waiting.
+      await Promise.allSettled(workers);
+      throw error;
+    } finally {
+      this.trackedFilesBatchDepth--;
+      if (this.trackedFilesBatchDepth === 0 && this.trackedFilesBatchChanged) {
+        this.trackedFilesBatchChanged = false;
+        this.publishLifecycle("tracked-files");
+      }
+    }
+  }
+
+  private async trackBulkFile(
+    filePath: string,
+    control?: CodeRequestControl,
+  ): Promise<BulkTrackFileOutcome> {
+    const resolvedPath = resolveSessionPath(this.cwd, filePath);
+    if (!this.isConfiguredAutomaticSourceFile(resolvedPath)) {
+      return { file: resolvedPath, kind: "unsupported", reason: "not-automatic-source" };
+    }
+    const fileStatus = this.inspectSourceFile(resolvedPath);
+    if (fileStatus !== "regular") {
+      if (fileStatus === "missing") {
+        return { file: resolvedPath, kind: "unsupported", reason: "missing" };
+      }
+      if (fileStatus === "not-automatic-source") {
+        return { file: resolvedPath, kind: "unsupported", reason: "not-automatic-source" };
+      }
+      return {
+        file: resolvedPath,
+        kind: "unavailable",
+        reason: "The source file could not be inspected.",
+      };
+    }
+    if (this.isFileTracked(resolvedPath)) {
+      return { file: resolvedPath, kind: "already-tracked" };
+    }
+
+    throwIfCodeRequestInterrupted(control);
+    // Recheck the automatic source-support rule after the inventory scan. A
+    // config, exclusion, or route can change while a refresh is in flight.
+    if (!this.isSupportedSourceFile(resolvedPath)) {
+      return {
+        file: resolvedPath,
+        kind: "unavailable",
+        reason: "No available LSP route can serve this source file.",
+      };
+    }
+
+    const client = await this.ensureFileOpen(resolvedPath, { control });
+    if (!client) {
+      return {
+        file: resolvedPath,
+        kind: "unavailable",
+        reason: "The LSP route could not open this source file.",
+      };
+    }
+    return { file: resolvedPath, kind: "tracked" };
+  }
+
+  private isConfiguredAutomaticSourceFile(filePath: string): boolean {
+    return this.isAutomaticScopePath(filePath) && getServerForFile(this.config, filePath) !== null;
+  }
+
+  private inspectSourceFile(
+    filePath: string,
+  ): "regular" | "missing" | "not-automatic-source" | "unavailable" {
+    try {
+      return fs.statSync(filePath).isFile() ? "regular" : "not-automatic-source";
+    } catch (error) {
+      if (isMissingFileError(error)) return "missing";
+      return "unavailable";
+    }
+  }
+
+  private isFileTracked(filePath: string): boolean {
+    return this.getExistingClientForFile(filePath)?.openFiles.includes(filePath) ?? false;
+  }
+
   /** Close a file across any active LSP clients and clear its cached diagnostics. */
   closeFile(filePath: string): void {
     closeFileAcrossClients(this.clients.values(), resolveSessionPath(this.cwd, filePath));
@@ -1994,9 +2140,14 @@ export class LspManager {
     const client = await this.getClientForFile(resolvedPath, options);
     if (!client) return null;
     try {
-      client.didOpen(resolvedPath, fs.readFileSync(resolvedPath, "utf-8"));
+      const content = fs.readFileSync(resolvedPath, "utf-8");
+      // Route startup can be shared. The document open belongs to this
+      // caller, so check again after the shared wait before sending didOpen.
+      throwIfCodeRequestInterrupted(options.control);
+      client.didOpen(resolvedPath, content);
       return client;
-    } catch {
+    } catch (error) {
+      if (isCodeRequestInterruption(error, options.control)) throw error;
       this.closeFile(resolvedPath);
       return null;
     }

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

@@ -43,6 +43,7 @@ import type {
   RecoverDiagnosticsResult,
 } from "./runtime-diagnostics.ts";
 import type {
+  BulkTrackFilesResult,
   RoutedMutationResponse,
   SemanticReadinessResult,
   WorkspaceLspRuntime,
@@ -70,6 +71,8 @@ export {
   type WorkspaceDiagnosticSummaryEntry,
 } from "./runtime-diagnostics.ts";
 export type {
+  BulkTrackFileOutcome,
+  BulkTrackFilesResult,
   RoutedMutationResponse,
   SemanticReadinessResult,
   WorkspaceLspRuntime,
@@ -345,7 +348,12 @@ class DefaultWorkspaceLspRuntime implements WorkspaceLspRuntime {
     return this.manager.scanWorkspaceSentinels(options);
   }
 
-  /** Refresh the automatic workspace sentinel and source inventory. */
+  /** Scan configured source extensions under the automatic path policy. */
+  scanWorkspaceSources(control?: CodeRequestControl) {
+    return this.manager.scanWorkspaceSources(control);
+  }
+
+  /** Refresh the automatic workspace sentinel. */
   syncWorkspaceSentinelSnapshot(
     previous: Map<string, number>,
     options: WorkspaceSentinelScanOptions = {},
@@ -353,6 +361,14 @@ class DefaultWorkspaceLspRuntime implements WorkspaceLspRuntime {
     return this.manager.syncWorkspaceSentinelSnapshot(previous, options);
   }
 
+  /** Track a bounded set of source files without exposing clients. */
+  bulkTrackFiles(
+    filePaths: readonly string[],
+    control?: CodeRequestControl,
+  ): Promise<BulkTrackFilesResult> {
+    return this.manager.bulkTrackFiles(filePaths, control);
+  }
+
   /** Track a file in its routed client without exposing that client. */
   async trackFile(filePath: string): Promise<boolean> {
     const resolvedPath = this.resolveFilePath(filePath);

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

@@ -17,9 +17,13 @@ import type {
   WorkspaceSentinelScanOptions,
   WorkspaceSentinelSyncResult,
 } from "../diagnostics/workspace-sentinels.ts";
+import type { WorkspaceSourceInventory } from "../diagnostics/workspace-sources.ts";
 import type { WorkspaceLspDiagnosticSurface } from "./runtime-diagnostic-surface.ts";
 import type { ProcessCrashRecoveryReport } from "./runtime-diagnostics.ts";
 
+/** Maximum number of files processed by one automatic bulk-tracking call. */
+export const MAX_BULK_TRACK_FILES = 256;
+
 export type WorkspaceLspRuntimeState =
   | { kind: "ready"; runtime: WorkspaceLspRuntime }
   | { kind: "inactive"; runtime: WorkspaceLspRuntime }
@@ -53,6 +57,22 @@ export interface RoutedMutationResponse<T> {
   readonly authorizedMutationRoots: readonly string[];
 }
 
+/** Outcome for one path selected by a bounded automatic tracking batch. */
+export type BulkTrackFileOutcome =
+  | { readonly file: string; readonly kind: "tracked" }
+  | { readonly file: string; readonly kind: "already-tracked" }
+  | {
+      readonly file: string;
+      readonly kind: "unsupported";
+      readonly reason: "missing" | "not-automatic-source";
+    }
+  | { readonly file: string; readonly kind: "unavailable"; readonly reason: string };
+
+/** Result of one bounded automatic tracking batch. */
+export interface BulkTrackFilesResult {
+  readonly outcomes: readonly BulkTrackFileOutcome[];
+}
+
 /**
  * Workspace-scoped LSP interface that owns routing, readiness, semantic operations,
  * diagnostics, and recovery without exposing clients or the mutable manager.
@@ -116,13 +136,23 @@ export interface WorkspaceLspRuntime extends WorkspaceLspDiagnosticSurface {
   getProjectServers(): ProjectServerInfo[];
   /** Check whether automatic LSP work can use and serve the source file. */
   isSupportedSourceFile(filePath: string): boolean;
-  /** Inventory policy-eligible workspace sentinels and optional source files. */
+  /** Inventory policy-eligible workspace sentinels. */
   scanWorkspaceSentinels(options?: WorkspaceSentinelScanOptions): Map<string, number>;
-  /** Refresh one policy-eligible workspace sentinel and source inventory. */
+  /** Scan configured source extensions under the automatic path policy. */
+  scanWorkspaceSources(control?: CodeRequestControl): Promise<WorkspaceSourceInventory>;
+  /** Refresh one policy-eligible workspace sentinel. */
   syncWorkspaceSentinelSnapshot(
     previous: Map<string, number>,
     options?: WorkspaceSentinelScanOptions,
   ): WorkspaceSentinelSyncResult;
+  /**
+   * Track a bounded, deduplicated set of automatic source files. Inputs after
+   * the first 256 unique paths are ignored; callers must retain those paths.
+   */
+  bulkTrackFiles(
+    filePaths: readonly string[],
+    control?: CodeRequestControl,
+  ): Promise<BulkTrackFilesResult>;
   trackFile(filePath: string): Promise<boolean>;
   closeFile(filePath: string): void;
   pruneMissingFiles(): readonly string[];

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

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

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

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