@schlenkr/ragents 0.1.7 → 0.1.9

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({

package/plugins/ragents.workspace/server/binding.ts

@@ -2,6 +2,7 @@ import { statSync } from "node:fs";
 import path from "node:path";
 import { Type } from "typebox";
 import { DomainError, type JsonValue, type RunState, type StartOptionContribution } from "@ragents/engine";
+import type { ShellTools } from "@ragents/workspace-executor";
 import { shellPlatformChapter } from "./shell-platform.js";
 import { storedStartOption } from "@ragents/host/ragents/start-option-state.js";
 import type { WorkspaceResolver } from "@ragents/host/ragents/workspace-runtime.js";
@@ -87,13 +88,18 @@ export const serverDirectoryFolder = (directory: string): ExistingWorkspaceFolde
   return { path: resolved };
 };
 
-/** Die Bash eines Runs läuft auf dem Executor seiner Bindung; der Prompt nennt deshalb dessen Plattform, nicht die des Servers. */
-export const executorShellChapter = (registry: WorkspaceClientRegistry, owner: string | null, binding: WorkspaceBinding): string => {
+/** Die Bash eines Runs läuft auf dem Executor seiner Bindung; der Prompt nennt deshalb dessen Plattform und Werkzeuge, nicht die des Servers. */
+export const executorShellChapter = (
+  registry: WorkspaceClientRegistry,
+  owner: string | null,
+  binding: WorkspaceBinding,
+  serverTools: ShellTools,
+): string => {
   const { machine } = binding;
-  if (machine === "server") return shellPlatformChapter(process.platform);
+  if (machine === "server") return shellPlatformChapter(process.platform, serverTools);
   const client = registry.info(owner, machine.client);
   return client
-    ? shellPlatformChapter(client.platform as NodeJS.Platform)
+    ? shellPlatformChapter(client.platform as NodeJS.Platform, { ripgrep: client.ripgrep })
     : `## Shell platform\n\nThe workstation ${machine.label} that holds this project is not registered right now, `
       + "so the platform of its shell is unknown; the workspace tools fail until it connects again.";
 };

package/plugins/ragents.workspace/server/clients.ts

@@ -1,8 +1,10 @@
+import { Value } from "typebox/value";
 import {
   DomainError,
   RPC_ERROR_CODES,
   RpcError,
   implement,
+  schemaComplaints,
   type AccessContext,
   type MethodConnection,
   type MethodContribution,
@@ -10,11 +12,13 @@ import {
 import {
   WORKSPACE_EXECUTOR_VERSION,
   sandboxRunEnvironment,
+  type ExecutorContributionStand,
   type WorkspaceExecuteOptions,
   type WorkspaceExecutor,
 } from "@ragents/workspace-executor";
 import {
   WORKSPACE_CLIENT_STOP_OPERATION,
+  clientRegistrationSchema,
   workspaceClientContracts,
   workspaceContracts,
   type WorkspaceClientDescription,
@@ -75,6 +79,35 @@ const messageOf = (cause: unknown): string => cause instanceof Error ? cause.mes
 /** Ein Arbeitsplatz ist erst durch Besitzer und Kennung bestimmt; zwei Benutzer mit derselben Kennung teilen nichts. */
 const keyOf = (owner: string | null, id: string): string => JSON.stringify([owner, id]);
 
+/** Server und Arbeitsplatz brauchen denselben Executor; die Meldung sagt, wer von beiden zu alt ist. */
+const assertExecutor = (label: string, executor: string): void => {
+  if (executor === WORKSPACE_EXECUTOR_VERSION) return;
+  const action = Number(executor) > Number(WORKSPACE_EXECUTOR_VERSION)
+    ? "Den Server auf die Fassung des Arbeitsplatzes aktualisieren."
+    : "Die RAgents-Erweiterung in VS Code beziehungsweise das Paket @schlenkr/ragents auf dem Arbeitsplatz aktualisieren.";
+  throw new DomainError(
+    "workspace-executor-version",
+    `Der Arbeitsplatz ${label} bringt den Executor ${executor} mit, der Server verlangt ${WORKSPACE_EXECUTOR_VERSION}. ${action}`,
+    409,
+  );
+};
+
+const described = (contributions: readonly ExecutorContributionStand[]): string =>
+  contributions.map(({ plugin, stand }) => `${plugin} (${stand.slice(0, 12)})`).join(", ") || "keine";
+
+/** Ein Arbeitsplatz führt aus, was die Plugins des Servers beitragen; mit anderen Beiträgen liefen dieselben Werkzeuge dort anders als auf dem Server. */
+const assertContributions = (label: string, expected: readonly ExecutorContributionStand[], given: readonly ExecutorContributionStand[]): void => {
+  const key = (entry: ExecutorContributionStand): string => `${entry.plugin}\0${entry.stand}`;
+  const same = expected.length === given.length && expected.every((entry) => given.some((other) => key(other) === key(entry)));
+  if (same) return;
+  throw new DomainError(
+    "workspace-executor-contributions",
+    `Der Arbeitsplatz ${label} bringt die Executor-Beiträge ${described(given)} mit, der Server verlangt ${described(expected)}. `
+      + "Der Arbeitsplatz fragt sie mit ragents.workspace.clients.contributions ab und meldet sich danach erneut an.",
+    409,
+  );
+};
+
 /** Über das Netz nimmt der Server Arbeitsplätze nur von angemeldeten Benutzern an; ohne Benutzer gäbe es nur einen Besitzer für alle Zugänge. */
 export const assertMayRegister = (access: AccessContext, local: boolean): void => {
   if (local || (access.enabled && access.user !== null)) return;
@@ -88,27 +121,29 @@ export const assertMayRegister = (access: AccessContext, local: boolean): void =
 
 /** Kennt die angemeldeten Arbeitsplätze je Besitzer, hält je Client die Verbindung, über die der Server ihn zurückruft, und die Stopps, die ihn nicht erreicht haben. */
 export class WorkspaceClientRegistry {
+  /** Was die Plugins des Servers zum Executor beitragen; jeder Arbeitsplatz muss genau diese Beiträge tragen. */
+  readonly contributions: readonly ExecutorContributionStand[];
   readonly #clients = new Map<string, ClientEntry>();
   /** Stopps, die den Arbeitsplatz noch nicht erreicht haben, je Arbeitsplatz und Run mit dem Ordner der Bindung. */
   readonly #pendingStops = new Map<string, Map<string, string>>();
   readonly #stopRetries = new Map<string, NodeJS.Timeout>();
 
+  constructor(contributions: readonly ExecutorContributionStand[]) {
+    this.contributions = contributions.map(({ plugin, stand }) => ({ plugin, stand }));
+  }
+
   async register(
     id: string,
     description: WorkspaceClientDescription,
     executor: string,
+    contributions: readonly ExecutorContributionStand[],
     connection: MethodConnection,
   ): Promise<WorkspaceClientInfo> {
     if (connection.streamless) {
       throw new DomainError("stream-required", "Die Anmeldung eines Arbeitsplatzes braucht einen Ereignisstrom.", 409);
     }
-    if (executor !== WORKSPACE_EXECUTOR_VERSION) {
-      throw new DomainError(
-        "workspace-executor-version",
-        `Der Arbeitsplatz ${description.label} bringt den Executor ${executor} mit, der Server verlangt ${WORKSPACE_EXECUTOR_VERSION}.`,
-        409,
-      );
-    }
+    assertExecutor(description.label, executor);
+    assertContributions(description.label, this.contributions, contributions);
     const owner = connection.userId;
     const key = keyOf(owner, id);
     const previous = this.#clients.get(key);
@@ -318,9 +353,21 @@ export class WorkspaceClientRegistry {
 
 export const clientMethods = (registry: WorkspaceClientRegistry): MethodContribution[] => [
   implement(workspaceContracts.clients.list, (_input, { access }) => registry.list(ownerOf(access))),
-  implement(workspaceContracts.clients.register, ({ id, executor, ...description }, { access, connection, local }) => {
+  implement(workspaceContracts.clients.contributions, ({ label, executor }, { access, local }) => {
     assertMayRegister(access, local);
-    return registry.register(id, description, executor, connection);
+    assertExecutor(label, executor);
+    return registry.contributions.map((entry) => ({ ...entry }));
+  }),
+  implement(workspaceContracts.clients.register, (input, { access, connection, local }) => {
+    assertMayRegister(access, local);
+    // Erst der Stand: ein Arbeitsplatz mit einem anderen kennt die Form dieses Stands nicht, mit diesem gilt sie ganz.
+    assertExecutor(input.label, input.executor);
+    if (!Value.Check(clientRegistrationSchema, input)) {
+      throw new RpcError(RPC_ERROR_CODES.invalidParams,
+        `Ungültige Eingabe für ${workspaceContracts.clients.register.id}: ${schemaComplaints(clientRegistrationSchema, input, "params")}`);
+    }
+    const { id, executor, contributions, ...description } = input;
+    return registry.register(id, description, executor, contributions, connection);
   }),
   implement(workspaceContracts.clients.unregister, ({ id }, { access, connection }) => {
     registry.unregister(ownerOf(access), id, connection);

package/plugins/ragents.workspace/server/config.ts

@@ -5,6 +5,8 @@ export const workspaceConfigDescriptors = [
   { key: "PROCESS_SANDBOX", source: "environment" },
   { key: "PROCESS_SANDBOX_NETWORK", source: "environment" },
   { key: "RAGENTS_BASH", source: "environment" },
+  { key: "RAGENTS_RG", source: "environment" },
+  { key: "RAGENTS_BASH_TIMEOUT_SECONDS", source: "environment" },
 ] as const;
 
 const env = declaredEnvironment(workspaceConfigDescriptors);
@@ -28,3 +30,10 @@ export const processSandboxSetting = (): ProcessSandboxSetting => {
 
 /** Die Bash, mit der der Executor dieses Servers das Werkzeug bash startet; unter Windows setzt sie die VS-Code-Erweiterung für ihren lokalen Host. */
 export const bashSetting = (): string | undefined => env.optional("RAGENTS_BASH") || undefined;
+
+/** Das rg, das der Executor dieses Servers vorn in den PATH der Bash setzt; die VS-Code-Erweiterung setzt es für ihren lokalen Host. */
+export const rgSetting = (): string | undefined => env.optional("RAGENTS_RG") || undefined;
+
+/** Die Zeitgrenze von bash in Sekunden für Aufrufe ohne eigene; mehr als die größte, die ein Aufruf nennen darf, lehnt das Werkzeug beim Start ab. */
+export const bashTimeoutSetting = (): number | undefined =>
+  env.optional("RAGENTS_BASH_TIMEOUT_SECONDS") ? env.positiveNumber("RAGENTS_BASH_TIMEOUT_SECONDS", "") : undefined;

package/plugins/ragents.workspace/server/index.ts

@@ -4,6 +4,7 @@ import { documentStoreToken } from "@ragents/host/ragents/document-store.js";
 import { workspaceResolverToken, workspaceRuntimeToken, type WorkspaceResolver } from "@ragents/host/ragents/workspace-runtime.js";
 import { sandboxServicesToken } from "@ragents/host/plugin-support/workspace-sandbox-host.js";
 import {
+  executorContributionsToken,
   hostAddressToken,
   runtimeProviderToken,
   runGuardToken,
@@ -12,6 +13,7 @@ import {
 } from "@ragents/host/ragents/host-services.js";
 import { pluginAsset } from "@ragents/host/plugin-support/plugin-folder.js";
 import { ServerProcessSandbox } from "@ragents/host/plugin-support/process-sandbox.js";
+import { ripgrepAvailable } from "@ragents/workspace-executor";
 import type { PluginModule } from "@ragents/host/plugin-support/plugin-module.js";
 import { boundToTools, handlebarsPrompt } from "@ragents/host/plugin-support/prompt.js";
 import { shellPlatformPrompt } from "./shell-platform.js";
@@ -21,7 +23,7 @@ import { WORKSPACE_BINDING_OPTION_ID, WORKSPACE_METADATA_ID } from "../contract.
 import { bindingOf, executorShellChapter, sessionMetadataOf, workspaceBindingOption, workspaceLocation, workspaceOwnerOf } from "./binding.js";
 import { createBrowseChannel, createBrowseMethods } from "./browse-route.js";
 import { clientMethods, WorkspaceClientRegistry } from "./clients.js";
-import { bashSetting, processSandboxSetting, workspaceConfigDescriptors } from "./config.js";
+import { bashSetting, bashTimeoutSetting, processSandboxSetting, rgSetting, workspaceConfigDescriptors } from "./config.js";
 import { RunWorkspaceRuntime } from "./runtime.js";
 
 const warnWithoutSandbox = (): void => {
@@ -48,7 +50,8 @@ const ragentsWorkspacePlugin = (skillPaths: () => Promise<readonly string[]>): R
       if (!directory) throw new Error("In diesem Profil gibt es keine Dateiablage; das Plugin ragents.documents fehlt");
       return directory;
     };
-    const clients = new WorkspaceClientRegistry();
+    const contributions = host.service(executorContributionsToken);
+    const clients = new WorkspaceClientRegistry(contributions);
     const contribution = (): WorkspaceResolver | undefined => host.optionalService(workspaceResolverToken);
     host.config(...workspaceConfigDescriptors);
     const sandboxSetting = processSandboxSetting();
@@ -60,10 +63,16 @@ const ragentsWorkspacePlugin = (skillPaths: () => Promise<readonly string[]>): R
       })
       : undefined;
     const bash = bashSetting();
+    const rg = rgSetting();
+    const bashTimeoutSeconds = bashTimeoutSetting();
+    const serverTools = { ripgrep: ripgrepAvailable(rg, process.env) };
     const runtime = new RunWorkspaceRuntime({
       clients,
+      contributions: contributions.map((contribution) => contribution.parts),
       ...(processSandbox ? { processSandbox } : {}),
       ...(bash === undefined ? {} : { bash }),
+      ...(rg === undefined ? {} : { rg }),
+      ...(bashTimeoutSeconds === undefined ? {} : { bashTimeoutSeconds }),
       globalDirectory: host.storage.root(),
       sessionDirectory: (runId, ...segments) => host.storage.session(runId, ...segments),
       storageRootFor: (runId) => path.join(host.storage.sessionsRoot, runId),
@@ -92,9 +101,9 @@ const ragentsWorkspacePlugin = (skillPaths: () => Promise<readonly string[]>): R
         // Die Regeln gelten für die Arbeitsbereiche des Hosts; eine beigesteuerte Art beschreibt ihre eigenen.
         render: (context) => contribution()?.kind ? "" : rules.render(context),
       }, ...agentWorkspaceToolNames),
-      shellPlatformPrompt("ragents.workspace.shell.prompt", 102, (runId) => {
+      shellPlatformPrompt("ragents.workspace.shell.prompt", 102, serverTools, (runId) => {
         const state = runState(runId);
-        return executorShellChapter(clients, workspaceOwnerOf(state), bindingOf(state));
+        return executorShellChapter(clients, workspaceOwnerOf(state), bindingOf(state), serverTools);
       }),
     );
     const browseOptions = {

package/plugins/ragents.workspace/server/runtime.ts

@@ -8,6 +8,7 @@ import {
   type SandboxHomeEnvironment,
   type WorkspaceExecuteOptions,
   type WorkspaceExecutor,
+  type WorkspaceExecutorParts,
 } from "@ragents/workspace-executor";
 import type {
   SessionWorkspace,
@@ -46,10 +47,16 @@ export interface RunWorkspaceRuntimeOptions {
   runState: (runId: string) => RunState | null;
   storeBinding: (runId: string, binding: WorkspaceBinding) => void;
   clients: WorkspaceClientRegistry;
+  /** Was die Plugins des Profils zum Executor des Servers beitragen; die Arbeitsplätze laden dieselben Beiträge selbst. */
+  contributions: readonly WorkspaceExecutorParts[];
   /** Die Prozess-Sandbox des Servers; ohne sie laufen die Prozesse des Servers ohne. */
   processSandbox?: RunProcessSandboxes;
   /** Die Bash des Servers aus RAGENTS_BASH; unter Windows Pflicht für das Werkzeug bash. */
   bash?: string;
+  /** Das rg des Servers aus RAGENTS_RG; ohne Angabe gilt eines im PATH. */
+  rg?: string;
+  /** Die Zeitgrenze von bash aus RAGENTS_BASH_TIMEOUT_SECONDS; ohne Angabe die des Werkzeugs. */
+  bashTimeoutSeconds?: number;
 }
 
 const runNotStarted = (): DomainError => new DomainError(
@@ -141,6 +148,7 @@ export class RunWorkspaceRuntime implements WorkspaceRuntime {
     this.#nugetCacheDirectory = path.join(options.globalDirectory, "nuget-cache");
     this.sandbox = new WorkspaceSandboxHost({
       contributorName: "ragents.workspace.sandbox",
+      contributions: options.contributions,
       workspaceFor: options.sessionWorkspaceFor,
       identFor: () => Promise.resolve(undefined),
       skillPaths: options.skillPaths,
@@ -150,6 +158,8 @@ export class RunWorkspaceRuntime implements WorkspaceRuntime {
       serverDirectoryFor: (runId) => this.#serverDirectoryFor(runId),
       ...(options.processSandbox ? { processSandbox: options.processSandbox } : {}),
       ...(options.bash === undefined ? {} : { bash: options.bash }),
+      ...(options.rg === undefined ? {} : { rg: options.rg }),
+      ...(options.bashTimeoutSeconds === undefined ? {} : { bashTimeoutSeconds: options.bashTimeoutSeconds }),
     });
   }
 

package/plugins/ragents.workspace/server/shell-platform.ts

@@ -1,19 +1,20 @@
 import type { PromptContribution } from "@ragents/engine";
-import { shellPlatformText } from "@ragents/workspace-executor";
+import { shellPlatformText, type ShellTools } from "@ragents/workspace-executor";
 import { boundToTools } from "@ragents/host/plugin-support/prompt.js";
 
-export const shellPlatformChapter = (platform: NodeJS.Platform): string =>
-  `## Shell platform\n\n${shellPlatformText(platform)}`;
+export const shellPlatformChapter = (platform: NodeJS.Platform, tools: ShellTools): string =>
+  `## Shell platform\n\n${shellPlatformText(platform, tools)}`;
 
-/** Ohne Angabe gilt die Plattform des Servers; `chapterFor` nennt die des Executors, der den Run ausführt. */
+/** Ohne Angabe gelten Plattform und Werkzeuge des Servers; `chapterFor` nennt die des Executors, der den Run ausführt. */
 export const shellPlatformPrompt = (
   id: string,
   order: number,
+  serverTools: ShellTools,
   chapterFor?: (runId: string) => string,
 ): PromptContribution => boundToTools({
   id,
   order,
   delivery: "initial",
-  render: () => shellPlatformChapter(process.platform),
+  render: () => shellPlatformChapter(process.platform, serverTools),
   ...(chapterFor ? { renderForRun: chapterFor } : {}),
 }, "bash");

package/plugins/ragents.workspace/web/WorkspaceBinding.tsx

@@ -42,7 +42,7 @@ const isClientInfo = (value: unknown): value is WorkspaceClientInfo => {
     && typeof raw.id === "string" && typeof raw.label === "string"
     && typeof raw.hostname === "string" && typeof raw.platform === "string"
     && Array.isArray(raw.folders) && raw.folders.every((folder) => typeof folder === "string")
-    && typeof raw.runsDirectory === "string";
+    && typeof raw.runsDirectory === "string" && typeof raw.ripgrep === "boolean";
 };
 
 const isFreshLabels = (value: unknown): value is FreshWorkspaceLabels => {

package/ragents.config.core.ts

@@ -6,7 +6,10 @@ export const config = {
     PRODUCT_PROFILE: "core",
     COMPACTION_MODEL: "google/gemma-4-26b-a4b-it",
     // Aliasse für andere RAgents-Server, die ihre Modelle über ragents.model-relay von hier beziehen.
-    MODEL_ALIASES: ["core-standard=openrouter/z-ai/glm-5.3-flash", "core-coordinator=openrouter/deepseek/deepseek-v4-flash-0731"],
+    MODEL_ALIASES: [
+      { alias: "core-standard", model: "openrouter/z-ai/glm-5.3-flash", compaction: { threshold: 160_000, keepRecentTokens: 24_000, summaryTokens: 12_000 } },
+      { alias: "core-coordinator", model: "openrouter/deepseek/deepseek-v4-flash-0731", compaction: { threshold: 300_000, keepRecentTokens: 40_000, summaryTokens: 16_000 } },
+    ],
     PRODUCT_ID: "ragents",
     PRODUCT_TITLE: "RAgents",
     PLUGINS: [