@schlenkr/ragents 0.1.8 → 0.1.10

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.orchestration/web/ActorTile.tsx

@@ -12,7 +12,7 @@ export function ActorTile({ actor, view, cardSections, chatInput, session, navig
   navigation: SessionNavigation;
   onSelect: (selection: EntityReference) => void;
 }) {
-  return <div className="flex flex-col overflow-hidden has-[>[data-slot=card-sections]:not(:empty)]:min-h-[260px]">
+  return <div className="flex flex-col overflow-hidden has-[>[data-slot=card-sections]:not(:empty)]:min-h-[260px] has-[[data-chat=actions]:not(:empty)]:min-h-[260px]">
     <ActorChatPreview actor={actor} view={view} chatInput={chatInput} running={actor.lifecycle?.kind === "running"}
       conversation={session.actorConversations?.[actor.id]} historyError={session.conversationError}
       onNavigate={onSelect} primaryMessages={actor.id === view.primaryActorId ? session.messages : undefined} />

package/plugins/ragents.orchestration/web/run-panel/RunPanel.tsx

@@ -1,4 +1,4 @@
-import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState, type KeyboardEvent, type MouseEvent, type PointerEvent, type ReactNode, type RefObject } from "react";
+import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState, type CSSProperties, type KeyboardEvent, type MouseEvent, type PointerEvent, type ReactNode, type RefObject } from "react";
 import { createPortal } from "react-dom";
 import { ArrowUpRightIcon, LayoutGridIcon, Maximize2Icon, MessageSquareIcon, PanelBottomIcon, PanelRightIcon } from "lucide-react";
 import { useAccess } from "@ragents/web/AccessContext";
@@ -181,7 +181,7 @@ function RunPanel({ surfaceElements, cardSections, navigation, renderChat, sessi
       />}
       <section
         aria-label="Chat"
-        className={cn(chatLayoutClass[layout], layout === "floating" && "[&:not([data-expanded])_[data-slot=card-sections]]:hidden [&[data-sheet-resizing]_[data-slot=card-sections]]:hidden")}
+        className={cn(chatLayoutClass[layout], layout === "floating" && "[&_[data-chat=composer]]:[--qsl-panel-height:var(--sheet-available-height)] [&:not([data-expanded])_[data-slot=card-sections]]:hidden [&[data-sheet-resizing]_[data-slot=card-sections]]:hidden")}
         data-expanded={layout === "floating" && sheet.expanded ? true : undefined}
         data-sheet-resizing={resize.height !== undefined || undefined}
         data-view={primarySelected ? "chat" : "actor-chat"}
@@ -190,7 +190,7 @@ function RunPanel({ surfaceElements, cardSections, navigation, renderChat, sessi
         onPointerEnter={layout === "floating" ? (event) => { if (event.pointerType === "mouse") sheet.openLater(); } : undefined}
         onPointerLeave={layout === "floating" ? () => sheet.closeLater(settings.closeDelay) : undefined}
         ref={sheetRef}
-        style={layout === "floating" ? { height: resize.height ?? (sheet.expanded ? expandedHeight : geometry.minimum), transition: resize.height !== undefined ? "none" : undefined } : undefined}
+        style={layout === "floating" ? { height: resize.height ?? (sheet.expanded ? expandedHeight : geometry.minimum), transition: resize.height !== undefined ? "none" : undefined, "--sheet-available-height": `${geometry.available}px` } as CSSProperties : undefined}
       >
         {layout === "floating" && <button
           aria-expanded={sheet.expanded}
@@ -307,9 +307,9 @@ function useSheet(active: boolean, sheetRef: RefObject<HTMLElement | null>, grab
   return { expanded, held, open, openLater, closeLater, close, toggle, pauseResize, finishResize };
 }
 
-/** Die Höhe des zugeschobenen Sheets: Griff, Statuszeile und Eingabe, gemessen an der Eingabe des Chat-Rahmens. */
+/** Die Höhe des zugeschobenen Sheets: Griff, Statuszeile und Eingabe samt offener Aktionen darüber, gemessen an der Eingabe des Chat-Rahmens. */
 function useSheetPeek(active: boolean, sheetRef: RefObject<HTMLElement | null>, grabRef: RefObject<HTMLButtonElement | null>, statusRef: RefObject<HTMLButtonElement | null>, actorId: string | undefined) {
-  const [geometry, setGeometry] = useState({ minimum: 0, maximum: 0, scale: 1 });
+  const [geometry, setGeometry] = useState({ minimum: 0, maximum: 0, available: 0, scale: 1 });
   useLayoutEffect(() => {
     if (!active) return;
     const sheet = sheetRef.current;
@@ -325,8 +325,9 @@ function useSheetPeek(active: boolean, sheetRef: RefObject<HTMLElement | null>,
       const scale = width / Number.parseFloat(style.width);
       const minimum = Math.ceil((grab.getBoundingClientRect().height + (status?.getBoundingClientRect().height ?? 0)
         + composer.getBoundingClientRect().height) / scale + Number.parseFloat(style.borderTopWidth) + Number.parseFloat(style.borderBottomWidth));
-      const maximum = Math.max(minimum, Math.floor(container.getBoundingClientRect().height / scale * 0.9));
-      setGeometry((previous) => previous.minimum === minimum && previous.maximum === maximum && previous.scale === scale ? previous : { minimum, maximum, scale });
+      const available = Math.floor(container.getBoundingClientRect().height / scale * 0.9);
+      const maximum = Math.max(minimum, available);
+      setGeometry((previous) => previous.minimum === minimum && previous.maximum === maximum && previous.available === available && previous.scale === scale ? previous : { minimum, maximum, available, scale });
     };
     const observer = new ResizeObserver(measure);
     observer.observe(composer);

package/plugins/ragents.orchestration/web/run-panel/sheet-status.ts

@@ -1,6 +1,6 @@
 import type { Message } from "quassel/events";
 
-/** Die eine Zeile des zugeschobenen Sheets: was der Chat gerade tut oder zuletzt gesagt hat. */
+/** Die eine Zeile des zugeschobenen Sheets: was der Chat gerade tut oder zuletzt gesagt hat; offene Aktionen selbst stehen im Dock darunter. */
 export interface SheetStatus {
   text: string;
   kind: "idle" | "working" | "waiting";
@@ -16,8 +16,8 @@ const senderOf = (message: Message, handle: string): string =>
 
 export function sheetStatus(messages: readonly Message[], working: boolean, handle: string): SheetStatus {
   const last = messages[messages.length - 1];
-  const waiting = [...messages].reverse().find((message) => message.role === "action" && message.action?.status === undefined);
-  if (waiting) return { kind: "waiting", text: `Wartet auf Eingabe: ${firstLine(waiting.text) || "Antwort erwartet"}` };
+  const waiting = messages.filter((message) => message.role === "action" && message.action?.status === undefined).length;
+  if (waiting > 0) return { kind: "waiting", text: waiting === 1 ? "Wartet auf Eingabe" : `Wartet auf ${waiting} Eingaben` };
   if (working) {
     if (last?.role === "thinking" && !last.closed) return { kind: "working", text: `@${handle} denkt ...` };
     if (last?.role === "tool" && last.tool && last.tool.result === undefined) return { kind: "working", text: `@${handle} nutzt ${last.tool.name} ...` };

package/plugins/ragents.overseer/server/api.ts

@@ -3,7 +3,7 @@ import type { Static } from "typebox";
 import { DomainError, implement, type AccessContext, type JsonValue, type MethodContribution, type PluginHost } from "@ragents/engine";
 import { methodReference, openRpcDocument, type ApiAuthentication } from "@ragents/host/api/reference.js";
 import type { RunManagement } from "@ragents/host/ragents/global-chat.js";
-import { overseerContracts } from "../contract.js";
+import { OVERSEER_PLUGIN_ID, overseerContracts } from "../contract.js";
 import { coordinatorRunIdOf } from "./coordinator.js";
 import type { RunDirectory } from "./run-directory.js";
 
@@ -36,7 +36,7 @@ const create = async (context: ManagementContext, body: CreateInput, access: Acc
   const runId = await (async () => {
     if ("packageDirectory" in body) {
       if (!path.isAbsolute(body.packageDirectory)) throw new DomainError("invalid-package-directory", "packageDirectory muss ein absoluter Serverpfad sein", 400);
-      return context.management().create({ ...common, kind: "package", directory: body.packageDirectory, input: (body.input ?? null) as JsonValue });
+      return context.management().create({ ...common, kind: "package", directory: body.packageDirectory, input: (body.input ?? null) as JsonValue, owner: OVERSEER_PLUGIN_ID });
     }
     if ("script" in body) {
       const entries = context.root.startEntries.describe().filter((entry) => entry.action === "script");

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,
@@ -23,12 +33,14 @@ import {
   type WorkspaceClientDescription,
 } from "../contract";
 
+/** mismatch: Arbeitsplatz und Server tragen einen anderen Stand von Executor oder Bundles; nur ein Update einer Seite behebt es. */
 export type WorkspaceClientStatus =
   | { kind: "idle" }
   | { kind: "registered" }
-  | { kind: "failed"; message: string };
+  | { kind: "failed"; message: string; mismatch: boolean };
 
-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 +53,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;
 }
 
@@ -63,6 +77,18 @@ const SIGN_OFF_TIMEOUT_MS = 3_000;
 
 const messageOf = (cause: unknown): string => cause instanceof Error ? cause.message : String(cause);
 
+/** Ein Stand dieses Arbeitsplatzes, der nicht zu dem des Servers passt. */
+class StandMismatch extends Error {}
+
+const STAND_REFUSALS = ["workspace-executor-version", "workspace-executor-contributions"];
+
+/** Nach dem Fachcode statt nach der Klasse: RpcError kann in einem Prozess zweimal geladen sein. */
+const isStandMismatch = (cause: unknown): boolean => {
+  if (cause instanceof StandMismatch) return true;
+  const code = typeof cause === "object" && cause !== null ? (cause as { domainCode?: unknown }).domainCode : undefined;
+  return typeof code === "string" && STAND_REFUSALS.includes(code);
+};
+
 /** Der echte Pfad des nächsten vorhandenen Elternordners, um die noch fehlenden Namen ergänzt. */
 const realPathOf = async (target: string): Promise<string> => {
   try {
@@ -93,9 +119,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 StandMismatch(`${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;
 }
@@ -148,7 +209,7 @@ export class WorkspaceClient {
     try {
       await this.#connected();
     } catch (cause) {
-      if (attachment === this.#attachment) this.#set({ kind: "failed", message: messageOf(cause) });
+      if (attachment === this.#attachment) this.#set({ kind: "failed", message: messageOf(cause), mismatch: false });
       return;
     }
     if (attachment === this.#attachment) await this.#announce();
@@ -172,7 +233,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 +244,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 +305,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 StandMismatch(`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,11 +326,13 @@ 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) {
-      if (attachment === this.#attachment) this.#set({ kind: "failed", message: messageOf(cause) });
+      if (attachment === this.#attachment) this.#set({ kind: "failed", message: messageOf(cause), mismatch: isStandMismatch(cause) });
     }
   }
 
@@ -242,22 +340,19 @@ export class WorkspaceClient {
     try {
       await this.transport.rpc.call(workspaceContracts.clients.unregister, { id: this.id }, { timeoutMs: SIGN_OFF_TIMEOUT_MS });
     } catch (cause) {
-      this.#set({ kind: "failed", message: messageOf(cause) });
+      this.#set({ kind: "failed", message: messageOf(cause), mismatch: false });
     }
   }
 
   /** 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 +362,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 +389,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({