@schlenkr/ragents 0.1.8 → 0.1.9

package/plugins/ragents.lsp-roslyn/executor.ts

@@ -0,0 +1,64 @@
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import type { LanguageServerDescription, WorkspaceExecutorContribution } from "@ragents/workspace-executor";
+
+export const ROSLYN_SERVER_VARIABLE = "ROSLYN_LANGUAGE_SERVER";
+export const ROSLYN_SERVER_FILE = "roslyn/Microsoft.CodeAnalysis.LanguageServer.dll";
+
+const languages = { ".cs": "csharp" } as const;
+
+export const roslynLanguageServer: LanguageServerDescription = {
+  id: "roslyn",
+  label: "Roslyn",
+  languages,
+  rootDescription: "the .sln file (or a single .csproj)",
+  solutionExtensions: [".sln", ".slnx"],
+};
+
+const dotnetCommand = (server: string, args: readonly string[]): { command: string; args: string[] } =>
+  server.toLowerCase().endsWith(".dll")
+    ? { command: "dotnet", args: [server, ...args] }
+    : { command: server, args: [...args] };
+
+const serverPath = (toolsDirectory: string): string => {
+  const configured = process.env[ROSLYN_SERVER_VARIABLE];
+  if (configured) return configured;
+  const provisioned = path.join(toolsDirectory, ...ROSLYN_SERVER_FILE.split("/"));
+  if (existsSync(provisioned)) return provisioned;
+  throw new Error("Microsoft.CodeAnalysis.LanguageServer gibt es auf diesem Rechner nicht: weder "
+    + `${ROSLYN_SERVER_VARIABLE} gesetzt noch ${provisioned} vorhanden. Ein Arbeitsplatz holt ihn mit `
+    + `pnpm provision --workspace, ein Server über pnpm provision <profil>; ${ROSLYN_SERVER_VARIABLE} übersteuert beides`);
+};
+
+export const executor: WorkspaceExecutorContribution = (machine) => ({
+  languageServers: [{
+    ...roslynLanguageServer,
+    resolveRoot: (workspaceRoot, root) => machine.resolveRootFile(workspaceRoot, root, [".sln", ".slnx", ".csproj"]),
+    rootDirectory: (root) => path.dirname(root),
+    launch: async (context, root) => ({
+      label: "Roslyn",
+      ...dotnetCommand(serverPath(machine.toolsDirectory), [
+        "--stdio",
+        "--logLevel", "Warning",
+        "--extensionLogDirectory", path.join(context.logDirectory, "roslyn-logs"),
+      ]),
+      cwd: path.dirname(root),
+      env: context.env,
+      uid: context.uid,
+      gid: context.gid,
+      rootUri: pathToFileURL(path.dirname(root)).href,
+      languages,
+      newFileSettleMs: 2_000,
+    }),
+    open: async (session, root, timeoutMs) => {
+      const uri = pathToFileURL(root).href;
+      const loaded = session.waitForNotification(timeoutMs, "Projekte geladen",
+        (method) => method === "workspace/projectInitializationComplete");
+      if (root.toLowerCase().endsWith(".csproj")) session.notify("project/open", { projects: [uri] });
+      else session.notify("solution/open", { solution: uri });
+      await loaded;
+      return `${path.basename(root)} geladen`;
+    },
+  }],
+});

package/plugins/ragents.lsp-roslyn/provision.ts

@@ -1,6 +1,5 @@
 import { stat } from "node:fs/promises";
 import path from "node:path";
-import { ROSLYN_SERVER_FILE } from "@ragents/workspace-executor";
 import {
   DOTNET_INSTRUCTION,
   downloadArchive,
@@ -14,6 +13,7 @@ import {
   type PluginProvision,
   type ProvisionState,
 } from "@ragents/host/plugin-support/provision.js";
+import { ROSLYN_SERVER_FILE } from "./executor.js";
 
 export const ROSLYN_VERSION = "5.4.0-2.26179.14";
 

package/plugins/ragents.lsp-roslyn/server/index.ts

@@ -1,15 +1,22 @@
-import { roslynAdapter, ROSLYN_SERVER_VARIABLE } from "@ragents/workspace-executor";
+import path from "node:path";
 import { declaredEnvironment } from "@ragents/host/plugin-support/plugin-config.js";
 import { createLanguageServerPlugin } from "@ragents/host/plugin-support/language-server/plugin.js";
 import type { PluginModule } from "@ragents/host/plugin-support/plugin-module.js";
 import { sandboxServicesToken } from "@ragents/host/plugin-support/workspace-sandbox-host.js";
 import { runtimeProviderToken } from "@ragents/host/ragents/host-services.js";
 import { askServiceToken } from "@ragents/plugins/ragents.ask/server/contract.js";
-import { createSolutionOnStart, SOLUTION_ON_START_VARIABLE, type SolutionOnStart } from "./solution-on-start.js";
+import { roslynLanguageServer, ROSLYN_SERVER_VARIABLE } from "../executor.js";
+import {
+  createSolutionOnStart,
+  SOLUTION_ON_START_VARIABLE,
+  SOLUTION_PREFERRED_VARIABLE,
+  type SolutionOnStart,
+} from "./solution-on-start.js";
 
 export const roslynConfigDescriptors = [
   { key: ROSLYN_SERVER_VARIABLE, source: "environment" },
   { key: SOLUTION_ON_START_VARIABLE, source: "environment" },
+  { key: SOLUTION_PREFERRED_VARIABLE, source: "environment" },
 ] as const;
 
 const PLUGIN_ID = "ragents.lsp-roslyn";
@@ -25,13 +32,26 @@ export const solutionOnStart = (): boolean => {
   return mode === "on";
 };
 
+/** Ein Pfad relativ zur Wurzel des Arbeitsbereichs, wie ihn `roslyn_solutions` nennt; ohne Laden beim Start hätte er keine Wirkung. */
+export const preferredSolution = (loadOnStart: boolean): string | undefined => {
+  const preferred = env.optional(SOLUTION_PREFERRED_VARIABLE);
+  if (preferred === undefined) return undefined;
+  if (!loadOnStart) {
+    throw new Error(`${SOLUTION_PREFERRED_VARIABLE} in der Sektion ragents.lsp-roslyn verlangt ${SOLUTION_ON_START_VARIABLE}: "on"`);
+  }
+  if (preferred === "" || preferred.includes("\\") || path.win32.isAbsolute(preferred)) {
+    throw new Error(`${SOLUTION_PREFERRED_VARIABLE} in der Sektion ragents.lsp-roslyn ist ein Pfad relativ zum Arbeitsbereich mit Schrägstrichen, nicht "${preferred}"`);
+  }
+  return preferred;
+};
+
 export const plugin: PluginModule = {
   requires: ["ragents.ask"],
   create: () => {
     let startup: SolutionOnStart | undefined;
     const languageServer = createLanguageServerPlugin({
       id: PLUGIN_ID,
-      adapter: roslynAdapter,
+      languageServer: roslynLanguageServer,
       configDescriptors: roslynConfigDescriptors,
       onOpened: (runId) => startup?.opened(runId),
     });
@@ -39,10 +59,13 @@ export const plugin: PluginModule = {
       manifest: languageServer.manifest,
       register: (host) => {
         languageServer.register(host);
-        if (!solutionOnStart()) return;
+        const loadOnStart = solutionOnStart();
+        const preferred = preferredSolution(loadOnStart);
+        if (!loadOnStart) return;
         startup = createSolutionOnStart({
           pluginId: PLUGIN_ID,
-          adapterId: roslynAdapter.id,
+          adapterId: roslynLanguageServer.id,
+          preferred,
           sandbox: () => host.service(sandboxServicesToken),
           runtime: () => host.service(runtimeProviderToken)(),
           ask: () => host.service(askServiceToken),

package/plugins/ragents.lsp-roslyn/server/solution-on-start.ts

@@ -8,6 +8,7 @@ import type { SandboxServices } from "@ragents/host/plugin-support/workspace-san
 import { DISMISSED_ANSWER, type AskService } from "@ragents/plugins/ragents.ask/server/contract.js";
 
 export const SOLUTION_ON_START_VARIABLE = "ROSLYN_SOLUTION_ON_START";
+export const SOLUTION_PREFERRED_VARIABLE = "ROSLYN_SOLUTION_PREFERRED";
 export const NO_SOLUTION = "Keine laden";
 export const SOLUTION_QUESTION = "Welche Solution soll Roslyn für die Diagnostik laden?";
 
@@ -21,11 +22,21 @@ export type SolutionAnswer =
   | { kind: "open"; path: string }
   | { kind: "forward" };
 
-/** Was jemand schon geöffnet hat oder gerade öffnet, bleibt ohne Frage und ohne zweites Laden. */
-export const solutionStartStep = (listing: LanguageServerSolutions): SolutionStartStep => {
+/** Die Vorgabe passt auch in einem Unterordner, etwa wenn der Arbeitsbereich der Ordner über dem Checkout ist. */
+const matchesPreferred = (solution: string, preferred: string): boolean => {
+  const path = solution.toLowerCase();
+  const expected = preferred.toLowerCase();
+  return path === expected || path.endsWith(`/${expected}`);
+};
+
+/** Was jemand schon geöffnet hat oder gerade öffnet, bleibt ohne Frage und ohne zweites Laden; passt die Vorgabe, zählen nur die passenden Solutions. */
+export const solutionStartStep = (listing: LanguageServerSolutions, preferred?: string): SolutionStartStep => {
   if (listing.opened || listing.solutions.length === 0) return { kind: "none" };
-  if (listing.solutions.length === 1) return { kind: "open", path: listing.solutions[0].path };
-  return { kind: "ask", options: [...listing.solutions.map((solution) => solution.path), NO_SOLUTION] };
+  const paths = listing.solutions.map((solution) => solution.path);
+  const matching = preferred === undefined ? [] : paths.filter((path) => matchesPreferred(path, preferred));
+  const candidates = matching.length > 0 ? matching : paths;
+  if (candidates.length === 1) return { kind: "open", path: candidates[0] };
+  return { kind: "ask", options: [...candidates, NO_SOLUTION] };
 };
 
 /** Eine frei formulierte Antwort bekommt der Koordinator, damit sie nicht verloren geht. */
@@ -38,6 +49,7 @@ export const solutionAnswer = (options: readonly string[], answer: string): Solu
 export interface SolutionOnStartOptions {
   pluginId: string;
   adapterId: string;
+  preferred?: string;
   sandbox: () => SandboxServices;
   runtime: () => Orchestration;
   ask: () => AskService;
@@ -45,7 +57,7 @@ export interface SolutionOnStartOptions {
 
 const messageOf = (error: unknown): string => error instanceof Error ? error.message : String(error);
 
-/** Lädt beim Start ohne Run-Script die einzige Solution oder fragt bei mehreren; der Merker im Journal lässt das je Run höchstens einmal zu. */
+/** Lädt beim Start ohne Run-Script die Vorgabe oder die einzige Solution oder fragt bei mehreren; der Merker im Journal lässt das je Run höchstens einmal zu. */
 export interface SolutionOnStart {
   lifecycle: SessionLifecycleContribution;
   /** Jemand hat eine Instanz geöffnet; eine noch offene Startfrage erledigt sich damit ohne Laden und ohne Input. */
@@ -78,7 +90,7 @@ export const createSolutionOnStart = (options: SolutionOnStartOptions): Solution
 
   const begin = async (runId: string, ownerId: string, coordinatorId: string, signal: AbortSignal): Promise<{ rest: Promise<void> }> => {
     const listing = await options.sandbox().execute(runId, languageServerSolutionsOperation(options.adapterId), null, { signal }) as LanguageServerSolutions;
-    const step = solutionStartStep(listing);
+    const step = solutionStartStep(listing, options.preferred);
     if (step.kind === "none") return { rest: Promise.resolve() };
     if (step.kind === "open") return { rest: load(runId, step.path, true, signal) };
     const answer = options.ask().ask(

package/plugins/ragents.lsp-typescript/executor.ts

@@ -0,0 +1,50 @@
+import { stat } from "node:fs/promises";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import type { LanguageServerDescription, WorkspaceExecutorContribution } from "@ragents/workspace-executor";
+
+const languages = {
+  ".ts": "typescript",
+  ".tsx": "typescriptreact",
+  ".mts": "typescript",
+  ".cts": "typescript",
+  ".js": "javascript",
+  ".jsx": "javascriptreact",
+} as const;
+
+export const typescriptLanguageServer: LanguageServerDescription = {
+  id: "typescript",
+  label: "TypeScript",
+  languages,
+  rootDescription: "the directory whose tsconfig.json projects should be served (e.g. src)",
+};
+
+const hasWorkspaceTypeScript = (root: string): Promise<boolean> =>
+  stat(path.join(root, "node_modules", "typescript", "lib", "tsserver.js")).then((info) => info.isFile(), () => false);
+
+/** Sprachserver und Compiler liegen in den node_modules des Hosts dieser Maschine; ohne Host gibt es sie hier nicht. */
+export const executor: WorkspaceExecutorContribution = (machine) => ({
+  languageServers: [{
+    ...typescriptLanguageServer,
+    resolveRoot: machine.resolveRootDirectory,
+    rootDirectory: (root) => root,
+    launch: async (context, root) => ({
+      label: "TypeScript",
+      command: process.execPath,
+      args: [machine.hostPackageFile(context.hostRoot, "typescript-language-server/lib/cli.mjs"), "--stdio"],
+      cwd: root,
+      // Im Extension-Host ist process.execPath Electron; ohne diese Variable startet es die Anwendung statt des Skripts.
+      env: { ...context.env, ELECTRON_RUN_AS_NODE: "1" },
+      uid: context.uid,
+      gid: context.gid,
+      rootUri: pathToFileURL(root).href,
+      initializationOptions: await hasWorkspaceTypeScript(root)
+        ? {}
+        : { tsserver: { path: path.dirname(machine.hostPackageFile(context.hostRoot, "typescript")) } },
+      languages,
+      publishesOnlyChangedDiagnostics: true,
+    }),
+    open: async (_session, root) =>
+      `TypeScript-Server auf ${path.basename(root)} bereit; Projekte werden je Datei aus der nächsten tsconfig.json geladen`,
+  }],
+});

package/plugins/ragents.lsp-typescript/server/index.ts

@@ -1,7 +1,7 @@
-import { typescriptAdapter } from "@ragents/workspace-executor";
 import { createLanguageServerPlugin } from "@ragents/host/plugin-support/language-server/plugin.js";
 import type { PluginModule } from "@ragents/host/plugin-support/plugin-module.js";
+import { typescriptLanguageServer } from "../executor.js";
 
 export const plugin: PluginModule = {
-  create: () => createLanguageServerPlugin({ id: "ragents.lsp-typescript", adapter: typescriptAdapter }),
+  create: () => createLanguageServerPlugin({ id: "ragents.lsp-typescript", languageServer: typescriptLanguageServer }),
 };

package/plugins/ragents.model-relay/server/config.ts

@@ -2,7 +2,7 @@ import { configuredModelAliases, type ModelAlias } from "@ragents/host/plugin-su
 
 /** Das Relay bietet die Aliasse des Profils an (MODEL_ALIASES im Abschnitt host), dieselben wie für die eigenen Runs. */
 export const relayAliases = (aliases: readonly ModelAlias[]): readonly ModelAlias[] => {
-  if (aliases.length === 0) throw new Error("ragents.model-relay braucht MODEL_ALIASES im Abschnitt host; erwartet wird eine Liste \"alias=anbieter/modell\"");
+  if (aliases.length === 0) throw new Error("ragents.model-relay needs MODEL_ALIASES in the host section, a list of { alias, model, thinking?, compaction }");
   return aliases;
 };
 

package/plugins/ragents.model-relay/server/relay.ts

@@ -18,6 +18,7 @@ export interface ResolvedAlias {
   readonly alias: string;
   readonly upstream: ModelUpstream;
   readonly model: ModelUpstream["models"][number];
+  readonly compaction: ModelAlias["compaction"];
 }
 
 /** Jeder Alias muss auf einen konfigurierten Anbieter und ein Modell aus dessen Katalog zeigen. */
@@ -30,10 +31,10 @@ export const resolveAliases = (aliases: readonly ModelAlias[], upstreams: readon
     }
     const model = upstream.models.find((candidate) => candidate.id === entry.model);
     if (!model) throw new Error(`MODEL_ALIASES: das Modell ${entry.model} hinter ${entry.alias} fehlt im Katalog von ${entry.upstream}`);
-    return { alias: entry.alias, upstream, model };
+    return { alias: entry.alias, upstream, model, compaction: entry.compaction };
   });
 
-/** Der Katalogeintrag nennt nur, was der Verbraucher für den Draht braucht; Name, Anbieter und Kosten bleiben beim Server. */
+/** Der Katalogeintrag nennt nur, was der Verbraucher für Draht und Kompaktierung braucht; Name, Anbieter und Kosten bleiben beim Server. */
 export const catalogEntryOf = (resolved: ResolvedAlias) => ({
   id: resolved.alias,
   object: "model" as const,
@@ -44,6 +45,7 @@ export const catalogEntryOf = (resolved: ResolvedAlias) => ({
     input: [...resolved.model.input],
     contextWindow: resolved.model.contextWindow,
     maxTokens: resolved.model.maxTokens,
+    compaction: resolved.compaction,
     ...(resolved.model.compat ? { compat: resolved.model.compat } : {}),
   },
 });

package/plugins/ragents.profile-distribution/server/archive.ts

@@ -55,7 +55,8 @@ const checkSections = (source: string, raw: Record<string, unknown>, pluginIds:
       if (isEnvironmentReference(entry) || isProvisionedReference(entry)) continue;
       if (SECRET_KEY_PATTERN.test(key)) throw new Error(`${source}: ${section}.${key} ist ein Secret und muss als env("...") stehen`);
       const valid = typeof entry === "string" || typeof entry === "number" || typeof entry === "boolean"
-        || (Array.isArray(entry) && entry.every((item) => typeof item === "string"));
+        || (Array.isArray(entry) && entry.every((item) => typeof item === "string"))
+        || (Array.isArray(entry) && entry.every((item) => !!item && typeof item === "object" && !Array.isArray(item)));
       if (!valid) throw new Error(`${source}: ${section}.${key} hat keinen gültigen Wert`);
       if (typeof entry === "string" && /^\$\{[A-Za-z_][A-Za-z0-9_]*\}$/.test(entry)) throw new Error(`${source}: ${section}.${key} verweist als Text auf die Umgebung; env("...") verwenden`);
     }

package/plugins/ragents.workspace/client/workspace-client.ts

@@ -2,20 +2,30 @@ import { realpath } from "node:fs/promises";
 import { homedir, tmpdir } from "node:os";
 import { basename, dirname, join, resolve } from "node:path";
 import {
+  EXECUTOR_CONTRIBUTION_FILE,
   WORKSPACE_EXECUTOR_VERSION,
   containsWorkspacePath,
+  hostDataDirectory,
+  loadExecutorContribution,
+  pluginToolsDirectory,
+  prepareExecutorContribution,
+  ripgrepAvailable,
   WorkspaceOperationError,
   WorkspaceOperationExecutor,
   workspaceDataDirectory,
   workspaceExecutorModules,
   workspaceProcessContext,
+  type ExecutorContributionStand,
+  type PreparedExecutorContribution,
   type WorkspaceProcessContext,
 } from "@ragents/workspace-executor";
 import type { RpcClient } from "../../../apps/web/src/rpc/client";
 import type { OperationInput } from "../../../packages/ragents/src/rpc/contract";
 import type { RpcHandlerContext } from "../../../packages/ragents/src/rpc/peer";
+import { RPC_ERROR_CODES, RpcError } from "../../../packages/ragents/src/rpc/protocol";
 import { DomainError } from "../../../packages/ragents/src/runtime/domain-error";
 import {
+  PLUGIN_ID_PATTERN,
   WORKSPACE_CLIENT_STOP_OPERATION,
   workspaceClientContracts,
   workspaceContracts,
@@ -28,7 +38,8 @@ export type WorkspaceClientStatus =
   | { kind: "registered" }
   | { kind: "failed"; message: string };
 
-export interface WorkspaceClientIdentity extends WorkspaceClientDescription {
+/** Was der Arbeitsplatz über sich sagt; ob seine Bash rg findet, ermittelt er selbst bei jeder Anmeldung. */
+export interface WorkspaceClientIdentity extends Omit<WorkspaceClientDescription, "ripgrep"> {
   id: string;
 }
 
@@ -41,10 +52,12 @@ export interface WorkspaceClientExecution {
 }
 
 export interface WorkspaceClientOptions {
-  /** Die Host-Wurzel dieses Rechners, aus der die Sprachserver aufgelöst werden; sie kann erst später entstehen. */
+  /** Die Host-Wurzel dieses Rechners mit den Bundles, aus denen der Executor seine Beiträge lädt; sie kann erst später entstehen. */
   hostRoot: () => string | undefined;
   /** Die Bash dieses Rechners für das Werkzeug bash; unter Windows die mitgebrachte und Pflicht, sonst ohne Angabe die des Systems. */
   bash?: string | undefined;
+  /** Das mitgebrachte rg, dessen Ordner die Bash vorn im PATH hat; ohne Angabe gilt eines im PATH dieses Rechners. */
+  rg?: string | undefined;
   onExecuted?: (execution: WorkspaceClientExecution) => void;
 }
 
@@ -93,9 +106,44 @@ const contextOf = (runs: ReadonlyMap<string, WorkspaceProcessContext>, runId: st
   return Promise.resolve(context);
 };
 
+const sameContributions = (left: readonly ExecutorContributionStand[], right: readonly ExecutorContributionStand[]): boolean =>
+  left.length === right.length && left.every((entry) => right.some((other) => other.plugin === entry.plugin && other.stand === entry.stand));
+
+/** Die Bundles eines Arbeitsplatzes sind die eingebauten seines Hosts; ein Plugin, das dort fehlt, kann er nicht ausführen. */
+const contributionFileOf = (hostRoot: string, plugin: string): string => join(hostRoot, "bundles", plugin, EXECUTOR_CONTRIBUTION_FILE);
+
+/** Lädt die Beiträge, die der Server verlangt, aus den Bundles des Hosts dieser Maschine; ein fehlendes Bundle oder ein anderer Stand ist ein Fehler mit Ursache. */
+const loadedContributions = async (
+  hostRoot: string | undefined,
+  wanted: readonly ExecutorContributionStand[],
+): Promise<readonly PreparedExecutorContribution[]> => {
+  if (wanted.length === 0) return [];
+  if (!hostRoot) {
+    throw new Error(`Der Server verlangt die Executor-Beiträge von ${wanted.map(({ plugin }) => plugin).join(", ")}; dieser Arbeitsplatz `
+      + "kennt keinen Host, aus dessen Bundles er sie laden könnte. Er bekommt ihn mit der ersten Verbindung zu einem verteilenden "
+      + "Server oder über die Einstellung ragents.hostPath");
+  }
+  return Promise.all(wanted.map(async ({ plugin, stand }) => {
+    if (!PLUGIN_ID_PATTERN.test(plugin)) throw new Error(`Der Server nennt ${plugin} als Plugin; das ist keine Kennung eines Plugins`);
+    const loaded = await loadExecutorContribution(plugin, contributionFileOf(hostRoot, plugin), stand).catch((cause: unknown) => {
+      throw new Error(`${messageOf(cause)}. Der Host dieses Arbeitsplatzes (${hostRoot}) muss dieselben Bundles tragen wie der Server: `
+        + "die RAgents-Erweiterung beziehungsweise das Paket @schlenkr/ragents in der Fassung des Servers, im Checkout pnpm build:plugins");
+    });
+    return prepareExecutorContribution(loaded, pluginToolsDirectory(hostDataDirectory(), plugin));
+  }));
+};
+
+/** Ein Executor aus den Beiträgen, die der Server bei der Anmeldung verlangt hat. */
+interface BuiltExecutor {
+  readonly executor: WorkspaceOperationExecutor;
+  readonly contributions: readonly ExecutorContributionStand[];
+}
+
 /** Was eine Anmeldung auf diesem Rechner hält: ihren eigenen Executor, die Aufträge ihrer Runs und ihre Handler an der Nachrichtenschicht. */
 interface Attachment {
-  readonly executor: WorkspaceOperationExecutor;
+  /** Entsteht mit der Antwort des Servers, welche Beiträge er verlangt; verlangt er nach einer Neuverbindung andere, ersetzt ein neuer ihn. */
+  built: BuiltExecutor | undefined;
+  readonly runsDirectory: string;
   readonly runs: Map<string, WorkspaceProcessContext>;
   readonly release: () => void;
 }
@@ -172,7 +220,7 @@ export class WorkspaceClient {
     this.#set({ kind: "idle" });
     const signingOff = Promise.allSettled([this.#signingOff, this.#announcing]).then(() => this.#signOff());
     this.#signingOff = signingOff;
-    await Promise.all([signingOff, attachment?.executor.shutdown()]);
+    await Promise.all([signingOff, attachment?.built?.executor.shutdown()]);
   }
 
   /** Der Arbeitsplatz bindet immer sich selbst; wo der Server läuft, ändert daran nichts. */
@@ -183,19 +231,44 @@ export class WorkspaceClient {
   /** Jede Anmeldung baut ihren eigenen Executor; einer, den eine Abmeldung beendet hat, wird nie wieder benutzt. */
   #attach(): Attachment {
     if (this.#attachment) return this.#attachment;
-    const runs = new Map<string, WorkspaceProcessContext>();
-    const runsDirectory = this.#identity.runsDirectory;
-    const executor = new WorkspaceOperationExecutor({
-      contextFor: (runId) => contextOf(runs, runId),
-      modules: workspaceExecutorModules({ runFolder: (runId) => runFolderOf(runsDirectory, runId) }),
-    });
     const rpc = this.transport.rpc;
-    const releases = [
-      rpc.handle(workspaceClientContracts.execute, (input, context) => this.#execute(executor, runs, input, context)),
+    const releases: Array<() => void> = [];
+    const attachment: Attachment = {
+      built: undefined,
+      runsDirectory: this.#identity.runsDirectory,
+      runs: new Map(),
+      release: () => { for (const release of releases) release(); },
+    };
+    releases.push(
+      rpc.handle(workspaceClientContracts.execute, (input, context) => this.#execute(attachment, input, context)),
       rpc.onConnected(() => void this.#announce()),
-    ];
-    this.#attachment = { executor, runs, release: () => { for (const release of releases) release(); } };
-    return this.#attachment;
+    );
+    this.#attachment = attachment;
+    return attachment;
+  }
+
+  /** Behält den Executor, solange der Server dieselben Beiträge verlangt; sonst baut es einen neuen aus den Bundles dieses Rechners und beendet den alten. */
+  async #built(attachment: Attachment, wanted: readonly ExecutorContributionStand[]): Promise<BuiltExecutor> {
+    const current = attachment.built;
+    if (current && sameContributions(current.contributions, wanted)) return current;
+    const contributions = await loadedContributions(this.options.hostRoot(), wanted);
+    const built: BuiltExecutor = {
+      executor: new WorkspaceOperationExecutor({
+        contextFor: (runId) => contextOf(attachment.runs, runId),
+        modules: workspaceExecutorModules({
+          runFolder: (runId) => runFolderOf(attachment.runsDirectory, runId),
+          contributions: contributions.map((contribution) => contribution.parts),
+        }),
+      }),
+      contributions: contributions.map(({ plugin, stand }) => ({ plugin, stand })),
+    };
+    if (attachment !== this.#attachment) {
+      await built.executor.shutdown();
+      throw new Error("Der Arbeitsplatz hat sich inzwischen abgemeldet");
+    }
+    attachment.built = built;
+    await current?.executor.shutdown();
+    return built;
   }
 
   /** Wartet auf den Ereignisstrom; ohne ihn nimmt der Server die Anmeldung nicht an. */
@@ -219,10 +292,20 @@ export class WorkspaceClient {
     return this.#announcing;
   }
 
-  /** Eine Antwort, die erst nach einer Abmeldung ankommt, ändert den Zustand nicht mehr. */
+  /** Erst die Beiträge, die der Server verlangt, dann die Anmeldung mit dem Executor daraus; eine Antwort nach einer Abmeldung ändert den Zustand nicht mehr. */
   async #send(): Promise<void> {
     const attachment = this.#attachment;
+    if (!attachment) return;
     try {
+      const wanted = await this.transport.rpc.call(workspaceContracts.clients.contributions, {
+        label: this.#identity.label,
+        executor: WORKSPACE_EXECUTOR_VERSION,
+      }, { timeoutMs: REGISTER_TIMEOUT_MS }).catch((cause: unknown) => {
+        if (!(cause instanceof RpcError) || cause.code !== RPC_ERROR_CODES.methodNotFound) throw cause;
+        throw new Error(`Der Server kennt ${workspaceContracts.clients.contributions.id} nicht; er ist älter als dieser Arbeitsplatz `
+          + `mit dem Executor ${WORKSPACE_EXECUTOR_VERSION}. Den Server auf die Fassung des Arbeitsplatzes aktualisieren.`);
+      });
+      const { contributions } = await this.#built(attachment, wanted);
       await this.transport.rpc.call(workspaceContracts.clients.register, {
         id: this.#identity.id,
         label: this.#identity.label,
@@ -230,7 +313,9 @@ export class WorkspaceClient {
         platform: this.#identity.platform,
         folders: [...this.#identity.folders],
         runsDirectory: this.#identity.runsDirectory,
+        ripgrep: ripgrepAvailable(this.options.rg, process.env),
         executor: WORKSPACE_EXECUTOR_VERSION,
+        contributions: contributions.map((contribution) => ({ ...contribution })),
       }, { timeoutMs: REGISTER_TIMEOUT_MS });
       if (attachment === this.#attachment) this.#set({ kind: "registered" });
     } catch (cause) {
@@ -247,17 +332,14 @@ export class WorkspaceClient {
   }
 
   /** Der Entwickler arbeitet auf seinem Arbeitsplatz mit seinen eigenen Zugangsdaten und seiner ganzen Umgebung; HOME bleibt sein Home. */
-  async #execute(
-    executor: WorkspaceOperationExecutor,
-    runs: Map<string, WorkspaceProcessContext>,
-    input: ExecuteInput,
-    context: RpcHandlerContext,
-  ): Promise<{ value: unknown }> {
-    if (input.operation === WORKSPACE_CLIENT_STOP_OPERATION) return this.#stop(executor, runs, input.runId);
+  async #execute(attachment: Attachment, input: ExecuteInput, context: RpcHandlerContext): Promise<{ value: unknown }> {
+    if (input.operation === WORKSPACE_CLIENT_STOP_OPERATION) return this.#stop(attachment, input.runId);
     const cwd = await this.#inside(input.cwd, input.runId);
     const root = await realPathOf(cwd);
-    if (executor !== this.#attachment?.executor) throw new Error("Der Arbeitsplatz hat sich inzwischen abgemeldet");
-    runs.set(input.runId, workspaceProcessContext({
+    if (attachment !== this.#attachment) throw new Error("Der Arbeitsplatz hat sich inzwischen abgemeldet");
+    const executor = attachment.built?.executor;
+    if (!executor) throw new Error("Der Arbeitsplatz ist beim Server noch nicht angemeldet");
+    attachment.runs.set(input.runId, workspaceProcessContext({
       runId: input.runId,
       cwd,
       root,
@@ -267,6 +349,7 @@ export class WorkspaceClient {
       additions: input.env,
       baseEnvironment: "inherited",
       ...(this.options.bash === undefined ? {} : { bash: this.options.bash }),
+      ...(this.options.rg === undefined ? {} : { rg: this.options.rg }),
     }));
     const startedAt = Date.now();
     let failure: string | undefined;
@@ -293,11 +376,11 @@ export class WorkspaceClient {
   }
 
   /** Der Stopp braucht keinen Ordner: er gibt frei, was der Run hält, auch wenn sein Ordner nicht mehr angeboten wird. */
-  async #stop(executor: WorkspaceOperationExecutor, runs: Map<string, WorkspaceProcessContext>, runId: string): Promise<{ value: null }> {
+  async #stop(attachment: Attachment, runId: string): Promise<{ value: null }> {
     try {
-      await executor.stopRun(runId);
+      await attachment.built?.executor.stopRun(runId);
     } finally {
-      runs.delete(runId);
+      attachment.runs.delete(runId);
     }
     return { value: null };
   }

package/plugins/ragents.workspace/contract.ts

@@ -66,6 +66,8 @@ export interface WorkspaceClientDescription {
   folders: string[];
   /** Wo der Arbeitsplatz die neuen Ordner je Run anlegt, je Run ein Unterordner mit dessen Kennung. */
   runsDirectory: string;
+  /** Ob die Bash des Arbeitsplatzes rg findet; der Prompt richtet die Suche danach. */
+  ripgrep: boolean;
 }
 
 export interface WorkspaceClientInfo extends WorkspaceClientDescription {
@@ -95,12 +97,21 @@ const clientId = Type.String({ pattern: "^[A-Za-z0-9_-]{8,64}$", description: "S
 
 const executorVersion = Type.String({ minLength: 1, maxLength: 64, description: "Stand des Executors, den der Arbeitsplatz mitbringt" });
 
+/** Die Kennung eines Plugins; ein Arbeitsplatz sucht dessen Bundle unter genau diesem Namen, ein Pfad kann darin nicht stecken. */
+export const PLUGIN_ID_PATTERN = /^[a-z0-9]+(?:[.-][a-z0-9]+)*$/;
+
+const executorContributions = Type.Array(Type.Object({
+  plugin: Type.String({ pattern: PLUGIN_ID_PATTERN.source, maxLength: 128, description: "Kennung des Plugins" }),
+  stand: Type.String({ pattern: "^[0-9a-f]{64}$", description: "SHA-256 der Datei des Beitrags" }),
+}, { additionalProperties: false }), { maxItems: 64, description: "Die Beiträge der Plugins zum Executor, in der Reihenfolge der Pluginliste des Servers" });
+
 const clientDescription = {
   label: Type.String({ minLength: 1, maxLength: 120 }),
   hostname: Type.String({ minLength: 1 }),
   platform: Type.String({ minLength: 1 }),
   folders: Type.Array(Type.String({ minLength: 1 }), { maxItems: 32 }),
   runsDirectory: Type.String({ minLength: 1, description: "Absoluter Ordner, unter dem der Arbeitsplatz die neuen Ordner je Run anlegt" }),
+  ripgrep: Type.Boolean({ description: "Ob die Bash des Arbeitsplatzes rg findet" }),
 };
 
 export const clientInfoSchema = Type.Object({
@@ -108,6 +119,19 @@ export const clientInfoSchema = Type.Object({
   ...clientDescription,
 }, { additionalProperties: false });
 
+/** Die Anmeldung, wie ein Arbeitsplatz mit dem Executor des Servers sie sendet. */
+export const clientRegistrationSchema = Type.Object({
+  id: clientId,
+  ...clientDescription,
+  executor: executorVersion,
+  contributions: executorContributions,
+}, { additionalProperties: false });
+
+/** Ein Arbeitsplatz mit einem anderen Executor kennt die Form dieses Stands nicht; der Server lehnt ihn an seinem Stand ab, nicht an der Form. */
+const otherExecutorRegistration = Type.Object({ label: clientDescription.label, executor: executorVersion }, {
+  description: "Anmeldung mit einem anderen Executor-Stand in beliebiger Form; der Server lehnt sie mit workspace-executor-version ab",
+});
+
 const absolutePath = Type.String({ minLength: 1, description: "Absoluter Pfad im gebundenen Ordner" });
 
 /** Keine Operation eines Moduls: gibt frei, was der Executor des Arbeitsplatzes für den Run hält. */
@@ -172,11 +196,18 @@ export const workspaceContracts = {
       input: Type.Object({}, { additionalProperties: false }),
       result: Type.Array(clientInfoSchema),
     }),
+    contributions: defineOperation({
+      id: "ragents.workspace.clients.contributions",
+      description: "Die Beiträge der Plugins zum Executor, die ein Arbeitsplatz vor der Anmeldung lädt und mit ihr zurückmeldet. Ein Arbeitsplatz mit anderem Executor-Stand scheitert an seinem Stand; weitere Felder zählen nicht.",
+      rights: ["runs.write"],
+      input: Type.Object({ label: clientDescription.label, executor: executorVersion }),
+      result: executorContributions,
+    }),
     register: defineOperation({
       id: "ragents.workspace.clients.register",
-      description: "Einen Arbeitsplatz anmelden oder seine Ordner erneuern; die Verbindung dieser Anfrage wird sein Rückweg und braucht einen Ereignisstrom.",
+      description: "Einen Arbeitsplatz anmelden oder seine Ordner erneuern; die Verbindung dieser Anfrage wird sein Rückweg und braucht einen Ereignisstrom. Ein Arbeitsplatz mit anderem Executor-Stand scheitert an seinem Stand, bevor die übrige Form zählt.",
       rights: ["runs.write"],
-      input: Type.Object({ id: clientId, ...clientDescription, executor: executorVersion }, { additionalProperties: false }),
+      input: Type.Union([clientRegistrationSchema, otherExecutorRegistration]),
       result: clientInfoSchema,
     }),
     unregister: defineOperation({